数据字典

vue-fastapi-backend/module_admin/controller/datastd_controller.py

@@ -6,7 +6,7 @@ from config.get_db import get_db
 from module_admin.entity.vo.user_vo import CurrentUserModel
 from module_admin.annotation.log_annotation import Log
 from module_admin.aspect.interface_auth import CheckUserInterfaceAuth
-from module_admin.entity.vo.datastd_vo import DataStdCodeModel, DataStdCodePageQueryModel, DeleteDataStdModel
+from module_admin.entity.vo.datastd_vo import DataStdCodeModel, DataStdCodePageQueryModel, DeleteDataStdModel,DataStdDictModel,DataStdDictPageQueryModel
 from module_admin.service.datastd_service import DataStdService
 from module_admin.service.login_service import LoginService
 from utils.log_util import logger
@@ -138,6 +138,72 @@ async def edit_std_code_with_items(
 
 
 
+    # ----------------------------------------------------------------数据字典----------------------------------------------------------------------------------------------------
+
+
+@datastdController.get(
+    '/stddict/dict/list', response_model=PageResponseModel, dependencies=[Depends(CheckUserInterfaceAuth('datastd:stddict:dict:list'))]
+)
+async def get_std_dict_list(
+    request: Request,
+    dict_page_query: DataStdDictPageQueryModel = Depends(DataStdDictPageQueryModel.as_query),
+    query_db: AsyncSession = Depends(get_db),
+):
+    dict_page_query_result = await DataStdService.get_std_dict_list_services(query_db, dict_page_query, is_page=True)
+    logger.info('获取列配置列表成功')
+    return ResponseUtil.success(model_content=dict_page_query_result)
+@datastdController.get(
+    '/stddict/dict/{id}', response_model=DataStdDictModel, dependencies=[Depends(CheckUserInterfaceAuth('datastd:stddict:dict:list'))]
+)
+async def query_detail_dict(request: Request, id: str, query_db: AsyncSession = Depends(get_db)):
+    config_detail_result = await DataStdService.dict_detail_services(query_db, id)
+    logger.info(f'获取config_id为{id}的信息成功')
+
+    return ResponseUtil.success(data=config_detail_result)
+@datastdController.post('/stddict/dict', dependencies=[Depends(CheckUserInterfaceAuth('datastd:stddict:dict:add'))])
+@Log(title='代码管理', business_type=BusinessType.INSERT)
+async def add_std_dict(
+    request: Request,
+    add_std_dict: DataStdDictModel,
+    query_db: AsyncSession = Depends(get_db),
+    current_user: CurrentUserModel = Depends(LoginService.get_current_user),
+):
+    
+    add_std_dict.create_by = current_user.user.user_name
+    add_std_dict.create_time = datetime.now()
+    add_std_dict.update_by = current_user.user.user_name
+    add_std_dict.update_time = datetime.now()
+    add_std_dict_result = await DataStdService.add_std_dict_services(request, query_db, add_std_dict)
+    logger.info(add_std_dict_result.message)
+    return ResponseUtil.success(msg=add_std_dict_result.message)
+
+
+@datastdController.put('/stddict/dict', dependencies=[Depends(CheckUserInterfaceAuth('datastd:stddict:dict:edit'))])
+@Log(title='代码管理', business_type=BusinessType.UPDATE)
+async def edit_std_dict(
+    request: Request,
+    edit_std_dict: DataStdDictModel,
+    query_db: AsyncSession = Depends(get_db),
+    current_user: CurrentUserModel = Depends(LoginService.get_current_user),
+):
+    edit_std_dict.update_by = current_user.user.user_name
+    edit_std_dict.update_time = datetime.now()
+    edit_std_dict_result = await DataStdService.edit_std_dict_services(request, query_db, edit_std_dict)
+    logger.info(edit_std_dict_result.message)
+    return ResponseUtil.success(msg=edit_std_dict_result.message)
+
+
+@datastdController.delete('/stddict/dict/{ids}', dependencies=[Depends(CheckUserInterfaceAuth('datastd:stddict:dict:remove'))])
+@Log(title='代码管理', business_type=BusinessType.DELETE)
+async def delete_std_dict(
+    request: Request,
+    ids: str,
+    query_db: AsyncSession = Depends(get_db),
+):
+    delete_std_dict = DeleteDataStdModel(ids =ids)
+    delete_std_dict_result = await DataStdService.delete_std_dict_services(request, query_db, delete_std_dict)
+    logger.info(delete_std_dict_result.message)
+    return ResponseUtil.success(msg=delete_std_dict_result.message)
 
 
 

vue-fastapi-backend/module_admin/dao/datastd_dao.py

@@ -1,15 +1,14 @@
 from sqlalchemy import delete, select, update, desc,or_
 from sqlalchemy.ext.asyncio import AsyncSession
-from module_admin.entity.do.datastd_do import DataStdCode
-from module_admin.entity.vo.datastd_vo import DataStdCodeModel
+from module_admin.entity.do.datastd_do import DataStdCode,DataStdDict
+from module_admin.entity.vo.datastd_vo import DataStdCodeModel,DataStdDictModel
 from utils.page_util import PageUtil
 from sqlalchemy.orm import aliased
 
 
 class DataStdDao:
-    """
-    数据标准模块
-    """
+
+    # ----------------------------------------------------------------数据标准模块----------------------------------------------------------------------------------------------------
 
     @classmethod
     async def get_std_code_list(cls, db: AsyncSession, query_object: DataStdCodeModel, is_page: bool = False):
@@ -172,8 +171,89 @@ class DataStdDao:
 
         # 如果不存在，则检查代码项表中是否存在相同的code_num
         if not existing_code:
-            result = await query_db.execute(select(DataStdCodeModel).filter(DataStdCodeModel.code_num == code_num))
+            result = await query_db.execute(select(DataStdCode).filter(DataStdCodeModel.code_num == code_num))
             existing_code_item = result.scalar_one_or_none()
             return existing_code_item is not None
 
-        return True
+        return True
+    # ----------------------------------------------------------------数据字典----------------------------------------------------------------------------------------------------
+    @classmethod
+    async def get_std_dict_list(cls, db: AsyncSession, query_object: DataStdDictModel, is_page: bool = False):
+        """
+        获取 DataStdDict 的列表信息，支持模糊查询和分页
+        :param db: ORM对象
+        :param query_object: 查询参数对象
+        :param is_page: 是否开启分页
+        :return: 列表信息
+        """
+        # 构建查询条件
+        filters = []
+        if query_object.dict_name:
+            filters.append(DataStdDict.dict_name.like(f"%{query_object.dict_name}%"))
+        if query_object.dict_code:
+            filters.append(DataStdDict.dict_code.like(f"%{query_object.dict_code}%"))
+        if query_object.dict_level:
+            filters.append(DataStdDict.dict_level == query_object.dict_level)
+        if query_object.sys_id:
+            filters.append(DataStdDict.sys_id == query_object.sys_id)
+        if query_object.dict_type:
+            filters.append(DataStdDict.dict_type == query_object.dict_type)
+        if query_object.dict_status:
+            filters.append(DataStdDict.dict_status == query_object.dict_status)
+
+        # 构建查询语句
+        query = (
+            select(DataStdDict)
+            .where(*filters)
+            .order_by(desc(DataStdDict.create_time))  # 按创建时间降序排序
+        )
+
+        # 分页处理
+        col_list = await PageUtil.paginate(
+            db, query, query_object.page_num, query_object.page_size, is_page
+        )
+
+        return col_list   
+    @classmethod
+    async def add_std_dict(cls, db: AsyncSession,model:DataStdDictModel):
+        col = DataStdDict(
+           **model.model_dump()
+        )
+        db.add(col)
+        await db.flush()
+        return col
+
+    @classmethod
+    async def delete_std_dict(cls, db: AsyncSession, Id: str):
+        await db.execute(delete(DataStdDict).where(DataStdDict.id == Id))
+
+    @classmethod
+    async def update_std_dict(cls, db: AsyncSession, update_data: DataStdDictModel):
+    
+        await db.execute(update(DataStdDict), [update_data])
+        await db.flush()    
+
+    @classmethod
+    async def get_std_dict_by_id(cls, db: AsyncSession, Id: str):
+        col = (
+            await db.execute(
+                select(DataStdDict)
+                .where(DataStdDict.id == Id)
+            )
+        ).scalars().first()
+        return col    
+    @classmethod
+    async def get_data_dict_by_info(cls, db: AsyncSession, query_object: DataStdDictModel):
+        List = (
+            await db.execute(
+                select(DataStdDict)
+                .where(
+                        DataStdDict.dict_name == query_object.dict_name if query_object.dict_name else True,
+                        DataStdDict.dict_num == query_object.dict_num if query_object.dict_num else True,
+                        DataStdDict.dict_status == query_object.dict_status if query_object.dict_status else True,
+                        DataStdDict.sys_id == query_object.sys_id if query_object.sys_id else True,
+                        DataStdDict.dict_type == query_object.dict_type if query_object.dict_type else True,
+                )
+            )
+        ).scalars().first()
+        return List

vue-fastapi-backend/module_admin/entity/do/datastd_do.py

@@ -1,4 +1,4 @@
-from sqlalchemy import Column, Integer, String, DateTime, Boolean
+from sqlalchemy import Column, Integer, String, DateTime, Boolean,BigInteger
 from config.database import Base
 
 # 数据标准模块相关表
@@ -25,3 +25,32 @@ class DataStdCode(Base):
     code_map_id = Column(String(50), default=None,comment='标准代码Id')
     code_map_num = Column(String(50), default=None, comment='标准代码编号')
     code_map_name = Column(String(200), default=None, comment='标准代码值')
+
+
+class DataStdDict(Base):
+    """
+    标准字典表 (Standard Code Table)
+    """
+    __tablename__ = 't_datastd_dict'  # 表名为 t_datastd_dict
+    
+    id = Column(String(50), primary_key=True, comment='标准代码Id')
+    create_by = Column(String(20), default='', comment='创建者')
+    create_time = Column(DateTime, nullable=True, default=None, comment='创建时间')
+    update_by = Column(String(20), default='', comment='更新者')
+    update_time = Column(DateTime, nullable=True, default=None, comment='更新时间')
+    dict_num = Column(String(50), default=None, comment='字典编号')
+    dict_code = Column(String(50), default=None, comment='字典英文名')
+    dict_name = Column(String(200), default=None, comment='字典中文名')
+    dict_level = Column(String(10), default=None, comment='字典归属（sys：系统级 company：公司级）')
+    dict_type = Column(String(1), default=None, comment='字典类型（0：基础数据 1：指标数据）')
+    sys_name = Column(String(50), default=None, comment='归属系统')
+    sys_id = Column(Integer, default=None, comment='归属系统Id')
+    dict_menu = Column(String(200), default=None, comment='字典业务定义')
+    data_type = Column(String(20), default=None, comment='数据类型')
+    std_code = Column(String(50), default=None, comment='数据标准编号')
+    std_name = Column(String(50), default=None, comment='数据标准名称')
+    dict_status = Column(String(1), default=None, comment='字典状态（1：有效 0：无效）')
+    buss_dept_id = Column(BigInteger, default=None, comment='业务认责部门')
+    tech_dept_id = Column(BigInteger, default=None, comment='技术认责部门')
+    buss_user = Column(String(20), default=None, comment='业务认责人员')
+    tech_user = Column(String(20), default=None, comment='技术认责人员')

vue-fastapi-backend/module_admin/entity/vo/datastd_vo.py

@@ -53,3 +53,37 @@ class DeleteDataStdModel(BaseModel):
     model_config = ConfigDict(alias_generator=to_camel)
     ids: str = Field(description='需要删除的参数主键')
 
+class DataStdDictModel(BaseModel):
+    """
+    标准字典表对应Pydantic模型 (Standard Dictionary Table Pydantic Model)
+    """
+    model_config = ConfigDict(alias_generator=to_camel, from_attributes=True)
+    
+    id: Optional[str] = Field(default=None, description='标准字典主键')
+    create_by: Optional[str] = Field(default='', description='创建者')
+    create_time: Optional[datetime] = Field(default=None, description='创建时间')
+    update_by: Optional[str] = Field(default='', description='更新者')
+    update_time: Optional[datetime] = Field(default=None, description='更新时间')
+    dict_num: Optional[str] = Field(default=None, description='字典编号')
+    dict_code: Optional[str] = Field(default=None, description='字典英文名')
+    dict_name: Optional[str] = Field(default=None, description='字典中文名')
+    dict_level: Optional[str] = Field(default=None, description='字典归属（sys：系统级 company：公司级）')
+    dict_type: Optional[str] = Field(default=None, description='字典类型（0：基础数据 1：指标数据）')
+    sys_name: Optional[str] = Field(default=None, description='归属系统')
+    sys_id: Optional[int] = Field(default=None, description='归属系统Id')
+    dict_menu: Optional[str] = Field(default=None, description='字典业务定义')
+    data_type: Optional[str] = Field(default=None, description='数据类型')
+    std_code: Optional[str] = Field(default=None, description='数据标准编号')
+    std_name: Optional[str] = Field(default=None, description='数据标准名称')
+    dict_status: Optional[str] = Field(default=None, description='字典状态（1：有效 0：无效）')
+    buss_dept_id: Optional[int] = Field(default=None, description='业务认责部门')
+    tech_dept_id: Optional[int] = Field(default=None, description='技术认责部门')
+    buss_user: Optional[str] = Field(default=None, description='业务认责人员')
+    tech_user: Optional[str] = Field(default=None, description='技术认责人员')
+@as_query
+class DataStdDictPageQueryModel(DataStdDictModel):
+    """
+    元数据任务分页查询模型
+    """
+    page_num: int = Field(default=1, description='当前页码')
+    page_size: int = Field(default=10, description='每页记录数')

vue-fastapi-backend/module_admin/service/datastd_service.py

@@ -3,7 +3,7 @@ from sqlalchemy.ext.asyncio import AsyncSession
 from exceptions.exception import ServiceException
 from module_admin.dao.datastd_dao import DataStdDao
 from module_admin.entity.vo.common_vo import CrudResponseModel
-from module_admin.entity.vo.datastd_vo import DataStdCodeModel,DeleteDataStdModel
+from module_admin.entity.vo.datastd_vo import DataStdCodeModel,DeleteDataStdModel,DataStdDictModel
 from utils.common_util import CamelCaseUtil
 import uuid
 from config.constant import CommonConstant
@@ -246,4 +246,149 @@ class DataStdService:
         )
         if dict_type and dict_type.id != id:
             return CommonConstant.NOT_UNIQUE
