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.
 
 
 
 
 

1485 lines
67 KiB

from fastapi import Request
from sqlalchemy.ext.asyncio import AsyncSession
from exceptions.exception import ServiceException
from module_admin.dao.datastd_dao import DataStdDao
from module_admin.entity.vo.common_vo import CrudResponseModel
from module_admin.entity.vo.datastd_vo import DataStdCodeModel,DeleteDataStdModel,DataStdDictModel,DataStdMainModel,DataStdMainApprModel,DataStdDictApprModel,DataStdCodeApprModel,DataStdCodePageQueryModel
from utils.common_util import CamelCaseUtil
import uuid
from module_admin.entity.vo.approval_vo import ApplyModel
from module_admin.service.approval_service import ApprovalService
from collections import defaultdict
from datetime import datetime
from config.constant import CommonConstant
from module_admin.entity.vo.data_ast_content_vo import DataCatalogPageQueryModel, DeleteDataCatalogModel,DataCatalogResponseWithChildren,DataCatalogMovedRequest,DataCatalogMergeRequest,DataCatalogChild,DataCatalogMoverelRequest
from module_admin.entity.vo.user_vo import CurrentUserModel
class DataStdService:
"""
数据源标准服务层
"""
@classmethod
async def get_std_code_list_services(
cls, query_db: AsyncSession, query_object: DataStdCodeModel, is_page: bool = False
):
"""
获取列配置列表信息service
:param query_db: orm对象
:param query_object: 查询参数对象
:param is_page: 是否开启分页
:return: 列配置列表信息对象
"""
col_list_result = await DataStdDao.get_std_code_list(query_db, query_object, is_page)
return col_list_result
# @classmethod
# async def get_appr_std_code_list_services(
# cls, query_db: AsyncSession, query_object: DataStdCodeModel, is_page: bool = False
# ):
# col_list_result = await DataStdDao.get_appr_std_code_list(query_db, query_object, is_page)
# # for 循环col_list_result.rows 如果changeType是update的 去查他的compareId 用oldItem= get_std_code_appr_by_id(compareId ) 获取原始数据 比较 cd_no cd_val_cn_mean code_map_id (code_map_id都为空的情况应该判断一致) 如果三个属性都一致的 判定一致 移除这个col_list_result,不一致的把改属性改为 item.cd_no=oldItem.cd_no-->item.cd_no
# return col_list_result
@classmethod
async def get_appr_std_code_list_services(
cls, query_db: AsyncSession, query_object: DataStdCodeModel, is_page: bool = False
):
col_list_result = await DataStdDao.get_appr_std_code_list(query_db, query_object, is_page)
filtered_rows = []
for item in col_list_result.rows:
if item.get("changeType") == "update" and item.get("compareId"):
old_item = await DataStdDao.get_std_code_appr_by_id(query_db, item.get("compareId"))
# 判断三个字段是否一致(空值也算一致)
is_code_num_same = item.get("cdNo") == old_item.cd_no
is_code_name_same = item.get("cdValCnMean") == old_item.cd_val_cn_mean
is_code_map_id_same = (
(not item.get("codeMapId") and not old_item.code_map_id) or
(item.get("codeMapId") == old_item.code_map_id)
)
if is_code_num_same and is_code_name_same and is_code_map_id_same:
continue # 跳过完全一致的记录
else:
# 拼接变更格式:旧值 ==> 新值
if not is_code_num_same:
item["cdNo"] = f"{old_item.cd_no or ''} ==> {item.get('cdNo', '')}"
if not is_code_name_same:
item["cdValCnMean"] = f"{old_item.cd_val_cn_mean or ''} ==> {item.get('cdValCnMean', '')}"
if not is_code_map_id_same:
old_val = old_item.code_map_id or ""
new_val = item.get("codeMapId") or ""
item["codeMapId"] = f"{old_val} ==> {new_val}"
filtered_rows.append(item)
else:
filtered_rows.append(item)
col_list_result.rows = filtered_rows
return col_list_result
@classmethod
async def get_std_code_appr_list(cls, query_db: AsyncSession, query_object: DataStdCodeApprModel, is_page: bool = False):
return await DataStdDao.get_std_code_appr_list(query_object.flowId, query_db)
@classmethod
async def get_std_code_map_list_services(
cls, query_db: AsyncSession, query_object: DataStdCodeModel, is_page: bool = False
):
"""
获取列配置列表信息service
:param query_db: orm对象
:param query_object: 查询参数对象
:param is_page: 是否开启分页
:return: 列配置列表信息对象
"""
col_list_result = await DataStdDao.get_std_code_map_list(query_db, query_object, is_page)
return col_list_result
@classmethod
async def get_std_code_by_id_services(cls, query_db: AsyncSession, id: str):
"""
获取列配置详细信息service
:param query_db: orm对象
:param id: 列配置ID
:return: 列配置详细信息对象
"""
col = await DataStdDao.get_std_code_by_id(query_db, id)
if col:
result = DataStdCodeModel(**CamelCaseUtil.transform_result(col))
else:
result = DataStdCodeModel(**dict())
return result
@classmethod
async def add_std_code_services(cls, request: Request, query_db: AsyncSession, page_object: DataStdCodeModel):
"""
新增列配置服务
:param request: Request对象
:param query_db: orm对象
:param page_object: 新增的列配置对象
:return: 新增列配置校验结果
"""
try:
# 创建新的 page_object 实例,避免修改原始对象
new_page_object = DataStdCodeModel(**page_object.model_dump(by_alias=True))
new_page_object.cd_val_stat="9"
# 调用 DAO 方法插入数据
await DataStdDao.add_std_code(query_db, new_page_object)
return CrudResponseModel(is_success=True, message='新增标准代码成功')
except Exception as e:
await query_db.rollback()
raise e
@classmethod
async def code_detail_services(cls, query_db: AsyncSession, col: str):
"""
获取参数配置详细信息service
:param query_db: orm对象
:param config_id: 参数配置id
:return: 参数配置id对应的信息
"""
config = await DataStdDao.get_std_code_by_id(query_db, col)
if config:
result = DataStdCodeModel(**CamelCaseUtil.transform_result(config))
else:
result = DataStdCodeModel(**dict())
return result
@classmethod
async def code_appr_detail_services(cls, query_db: AsyncSession, col: str):
"""
获取参数配置详细信息service
:param query_db: orm对象
:param config_id: 参数配置id
:return: 参数配置id对应的信息
"""
config = await DataStdDao.get_std_code_appr_by_id(query_db, col)
if config:
result = DataStdCodeApprModel(**CamelCaseUtil.transform_result(config))
else:
result = DataStdCodeApprModel(**dict())
return result
@classmethod
async def edit_std_code_services(cls, request: Request, query_db: AsyncSession, page_object: DataStdCodeModel):
"""
编辑列配置服务
:param request: Request对象
:param query_db: orm对象
:param page_object: 编辑的列配置对象
:return: 编辑列配置校验结果
"""
edit_col = page_object.model_dump(exclude_unset=True)
col_info = await cls.get_std_code_by_id_services(query_db, page_object.onum)
if col_info:
try:
await DataStdDao.update_std_code(query_db, edit_col)
return CrudResponseModel(is_success=True, message='编辑标准代码成功')
except Exception as e:
await query_db.rollback()
raise e
else:
raise ServiceException(message=f'标准代码{page_object.onum}不存在')
@classmethod
async def delete_std_code_with_items_appr(
cls,
ids: str,
query_db: AsyncSession,
current_user: CurrentUserModel
):
"""
批量删除标准代码及其代码项的审批流程。
:param ids: 多个标准代码ID,用逗号分隔
"""
try:
id_list = [i.strip() for i in ids.split(',') if i.strip()]
if not id_list:
raise ServiceException(message="请提供有效的标准代码ID列表")
for std_id in id_list:
data_std_no = await DataStdDao.get_std_code_by_id(query_db, std_id)
if not data_std_no:
raise ServiceException(message=f"ID 为 {std_id} 的标准代码不存在,无法提交删除审批")
flow_id = str(uuid.uuid4())
last_appr= await DataStdDao.get_last_std_code_appr_by_id(query_db,std_id)
# 标准代码审批记录
std_code_appr = DataStdCodeApprModel(**CamelCaseUtil.transform_result(data_std_no))
std_code_appr.changeType = "delete"
std_code_appr.compareId = last_appr.onum
std_code_appr.oldInstId = data_std_no.onum
std_code_appr.approStatus = "waiting"
std_code_appr.cd_val_stat = "9"
std_code_appr.flowId = flow_id
std_code_appr.onum=str(uuid.uuid4())
std_code_appr.create_by = current_user.user.user_name
std_code_appr.create_time = datetime.now()
await DataStdDao.add_std_code_appr(query_db, std_code_appr)
queryCodeItem = DataStdCodePageQueryModel()
queryCodeItem.parent_id=data_std_no.onum
queryCodeItem.class_id="codeItem"
queryCodeItem.page_size=100
queryCodeItem.page_num=1
code_item_list_old = await DataStdDao.get_std_code_list(query_db, queryCodeItem, False)
for code_item in code_item_list_old:
appr_item=DataStdCodeApprModel(**code_item)
last_appr_item= await DataStdDao.get_last_std_code_appr_by_id(query_db,std_id)
appr_item.changeType = "delete"
appr_item.parent_id = std_code_appr.onum
appr_item.compareId = last_appr_item.onum
appr_item.oldInstId = appr_item.onum
appr_item.approStatus = "waiting"
appr_item.cd_val_stat = "9"
appr_item.flowId = flow_id
appr_item.onum=str(uuid.uuid4())
appr_item.create_by = current_user.user.user_name
appr_item.create_time = datetime.now()
await DataStdDao.add_std_code_appr(query_db, appr_item)
# 发起审批流程(每个标准代码一条审批)
apply_model = ApplyModel()
apply_model.businessType = "dataStdCode"
apply_model.businessId = flow_id
apply_model.applicant = current_user.user.user_name
await ApprovalService.apply_services(query_db, apply_model, 'dataStdCode')
return CrudResponseModel(is_success=True, message="批量提交删除标准代码审批成功!")
except Exception as e:
await query_db.rollback()
raise ServiceException(message=f"提交删除标准代码审批失败: {str(e)}")
@classmethod
async def delete_std_code_services(cls, request: Request, query_db: AsyncSession, page_object: DeleteDataStdModel):
"""
删除列配置服务
:param request: Request对象
:param query_db: orm对象
:param page_object: 删除列配置对象
:return: 删除列配置校验结果
"""
if page_object.ids:
col_id_list = page_object.ids.split(',')
try:
for col_id in col_id_list:
col_info = await cls.get_std_code_by_id_services(query_db, col_id)
if col_info:
# 校验不能删除的系统内置列
await DataStdDao.delete_std_code(query_db, col_id)
await query_db.commit()
return CrudResponseModel(is_success=True, message='删除标准代码成功')
except Exception as e:
await query_db.rollback()
raise e
else:
raise ServiceException(message='传入标准代码ID为空')
@classmethod
async def add_std_code_with_items_services(cls, request, query_db: AsyncSession, code: DataStdCodeModel, code_item_list: list[DataStdCodeModel]):
"""
新增标准代码和对应的代码项
"""
try:
# 先校验标准代码是否唯一
if not await cls.check_code_unique_services(query_db, code):
raise ServiceException(message=f'新增代码{code.cd_val_cn_mean}失败,{code.cd_no}代码已存在')
else:
# 保存标准代码
code.onum=str(uuid.uuid4())
await cls.add_std_code_services(request, query_db, code)
# 为每个代码项设置parent_id,并进行校验
for code_item in code_item_list:
# 校验同一个父级下,code是否已存在
code_item.parent_id = code.onum
if not await cls.check_code_unique_services(query_db, code_item):
raise ServiceException(message=f"父级代码{code.cd_no}下的代码项{code_item.cd_no}已存在")
# 将parent_id设为code的ID
code_item.onum=str(uuid.uuid4())
code_item.create_by=code.create_by
code_item.create_time=code.create_time
code_item.upd_prsn=code.upd_prsn
code_item.upd_time=code.upd_time
await cls.add_std_code_services(request, query_db, code_item)
# 提交事务
await query_db.commit()
return CrudResponseModel(is_success=True, message='标准代码和代码项新增成功')
except Exception as e:
await query_db.rollback()
raise ServiceException(message=f"新增标准代码失败: {str(e)}")
@classmethod
async def add_std_code_with_items_appr(
cls,
code: DataStdCodeModel,
code_item_list: list[DataStdCodeModel],
query_db: AsyncSession,
current_user: CurrentUserModel
):
# 设置标准代码的创建和更新时间
code.onum = str(uuid.uuid4()) # 新生成 ID
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()
# 校验标准代码是否已存在于正式表中
if not await cls.check_code_unique_services(query_db, code):
raise ServiceException(message=f'标准代码{code.cd_no}已经存在于正式表中,无法新增')
# 先创建标准代码的审批记录
appr_model = DataStdCodeApprModel(**code.model_dump(exclude_unset=True, by_alias=True))
appr_model.changeType = "add"
appr_model.compareId = code.onum
appr_model.oldInstId = code.onum
appr_model.cd_val_stat="9"
appr_model.approStatus = "waiting"
appr_model.flowId = str(uuid.uuid4()) # 新生成 Flow ID
# 将标准代码添加到审批表
await DataStdDao.add_std_code_appr(query_db, appr_model)
# 同时处理代码项的添加
for item in code_item_list:
item.onum = str(uuid.uuid4()) # 新生成 ID
item.create_by = current_user.user.user_name
item.create_time = datetime.now()
item.upd_prsn = current_user.user.user_name
item.upd_time = datetime.now()
item.src_sys = '公司级' if 'company' == item.cd_type else item.src_sys
item.parent_id = appr_model.onum # 设置父级 ID
# 校验代码项是否已存在于正式表中
if not await cls.check_code_unique_services(query_db, item):
raise ServiceException(message=f'代码项{item.cd_no}已经存在于正式表中,无法新增')
# 同样需要创建审批记录
item_appr_model = DataStdCodeApprModel(**item.model_dump(exclude_unset=True, by_alias=True))
item_appr_model.changeType = "add"
item_appr_model.compareId = item.onum
item_appr_model.oldInstId = item.onum
item_appr_model.approStatus = "waiting"
item_appr_model.flowId = appr_model.flowId # 使用相同的 Flow ID
await DataStdDao.add_std_code_appr(query_db, item_appr_model)
# 创建审批申请
apply_model = ApplyModel()
apply_model.businessType = "dataStdCode"
apply_model.businessId = appr_model.flowId
apply_model.applicant = appr_model.create_by
await ApprovalService.apply_services(query_db, apply_model, 'dataStdCode')
return CrudResponseModel(is_success=True, message='提交新增标准代码审批成功!')
@classmethod
async def edit_std_code_with_items_services(cls, request, query_db: AsyncSession, code: DataStdCodeModel, code_item_list: list[DataStdCodeModel]):
"""
修改标准代码和对应的代码项。如果code_item.id为0,则执行新增操作,否则执行更新操作。
"""
try:
# 校验标准代码是否存在并且唯一
if not await cls.check_code_unique_services(query_db, code):
raise ServiceException(message=f'修改代码{code.cd_val_cn_mean}失败,{code.cd_no}代码不存在或已存在')
# 更新标准代码
await cls.edit_std_code_services(request, query_db, code)
# 为每个代码项设置parent_id,并进行校验
for code_item in code_item_list:
code_item.parent_id = code.onum
if code_item.onum :
# 校验同一个父级下,code_num是否已存在
if not await cls.check_code_unique_services(query_db, code_item):
raise ServiceException(message=f"父级代码{code.cd_no}下的代码项{code_item.cd_no}已存在")
# 更新代码项的相关信息
code_item.upd_time = code.upd_time
code_item.upd_prsn = code.upd_prsn
await cls.edit_std_code_services(request, query_db, code_item) # 执行更新操作
else: # 如果code_item的id不为0,表示是修改操作
# 校验同一个父级下,code_num是否已存在
if not await cls.check_code_unique_services(query_db, code_item):
raise ServiceException(message=f"父级代码{code.cd_no}下的代码项{code_item.cd_no}已存在")
# 生成新的UUID,并新增代码项
code_item.onum = str(uuid.uuid4()) # 新生成的UUID
code_item.create_time = code.upd_time
code_item.create_by = code.create_by
code_item.upd_time = code.upd_time
code_item.upd_prsn = code.upd_prsn
await cls.add_std_code_services(request, query_db, code_item) # 执行新增操作
# 提交事务
await query_db.commit()
return CrudResponseModel(is_success=True, message='标准代码和代码项修改成功')
except Exception as e:
await query_db.rollback()
raise ServiceException(message=f"修改标准代码失败: {str(e)}")
@classmethod
async def edit_std_code_with_items_appr(
cls,
code: DataStdCodeModel,
code_item_list: list[DataStdCodeModel],
query_db: AsyncSession,
current_user: CurrentUserModel
):
"""
修改标准代码及其代码项的审批流程(修改审批)。
code_item.onum 存在为修改,若为空则为新增。
"""
# 更新时间及人
code.create_by = current_user.user.user_name
code.create_time = datetime.now()
# 校验标准代码是否存在并且唯一
if not await cls.check_code_unique_services(query_db, code):
raise ServiceException(message=f'标准代码{code.cd_no}不存在或已存在,无法提交修改审批')
# 创建标准代码的审批记录(changeType 为 update)
appr_model = DataStdCodeApprModel(**code.model_dump(exclude_unset=True, by_alias=True))
last_appr= await DataStdDao.get_last_std_code_appr_by_id(query_db,code.onum)
appr_model.changeType = "update"
appr_model.compareId = last_appr.onum # 对比对象为正式表的 ID
appr_model.oldInstId = code.onum
appr_model.cd_val_stat = "9"
appr_model.approStatus = "waiting"
appr_model.flowId = str(uuid.uuid4()) # flowId 共用
appr_model.onum = str(uuid.uuid4()) # flowId 共用
await DataStdDao.add_std_code_appr(query_db, appr_model)
# query_object.
query_object = DataStdCodePageQueryModel(
)
query_object.parent_id=code.onum
query_object.class_id="codeItem"
query_object.page_size=100
query_object.page_num=1
code_item_list_old = await DataStdDao.get_std_code_list(query_db, query_object, False)
new_ids = {item.onum for item in code_item_list if item.onum}
# 同步处理代码项
for item in code_item_list:
item.parent_id = code.onum
item.upd_prsn = current_user.user.user_name
item.upd_time = datetime.now()
item.src_sys = '公司级' if 'company' == item.cd_type else item.src_sys
if item.onum: # 修改项
if not await cls.check_code_unique_services(query_db, item):
raise ServiceException(message=f'父级代码{code.cd_no}下代码项{item.cd_no}重复,无法提交修改审批')
item_appr_model = DataStdCodeApprModel(**item.model_dump(exclude_unset=True, by_alias=True))
last_item_appr= await DataStdDao.get_last_std_code_appr_by_id(query_db,item_appr_model.onum)
item_appr_model.changeType = "update"
item_appr_model.compareId = last_item_appr.onum
item_appr_model.parent_id = code.onum
item_appr_model.oldInstId = item.onum
item_appr_model.approStatus = "waiting"
item_appr_model.flowId = appr_model.flowId
item_appr_model.onum = str(uuid.uuid4()) # flowId 共用
await DataStdDao.add_std_code_appr(query_db, item_appr_model)
else: # 新增项
item.onum = str(uuid.uuid4())
item.create_by = current_user.user.user_name
item.create_time = datetime.now()
if not await cls.check_code_unique_services(query_db, item):
raise ServiceException(message=f'父级代码{code.cd_no}下代码项{item.cd_no}重复,无法提交新增审批')
item_appr_model = DataStdCodeApprModel(**item.model_dump(exclude_unset=True, by_alias=True))
item_appr_model.changeType = "add"
item_appr_model.compareId = item.onum
item_appr_model.oldInstId = item.onum
item_appr_model.approStatus = "waiting"
item_appr_model.flowId = appr_model.flowId
item_appr_model.parent_id = code.onum
await DataStdDao.add_std_code_appr(query_db, item_appr_model)
for old_item in code_item_list_old:
if old_item["onum"] not in new_ids:
# 创建“删除”审批记录
delete_appr_model = DataStdCodeApprModel(**old_item)
delete_appr_model.changeType = "delete"
last_appr= await DataStdDao.get_last_std_code_appr_by_id(query_db,old_item["onum"])
delete_appr_model.compareId = last_appr.onum
delete_appr_model.oldInstId = old_item["onum"]
delete_appr_model.approStatus = "waiting"
delete_appr_model.flowId = appr_model.flowId
delete_appr_model.onum = str(uuid.uuid4())
delete_appr_model.parent_id = code.onum
delete_appr_model.create_by = current_user.user.user_name
delete_appr_model.create_time = datetime.now()
await DataStdDao.add_std_code_appr(query_db, delete_appr_model)
# 创建审批流程
apply_model = ApplyModel()
apply_model.businessType = "dataStdCode"
apply_model.businessId = appr_model.flowId
apply_model.applicant = appr_model.upd_prsn
await ApprovalService.apply_services(query_db, apply_model, 'dataStdCode')
return CrudResponseModel(is_success=True, message='提交修改标准代码审批成功!')
@classmethod
async def check_code_unique_services(cls, query_db: AsyncSession, page_object: DataStdCodeModel):
"""
校验字典类型称是否唯一service
:param query_db: orm对象
:param page_object: 字典类型对象
:return: 校验结果
"""
id = -1 if page_object.onum is None else page_object.onum
codemodel=DataStdCodeModel()
codemodel.cd_no=page_object.cd_no
codemodel.class_id=page_object.class_id
codemodel.parent_id=page_object.parent_id
codemodel.cd_type=page_object.cd_type
data_dict_type = await DataStdDao.get_data_code_by_info(query_db, codemodel
)
if data_dict_type and data_dict_type.onum != id:
return CommonConstant.NOT_UNIQUE
return CommonConstant.UNIQUE
# ----------------------------------------------------------------数据字典----------------------------------------------------------------------------------------------------
@classmethod
async def get_std_dict_list_services(
cls, query_db: AsyncSession, query_object: DataStdDictModel, is_page: bool = False
):
"""
获取列配置列表信息service
:param query_db: orm对象
:param query_object: 查询参数对象
:param is_page: 是否开启分页
:return: 列配置列表信息对象
"""
col_list_result = await DataStdDao.get_std_dict_list(query_db, query_object, is_page)
return col_list_result
@classmethod
async def get_std_dict_by_id_services(cls, query_db: AsyncSession, id: str):
"""
获取列配置详细信息service
:param query_db: orm对象
:param id: 列配置ID
:return: 列配置详细信息对象
"""
col = await DataStdDao.get_std_dict_by_id(query_db, id)
if col:
result = DataStdDictModel(**CamelCaseUtil.transform_result(col))
else:
result = DataStdDictModel(**dict())
return result
@classmethod
async def add_std_dict_services(cls, request: Request, query_db: AsyncSession, page_object: DataStdDictModel):
"""
新增列配置服务
:param request: Request对象
:param query_db: orm对象
:param page_object: 新增的列配置对象
:return: 新增列配置校验结果
"""
try:
if not await cls.check_dict_unique_services(query_db, page_object):
raise ServiceException(message=f"数据字典{page_object.data_dict_no}已存在")
# 创建新的 page_object 实例,避免修改原始对象
new_page_object = DataStdDictModel(**page_object.model_dump(by_alias=True))
new_page_object.data_dict_stat="9"
new_page_object.onum=str(uuid.uuid4())
# 调用 DAO 方法插入数据
await DataStdDao.add_std_dict(query_db, new_page_object)
return CrudResponseModel(is_success=True, message='新增数据字典成功')
except Exception as e:
await query_db.rollback()
raise e
@classmethod
async def dict_detail_services(cls, query_db: AsyncSession, col: str):
"""
获取参数配置详细信息service
:param query_db: orm对象
:param config_id: 参数配置id
:return: 参数配置id对应的信息
"""
config = await DataStdDao.get_std_dict_by_id(query_db, col)
if config:
result = DataStdDictModel(**CamelCaseUtil.transform_result(config))
else:
result = DataStdDictModel(**dict())
return result
@classmethod
async def edit_std_dict_services(cls, request: Request, query_db: AsyncSession, page_object: DataStdDictModel):
"""
编辑列配置服务
:param request: Request对象
:param query_db: orm对象
:param page_object: 编辑的列配置对象
:return: 编辑列配置校验结果
"""
if not await cls.check_dict_unique_services(query_db, page_object):
raise ServiceException(message=f"数据字典编号:{page_object.data_dict_no}已存在")
edit_col = page_object.model_dump(exclude_unset=True)
col_info = await cls.get_std_dict_by_id_services(query_db, page_object.onum)
if col_info:
try:
await DataStdDao.update_std_dict(query_db, edit_col)
return CrudResponseModel(is_success=True, message='编辑数据字典成功')
except Exception as e:
await query_db.rollback()
raise e
else:
raise ServiceException(message=f'数据字典{page_object.onum}不存在')
@classmethod
async def delete_std_dict_services(cls, request: Request, query_db: AsyncSession, page_object: DeleteDataStdModel):
"""
删除列配置服务
:param request: Request对象
:param query_db: orm对象
:param page_object: 删除列配置对象
:return: 删除列配置校验结果
"""
if page_object.ids:
col_id_list = page_object.ids.split(',')
try:
for col_id in col_id_list:
col_info = await cls.get_std_dict_by_id_services(query_db, col_id)
if col_info:
# 校验不能删除的系统内置列
await DataStdDao.delete_std_dict(query_db, col_id)
await query_db.commit()
return CrudResponseModel(is_success=True, message='删除数据字典成功')
except Exception as e:
await query_db.rollback()
raise e
else:
raise ServiceException(message='传入数据字典ID为空')
@classmethod
async def check_dict_unique_services(cls, query_db: AsyncSession, page_object: DataStdDictModel):
"""
校验字典类型称是否唯一service
:param query_db: orm对象
:param page_object: 字典类型对象
:return: 校验结果
"""
id ='-1' if page_object.onum is None else page_object.onum
codemodel=DataStdDictModel()
codemodel.data_dict_no=page_object.data_dict_no
data_dict_type = await DataStdDao.get_data_dict_by_info(query_db, codemodel
)
if data_dict_type and data_dict_type.onum != id:
return CommonConstant.NOT_UNIQUE
return CommonConstant.UNIQUE
# ----------------------------------------------------------------数据标准分类----------------------------------------------------------------------------------------------------
@classmethod
async def get_catalog_list_services(
cls, query_db: AsyncSession, query_object: DataCatalogPageQueryModel, user_id: int, is_page: bool = False
):
"""
获取数据目录列表信息service
:param query_db: orm对象
:param query_object: 查询参数对象
:param is_page: 是否开启分页
:return: 数据目录列表信息对象
"""
catalog_list_result = await DataStdDao.get_catalog_list(query_db, query_object, user_id, is_page)
# 按contentOnum分组
grouped = defaultdict(list)
for item in catalog_list_result.rows:
grouped[item['contentOnum']].append(item)
nodes = {} # 存储所有处理后的节点
# 处理每个组,生成节点
for belt_data_std_content, items in grouped.items():
first_item = items[0]
is_leaf = first_item['leafNodeFlag'] == 1
rela_onum = first_item['relaOnum'] is not None
# 公共字段提取
common_fields = {
'contentOnum': first_item['contentOnum'],
'contentName': first_item['contentName'],
'contentStat': first_item['contentStat'],
'contentIntr': first_item['contentIntr'],
'contentPic': first_item['contentPic'],
'suprContentOnum': first_item['suprContentOnum'],
'leafNodeFlag': first_item['leafNodeFlag'],
'updPrsn': first_item['updPrsn'],
'updTime': first_item['updTime'],
'children': []
}
nodes[belt_data_std_content] = common_fields
# 构建父子关系
root = None
for belt_data_std_content, node in nodes.items():
supr = node['suprContentOnum']
if supr is None:
root = node
else:
parent = nodes.get(supr)
if parent:
parent['children'].append(node)
# 对每个父节点的children进行排序,将'临时的节点'放到最后
for belt_data_std_content, node in nodes.items():
if 'children' in node:
# 排序时,'临时的节点'会被放到最后
node['children'] = sorted(
node['children'],
key=lambda x: x['contentName'] == '临时',
reverse=False # True会将'临时的节点'排在最前面,False是排在最后
)
print('获取数据清单内容:',root)
catalog_list_result.rows = [root]
return catalog_list_result
@classmethod
async def get_catalog_detail_services(cls, query_db: AsyncSession, belt_data_std_content: int):
"""
获取数据目录详细信息service
:param query_db: orm对象
:param belt_data_std_content: 数据目录ID
:return: 数据目录详细信息对象
"""
catalog_detail_result = await DataStdDao.get_catalog_by_id(query_db, belt_data_std_content)
return catalog_detail_result
@classmethod
async def add_catalog_services(cls, query_db: AsyncSession, request: DataCatalogResponseWithChildren):
"""
新增数据目录信息service
:param query_db: orm对象
:param request: 新增数据目录请求对象
:return: 新增目录操作结果
"""
catalog_data1 = {
'content_name': request.content_name,
'content_stat': request.content_stat,
'content_intr': request.content_intr,
'content_pic': request.content_pic,
'supr_content_onum': request.supr_content_onum,
'leaf_node_flag': request.leaf_node_flag,
'upd_prsn': request.upd_prsn
}
catalog_data2 = {
'content_name': request.content_name,
'content_stat': request.content_stat,
'content_intr': request.content_intr,
'content_pic': request.content_pic,
'supr_content_onum': request.supr_content_onum,
'leaf_node_flag': request.leaf_node_flag,
'upd_prsn': request.upd_prsn,
'children': [child.model_dump() for child in request.children] # 将 children 转换为字典列表
}
try:
for child in catalog_data2["children"]:
child["rela_eff_begn_date"] = datetime.now().strftime("%Y-%m-%d %H:%M:%S"), # 设置默认值,当前时间
child["rela_eff_end_date"] = datetime(year=2999, month=12, day=31, hour=0, minute=0, second=0).strftime("%Y-%m-%d %H:%M:%S"), # 设置默认值,2999-12-31
child["upd_prsn"] = request.upd_prsn,
child["rela_status"] = "1"
new_catalog = await DataStdDao.add_catalog_dao(query_db, catalog_data1, catalog_data2)
await query_db.commit()
return CrudResponseModel(is_success=True, message='新增成功', data=new_catalog)
except Exception as e:
await query_db.rollback()
raise ServiceException(message=f"创建目录时发生错误: {str(e)}")
@classmethod
async def edit_catalog_leaf_services(cls, query_db: AsyncSession,belt_data_std_content : int, leaf_node_flag : int):
"""
编辑数据目录信息service
:param query_db: orm对象
:param request: 编辑数据目录请求对象
:return: 编辑目录操作结果
"""
catalog_data1 = {
'belt_data_std_content': belt_data_std_content,
'leaf_node_flag': leaf_node_flag
}
try:
await DataStdDao.edit_catalog_leaf_dao(query_db, catalog_data1)
await query_db.commit()
return CrudResponseModel(is_success=True, message='更新成功')
except Exception as e:
await query_db.rollback()
raise ServiceException(message=f"更新目录时发生错误: {str(e)}")
@classmethod
async def edit_catalog_child_services(cls, query_db: AsyncSession, request: DataCatalogResponseWithChildren):
"""
编辑数据目录信息service
:param query_db: orm对象
:param request: 编辑数据目录请求对象
:return: 编辑目录操作结果
"""
catalog_data = {
'belt_data_std_content': request.belt_data_std_content,
'content_name': request.content_name,
'content_stat': request.content_stat,
'content_intr': request.content_intr,
'content_pic': request.content_pic,
'supr_content_onum': request.supr_content_onum,
'leaf_node_flag': request.leaf_node_flag,
'upd_prsn': request.upd_prsn,
'children': [child.model_dump() for child in request.children] # 将 children 转换为字典列表
}
try:
for child in catalog_data["children"]:
# 设置 rela_eff_begn_date
if child.get("rela_eff_begn_date"):
child["rela_eff_begn_date"] = child["rela_eff_begn_date"].strftime("%Y-%m-%d %H:%M:%S")
else:
child["rela_eff_begn_date"] = datetime.now().strftime("%Y-%m-%d %H:%M:%S")
# 设置 rela_eff_end_date
if child.get("rela_eff_end_date"):
child["rela_eff_end_date"] = child["rela_eff_end_date"].strftime("%Y-%m-%d %H:%M:%S")
else:
child["rela_eff_end_date"] = datetime(year=2999, month=12, day=31, hour=0, minute=0, second=0).strftime("%Y-%m-%d %H:%M:%S")
child["upd_prsn"] = request.upd_prsn
child["rela_status"] = "1"
await DataStdDao.edit_catalog_child_dao(query_db, catalog_data)
await query_db.commit()
return CrudResponseModel(is_success=True, message='更新成功')
except Exception as e:
await query_db.rollback()
raise ServiceException(message=f"更新目录时发生错误: {str(e)}")
@classmethod
async def delete_catalog_services(cls, query_db: AsyncSession, request: DeleteDataCatalogModel,user_id):
"""
删除数据目录信息service
:param query_db: orm对象
:param request: 删除数据目录请求对象
:return: 删除目录操作结果
"""
if request.content_onums:
content_onum_list = request.content_onums.split(',')
try:
for belt_data_std_content in content_onum_list:
catalog = await cls.get_catalog_detail_services(query_db, int(belt_data_std_content))
if not catalog:
raise ServiceException(message=f'目录ID {belt_data_std_content} 不存在')
await DataStdDao.delete_catalog_dao(query_db, DeleteDataCatalogModel(content_onums=belt_data_std_content))
# await DataStdDao.delete_ast_book_mark_rela_by_content_onum(query_db, int(belt_data_std_content), user_id)
await query_db.commit()
return CrudResponseModel(is_success=True, message='删除成功')
except Exception as e:
await query_db.rollback()
raise e
else:
raise ServiceException(message='传入目录id为空')
@classmethod
async def get_data_asset_catalog_tree_services(cls, query_db: AsyncSession):
"""
获取数据资产树信息service
:param query_db: orm对象
:return: 数据资产树信息对象
"""
# 从 DAO 层获取数据
rows = await DataStdDao.get_data_asset_catalog_tree(query_db)
# 使用字典暂存分组数据
sys_groups = {}
for item in rows:
src_sys, eng_name, cn_name, ast_no = item
# 创建或获取系统分组
if src_sys not in sys_groups:
sys_groups[src_sys] = {
"dataAssetSysName": src_sys,
"children": []
}
# 添加子节点
sys_groups[src_sys]["children"].append({
"dataAssetCatalogNo": eng_name,
"dataAssetCatalogName": cn_name,
"dataAssetCatalogAstno": ast_no
})
results = list(sys_groups.values())
# 转换为最终列表格式
return results
@classmethod
async def moved_catalog_instr_services(cls, query_db: AsyncSession, request: DataCatalogMovedRequest):
"""
移动数据目录service
"""
moved_catalog_data = {
'belt_data_std_content': request.belt_data_std_content,
'supr_content_onum': request.supr_content_onum,
'supr_content_onum_after': request.supr_content_onum_after
}
try:
await DataStdDao.moved_catalog_instr_dao(query_db, moved_catalog_data)
await query_db.commit()
return CrudResponseModel(is_success=True, message='目录移动成功')
except Exception as e:
await query_db.rollback()
raise ServiceException(message=f"移动目录时发生错误: {str(e)}")
@classmethod
async def merge_catalog_instr_services(cls, query_db: AsyncSession, request: DataCatalogMergeRequest):
"""
移动数据目录service
"""
merge_catalog_data = {
'belt_data_std_content': request.belt_data_std_content,
'supr_content_onum': request.supr_content_onum,
'content_onum_after': request.content_onum_after,
'supr_content_onum_after': request.supr_content_onum_after
}
try:
await DataStdDao.merge_catalog_instr_dao(query_db, merge_catalog_data)
await query_db.commit()
return CrudResponseModel(is_success=True, message='目录合并成功')
except Exception as e:
await query_db.rollback()
raise ServiceException(message=f"目录合并时发生错误: {str(e)}")
@classmethod
async def removerel_data_ast_catalog_services(cls, query_db: AsyncSession, request: DataCatalogChild):
"""
移除数据资产目录service
"""
removerel_catalog_data = {
'rela_onum': request.rela_onum,
'belt_data_std_content': request.belt_data_std_content,
'ast_onum': request.ast_onum,
'rela_type': request.rela_type,
'rela_eff_begn_date': request.rela_eff_begn_date,
'rela_eff_end_date': request.rela_eff_end_date,
'upd_prsn': request.upd_prsn,
'rela_status': request.rela_status
}
try:
await DataStdDao.removerel_data_ast_catalog_dao(query_db, removerel_catalog_data)
await query_db.commit()
return CrudResponseModel(is_success=True, message='资产移除成功')
except Exception as e:
await query_db.rollback()
raise ServiceException(message=f"移除资产时发生错误: {str(e)}")
@classmethod
async def moverel_data_ast_catalog_services(cls, query_db: AsyncSession, request: DataCatalogMoverelRequest):
"""
移动数据目录service
"""
moverel_catalog_data = {
'rela_onum': request.rela_onum,
'belt_data_std_content': request.belt_data_std_content,
'content_onum_after': request.content_onum_after
}
try:
await DataStdDao.moverel_data_ast_catalog_dao(query_db, moverel_catalog_data)
await query_db.commit()
return CrudResponseModel(is_success=True, message='资产移动成功')
except Exception as e:
await query_db.rollback()
raise ServiceException(message=f"资产移动时发生错误: {str(e)}")
#------------------------------------------------------------数据标准--------------------------------------------------------------------------------------------------------------
@classmethod
async def check_std_num_unique(cls, query_db: AsyncSession, model: DataStdMainModel):
"""
校验标准编号是否唯一
"""
id = '-1' if model.onum is None else model.onum
check_model = DataStdMainModel()
check_model.data_std_no=model.data_std_no
existing = await DataStdDao.get_data_main_by_info(query_db, check_model)
return CommonConstant.NOT_UNIQUE if existing and existing.onum != id else CommonConstant.UNIQUE
@classmethod
async def get_std_main_list(cls, query_db: AsyncSession, query_object: DataStdMainModel, is_page: bool = False):
return await DataStdDao.get_std_main_list(query_db, query_object, is_page)
@classmethod
async def get_std_main_appr_list(cls, query_db: AsyncSession, query_object: DataStdMainApprModel, is_page: bool = False):
return await DataStdDao.get_std_main_appr_list(query_object.flowId, query_db)
@classmethod
async def get_std_dict_appr_list(cls, query_db: AsyncSession, query_object: DataStdDictApprModel, is_page: bool = False):
return await DataStdDao.get_std_dict_appr_list(query_object.flowId, query_db)
@classmethod
async def get_std_main_list_all(cls, query_db: AsyncSession, query_object: DataStdMainModel):
main_query_result= await DataStdDao.get_std_main_list_all(query_db, query_object)
return main_query_result
@classmethod
async def get_std_main_by_id(cls, query_db: AsyncSession, id: str):
mainstd= await DataStdDao.get_std_main_by_id(query_db, id)
if mainstd:
return DataStdMainModel(**CamelCaseUtil.transform_result(mainstd))
else:
return DataStdMainModel(**dict())
@classmethod
async def get_std_main_appr_by_id(cls, query_db: AsyncSession, id: str):
mainstd= await DataStdDao.get_std_main_appr_by_id(query_db, id)
if mainstd:
return DataStdMainModel(**CamelCaseUtil.transform_result(mainstd))
else:
return DataStdMainModel(**dict())
@classmethod
async def get_std_main_change_by_id(cls, query_db: AsyncSession, id: str):
mainstd= await DataStdDao.get_std_main_appr_by_id(query_db, id)
if mainstd:
if mainstd.changeType == "edit":
compareMainstd = await DataStdDao.get_std_main_appr_by_id(query_db, mainstd.compareId)
# 将对象转成 dict,驼峰转小写风格字段
new_data = CamelCaseUtil.transform_result(mainstd)
old_data = CamelCaseUtil.transform_result(compareMainstd) if compareMainstd else {}
result_dict = {}
for key, new_value in new_data.items():
old_value = old_data.get(key)
if new_value != old_value and old_value is not None:
# 有变化,拼接 "旧值 ==> 新值"
result_dict[key] = f"{old_value} ==> {new_value}"
else:
result_dict[key] = new_value
return result_dict # 返回 dict,不是 DataStdMainModel 实例
return DataStdMainModel(**CamelCaseUtil.transform_result(mainstd))
else:
return DataStdMainModel(**dict())
@classmethod
async def get_std_dict_change_by_id(cls, query_db: AsyncSession, id: str):
mainstd= await DataStdDao.get_std_dict_appr_by_id(query_db, id)
if mainstd:
if mainstd.changeType == "edit":
compareMainstd = await DataStdDao.get_std_dict_appr_by_id(query_db, mainstd.compareId)
# 将对象转成 dict,驼峰转小写风格字段
new_data = CamelCaseUtil.transform_result(mainstd)
old_data = CamelCaseUtil.transform_result(compareMainstd) if compareMainstd else {}
result_dict = {}
for key, new_value in new_data.items():
old_value = old_data.get(key)
if new_value != old_value and old_value is not None:
# 有变化,拼接 "旧值 ==> 新值"
result_dict[key] = f"{old_value} ==> {new_value}"
else:
result_dict[key] = new_value
return result_dict # 返回 dict,不是 DataStdMainModel 实例
return DataStdDictModel(**CamelCaseUtil.transform_result(mainstd))
else:
return DataStdDictModel(**dict())
@classmethod
async def add_std_main(cls, query_db: AsyncSession, model: DataStdMainModel):
if not await cls.check_std_num_unique(query_db, model):
raise ServiceException(message=f"标准编号 {model.data_std_no} 已存在")
model.onum=str(uuid.uuid4())
model.std_status="9"
model.belt_data_std_content=2
await DataStdDao.add_std_main(query_db, model)
return CrudResponseModel(is_success=True, message='新增标准成功')
@classmethod
async def edit_std_main(cls, query_db: AsyncSession, model: DataStdMainModel):
if not await cls.check_std_num_unique(query_db, model):
raise ServiceException(message=f"标准编号 {model.data_std_no} 已存在")
existing = await cls.get_std_main_by_id(query_db, model.onum)
if existing:
await DataStdDao.update_std_main(query_db, model.model_dump(exclude_unset=True))
return CrudResponseModel(is_success=True, message='编辑标准成功')
else:
raise ServiceException(message=f'标准 {model.onum} 不存在')
@classmethod
async def add_std_main_appr(cls, query_db: AsyncSession, model: DataStdMainModel):
if not await cls.check_std_num_unique(query_db, model):
raise ServiceException(message=f"标准编号 {model.data_std_no} 已存在")
model.onum=str(uuid.uuid4())
model.std_status="9"
model.belt_data_std_content=2
# 将 DataStdMainModel 转换为 DataStdMainApprModel,保留字段原始名
apprModel = DataStdMainApprModel(**model.model_dump(exclude_unset=True, by_alias=True))
apprModel.changeType="add"
apprModel.compareId=model.onum
apprModel.oldInstId=model.onum
apprModel.approStatus="waiting"
apprModel.flowId=str(uuid.uuid4())
await DataStdDao.add_std_main_appr(query_db, apprModel)
applyModel = ApplyModel()
applyModel.businessType = "dataStdMain"
applyModel.businessId = apprModel.flowId
applyModel.applicant = apprModel.create_by
await ApprovalService.apply_services(query_db, applyModel, 'dataStdMain')
return CrudResponseModel(is_success=True, message='新增标准成功')
@classmethod
async def add_std_dict_appr(cls, query_db: AsyncSession, model: DataStdDictModel):
if not await cls.check_dict_unique_services(query_db, model):
raise ServiceException(message=f"字典编号 {model.data_dict_no} 已存在")
model.onum=str(uuid.uuid4())
model.data_dict_stat="9"
# 将 DataStdMainModel 转换为 DataStdMainApprModel,保留字段原始名
apprModel = DataStdDictApprModel(**model.model_dump(exclude_unset=True, by_alias=True))
apprModel.changeType="add"
apprModel.compareId=model.onum
apprModel.oldInstId=model.onum
apprModel.approStatus="waiting"
apprModel.flowId=str(uuid.uuid4())
await DataStdDao.add_std_dict_appr(query_db, apprModel)
applyModel = ApplyModel()
applyModel.businessType = "dataStdDict"
applyModel.businessId = apprModel.flowId
applyModel.applicant = apprModel.create_by
await ApprovalService.apply_services(query_db, applyModel, 'dataStdDict')
return CrudResponseModel(is_success=True, message='新增标准成功')
@classmethod
async def edit_std_main_appr(cls, query_db: AsyncSession, model: DataStdMainModel):
if not await cls.check_std_num_unique(query_db, model):
raise ServiceException(message=f"标准编号 {model.data_std_no} 已存在")
model.std_status="9"
# 将 DataStdMainModel 转换为 DataStdMainApprModel,保留字段原始名
watingList=await DataStdDao.check_std_main_waiting(model.onum, query_db)
if len(watingList)>0 : # 如果 watingList 存在,意味着标准正在审批中
raise ServiceException(message="标准正在审批中,请等待审批完成")
lastAppr =await DataStdDao.get_last_std_main_appr_by_id(query_db,model.onum)
apprModel = DataStdMainApprModel(**model.model_dump(exclude_unset=True, by_alias=True))
apprModel.changeType="edit"
apprModel.onum=str(uuid.uuid4())
apprModel.oldInstId=model.onum
apprModel.compareId=lastAppr.onum
apprModel.approStatus="waiting"
apprModel.flowId=str(uuid.uuid4())
await DataStdDao.add_std_main_appr(query_db, apprModel)
applyModel = ApplyModel()
applyModel.businessType = "dataStdMain"
applyModel.businessId = apprModel.flowId
applyModel.applicant = apprModel.create_by
await ApprovalService.apply_services(query_db, applyModel, 'dataStdMain')
return CrudResponseModel(is_success=True, message='修改标准成功')
@classmethod
async def edit_std_dict_appr(cls, query_db: AsyncSession, model: DataStdDictModel):
if not await cls.check_dict_unique_services(query_db, model):
raise ServiceException(message=f"字典编号 {model.c} 已存在")
model.data_dict_stat="9"
watingList=await DataStdDao.check_std_dict_waiting(model.onum, query_db)
if len(watingList)>0 : # 如果 watingList 存在,意味着标准正在审批中
raise ServiceException(message="标准正在审批中,请等待审批完成")
lastAppr =await DataStdDao.get_last_std_dict_appr_by_id(query_db,model.onum)
apprModel = DataStdDictApprModel(**model.model_dump(exclude_unset=True, by_alias=True))
apprModel.changeType="edit"
apprModel.onum=str(uuid.uuid4())
apprModel.oldInstId=model.onum
apprModel.compareId=lastAppr.onum
apprModel.approStatus="waiting"
apprModel.flowId=str(uuid.uuid4())
await DataStdDao.add_std_dict_appr(query_db, apprModel)
applyModel = ApplyModel()
applyModel.businessType = "dataStdDict"
applyModel.businessId = apprModel.flowId
applyModel.applicant = apprModel.create_by
await ApprovalService.apply_services(query_db, applyModel, 'dataStdDict')
return CrudResponseModel(is_success=True, message='修改标准成功')
@classmethod
async def delete_std_main_Appr(cls, query_db: AsyncSession, ids: str):
if ids:
col_id_list = ids.split(',')
try:
for col_id in col_id_list:
col_info = await cls.get_std_main_by_id(query_db, col_id)
if col_info:
watingList=await DataStdDao.check_std_main_waiting(col_info.onum,query_db )
if len(watingList)>0 : # 如果 watingList 存在,意味着标准正在审批中
raise ServiceException(message="标准正在审批中,请等待审批完成")
apprModel = DataStdMainApprModel(**col_info.model_dump(exclude_unset=True, by_alias=True))
apprModel.changeType="delete"
apprModel.onum=str(uuid.uuid4())
apprModel.oldInstId=col_info.onum
apprModel.approStatus="waiting"
apprModel.flowId=str(uuid.uuid4())
await DataStdDao.add_std_main_appr(query_db, apprModel)
applyModel = ApplyModel()
applyModel.businessType = "dataStdMain"
applyModel.businessId = apprModel.flowId
applyModel.applicant = apprModel.create_by
await ApprovalService.apply_services(query_db, applyModel, 'dataStdMain')
await query_db.commit()
return CrudResponseModel(is_success=True, message='提交删除标准审批成功')
except Exception as e:
await query_db.rollback()
raise e
else:
raise ServiceException(message='传入标准ID为空')
@classmethod
async def delete_std_dict_Appr(cls, query_db: AsyncSession, ids: str):
if ids:
col_id_list = ids.split(',')
try:
for col_id in col_id_list:
col_info = await cls.get_std_dict_by_id_services(query_db, col_id)
if col_info:
watingList=await DataStdDao.check_std_dict_waiting(col_info.onum,query_db )
if len(watingList)>0 : # 如果 watingList 存在,意味着标准正在审批中
raise ServiceException(message="标准正在审批中,请等待审批完成")
apprModel = DataStdDictApprModel(**col_info.model_dump(exclude_unset=True, by_alias=True))
apprModel.changeType="delete"
apprModel.onum=str(uuid.uuid4())
apprModel.oldInstId=col_info.onum
apprModel.approStatus="waiting"
apprModel.flowId=str(uuid.uuid4())
await DataStdDao.add_std_dict_appr(query_db, apprModel)
applyModel = ApplyModel()
applyModel.businessType = "dataStdDict"
applyModel.businessId = apprModel.flowId
applyModel.applicant = apprModel.create_by
await ApprovalService.apply_services(query_db, applyModel, 'dataStdDict')
await query_db.commit()
return CrudResponseModel(is_success=True, message='提交删除字典审批成功')
except Exception as e:
await query_db.rollback()
raise e
else:
raise ServiceException(message='传入标准ID为空')
@classmethod
async def delete_std_main(cls, query_db: AsyncSession, ids: str):
if ids:
col_id_list = ids.split(',')
try:
for col_id in col_id_list:
col_info = await cls.get_std_main_by_id(query_db, col_id)
if col_info:
# 校验不能删除的系统内置列
await DataStdDao.delete_std_main(query_db, col_id)
await query_db.commit()
return CrudResponseModel(is_success=True, message='删除标准成功')
except Exception as e:
await query_db.rollback()
raise e
else:
raise ServiceException(message='传入标准ID为空')
@classmethod
async def change_std_main_onum(cls, query_db: AsyncSession, ids: str,onum:int):
if ids:
col_id_list = ids.split(',')
try:
for col_id in col_id_list:
col_info = await cls.get_std_main_by_id(query_db, col_id)
if col_info:
col_info.belt_data_std_content=onum
await DataStdDao.update_std_main(query_db,col_info.model_dump(exclude_unset=True) )
await query_db.commit()
return CrudResponseModel(is_success=True, message='修改标准分类成功')
except Exception as e:
await query_db.rollback()
raise e
else:
raise ServiceException(message='传入标准ID为空')
@classmethod
async def get_code_std_map_list_services(cls, query_db: AsyncSession, id: str):
# 查询 A 表(t_datastd_main)
check_model = DataStdMainModel()
check_model.cd_id = id
main_list = await DataStdDao.get_std_main_list_all(query_db, check_model)
dataStdNo=await DataStdDao.get_std_code_by_id(query_db, id)
if not main_list:
return {"tableData": [], "children": []} # 如果 A 表没有数据,返回空结构
table_data = [] # 存储表格数据
children = [] # 存储图谱数据
for main in main_list:
# 查询 B 表(t_datastd_dict),通过 A 表的 id 匹配 data_std_no
dict_model = DataStdDictModel()
dict_model.data_std_no = main.get('id') # 使用 get() 方法访问字段
dict_list = await DataStdDao.get_std_dict_list_all(query_db, dict_model)
# 组织表格数据
if dict_list:
for dict_item in dict_list:
table_data.append({
"cdNo": dataStdNo.cd_no, # 使用 get() 方法访问字段
"cdValCnMean": dataStdNo.cd_val_cn_mean, # 使用 get() 方法访问字段
"dataStdNo": main.get('dataStdNo'), # 使用 get() 方法访问字段
"dataStdCnName": main.get('dataStdCnName'), # 使用 get() 方法访问字段
"dataStdNo": main.get('dataStdNo'), # 使用 get() 方法访问字段
"dataDictNo": dict_item.get('dataDictNo'), # 使用 get() 方法访问字段
"dataDictCnName": dict_item.get('dataDictCnName'), # 使用 get() 方法访问字段
"dataDictEngName": dict_item.get('dataDictEngName'), # 使用 get() 方法访问字段
})
else :
table_data.append({
"cdNo": dataStdNo.cd_no, # 使用 get() 方法访问字段
"cdValCnMean": dataStdNo.cd_val_cn_mean, # 使用 get() 方法访问字段
"dataStdNo": main.get('dataStdNo'), # 使用 get() 方法访问字段
"dataStdCnName": main.get('dataStdCnName'), # 使用 get() 方法访问字段
"dataStdNo": main.get('dataStdNo'), # 使用 get() 方法访问字段
"dataDictNo": "", # 使用 get() 方法访问字段
"dataDictCnName":"", # 使用 get() 方法访问字段
"dataDictEngName": "", # 使用 get() 方法访问字段
})
# 组织图谱数据(A 表作为父节点)
node = {
"id": f"node_{main.get('id')}", # 使用 get() 方法访问字段
"name": main.get('dataStdCnName'), # 使用 get() 方法访问字段
"label": main.get('dataStdNo'), # 使用 get() 方法访问字段
"rate": 1.0,
"status": "B",
"currency": main.get('dataStdNo'), # 使用 get() 方法访问字段
"variableValue": "标准",
"variableUp": True,
"children": [],
}
# B 表数据作为子节点
for dict_item in dict_list:
node["children"].append({
"id": f"dict_{dict_item.get('id')}", # 使用 get() 方法访问字段
"name": dict_item.get('dataDictCnName'), # 使用 get() 方法访问字段
"label": dict_item.get('dataDictEngName'), # 使用 get() 方法访问字段
"rate": 1.0,
"status": "R",
"currency": dict_item.get('dataDictNo'), # 使用 get() 方法访问字段
"variableValue": "词典",
"variableUp": True,
})
children.append(node)
return {
"tableData": table_data,
"children": children
}
@classmethod
async def get_code_map_list(cls, query_db: AsyncSession, id: str):
check_model = DataStdCodeModel()
dataStdNo=await DataStdDao.get_std_code_by_id(query_db, id)
cd_type="公司级"
if dataStdNo.cd_type=='sys':
if dataStdNo.code_map_id:
check_model.onum=dataStdNo.code_map_id
else:
check_model.onum="no"
else:
check_model.code_map_id = id
cd_type="系统级"
main_list = await DataStdDao.get_data_code_list_by_info(query_db, check_model)
if not main_list:
return { "children": []} # 如果 A 表没有数据,返回空结构
table_data = [] # 存储表格数据
children = [] # 存储图谱数据
for main in main_list:
# 组织图谱数据(A 表作为父节点)
node = {
"id": f"node_{main.onum}", # 使用 get() 方法访问字段
"name": main.cd_val_cn_mean, # 使用 get() 方法访问字段
"label": main.cd_no, # 使用 get() 方法访问字段
"rate": 1.0,
"status": "B",
# "currency": main.get('dataStdNo'), # 使用 get() 方法访问字段
"variableValue": cd_type,
"variableUp": True,
"children": [],
}
children.append(node)
return {
"tableData": table_data,
"children": children
}