Merge remote-tracking branch 'origin/master'

# Conflicts:
#	vue-fastapi-backend/module_admin/controller/datastd_controller.py
#	vue-fastapi-backend/module_admin/service/datastd_service.py

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

@@ -6,96 +6,123 @@ 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,DataStdDictApprModel,DataStdCodeApprModel, DataStdCodePageQueryModel, DeleteDataStdModel,DataStdDictModel,DataStdDictPageQueryModel,DataStdMainModel,DataStdMainPageQueryModel,DataStdMainApprModel
+from module_admin.entity.vo.datastd_vo import DataStdCodeModel, DataStdDictApprModel, DataStdCodeApprModel, \
+    DataStdCodePageQueryModel, DeleteDataStdModel, DataStdDictModel, DataStdDictPageQueryModel, DataStdMainModel, \
+    DataStdMainPageQueryModel, DataStdMainApprModel, StdDictNoPageParam
 from module_admin.service.datastd_service import DataStdService
 from module_admin.service.login_service import LoginService
 from utils.log_util import logger
 from utils.page_util import PageResponseModel
 from utils.response_util import ResponseUtil
 import uuid
-from module_admin.entity.vo.data_ast_content_vo import  DataCatalogPageQueryModel, DeleteDataCatalogModel,DataCatalogResponseWithChildren,DataAssetCatalogTreeResponse,DataCatalogMovedRequest,DataCatalogMergeRequest,DataCatalogChild,DataCatalogMoverelRequest
+from module_admin.entity.vo.data_ast_content_vo import DataCatalogPageQueryModel, DeleteDataCatalogModel, \
+    DataCatalogResponseWithChildren, DataAssetCatalogTreeResponse, DataCatalogMovedRequest, DataCatalogMergeRequest, \
+    DataCatalogChild, DataCatalogMoverelRequest
 from pydantic_validation_decorator import ValidateFields
 from utils.common_util import bytes2file_response
 
 datastdController = APIRouter(prefix='/datastd', dependencies=[Depends(LoginService.get_current_user)])
 
 
-#标准代码相关API
+# 标准代码相关API
 @datastdController.get(
-    '/stdcode/code/list', response_model=PageResponseModel, dependencies=[Depends(CheckUserInterfaceAuth('datastd:stdcode:code:list'))]
+    '/stdcode/code/list', response_model=PageResponseModel,
+    dependencies=[Depends(CheckUserInterfaceAuth('datastd:stdcode:code:list'))]
 )
 async def get_std_code_list(
-    request: Request,
-    code_page_query: DataStdCodePageQueryModel = Depends(DataStdCodePageQueryModel.as_query),
-    query_db: AsyncSession = Depends(get_db),
+        request: Request,
+        code_page_query: DataStdCodePageQueryModel = Depends(DataStdCodePageQueryModel.as_query),
+        query_db: AsyncSession = Depends(get_db),
 ):
     code_page_query_result = await DataStdService.get_std_code_list_services(query_db, code_page_query, is_page=True)
     return ResponseUtil.success(model_content=code_page_query_result)
+
+
 @datastdController.get(
-    '/stdcode/Appr/list', response_model=PageResponseModel, dependencies=[Depends(CheckUserInterfaceAuth('datastd:stdcode:code:list'))]
+    '/stdcode/Appr/list', response_model=PageResponseModel,
+    dependencies=[Depends(CheckUserInterfaceAuth('datastd:stdcode:code:list'))]
 )
 async def get_appr_std_code_list(
-    request: Request,
-    code_page_query: DataStdCodePageQueryModel = Depends(DataStdCodePageQueryModel.as_query),
-    query_db: AsyncSession = Depends(get_db),
+        request: Request,
+        code_page_query: DataStdCodePageQueryModel = Depends(DataStdCodePageQueryModel.as_query),
+        query_db: AsyncSession = Depends(get_db),
 ):
-    code_page_query_result = await DataStdService.get_appr_std_code_list_services(query_db, code_page_query, is_page=True)
+    code_page_query_result = await DataStdService.get_appr_std_code_list_services(query_db, code_page_query,
+                                                                                  is_page=True)
     return ResponseUtil.success(model_content=code_page_query_result)
+
+
 @datastdController.get(
-    '/stdcode/code/maplist', response_model=PageResponseModel, dependencies=[Depends(CheckUserInterfaceAuth('datastd:stdcode:code:list'))]
+    '/stdcode/code/maplist', response_model=PageResponseModel,
+    dependencies=[Depends(CheckUserInterfaceAuth('datastd:stdcode:code:list'))]
 )
 async def get_std_code_map_list(
-    request: Request,
-    code_page_query: DataStdCodePageQueryModel = Depends(DataStdCodePageQueryModel.as_query),
-    query_db: AsyncSession = Depends(get_db),
+        request: Request,
+        code_page_query: DataStdCodePageQueryModel = Depends(DataStdCodePageQueryModel.as_query),
+        query_db: AsyncSession = Depends(get_db),
 ):
-    code_page_query_result = await DataStdService.get_std_code_map_list_services(query_db, code_page_query, is_page=True)
+    code_page_query_result = await DataStdService.get_std_code_map_list_services(query_db, code_page_query,
+                                                                                 is_page=True)
     return ResponseUtil.success(model_content=code_page_query_result)
+
+
 @datastdController.get(
-    '/stdcode/code/maplist2', response_model=PageResponseModel, dependencies=[Depends(CheckUserInterfaceAuth('datastd:stdcode:code:list'))]
+    '/stdcode/code/maplist2', response_model=PageResponseModel,
+    dependencies=[Depends(CheckUserInterfaceAuth('datastd:stdcode:code:list'))]
 )
 async def get_std_code_map_list2(
-    request: Request,
-    code_page_query: DataStdCodePageQueryModel = Depends(DataStdCodePageQueryModel.as_query),
-    query_db: AsyncSession = Depends(get_db),
+        request: Request,
+        code_page_query: DataStdCodePageQueryModel = Depends(DataStdCodePageQueryModel.as_query),
+        query_db: AsyncSession = Depends(get_db),
 ):
-    code_page_query_result = await DataStdService.get_std_main_map_list_services(query_db, code_page_query, is_page=True)
+    code_page_query_result = await DataStdService.get_std_main_map_list_services(query_db, code_page_query,
+                                                                                 is_page=True)
     return ResponseUtil.success(model_content=code_page_query_result)
-@datastdController.get('/stdcode/code/listappr', response_model=PageResponseModel, dependencies=[Depends(CheckUserInterfaceAuth('datastd:stddict:dict:list'))]
-)
+
+
+@datastdController.get('/stdcode/code/listappr', response_model=PageResponseModel,
+                       dependencies=[Depends(CheckUserInterfaceAuth('datastd:stddict:dict:list'))]
+                       )
 async def get_std_code_appr_list(
-    request: Request,
-    main_page_query: DataStdCodeApprModel= Depends(DataStdCodeApprModel),
-    query_db: AsyncSession = Depends(get_db),
+        request: Request,
+        main_page_query: DataStdCodeApprModel = Depends(DataStdCodeApprModel),
+        query_db: AsyncSession = Depends(get_db),
 ):
     main_page_query_result = await DataStdService.get_std_code_appr_list(query_db, main_page_query, is_page=True)
     logger.info('获取数据标准列表成功')
     return ResponseUtil.success(data=main_page_query_result)
+
+
 @datastdController.get(
-    '/stdcode/code/{id}', response_model=DataStdCodeModel, dependencies=[Depends(CheckUserInterfaceAuth('datastd:stdcode:code:list'))]
+    '/stdcode/code/{id}', response_model=DataStdCodeModel,
+    dependencies=[Depends(CheckUserInterfaceAuth('datastd:stdcode:code:list'))]
 )
 async def query_detail_code(request: Request, id: str, query_db: AsyncSession = Depends(get_db)):
     config_detail_result = await DataStdService.code_detail_services(query_db, id)
     logger.info(f'获取config_id为{id}的信息成功')
 
     return ResponseUtil.success(data=config_detail_result)