-        return CommonConstant.UNIQUE        
+        return CommonConstant.UNIQUE        
+    # ----------------------------------------------------------------数据字典----------------------------------------------------------------------------------------------------
+
+    @classmethod
+    async def get_std_dict_list_services(
+        cls, query_db: AsyncSession, query_object: DataStdDictModel, is_page: bool = False
+    ):
+        """
+        获取列配置列表信息service
+
+        :param query_db: orm对象
+        :param query_object: 查询参数对象
+        :param is_page: 是否开启分页
+        :return: 列配置列表信息对象
+        """
+        col_list_result = await DataStdDao.get_std_dict_list(query_db, query_object, is_page)
+        return col_list_result
+
+  
+    @classmethod
+    async def get_std_dict_by_id_services(cls, query_db: AsyncSession, id: str):
+        """
+        获取列配置详细信息service
+
+        :param query_db: orm对象
+        :param id: 列配置ID
+        :return: 列配置详细信息对象
+        """
+        col = await DataStdDao.get_std_dict_by_id(query_db, id)
+        if col:
+            result = DataStdDictModel(**CamelCaseUtil.transform_result(col))
+        else:
+            result = DataStdDictModel(**dict())
+        return result
+
+  
+    @classmethod
+    async def add_std_dict_services(cls, request: Request, query_db: AsyncSession, page_object: DataStdDictModel):
+        """
+        新增列配置服务
+
+        :param request: Request对象
+        :param query_db: orm对象
+        :param page_object: 新增的列配置对象
+        :return: 新增列配置校验结果
+        """
+        try:
+            if not await cls.check_dict_unique_services(query_db, page_object):
+                raise ServiceException(message=f"数据字典{page_object.dict_num}已存在")
+            # 创建新的 page_object 实例，避免修改原始对象
+            new_page_object = DataStdDictModel(**page_object.model_dump(by_alias=True))
+            new_page_object.dict_status="0"
+            new_page_object.id=str(uuid.uuid4())
+            # 调用 DAO 方法插入数据
+            await DataStdDao.add_std_dict(query_db, new_page_object)
+            return CrudResponseModel(is_success=True, message='新增数据字典成功')
+        except Exception as e:
+            await query_db.rollback()
+            raise e
+ 
+
+    @classmethod
+    async def dict_detail_services(cls, query_db: AsyncSession, col: str):
+        """
+        获取参数配置详细信息service
+
+        :param query_db: orm对象
+        :param config_id: 参数配置id
+        :return: 参数配置id对应的信息
+        """
+        config = await DataStdDao.get_std_dict_by_id(query_db, col)
+        if config:
+            result = DataStdDictModel(**CamelCaseUtil.transform_result(config))
+        else:
+            result = DataStdDictModel(**dict())
+
+        return result
+    @classmethod
+    async def edit_std_dict_services(cls, request: Request, query_db: AsyncSession, page_object: DataStdDictModel):
+        """
+        编辑列配置服务
+
+        :param request: Request对象
+        :param query_db: orm对象
+        :param page_object: 编辑的列配置对象
+        :return: 编辑列配置校验结果
+        """
+        if not await cls.check_dict_unique_services(query_db, page_object):
+                raise ServiceException(message=f"数据字典编号：{page_object.dict_num}已存在")
+        edit_col = page_object.model_dump(exclude_unset=True)
+        col_info = await cls.get_std_dict_by_id_services(query_db, page_object.id)
+        if col_info:
+            try:
+                await DataStdDao.update_std_dict(query_db, edit_col)
+                return CrudResponseModel(is_success=True, message='编辑数据字典成功')
+            except Exception as e:
+                await query_db.rollback()
+                raise e
+        else:
+            raise ServiceException(message=f'数据字典{page_object.id}不存在')
+
+ 
+    @classmethod
+    async def delete_std_dict_services(cls, request: Request, query_db: AsyncSession, page_object: DeleteDataStdModel):
+        """
+        删除列配置服务
+        :param request: Request对象
+        :param query_db: orm对象
+        :param page_object: 删除列配置对象
+        :return: 删除列配置校验结果
+        """
+        if page_object.ids:
+            col_id_list = page_object.ids.split(',')
+            try:
+                for col_id in col_id_list:
+                    col_info = await cls.get_std_dict_by_id_services(query_db, col_id)
+                    if col_info:
+                        # 校验不能删除的系统内置列
+                        await DataStdDao.delete_std_dict(query_db, col_id)
+                await query_db.commit()
+
+
+                return CrudResponseModel(is_success=True, message='删除数据字典成功')
+            except Exception as e:
+                await query_db.rollback()
+                raise e
+        else:
+            raise ServiceException(message='传入数据字典ID为空')
+    @classmethod
+    async def check_dict_unique_services(cls, query_db: AsyncSession, page_object: DataStdDictModel):
+        """
+        校验字典类型称是否唯一service
+
+        :param query_db: orm对象
+        :param page_object: 字典类型对象
+        :return: 校验结果
+        """
+        id ='-1' if page_object.id is None else page_object.id
+        codemodel=DataStdDictModel()
+        codemodel.dict_num=page_object.dict_num
+
+        dict_type = await DataStdDao.get_data_dict_by_info(query_db, codemodel
+        )
+        if dict_type and dict_type.id != id:
+            return CommonConstant.NOT_UNIQUE
+        return CommonConstant.UNIQUE       

