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

from datetime import datetime
from fastapi import APIRouter, Depends, Request,UploadFile,File, Query, Body
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, 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 pydantic_validation_decorator import ValidateFields
from utils.common_util import bytes2file_response

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)
    return ResponseUtil.success(model_content=code_page_query_result)


@datastdController.get(
    '/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),
):
    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'))]
)
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)
    return ResponseUtil.success(model_content=code_page_query_result)


@datastdController.get(
    '/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),
):
    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/maplistDict', response_model=PageResponseModel,
    dependencies=[Depends(CheckUserInterfaceAuth('datastd:stdcode:code:list'))]
)
async def get_std_code_map_dict_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_dict_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'))]
                       )
async def get_std_code_appr_list(
        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'))]
)
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'))]
)
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),
):
    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
    add_std_code.upd_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.upd_prsn = current_user.user.user_name
    edit_std_code.upd_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.delete('/stdcode/codeappr',
                          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 = Body(..., embed=True, description="逗号分隔的字典ID字符串"),
        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'))])
@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.upd_prsn = current_user.user.user_name
    code.upd_time = datetime.now()
    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'))])
@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),
):
    try:
        # 调用 service 层的业务逻辑
        await DataStdService.add_std_code_with_items_appr(
            code, code_item_list, query_db, current_user
        )
        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'))])
@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.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'))])
@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),
):
    try:
        await DataStdService.edit_std_code_with_items_appr(
            code, code_item_list, query_db, current_user
        )
        return ResponseUtil.success(msg="标准代码及代码项修改成功，等待审批")
    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'))]
                       )
async def get_std_dict_appr_list(
        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'))]
)
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/listNoPage', response_model=PageResponseModel,
    dependencies=[Depends(CheckUserInterfaceAuth('datastd:stddict:dict:list'))]
)
async def get_std_dict_list_no_page(
        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'))]
)
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.upd_prsn = current_user.user.user_name
    add_std_dict.upd_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.upd_prsn = current_user.user.user_name
    edit_std_dict.upd_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(
    '/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),
):
    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
    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)


@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),
):
    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',
                          dependencies=[Depends(CheckUserInterfaceAuth('datastd:stdmain:main:remove'))])
@Log(title='数据字典', business_type=BusinessType.DELETE)
async def delete_std_dict_Appr(
        request: Request,
        ids: str = Body(..., embed=True, description="逗号分隔的字典ID字符串"),
        query_db: AsyncSession = Depends(get_db),
):
    delete_std_dict_result = await DataStdService.delete_std_dict_Appr(query_db, ids)
    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/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),
):
    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'))]
)
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(data=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.get(
    '/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)
    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.upd_prsn = current_user.user.user_name
    add_std_main.upd_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.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),
):
    add_std_main.create_by = current_user.user.user_name
    add_std_main.create_time = datetime.now()
    add_std_main.upd_prsn = current_user.user.user_name
    add_std_main.upd_time = datetime.now()
    add_std_main_result = await DataStdService.add_std_main_appr(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.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)


@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),
):
    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)


@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)


@datastdController.delete('/stdmain/mainAppr',
                          dependencies=[Depends(CheckUserInterfaceAuth('datastd:stdmain:main:remove'))])
@Log(title='数据标准', business_type=BusinessType.DELETE)
async def delete_std_main_Appr(
        request: Request,
        ids: str = Body(..., embed=True, description="逗号分隔的字典ID字符串"),
        query_db: AsyncSession = Depends(get_db),
):
    delete_std_main_result = await DataStdService.delete_std_main_Appr(query_db, ids)
    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'))])
@Log(title='数据标准', business_type=BusinessType.DELETE)
async def change_std_main_onum(
        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)
    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'))]
)
async def get_code_std_map_list(
        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('获取列配置列表成功')
    return ResponseUtil.success(data=code_page_query_result)


@datastdController.get(
    '/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),
):
    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'))]
)
async def get_code_map_list2(
        request: Request,
        id: str,
        query_db: AsyncSession = Depends(get_db),
        current_user: CurrentUserModel = Depends(LoginService.get_current_user),

):
    code_page_query_result = await DataStdService.get_code_map_list2(request,query_db, id,current_user)
    logger.info('获取列配置列表成功')
    return ResponseUtil.success(data=code_page_query_result)
@datastdController.get(
    '/stdcode/code/mapdictlist/{id}', response_model=PageResponseModel,
    dependencies=[Depends(CheckUserInterfaceAuth('datastd:stdcode:code:list'))]
)
async def get_dict_map_list2(
        request: Request,
        id: str,
        query_db: AsyncSession = Depends(get_db),
):
    code_page_query_result = await DataStdService.get_dict_map_list(request,query_db, id)
    logger.info('获取列配置列表成功')
    return ResponseUtil.success(data=code_page_query_result)
# -----------------------------------------------------导入----------------------------------------------------------------------
@datastdController.post('/stdMain/importTemplate', dependencies=[Depends(CheckUserInterfaceAuth('system:user:import'))])
async def export_std_main_template(request: Request, query_db: AsyncSession = Depends(get_db)):
    main_import_template_result = await DataStdService.get_main_import_template_services()
    logger.info('获取成功')

    return ResponseUtil.streaming(data=bytes2file_response(main_import_template_result))
@datastdController.post('/stdMain/importData', dependencies=[Depends(CheckUserInterfaceAuth('system:user:import'))])
@Log(title='数据标准', business_type=BusinessType.IMPORT)
async def batch_import_stdMain(
    request: Request,
    file: UploadFile = File(...),
    query_db: AsyncSession = Depends(get_db),
    current_user: CurrentUserModel = Depends(LoginService.get_current_user),

):
    batch_import_result = await DataStdService.batch_import_std_services(
        request, query_db, file, current_user
    )
    logger.info(batch_import_result.message)

    return ResponseUtil.success(msg=batch_import_result.message)
@datastdController.post('/stdDict/importData', dependencies=[Depends(CheckUserInterfaceAuth('system:user:import'))])
@Log(title='数据字典', business_type=BusinessType.IMPORT)
async def batch_import_stdDict(
    request: Request,
    file: UploadFile = File(...),
    query_db: AsyncSession = Depends(get_db),
    current_user: CurrentUserModel = Depends(LoginService.get_current_user),

):
    batch_import_result = await DataStdService.batch_import_dict_services(
        request, query_db, file, current_user
    )
    logger.info(batch_import_result.message)

    return ResponseUtil.success(msg=batch_import_result.message)
@datastdController.post('/stdDict/importTemplate', dependencies=[Depends(CheckUserInterfaceAuth('system:user:import'))])
async def export_std_dict_template(request: Request, query_db: AsyncSession = Depends(get_db)):
    dict_import_template_result = await DataStdService.get_dict_import_template_services()
    logger.info('获取成功')

    return ResponseUtil.streaming(data=bytes2file_response(dict_import_template_result))
@datastdController.post("/stdmain/saveStdStatus")
async def save_tsmcb(request: Request,
                     saveSscfModel: DataStdMainModel,
                     query_db: AsyncSession = Depends(get_db),
                     current_user: CurrentUserModel = Depends(LoginService.get_current_user)):
    result = await DataStdService.edit_std_main_status(query_db, saveSscfModel)
    return ResponseUtil.success(msg=result.message)