You can not select more than 25 topics Topics must start with a letter or number, can include dashes ('-') and can be up to 35 characters long.
 
 
 
 
 

441 lines
28 KiB

import json
import uuid
from module_admin.entity.vo.meta_vo import MetaPageObject, MetaColObject, SuppleModel, MetaBusinessRelShipObject
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)
if meta_rel_list and len(meta_rel_list.rows) > 0:
for table in meta_rel_list.rows:
tab_list = await MetaDao.get_meta_tab_clas(result_db, table['ssysCd'], table['mdlName'],
table['tabEngName'])
table['batchTabClas'] = CamelCaseUtil.transform_result(tab_list)
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)
result = CamelCaseUtil.transform_result(meta_result)
for column in result:
fld_list = await MetaDao.get_meta_fld_clas(result_db, column['ssysCd'], column['mdlName'],
column['tabEngName'], column['fldEngName'])
column['batchFldClas'] = CamelCaseUtil.transform_result(fld_list)
return 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=tableInfo.onum,
crrctVerNum=table.crrct_ver_num if table else None,
ssysCd=tableInfo.ssys_cd,
mdlName=tableInfo.mdl_name,
tabEngName=tableInfo.tab_eng_name,
tabCnName=tableInfo.tab_cn_name,
tabType=tableInfo.tab_type,
tabRecNum=tableInfo.tab_rec_num,
tabCrrctName=table.tab_crrct_name if table else None,
tabDesc=table.tab_desc if table else None,
pic=table.pic if table else None,
govFlag=table.gov_flag if table else None,
recStat=table.rec_stat if table else None,
tabClas=table.tab_clas if table else None,
recSubmPrsn=table.rec_subm_prsn if table else None,
updTime=table.upd_time if table else None
)
return json.dumps(tableDict)
@classmethod
def castToColumnStr(cls, column: MetadataFldSuppInfo, columnInfo: MetadataFldTabExtractInfo):
columnDict = dict(
onum=columnInfo.onum,
crrctVerNum=column.crrct_ver_num if column else None,
ssysCd=columnInfo.ssys_cd,
mdlName=columnInfo.mdl_name,
tabEngName=columnInfo.tab_eng_name,
fldEngName=columnInfo.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 if column else None,
crrctPkFlag=column.crrct_pk_flag if column else None,
fldDesc=column.fld_desc if column else None,
pic=column.pic if column else None,
fldClas=column.fld_clas if column else None,
fldNullRate=column.fld_null_rate if column else None,
recStat=column.rec_stat if column else None,
updTime=column.upd_time if column else None
)
return json.dumps(columnDict)
@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)
table = CamelCaseUtil.transform_result(tableData)
clas_list = await MetaDao.get_meta_tab_clas(result_db, tableData.ssys_cd, tableData.mdl_name,
tableData.tab_eng_name)
table['batchTabClas'] = CamelCaseUtil.transform_result(clas_list)
columnData = await MetaDao.get_supp_column_vett_by_tableInfo(result_db, tableData)
column_list = CamelCaseUtil.transform_result(columnData)
for column in column_list:
col_list = await MetaDao.get_meta_fld_clas(result_db, column['ssysCd'], column['mdlName'],
column['tabEngName'], column['fldEngName'])
column['batchColClas'] = CamelCaseUtil.transform_result(col_list)
result = dict(
table=table,
column=column_list
)
return result
@classmethod
async def get_table_by_id(cls, result_db: AsyncSession, tableId: int):
table = await MetaDao.get_meta_table_by_id(tableId, result_db)
tab_list = await MetaDao.get_meta_tab_clas(result_db, table['ssysCd'], table['mdlName'],
table['tabEngName'])
table['batchTabClas'] = CamelCaseUtil.transform_result(tab_list)
colQuery = MetaColObject()
colQuery.ssys_cd = table['ssysCd']
colQuery.mdl_name = table['mdlName']
colQuery.tab_name = table['tabEngName']
columnList = await MetaDao.get_meta_col_list(result_db, colQuery)
for column in columnList:
col_list = await MetaDao.get_meta_fld_clas(result_db, column['ssys_cd'], column['mdl_name'],
column['tab_eng_name'], column['fld_eng_name'])
column['batchColClas'] = CamelCaseUtil.transform_result(col_list)
table['columnList'] = CamelCaseUtil.transform_result(columnList)
return table
@classmethod
async def getBusinessRelationShip(cls, result_db: AsyncSession, meta_query: MetaBusinessRelShipObject):
currentNodeList = await cls.getRelationByTable(result_db, meta_query.ssys_cd, meta_query.mdl_name,
meta_query.tab_eng_name, meta_query.type)
relationList = []
if currentNodeList is not None and len(currentNodeList) > 0:
for currentNode in currentNodeList:
if currentNode['father'] is None:
relation = {"source": {"ssys_cd": currentNode['a_ssys_cd'],
"mdl_name": currentNode['a_mdl_name'],
"tab_eng_name": currentNode['a_tab_eng_name'],
"fld_eng_name": currentNode['a_fld_eng_name']},
"target": {'ssys_cd': currentNode['b_ssys_cd'],
'mdl_name': currentNode['b_mdl_name'],
'tab_eng_name': currentNode['b_tab_eng_name'],
'fld_eng_name': currentNode['b_fld_eng_name']},
"endArrow": False}
else:
relation = {"source": {"ssys_cd": currentNode['a_ssys_cd'],
"mdl_name": currentNode['a_mdl_name'],
"tab_eng_name": currentNode['a_tab_eng_name'],
"fld_eng_name": currentNode['a_fld_eng_name']},
"target": {'ssys_cd': currentNode['b_ssys_cd'],
'mdl_name': currentNode['b_mdl_name'],
'tab_eng_name': currentNode['b_tab_eng_name'],
'fld_eng_name': currentNode['b_fld_eng_name']},
"endArrow": True} if \
currentNode['father'] == 'A' else {
"source": {'ssys_cd': currentNode['b_ssys_cd'],
'mdl_name': currentNode['b_mdl_name'],
'tab_eng_name': currentNode['b_tab_eng_name'],
'fld_eng_name': currentNode['b_fld_eng_name']},
"target": {"ssys_cd": currentNode['a_ssys_cd'],
"mdl_name": currentNode['a_mdl_name'],
"tab_eng_name": currentNode['a_tab_eng_name'],
"fld_eng_name": currentNode['a_fld_eng_name']},
"endArrow": True}
relationList.append(relation)
if meta_query.type == 'er':
if currentNode['a_tab_eng_name'] == meta_query.tab_eng_name:
if currentNode['father'] == 'A':
# b为下游,取b字段的下下游
nextNodeList = (await cls.getRelationByColumn(result_db, currentNode['b_ssys_cd'],
currentNode['b_mdl_name'],
currentNode['b_tab_eng_name'],
currentNode['b_fld_eng_name'],
meta_query.type,
'next'))
if nextNodeList and len(nextNodeList) > 0:
for nextNode in nextNodeList:
relation = {"source": {"ssys_cd": nextNode['a_ssys_cd'],
"mdl_name": nextNode['a_mdl_name'],
"tab_eng_name": nextNode['a_tab_eng_name'],
"fld_eng_name": nextNode['a_fld_eng_name']},
"target": {'ssys_cd': nextNode['b_ssys_cd'],
'mdl_name': nextNode['b_mdl_name'],
'tab_eng_name': nextNode['b_tab_eng_name'],
'fld_eng_name': nextNode['b_fld_eng_name']},
"endArrow": True} if nextNode['father'] == 'A' else \
{"source": {'ssys_cd': nextNode['b_ssys_cd'],
'mdl_name': nextNode['b_mdl_name'],
'tab_eng_name': nextNode['b_tab_eng_name'],
'fld_eng_name': nextNode['b_fld_eng_name']},
"target": {"ssys_cd": nextNode['a_ssys_cd'],
"mdl_name": nextNode['a_mdl_name'],
"tab_eng_name": nextNode['a_tab_eng_name'],
"fld_eng_name": nextNode['a_fld_eng_name']},
"endArrow": True
}
relationList.append(relation)
if currentNode['father'] == 'B':
# b为上游, 取b字段的上上游
preNodeList = await cls.getRelationByColumn(result_db, currentNode['b_ssys_cd'],
currentNode['b_mdl_name'],
currentNode['b_tab_eng_name'],
currentNode['b_fld_eng_name'],
meta_query.type,
'pre')
if preNodeList and len(preNodeList) > 0:
for preNode in preNodeList:
relation = {"source": {"ssys_cd": preNode['a_ssys_cd'],
"mdl_name": preNode['a_mdl_name'],
"tab_eng_name": preNode['a_tab_eng_name'],
"fld_eng_name": preNode['a_fld_eng_name']},
"target": {'ssys_cd': preNode['b_ssys_cd'],
'mdl_name': preNode['b_mdl_name'],
'tab_eng_name': preNode['b_tab_eng_name'],
'fld_eng_name': preNode['b_fld_eng_name']},
"endArrow": True} if preNode['father'] == 'A' else\
{ "source": {'ssys_cd': preNode['b_ssys_cd'],
'mdl_name': preNode['b_mdl_name'],
'tab_eng_name': preNode['b_tab_eng_name'],
'fld_eng_name': preNode['b_fld_eng_name']},
"target": {"ssys_cd": preNode['a_ssys_cd'], "mdl_name": preNode['a_mdl_name'],
"tab_eng_name": preNode['a_tab_eng_name'],
"fld_eng_name": preNode['a_fld_eng_name']},
"endArrow": True}
relationList.append(relation)
if currentNode['b_tab_eng_name'] == meta_query.tab_eng_name:
if currentNode['father'] == 'A':
# a 为上游,取a字段的上上游
preNodeList = await cls.getRelationByColumn(result_db, currentNode['a_ssys_cd'],
currentNode['a_mdl_name'],
currentNode['a_tab_eng_name'],
currentNode['a_fld_eng_name'],
meta_query.type,
'pre')
if preNodeList and len(preNodeList) > 0:
for preNode in preNodeList:
relation = {"source": {"ssys_cd": preNode['a_ssys_cd'],
"mdl_name": preNode['a_mdl_name'],
"tab_eng_name": preNode['a_tab_eng_name'],
"fld_eng_name": preNode['a_fld_eng_name']},
"target": {'ssys_cd': preNode['b_ssys_cd'],
'mdl_name': preNode['b_mdl_name'],
'tab_eng_name': preNode['b_tab_eng_name'],
'fld_eng_name': preNode['b_fld_eng_name']},
"endArrow": True} if \
preNode['father'] == 'A' else {
"source": {'ssys_cd': preNode['b_ssys_cd'],
'mdl_name': preNode['b_mdl_name'],
'tab_eng_name': preNode['b_tab_eng_name'],
'fld_eng_name': preNode['b_fld_eng_name']},
"target": {"ssys_cd": preNode['a_ssys_cd'], "mdl_name": preNode['a_mdl_name'],
"tab_eng_name": preNode['a_tab_eng_name'],
"fld_eng_name": preNode['a_fld_eng_name']},
"endArrow": True}
relationList.append(relation)
if currentNode['father'] == 'B':
# a 为下游,取a字段的下下游
nextNodeList = await cls.getRelationByColumn(result_db, currentNode['a_ssys_cd'],
currentNode['a_mdl_name'],
currentNode['a_tab_eng_name'],
currentNode['a_fld_eng_name'],
meta_query.type,
'next')
for nextNode in nextNodeList:
relation = {"source": {"ssys_cd": nextNode['a_ssys_cd'],
"mdl_name": nextNode['a_mdl_name'],
"tab_eng_name": nextNode['a_tab_eng_name'],
"fld_eng_name": nextNode['a_fld_eng_name']},
"target": {'ssys_cd': nextNode['b_ssys_cd'],
'mdl_name': nextNode['b_mdl_name'],
'tab_eng_name': nextNode['b_tab_eng_name'],
'fld_eng_name': nextNode['b_fld_eng_name']},
"endArrow": True} if \
nextNode['father'] == 'A' else {
"source": {'ssys_cd': nextNode['b_ssys_cd'],
'mdl_name': nextNode['b_mdl_name'],
'tab_eng_name': nextNode['b_tab_eng_name'],
'fld_eng_name': nextNode['b_fld_eng_name']},
"target": {"ssys_cd": nextNode['a_ssys_cd'], "mdl_name": nextNode['a_mdl_name'],
"tab_eng_name": nextNode['a_tab_eng_name'],
"fld_eng_name": nextNode['a_fld_eng_name']},
"endArrow": True}
relationList.append(relation)
tableList = []
if len(relationList) > 0:
for relation in relationList:
if len(tableList) > 0:
hasSourceTable = False
hasTargetTable = False
for tab in tableList:
if tab['ssys_cd'] == relation['source']['ssys_cd'] and tab['mdl_name'] == \
relation['source']['mdl_name'] and tab['tab_eng_name'] == \
relation['source']['tab_eng_name']:
hasSourceTable = True
if tab['ssys_cd'] == relation['target']['ssys_cd'] and tab['mdl_name'] == \
relation['target']['mdl_name'] and tab['tab_eng_name'] == \
relation['target']['tab_eng_name']:
hasTargetTable = True
if not hasSourceTable:
tableList.append({"ssys_cd": relation['source']['ssys_cd'],
"mdl_name": relation['source']['mdl_name'],
"tab_eng_name": relation['source']['tab_eng_name']})
if not hasTargetTable:
tableList.append({"ssys_cd": relation['target']['ssys_cd'],
"mdl_name": relation['target']['mdl_name'],
"tab_eng_name": relation['target']['tab_eng_name']})
else:
tableList.append({"ssys_cd": relation['source']['ssys_cd'],
"mdl_name": relation['source']['mdl_name'],
"tab_eng_name": relation['source']['tab_eng_name']})
tableList.append({"ssys_cd": relation['target']['ssys_cd'],
"mdl_name": relation['target']['mdl_name'],
"tab_eng_name": relation['target']['tab_eng_name']})
if len(tableList) > 0:
for table in tableList:
query_object = MetaColObject()
query_object.ssys_cd = table['ssys_cd']
query_object.mdl_name = table['mdl_name']
query_object.tab_name = table['tab_eng_name']
meta_result = await MetaDao.get_meta_col_name_list(result_db, query_object)
result = CamelCaseUtil.transform_result(meta_result)
tableCnName = await MetaDao.get_meta_table_cn_name(result_db, table['ssys_cd'], table['mdl_name'],
table['tab_eng_name'])
table['tab_cn_name'] = tableCnName
table['column'] = result
result = {
"tableList": tableList,
"relation": relationList
}
return result
@classmethod
async def getRelationByTable(cls, result_db: AsyncSession, ssys_cd: str, mdl_name: str,
tab_eng_name: str, rel_type: str):
if rel_type == 'op':
currentNodeList = await MetaDao.get_op_relation_by_table(result_db, ssys_cd, mdl_name, tab_eng_name)
return currentNodeList
if rel_type == 'er':
currentNodeList = await MetaDao.get_er_relation_by_table(result_db, ssys_cd, mdl_name, tab_eng_name)
return currentNodeList
return None
@classmethod
async def getRelationByColumn(cls, result_db: AsyncSession, ssys_cd: str, mdl_name: str,
tab_eng_name: str, fld_eng_name: str, rel_type: str, module: str):
col = {
'ssys_cd': ssys_cd,
'mdl_name': mdl_name,
'tab_eng_name': tab_eng_name,
'fld_eng_name': fld_eng_name
}
if rel_type == 'op':
currentNodeList = await MetaDao.get_op_relation_by_column(result_db, col, module)
return currentNodeList
if rel_type == 'er':
currentNodeList = await MetaDao.get_er_relation_by_column(result_db, col, module)
return currentNodeList
return None