vue-fastapi-frontend/src/api/datastd/stdcode.js → vue-fastapi-frontend/src/api/datastd/std.js

@@ -116,6 +116,62 @@ export function deleteStdCodeItems(rowIds) {
   })
 }
 
+// ------------------------------------------------------------数据词典-----------------------------------------------------------------
+export function listStdDict(query) {
+  return request({
+    url: '/default-api/datastd/stddict/dict/list',
+    method: 'get',
+    params: query
+  })
+}
+
+
+
+// 查询标准代码详情
+export function getStdDict(colId) {
+  return request({
+    url: '/default-api/datastd/stddict/dict/' + parseStrEmpty(colId),
+    method: 'get'
+  })
+}
+
+
+// 新增标准代码
+export function addStdDict(data) {
+  return request({
+    url: '/default-api/datastd/stddict/dict',
+    method: 'post',
+    data: data
+  })
+}
+
 
 
+// 修改标准代码
+export function updateStdDict(data) {
+  return request({
+    url: '/default-api/datastd/stddict/dict',
+    method: 'put',
+    data: data
+  })
+}
+
+
+// 删除标准代码
+export function deleteStdDict(colId) {
+  return request({
+    url: '/default-api/datastd/stddict/dict/' + colId,
+    method: 'delete'
+  })
+}
+
+
+
+// 批量删除标准代码
+export function deleteStdDicts(colIds) {
+  return request({
+    url: '/default-api/datastd/stddict/dict/' + colIds,
+    method: 'delete'
+  })
+}
 

vue-fastapi-frontend/src/views/datastd/stdcode/codeItem.vue

@@ -197,7 +197,7 @@
 
 <script setup>
 import { ref, reactive, onMounted, toRefs } from 'vue';
-import { listStdCode,listStdCodeCompany,addStdCode,updateStdCode } from "@/api/datastd/stdcode"; // 更新为新的接口
+import { listStdCode,listStdCodeCompany,addStdCode,updateStdCode } from "@/api/datastd/std"; // 更新为新的接口
 import codeItemCommon from './codeItemCommon.vue'; // 引入第二个页面组件
 
 const { proxy } = getCurrentInstance();
