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

from datetime import datetime
from fastapi import APIRouter, Depends, Request, Form
from pydantic_validation_decorator import ValidateFields
from sqlalchemy.ext.asyncio import AsyncSession
from module_admin.entity.vo.data_ast_content_vo import DataCatalogPageQueryModel, DeleteDataCatalogModel, \
    DataCatalogResponseWithChildren, DataAssetCatalogTreeResponse, DataCatalogMovedRequest, DataCatalogMergeRequest, \
    DataCatalogChild, DataCatalogMoverelRequest
from utils.log_util import logger
from config.enums import BusinessType
from module_admin.annotation.log_annotation import Log
from module_admin.entity.vo.metadata_config_vo import (
    MetadataClasModel,
    MetadataClasPageQueryModel,
    MetadataSecModel,
    MetadataSecPageQueryModel,
    SecuBizConfigModel,
    SecuBizConfigPageQueryModel,
    SecuBizConfigQueryModel,
    SecuBizConfigAddModel,
    SecuBizPermiConfigModel,
    SecuBizPermiConfigBatchModel,
    SecuBizPermiConfigPageQueryModel,
    BatchBusiLabelConfigModel,
    BatchDatatypeLabelConfigModel,
    BatchTableRelaLabelConfigModel,
    TableRelaLabelConfigQuery,
    ColOpTypeLabelPageQueryModel,
    BatchDataopLabelConfigModelVo,
    BatchBusiLabelConfigPageQueryModel,
    BatchDatatypeLabelConfigPageQueryModel,
    DatasecConfigPageQueryModel,
    DatasecConfigModel,
    TaskBizConfigModel,
    TaskBizConfigPageQueryModel,
    TaskBizConfigQueryModel,
    TaskBizConfigAddModel,
)
from module_admin.service.metadata_config_service import MetadataConfigService
from module_admin.service.batch_label_config_service import BatchLabelConfigService
from module_admin.service.datasec_config_service import DatasecConfigService
from config.get_db import get_db
from utils.response_util import ResponseUtil
from utils.page_util import PageResponseModel
from utils.log_util import logger
from module_admin.service.login_service import LoginService
from module_admin.entity.vo.user_vo import CurrentUserModel
from module_admin.entity.vo.metatask_vo import DeleteMetataskModel, OperaMetataskModel
from module_admin.entity.vo.dataSource_vo import ProcessDefinition, ParmScheduleVo, ProcessInstancePage

metadataConfigController = APIRouter(prefix='/metadataConfig')


@metadataConfigController.get('/clas/list', response_model=PageResponseModel)
async def get_metadata_clas_list(
        request: Request,
        query: MetadataClasPageQueryModel = Depends(MetadataClasPageQueryModel.as_query),
        query_db: AsyncSession = Depends(get_db),
):
    result = await MetadataConfigService.get_metadata_clas_list_services(query_db, query, is_page=True)
    logger.info('获取元数据分类列表成功')
    return ResponseUtil.success(model_content=result)


@metadataConfigController.post('/clas')
@ValidateFields(validate_model='add_metadata_clas')
async def add_metadata_clas(
        request: Request,
        add_clas: MetadataClasModel,
        query_db: AsyncSession = Depends(get_db),
        current_user: CurrentUserModel = Depends(LoginService.get_current_user),
):
    add_clas.upd_time = datetime.now()
    add_clas.rec_subm_prsn = current_user.user.user_name

    # 这里没有用户信息，若需要创建人信息可自行补充
    result = await MetadataConfigService.add_metadata_clas_services(query_db, add_clas)
    logger.info(result.message)
    return ResponseUtil.success(msg=result.message)


@metadataConfigController.put('/clas')
@ValidateFields(validate_model='edit_metadata_clas')
async def edit_metadata_clas(
        request: Request,
        edit_clas: MetadataClasModel,
        query_db: AsyncSession = Depends(get_db),
        current_user: CurrentUserModel = Depends(LoginService.get_current_user),
):
    edit_clas.upd_time = datetime.now()
    edit_clas.rec_subm_prsn = current_user.user.user_name
    result = await MetadataConfigService.edit_metadata_clas_services(query_db, edit_clas)
    logger.info(result.message)
    return ResponseUtil.success(msg=result.message)


