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

import json
import uuid

from module_admin.entity.vo.meta_vo import MetaPageObject, MetaColObject, SuppleModel
from module_admin.entity.do.meta_do import MetadataSuppInfo, MetadataFldSuppInfo, MetadataSuppInfoVett, \
    MetadataFldSuppInfoVett, MetadataExtractInfo, MetadataFldTabExtractInfo
from module_admin.dao.meta_dao import MetaDao
from datetime import datetime
from module_admin.entity.vo.user_vo import CurrentUserModel
from module_admin.entity.vo.approval_vo import ApplyModel
from sqlalchemy.ext.asyncio import AsyncSession
from exceptions.exception import ServiceException, ServiceWarning
from utils.pwd_util import *
from utils.common_util import *
from utils.log_util import logger
from module_admin.service.login_service import LoginService
from module_admin.service.approval_service import ApprovalService

from module_admin.entity.vo.common_vo import CrudResponseModel
from module_admin.entity.vo.user_vo import CurrentUserModel
from utils.common_util import CamelCaseUtil


class MetaService:

    @classmethod
    async def get_meta_list_services(cls, result_db: AsyncSession, query_object: MetaPageObject,
                                     current_user: CurrentUserModel):
        """
        获取元信息service
        :param result_db: orm对象
        :param query_object: 查询参数对象
        :param data_scope_sql: 数据权限对应的查询sql语句
        :return: 用户列表信息对象
        """
        # print("********")
        # 0,正常,1已发布，2审核中，3已审核，4已作废
        if 'admin' in current_user.roles:
            meta_rel_list = await MetaDao.get_meta_rel_list(result_db, query_object)
            return meta_rel_list
        else:
            # meta_rel_list = MetaDao.get_meta_rel_list(result_db, query_object, data_scope_sql)
            return None

    @classmethod
    async def get_meta_col_list_services(cls, result_db: AsyncSession, query_object: MetaColObject):
        meta_result = await MetaDao.get_meta_col_list(result_db, query_object)
        return cls.convert_json_keys(meta_result)

    @classmethod
    async def get_meta_clas_list_services(cls, result_db: AsyncSession):
        result = await MetaDao.get_meta_clas_list(result_db)
        return CamelCaseUtil.transform_result(result)

    @classmethod
    async def meta_supp(cls, result_db: AsyncSession, supple: SuppleModel, current_user: CurrentUserModel):
        # 0,暂存 waiting,申请中,pending审核中，succeed,rejected已审核，canceled已取消
        hasTable = await MetaDao.get_lastest_meta_data_supp_vett(result_db, supple.ssys_cd, supple.mdl_name,
                                                                 supple.tab_eng_name)
        oldTable = await MetaDao.get_supp_table_by_vett(supple.ssys_cd, supple.mdl_name, supple.tab_eng_name, result_db)
        tableInfo = await MetaDao.get_meta_table(supple.ssys_cd, supple.mdl_name, supple.tab_eng_name, result_db)
        tableOnum = uuid.uuid4()
        if hasTable is not None:
            if hasTable.apply_status == 'waiting':
                raise ServiceException(message=f'所补录对象已存在补录待审核记录，请等待审批完成或撤回申请后，再行补录')
            if hasTable.apply_status == 'pending':
                raise ServiceException(message=f'所补录对象已存在待审核记录，请等待审批完成后，再行补录')
        applyTime = datetime.now().strftime("%Y-%m-%d %H:%M:%S")
        suppTableInfo = MetadataSuppInfoVett()
        suppTableInfo.onum = tableOnum
        suppTableInfo.ssys_cd = supple.ssys_cd
        suppTableInfo.mdl_name = supple.mdl_name
        suppTableInfo.tab_eng_name = supple.tab_eng_name
        suppTableInfo.tab_crrct_name = supple.tab_crrct_name
        suppTableInfo.tab_desc = supple.tab_desc
        suppTableInfo.pic = supple.pic
        suppTableInfo.gov_flag = supple.gov_flag
        suppTableInfo.tab_clas = supple.tab_clas
        suppTableInfo.rec_subm_prsn = current_user.user.user_name
        suppTableInfo.apply_time = applyTime
        suppTableInfo.apply_status = 'waiting'
        suppTableInfo.oldTableData = cls.castToTableStr(oldTable, tableInfo)
        await MetaDao.insertMetadataSuppInfoVett(suppTableInfo, result_db)
        if supple.columnInfo is not None and len(supple.columnInfo) > 0:
            for column in supple.columnInfo:
                oldColumn = await MetaDao.get_supp_column_by_columnInfo(supple.ssys_cd, supple.mdl_name,
                                                                        supple.tab_eng_name,
                                                                        column.fld_eng_name, result_db)
                columnInfo = await MetaDao.get_meta_column(supple.ssys_cd, supple.mdl_name, supple.tab_eng_name,
                                                           column.fld_eng_name, result_db)
                suppColumnInfo = MetadataFldSuppInfoVett()
                suppColumnInfo.onum = uuid.uuid4()
                suppColumnInfo.ssys_cd = supple.ssys_cd
                suppColumnInfo.mdl_name = supple.mdl_name
                suppColumnInfo.tab_eng_name = supple.tab_eng_name
                suppColumnInfo.fld_eng_name = column.fld_eng_name
                suppColumnInfo.fld_crrct_name = column.fld_crrct_name
                suppColumnInfo.crrct_pk_flag = column.crrct_pk_flag
                suppColumnInfo.fld_desc = column.fld_desc
                suppColumnInfo.pic = column.pic
                suppColumnInfo.fld_clas = column.fld_clas
                suppColumnInfo.fld_null_rate = column.fld_null_rate
                suppColumnInfo.rec_stat = column.rec_stat
                suppColumnInfo.rec_subm_prsn = current_user.user.user_name
                suppColumnInfo.apply_time = applyTime
                suppColumnInfo.apply_status = 'waiting'
                suppColumnInfo.oldColumnData = cls.castToColumnStr(oldColumn, columnInfo)
                await MetaDao.insertMetadataFldSuppInfoVett(suppColumnInfo, result_db)
        applyModel = ApplyModel()
        applyModel.businessType = "metaDataInfo"
        applyModel.businessId = tableOnum
        applyModel.applicant = current_user.user.user_name
        await ApprovalService.apply_services(result_db, applyModel, 'metaDataInfo')
        await result_db.commit()
        return CrudResponseModel(is_success=True, message='操作成功')

    @classmethod
    def castToTableStr(cls, table: MetadataSuppInfo, tableInfo: MetadataExtractInfo):
        tableDict = dict(
            onum=table.onum,
            crrctVerNum=table.crrct_ver_num,
            ssysCd=table.ssys_cd,
            mdlName=table.mdl_name,
            tabEngName=table.tab_eng_name,
            tabCnName=tableInfo.tab_cn_name,
            tabType=tableInfo.tab_type,
            tabRecNum=tableInfo.tab_rec_num,
            tabCrrctName=table.tab_crrct_name,
            tabDesc=table.tab_desc,
            pic=table.pic,
            govFlag=table.gov_flag,
            recStat=table.rec_stat,
            tabClas=table.tab_clas,
            recSubmPrsn=table.rec_subm_prsn,
            updTime=table.upd_time
        )
        return json.dumps(tableDict)

    @classmethod
    def castToColumnStr(cls, column: MetadataFldSuppInfo, columnInfo: MetadataFldTabExtractInfo):
        columnDict = dict(
            onum=column.onum,
            crrctVerNum=column.crrct_ver_num,
            ssysCd=column.ssys_cd,
            mdlName=column.mdl_name,
            tabEngName=column.tab_eng_name,
            fldEngName=column.fld_eng_name,
            fldCnName=columnInfo.fld_cn_name,
            fldType=columnInfo.fld_type,
            pkFlag=columnInfo.pk_flag,
            requireFlag=columnInfo.require_flag,
            idxFlag=columnInfo.idx_flag,
            fldCrrctName=column.fld_crrct_name,
            crrctPkFlag=column.crrct_pk_flag,
            fldDesc=column.fld_desc,
            pic=column.pic,
            fldClas=column.fld_clas,
            fldNullRate=column.fld_null_rate,
            recStat=column.rec_stat,
            updTime=column.upd_time
        )
        return json.dumps(columnDict)

    @classmethod
    def snake_to_camel(cls, snake_str: str):
        # 将字符串按下划线分割成列表
        components = snake_str.split('_')
        # 第一个单词保持小写，后续单词首字母大写
        camel_str = components[0] + ''.join(word.capitalize() for word in components[1:])
        return camel_str

    @classmethod
    def convert_json_keys(cls, data):
        if isinstance(data, dict):
            # 如果数据是字典，则转换键名并递归处理值
            return {cls.snake_to_camel(k): cls.convert_json_keys(v) for k, v in data.items()}
        elif isinstance(data, list):
            # 如果数据是列表，则递归处理列表中的每个元素
            return [cls.convert_json_keys(element) for element in data]
        else:
            # 如果数据不是字典或列表，则直接返回（即基本数据类型，如字符串、数字等）
            return data

    @classmethod
    async def get_meta_apply_detail_services(cls, result_db: AsyncSession, businessId: str):
        tableData = await MetaDao.get_supp_table_vett_by_id(businessId, result_db)
        columnData = await MetaDao.get_supp_column_vett_by_tableInfo(result_db, tableData)
        result = dict(
            table=tableData,
            column=columnData
        )
        return result