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.
819 lines
34 KiB
819 lines
34 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
|
|
from utils.common_util import CamelCaseUtil
|
|
import uuid
|
|
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
|
|
|
|
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_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.code_status="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 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.id)
|
|
|
|
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.id}不存在')
|
|
|
|
|
|
@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.code_name}失败，{code.code_num}代码已存在')
|
|
else:
|
|
# 保存标准代码
|
|
code.id=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.id
|
|
if not await cls.check_code_unique_services(query_db, code_item):
|
|
raise ServiceException(message=f"父级代码{code.code_num}下的代码项{code_item.code_num}已存在")
|
|
|
|
# 将parent_id设为code的ID
|
|
code_item.id=str(uuid.uuid4())
|
|
code_item.create_by=code.create_by
|
|
code_item.create_time=code.create_time
|
|
code_item.update_by=code.update_by
|
|
code_item.update_time=code.update_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 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.code_name}失败，{code.code_num}代码不存在或已存在')
|
|
|
|
# 更新标准代码
|
|
await cls.edit_std_code_services(request, query_db, code)
|
|
|
|
# 为每个代码项设置parent_id，并进行校验
|
|
for code_item in code_item_list:
|
|
code_item.parent_id = code.id
|
|
if code_item.id :
|
|
# 校验同一个父级下，code_num是否已存在
|
|
if not await cls.check_code_unique_services(query_db, code_item):
|
|
raise ServiceException(message=f"父级代码{code.code_num}下的代码项{code_item.code_num}已存在")
|
|
|
|
# 更新代码项的相关信息
|
|
code_item.update_time = code.update_time
|
|
code_item.update_by = code.update_by
|
|
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.code_num}下的代码项{code_item.code_num}已存在")
|
|
# 生成新的UUID，并新增代码项
|
|
code_item.id = str(uuid.uuid4()) # 新生成的UUID
|
|
code_item.create_time = code.update_time
|
|
code_item.create_by = code.create_by
|
|
code_item.update_time = code.update_time
|
|
code_item.update_by = code.update_by
|
|
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 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.id is None else page_object.id
|
|
codemodel=DataStdCodeModel()
|
|
codemodel.code_num=page_object.code_num
|
|
codemodel.class_id=page_object.class_id
|
|
codemodel.parent_id=page_object.parent_id
|
|
codemodel.code_type=page_object.code_type
|
|
dict_type = await DataStdDao.get_data_code_by_info(query_db, codemodel
|
|
)
|
|
if dict_type and dict_type.id != 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.dict_num}已存在")
|
|
# 创建新的 page_object 实例，避免修改原始对象
|
|
new_page_object = DataStdDictModel(**page_object.model_dump(by_alias=True))
|
|
new_page_object.dict_status="9"
|
|
new_page_object.id=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.dict_num}已存在")
|
|
edit_col = page_object.model_dump(exclude_unset=True)
|
|
col_info = await cls.get_std_dict_by_id_services(query_db, page_object.id)
|
|
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.id}不存在')
|
|
|
|
|
|
@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.id is None else page_object.id
|
|
codemodel=DataStdDictModel()
|
|
codemodel.dict_num=page_object.dict_num
|
|
|
|
dict_type = await DataStdDao.get_data_dict_by_info(query_db, codemodel
|
|
)
|
|
if dict_type and dict_type.id != 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 content_onum, 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[content_onum] = common_fields
|
|
|
|
|
|
# 构建父子关系
|
|
root = None
|
|
for content_onum, 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 content_onum, 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, content_onum: int):
|
|
"""
|
|
获取数据目录详细信息service
|
|
|
|
:param query_db: orm对象
|
|
:param content_onum: 数据目录ID
|
|
:return: 数据目录详细信息对象
|
|
"""
|
|
|
|
catalog_detail_result = await DataStdDao.get_catalog_by_id(query_db, content_onum)
|
|
|
|
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,content_onum : int, leaf_node_flag : int):
|
|
"""
|
|
编辑数据目录信息service
|
|
|
|
:param query_db: orm对象
|
|
:param request: 编辑数据目录请求对象
|
|
:return: 编辑目录操作结果
|
|
"""
|
|
catalog_data1 = {
|
|
'content_onum': content_onum,
|
|
'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 = {
|
|
'content_onum': request.content_onum,
|
|
'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 content_onum in content_onum_list:
|
|
catalog = await cls.get_catalog_detail_services(query_db, int(content_onum))
|
|
if not catalog:
|
|
raise ServiceException(message=f'目录ID {content_onum} 不存在')
|
|
await DataStdDao.delete_catalog_dao(query_db, DeleteDataCatalogModel(content_onums=content_onum))
|
|
# await DataStdDao.delete_ast_book_mark_rela_by_content_onum(query_db, int(content_onum), 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:
|
|
sys_name, eng_name, cn_name, ast_no = item
|
|
# 创建或获取系统分组
|
|
if sys_name not in sys_groups:
|
|
sys_groups[sys_name] = {
|
|
"dataAssetSysName": sys_name,
|
|
"children": []
|
|
}
|
|
|
|
# 添加子节点
|
|
sys_groups[sys_name]["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 = {
|
|
'content_onum': request.content_onum,
|
|
'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 = {
|
|
'content_onum': request.content_onum,
|
|
'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,
|
|
'content_onum': request.content_onum,
|
|
'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,
|
|
'content_onum': request.content_onum,
|
|
'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.id is None else model.id
|
|
check_model = DataStdMainModel()
|
|
check_model.std_num=model.std_num
|
|
existing = await DataStdDao.get_data_main_by_info(query_db, check_model)
|
|
return CommonConstant.NOT_UNIQUE if existing and existing.id != 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_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 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.std_num} 已存在")
|
|
model.id=str(uuid.uuid4())
|
|
model.std_status="9"
|
|
model.content_onum=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.std_num} 已存在")
|
|
existing = await cls.get_std_main_by_id(query_db, model.id)
|
|
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.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为空')
|