@@ -309,7 +309,6 @@ const getList = async () => {
 const getcompanyList = async () => {
   const response = await listStdCodeCompany();
   companyist.value = response.rows;
-  console.log(companyist.value,"companyCodeList")
 };
 const formRules = reactive({
   codeNum: [{ required: true, message: "请输入标准代码编号", trigger: "blur" }],

vue-fastapi-frontend/src/views/datastd/stdcode/codeItemCommon.vue

@@ -75,7 +75,7 @@
 
 <script setup>
 import { ref, reactive, onMounted, toRefs } from 'vue';
-import { listStdCode,getStdCode} from "@/api/datastd/stdcode"; // 更新为新的接口
+import { listStdCode,getStdCode} from "@/api/datastd/std"; // 更新为新的接口
 
 const { proxy } = getCurrentInstance();
 const { std_code_status } = proxy.useDict("std_code_status");

vue-fastapi-frontend/src/views/datastd/stdcode/codeMap.vue

@@ -121,7 +121,7 @@
 
 <script setup>
 import { ref, reactive, onMounted, toRefs } from 'vue';
-import { listStdCodemap,getStdCode} from "@/api/datastd/stdcode"; // 更新为新的接口
+import { listStdCodemap,getStdCode} from "@/api/datastd/std"; // 更新为新的接口
 
 const { proxy } = getCurrentInstance();
 const { std_code_status } = proxy.useDict("std_code_status");

vue-fastapi-frontend/src/views/datastd/stdcode/index.vue

@@ -169,7 +169,7 @@
 
 <script setup>
 import { ref, reactive, onMounted, toRefs } from 'vue';
-import { listStdCode, addStdCode, getStdCode, updateStdCode, deleteStdCode } from "@/api/datastd/stdcode"; // 更新为新的接口
+import { listStdCode, addStdCode, getStdCode, updateStdCode, deleteStdCode } from "@/api/datastd/std"; // 更新为新的接口
 import { datasourcetree } from "@/api/meta/metatask";
 import { ElLink } from 'element-plus';
 import CodeItem from './codeItem.vue'; // 引入第二个页面组件
@@ -250,13 +250,11 @@ const codeMapId = ref(null);
 // 点击代码名称，弹出第二个对话框并传递数据
 const handleCodeClick = (row) => {
   codeMapId.value=row.id
-  console.log(codeMapId.value,"ddddddd")
   codeVisible.value = true;
 
 };
 const handleMapCodeClick = (row) => {
   codeMapId.value=row.id
-  console.log(codeMapId.value,"ddddddd2222")
   mapVisible.value = true;
 
 };

vue-fastapi-frontend/src/views/datastd/stddict/AddEditForm.vue

@@ -0,0 +1,209 @@
+<template>
+  <el-dialog width="500px" append-to-body :title="isEdit ? '修改数据字典' : '新增数据字典'" v-model="visible" @close="handleClose">
+    <el-form :model="formData" ref="formRef" label-width="120px" :rules="formRules">
+      <el-form-item label="字典归属" prop="dictLevel">
+        <el-select
+              v-model="formData.dictLevel"
+              placeholder="请选择字典归属"
+              maxlength="30"
+              @change="changeCodeType"
+            >
+              <el-option
+                v-for="dict in std_code_status"
+                :key="dict.value"
+                :label="dict.label"
+                :value="dict.value"
+              ></el-option>
+            </el-select>
+        </el-form-item>
+        <el-form-item label="来源系统" prop="sysId" v-show="showSys">
+        <el-select
+              v-model="formData.sysId"
+              placeholder="请选择来源系统"
+              maxlength="30"
+              @change="dataChange"
+            >
+              <el-option
+                v-for="dict in dbResourceOldList"
+                :key="dict.id"
+                :label="dict.name"
+                :value="dict.id"
+              ></el-option>
+            </el-select>  
+        </el-form-item>
+        <el-form-item label="数据字典类型" prop="dictType">
+        <el-select v-model="formData.dictType" placeholder="请选择数据字典类型">
+          <el-option label="基础数据" value="0" />
+          <el-option label="指标数据" value="1" />
+        </el-select>    
+        </el-form-item>
+      <el-form-item label="数据字典编号" prop="dictNum">
+        <el-input v-model="formData.dictNum" :disabled=isEdit placeholder="请输入数据字典编号" clearable />
+      </el-form-item>
+      <el-form-item label="字典英文名" prop="dictCode">
+        <el-input v-model="formData.dictCode" placeholder="请输入字典英文名" clearable />
+      </el-form-item>
+      <el-form-item label="字典中文名" prop="dictName">
+        <el-input v-model="formData.dictName" placeholder="请输入字典中文名" clearable />
+      </el-form-item>
+      <el-form-item label="字典业务定义" prop="dictMenu">
+        <el-input v-model="formData.dictMenu" placeholder="请输入字典中文名" clearable />
+      </el-form-item>
+      <el-form-item label="数据类型" prop="dataType">
+        <el-input v-model="formData.dataType" placeholder="请输入字典中文名" clearable />
+      </el-form-item>
+      <el-form-item label="数据标准" prop="stdCode">
+        <el-input v-model="formData.stdCode" placeholder="请输入字典中文名" clearable />
+      </el-form-item>
+      <el-form-item label="业务认责部门" prop="bussDeptId">
+                     <el-tree-select
+                        v-model="formData.bussDeptId"
+                        :data="deptOptions"
+                        :props="{ value: 'id', label: 'label', children: 'children' }"
+                        value-key="id"
+                        placeholder="请选择业务认责部门"
+                        check-strictly />
+     </el-form-item>
+     <el-form-item label="业务认责人员" prop="bussUser">
+        <el-select v-model="formData.bussUser" placeholder="请选择业务认责人员">
+          <el-option
+                v-for="dict in userList"
+                :key="dict.id"
+                :label="dict.userName"
+                :value="dict.userName"
+              ></el-option>
+        </el-select>    
+        </el-form-item>
+     <el-form-item label="技术认责部门" prop="techDeptId">
+                     <el-tree-select
+                        v-model="formData.techDeptId"
+                        :data="deptOptions"
+                        :props="{ value: 'id', label: 'label', children: 'children' }"
+                        value-key="id"
+                        placeholder="请选择技术认责部门"
+                        check-strictly />
+     </el-form-item>
+     <el-form-item label="技术认责人员" prop="techUser">
+        <el-select v-model="formData.techUser" placeholder="技术认责人员">
+          <el-option
+                v-for="dict in userList"
+                :key="dict.id"
+                :label="dict.userName"
+                :value="dict.userName"
+              ></el-option>
+        </el-select>    
+        </el-form-item>
+
+         <!-- 底部按钮区域 -->
+         <el-row justify="center" style="margin-top: 20px;">
+        <el-col :span="4" style="padding-right: 10px;">
+          <el-button @click="handleClose" style="width: 100%" plain>取消</el-button>
+        </el-col>
+        <el-col :span="4" style="padding-left: 10px;">
+          <el-button type="primary" @click="handleSubmit" style="width: 100%">保存</el-button>
+        </el-col>
+      </el-row>
+  
+
+    </el-form>
+  </el-dialog>
+</template>
+
+<script setup>
+import { ref, watch } from 'vue';
+import { updateStdDict, addStdDict } from '@/api/datastd/std'; // 确保接口存在
+import {  listUser,  deptTreeSelect } from "@/api/system/user";
+const { proxy } = getCurrentInstance();
+const { std_code_status,std_code_appr } = proxy.useDict("std_code_status","std_code_appr");
+
+const props = defineProps({
+  data: {
+    type: Object,
+    required: false,
+  },
+  isEdit: {
+    type: Boolean,
+  },
+  dbResourceOldList: {
+    type: Object,
+  },
+  visible: {
+    type: Boolean,
+  },
+});
+// 定义表单校验规则
+const formRules = ref({
+  dictLevel: [{ required: true, message: '请选择字典归属', trigger: 'blur' }],
+  dictType: [{ required: true, message: '请选择数据字典类型', trigger: 'blur' }],
+  dictNum: [{ required: true, message: '请输入数据字典编号', trigger: 'blur' }]
+});
+const showSys = ref(false);
+const emit = defineEmits(['update:visible', 'refresh']);
+const userList = ref([]);
+const formData = ref({ ...props.data });
+const visible = ref(props.visible);  // 使用 prop 传入的 visible
+function dataChange(data) {
+  // 从 dbResourceOldList 中查找对应的 name
+  const selectedItem = props.dbResourceOldList.find(item => item.id === data);
+  if (selectedItem) {
+    // 如果找到对应的项，将 name 赋值给 formData.value.dbRName
+    formData.value.sysName = selectedItem.name;
+  } else {
+    // 如果未找到，清空 formData.value.dbRName
+    formData.value.sysName = '';
+  }
+}
+// 监听 props.visible 的变化，确保同步到 local visible
+watch(() => props.visible, (newVal) => {
+  visible.value = newVal;
+  formData.value = { ...props.data }
+});
+
+function getList() {
+  listUser({pageSize:1,pageNumber:1000}).then(res => {
+    userList.value = res.rows;
+  });
+};
+const handleClose = () => {
+  emit('update:visible', false);  // 关闭弹框
+};
+const deptOptions = ref(undefined);
+
+function getDeptTree() {
+  deptTreeSelect().then(response => {
+    deptOptions.value = response.data;
+  });
+};
+function changeCodeType(data) {
+  if (data != "company") {
+    showSys.value = true;
+    formData.value.sysName = "";
+    formData.value.sysId = undefined;
+  } else {
+    showSys.value = false;
+    formData.value.sysName = "公司级";
+    formData.value.sysId = 10000;
+  }
+}
+getDeptTree();
+getList();
+const handleSubmit = () => {
+  const formRef = proxy.$refs.formRef;
+  formRef.validate((valid) => {
+    if (valid) {
+      const apiCall = props.isEdit ? updateStdDict(formData.value) : addStdDict(formData.value);
+      apiCall
+        .then(() => {
+          emit('refresh');
+          handleClose();
+        })
+        .catch((error) => {
+          console.error(error);
+        });
+    } else {
+      console.log('表单验证失败');
+      return false;
+    }
+  });
+};
+</script>

vue-fastapi-frontend/src/views/datastd/stddict/codeItem.vue

@@ -0,0 +1,446 @@
+<template>
+  <el-form :model="form" ref="formRef" label-width="120px" :rules="formRules">
+    <div class="form-container">
+      <el-row :gutter="20">
+        <!-- 标准代码编号 -->
+        <el-col :span="8">
+          <el-form-item label="标准代码编号" prop="codeNum">
+            <el-input v-model="form.codeNum" placeholder="请输入标准代码编号" />
+          </el-form-item>
+        </el-col>
+
+        <!-- 标准代码名称 -->
+        <el-col :span="8">
+          <el-form-item label="标准代码名称" prop="codeName">
+            <el-input v-model="form.codeName" placeholder="请输入标准代码名称" />
+          </el-form-item>
+        </el-col>
+      </el-row>
+
+      <el-row :gutter="20">
+        <!-- 标准代码类型 -->
+        <el-col :span="8">
+          <el-form-item label="标准代码类型" prop="codeType">
+            <el-select
+              v-model="form.codeType"
+              placeholder="请选择标准代码类型"
+              maxlength="30"
+              @change="changeCodeType"
+            >
+              <el-option
+                v-for="dict in std_code_status"
+                :key="dict.value"
+                :label="dict.label"
+                :value="dict.value"
+              ></el-option>
+            </el-select>
+          </el-form-item>
+        </el-col>
+
+        <!-- 归属系统 -->
+        <el-col :span="8" v-show="showSys">
+          <el-form-item label="归属系统" prop="sysId">
+            <el-select
+              v-model="form.sysId"
+              placeholder="请选择归属系统"
+              maxlength="30"
+              @change="dataChange"
+            >
+              <el-option
+                v-for="dict in dbResourceOldList"
+                :key="dict.id"
+                :label="dict.name"
+                :value="dict.id"
+              ></el-option>
+            </el-select>
+          </el-form-item>
+        </el-col>
+        <!-- 代码映射 -->
+        <el-col :span="8" v-show="showSys">
+          <el-form-item label="代码映射" prop="codeMapId">
+            <el-select
+              v-model="form.codeMapId"
+              placeholder="请选择代码映射"
+              maxlength="30"
+              @change="mapChange"
+            >
+              <el-option
+                v-for="dict in companyist"
+                :key="dict.id"
+                :label="dict.codeName"
+                :value="dict.id"
+              ></el-option>
+            </el-select>
+          </el-form-item>
+        </el-col>
+      </el-row>
+    </div>
+
+    <!-- 查询表单 -->
+    <!-- <div class="query-form-container">
+      <el-form :model="queryParams" ref="queryRef" :inline="true">
+        <el-form-item label="代码值/名称" prop="codeNum">
+          <el-input
+            v-model="queryParams.codeNum"
+            placeholder="请输入标准代码编号"
+            clearable
+            style="width: 220px"
+          />
+        </el-form-item>
+
+        <el-form-item>
+          <el-button type="primary" @click="handleQuery">搜索</el-button>
+          <el-button icon="Refresh" @click="resetQuery">重置</el-button>
+        </el-form-item>
+      </el-form>
+    </div> -->
+  </el-form>
+
+  <!-- 操作按钮 -->
+  <el-row :gutter="10" class="mb8">
+    <el-col :span="1.5">
+      <el-button
+        type="primary"
+        plain
+        icon="Plus"
+        @click="handleAdd"
+        v-hasPermi="['meta:metaSecurityCol:add']"
+      >新增</el-button>
+    </el-col>
+
+    <el-col :span="1.5">
+      <el-button
+        type="danger"
+        plain
+        icon="Delete"
+        :disabled="multiple"
+        @click="handleRemove"
+        v-hasPermi="['meta:metaSecurityCol:remove']"
+      >删除</el-button>
+    </el-col>
+  </el-row>
+
+  <!-- 表格展示 -->
+  <el-table
+    v-loading="loading"
+    :data="tableData"
+    @selection-change="handleSelectionChange"
+    @row-dblclick="handleRowDblClick"
+    border
+    style="width: 100%"
+  >
+    <el-table-column type="selection" width="55" align="center" />
+    <el-table-column
+      label="代码值"
+      align="center"
+      prop="codeNum"
+      :editable="true"
+    >
+      <template #default="scope">
+        <el-input
+          v-if="scope.row.isEditing"
+          v-model="scope.row.codeNum"
+          size="small"
+          placeholder="请输入代码值"
+          @blur="handleBlur(scope.row)"
+        />
+        <span v-else>{{ scope.row.codeNum }}</span>
+      </template>
+    </el-table-column>
+
+    <el-table-column
+      label="代码含义"
+      align="center"
+      prop="codeName"
+      :editable="true"
+    >
+      <template #default="scope">
+        <el-input
+          v-if="scope.row.isEditing"
+          v-model="scope.row.codeName"
+          size="small"
+          placeholder="请输入代码含义"
+          @blur="handleBlur(scope.row)"
+        />
+        <span v-else>{{ scope.row.codeName }}</span>
+      </template>
+    </el-table-column>
+
+    <el-table-column
+      label="代码映射"
+      align="center"
+      prop="代码映射"
+
+    >
+      <template #default="scope">
+        <el-link
+          type="primary"
+          :underline="true"
+          @click="handleCodeClick(scope.row, scope.$index)"
+          style="cursor: pointer"
+        >
+        <span v-if="!scope.row.codeMapName">代码映射</span>
+        <span v-else>{{ scope.row.codeMapName }}</span>        
+        </el-link>
+      </template>
+    </el-table-column>
+  </el-table>
+  <el-dialog  title="代码映射" v-model="mapVisible" width="1000px">
+      <!-- 引入第二个页面组件 -->
+      <code-item-common  ref="showCodeDialog" v-if="mapVisible" :codeId="form.codeMapId"/>
+      <template #footer>
+        <el-button @click="handleCancel2">取消</el-button>
+        <el-button type="primary" @click="handleSave2">确定</el-button>
+      </template>
+    </el-dialog>
+</template>
+
+<script setup>
+import { ref, reactive, onMounted, toRefs } from 'vue';
+import { listStdCode,listStdCodeCompany,addStdCode,updateStdCode } from "@/api/datastd/stdcode"; // 更新为新的接口
+import codeItemCommon from './codeItemCommon.vue'; // 引入第二个页面组件
+
+const { proxy } = getCurrentInstance();
+const { std_code_status } = proxy.useDict("std_code_status");
+
+const props = defineProps({
+  rowData: {
+    type: Object,
+    required: false
+  },
+  dbResourceOldList: {
+    type: Object,
+    required: false
+  }
+});
+
+const queryParams = ref({
+  codeNum: '',
+  parentId: props.rowData.id,
+  codeName: '',
+  codeType: '',
+  sysName: '',
+  classId: 'codeItem',
+  sysId: '',
+  pageNum: 1,
+  pageSize: 100
+});
+
+const form = ref({
+  id: "",
+  codeNum: '',
+  codeName: '',
+  codeType: 'company',
+  codeStatus: '',
+  sysName: '',
+  classId: 'code',
+  codeMapId: '',
+  codeMapName: '',
+  codeMapNum: '',
+  sysId: undefined
+});
+const handleCancel2 = () => {
+  mapVisible.value = false;
+};
+
+const tableData = ref([]);
+const companyist = ref([]);
+const loading = ref(false);
+const showSys = ref(false);
+const mapVisible = ref(false);
+const multiple = ref(false);
+function dataChange(data) {
+  // 从 dbResourceOldList 中查找对应的 name
+  const selectedItem = props.dbResourceOldList.find(item => item.id === data);
+  if (selectedItem) {
+    // 如果找到对应的项，将 name 赋值给 form.value.dbRName
+    form.value.sysName = selectedItem.name;
+  } else {
+    // 如果未找到，清空 form.value.dbRName
+    form.value.sysName = '';
+  }
+}
+
+function mapChange(data) {
+  const selectedItem = companyist.value.find(item => item.id === data);
+  console.log("selectmap",selectedItem,data)
+  if (selectedItem) {
+    // 如果找到对应的项，将 name 赋值给 form.value.dbRName
+    form.value.codeMapName = selectedItem.codeName;
+    form.value.codeMapNum = selectedItem.codeNum;
+  } else {
+    // 如果未找到，清空 form.value.codeMapName
+    form.value.codeMapName = '';
+  }
+}
+//初始话判断展示系统及映射下拉选
+if (props.rowData.id) {
+  form.value = { ...props.rowData };
+  if (form.value.codeType == "sys") {
+    showSys.value = true;
+  } else {
+    showSys.value = false;
+  }
+}
+
+// 双击行进入编辑模式
+const handleRowDblClick = (row) => {
+  row.isEditing = true;
+};
+const selectedRow = ref(null); // 传递给 codeItem 组件的数据
+const selectedRowIndex = ref(null); // 传递给 codeItem 组件的数据
+
+// 失去焦点时保存编辑结果
+const handleBlur = (row) => {
+  row.isEditing = false;
+  // 可以在这里发送请求保存编辑的结果
+  console.log('保存编辑', row);
+};
+
+// 获取数据列表
+const getList = async () => {
+  loading.value = true;
+  console.log(queryParams.value,"queryParams.value")
+  const response = await listStdCode(queryParams.value);
+  tableData.value = response.rows.map(item => ({ ...item, isEditing: false }));
+  loading.value = false;
+};
+
+const getcompanyList = async () => {
+  const response = await listStdCodeCompany();
+  companyist.value = response.rows;
+  console.log(companyist.value,"companyCodeList")
+};
+const formRules = reactive({
+  codeNum: [{ required: true, message: "请输入标准代码编号", trigger: "blur" }],
+  codeName: [{ required: true, message: "请输入标准代码名称", trigger: "blur" }]
+});
+const handleCodeClick = (row,index) => {
+  selectedRow.value=row
+  selectedRowIndex.value=index
+  if(form.value.codeMapId){
+    mapVisible.value=true
+  }else {
+    proxy.$modal.msgWarning("请选择关联代码！");
+
+  }
+  console.log(index,'点击了标准代码名称', row);
+};
+const handleSave2 =async () => {
+  const child = proxy.$refs.showCodeDialog;
+ console.log(child.selections,"父组件获取")
+ const mapList=child.selections
+ if(mapList.length!=1){
+  proxy.$modal.msgWarning("请选择一条代码进行映射");
+
+ }else{
+  const mapCodeItem=child.selections[0]
+  if (selectedRow.value) {
+        tableData.value[selectedRowIndex.value].codeMapId = mapCodeItem.id;
+        tableData.value[selectedRowIndex.value].codeMapName = mapCodeItem.codeName;
+        tableData.value[selectedRowIndex.value].codeMapNum = mapCodeItem.codeNum;
+
+      tableData.value = [...tableData.value]; // This ensures reactivity is triggered
+
+      mapVisible.value = false; 
+
+      proxy.$modal.msgSuccess("码值映射成功");
+
+ }}
+};
+const handleSave = async () => {
+  // 检查是否有 ID，决定调用哪个接口
+  const params = { code: form.value, code_item_list: tableData.value };
+
+  try {
+    let response;
+    if (props.rowData.id) {
+      // 如果 ID 存在，调用 updateStdCode
+      response = await updateStdCode(params);
+      if (response.success) {
+        proxy.$modal.msgSuccess(response.msg);
+      } else {
+        proxy.$modal.msgError(response.msg);
+      }
+    } else {
+      // 如果 ID 为空，调用 addStdCode
+      response = await addStdCode(params);
+      if (response.success) {
+        proxy.$modal.msgSuccess(response.msg);
+      } else {
+        proxy.$modal.msgError(response.msg);
+      }
+    }
+
+    // 根据 response.success 返回 true 或 false
+    if (response.success) {
+      // 操作成功
+      return true;
+    } else {
+      // 操作失败
+      return false;
+    }
+
+  } catch (error) {
+    console.error('保存时出错:', error);
+    // 这里可以弹出错误提示
+    return false;  // 出现异常时返回 false
+  }
+};
+
+const handleSelectionChange = (selection) => {
+  multiple.value = selection.length > 0;
+};
+
+
+
+function changeCodeType(data) {
+  if (data != "company") {
+    showSys.value = true;
+    form.value.sysName = "";
+    form.value.sysId = undefined;
+  } else {
+    showSys.value = false;
+    form.value.sysName = "公司级";
+    form.value.sysId = 10000;
+  }
+}
+// 新增行
+const handleAdd = () => {
+  const newRow = {id:'',classId: 'codeItem',parentId: props.rowData.id,codeNum: '', codeName: '',  codeMapId: '',
+  codeMapName: '',
+  codeMapNum: '', isEditing: true };
+  tableData.value.push(newRow);
+};
+
+// 删除选中行
+const handleRemove = () => {
+  const selectedRows = tableData.value.filter(row => row.isSelected);
+  tableData.value = tableData.value.filter(row => !row.isSelected);
+};
+defineExpose({
+  handleSave
+});
+onMounted(() => {
+  getList();
+  getcompanyList()
+});
+</script>
+
+<style scoped>
+.app-container {
+  padding: 20px;
+}
+
+.form-container {
+  margin-bottom: 20px;
+}
+
+.query-form-container {
+  margin-bottom: 20px;
+}
+
+.el-table .el-input {
+  width: 100%;
+}
+</style>

vue-fastapi-frontend/src/views/datastd/stddict/codeItemCommon.vue

@@ -0,0 +1,222 @@
+<template>
+  <el-form :model="form" ref="formRef" label-width="120px" >
+    <div class="form-container">
+  <el-row :gutter="20">
+    <!-- 代码归属 -->
+    <el-col :span="8">
+      <span class="info-text">代码归属: {{ form.sysName || '暂无代码归属' }}</span>
+    </el-col>
+
+    <!-- 代码编号 -->
+    <el-col :span="8">
+      <span class="info-text">代码编号: {{ form.codeNum || '暂无代码编号' }}</span>
+    </el-col>
+
+    <!-- 代码名称 -->
+    <el-col :span="8">
+      <span class="info-text">代码名称: {{ form.codeName || '暂无代码名称' }}</span>
+    </el-col>
+  </el-row>
+</div>
+
+
+    <!-- 查询表单 -->
+   <div class="query-form-container">
+      <el-form :model="queryParams" ref="queryRef" :inline="true">
+        <el-form-item label="代码值/名称" prop="codeNum">
+          <el-input
+            v-model="queryParams.codeNum"
+            placeholder="请输入标准代码编号"
+            clearable
+            style="width: 220px"
+          />
+        </el-form-item>
+
+        <el-form-item>
+          <el-button type="primary" @click="handleQuery">搜索</el-button>
+          <el-button icon="Refresh" @click="resetQuery">重置</el-button>
+        </el-form-item>
+      </el-form>
+    </div>
+  </el-form>
+
+
+
+  <!-- 表格展示 -->
+  <el-table
+    v-loading="loading"
+    :data="tableData"
+    @selection-change="handleSelectionChange"
+    border
+    style="width: 100%"
+  >
+    <el-table-column type="selection" width="55" align="center" />
+    <el-table-column
+      label="代码值"
+      align="center"
+      prop="codeNum"
+      :editable="true"
+    >
+
+    </el-table-column>
+
+    <el-table-column
+      label="代码含义"
+      align="center"
+      prop="codeName"
+      :editable="true"
+    >
+
+    </el-table-column>
+
+  </el-table>
+  
+</template>
+
+<script setup>
+import { ref, reactive, onMounted, toRefs } from 'vue';
+import { listStdCode,getStdCode} from "@/api/datastd/stdcode"; // 更新为新的接口
+
+const { proxy } = getCurrentInstance();
+const { std_code_status } = proxy.useDict("std_code_status");
+
+const props = defineProps({
+  codeId: {
+    type: Object,
+    required: false
+  },
+
+});
+
+const queryParams = ref({
+  codeNum: '',
+  parentId: props.codeId,
+  codeName: '',
+  codeType: '',
+  sysName: '',
+  classId: 'codeItem',
+  sysId: '',
+  pageNum: 1,
+  pageSize: 100
+});
+
+const form = ref({
+  id: "",
+  codeNum: '',
+  codeName: '',
+  codeType: 'company',
+  codeStatus: '',
+  sysName: '',
+  classId: 'code',
+  codeMapId: '',
+  codeMapName: '',
+  codeMapNum: '',
+  sysId: undefined
+});
+
+const tableData = ref([]);
+const selections = ref([]);
+const loading = ref(false);
+const showSys = ref(false);
+const multiple = ref(false);
+
+
+//初始话判断展示系统及映射下拉选
+if (props.codeId) {
+  form.value = { ...props.rowData };
+  if (form.value.codeType == "sys") {
+    showSys.value = true;
+  } else {
+    showSys.value = false;
+  }
+}
+
+
+
+
+
+// 获取数据列表
+const getList = async () => {
+  loading.value = true;
+  console.log(queryParams.value,"queryParams.value")
+  const response = await listStdCode(queryParams.value);
+  tableData.value = response.rows.map(item => ({ ...item}));
+  loading.value = false;
+};
+
+
+
+const handleCodeClick = (row) => {
+  console.log('点击了标准代码名称', row);
+};
+
+
+const handleSelectionChange = (selection) => {
+  multiple.value = selection.length > 0;
+  selections.value = selection; // 保存选中的行数据
+console.log(selections.value,"子页面选中")
+};
+
+// 搜索
+const handleQuery = () => {
+  queryParams.value.pageNum = 1;
+  getList();
+};
+
+// 重置查询
+const resetQuery = () => {
+  queryParams.value = {
+    parentId:props.codeId,
+    pageNum: 1,
+    pageSize: 100
+  };
+
+};
+
+defineExpose({
+  selections
+});
+
+
+onMounted(() => {
+  getStdCode(props.codeId).then(response => {
+    form.value = response.data;
+
+  });
+  getList();
+  // getcompanyList()
+});
+</script>
+
+<style scoped>
+.app-container {
+  padding: 20px;
+}
+
+
+
+.query-form-container {
+  margin-bottom: 20px;
+}
+
+.el-table .el-input {
+  width: 100%;
+}
+.form-container {
+  margin-bottom: 20px;
+  
+}
+.info-text {
+  font-size: 18px; /* 调整字体大小 */
+  line-height: 1.6; /* 行高，使文字更易于阅读 */
+  color: #333; /* 字体颜色 */
+  font-weight: 500; /* 设置字体加粗 */
+  display: inline-block;
+  width: 100%;
+}
+
+
+
+</style>
+
+

vue-fastapi-frontend/src/views/datastd/stddict/index.vue

@@ -0,0 +1,277 @@
+<template>
+  <div class="app-container">
+    <el-row :gutter="20">
+      <el-col :span="4" :xs="24">
+        <div class="head-container">
+          <el-input
+            v-model="dbResoursName"
+            placeholder="请输入字典分类"
+            clearable
+            prefix-icon="search"
+            style="margin-bottom: 20px"
+          />
+        </div>
+        <div class="head-container">
+          <el-tree
+            :data="dbResourceOptions"
+            :props="defaultProps"
+            :expand-on-click-node="false"
+            :filter-node-method="filterNode"
+            ref="tree"
+            node-key="id"
+            default-expand-all
+            highlight-current
+            @node-click="handleNodeClick"
+          >
+            <template #default="{ node, data }">
+              <span class="custom-tree-node">
+                <span>{{ data.name }}</span>
+              </span>
+            </template>
+          </el-tree>
+        </div>
+      </el-col>
+
+      <el-col :span="20" :xs="24">
+        <el-form :model="queryParams" ref="queryRef" :inline="true">
+          <el-form-item label="字典编号" prop="dictNum">
+            <el-input v-model="queryParams.dictNum" placeholder="请输入标准字典编号" clearable style="width: 220px" />
+          </el-form-item>
+  
+          <el-form-item>
+            <el-button type="primary" @click="handleQuery">搜索</el-button>
+            <el-button icon="Refresh" @click="resetQuery">重置</el-button>
+          </el-form-item>
+        </el-form>
+
+        <!-- 操作按钮 -->
+        <el-row :gutter="10" class="mb8">
+          <el-col :span="1.5">
+            <el-button
+              type="primary"
+              plain
+              icon="Plus"
+              @click="handleAdd"
+              v-hasPermi="['meta:metaSecurityCol:add']"
+            >新增</el-button>
+          </el-col>
+          <el-col :span="1.5">
+            <el-button
+              type="success"
+              plain
+              icon="Edit"
+              :disabled="single"
+              @click="handleEdit"
+              v-hasPermi="['meta:metaSecurityCol:edit']"
+            >修改</el-button>
+          </el-col>
+          <el-col :span="1.5">
+            <el-button
+              type="danger"
+              plain
+              icon="Delete"
+              :disabled="multiple"
+              @click="handleRemove"
+              v-hasPermi="['meta:metaSecurityCol:remove']"
+            >删除</el-button>
+          </el-col>
+        </el-row>
+
+        <!-- 表格展示 -->
+        <el-table v-loading="loading" :data="tableData" @selection-change="handleSelectionChange">
+          <el-table-column type="selection" width="55" align="center" />
+          <el-table-column label="归属" align="center" prop="dictLevel" />
+          <el-table-column label="类型" align="center" prop="dictType" />
+          <el-table-column label="来源系统" width="150" align="center" prop="sysName" />
+          <el-table-column label="字典编号" width="150" align="center" prop="dictNum" />
+          <el-table-column label="字典英文名" width="120" align="center" prop="dictCode" />
+          <el-table-column label="字典中文名" width="120" align="center" prop="dictName" />
+          <el-table-column label="字典业务定义" width="120" align="center" prop="dictMenu" />
+          <el-table-column label="数据类型" align="center" prop="dataType" />
+          <el-table-column label="数据标准" align="center" prop="stdCode" />
+          <el-table-column label="字典状态" align="center" prop="dictStatus" />
+          <el-table-column label="业务认责部门" width="120" align="center" prop="bussDeptId" />
+          <el-table-column label="业务认责人员" width="120" align="center" prop="bussUser" />
+          <el-table-column label="技术认责部门" width="120" align="center" prop="techDeptId" />
+          <el-table-column label="技术认责人员" width="120" align="center" prop="techUser" />
+          <el-table-column label="更新者" width="120" align="center" prop="updateBy" />
+          <el-table-column label="更新时间" width="120" align="center" prop="updateTime" />
+          <el-table-column label="操作" align="center" width="180">
+            <template #default="scope">
+              <el-button @click="handleEdit(scope.row)" type="text" icon="Edit" />
+              <el-button @click="handleRemove(scope.row)" type="text" icon="Delete" />
+            </template>
+          </el-table-column>
+        </el-table>
+
+        <!-- 分页 -->
+        <pagination v-show="total > 0" :total="total" v-model:page="queryParams.pageNum" v-model:limit="queryParams.pageSize" @pagination="handlePagination" />
+      </el-col>
+    </el-row>
+    <AddEditForm
+    :data="selectedRow"
+  :isEdit="isEdit"
+  :dbResourceOldList="dbResourceOldList"
+  v-model:visible="dialogVisible"
+  @refresh="getList"
+/>
+
+  </div>
+</template>
+
+<script setup>
+import { ref, reactive, onMounted, toRefs } from 'vue';
+import { listStdDict, addStdDict, getStdDict, updateStdDict, deleteStdDict } from "@/api/datastd/std"; // 更新为新的接口
+import { datasourcetree } from "@/api/meta/metatask";
+import AddEditForm from './AddEditForm.vue';
+const { proxy } = getCurrentInstance();
+
+const queryParams = ref({
+  dictNum: '',
+  dictName: '',
+  dictType: '',
+  sysName: '',
+  classId: 'dict',
+  sysId: '',
+  pageNum: 1,
+  pageSize: 10
+});
+const single = ref(true);
+const multiple = ref(true);
+const dbResoursName = ref(undefined);
+const defaultProps = { children: "children", label: "name" };
+const dialogVisible = ref(false);
+const selectedRow = ref(null);
+const isEdit = ref(false);
+const tableData = ref([]);
+const total = ref(0);
+const loading = ref(false);
+const ids = ref([]);
+const codeNums = ref([]);
+
+const dbResourceOptions = ref([]);
+
+const handlePagination = (pageNum, pageSize) => {
+  queryParams.value.pageNum = pageNum;
+  queryParams.value.pageSize = pageSize;
+  handleQuery();
+};
+
+const filterNode = (value, data) => {
+  if (!value) return true;
+  return data.name.indexOf(value) !== -1;
+};
+
+const handleNodeClick = (data) => {
+  queryParams.value.sysId = data.id === 9999 ? undefined : data.id;
+  handleQuery();
+};
+
+const handleSelectionChange = (selection) => {
+  single.value = selection.length !== 1;
+  multiple.value = !selection.length;
+  ids.value = selection.map(item => item.id);
+  codeNums.value = selection.map(item => item.dictNum);
+
+};
+
+const getList = async () => {
+  loading.value = true;
+  const response = await listStdDict(queryParams.value);
+  tableData.value = response.rows;
+  total.value = response.total;
+  loading.value = false;
+};
+
+const handleQuery = () => {
+  queryParams.value.pageNum = 1;
+  getList();
+};
+
+const resetQuery = () => {
+  queryParams.value = {
+    dictNum: '',
+    dictName: '',
+    dictType: '',
+    sysName: '',
+    sysId: undefined,
+    pageNum: 1,
+    pageSize: 10
+  };
+  getList();
+};
+
+const handleRemove = (row) => {
+  const idsToDelete = row.id ? [row.id] : ids.value;
+  const codesToDelete = row.codeNum ? [row.codeNum] : codeNums.value;
+  proxy.$modal.confirm('是否确认删除字典编号为"' + codesToDelete.toString() + '"的数据项？').then(function () {
+    return deleteStdDict(idsToDelete.toString());
+  }).then(() => {
+    handleQuery();
+    proxy.$modal.msgSuccess("删除成功");
+  }).catch(() => {});
+};
+const dbResourceOldList = ref([]);
+
+const handleAdd = () => {
+  console.log('update:visible', 111)
+  isEdit.value = false;
+  selectedRow.value={
+        dictLevel: 'company',
+        sysId: undefined,
+        dictType: '',
+        dictNum: '',
+        dictCode: '',
+        dictName: '',
+        dictMenu: '',
+        dataType: '',
+        stdCode: '',
+        bussDeptId: '',
+        bussUser: '',
+        techDeptId: '',
+        techUser: ''
+  }
+
+  // 清空选中的数据
+  dialogVisible.value = true;};
+  
+const handleEdit = (row) => {
+  const id = row.id ?row.id: ids.value.toString()
+  getStdDict(id).then(response => {
+    selectedRow.value = response.data;
+    isEdit.value = true;
+    dialogVisible.value = true;
+
+  });
+  }
+
+onMounted(() => {
+  datasourcetree().then(response => {
+    dbResourceOldList.value = response.rows;
+    dbResourceOptions.value = [
+      { id: 10000, name: "公司级字典", parentId: 0, children: [] },
+      { id: 99999, name: "系统级字典", parentId: 0, children: response.rows.map(element => ({ ...element, parentId: "99999" })) }
+    ];
+  });
+  getList();
+});
+</script>
+
+<style scoped>
+.app-container {
+  padding: 20px;
+}
+
+.head-container {
+  margin-bottom: 0px;
+}
+
+.custom-tree-node {
+  display: flex;
+  align-items: center;
+}
+
+.custom-tree-node i {
+  margin-right: 8px;
+}
+</style>