+
+
 @datastdController.get(
-    '/stdcode/codeAppr/{id}', response_model=DataStdCodeModel, dependencies=[Depends(CheckUserInterfaceAuth('datastd:stdcode:code:list'))]
+    '/stdcode/codeAppr/{id}', response_model=DataStdCodeModel,
+    dependencies=[Depends(CheckUserInterfaceAuth('datastd:stdcode:code:list'))]
 )
 async def query_detail_code_appr(request: Request, id: str, query_db: AsyncSession = Depends(get_db)):
     config_detail_result = await DataStdService.code_appr_detail_services(query_db, id)
     logger.info(f'获取config_id为{id}的信息成功')
 
     return ResponseUtil.success(data=config_detail_result)
+
+
 @datastdController.post('/stdcode/code', dependencies=[Depends(CheckUserInterfaceAuth('datastd:stdcode:code:add'))])
 @Log(title='代码管理', business_type=BusinessType.INSERT)
 async def add_std_code(
-    request: Request,
-    add_std_code: DataStdCodeModel,
-    query_db: AsyncSession = Depends(get_db),
-    current_user: CurrentUserModel = Depends(LoginService.get_current_user),
+        request: Request,
+        add_std_code: DataStdCodeModel,
+        query_db: AsyncSession = Depends(get_db),
+        current_user: CurrentUserModel = Depends(LoginService.get_current_user),
 ):
-    
     add_std_code.create_by = current_user.user.user_name
     add_std_code.create_time = datetime.now()
     add_std_code.upd_prsn = current_user.user.user_name