@metadataConfigController.delete('/clas/{clas_ids}')
async def delete_metadata_clas(
        request: Request,
        clas_ids: str,
        query_db: AsyncSession = Depends(get_db),
):
    result = await MetadataConfigService.delete_metadata_clas_services(query_db, clas_ids)
    logger.info(result.message)
    return ResponseUtil.success(msg=result.message)


@metadataConfigController.get('/clas/{clas_id}', response_model=MetadataClasModel)
async def get_metadata_clas_detail(
        request: Request,
        clas_id: int,
        query_db: AsyncSession = Depends(get_db),
):
    result = await MetadataConfigService.get_metadata_clas_detail_services(query_db, clas_id)
    logger.info(f'获取元数据分类ID={clas_id}详情成功')
    return ResponseUtil.success(data=result)


# ------------------------ MetadataSec 控制接口 ------------------------ #


@metadataConfigController.get('/sec/list', response_model=PageResponseModel)
async def get_metadata_sec_list(
        request: Request,
        query: MetadataSecPageQueryModel = Depends(MetadataSecPageQueryModel.as_query),
        query_db: AsyncSession = Depends(get_db),
):
    result = await MetadataConfigService.get_metadata_sec_list_services(query_db, query, is_page=True)
    logger.info('获取数据安全配置列表成功')
    return ResponseUtil.success(model_content=result)


@metadataConfigController.get('/sec/optionList', response_model=PageResponseModel)
async def get_metadata_sec_list(
        request: Request,
        query_db: AsyncSession = Depends(get_db),
):
    result = await MetadataConfigService.get_metadata_sec_option_list_services(query_db)
    logger.info('获取数据安全配置列表成功')
    return ResponseUtil.success(data=result)


@metadataConfigController.post('/sec')
@ValidateFields(validate_model='add_metadata_sec')
async def add_metadata_sec(
        request: Request,
        add_sec: MetadataSecModel,
        query_db: AsyncSession = Depends(get_db),
        current_user: CurrentUserModel = Depends(LoginService.get_current_user),
):
    add_sec.upd_time = datetime.now()
    add_sec.rec_subm_prsn = current_user.user.user_name

    result = await MetadataConfigService.add_metadata_sec_services(query_db, add_sec)
    logger.info(result.message)
    return ResponseUtil.success(msg=result.message)


@metadataConfigController.put('/sec')
@ValidateFields(validate_model='edit_metadata_sec')
async def edit_metadata_sec(
        request: Request,
        edit_sec: MetadataSecModel,
        query_db: AsyncSession = Depends(get_db),
        current_user: CurrentUserModel = Depends(LoginService.get_current_user),
):
    edit_sec.upd_time = datetime.now()
    edit_sec.rec_subm_prsn = current_user.user.user_name

    result = await MetadataConfigService.edit_metadata_sec_services(query_db, edit_sec)
    logger.info(result.message)
    return ResponseUtil.success(msg=result.message)


@metadataConfigController.delete('/sec/{sec_ids}')
async def delete_metadata_sec(
        request: Request,
        sec_ids: str,
        query_db: AsyncSession = Depends(get_db),
):
    result = await MetadataConfigService.delete_metadata_sec_services(query_db, sec_ids)
    logger.info(result.message)
    return ResponseUtil.success(msg=result.message)


@metadataConfigController.get('/sec/{sec_id}', response_model=MetadataSecModel)
async def get_metadata_sec_detail(
        request: Request,
        sec_id: str,
        query_db: AsyncSession = Depends(get_db),
):
    result = await MetadataConfigService.get_metadata_sec_detail_services(query_db, sec_id)
    logger.info(f'获取数据安全配置 onum={sec_id} 详情成功')
    return ResponseUtil.success(data=result)


# ---------- t_secu_biz_config 接口（改造后） ----------


@metadataConfigController.get('/bizConfig/list', response_model=PageResponseModel)
async def get_biz_config_list(
        request: Request,
        query: SecuBizConfigQueryModel = Depends(SecuBizConfigPageQueryModel.as_query),
        db: AsyncSession = Depends(get_db),
):
    result = await MetadataConfigService.get_biz_config_list_services(db, query, is_page=True)
    return ResponseUtil.success(model_content=result)


