from datetime import datetime from fastapi import APIRouter, Depends, Request from sqlalchemy.ext.asyncio import AsyncSession from config.enums import BusinessType 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,DataStdDictModel,DataStdDictPageQueryModel,DataStdMainModel,DataStdMainPageQueryModel 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 pydantic_validation_decorator import ValidateFields datastdController = APIRouter(prefix='/datastd', dependencies=[Depends(LoginService.get_current_user)]) #标准代码相关API @datastdController.get( '/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), ): code_page_query_result = await DataStdService.get_std_code_list_services(query_db, code_page_query, is_page=True) logger.info('获取列配置列表成功') return ResponseUtil.success(model_content=code_page_query_result) @datastdController.get( '/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), ): code_page_query_result = await DataStdService.get_std_code_map_list_services(query_db, code_page_query, is_page=True) logger.info('获取列配置列表成功') return ResponseUtil.success(model_content=code_page_query_result) @datastdController.get( '/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.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), ): add_std_code.create_by = current_user.user.user_name add_std_code.create_time = datetime.now() add_std_code.update_by = current_user.user.user_name add_std_code.update_time = datetime.now() add_std_code_result = await DataStdService.add_std_code_services(request, query_db, add_std_code) logger.info(add_std_code_result.message) return ResponseUtil.success(msg=add_std_code_result.message) @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), ): edit_std_code.update_by = current_user.user.user_name edit_std_code.update_time = datetime.now() edit_std_code_result = await DataStdService.edit_std_code_services(request, query_db, edit_std_code) logger.info(edit_std_code_result.message) return ResponseUtil.success(msg=edit_std_code_result.message) @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), ): 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.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), ): # 设置标准代码的创建和更新时间 code.create_by = current_user.user.user_name code.create_time = datetime.now() code.update_by = current_user.user.user_name code.update_time = datetime.now() code.sys_name='公司级' if 'company'==code.code_type else code.sys_name # 传递给服务层，处理标准代码和代码项的添加 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.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), ): # 设置标准代码的创建和更新时间 code.sys_name='公司级' if 'company'==code.code_type else code.sys_name code.update_by = current_user.user.user_name code.update_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.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) # ----------------------------------------------------------------标准目录---------------------------------------------------------------------------------------------------- @datastdController.get( '/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), ): #设置字段 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) 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" ) async def get_data_asset_catalog_tree(query_db: AsyncSession = Depends(get_db)): try: logger.debug("开始获取数据资产目录树") catalog_tree_result = await DataStdService.get_data_asset_catalog_tree_services(query_db) logger.info('数据资产树获取成功') return ResponseUtil.success(data=catalog_tree_result) except Exception as e: 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), ): # 设置字段 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) # 新增成功后，更新新增数据目录的父亲节点的叶子标志为0 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) else: logger.error(add_result.message) # 返回标准化响应 return ResponseUtil.success( 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), ): # 设置审计字段 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) # 返回标准化响应 return ResponseUtil.success( msg=edit_result.message ) @datastdController.put('/cata/moved', dependencies=[Depends(CheckUserInterfaceAuth('system:data_catalog:edit'))]) @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), ): # 调用服务层方法 moved_result = await DataStdService.moved_catalog_instr_services(query_db, moved_catalog) logger.info(moved_result.message) # 返回标准化响应 return ResponseUtil.success( msg=moved_result.message ) @datastdController.put('/cata/merge', dependencies=[Depends(CheckUserInterfaceAuth('system:data_catalog:edit'))]) @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), ): # 调用服务层方法 merge_result = await DataStdService.merge_catalog_instr_services(query_db, merge_catalog) logger.info(merge_result.message) # 返回标准化响应 return ResponseUtil.success( msg=merge_result.message ) @datastdController.put('/cata/removerel', dependencies=[Depends(CheckUserInterfaceAuth('system:data_catalog:edit'))]) @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), ): # 调用服务层方法 removerel_result = await DataStdService.removerel_data_ast_catalog_services(query_db, removerel_catalog) logger.info(removerel_result.message) # 返回标准化响应 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), ): # 调用服务层方法 moverel_result = await DataStdService.moverel_data_ast_catalog_services(query_db, moverel_catalog) logger.info(moverel_result.message) # 返回标准化响应 return ResponseUtil.success() @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) 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'))] ) async def get_std_main_list( 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/selectlist', response_model=PageResponseModel, dependencies=[Depends(CheckUserInterfaceAuth('datastd:stdmain:main:list'))] ) async def get_std_main_select_list( request: Request, main_page_query: DataStdMainPageQueryModel = Depends(DataStdMainPageQueryModel.as_query), 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(model_content=main_query_result) @datastdController.get( '/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.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), ): add_std_main.create_by = current_user.user.user_name add_std_main.create_time = datetime.now() add_std_main.update_by = current_user.user.user_name add_std_main.update_time = datetime.now() add_std_main_result = await DataStdService.add_std_main(query_db, add_std_main) logger.info(add_std_main_result.message) return ResponseUtil.success(msg=add_std_main_result.message) @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), ): edit_std_main.update_by = current_user.user.user_name edit_std_main.update_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) @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), ): 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)