wren
1071 lines
50 KiB
Python
1071 lines
50 KiB
Python
"""评查点分组服务实现（新链路：文档类型 -> 子类型 -> 规则集）。"""
|
||
|
||
from __future__ import annotations
|
||
|
||
from datetime import datetime
|
||
from typing import Any
|
||
|
||
from sqlalchemy import bindparam, text
|
||
|
||
from fastapi_common.fastapi_common_storage.oss_path_utils import OssPathUtils
|
||
from fastapi_common.fastapi_common_sqlalchemy.database import GetAsyncSession
|
||
from fastapi_common.fastapi_common_web.domain.responses import StatusCodeEnum
|
||
from fastapi_common.fastapi_common_web.exception.LeauditException import LeauditException
|
||
from fastapi_modules.fastapi_leaudit.domian.Dto.evaluationPointGroupDto import (
|
||
EvaluationPointGroupBatchDeleteDTO,
|
||
EvaluationPointGroupBatchStatusDTO,
|
||
EvaluationPointGroupBindingCreateDTO,
|
||
EvaluationPointGroupBindingUpdateDTO,
|
||
EvaluationPointGroupCreateDTO,
|
||
EvaluationPointGroupRuleDraftCreateDTO,
|
||
EvaluationPointGroupRebindDTO,
|
||
EvaluationPointGroupUpdateDTO,
|
||
)
|
||
from fastapi_modules.fastapi_leaudit.domian.vo.evaluationPointGroupVo import (
|
||
EvaluationPointGroupBatchDeleteVO,
|
||
EvaluationPointGroupBatchStatusVO,
|
||
EvaluationPointGroupDeleteVO,
|
||
EvaluationPointGroupListVO,
|
||
EvaluationPointGroupRuleDraftVO,
|
||
EvaluationPointGroupRuleTemplateContextVO,
|
||
EvaluationPointGroupRuleTemplateVO,
|
||
EvaluationPointGroupRebindVO,
|
||
EvaluationPointGroupVO,
|
||
RuleGroupBindingVO,
|
||
)
|
||
from fastapi_modules.fastapi_leaudit.services.evaluationPointGroupService import IEvaluationPointGroupService
|
||
from fastapi_modules.fastapi_leaudit.services.impl.ruleGroupSupport import (
|
||
bootstrap_rule_groups,
|
||
ensure_rule_group_schema,
|
||
sync_doc_type_bindings_from_group,
|
||
)
|
||
from fastapi_modules.fastapi_leaudit.services.impl.ruleServiceImpl import GetRuleServiceSingleton
|
||
|
||
|
||
class EvaluationPointGroupServiceImpl(IEvaluationPointGroupService):
|
||
"""评查点分组服务实现。"""
|
||
|
||
def __init__(self) -> None:
|
||
self.RuleService = GetRuleServiceSingleton()
|
||
|
||
async def ListGroups(
|
||
self,
|
||
Name: str | None,
|
||
Code: str | None,
|
||
IsEnabled: bool | None,
|
||
Pid: int | None,
|
||
Page: int,
|
||
PageSize: int,
|
||
) -> EvaluationPointGroupListVO:
|
||
async with GetAsyncSession() as session:
|
||
await self._ensure_ready(session)
|
||
offset = max(Page - 1, 0) * PageSize
|
||
filters = ["g.deleted_at IS NULL", "(COALESCE(g.pid, 0) <> 0 OR g.document_type_id IS NOT NULL OR g.entry_module_id IS NOT NULL)"]
|
||
params: dict[str, Any] = {"limit": PageSize, "offset": offset}
|
||
|
||
if Name:
|
||
filters.append("g.name ILIKE :name")
|
||
params["name"] = f"%{Name.strip()}%"
|
||
if Code:
|
||
filters.append("g.code ILIKE :code")
|
||
params["code"] = f"%{Code.strip()}%"
|
||
if IsEnabled is not None:
|
||
filters.append("g.is_enabled = :is_enabled")
|
||
params["is_enabled"] = IsEnabled
|
||
if Pid is not None:
|
||
filters.append("COALESCE(g.pid, 0) = :pid")
|
||
params["pid"] = self._normalize_pid(Pid)
|
||
|
||
where_clause = " AND ".join(filters)
|
||
total = int(
|
||
(
|
||
await session.execute(
|
||
text(f"SELECT COUNT(*) FROM leaudit_evaluation_point_groups g WHERE {where_clause}"),
|
||
params,
|
||
)
|
||
).scalar_one()
|
||
)
|
||
rows = (
|
||
await session.execute(
|
||
text(
|
||
f"""
|
||
SELECT
|
||
g.id,
|
||
g.pid,
|
||
g.name,
|
||
g.code,
|
||
g.description,
|
||
g.document_type_id,
|
||
dt.name AS document_type_name,
|
||
COALESCE(g.entry_module_id, parent.entry_module_id, dt.entry_module_id) AS entry_module_id,
|
||
em.name AS entry_module_name,
|
||
g.sort_order,
|
||
g.is_enabled,
|
||
g.created_at,
|
||
g.updated_at,
|
||
COALESCE(bg.binding_count, 0) AS rule_count
|
||
FROM leaudit_evaluation_point_groups g
|
||
LEFT JOIN leaudit_document_types dt ON dt.id = g.document_type_id
|
||
LEFT JOIN leaudit_evaluation_point_groups parent ON parent.id = g.pid AND parent.deleted_at IS NULL
|
||
LEFT JOIN leaudit_entry_modules em ON em.id = COALESCE(g.entry_module_id, parent.entry_module_id, dt.entry_module_id)
|
||
LEFT JOIN (
|
||
SELECT group_id, COUNT(*)::int AS binding_count
|
||
FROM leaudit_rule_group_bindings
|
||
WHERE deleted_at IS NULL
|
||
GROUP BY group_id
|
||
) bg ON bg.group_id = g.id
|
||
WHERE {where_clause}
|
||
ORDER BY COALESCE(g.sort_order, 0) ASC, g.id ASC
|
||
LIMIT :limit OFFSET :offset
|
||
"""
|
||
),
|
||
params,
|
||
)
|
||
).mappings().all()
|
||
binding_map = await self._load_binding_map(session, [int(row["id"]) for row in rows])
|
||
return EvaluationPointGroupListVO(
|
||
data=[self._to_group_vo(row, binding_map.get(int(row["id"]), []), include_rule_count=True) for row in rows],
|
||
total=total,
|
||
page=Page,
|
||
page_size=PageSize,
|
||
)
|
||
|
||
async def ListAllGroups(self, IncludeDisabled: bool, WithRuleCount: bool) -> list[EvaluationPointGroupVO]:
|
||
async with GetAsyncSession() as session:
|
||
await self._ensure_ready(session)
|
||
filters = ["g.deleted_at IS NULL", "(COALESCE(g.pid, 0) <> 0 OR g.document_type_id IS NOT NULL OR g.entry_module_id IS NOT NULL)"]
|
||
if not IncludeDisabled:
|
||
filters.append("g.is_enabled = TRUE")
|
||
rows = (
|
||
await session.execute(
|
||
text(
|
||
f"""
|
||
SELECT
|
||
g.id,
|
||
g.pid,
|
||
g.name,
|
||
g.code,
|
||
g.description,
|
||
g.document_type_id,
|
||
dt.name AS document_type_name,
|
||
COALESCE(g.entry_module_id, parent.entry_module_id, dt.entry_module_id) AS entry_module_id,
|
||
em.name AS entry_module_name,
|
||
g.sort_order,
|
||
g.is_enabled,
|
||
g.created_at,
|
||
g.updated_at,
|
||
COALESCE(bg.binding_count, 0) AS rule_count
|
||
FROM leaudit_evaluation_point_groups g
|
||
LEFT JOIN leaudit_document_types dt ON dt.id = g.document_type_id
|
||
LEFT JOIN leaudit_evaluation_point_groups parent ON parent.id = g.pid AND parent.deleted_at IS NULL
|
||
LEFT JOIN leaudit_entry_modules em ON em.id = COALESCE(g.entry_module_id, parent.entry_module_id, dt.entry_module_id)
|
||
LEFT JOIN (
|
||
SELECT group_id, COUNT(*)::int AS binding_count
|
||
FROM leaudit_rule_group_bindings
|
||
WHERE deleted_at IS NULL
|
||
GROUP BY group_id
|
||
) bg ON bg.group_id = g.id
|
||
WHERE {' AND '.join(filters)}
|
||
ORDER BY COALESCE(g.sort_order, 0) ASC, g.id ASC
|
||
"""
|
||
)
|
||
)
|
||
).mappings().all()
|
||
binding_map = await self._load_binding_map(session, [int(row["id"]) for row in rows])
|
||
|
||
groups = [self._to_group_vo(row, binding_map.get(int(row["id"]), []), include_rule_count=WithRuleCount) for row in rows]
|
||
by_parent: dict[int, list[EvaluationPointGroupVO]] = {}
|
||
roots: list[EvaluationPointGroupVO] = []
|
||
for group in groups:
|
||
parent_id = self._normalize_pid(group.pid)
|
||
if parent_id == 0:
|
||
roots.append(group)
|
||
else:
|
||
by_parent.setdefault(parent_id, []).append(group)
|
||
for group in groups:
|
||
children = by_parent.get(group.id)
|
||
if children:
|
||
group.children = children
|
||
return roots
|
||
|
||
async def ListGroupsByDocumentTypes(
|
||
self,
|
||
DocumentTypeIds: list[int],
|
||
IncludeDisabled: bool,
|
||
WithRuleCount: bool,
|
||
) -> list[EvaluationPointGroupVO]:
|
||
normalized_ids = sorted({int(item) for item in DocumentTypeIds if item})
|
||
if not normalized_ids:
|
||
return []
|
||
roots = await self.ListAllGroups(IncludeDisabled=IncludeDisabled, WithRuleCount=WithRuleCount)
|
||
result: list[EvaluationPointGroupVO] = []
|
||
for root in roots:
|
||
if root.document_type_id in normalized_ids:
|
||
result.append(root)
|
||
continue
|
||
children = root.children or []
|
||
if any(child.document_type_id in normalized_ids for child in children):
|
||
result.append(root)
|
||
return result
|
||
|
||
async def GetGroup(self, GroupId: int, WithRuleCount: bool) -> EvaluationPointGroupVO:
|
||
async with GetAsyncSession() as session:
|
||
await self._ensure_ready(session)
|
||
row = await self._get_group_row(session, GroupId)
|
||
binding_map = await self._load_binding_map(session, [GroupId])
|
||
return self._to_group_vo(row, binding_map.get(GroupId, []), include_rule_count=WithRuleCount)
|
||
|
||
async def GetChildren(self, GroupId: int, IsEnabled: bool | None, Page: int, PageSize: int) -> EvaluationPointGroupListVO:
|
||
await self.GetGroup(GroupId, WithRuleCount=False)
|
||
return await self.ListGroups(Name=None, Code=None, IsEnabled=IsEnabled, Pid=GroupId, Page=Page, PageSize=PageSize)
|
||
|
||
async def CreateGroup(self, Body: EvaluationPointGroupCreateDTO) -> EvaluationPointGroupVO:
|
||
payload = self._normalize_create_payload(Body)
|
||
async with GetAsyncSession() as session:
|
||
await self._ensure_ready(session)
|
||
await self._ensure_code_unique(session, payload["code"], None)
|
||
parent = await self._ensure_parent_valid(session, payload["pid"])
|
||
payload["entry_module_id"] = await self._ensure_entry_module_valid(
|
||
session, payload["pid"], payload["entry_module_id"], parent
|
||
)
|
||
payload["document_type_id"] = await self._ensure_document_type_valid(
|
||
session, payload["pid"], payload["document_type_id"], payload["entry_module_id"], None, parent
|
||
)
|
||
row = (
|
||
await session.execute(
|
||
text(
|
||
"""
|
||
INSERT INTO leaudit_evaluation_point_groups (
|
||
pid, code, name, description, document_type_id, entry_module_id, sort_order, is_enabled, created_at, updated_at
|
||
) VALUES (
|
||
:pid, :code, :name, :description, :document_type_id, :entry_module_id, :sort_order, :is_enabled, NOW(), NOW()
|
||
)
|
||
RETURNING id
|
||
"""
|
||
),
|
||
payload,
|
||
)
|
||
).mappings().one()
|
||
await session.commit()
|
||
group_id = int(row["id"])
|
||
return await self.GetGroup(group_id, WithRuleCount=True)
|
||
|
||
async def UpdateGroup(self, GroupId: int, Body: EvaluationPointGroupUpdateDTO) -> EvaluationPointGroupVO:
|
||
async with GetAsyncSession() as session:
|
||
await self._ensure_ready(session)
|
||
current = await self._get_group_row(session, GroupId)
|
||
provided_fields = set(getattr(Body, "model_fields_set", set()))
|
||
next_pid = self._normalize_pid(Body.pid) if Body.pid is not None else self._normalize_pid(current["pid"])
|
||
name = (Body.name.strip() if Body.name is not None else str(current.get("name") or "")).strip()
|
||
code = (Body.code.strip() if Body.code is not None else str(current.get("code") or "")).strip()
|
||
description = Body.description.strip() if Body.description is not None and Body.description else current.get("description")
|
||
document_type_id = Body.document_type_id if "document_type_id" in provided_fields else current.get("document_type_id")
|
||
entry_module_id = Body.entry_module_id if "entry_module_id" in provided_fields else current.get("entry_module_id")
|
||
sort_order = Body.sort_order if Body.sort_order is not None else int(current.get("sort_order") or 0)
|
||
is_enabled = Body.is_enabled if Body.is_enabled is not None else bool(current.get("is_enabled", True))
|
||
|
||
if not name:
|
||
raise LeauditException(StatusCodeEnum.HTTP_400_BAD_REQUEST, "分组名称不能为空")
|
||
if not code:
|
||
raise LeauditException(StatusCodeEnum.HTTP_400_BAD_REQUEST, "分组编码不能为空")
|
||
|
||
await self._ensure_code_unique(session, code, GroupId)
|
||
parent = await self._ensure_parent_valid(session, next_pid)
|
||
entry_module_id = await self._ensure_entry_module_valid(session, next_pid, entry_module_id, parent)
|
||
document_type_id = await self._ensure_document_type_valid(
|
||
session, next_pid, document_type_id, entry_module_id, GroupId, parent
|
||
)
|
||
await session.execute(
|
||
text(
|
||
"""
|
||
UPDATE leaudit_evaluation_point_groups
|
||
SET pid = :pid,
|
||
code = :code,
|
||
name = :name,
|
||
description = :description,
|
||
document_type_id = :document_type_id,
|
||
entry_module_id = :entry_module_id,
|
||
sort_order = :sort_order,
|
||
is_enabled = :is_enabled,
|
||
updated_at = NOW()
|
||
WHERE id = :group_id
|
||
"""
|
||
),
|
||
{
|
||
"group_id": GroupId,
|
||
"pid": next_pid,
|
||
"code": code,
|
||
"name": name,
|
||
"description": description,
|
||
"document_type_id": document_type_id,
|
||
"entry_module_id": entry_module_id,
|
||
"sort_order": sort_order,
|
||
"is_enabled": is_enabled,
|
||
},
|
||
)
|
||
await sync_doc_type_bindings_from_group(session, GroupId)
|
||
await session.commit()
|
||
return await self.GetGroup(GroupId, WithRuleCount=True)
|
||
|
||
async def DeleteGroup(self, GroupId: int) -> EvaluationPointGroupDeleteVO:
|
||
async with GetAsyncSession() as session:
|
||
await self._ensure_ready(session)
|
||
current = await self._get_group_row(session, GroupId)
|
||
is_root = self._normalize_pid(current["pid"]) == 0
|
||
if is_root:
|
||
child_count = int(
|
||
(
|
||
await session.execute(
|
||
text(
|
||
"SELECT COUNT(*) FROM leaudit_evaluation_point_groups WHERE pid = :group_id AND deleted_at IS NULL"
|
||
),
|
||
{"group_id": GroupId},
|
||
)
|
||
).scalar_one()
|
||
)
|
||
if child_count > 0:
|
||
return EvaluationPointGroupDeleteVO(
|
||
success=False,
|
||
message="当前一级分组下仍存在二级分组，请先迁移或删除二级分组",
|
||
deleted_groups=0,
|
||
deleted_points=0,
|
||
)
|
||
|
||
binding_count = int(
|
||
(
|
||
await session.execute(
|
||
text(
|
||
"SELECT COUNT(*) FROM leaudit_rule_group_bindings WHERE group_id = :group_id AND deleted_at IS NULL"
|
||
),
|
||
{"group_id": GroupId},
|
||
)
|
||
).scalar_one()
|
||
)
|
||
await session.execute(
|
||
text(
|
||
"UPDATE leaudit_rule_group_bindings SET deleted_at = NOW(), updated_at = NOW() WHERE group_id = :group_id AND deleted_at IS NULL"
|
||
),
|
||
{"group_id": GroupId},
|
||
)
|
||
await sync_doc_type_bindings_from_group(session, GroupId)
|
||
result = await session.execute(
|
||
text(
|
||
"UPDATE leaudit_evaluation_point_groups SET deleted_at = NOW(), updated_at = NOW() WHERE id = :group_id AND deleted_at IS NULL"
|
||
),
|
||
{"group_id": GroupId},
|
||
)
|
||
await session.commit()
|
||
deleted_groups = int(result.rowcount or 0)
|
||
return EvaluationPointGroupDeleteVO(
|
||
success=True,
|
||
message="规则分组删除成功",
|
||
deleted_count=deleted_groups,
|
||
deleted_groups=deleted_groups,
|
||
deleted_points=binding_count,
|
||
)
|
||
|
||
async def RebindGroup(self, GroupId: int, Body: EvaluationPointGroupRebindDTO) -> EvaluationPointGroupRebindVO:
|
||
async with GetAsyncSession() as session:
|
||
await self._ensure_ready(session)
|
||
current = await self._get_group_row(session, GroupId)
|
||
target = await self._get_group_row(session, Body.new_parent_id)
|
||
if self._normalize_pid(current["pid"]) != 0 or self._normalize_pid(target["pid"]) != 0:
|
||
raise LeauditException(StatusCodeEnum.HTTP_400_BAD_REQUEST, "仅支持一级分组之间迁移二级分组")
|
||
if GroupId == Body.new_parent_id:
|
||
raise LeauditException(StatusCodeEnum.HTTP_400_BAD_REQUEST, "迁移目标不能与原分组相同")
|
||
result = await session.execute(
|
||
text(
|
||
"""
|
||
UPDATE leaudit_evaluation_point_groups
|
||
SET pid = :new_parent_id,
|
||
updated_at = NOW()
|
||
WHERE pid = :old_group_id AND deleted_at IS NULL
|
||
"""
|
||
),
|
||
{"old_group_id": GroupId, "new_parent_id": Body.new_parent_id},
|
||
)
|
||
await session.commit()
|
||
moved = int(result.rowcount or 0)
|
||
return EvaluationPointGroupRebindVO(success=True, message="二级分组迁移成功", rebind_count=moved, doc_types_updated=moved)
|
||
|
||
async def BatchUpdateStatus(self, Body: EvaluationPointGroupBatchStatusDTO) -> EvaluationPointGroupBatchStatusVO:
|
||
ids = sorted({int(item) for item in Body.ids if item})
|
||
if not ids:
|
||
raise LeauditException(StatusCodeEnum.HTTP_400_BAD_REQUEST, "请选择至少一个分组")
|
||
async with GetAsyncSession() as session:
|
||
await self._ensure_ready(session)
|
||
result = await session.execute(
|
||
text(
|
||
"""
|
||
UPDATE leaudit_evaluation_point_groups
|
||
SET is_enabled = :is_enabled,
|
||
updated_at = NOW()
|
||
WHERE id IN :ids AND deleted_at IS NULL
|
||
"""
|
||
).bindparams(bindparam("ids", expanding=True)),
|
||
{"ids": ids, "is_enabled": Body.is_enabled},
|
||
)
|
||
await session.commit()
|
||
updated_count = int(result.rowcount or 0)
|
||
return EvaluationPointGroupBatchStatusVO(success=True, updated_count=updated_count, message=f"成功更新 {updated_count} 个分组状态")
|
||
|
||
async def BatchDelete(self, Body: EvaluationPointGroupBatchDeleteDTO) -> EvaluationPointGroupBatchDeleteVO:
|
||
ids = sorted({int(item) for item in Body.ids if item})
|
||
if not ids:
|
||
raise LeauditException(StatusCodeEnum.HTTP_400_BAD_REQUEST, "请选择至少一个分组")
|
||
async with GetAsyncSession() as session:
|
||
await self._ensure_ready(session)
|
||
rows = (
|
||
await session.execute(
|
||
text(
|
||
"SELECT id, pid, document_type_id FROM leaudit_evaluation_point_groups WHERE id IN :ids AND deleted_at IS NULL"
|
||
).bindparams(bindparam("ids", expanding=True)),
|
||
{"ids": ids},
|
||
)
|
||
).mappings().all()
|
||
if len(rows) != len(ids):
|
||
raise LeauditException(StatusCodeEnum.HTTP_404_NOT_FOUND, "部分分组不存在")
|
||
if any(self._normalize_pid(row["pid"]) == 0 for row in rows):
|
||
raise LeauditException(StatusCodeEnum.HTTP_400_BAD_REQUEST, "批量删除仅支持二级分组")
|
||
|
||
deleted_bindings = 0
|
||
for row in rows:
|
||
deleted_bindings += int(
|
||
(
|
||
await session.execute(
|
||
text(
|
||
"UPDATE leaudit_rule_group_bindings SET deleted_at = NOW(), updated_at = NOW() WHERE group_id = :group_id AND deleted_at IS NULL"
|
||
),
|
||
{"group_id": int(row["id"])},
|
||
)
|
||
).rowcount
|
||
or 0
|
||
)
|
||
await sync_doc_type_bindings_from_group(session, int(row["id"]))
|
||
result = await session.execute(
|
||
text(
|
||
"UPDATE leaudit_evaluation_point_groups SET deleted_at = NOW(), updated_at = NOW() WHERE id IN :ids AND deleted_at IS NULL"
|
||
).bindparams(bindparam("ids", expanding=True)),
|
||
{"ids": ids},
|
||
)
|
||
await session.commit()
|
||
deleted_groups = int(result.rowcount or 0)
|
||
return EvaluationPointGroupBatchDeleteVO(success=True, deleted_groups=deleted_groups, deleted_points=deleted_bindings, message=f"成功删除 {deleted_groups} 个分组")
|
||
|
||
async def CreateBinding(self, GroupId: int, Body: EvaluationPointGroupBindingCreateDTO) -> RuleGroupBindingVO:
|
||
async with GetAsyncSession() as session:
|
||
await self._ensure_ready(session)
|
||
group = await self._get_group_row(session, GroupId)
|
||
if self._normalize_pid(group["pid"]) == 0:
|
||
raise LeauditException(StatusCodeEnum.HTTP_400_BAD_REQUEST, "一级分组不能直接绑定规则集，请先选择二级分组")
|
||
await self._ensure_rule_set_valid(session, Body.rule_set_id)
|
||
existing = (
|
||
await session.execute(
|
||
text(
|
||
"SELECT id FROM leaudit_rule_group_bindings WHERE group_id = :group_id AND rule_set_id = :rule_set_id AND deleted_at IS NULL LIMIT 1"
|
||
),
|
||
{"group_id": GroupId, "rule_set_id": Body.rule_set_id},
|
||
)
|
||
).mappings().first()
|
||
if existing:
|
||
raise LeauditException(StatusCodeEnum.HTTP_400_BAD_REQUEST, "该规则集已绑定到当前二级分组")
|
||
row = (
|
||
await session.execute(
|
||
text(
|
||
"""
|
||
INSERT INTO leaudit_rule_group_bindings (
|
||
group_id, rule_set_id, priority, is_active, note, created_at, updated_at
|
||
) VALUES (
|
||
:group_id, :rule_set_id, :priority, :is_active, :note, NOW(), NOW()
|
||
)
|
||
RETURNING id
|
||
"""
|
||
),
|
||
{
|
||
"group_id": GroupId,
|
||
"rule_set_id": Body.rule_set_id,
|
||
"priority": Body.priority,
|
||
"is_active": Body.is_active,
|
||
"note": Body.note.strip() if Body.note else None,
|
||
},
|
||
)
|
||
).mappings().one()
|
||
await sync_doc_type_bindings_from_group(session, GroupId)
|
||
await session.commit()
|
||
binding_id = int(row["id"])
|
||
binding_row = await self._get_binding_row(session, binding_id)
|
||
binding_vo = await self._build_binding_vo(binding_row)
|
||
return binding_vo
|
||
|
||
async def UpdateBinding(self, BindingId: int, Body: EvaluationPointGroupBindingUpdateDTO) -> RuleGroupBindingVO:
|
||
async with GetAsyncSession() as session:
|
||
await self._ensure_ready(session)
|
||
current = await self._get_binding_row(session, BindingId)
|
||
await session.execute(
|
||
text(
|
||
"""
|
||
UPDATE leaudit_rule_group_bindings
|
||
SET priority = :priority,
|
||
is_active = :is_active,
|
||
note = :note,
|
||
updated_at = NOW()
|
||
WHERE id = :binding_id
|
||
"""
|
||
),
|
||
{
|
||
"binding_id": BindingId,
|
||
"priority": Body.priority if Body.priority is not None else int(current.get("priority") or 0),
|
||
"is_active": Body.is_active if Body.is_active is not None else bool(current.get("is_active", True)),
|
||
"note": Body.note.strip() if Body.note else (current.get("note") if Body.note is None else None),
|
||
},
|
||
)
|
||
await sync_doc_type_bindings_from_group(session, int(current["group_id"]))
|
||
await session.commit()
|
||
binding_row = await self._get_binding_row(session, BindingId)
|
||
binding_vo = await self._build_binding_vo(binding_row)
|
||
return binding_vo
|
||
|
||
async def DeleteBinding(self, BindingId: int) -> None:
|
||
async with GetAsyncSession() as session:
|
||
await self._ensure_ready(session)
|
||
current = await self._get_binding_row(session, BindingId)
|
||
await session.execute(
|
||
text(
|
||
"UPDATE leaudit_rule_group_bindings SET deleted_at = NOW(), updated_at = NOW() WHERE id = :binding_id"
|
||
),
|
||
{"binding_id": BindingId},
|
||
)
|
||
await sync_doc_type_bindings_from_group(session, int(current["group_id"]))
|
||
await session.commit()
|
||
|
||
async def GetRuleTemplate(self, GroupId: int) -> EvaluationPointGroupRuleTemplateVO:
|
||
async with GetAsyncSession() as session:
|
||
await self._ensure_ready(session)
|
||
context = await self._load_rule_context(session, GroupId)
|
||
template = self._build_rule_yaml_template(context)
|
||
existing_binding_id = await self._get_group_binding_id_for_rule_type(session, GroupId, context["rule_type"])
|
||
return EvaluationPointGroupRuleTemplateVO(
|
||
context=EvaluationPointGroupRuleTemplateContextVO(
|
||
group_id=context["group_id"],
|
||
group_code=context["group_code"],
|
||
group_name=context["group_name"],
|
||
parent_group_id=context["parent_group_id"],
|
||
parent_group_code=context["parent_group_code"],
|
||
parent_group_name=context["parent_group_name"],
|
||
document_type_id=context["document_type_id"],
|
||
document_type_code=context["document_type_code"],
|
||
document_type_name=context["document_type_name"],
|
||
entry_module_id=context["entry_module_id"],
|
||
entry_module_name=context["entry_module_name"],
|
||
),
|
||
ruleType=context["rule_type"],
|
||
ruleName=context["rule_name"],
|
||
nextVersionNo=context["next_version_no"],
|
||
ossPreviewKey=context["oss_preview_key"],
|
||
yamlTemplate=template,
|
||
existingRuleSetId=context["existing_rule_set_id"],
|
||
existingBindingId=existing_binding_id,
|
||
)
|
||
|
||
async def CreateRuleDraft(self, GroupId: int, Body: EvaluationPointGroupRuleDraftCreateDTO) -> EvaluationPointGroupRuleDraftVO:
|
||
async with GetAsyncSession() as session:
|
||
await self._ensure_ready(session)
|
||
context = await self._load_rule_context(session, GroupId)
|
||
yaml_text = Body.yaml_text.strip()
|
||
if not yaml_text:
|
||
raise LeauditException(StatusCodeEnum.HTTP_400_BAD_REQUEST, "YAML 内容不能为空")
|
||
|
||
created_version = await self.RuleService.CreateVersion(
|
||
RuleType=context["rule_type"],
|
||
YamlText=yaml_text,
|
||
ChangeNote=Body.change_note.strip() if Body.change_note else None,
|
||
EditorUserId=Body.editor_user_id,
|
||
)
|
||
|
||
async with GetAsyncSession() as session:
|
||
await self._ensure_ready(session)
|
||
rule_set_id = await self._get_rule_set_id_by_type(session, context["rule_type"])
|
||
if rule_set_id is None:
|
||
raise LeauditException(StatusCodeEnum.HTTP_500_INTERNAL_SERVER_ERROR, "规则版本已创建，但未找到对应规则集")
|
||
binding_id, auto_bound = await self._ensure_group_binding_for_rule_set(session, GroupId, rule_set_id)
|
||
await sync_doc_type_bindings_from_group(session, GroupId)
|
||
await session.commit()
|
||
binding_row = await self._get_binding_row(session, binding_id)
|
||
binding_vo = await self._build_binding_vo(binding_row)
|
||
|
||
return EvaluationPointGroupRuleDraftVO(
|
||
packId=GroupId,
|
||
groupId=GroupId,
|
||
ruleName=context["rule_name"],
|
||
ruleType=context["rule_type"],
|
||
ruleSetId=rule_set_id,
|
||
ossKey=OssPathUtils.BuildRuleYamlKey(context["rule_type"], created_version.versionNo),
|
||
version=created_version,
|
||
binding=binding_vo,
|
||
autoBound=auto_bound,
|
||
)
|
||
|
||
async def _ensure_ready(self, session) -> None:
|
||
self._rule_set_meta_cache = None
|
||
await ensure_rule_group_schema(session)
|
||
await bootstrap_rule_groups(session)
|
||
|
||
async def _get_group_row(self, session, group_id: int):
|
||
row = (
|
||
await session.execute(
|
||
text(
|
||
"""
|
||
SELECT
|
||
g.id,
|
||
g.pid,
|
||
g.name,
|
||
g.code,
|
||
g.description,
|
||
g.document_type_id,
|
||
dt.code AS document_type_code,
|
||
dt.name AS document_type_name,
|
||
parent.id AS root_group_id,
|
||
parent.name AS root_group_name,
|
||
parent.code AS root_group_code,
|
||
COALESCE(g.entry_module_id, parent.entry_module_id, dt.entry_module_id) AS entry_module_id,
|
||
em.name AS entry_module_name,
|
||
g.sort_order,
|
||
g.is_enabled,
|
||
g.created_at,
|
||
g.updated_at,
|
||
COALESCE(bg.binding_count, 0) AS rule_count
|
||
FROM leaudit_evaluation_point_groups g
|
||
LEFT JOIN leaudit_document_types dt ON dt.id = g.document_type_id
|
||
LEFT JOIN leaudit_evaluation_point_groups parent ON parent.id = g.pid AND parent.deleted_at IS NULL
|
||
LEFT JOIN leaudit_entry_modules em ON em.id = COALESCE(g.entry_module_id, parent.entry_module_id, dt.entry_module_id)
|
||
LEFT JOIN (
|
||
SELECT group_id, COUNT(*)::int AS binding_count
|
||
FROM leaudit_rule_group_bindings
|
||
WHERE deleted_at IS NULL
|
||
GROUP BY group_id
|
||
) bg ON bg.group_id = g.id
|
||
WHERE g.id = :group_id AND g.deleted_at IS NULL
|
||
LIMIT 1
|
||
"""
|
||
),
|
||
{"group_id": group_id},
|
||
)
|
||
).mappings().first()
|
||
if not row:
|
||
raise LeauditException(StatusCodeEnum.HTTP_404_NOT_FOUND, "规则分组不存在")
|
||
return row
|
||
|
||
async def _get_binding_row(self, session, binding_id: int):
|
||
row = (
|
||
await session.execute(
|
||
text(
|
||
"""
|
||
SELECT id, group_id, rule_set_id, rule_type_binding_id, priority, is_active, note, created_at, updated_at
|
||
FROM leaudit_rule_group_bindings
|
||
WHERE id = :binding_id AND deleted_at IS NULL
|
||
LIMIT 1
|
||
"""
|
||
),
|
||
{"binding_id": binding_id},
|
||
)
|
||
).mappings().first()
|
||
if not row:
|
||
raise LeauditException(StatusCodeEnum.HTTP_404_NOT_FOUND, "规则组绑定不存在")
|
||
return row
|
||
|
||
async def _load_binding_map(self, session, group_ids: list[int]) -> dict[int, list[RuleGroupBindingVO]]:
|
||
group_ids = [int(item) for item in group_ids if item]
|
||
if not group_ids:
|
||
return {}
|
||
rows = (
|
||
await session.execute(
|
||
text(
|
||
"""
|
||
SELECT id, group_id, rule_set_id, rule_type_binding_id, priority, is_active, note, created_at, updated_at
|
||
FROM leaudit_rule_group_bindings
|
||
WHERE group_id IN :group_ids AND deleted_at IS NULL
|
||
ORDER BY priority DESC, id ASC
|
||
"""
|
||
).bindparams(bindparam("group_ids", expanding=True)),
|
||
{"group_ids": group_ids},
|
||
)
|
||
).mappings().all()
|
||
result: dict[int, list[RuleGroupBindingVO]] = {}
|
||
for row in rows:
|
||
result.setdefault(int(row["group_id"]), []).append(await self._build_binding_vo(row))
|
||
return result
|
||
|
||
async def _build_binding_vo(self, row) -> RuleGroupBindingVO:
|
||
rule_set_meta = await self._get_rule_set_meta(int(row["rule_set_id"]))
|
||
return RuleGroupBindingVO(
|
||
id=int(row["id"]),
|
||
group_id=int(row["group_id"]),
|
||
rule_set_id=int(row["rule_set_id"]),
|
||
rule_type_binding_id=int(row["rule_type_binding_id"]) if row.get("rule_type_binding_id") else None,
|
||
priority=int(row.get("priority") or 0),
|
||
is_active=bool(row.get("is_active", True)),
|
||
note=row.get("note"),
|
||
rule_type=rule_set_meta.get("rule_type"),
|
||
rule_name=rule_set_meta.get("rule_name"),
|
||
current_version_id=rule_set_meta.get("current_version_id"),
|
||
fallback_version_id=rule_set_meta.get("fallback_version_id"),
|
||
has_usable_version=bool(rule_set_meta.get("has_usable_version", False)),
|
||
usable_rule_count=int(rule_set_meta.get("usable_rule_count") or 0),
|
||
)
|
||
|
||
async def _get_rule_set_meta(self, rule_set_id: int) -> dict[str, Any]:
|
||
if not getattr(self, "_rule_set_meta_cache", None):
|
||
rule_sets = await self.RuleService.ListSets()
|
||
self._rule_set_meta_cache = {
|
||
int(item.id): {
|
||
"rule_type": item.ruleType,
|
||
"rule_name": item.ruleName,
|
||
"current_version_id": item.currentVersionId,
|
||
"fallback_version_id": item.fallbackVersionId,
|
||
"has_usable_version": item.hasUsableVersion,
|
||
"usable_rule_count": item.usableRuleCount,
|
||
}
|
||
for item in rule_sets
|
||
}
|
||
return self._rule_set_meta_cache.get(rule_set_id, {})
|
||
|
||
async def _ensure_parent_valid(self, session, pid: int):
|
||
if pid == 0:
|
||
return None
|
||
parent = await self._get_group_row(session, pid)
|
||
if self._normalize_pid(parent["pid"]) != 0:
|
||
raise LeauditException(StatusCodeEnum.HTTP_400_BAD_REQUEST, "上级分组必须是一级分组")
|
||
return parent
|
||
|
||
async def _ensure_entry_module_valid(
|
||
self,
|
||
session,
|
||
pid: int,
|
||
entry_module_id: int | None,
|
||
parent: Any | None,
|
||
) -> int | None:
|
||
if pid != 0:
|
||
if parent is not None and parent.get("entry_module_id") is not None:
|
||
return int(parent["entry_module_id"])
|
||
return None if entry_module_id in (None, 0, "0", "") else int(entry_module_id)
|
||
|
||
if entry_module_id in (None, 0, "0", ""):
|
||
return None
|
||
|
||
exists = (
|
||
await session.execute(
|
||
text("SELECT id FROM leaudit_entry_modules WHERE id = :entry_module_id AND deleted_at IS NULL LIMIT 1"),
|
||
{"entry_module_id": int(entry_module_id)},
|
||
)
|
||
).scalar_one_or_none()
|
||
if exists is None:
|
||
raise LeauditException(StatusCodeEnum.HTTP_400_BAD_REQUEST, "关联入口模块不存在")
|
||
return int(entry_module_id)
|
||
|
||
async def _ensure_document_type_valid(
|
||
self,
|
||
session,
|
||
pid: int,
|
||
document_type_id: int | None,
|
||
entry_module_id: int | None,
|
||
group_id: int | None,
|
||
parent: Any | None,
|
||
) -> int | None:
|
||
if pid == 0:
|
||
if document_type_id is None and entry_module_id is None:
|
||
return None
|
||
else:
|
||
if parent is None:
|
||
raise LeauditException(StatusCodeEnum.HTTP_400_BAD_REQUEST, "二级分组必须挂到一级分组下")
|
||
if parent.get("document_type_id") is not None:
|
||
parent_doc_type_id = int(parent["document_type_id"])
|
||
if document_type_id is None:
|
||
document_type_id = parent_doc_type_id
|
||
elif int(document_type_id) != parent_doc_type_id:
|
||
raise LeauditException(StatusCodeEnum.HTTP_400_BAD_REQUEST, "二级分组的文档类型必须与所属一级分组一致")
|
||
elif document_type_id is None:
|
||
raise LeauditException(StatusCodeEnum.HTTP_400_BAD_REQUEST, "二级分组必须明确绑定具体文档类型")
|
||
|
||
if document_type_id is None:
|
||
return None
|
||
exists = (
|
||
await session.execute(
|
||
text(
|
||
"SELECT id FROM leaudit_document_types WHERE id = :doc_type_id AND deleted_at IS NULL LIMIT 1"
|
||
),
|
||
{"doc_type_id": int(document_type_id)},
|
||
)
|
||
).scalar_one_or_none()
|
||
if exists is None:
|
||
raise LeauditException(StatusCodeEnum.HTTP_400_BAD_REQUEST, "关联文档类型不存在")
|
||
if pid == 0:
|
||
duplicated_root = (
|
||
await session.execute(
|
||
text(
|
||
"""
|
||
SELECT id
|
||
FROM leaudit_evaluation_point_groups
|
||
WHERE deleted_at IS NULL
|
||
AND COALESCE(pid, 0) = 0
|
||
AND document_type_id = :doc_type_id
|
||
AND (:group_id IS NULL OR id <> :group_id)
|
||
LIMIT 1
|
||
"""
|
||
),
|
||
{"doc_type_id": int(document_type_id), "group_id": group_id},
|
||
)
|
||
).scalar_one_or_none()
|
||
if duplicated_root is not None:
|
||
raise LeauditException(StatusCodeEnum.HTTP_400_BAD_REQUEST, "该文档类型已存在一级分组")
|
||
return int(document_type_id)
|
||
|
||
async def _ensure_code_unique(self, session, code: str, group_id: int | None) -> None:
|
||
sql = "SELECT id FROM leaudit_evaluation_point_groups WHERE LOWER(code) = LOWER(:code) AND deleted_at IS NULL"
|
||
params: dict[str, Any] = {"code": code}
|
||
if group_id is not None:
|
||
sql += " AND id <> :group_id"
|
||
params["group_id"] = group_id
|
||
duplicated = (await session.execute(text(sql + " LIMIT 1"), params)).scalar_one_or_none()
|
||
if duplicated is not None:
|
||
raise LeauditException(StatusCodeEnum.HTTP_400_BAD_REQUEST, "分组编码已存在")
|
||
|
||
async def _ensure_rule_set_valid(self, session, rule_set_id: int) -> None:
|
||
exists = (
|
||
await session.execute(
|
||
text("SELECT id FROM leaudit_rule_sets WHERE id = :rule_set_id AND deleted_at IS NULL LIMIT 1"),
|
||
{"rule_set_id": rule_set_id},
|
||
)
|
||
).scalar_one_or_none()
|
||
if exists is None:
|
||
raise LeauditException(StatusCodeEnum.HTTP_400_BAD_REQUEST, "规则集不存在")
|
||
|
||
async def _load_rule_context(self, session, group_id: int) -> dict[str, Any]:
|
||
row = await self._get_group_row(session, group_id)
|
||
if self._normalize_pid(row["pid"]) == 0:
|
||
raise LeauditException(StatusCodeEnum.HTTP_400_BAD_REQUEST, "请先选择二级分组，再创建规则 YAML")
|
||
|
||
rule_type = self._resolve_rule_type(row)
|
||
if not rule_type:
|
||
raise LeauditException(StatusCodeEnum.HTTP_400_BAD_REQUEST, "当前二级分组缺少可推导的规则类型编码，请先补充分组编码或文档类型编码")
|
||
|
||
rule_name = str(row.get("document_type_name") or row.get("name") or "").strip()
|
||
if not rule_name:
|
||
raise LeauditException(StatusCodeEnum.HTTP_400_BAD_REQUEST, "当前二级分组缺少规则名称，请先补充分组名称")
|
||
|
||
next_version_no = await self._get_next_rule_version_no(session, rule_type)
|
||
return {
|
||
"group_id": int(row["id"]),
|
||
"group_code": str(row.get("code") or "").strip(),
|
||
"group_name": str(row.get("name") or ""),
|
||
"parent_group_id": int(row.get("root_group_id") or 0),
|
||
"parent_group_code": str(row.get("root_group_code") or "").strip(),
|
||
"parent_group_name": str(row.get("root_group_name") or row.get("entry_module_name") or ""),
|
||
"document_type_id": int(row["document_type_id"]) if row.get("document_type_id") is not None else None,
|
||
"document_type_code": str(row.get("document_type_code") or "").strip() or None,
|
||
"document_type_name": str(row.get("document_type_name") or "").strip() or None,
|
||
"entry_module_id": int(row["entry_module_id"]) if row.get("entry_module_id") is not None else None,
|
||
"entry_module_name": str(row.get("entry_module_name") or "").strip() or None,
|
||
"rule_type": rule_type,
|
||
"rule_name": rule_name,
|
||
"next_version_no": next_version_no,
|
||
"oss_preview_key": OssPathUtils.BuildRuleYamlKey(rule_type, next_version_no),
|
||
"existing_rule_set_id": await self._get_rule_set_id_by_type(session, rule_type),
|
||
}
|
||
|
||
def _resolve_rule_type(self, row: Any) -> str:
|
||
doc_type_code = str(row.get("document_type_code") or "").strip()
|
||
if doc_type_code:
|
||
return self._normalize_rule_code(doc_type_code)
|
||
child_code = str(row.get("code") or "").strip()
|
||
root_code = str(row.get("root_group_code") or "").strip()
|
||
if child_code and root_code and child_code != root_code and not child_code.startswith(f"{root_code}."):
|
||
return self._normalize_rule_code(f"{root_code}.{child_code}")
|
||
if child_code:
|
||
return self._normalize_rule_code(child_code)
|
||
group_name = str(row.get("name") or "").strip()
|
||
if root_code and group_name:
|
||
return self._normalize_rule_code(f"{root_code}.{group_name}")
|
||
if group_name:
|
||
return self._normalize_rule_code(group_name)
|
||
return ""
|
||
|
||
def _normalize_rule_code(self, value: str) -> str:
|
||
normalized = ".".join(segment.strip() for segment in value.strip().split(".") if segment.strip())
|
||
if not normalized:
|
||
return ""
|
||
return normalized.replace("/", "_").replace("\\", "_").replace(" ", "_")
|
||
|
||
async def _get_next_rule_version_no(self, session, rule_type: str) -> str:
|
||
row = (
|
||
await session.execute(
|
||
text(
|
||
"""
|
||
SELECT COALESCE(MAX(rv.version_seq), 0) AS max_seq
|
||
FROM leaudit_rule_versions rv
|
||
JOIN leaudit_rule_sets rs ON rs.id = rv.rule_set_id
|
||
WHERE rs.rule_type = :rule_type
|
||
AND rs.deleted_at IS NULL
|
||
"""
|
||
),
|
||
{"rule_type": rule_type},
|
||
)
|
||
).mappings().first()
|
||
next_seq = int((row or {}).get("max_seq") or 0) + 1
|
||
return f"v{next_seq}"
|
||
|
||
def _build_rule_yaml_template(self, context: dict[str, Any]) -> str:
|
||
keywords = [
|
||
item
|
||
for item in dict.fromkeys(
|
||
[
|
||
context.get("parent_group_name"),
|
||
context.get("group_name"),
|
||
context.get("document_type_name"),
|
||
context.get("entry_module_name"),
|
||
]
|
||
)
|
||
if item
|
||
]
|
||
keyword_lines = "\n".join(f" - {item}" for item in keywords) or " - 待补充"
|
||
description = (
|
||
f"{context['rule_name']} 规则模板。"
|
||
f" 入口模块：{context.get('entry_module_name') or '未配置'}；"
|
||
f" 一级分组：{context.get('parent_group_name') or '未配置'}；"
|
||
f" 二级分组：{context.get('group_name') or '未配置'}。"
|
||
)
|
||
parent_type = context.get("parent_group_name") or context.get("group_name") or context["rule_type"]
|
||
return (
|
||
"metadata:\n"
|
||
f" type_id: {context['rule_type']}\n"
|
||
f" name: {context['rule_name']}\n"
|
||
f" version: {context['next_version_no']}\n"
|
||
f" last_updated: '{datetime.now().date().isoformat()}'\n"
|
||
f" parent: {parent_type}\n"
|
||
" classification_keywords:\n"
|
||
f"{keyword_lines}\n"
|
||
" description: >\n"
|
||
f" {description}\n\n"
|
||
"sub_documents: []\n"
|
||
"rules: []\n"
|
||
)
|
||
|
||
async def _get_group_binding_id_for_rule_type(self, session, group_id: int, rule_type: str) -> int | None:
|
||
rule_set_id = await self._get_rule_set_id_by_type(session, rule_type)
|
||
if rule_set_id is None:
|
||
return None
|
||
row = (
|
||
await session.execute(
|
||
text(
|
||
"""
|
||
SELECT id
|
||
FROM leaudit_rule_group_bindings
|
||
WHERE group_id = :group_id
|
||
AND rule_set_id = :rule_set_id
|
||
AND deleted_at IS NULL
|
||
LIMIT 1
|
||
"""
|
||
),
|
||
{"group_id": group_id, "rule_set_id": rule_set_id},
|
||
)
|
||
).mappings().first()
|
||
return int(row["id"]) if row else None
|
||
|
||
async def _get_rule_set_id_by_type(self, session, rule_type: str) -> int | None:
|
||
row = (
|
||
await session.execute(
|
||
text("SELECT id FROM leaudit_rule_sets WHERE rule_type = :rule_type AND deleted_at IS NULL LIMIT 1"),
|
||
{"rule_type": rule_type},
|
||
)
|
||
).mappings().first()
|
||
return int(row["id"]) if row else None
|
||
|
||
async def _ensure_group_binding_for_rule_set(self, session, group_id: int, rule_set_id: int) -> tuple[int, bool]:
|
||
existing = (
|
||
await session.execute(
|
||
text(
|
||
"""
|
||
SELECT id
|
||
FROM leaudit_rule_group_bindings
|
||
WHERE group_id = :group_id
|
||
AND rule_set_id = :rule_set_id
|
||
AND deleted_at IS NULL
|
||
LIMIT 1
|
||
"""
|
||
),
|
||
{"group_id": group_id, "rule_set_id": rule_set_id},
|
||
)
|
||
).mappings().first()
|
||
if existing:
|
||
return int(existing["id"]), False
|
||
|
||
row = (
|
||
await session.execute(
|
||
text(
|
||
"""
|
||
INSERT INTO leaudit_rule_group_bindings (
|
||
group_id, rule_set_id, priority, is_active, note, created_at, updated_at
|
||
) VALUES (
|
||
:group_id, :rule_set_id, 100, TRUE, :note, NOW(), NOW()
|
||
)
|
||
RETURNING id
|
||
"""
|
||
),
|
||
{
|
||
"group_id": group_id,
|
||
"rule_set_id": rule_set_id,
|
||
"note": "由二级分组新建规则 YAML 时自动补绑",
|
||
},
|
||
)
|
||
).mappings().one()
|
||
return int(row["id"]), True
|
||
|
||
def _normalize_create_payload(self, body: EvaluationPointGroupCreateDTO) -> dict[str, Any]:
|
||
name = body.name.strip()
|
||
code = body.code.strip()
|
||
if not name:
|
||
raise LeauditException(StatusCodeEnum.HTTP_400_BAD_REQUEST, "分组名称不能为空")
|
||
if not code:
|
||
raise LeauditException(StatusCodeEnum.HTTP_400_BAD_REQUEST, "分组编码不能为空")
|
||
return {
|
||
"name": name,
|
||
"code": code,
|
||
"pid": self._normalize_pid(body.pid),
|
||
"description": body.description.strip() if body.description else None,
|
||
"document_type_id": body.document_type_id,
|
||
"entry_module_id": body.entry_module_id,
|
||
"sort_order": int(body.sort_order or 0),
|
||
"is_enabled": body.is_enabled,
|
||
}
|
||
|
||
def _to_group_vo(self, row, bindings: list[RuleGroupBindingVO], include_rule_count: bool) -> EvaluationPointGroupVO:
|
||
return EvaluationPointGroupVO(
|
||
id=int(row["id"]),
|
||
pid=self._normalize_pid(row.get("pid")),
|
||
name=str(row.get("name") or ""),
|
||
code=str(row.get("code") or ""),
|
||
description=row.get("description"),
|
||
document_type_id=int(row["document_type_id"]) if row.get("document_type_id") is not None else None,
|
||
document_type_name=row.get("document_type_name"),
|
||
entry_module_id=int(row["entry_module_id"]) if row.get("entry_module_id") is not None else None,
|
||
entry_module_name=row.get("entry_module_name"),
|
||
sort_order=int(row.get("sort_order") or 0),
|
||
is_enabled=bool(row.get("is_enabled", True)),
|
||
created_at=self._to_iso(row.get("created_at")),
|
||
updated_at=self._to_iso(row.get("updated_at")),
|
||
rule_count=len(bindings) if include_rule_count else None,
|
||
bindings=bindings,
|
||
children=None,
|
||
)
|
||
|
||
def _normalize_pid(self, value: Any) -> int:
|
||
if value in (None, "", "0", 0):
|
||
return 0
|
||
return int(value)
|
||
|
||
def _to_iso(self, value: Any) -> str | None:
|
||
if value is None:
|
||
return None
|
||
if isinstance(value, datetime):
|
||
return value.isoformat()
|
||
return str(value)
|