@metadataConfigController.get('/bizConfig/listall')
async def get_biz_config_list_all(
        request: Request,
        query: SecuBizConfigQueryModel = Depends(SecuBizConfigPageQueryModel.as_query),
        db: AsyncSession = Depends(get_db),
):
    result = await MetadataConfigService.get_biz_config_list_services(db, query, is_page=False)
    return ResponseUtil.success(data=result)


@metadataConfigController.post('/bizConfig/add')
@ValidateFields(['bizModule', 'configType', 'data_sec_lvl', 'applyType'])
async def add_biz_config(
        item: SecuBizConfigAddModel,
        db: AsyncSession = Depends(get_db),
        current_user: CurrentUserModel = Depends(LoginService.get_current_user),
):
    item.create_by = current_user.user.user_name
    item.create_time = datetime.now()
    result = await MetadataConfigService.add_biz_config_services(db, item)
    return ResponseUtil.success(msg=result.message)


@metadataConfigController.post('/bizConfig/edit')
@ValidateFields(['onum'])
async def edit_biz_config(
        item: SecuBizConfigAddModel,
        db: AsyncSession = Depends(get_db),
        current_user: CurrentUserModel = Depends(LoginService.get_current_user),
):
    item.update_by = current_user.user.user_name
    item.update_time = datetime.now()
    result = await MetadataConfigService.edit_biz_config_services(db, item)
    return ResponseUtil.success(msg=result.message)


@metadataConfigController.delete('/bizConfig/delete')
async def delete_biz_config(onums: str, db: AsyncSession = Depends(get_db)):
    result = await MetadataConfigService.delete_biz_config_services(db, onums)
    return ResponseUtil.success(msg=result.message)


@metadataConfigController.get('/bizConfig/detail')
async def get_biz_config_detail(onum: str, db: AsyncSession = Depends(get_db)):
    data = await MetadataConfigService.get_biz_config_detail_services(db, onum)
    return ResponseUtil.success(data=data)


# ---------- t_secu_biz_permi_config 接口 ----------


@metadataConfigController.get('/bizPermiConfig/list', response_model=PageResponseModel)
async def get_biz_permi_config_list(
        request: Request,
        query: SecuBizConfigModel = Depends(SecuBizPermiConfigPageQueryModel.as_query),
        query_db: AsyncSession = Depends(get_db),
):
    result = await MetadataConfigService.get_biz_permi_config_list_services(query_db, query, is_page=True)
    return ResponseUtil.success(model_content=result)


@metadataConfigController.post('/bizPermiConfig/add')
async def add_biz_permi_config(
        item: SecuBizPermiConfigBatchModel,
        db: AsyncSession = Depends(get_db),
        current_user: CurrentUserModel = Depends(LoginService.get_current_user),
):
    create_by = current_user.user.user_name
    create_time = datetime.now()
    result = await MetadataConfigService.add_biz_permi_config_services(db, item, create_by, create_time)
    return ResponseUtil.success(msg=result.message)


@metadataConfigController.post('/bizPermiConfig/edit')
@ValidateFields(['onum'])
async def edit_biz_permi_config(
        item: SecuBizPermiConfigModel,
        db: AsyncSession = Depends(get_db),
        current_user: CurrentUserModel = Depends(LoginService.get_current_user),
):
    item.update_by = current_user.user.user_name
    item.update_time = datetime.now()

    result = await MetadataConfigService.edit_biz_permi_config_services(db, item)
    return ResponseUtil.success(msg=result.message)


@metadataConfigController.delete('/bizPermiConfig/delete')
async def delete_biz_permi_config(onums: str, db: AsyncSession = Depends(get_db)):
    result = await MetadataConfigService.delete_biz_permi_config_services(db, onums)
    return ResponseUtil.success(msg=result.message)


@metadataConfigController.get('/bizPermiConfig/detail')
async def get_biz_permi_config_detail(onum: str, db: AsyncSession = Depends(get_db)):
    data = await MetadataConfigService.get_biz_permi_config_detail_services(db, onum)
    return ResponseUtil.success(data=data)


@metadataConfigController.get('/bizConfigRela/list/{bizOnum}')
async def get_biz_rela_config_list(
        bizOnum: int,
        query_db: AsyncSession = Depends(get_db),
):
    ai_chat_list_result = await MetadataConfigService.get_biz_config_rela_list_services(query_db, bizOnum)
    logger.info('获取成功')
    return ResponseUtil.success(data=ai_chat_list_result)