@@ -108,10 +135,10 @@ async def add_std_code(
 @datastdController.put('/stdcode/code', dependencies=[Depends(CheckUserInterfaceAuth('datastd:stdcode:code:edit'))])
 @Log(title='代码管理', business_type=BusinessType.UPDATE)
 async def edit_std_code(
-    request: Request,
-    edit_std_code: DataStdCodeModel,
-    query_db: AsyncSession = Depends(get_db),
-    current_user: CurrentUserModel = Depends(LoginService.get_current_user),
+        request: Request,
+        edit_std_code: DataStdCodeModel,
+        query_db: AsyncSession = Depends(get_db),
+        current_user: CurrentUserModel = Depends(LoginService.get_current_user),
 ):
     edit_std_code.upd_prsn = current_user.user.user_name
     edit_std_code.upd_time = datetime.now()
@@ -120,59 +147,69 @@ async def edit_std_code(
     return ResponseUtil.success(msg=edit_std_code_result.message)
 
 
-@datastdController.delete('/stdcode/code/{ids}', dependencies=[Depends(CheckUserInterfaceAuth('datastd:stdcode:code:remove'))])
+@datastdController.delete('/stdcode/code/{ids}',
+                          dependencies=[Depends(CheckUserInterfaceAuth('datastd:stdcode:code:remove'))])
 @Log(title='代码管理', business_type=BusinessType.DELETE)
 async def delete_std_code(
-    request: Request,
-    ids: str,
-    query_db: AsyncSession = Depends(get_db),
+        request: Request,
+        ids: str,
+        query_db: AsyncSession = Depends(get_db),
 ):
-    delete_std_code = DeleteDataStdModel(ids =ids)
+    delete_std_code = DeleteDataStdModel(ids=ids)
     delete_std_code_result = await DataStdService.delete_std_code_services(request, query_db, delete_std_code)
     logger.info(delete_std_code_result.message)
     return ResponseUtil.success(msg=delete_std_code_result.message)
-@datastdController.delete('/stdcode/codeappr/{ids}', dependencies=[Depends(CheckUserInterfaceAuth('datastd:stdcode:codeWithItems:delete'))])
+
+
+@datastdController.delete('/stdcode/codeappr/{ids}',
+                          dependencies=[Depends(CheckUserInterfaceAuth('datastd:stdcode:codeWithItems:delete'))])
 @Log(title='标准代码与代码项管理', business_type=BusinessType.DELETE)
 async def delete_std_code_with_items_appr(
-    request: Request,
-    ids: str,
-    query_db: AsyncSession = Depends(get_db),
-    current_user: CurrentUserModel = Depends(LoginService.get_current_user),
+        request: Request,
+        ids: str,
+        query_db: AsyncSession = Depends(get_db),
+        current_user: CurrentUserModel = Depends(LoginService.get_current_user),
 ):
     try:
         await DataStdService.delete_std_code_with_items_appr(ids, query_db, current_user)
         return ResponseUtil.success(msg="提交删除标准代码审批成功")
     except Exception as e:
         return ResponseUtil.error(msg=str(e))
-@datastdController.post('/stdcode/codeWithItems', dependencies=[Depends(CheckUserInterfaceAuth('datastd:stdcode:codeWithItems:add'))])
+
+
+@datastdController.post('/stdcode/codeWithItems',
+                        dependencies=[Depends(CheckUserInterfaceAuth('datastd:stdcode:codeWithItems:add'))])
 @Log(title='标准代码与代码项管理', business_type=BusinessType.INSERT)
 async def add_std_code_with_items(
-    request: Request,
-    code: DataStdCodeModel,  # 接收标准代码对象
-    code_item_list: list[DataStdCodeModel] = [],  # 接收代码项列表，默认空列表
-    query_db: AsyncSession = Depends(get_db),
-    current_user: CurrentUserModel = Depends(LoginService.get_current_user),
+        request: Request,
+        code: DataStdCodeModel,  # 接收标准代码对象
+        code_item_list: list[DataStdCodeModel] = [],  # 接收代码项列表，默认空列表
+        query_db: AsyncSession = Depends(get_db),
+        current_user: CurrentUserModel = Depends(LoginService.get_current_user),
 ):
     # 设置标准代码的创建和更新时间
     code.create_by = current_user.user.user_name
     code.create_time = datetime.now()
     code.upd_prsn = current_user.user.user_name
     code.upd_time = datetime.now()
-    code.src_sys='公司级'  if  'company'==code.cd_type else code.src_sys
+    code.src_sys = '公司级' if 'company' == code.cd_type else code.src_sys
     # 传递给服务层，处理标准代码和代码项的添加
     result = await DataStdService.add_std_code_with_items_services(request, query_db, code, code_item_list)
-    
+
     # 返回响应
     logger.info(result.message)
     return ResponseUtil.success(msg=result.message)
-@datastdController.post('/stdcode/codeWithItems/appr', dependencies=[Depends(CheckUserInterfaceAuth('datastd:stdcode:codeWithItems:add'))])
+
+
+@datastdController.post('/stdcode/codeWithItems/appr',
+                        dependencies=[Depends(CheckUserInterfaceAuth('datastd:stdcode:codeWithItems:add'))])
 @Log(title='标准代码与代码项管理', business_type=BusinessType.INSERT)
 async def add_std_code_with_items_appr(
-    request: Request,
-    code: DataStdCodeModel,
-    code_item_list: list[DataStdCodeModel] = [],
-    query_db: AsyncSession = Depends(get_db),
-    current_user: CurrentUserModel = Depends(LoginService.get_current_user),
+        request: Request,
+        code: DataStdCodeModel,
+        code_item_list: list[DataStdCodeModel] = [],
+        query_db: AsyncSession = Depends(get_db),
+        current_user: CurrentUserModel = Depends(LoginService.get_current_user),
 ):
     try:
         # 调用 service 层的业务逻辑
@@ -182,38 +219,39 @@ async def add_std_code_with_items_appr(
         return ResponseUtil.success(msg="标准代码及代码项添加成功，等待审批")
     except Exception as e:
         return ResponseUtil.error(msg=str(e))
-@datastdController.put('/stdcode/codeWithItems', dependencies=[Depends(CheckUserInterfaceAuth('datastd:stdcode:codeWithItems:add'))])
+
+
+@datastdController.put('/stdcode/codeWithItems',
+                       dependencies=[Depends(CheckUserInterfaceAuth('datastd:stdcode:codeWithItems:add'))])
 @Log(title='标准代码与代码项管理', business_type=BusinessType.INSERT)
 async def edit_std_code_with_items(
-    request: Request,
-    code: DataStdCodeModel,  # 接收标准代码对象
-    code_item_list: list[DataStdCodeModel],  # 接收代码项列表
-    query_db: AsyncSession = Depends(get_db),
-    current_user: CurrentUserModel = Depends(LoginService.get_current_user),
+        request: Request,
+        code: DataStdCodeModel,  # 接收标准代码对象
+        code_item_list: list[DataStdCodeModel],  # 接收代码项列表
+        query_db: AsyncSession = Depends(get_db),
+        current_user: CurrentUserModel = Depends(LoginService.get_current_user),
 ):
     # 设置标准代码的创建和更新时间
-    code.src_sys='公司级'  if  'company'==code.cd_type else code.src_sys
+    code.src_sys = '公司级' if 'company' == code.cd_type else code.src_sys
     code.upd_prsn = current_user.user.user_name
     code.upd_time = datetime.now()
     # 传递给服务层，处理标准代码和代码项的添加
     result = await DataStdService.edit_std_code_with_items_services(request, query_db, code, code_item_list)
-    
+
     # 返回响应
     logger.info(result.message)
     return ResponseUtil.success(msg=result.message)
 
 
-
-
-
-@datastdController.put('/stdcode/codeWithItems/appr', dependencies=[Depends(CheckUserInterfaceAuth('datastd:stdcode:codeWithItems:edit'))])
+@datastdController.put('/stdcode/codeWithItems/appr',
+                       dependencies=[Depends(CheckUserInterfaceAuth('datastd:stdcode:codeWithItems:edit'))])
 @Log(title='标准代码与代码项管理', business_type=BusinessType.UPDATE)
 async def edit_std_code_with_items_appr(
-    request: Request,
-    code: DataStdCodeModel,
-    code_item_list: list[DataStdCodeModel],
-    query_db: AsyncSession = Depends(get_db),
-    current_user: CurrentUserModel = Depends(LoginService.get_current_user),
+        request: Request,
+        code: DataStdCodeModel,
+        code_item_list: list[DataStdCodeModel],
+        query_db: AsyncSession = Depends(get_db),
+        current_user: CurrentUserModel = Depends(LoginService.get_current_user),
 ):
     try:
         await DataStdService.edit_std_code_with_items_appr(
@@ -223,29 +261,30 @@ async def edit_std_code_with_items_appr(
     except Exception as e:
         return ResponseUtil.error(msg=str(e))
 
+    # ----------------------------------------------------------------数据字典----------------------------------------------------------------------------------------------------
 
 
-
-
-    # ----------------------------------------------------------------数据字典----------------------------------------------------------------------------------------------------
-@datastdController.get('/stddict/dict/listappr', response_model=PageResponseModel, dependencies=[Depends(CheckUserInterfaceAuth('datastd:stddict:dict:list'))]
-)
+@datastdController.get('/stddict/dict/listappr', response_model=PageResponseModel,
+                       dependencies=[Depends(CheckUserInterfaceAuth('datastd:stddict:dict:list'))]
+                       )
 async def get_std_dict_appr_list(
-    request: Request,
-    main_page_query: DataStdDictApprModel= Depends(DataStdDictApprModel),
-    query_db: AsyncSession = Depends(get_db),
+        request: Request,
+        main_page_query: DataStdDictApprModel = Depends(DataStdDictApprModel),
+        query_db: AsyncSession = Depends(get_db),
 ):
     main_page_query_result = await DataStdService.get_std_dict_appr_list(query_db, main_page_query, is_page=True)
     logger.info('获取数据标准列表成功')
     return ResponseUtil.success(data=main_page_query_result)
 
+
 @datastdController.get(
-    '/stddict/dict/list', response_model=PageResponseModel, dependencies=[Depends(CheckUserInterfaceAuth('datastd:stddict:dict:list'))]
+    '/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),
+        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('获取列配置列表成功')
@@ -253,37 +292,38 @@ async def get_std_dict_list(
 
 
 @datastdController.get(
-    '/stddict/dict/listNoPage', response_model=PageResponseModel, dependencies=[Depends(CheckUserInterfaceAuth('datastd:stddict:dict:list'))]
+    '/stddict/dict/listNoPage', response_model=PageResponseModel,
+    dependencies=[Depends(CheckUserInterfaceAuth('datastd:stddict:dict:list'))]
 )
 async def get_std_dict_list_no_page(
-    request: Request,
-    query: str,
-    query_db: AsyncSession = Depends(get_db),
+        request: Request,
+        query: StdDictNoPageParam = Depends(StdDictNoPageParam.as_query),
+        query_db: AsyncSession = Depends(get_db),
 ):
     dict_page_query_result = await DataStdService.get_std_dict_list_no_page_services(query_db, query)
     logger.info('获取列配置列表成功')
     return ResponseUtil.success(data=dict_page_query_result)
 
 
-
-
 @datastdController.get(
-    '/stddict/dict/{id}', response_model=DataStdDictModel, dependencies=[Depends(CheckUserInterfaceAuth('datastd:stddict:dict:list'))]
+    '/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),
+        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.upd_prsn = current_user.user.user_name
@@ -296,10 +336,10 @@ async def add_std_dict(
 @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),
+        request: Request,
+        edit_std_dict: DataStdDictModel,
+        query_db: AsyncSession = Depends(get_db),
+        current_user: CurrentUserModel = Depends(LoginService.get_current_user),
 ):
     edit_std_dict.upd_prsn = current_user.user.user_name
     edit_std_dict.upd_time = datetime.now()
@@ -308,33 +348,39 @@ async def edit_std_dict(
     return ResponseUtil.success(msg=edit_std_dict_result.message)
 
 
-@datastdController.delete('/stddict/dict/{ids}', dependencies=[Depends(CheckUserInterfaceAuth('datastd:stddict:dict:remove'))])
+@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),
+        request: Request,
+        ids: str,
+        query_db: AsyncSession = Depends(get_db),
 ):
-    delete_std_dict = DeleteDataStdModel(ids =ids)
+    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)
+
+
 # 字典审批接口
 
 @datastdController.get(
-    '/stddict/dictappr/{id}', response_model=DataStdDictModel, dependencies=[Depends(CheckUserInterfaceAuth('datastd:stdmain:main:list'))]
+    '/stddict/dictappr/{id}', response_model=DataStdDictModel,
+    dependencies=[Depends(CheckUserInterfaceAuth('datastd:stdmain:main:list'))]
 )
 async def query_detail_dict_appr(request: Request, id: str, query_db: AsyncSession = Depends(get_db)):
     config_detail_result = await DataStdService.get_std_dict_change_by_id(query_db, id)
     logger.info(f'获取数据标准ID为{id}的信息成功')
     return ResponseUtil.success(data=config_detail_result)
+
+
 @datastdController.post('/stddict/dictappr', dependencies=[Depends(CheckUserInterfaceAuth('datastd:stdmain:main:add'))])
 @Log(title='数据字典', business_type=BusinessType.INSERT)
 async def add_std_dict_appr(
-    request: Request,
-    add_std_dict: DataStdDictModel,
-    query_db: AsyncSession = Depends(get_db),
-    current_user: CurrentUserModel = Depends(LoginService.get_current_user),
+        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()
@@ -342,59 +388,62 @@ async def add_std_dict_appr(
     add_std_dict.upd_time = datetime.now()
     add_std_dict_result = await DataStdService.add_std_dict_appr(query_db, add_std_dict)
     logger.info(add_std_dict_result.message)
-    return ResponseUtil.success(msg=add_std_dict_result.message)      
+    return ResponseUtil.success(msg=add_std_dict_result.message)
+
+
 @datastdController.put('/stddict/dictappr', dependencies=[Depends(CheckUserInterfaceAuth('datastd:stdmain:main:edit'))])
 @Log(title='数据字典', business_type=BusinessType.UPDATE)
 async def edit_std_dict_appr(
-    request: Request,
-    edit_std_dict: DataStdDictModel,
-    query_db: AsyncSession = Depends(get_db),
-    current_user: CurrentUserModel = Depends(LoginService.get_current_user),
+        request: Request,
+        edit_std_dict: DataStdDictModel,
+        query_db: AsyncSession = Depends(get_db),
+        current_user: CurrentUserModel = Depends(LoginService.get_current_user),
 ):
     edit_std_dict.upd_prsn = current_user.user.user_name
     edit_std_dict.upd_time = datetime.now()
     edit_std_dict_result = await DataStdService.edit_std_dict_appr(query_db, edit_std_dict)
     logger.info(edit_std_dict_result.message)
-    return ResponseUtil.success(msg=edit_std_dict_result.message)   
-@datastdController.delete('/stddict/dictappr/{id}', dependencies=[Depends(CheckUserInterfaceAuth('datastd:stdmain:main:remove'))])
+    return ResponseUtil.success(msg=edit_std_dict_result.message)
+
+
+@datastdController.delete('/stddict/dictappr/{id}',
+                          dependencies=[Depends(CheckUserInterfaceAuth('datastd:stdmain:main:remove'))])
 @Log(title='数据字典', business_type=BusinessType.DELETE)
 async def delete_std_dict_Appr(
-    request: Request,
-    id: str,
-    query_db: AsyncSession = Depends(get_db),
+        request: Request,
+        id: str,
+        query_db: AsyncSession = Depends(get_db),
 ):
     delete_std_dict_result = await DataStdService.delete_std_dict_Appr(query_db, id)
     logger.info(delete_std_dict_result.message)
     return ResponseUtil.success(msg=delete_std_dict_result.message)
 
-
-
-
     # ----------------------------------------------------------------标准目录----------------------------------------------------------------------------------------------------
 
+
 @datastdController.get(
-    '/cata/list', response_model=PageResponseModel, dependencies=[Depends(CheckUserInterfaceAuth('system:data_catalog:list'))]
+    '/cata/list', response_model=PageResponseModel,
+    dependencies=[Depends(CheckUserInterfaceAuth('system:data_catalog:list'))]
 )
 async def get_data_catalog_list(
-    request: Request,
-    catalog_page_query: DataCatalogPageQueryModel = Depends(DataCatalogPageQueryModel.as_query),
-    query_db: AsyncSession = Depends(get_db),
-    current_user: CurrentUserModel = Depends(LoginService.get_current_user),
+        request: Request,
+        catalog_page_query: DataCatalogPageQueryModel = Depends(DataCatalogPageQueryModel.as_query),
+        query_db: AsyncSession = Depends(get_db),
+        current_user: CurrentUserModel = Depends(LoginService.get_current_user),
 ):
-
-    #设置字段
+    # 设置字段
     user_id = current_user.user.user_id
     # 获取分页数据
-    catalog_page_query_result = await DataStdService.get_catalog_list_services(query_db, catalog_page_query, user_id, is_page=True)
+    catalog_page_query_result = await DataStdService.get_catalog_list_services(query_db, catalog_page_query, user_id,
+                                                                               is_page=True)
     logger.info('获取成功')
 
-
-
     return ResponseUtil.success(model_content=catalog_page_query_result)
 
 
 @datastdController.get(
-    '/cata/atree',response_model=DataAssetCatalogTreeResponse,dependencies=[Depends(CheckUserInterfaceAuth('system:data_catalog:atree'))],summary="Data Asset Tree Query"
+    '/cata/atree', response_model=DataAssetCatalogTreeResponse,
+    dependencies=[Depends(CheckUserInterfaceAuth('system:data_catalog:atree'))], summary="Data Asset Tree Query"
 )
 async def get_data_asset_catalog_tree(query_db: AsyncSession = Depends(get_db)):
     try:
@@ -406,18 +455,19 @@ async def get_data_asset_catalog_tree(query_db: AsyncSession = Depends(get_db)):
         logger.error(f"数据资产树获取失败: {str(e)}", exc_info=True)
         return ResponseUtil.error(msg="数据查询异常，请联系管理员")
 
+
 @datastdController.post('/cata', dependencies=[Depends(CheckUserInterfaceAuth('system:data_catalog:add'))])
 @ValidateFields(validate_model='add_data_catalog')
 @Log(title='标准分类管理', business_type=BusinessType.INSERT)
 async def add_data_catalog(
-    request: Request,
-    add_catalog: DataCatalogResponseWithChildren,
-    query_db: AsyncSession = Depends(get_db),
-    current_user: CurrentUserModel = Depends(LoginService.get_current_user),
+        request: Request,
+        add_catalog: DataCatalogResponseWithChildren,
+        query_db: AsyncSession = Depends(get_db),
+        current_user: CurrentUserModel = Depends(LoginService.get_current_user),
 ):
     # 设置字段 
     add_catalog.upd_prsn = current_user.user.user_name
-    
+
     # 调用服务层方法
     add_result = await DataStdService.add_catalog_services(query_db, add_catalog)
     logger.info(add_result.message)
@@ -426,7 +476,7 @@ async def add_data_catalog(
     if add_result.is_success:
         if add_catalog.supr_content_onum is not None:
             supr_content_onum = add_catalog.supr_content_onum
-            await DataStdService.edit_catalog_leaf_services(query_db,supr_content_onum, 0)
+            await DataStdService.edit_catalog_leaf_services(query_db, supr_content_onum, 0)
     else:
         logger.error(add_result.message)
     # 返回标准化响应
@@ -434,19 +484,19 @@ async def add_data_catalog(
         msg=add_result.message
     )
 
+
 @datastdController.put('/cata/edit', dependencies=[Depends(CheckUserInterfaceAuth('system:data_catalog:edit'))])
 @ValidateFields(validate_model='edit_data_catalog')
 @Log(title='标准分类管理', business_type=BusinessType.UPDATE)
 async def edit_data_catalog(
-    request: Request,
-    edit_catalog: DataCatalogResponseWithChildren,
-    query_db: AsyncSession = Depends(get_db),
-    current_user: CurrentUserModel = Depends(LoginService.get_current_user),
+        request: Request,
+        edit_catalog: DataCatalogResponseWithChildren,
+        query_db: AsyncSession = Depends(get_db),
+        current_user: CurrentUserModel = Depends(LoginService.get_current_user),
 ):
     # 设置审计字段
     edit_catalog.upd_prsn = current_user.user.user_name
 
-
     # 调用服务层方法
     edit_result = await DataStdService.edit_catalog_child_services(query_db, edit_catalog)
     logger.info(edit_result.message)
@@ -461,10 +511,10 @@ async def edit_data_catalog(
 @ValidateFields(validate_model='moved_data_catalog')
 @Log(title='标准分类管理', business_type=BusinessType.UPDATE)
 async def moved_data_catalog(
-    request: Request,
-    moved_catalog: DataCatalogMovedRequest,
-    query_db: AsyncSession = Depends(get_db),
-    current_user: CurrentUserModel = Depends(LoginService.get_current_user),
+        request: Request,
+        moved_catalog: DataCatalogMovedRequest,
+        query_db: AsyncSession = Depends(get_db),
+        current_user: CurrentUserModel = Depends(LoginService.get_current_user),
 ):
     # 调用服务层方法
     moved_result = await DataStdService.moved_catalog_instr_services(query_db, moved_catalog)
@@ -480,10 +530,10 @@ async def moved_data_catalog(
 @ValidateFields(validate_model='merge_data_catalog')
 @Log(title='标准分类管理', business_type=BusinessType.UPDATE)
 async def moved_data_catalog(
-    request: Request,
-    merge_catalog: DataCatalogMergeRequest,
-    query_db: AsyncSession = Depends(get_db),
-    current_user: CurrentUserModel = Depends(LoginService.get_current_user),
+        request: Request,
+        merge_catalog: DataCatalogMergeRequest,
+        query_db: AsyncSession = Depends(get_db),
+        current_user: CurrentUserModel = Depends(LoginService.get_current_user),
 ):
     # 调用服务层方法
     merge_result = await DataStdService.merge_catalog_instr_services(query_db, merge_catalog)
@@ -499,10 +549,10 @@ async def moved_data_catalog(
 @ValidateFields(validate_model='removerel_data_ast_catalog')
 @Log(title='标准分类管理', business_type=BusinessType.UPDATE)
 async def removerel_data_ast_catalog(
-    request: Request,
-    removerel_catalog: DataCatalogChild,
-    query_db: AsyncSession = Depends(get_db),
-    current_user: CurrentUserModel = Depends(LoginService.get_current_user),
+        request: Request,
+        removerel_catalog: DataCatalogChild,
+        query_db: AsyncSession = Depends(get_db),
+        current_user: CurrentUserModel = Depends(LoginService.get_current_user),
 ):
     # 调用服务层方法
     removerel_result = await DataStdService.removerel_data_ast_catalog_services(query_db, removerel_catalog)
@@ -511,14 +561,15 @@ async def removerel_data_ast_catalog(
     # 返回标准化响应
     return ResponseUtil.success()
 
+
 @datastdController.put('/cata/moverel', dependencies=[Depends(CheckUserInterfaceAuth('system:data_catalog:edit'))])
 @ValidateFields(validate_model='moverel_data_ast_catalog')
 @Log(title='标准分类管理', business_type=BusinessType.UPDATE)
 async def moverel_data_ast_catalog(
-    request: Request,
-    moverel_catalog: DataCatalogMoverelRequest,
-    query_db: AsyncSession = Depends(get_db),
-    current_user: CurrentUserModel = Depends(LoginService.get_current_user),
+        request: Request,
+        moverel_catalog: DataCatalogMoverelRequest,
+        query_db: AsyncSession = Depends(get_db),
+        current_user: CurrentUserModel = Depends(LoginService.get_current_user),
 ):
     # 调用服务层方法
     moverel_result = await DataStdService.moverel_data_ast_catalog_services(query_db, moverel_catalog)
@@ -528,62 +579,77 @@ async def moverel_data_ast_catalog(
     return ResponseUtil.success()
 
 
-
-@datastdController.delete('/cata/{content_onums}', dependencies=[Depends(CheckUserInterfaceAuth('system:data_catalog:remove'))])
+@datastdController.delete('/cata/{content_onums}',
+                          dependencies=[Depends(CheckUserInterfaceAuth('system:data_catalog:remove'))])
 @Log(title='标准分类管理', business_type=BusinessType.DELETE)
 async def delete_data_catalog(request: Request, content_onums: str, query_db: AsyncSession = Depends(get_db),
                               current_user: CurrentUserModel = Depends(LoginService.get_current_user),
                               ):
     delete_catalog = DeleteDataCatalogModel(content_onums=content_onums)
-    delete_catalog_result = await DataStdService.delete_catalog_services(query_db, delete_catalog,user_id=current_user.user.user_id)
+    delete_catalog_result = await DataStdService.delete_catalog_services(query_db, delete_catalog,
+                                                                         user_id=current_user.user.user_id)
     logger.info(delete_catalog_result.message)
 
     return ResponseUtil.success(msg=delete_catalog_result.message)
-#----------------------------------------------数据标准--------------------------------------------------------------------------------------------------------------------------
+
+
+# ----------------------------------------------数据标准--------------------------------------------------------------------------------------------------------------------------
 @datastdController.get(
-    '/stdmain/main/list', response_model=PageResponseModel, dependencies=[Depends(CheckUserInterfaceAuth('datastd:stdmain:main:list'))]
+    '/stdmain/main/list', response_model=PageResponseModel,
+    dependencies=[Depends(CheckUserInterfaceAuth('datastd:stdmain:main:list'))]
 )
 async def get_std_main_list(
-    request: Request,
-    main_page_query: DataStdMainPageQueryModel = Depends(DataStdMainPageQueryModel.as_query),
-    query_db: AsyncSession = Depends(get_db),
+        request: Request,
+        main_page_query: DataStdMainPageQueryModel = Depends(DataStdMainPageQueryModel.as_query),
+        query_db: AsyncSession = Depends(get_db),
 ):
     main_page_query_result = await DataStdService.get_std_main_list(query_db, main_page_query, is_page=True)
     logger.info('获取数据标准列表成功')
     return ResponseUtil.success(model_content=main_page_query_result)
+
+
 @datastdController.get(
-    '/stdmain/main/listappr', response_model=PageResponseModel, dependencies=[Depends(CheckUserInterfaceAuth('datastd:stdmain:main:list'))]
+    '/stdmain/main/listappr', response_model=PageResponseModel,
+    dependencies=[Depends(CheckUserInterfaceAuth('datastd:stdmain:main:list'))]
 )
 async def get_std_main_appr_list(
-    request: Request,
-    main_page_query: DataStdMainApprModel= Depends(DataStdMainApprModel),
-    query_db: AsyncSession = Depends(get_db),
+        request: Request,
+        main_page_query: DataStdMainApprModel = Depends(DataStdMainApprModel),
+        query_db: AsyncSession = Depends(get_db),
 ):
     main_page_query_result = await DataStdService.get_std_main_appr_list(query_db, main_page_query, is_page=True)
     logger.info('获取数据标准列表成功')
     return ResponseUtil.success(data=main_page_query_result)
+
+
 @datastdController.get(
-    '/stdmain/main/selectlist', response_model=PageResponseModel, dependencies=[Depends(CheckUserInterfaceAuth('datastd:stdmain:main:list'))]
+    '/stdmain/main/selectlist', response_model=PageResponseModel,
+    dependencies=[Depends(CheckUserInterfaceAuth('datastd:stdmain:main:list'))]
 )
 async def get_std_main_select_list(
-    request: Request,
-    main_page_query: DataStdMainModel= Depends(DataStdMainModel),
-    query_db: AsyncSession = Depends(get_db),
+        request: Request,
+        main_page_query: DataStdMainModel = Depends(DataStdMainModel),
+        query_db: AsyncSession = Depends(get_db),
 ):
     main_query_result = await DataStdService.get_std_main_list_all(query_db, main_page_query)
     logger.info('获取数据标准列表成功')
     return ResponseUtil.success(data=main_query_result)
 
+
 @datastdController.get(
-    '/stdmain/main/{id}', response_model=DataStdMainModel, dependencies=[Depends(CheckUserInterfaceAuth('datastd:stdmain:main:list'))]
+    '/stdmain/main/{id}', response_model=DataStdMainModel,
+    dependencies=[Depends(CheckUserInterfaceAuth('datastd:stdmain:main:list'))]
 )
 async def query_detail_main(request: Request, id: str, query_db: AsyncSession = Depends(get_db)):
     config_detail_result = await DataStdService.get_std_main_by_id(query_db, id)
     logger.info(f'获取数据标准ID为{id}的信息成功')
 
     return ResponseUtil.success(data=config_detail_result)
+
+
 @datastdController.get(
-    '/stdmain/mainappr/{id}', response_model=DataStdMainModel, dependencies=[Depends(CheckUserInterfaceAuth('datastd:stdmain:main:list'))]
+    '/stdmain/mainappr/{id}', response_model=DataStdMainModel,
+    dependencies=[Depends(CheckUserInterfaceAuth('datastd:stdmain:main:list'))]
 )
 async def query_detail_main_appr(request: Request, id: str, query_db: AsyncSession = Depends(get_db)):
     config_detail_result = await DataStdService.get_std_main_change_by_id(query_db, id)
@@ -595,10 +661,10 @@ async def query_detail_main_appr(request: Request, id: str, query_db: AsyncSessi
 @datastdController.post('/stdmain/main', dependencies=[Depends(CheckUserInterfaceAuth('datastd:stdmain:main:add'))])
 @Log(title='数据标准', business_type=BusinessType.INSERT)
 async def add_std_main(
-    request: Request,
-    add_std_main: DataStdMainModel,
-    query_db: AsyncSession = Depends(get_db),
-    current_user: CurrentUserModel = Depends(LoginService.get_current_user),
+        request: Request,
+        add_std_main: DataStdMainModel,
+        query_db: AsyncSession = Depends(get_db),
+        current_user: CurrentUserModel = Depends(LoginService.get_current_user),
 ):
     add_std_main.create_by = current_user.user.user_name
     add_std_main.create_time = datetime.now()
@@ -608,13 +674,14 @@ async def add_std_main(
     logger.info(add_std_main_result.message)
     return ResponseUtil.success(msg=add_std_main_result.message)
 
+
 @datastdController.post('/stdmain/mainAppr', dependencies=[Depends(CheckUserInterfaceAuth('datastd:stdmain:main:add'))])
 @Log(title='数据标准', business_type=BusinessType.INSERT)
 async def add_std_main_appr(
-    request: Request,
-    add_std_main: DataStdMainModel,
-    query_db: AsyncSession = Depends(get_db),
-    current_user: CurrentUserModel = Depends(LoginService.get_current_user),
+        request: Request,
+        add_std_main: DataStdMainModel,
+        query_db: AsyncSession = Depends(get_db),
+        current_user: CurrentUserModel = Depends(LoginService.get_current_user),
 ):
     add_std_main.create_by = current_user.user.user_name
     add_std_main.create_time = datetime.now()
@@ -628,69 +695,83 @@ async def add_std_main_appr(
 @datastdController.put('/stdmain/main', dependencies=[Depends(CheckUserInterfaceAuth('datastd:stdmain:main:edit'))])
 @Log(title='数据标准', business_type=BusinessType.UPDATE)
 async def edit_std_main(
-    request: Request,
-    edit_std_main: DataStdMainModel,
-    query_db: AsyncSession = Depends(get_db),
-    current_user: CurrentUserModel = Depends(LoginService.get_current_user),
+        request: Request,
+        edit_std_main: DataStdMainModel,
+        query_db: AsyncSession = Depends(get_db),
+        current_user: CurrentUserModel = Depends(LoginService.get_current_user),
 ):
     edit_std_main.upd_prsn = current_user.user.user_name
     edit_std_main.upd_time = datetime.now()
     edit_std_main_result = await DataStdService.edit_std_main(query_db, edit_std_main)
     logger.info(edit_std_main_result.message)
-    return ResponseUtil.success(msg=edit_std_main_result.message)       
+    return ResponseUtil.success(msg=edit_std_main_result.message)
+
+
 @datastdController.put('/stdmain/mainAppr', dependencies=[Depends(CheckUserInterfaceAuth('datastd:stdmain:main:edit'))])
 @Log(title='数据标准', business_type=BusinessType.UPDATE)
 async def edit_std_main_appr(
-    request: Request,
-    edit_std_main: DataStdMainModel,
-    query_db: AsyncSession = Depends(get_db),
-    current_user: CurrentUserModel = Depends(LoginService.get_current_user),
+        request: Request,
+        edit_std_main: DataStdMainModel,
+        query_db: AsyncSession = Depends(get_db),
+        current_user: CurrentUserModel = Depends(LoginService.get_current_user),
 ):
     edit_std_main.upd_prsn = current_user.user.user_name
     edit_std_main.upd_time = datetime.now()
     edit_std_main_result = await DataStdService.edit_std_main_appr(query_db, edit_std_main)
     logger.info(edit_std_main_result.message)
-    return ResponseUtil.success(msg=edit_std_main_result.message)   
+    return ResponseUtil.success(msg=edit_std_main_result.message)
+
 
-@datastdController.delete('/stdmain/main/{id}', dependencies=[Depends(CheckUserInterfaceAuth('datastd:stdmain:main:remove'))])
+@datastdController.delete('/stdmain/main/{id}',
+                          dependencies=[Depends(CheckUserInterfaceAuth('datastd:stdmain:main:remove'))])
 @Log(title='数据标准', business_type=BusinessType.DELETE)
 async def delete_std_main(
-    request: Request,
-    id: str,
-    query_db: AsyncSession = Depends(get_db),
+        request: Request,
+        id: str,
+        query_db: AsyncSession = Depends(get_db),
 ):
     delete_std_main_result = await DataStdService.delete_std_main(query_db, id)
     logger.info(delete_std_main_result.message)
     return ResponseUtil.success(msg=delete_std_main_result.message)
-@datastdController.delete('/stdmain/mainAppr/{id}', dependencies=[Depends(CheckUserInterfaceAuth('datastd:stdmain:main:remove'))])
+
+
+@datastdController.delete('/stdmain/mainAppr/{id}',
+                          dependencies=[Depends(CheckUserInterfaceAuth('datastd:stdmain:main:remove'))])
 @Log(title='数据标准', business_type=BusinessType.DELETE)
 async def delete_std_main_Appr(
-    request: Request,
-    id: str,
-    query_db: AsyncSession = Depends(get_db),
+        request: Request,
+        id: str,
+        query_db: AsyncSession = Depends(get_db),
 ):
     delete_std_main_result = await DataStdService.delete_std_main_Appr(query_db, id)
     logger.info(delete_std_main_result.message)
     return ResponseUtil.success(msg=delete_std_main_result.message)
-@datastdController.put('/stdmain/mainonum', dependencies=[Depends(CheckUserInterfaceAuth('datastd:stdmain:main:remove'))])
+
+
+@datastdController.put('/stdmain/mainonum',
+                       dependencies=[Depends(CheckUserInterfaceAuth('datastd:stdmain:main:remove'))])
 @Log(title='数据标准', business_type=BusinessType.DELETE)
 async def change_std_main_onum(
-    request: Request,
-    edit_std_main: DataStdMainModel,
-    query_db: AsyncSession = Depends(get_db),
+        request: Request,
+        edit_std_main: DataStdMainModel,
+        query_db: AsyncSession = Depends(get_db),
 ):
-    delete_std_main_result = await DataStdService.change_std_main_onum(query_db, edit_std_main.onum,edit_std_main.belt_data_std_content)
+    delete_std_main_result = await DataStdService.change_std_main_onum(query_db, edit_std_main.onum,
+                                                                       edit_std_main.belt_data_std_content)
     logger.info(delete_std_main_result.message)
     return ResponseUtil.success(msg=delete_std_main_result.message)
+
+
 # 标准代码映射图谱
 
 @datastdController.get(
-    '/stdcode/code/mapstdlistOld/{id}', response_model=PageResponseModel, dependencies=[Depends(CheckUserInterfaceAuth('datastd:stdcode:code:list'))]
+    '/stdcode/code/mapstdlistOld/{id}', response_model=PageResponseModel,
+    dependencies=[Depends(CheckUserInterfaceAuth('datastd:stdcode:code:list'))]
 )
 async def get_code_std_map_list(
-    request: Request,
-    id: str,
-    query_db: AsyncSession = Depends(get_db),
+        request: Request,
+        id: str,
+        query_db: AsyncSession = Depends(get_db),
 ):
     code_page_query_result = await DataStdService.get_code_std_map_list_services(query_db, id)
     logger.info('获取列配置列表成功')
@@ -698,23 +779,27 @@ async def get_code_std_map_list(
 
 
 @datastdController.get(
-    '/stdcode/code/mapstdlist/{id}', response_model=PageResponseModel, dependencies=[Depends(CheckUserInterfaceAuth('datastd:stdcode:code:list'))]
+    '/stdcode/code/mapstdlist/{id}', response_model=PageResponseModel,
+    dependencies=[Depends(CheckUserInterfaceAuth('datastd:stdcode:code:list'))]
 )
 async def get_code_map_list(
-    request: Request,
-    id: str,
-    query_db: AsyncSession = Depends(get_db),
+        request: Request,
+        id: str,
+        query_db: AsyncSession = Depends(get_db),
 ):
     code_page_query_result = await DataStdService.get_code_map_list(query_db, id)
     logger.info('获取列配置列表成功')
     return ResponseUtil.success(data=code_page_query_result)
+
+
 @datastdController.get(
-    '/stdcode/code/mapstdlist2/{id}', response_model=PageResponseModel, dependencies=[Depends(CheckUserInterfaceAuth('datastd:stdcode:code:list'))]
+    '/stdcode/code/mapstdlist2/{id}', response_model=PageResponseModel,
+    dependencies=[Depends(CheckUserInterfaceAuth('datastd:stdcode:code:list'))]
 )
 async def get_code_map_list2(
-    request: Request,
-    id: str,
-    query_db: AsyncSession = Depends(get_db),
+        request: Request,
+        id: str,
+        query_db: AsyncSession = Depends(get_db),
 ):
     code_page_query_result = await DataStdService.get_code_map_list2(query_db, id)
     logger.info('获取列配置列表成功')

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

@@ -1,7 +1,8 @@
 from sqlalchemy import delete, select, update, desc,or_,not_
 from sqlalchemy.ext.asyncio import AsyncSession
 from module_admin.entity.do.datastd_do import DataStdCode,DataStdDict,DataAstContent,DataAstContentRela,DataStdMain,DataStdMainAppr,DataStdDictAppr,DataStdCodeAppr
-from module_admin.entity.vo.datastd_vo import DataStdCodeModel,DataStdDictModel,DataStdMainModel,DataStdMainApprModel,DataStdDictApprModel,DataStdCodeApprModel
+from module_admin.entity.vo.datastd_vo import DataStdCodeModel, DataStdDictModel, DataStdMainModel, \
+    DataStdMainApprModel, DataStdDictApprModel, DataStdCodeApprModel, StdDictNoPageParam
 from module_admin.entity.do.dept_do import SysDept
 from utils.page_util import PageUtil
 from sqlalchemy.orm import aliased
@@ -400,7 +401,7 @@ class DataStdDao:
         return col_list   
 
     @classmethod
-    async def get_std_dict_list_no_page(cls, db: AsyncSession, query: str):
+    async def get_std_dict_list_no_page(cls, db: AsyncSession, query: StdDictNoPageParam):
         """
         获取 DataStdDict 的列表信息，支持模糊查询和分页
         :param db: ORM对象
@@ -411,9 +412,10 @@ class DataStdDao:
         # 构建查询条件
         filters = []
         filters.append(or_(
-            DataStdDict.data_dict_cn_name.like(f"%{query}%"),
-            DataStdDict.data_dict_eng_name.like(f"%{query}%")
+            DataStdDict.data_dict_cn_name.like(f"%{query.queryStr}%"),
+            DataStdDict.data_dict_eng_name.like(f"%{query.queryStr}%")
         ))
+        filters.append(DataStdDict.src_sys == query.ssysCd)
         # c1 = aliased(DataStdDict)  # 技术部门
         # 构建查询语句
         query = (

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

@@ -17,7 +17,7 @@ class DataStdCodeModel(BaseModel):
     标准代码表对应Pydantic模型 (Standard Code Table Pydantic Model)
     """
     model_config = ConfigDict(alias_generator=to_camel, from_attributes=True)
-    
+
     onum: Optional[str] = Field(default=None, description='序号')
     cd_no: Optional[str] = Field(default=None, description='标准代码编号')
     cd_val_cn_mean: Optional[str] = Field(default=None, description='标准代码名称')
@@ -33,12 +33,14 @@ class DataStdCodeModel(BaseModel):
     code_map_id: Optional[str] = Field(default=None, description='标准代码主键(映射)')
 
 
-class DataStdCodeApprModel(DataStdCodeModel):    
+class DataStdCodeApprModel(DataStdCodeModel):
     changeType: Optional[str] = Field(default=None, description='变更类型')
     flowId: Optional[str] = Field(default=None, description='审批Id')
     oldInstId: Optional[str] = Field(default=None, description='原始正式id')
     compareId: Optional[str] = Field(default=None, description='原始数据id（用于对比差异）')
-    approStatus: Optional[str] = Field(default=None, description='审批状态（waiting,申请中,pending审核中，succeed,rejected已审核，canceled已取消）')
+    approStatus: Optional[str] = Field(default=None,
+                                       description='审批状态（waiting,申请中,pending审核中，succeed,rejected已审核，canceled已取消）')
+
 
 @as_query
 class DataStdCodePageQueryModel(DataStdCodeModel):
@@ -56,12 +58,13 @@ 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)
-    
+
     onum: Optional[str] = Field(default=None, description='标准字典主键')
     create_by: Optional[str] = Field(default='', description='创建者')
     create_time: Optional[datetime] = Field(default=None, description='创建时间')
@@ -79,6 +82,7 @@ class DataStdDictModel(BaseModel):
     data_std_no: Optional[str] = Field(default=None, description='数据标准编号')
     data_dict_stat: Optional[str] = Field(default=None, description='字典状态（1：有效 0：无效）')
 
+
 @as_query
 class DataStdDictPageQueryModel(DataStdDictModel):
     """
@@ -86,18 +90,23 @@ class DataStdDictPageQueryModel(DataStdDictModel):
     """
     page_num: int = Field(default=1, description='当前页码')
     page_size: int = Field(default=10, description='每页记录数')
-class DataStdDictApprModel(DataStdDictModel):    
+
+
+class DataStdDictApprModel(DataStdDictModel):
     changeType: Optional[str] = Field(default=None, description='变更类型')
     flowId: Optional[str] = Field(default=None, description='审批Id')
     oldInstId: Optional[str] = Field(default=None, description='原始正式id')
     compareId: Optional[str] = Field(default=None, description='原始数据id（用于对比差异）')
-    approStatus: Optional[str] = Field(default=None, description='审批状态（waiting,申请中,pending审核中，succeed,rejected已审核，canceled已取消）')    
+    approStatus: Optional[str] = Field(default=None,
+                                       description='审批状态（waiting,申请中,pending审核中，succeed,rejected已审核，canceled已取消）')
+
+
 class DataStdMainModel(BaseModel):
     """
     标准代码表对应Pydantic模型 (Standard Code Table Pydantic Model)
     """
     model_config = ConfigDict(alias_generator=to_camel, from_attributes=True)
-    
+
     onum: Optional[str] = Field(default=None, description='标准代码Id')
     create_by: Optional[str] = Field(default='', description='创建者')
     create_time: Optional[datetime] = Field(default=None, description='创建时间')
@@ -121,6 +130,8 @@ class DataStdMainModel(BaseModel):
     data_std_src: Optional[str] = Field(default=None, description='标准来源')
     data_clas: Optional[str] = Field(default=None, description='数据类别')
     typical_fld: Optional[str] = Field(default=None, description='典型字段')
+
+
 @as_query
 class DataStdMainPageQueryModel(DataStdMainModel):
     """
@@ -128,9 +139,20 @@ class DataStdMainPageQueryModel(DataStdMainModel):
     """
     page_num: int = Field(default=1, description='当前页码')
     page_size: int = Field(default=10, description='每页记录数')
-class DataStdMainApprModel(DataStdMainModel):    
+
+
+@as_query
+class StdDictNoPageParam(BaseModel):
+    model_config = ConfigDict(alias_generator=to_camel, from_attributes=True)
+
+    queryStr: Optional[str] = Field(default=None, description='查询数据字典名称或代码')
+    ssysCd: Optional[str] = Field(default=None, description='系统名称')
+
+
+class DataStdMainApprModel(DataStdMainModel):
     changeType: Optional[str] = Field(default=None, description='变更类型')
     flowId: Optional[str] = Field(default=None, description='审批Id')
     oldInstId: Optional[str] = Field(default=None, description='原始正式id')
     compareId: Optional[str] = Field(default=None, description='原始数据id（用于对比差异）')
-    approStatus: Optional[str] = Field(default=None, description='审批状态（waiting,申请中,pending审核中，succeed,rejected已审核，canceled已取消）')
+    approStatus: Optional[str] = Field(default=None,
+                                       description='审批状态（waiting,申请中,pending审核中，succeed,rejected已审核，canceled已取消）')

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

@@ -3,6 +3,9 @@ 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, DataStdDictModel, DataStdMainModel,\
+    DataStdMainApprModel, DataStdDictApprModel, DataStdCodeApprModel, DataStdCodePageQueryModel, StdDictNoPageParam
+from utils.common_util import CamelCaseUtil
 from module_admin.entity.vo.datastd_vo import DataStdCodeModel,DeleteDataStdModel,DataStdDictModel,DataStdMainModel,DataStdMainApprModel,DataStdDictApprModel,DataStdCodeApprModel,DataStdCodePageQueryModel
 import uuid
 from module_admin.entity.vo.approval_vo import ApplyModel
@@ -625,7 +628,7 @@ class DataStdService:
         return col_list_result
 
     @classmethod
-    async def get_std_dict_list_no_page_services(cls, query_db: AsyncSession, query: str):
+    async def get_std_dict_list_no_page_services(cls, query_db: AsyncSession, query: StdDictNoPageParam):
         """
         获取列配置列表信息service
 
@@ -1284,7 +1287,7 @@ class DataStdService:
         applyModel.businessId = apprModel.flowId
         applyModel.applicant = apprModel.create_by
         await ApprovalService.apply_services(query_db, applyModel, 'dataStdMain')
-        return CrudResponseModel(is_success=True, message='修改标准成功')    
+        return CrudResponseModel(is_success=True, message='修改标准成功')
     @classmethod
     async def add_std_dict_appr(cls, query_db: AsyncSession, model: DataStdDictModel):
         if not await cls.check_dict_unique_services(query_db, model):
@@ -1304,7 +1307,7 @@ class DataStdService:
         applyModel.businessId = apprModel.flowId
         applyModel.applicant = apprModel.create_by
         await ApprovalService.apply_services(query_db, applyModel, 'dataStdDict')
-        return CrudResponseModel(is_success=True, message='新增标准成功')             
+        return CrudResponseModel(is_success=True, message='新增标准成功')
 
     @classmethod
     async def edit_std_dict_appr(cls, query_db: AsyncSession, model: DataStdDictModel):
@@ -1583,7 +1586,7 @@ class DataStdService:
             "tableData": table_data,
             "children": children
         }
-        
+
     @staticmethod
     async def get_main_import_template_services():
         """
@@ -1598,7 +1601,7 @@ class DataStdService:
             header_list=header_list, selector_header_list=selector_header_list, option_list=option_list
         )
 
-        return binary_data   
+        return binary_data
 
 
 
@@ -1661,13 +1664,13 @@ class DataStdService:
                 try:
                    input_code_no = row.get('code_no')
                    matched_code = next((item for item in std_code_list if item.cd_no == input_code_no), None)
-                   
+
                    if input_code_no and not matched_code:
                        raise HTTPException(status_code=400, detail=f"第 {idx + 2} 行导入失败，代码编号 [{input_code_no}] 在系统中不存在")
                     # 获取来源系统字段
                    input_src_sys = row.get("std_source_system")
                    matched_source = next((ds for ds in data_tree_result if ds.name == input_src_sys or str(ds.id) == str(input_src_sys)), None)
-                   
+
                    # 如果能匹配到系统，则使用 id；否则判断是否为空
                    if matched_source:
                        src_sys_id = matched_source.id
@@ -1675,7 +1678,7 @@ class DataStdService:
                        src_sys_id = 10000
                    else:
                        raise HTTPException(status_code=400, detail=f"第 {idx + 2} 行导入失败，来源系统 [{input_src_sys}] 不存在")
-                  
+
                    # 如果存在，使用对应 onum 作为 cdId
                    cd_id = matched_code.onum if matched_code else None
                    vo = DataStdMainModel(
@@ -1754,7 +1757,7 @@ class DataStdService:
         except Exception as e:
             await query_db.rollback()
             raise ServiceException(message=f"导入失败：{str(e)}")
-         
+
     @staticmethod
     async def get_dict_import_template_services():
         """
@@ -1769,4 +1772,4 @@ class DataStdService:
             header_list=header_list, selector_header_list=selector_header_list, option_list=option_list
         )
 
-        return binary_data          
+        return binary_data

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

@@ -170,7 +170,7 @@ class MetaService:
             fldNullRate=column.fld_null_rate if column else None,
             dataDictId=column.data_dict_id if column else None,
             recStat=column.rec_stat if column else None,
-            updTime=column.upd_time if column else None
+            updTime=column.upd_time.isoformat() if column else None
         )
         return json.dumps(columnDict)
 

vue-fastapi-frontend/src/views/meta/metaInfo/index.vue

@@ -351,7 +351,7 @@
                 </el-tab-pane>
                 <el-tab-pane label="血缘关系" name="bloodRelation">
                   <div style="width: 100%;height: 100%">
-                    <blood-relation :currentTable="currentMetaData" :data="bloodRelation"></blood-relation>
+                    <blood-relation v-if="activeColumnTab === 'bloodRelation'" :currentTable="currentMetaData" :data="bloodRelation"></blood-relation>
                   </div>
                 </el-tab-pane>
                 <el-tab-pane label="存储过程" name="proc">
@@ -851,7 +851,14 @@
   }
   function remoteStddict(query){
     if (query !== ""){
-      let param = {query:query}
+      let param = {queryStr:query}
+      let dbList = databaseList.value[0].children;
+      for (let i = 0; i < dbList.length; i++) {
+        if (currentMetaData.value.ssysCd.toUpperCase() === dbList[i].name.toUpperCase()){
+          param.ssysCd = dbList[i].id + ""
+        }
+      }
+
       listStdDictNoPage(param).then(res=>{
         stddictOptions.value = res.data
       })
@@ -886,7 +893,7 @@
   function changeBloodOption(){
     if (procId.value === -1){
       proxy.$modal.msgWarning("此表暂无血缘，请执行存储过程跑批任务后查看");
-      bloodRelation.value = []
+      bloodRelation.value = {}
     }else {
       getMetaDataBloodRelship(procId.value).then(res=>{
         bloodRelation.value = res.data