@metadataConfigController.get('/busiLabel/list', response_model=PageResponseModel)
async def get_busi_label_list(
        request: Request,
        query: BatchBusiLabelConfigModel = Depends(BatchBusiLabelConfigPageQueryModel.as_query),
        query_db: AsyncSession = Depends(get_db),
):
    result = await BatchLabelConfigService.get_busi_list_services(query_db, query, False)
    logger.info('获取业务标签配置列表成功')
    return ResponseUtil.success(data=result)


@metadataConfigController.get('/colOpTypeLabel/list', response_model=PageResponseModel)
async def get_col_optype_label_list(
        request: Request,
        query: ColOpTypeLabelPageQueryModel = Depends(ColOpTypeLabelPageQueryModel.as_query),
        query_db: AsyncSession = Depends(get_db),
):
    result = await BatchLabelConfigService.get_col_optype_list_services(query_db, query, False)
    logger.info('获取业务标签配置列表成功')
    return ResponseUtil.success(data=result)


@metadataConfigController.post('/busiLabel')
@ValidateFields(validate_model='add_busi_label')
async def add_busi_label(
        request: Request,
        model: BatchBusiLabelConfigModel,
        query_db: AsyncSession = Depends(get_db),
        current_user: CurrentUserModel = Depends(LoginService.get_current_user),

):
    model.upd_by = current_user.user.user_name
    model.upd_time = datetime.now()
    result = await BatchLabelConfigService.add_busi_services(query_db, model)
    logger.info(result.message)
    return ResponseUtil.success(msg=result.message)


@metadataConfigController.put('/busiLabel')
@ValidateFields(validate_model='edit_busi_label')
async def edit_busi_label(
        request: Request,
        model: BatchBusiLabelConfigModel,
        query_db: AsyncSession = Depends(get_db),
        current_user: CurrentUserModel = Depends(LoginService.get_current_user),

):
    model.upd_by = current_user.user.user_name
    model.upd_time = datetime.now()
    result = await BatchLabelConfigService.edit_busi_services(query_db, model)
    logger.info(result.message)
    return ResponseUtil.success(msg=result.message)


@metadataConfigController.delete('/busiLabel/{onum_list}')
async def delete_busi_label(
        request: Request,
        onum_list: str,
        query_db: AsyncSession = Depends(get_db),
):
    result = await BatchLabelConfigService.delete_busi_services(query_db, onum_list)
    logger.info(result.message)
    return ResponseUtil.success(msg=result.message)


@metadataConfigController.get('/busiLabel/{onum}', response_model=BatchBusiLabelConfigModel)
async def get_busi_label_detail(
        request: Request,
        onum: str,
        query_db: AsyncSession = Depends(get_db),
):
    result = await BatchLabelConfigService.get_busi_detail_services(query_db, onum)
    logger.info(f'获取业务标签配置 onum={onum} 详情成功')
    return ResponseUtil.success(data=result)


@metadataConfigController.post('/dataopLabel')
@ValidateFields(validate_model='add_dataop_label')
async def add_dataop_label(
        request: Request,
        model: BatchDataopLabelConfigModelVo,
        query_db: AsyncSession = Depends(get_db),
        current_user: CurrentUserModel = Depends(LoginService.get_current_user),
):
    model.upd_by = current_user.user.user_name
    model.upd_time = datetime.now()
    result = await BatchLabelConfigService.add_dataop_services(query_db, model)
    logger.info(result.message)
    return ResponseUtil.success(msg=result.message)


@metadataConfigController.put('/dataopLabel')
@ValidateFields(validate_model='edit_dataop_label')
async def edit_dataop_label(
        request: Request,
        model: BatchDataopLabelConfigModelVo,
        query_db: AsyncSession = Depends(get_db),
        current_user: CurrentUserModel = Depends(LoginService.get_current_user),

):
    model.upd_by = current_user.user.user_name
    model.upd_time = datetime.now()
    result = await BatchLabelConfigService.edit_dataop_services(query_db, model)
    logger.info(result.message)
    return ResponseUtil.success(msg=result.message)


@metadataConfigController.delete('/dataopLabel/{onum_list}')
async def delete_dataop_label(
        request: Request,
        onum_list: str,
        query_db: AsyncSession = Depends(get_db),
):
    result = await BatchLabelConfigService.delete_dataop_services(query_db, onum_list)
    logger.info(result.message)
    return ResponseUtil.success(msg=result.message)


@metadataConfigController.get('/datatypeLabel/list', response_model=PageResponseModel)
async def get_datatype_label_list(
        request: Request,
        query: BatchDatatypeLabelConfigModel = Depends(BatchDatatypeLabelConfigPageQueryModel.as_query),
        query_db: AsyncSession = Depends(get_db),

):
    result = await BatchLabelConfigService.get_datatype_list_services(query_db, query, False)
    logger.info('获取数据类型标签配置列表成功')
    return ResponseUtil.success(data=result)


@metadataConfigController.get('/tableRelaLabel/list', response_model=PageResponseModel)
async def get_tableRela_label_list(
        request: Request,
        query: TableRelaLabelConfigQuery = Depends(TableRelaLabelConfigQuery.as_query),
        query_db: AsyncSession = Depends(get_db),

):
    result = await BatchLabelConfigService.get_table_rel_list_services(query_db, query, False)
    logger.info('获取数据类型标签配置列表成功')
    return ResponseUtil.success(data=result)


@metadataConfigController.post('/datatypeLabel')
@ValidateFields(validate_model='add_datatype_label')
async def add_datatype_label(
        request: Request,
        model: BatchDatatypeLabelConfigModel,
        query_db: AsyncSession = Depends(get_db),
        current_user: CurrentUserModel = Depends(LoginService.get_current_user),
):
    model.upd_by = current_user.user.user_name
    model.upd_time = datetime.now()

    result = await BatchLabelConfigService.add_datatype_services(query_db, model)
    logger.info(result.message)
    return ResponseUtil.success(msg=result.message)


@metadataConfigController.post('/tableRelaLabel')
@ValidateFields(validate_model='add_datatype_label')
async def add_table_rela_label(
        request: Request,
        model: BatchTableRelaLabelConfigModel,
        query_db: AsyncSession = Depends(get_db),
        current_user: CurrentUserModel = Depends(LoginService.get_current_user),
):
    model.upd_by = current_user.user.user_name
    model.upd_time = datetime.now()

    result = await BatchLabelConfigService.add_table_rela_services(query_db, model)
    logger.info(result.message)
    return ResponseUtil.success(msg=result.message)


@metadataConfigController.put('/datatypeLabel')
@ValidateFields(validate_model='edit_datatype_label')
async def edit_datatype_label(
        request: Request,
        model: BatchDatatypeLabelConfigModel,
        query_db: AsyncSession = Depends(get_db),
        current_user: CurrentUserModel = Depends(LoginService.get_current_user),

):
    model.upd_by = current_user.user.user_name
    model.upd_time = datetime.now()
    result = await BatchLabelConfigService.edit_datatype_services(query_db, model)
    logger.info(result.message)
    return ResponseUtil.success(msg=result.message)


@metadataConfigController.put('/tableRelaLabel')
@ValidateFields(validate_model='edit_datatype_label')
async def edit_table_rela_label(
        request: Request,
        model: BatchTableRelaLabelConfigModel,
        query_db: AsyncSession = Depends(get_db),
        current_user: CurrentUserModel = Depends(LoginService.get_current_user),
):
    model.upd_by = current_user.user.user_name
    model.upd_time = datetime.now()
    result = await BatchLabelConfigService.edit_table_rela_services(query_db, model)
    logger.info(result.message)
    return ResponseUtil.success(msg=result.message)


@metadataConfigController.delete('/datatypeLabel/{onum_list}')
async def delete_datatype_label(
        request: Request,
        onum_list: str,
        query_db: AsyncSession = Depends(get_db),
):
    result = await BatchLabelConfigService.delete_datatype_services(query_db, onum_list)
    logger.info(result.message)
    return ResponseUtil.success(msg=result.message)


@metadataConfigController.delete('/tableRelaLabel/{onum_list}')
async def delete_datatype_label(
        request: Request,
        onum_list: str,
        query_db: AsyncSession = Depends(get_db),
):
    result = await BatchLabelConfigService.delete_table_rela_services(query_db, onum_list)
    logger.info(result.message)
    return ResponseUtil.success(msg=result.message)


@metadataConfigController.get('/datatypeLabel/{onum}', response_model=BatchDatatypeLabelConfigModel)
async def get_datatype_label_detail(
        request: Request,
        onum: str,
        query_db: AsyncSession = Depends(get_db),
):
    result = await BatchLabelConfigService.get_datatype_detail_services(query_db, onum)
    logger.info(f'获取数据类型标签配置 onum={onum} 详情成功')
    return ResponseUtil.success(data=result)


@metadataConfigController.get("/datasecConfig/list", response_model=PageResponseModel)
async def get_datasec_config_list(
        request: Request,
        query: DatasecConfigModel = Depends(DatasecConfigPageQueryModel.as_query),
        query_db: AsyncSession = Depends(get_db),
):
    result = await DatasecConfigService.get_datasec_list_services(query_db, query, True)
    logger.info("获取数据安全参数配置列表成功")
    return ResponseUtil.success(model_content=result)


@metadataConfigController.post("/datasecConfig")
@ValidateFields(validate_model="add_datasec_config")
async def add_datasec_config(
        request: Request,
        model: DatasecConfigModel,
        query_db: AsyncSession = Depends(get_db),
        current_user: CurrentUserModel = Depends(LoginService.get_current_user),
):
    model.create_by = current_user.user.user_name
    model.create_time = datetime.now()
    result = await DatasecConfigService.add_datasec_services(query_db, model, current_user, request)
    logger.info(result.message)
    return ResponseUtil.success(msg=result.message)


@metadataConfigController.put("/datasecConfig")
@ValidateFields(validate_model="edit_datasec_config")
async def edit_datasec_config(
        request: Request,
        model: DatasecConfigModel,
        query_db: AsyncSession = Depends(get_db),
        current_user: CurrentUserModel = Depends(LoginService.get_current_user),
):
    model.update_by = current_user.user.user_name
    model.update_time = datetime.now()
    result = await DatasecConfigService.edit_datasec_services(query_db, model, current_user, request)
    logger.info(result.message)
    return ResponseUtil.success(msg=result.message)


# @metadataConfigController.delete("/datasecConfig/{onum_list}")
# async def delete_datasec_config(
#     request: Request,
#     onum_list: str,
#     query_db: AsyncSession = Depends(get_db),
# ):
#     result = await DatasecConfigService.delete_datasec_services(query_db, onum_list)
#     logger.info(result.message)
#     return ResponseUtil.success(msg=result.message)
@metadataConfigController.delete('/datasecConfig/{metatask_ids}/{ds_ids}')
async def delete_system_config(request: Request, metatask_ids: str, ds_ids: str,
                               query_db: AsyncSession = Depends(get_db),
                               current_user: CurrentUserModel = Depends(LoginService.get_current_user)):
    delete_config = DeleteMetataskModel(metatask_ids=metatask_ids, ds_ids=ds_ids)
    delete_config_result = await DatasecConfigService.delete_datasec_services(request, query_db, delete_config,
                                                                              current_user)
    logger.info(delete_config_result.message)

    return ResponseUtil.success(msg=delete_config_result.message)


@metadataConfigController.get("/datasecConfig/{onum}", response_model=DatasecConfigModel)
async def get_datasec_config_detail(
        request: Request,
        onum: int,
        query_db: AsyncSession = Depends(get_db),
):
    result = await DatasecConfigService.get_datasec_detail_services(query_db, onum)
    logger.info(f"获取数据安全参数配置 onum={onum} 详情成功")
    return ResponseUtil.success(data=result)


@metadataConfigController.put('/upOrdown')
async def up_or_down_meta_metatask(
        request: Request,
        DownOrUpdate: OperaMetataskModel,
        query_db: AsyncSession = Depends(get_db),
        current_user: CurrentUserModel = Depends(LoginService.get_current_user),
):
    edit_config_result = await DatasecConfigService.up_or_down_metatask_services(request, query_db, current_user,
                                                                                 DownOrUpdate.id, DownOrUpdate.type)
    logger.info(edit_config_result.message)
    return ResponseUtil.success(msg=edit_config_result.message)


# 元数据任务调度
@metadataConfigController.put('/DS')
async def DS_meta_metatask(
        request: Request,
        process: ParmScheduleVo,
        query_db: AsyncSession = Depends(get_db),
        current_user: CurrentUserModel = Depends(LoginService.get_current_user)
):
    edit_config_result = await DatasecConfigService.ds_metatask_services(request, query_db, process, current_user)

    return ResponseUtil.success(msg=edit_config_result)


@metadataConfigController.get('/DS/{id}')
async def DS_meta_metatask_detail(
        request: Request,
        id: int,
        query_db: AsyncSession = Depends(get_db),
        current_user: CurrentUserModel = Depends(LoginService.get_current_user)
):
    process = ParmScheduleVo()
    process.processDefinitionCode = id
    edit_config_result = await DatasecConfigService.ds_metatask_detail(request, query_db, process, current_user)

    return ResponseUtil.success(data=edit_config_result)


@metadataConfigController.delete('/DS')
async def DS_meta_metatask_delete(
        request: Request,
        process: ParmScheduleVo,
        query_db: AsyncSession = Depends(get_db),
        current_user: CurrentUserModel = Depends(LoginService.get_current_user)
):
    edit_config_result = await DatasecConfigService.ds_metatask_delete(request, query_db, process, current_user)

    return ResponseUtil.success(msg=edit_config_result)


# ----------元数据标签调度任务 ----------

@metadataConfigController.get('/taskBizConfig/list', response_model=PageResponseModel)
async def get_task_biz_config_list(
        request: Request,
        query: TaskBizConfigQueryModel = Depends(TaskBizConfigPageQueryModel.as_query),
        db: AsyncSession = Depends(get_db),
):
    result = await MetadataConfigService.get_task_biz_config_list_services(db, query, is_page=True)
    return ResponseUtil.success(model_content=result)


@metadataConfigController.get('/taskBizConfig/listall')
async def get_task_biz_config_list_all(
        request: Request,
        query: TaskBizConfigQueryModel = Depends(TaskBizConfigPageQueryModel.as_query),
        db: AsyncSession = Depends(get_db),
):
    result = await MetadataConfigService.get_task_biz_config_list_services(db, query, is_page=False)
    return ResponseUtil.success(data=result)


@metadataConfigController.post('/taskBizConfig/add')
@ValidateFields(['bizModule', 'configType', 'data_sec_lvl', 'applyType'])
async def add_task_biz_config(
        request: Request,
        item: TaskBizConfigAddModel,
        db: AsyncSession = Depends(get_db),
        current_user: CurrentUserModel = Depends(LoginService.get_current_user),
):
    item.create_by = current_user.user.user_name
    item.create_time = datetime.now()
    result = await MetadataConfigService.add_task_biz_config_services(db, item, current_user, request)
    return ResponseUtil.success(msg=result.message)


@metadataConfigController.post('/taskBizConfig/edit')
@ValidateFields(['onum'])
async def edit_task_biz_config(
        request: Request,
        item: TaskBizConfigAddModel,
        db: AsyncSession = Depends(get_db),
        current_user: CurrentUserModel = Depends(LoginService.get_current_user),
):
    item.update_by = current_user.user.user_name
    item.update_time = datetime.now()
    result = await MetadataConfigService.edit_task_biz_config_services(db, item, current_user, request)
    return ResponseUtil.success(msg=result.message)


# @metadataConfigController.delete('/taskBizConfig/delete')
# async def delete_task_biz_config(onums: str, db: AsyncSession = Depends(get_db)):
#     result = await MetadataConfigService.delete_task_biz_config_services(db, onums)
#     return ResponseUtil.success(msg=result.message)
@metadataConfigController.delete('/taskBizConfig/{metatask_ids}/{ds_ids}')
async def delete_task_biz_config(request: Request, metatask_ids: str, ds_ids: str,
                                 query_db: AsyncSession = Depends(get_db),
                                 current_user: CurrentUserModel = Depends(LoginService.get_current_user)):
    delete_config = DeleteMetataskModel(metatask_ids=metatask_ids, ds_ids=ds_ids)
    delete_config_result = await MetadataConfigService.delete_task_biz_config_services(request, query_db, delete_config,
                                                                                       current_user)
    logger.info(delete_config_result.message)
    return ResponseUtil.success(msg=delete_config_result.message)


@metadataConfigController.get('/taskBizConfig/detail')
async def get_task_biz_config_detail(onum: str, db: AsyncSession = Depends(get_db)):
    data = await MetadataConfigService.get_task_biz_config_detail_services(db, onum)
    return ResponseUtil.success(data=data)


@metadataConfigController.get('/taskBizConfigRela/list/{bizOnum}')
async def get_task_biz_rela_config_list(
        bizOnum: int,
        query_db: AsyncSession = Depends(get_db),
):
    ai_chat_list_result = await MetadataConfigService.get_task_biz_config_rela_list_services(query_db, bizOnum)
    logger.info('获取成功')
    return ResponseUtil.success(data=ai_chat_list_result)


@metadataConfigController.put('/taskBiz/upOrdown')
async def task_biz_up_or_down_meta_metatask(
        request: Request,
        DownOrUpdate: OperaMetataskModel,
        query_db: AsyncSession = Depends(get_db),
        current_user: CurrentUserModel = Depends(LoginService.get_current_user),
):
    edit_config_result = await MetadataConfigService.up_or_down_metatask_services(request, query_db, current_user,
                                                                                  DownOrUpdate.id, DownOrUpdate.type)
    logger.info(edit_config_result.message)
    return ResponseUtil.success(msg=edit_config_result.message)


@metadataConfigController.put('/taskBiz/DS')
async def task_biz_DS_meta_metatask(
        request: Request,
        process: ParmScheduleVo,
        query_db: AsyncSession = Depends(get_db),
        current_user: CurrentUserModel = Depends(LoginService.get_current_user)
):
    edit_config_result = await MetadataConfigService.ds_metatask_services(request, query_db, process, current_user)

    return ResponseUtil.success(msg=edit_config_result)


@metadataConfigController.delete('/taskBiz/DS')
async def task_biz_DS_meta_metatask_delete(
        request: Request,
        process: ParmScheduleVo,
        query_db: AsyncSession = Depends(get_db),
        current_user: CurrentUserModel = Depends(LoginService.get_current_user)
):
    edit_config_result = await MetadataConfigService.ds_metatask_delete(request, query_db, process, current_user)

    return ResponseUtil.success(msg=edit_config_result)


# --------------------------------------------------------------------------------标签树---------------------------------------------------
@metadataConfigController.get(
    '/cata/list', response_model=PageResponseModel)
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 MetadataConfigService.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)


@metadataConfigController.delete('/cata/{content_onums}',
                                 )
@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 MetadataConfigService.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)


@metadataConfigController.put('/cata/removerel')
@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 MetadataConfigService.removerel_data_ast_catalog_services(query_db, removerel_catalog)
    logger.info(removerel_result.message)

    # 返回标准化响应
    return ResponseUtil.success()


@metadataConfigController.put('/cata/moved')
@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 MetadataConfigService.moved_catalog_instr_services(query_db, moved_catalog)
    logger.info(moved_result.message)

    # 返回标准化响应
    return ResponseUtil.success(
        msg=moved_result.message
    )


@metadataConfigController.put('/cata/merge')
@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 MetadataConfigService.merge_catalog_instr_services(query_db, merge_catalog)
    logger.info(merge_result.message)

    # 返回标准化响应
    return ResponseUtil.success(
        msg=merge_result.message
    )


@metadataConfigController.put('/cata/moverel')
@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 MetadataConfigService.moverel_data_ast_catalog_services(query_db, moverel_catalog)
    logger.info(moverel_result.message)

    # 返回标准化响应
    return ResponseUtil.success()


@metadataConfigController.put('/cata/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 MetadataConfigService.edit_catalog_child_services(query_db, edit_catalog)
    logger.info(edit_result.message)

    # 返回标准化响应
    return ResponseUtil.success(
        msg=edit_result.message
    )


@metadataConfigController.post('/cata')
@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 MetadataConfigService.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 MetadataConfigService.edit_catalog_leaf_services(query_db, supr_content_onum, 0)
    else:
        logger.error(add_result.message)
    # 返回标准化响应
    return ResponseUtil.success(
        msg=add_result.message
    )