wren
934 lines
39 KiB
Python
934 lines
39 KiB
Python
"""入口模块管理服务实现。"""
|
|
|
|
from __future__ import annotations
|
|
|
|
import json
|
|
from datetime import datetime
|
|
from pathlib import Path
|
|
from typing import Any
|
|
|
|
from sqlalchemy import bindparam, text
|
|
|
|
from fastapi_admin.config import OSS_BASE_URL, OSS_BUCKET
|
|
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.entryModuleDto import (
|
|
EntryModuleAreaDTO,
|
|
EntryModuleCreateDTO,
|
|
EntryModuleTenantDTO,
|
|
EntryModuleUpdateDTO,
|
|
)
|
|
from fastapi_modules.fastapi_leaudit.domian.vo.entryModuleAdminVo import (
|
|
EntryModuleBusinessScopeVO,
|
|
EntryModuleImageUploadVO,
|
|
EntryModuleListVO,
|
|
EntryModuleTenantVO,
|
|
EntryModuleVO,
|
|
)
|
|
from fastapi_modules.fastapi_leaudit.services.entryModuleAdminService import IEntryModuleAdminService
|
|
from fastapi_modules.fastapi_leaudit.services.impl.ossServiceImpl import OssServiceImpl
|
|
from fastapi_modules.fastapi_leaudit.services.impl.tenantResolver import TenantResolution, TenantResolver
|
|
|
|
|
|
_ALLOWED_MENU_PROFILES = {"document_review", "contract", "govdoc", "cross_checking", "custom"}
|
|
_ALLOWED_FEATURES = {
|
|
"home",
|
|
"documents",
|
|
"upload",
|
|
"rules",
|
|
"rule_groups",
|
|
"contract_template_search",
|
|
"contract_template_list",
|
|
"govdoc_audits",
|
|
"govdoc_upload",
|
|
"cross_checking",
|
|
"cross_checking_upload",
|
|
"cross_checking_list",
|
|
"usage_stats",
|
|
}
|
|
_DEFAULT_FEATURES_BY_PROFILE = {
|
|
"document_review": ["home", "documents", "upload", "rules", "rule_groups"],
|
|
"contract": ["home", "documents", "upload", "rules", "contract_template_search", "contract_template_list"],
|
|
"govdoc": ["home", "govdoc_audits", "govdoc_upload", "rules"],
|
|
"cross_checking": ["cross_checking", "cross_checking_upload", "cross_checking_list"],
|
|
"custom": ["home", "documents"],
|
|
}
|
|
|
|
|
|
class EntryModuleAdminServiceImpl(IEntryModuleAdminService):
|
|
"""入口模块管理服务实现。"""
|
|
|
|
def __init__(self) -> None:
|
|
self.OssService = OssServiceImpl()
|
|
self.TenantResolver = TenantResolver()
|
|
self._tenant_table_exists_cache: bool | None = None
|
|
self._entry_module_tenant_table_exists_cache: bool | None = None
|
|
self._entry_module_menu_columns_exist_cache: bool | None = None
|
|
|
|
async def ListModules(
|
|
self,
|
|
Name: str | None,
|
|
Area: str | None,
|
|
TenantCode: str | None,
|
|
Page: int,
|
|
PageSize: int,
|
|
) -> EntryModuleListVO:
|
|
"""分页查询入口模块。"""
|
|
offset = max(Page - 1, 0) * PageSize
|
|
filters = ["em.deleted_at IS NULL"]
|
|
params: dict[str, object] = {"limit": PageSize, "offset": offset}
|
|
|
|
if Name:
|
|
filters.append("em.name ILIKE :name")
|
|
params["name"] = f"%{Name.strip()}%"
|
|
|
|
resolved_filter_tenant_code = await self._resolveFilterTenantCode(Area=Area, TenantCode=TenantCode)
|
|
has_tenant_mapping_table = await self._entry_module_tenant_table_exists()
|
|
if resolved_filter_tenant_code:
|
|
legacy_area = (Area or "").strip()
|
|
if not legacy_area:
|
|
tenant_name_map = await self._loadTenantNameMap([resolved_filter_tenant_code])
|
|
legacy_area = tenant_name_map.get(resolved_filter_tenant_code, "")
|
|
if has_tenant_mapping_table:
|
|
filters.append(
|
|
"""
|
|
(
|
|
EXISTS (
|
|
SELECT 1
|
|
FROM leaudit_entry_module_tenants emt
|
|
WHERE emt.entry_module_id = em.id
|
|
AND emt.deleted_at IS NULL
|
|
AND emt.tenant_code = :tenant_code
|
|
)
|
|
OR (
|
|
NOT EXISTS (
|
|
SELECT 1
|
|
FROM leaudit_entry_module_tenants emt0
|
|
WHERE emt0.entry_module_id = em.id
|
|
AND emt0.deleted_at IS NULL
|
|
)
|
|
AND EXISTS (
|
|
SELECT 1
|
|
FROM jsonb_array_elements(COALESCE(em.areas, '[]'::jsonb)) AS area_item
|
|
WHERE area_item->>'area' = :legacy_area
|
|
)
|
|
)
|
|
)
|
|
"""
|
|
)
|
|
params["tenant_code"] = resolved_filter_tenant_code
|
|
else:
|
|
filters.append(
|
|
"""
|
|
EXISTS (
|
|
SELECT 1
|
|
FROM jsonb_array_elements(COALESCE(em.areas, '[]'::jsonb)) AS area_item
|
|
WHERE area_item->>'area' = :legacy_area
|
|
)
|
|
"""
|
|
)
|
|
params["legacy_area"] = legacy_area
|
|
|
|
where_clause = " AND ".join(filters)
|
|
tenant_select_sql = (
|
|
"""
|
|
COALESCE(
|
|
(
|
|
SELECT jsonb_agg(
|
|
jsonb_build_object(
|
|
'tenant_code', emt.tenant_code,
|
|
'tenant_name', emt.tenant_name,
|
|
'enabled', emt.is_enabled,
|
|
'sort_order', emt.sort_order
|
|
)
|
|
ORDER BY emt.sort_order ASC, emt.id ASC
|
|
)
|
|
FROM leaudit_entry_module_tenants emt
|
|
WHERE emt.entry_module_id = em.id
|
|
AND emt.deleted_at IS NULL
|
|
),
|
|
'[]'::jsonb
|
|
) AS tenants
|
|
"""
|
|
if has_tenant_mapping_table
|
|
else "'[]'::jsonb AS tenants"
|
|
)
|
|
menu_select_sql = await self._entry_module_menu_select_sql()
|
|
business_scope_select_sql = self._entry_module_business_scope_select_sql()
|
|
|
|
async with GetAsyncSession() as session:
|
|
total = int(
|
|
(
|
|
await session.execute(
|
|
text(f"SELECT COUNT(*) FROM leaudit_entry_modules em WHERE {where_clause}"),
|
|
params,
|
|
)
|
|
).scalar_one()
|
|
)
|
|
|
|
rows = (
|
|
await session.execute(
|
|
text(
|
|
f"""
|
|
SELECT
|
|
em.id,
|
|
em.name,
|
|
em.description,
|
|
em.path,
|
|
em.icon_path,
|
|
em.areas,
|
|
em.sort_order,
|
|
em.is_enabled,
|
|
em.created_at,
|
|
em.updated_at,
|
|
{menu_select_sql},
|
|
{business_scope_select_sql},
|
|
{tenant_select_sql}
|
|
FROM leaudit_entry_modules em
|
|
WHERE {where_clause}
|
|
ORDER BY em.sort_order ASC, em.id ASC
|
|
LIMIT :limit OFFSET :offset
|
|
"""
|
|
),
|
|
params,
|
|
)
|
|
).mappings().all()
|
|
|
|
items = [await self._toModuleVo(row) for row in rows]
|
|
return EntryModuleListVO(total=total, page=Page, page_size=PageSize, items=items)
|
|
|
|
async def GetModule(self, ModuleId: int) -> EntryModuleVO:
|
|
"""获取入口模块详情。"""
|
|
row = await self._getModuleRow(ModuleId)
|
|
return await self._toModuleVo(row)
|
|
|
|
async def CreateModule(self, Body: EntryModuleCreateDTO) -> EntryModuleVO:
|
|
"""创建入口模块。"""
|
|
route_path = (Body.route_path if Body.route_path is not None else Body.path or "").strip() or None
|
|
normalized_tenants = await self._normalizeTenants(
|
|
Tenants=Body.tenants,
|
|
Areas=Body.areas,
|
|
)
|
|
self._ensureTenantAssignments(normalized_tenants)
|
|
legacy_areas_json = self._legacyAreasJson(normalized_tenants)
|
|
menu_profile = self._normalizeMenuProfile(Body.menu_profile)
|
|
features = self._normalizeFeatures(Body.features, menu_profile)
|
|
has_menu_columns = await self._entry_module_menu_columns_exist()
|
|
|
|
async with GetAsyncSession() as session:
|
|
try:
|
|
menu_insert_columns = ", menu_profile, features" if has_menu_columns else ""
|
|
menu_insert_values = ", :menu_profile, CAST(:features AS jsonb)" if has_menu_columns else ""
|
|
params = {
|
|
"name": Body.name.strip(),
|
|
"description": (Body.description or "").strip() or None,
|
|
"route_path": route_path,
|
|
"icon_path": None,
|
|
"areas": legacy_areas_json,
|
|
"sort_order": await self._nextSortOrder(session),
|
|
"menu_profile": menu_profile,
|
|
"features": json.dumps(features, ensure_ascii=False),
|
|
}
|
|
row = (
|
|
await session.execute(
|
|
text(
|
|
f"""
|
|
INSERT INTO leaudit_entry_modules (
|
|
name, description, path, icon_path, areas, sort_order, is_enabled, created_at, updated_at, deleted_at{menu_insert_columns}
|
|
) VALUES (
|
|
:name, :description, :route_path, :icon_path, CAST(:areas AS jsonb), :sort_order, TRUE, NOW(), NOW(), NULL{menu_insert_values}
|
|
)
|
|
RETURNING id
|
|
"""
|
|
),
|
|
params,
|
|
)
|
|
).mappings().one()
|
|
module_id = int(row["id"])
|
|
await self._syncModuleTenants(session, module_id, normalized_tenants)
|
|
await session.commit()
|
|
except Exception as exc:
|
|
await session.rollback()
|
|
raise LeauditException(StatusCodeEnum.HTTP_400_BAD_REQUEST, f"创建入口模块失败: {exc}") from exc
|
|
|
|
return await self.GetModule(module_id)
|
|
|
|
async def UpdateModule(self, ModuleId: int, Body: EntryModuleUpdateDTO) -> EntryModuleVO:
|
|
"""更新入口模块。"""
|
|
current = await self._getModuleRow(ModuleId)
|
|
incoming_route_path = Body.route_path if Body.route_path is not None else Body.path
|
|
|
|
if Body.tenants is not None or Body.areas is not None:
|
|
normalized_tenants = await self._normalizeTenants(Tenants=Body.tenants, Areas=Body.areas)
|
|
else:
|
|
normalized_tenants = await self._extractTenantsFromRow(current)
|
|
self._ensureTenantAssignments(normalized_tenants)
|
|
current_menu_profile = self._safeMenuProfile(current.get("menu_profile"))
|
|
menu_profile = self._normalizeMenuProfile(Body.menu_profile) if Body.menu_profile is not None else current_menu_profile
|
|
features = (
|
|
self._normalizeFeatures(Body.features, menu_profile)
|
|
if Body.features is not None
|
|
else self._parseFeatures(current.get("features"), menu_profile)
|
|
)
|
|
has_menu_columns = await self._entry_module_menu_columns_exist()
|
|
|
|
async with GetAsyncSession() as session:
|
|
menu_update_sql = ", menu_profile = :menu_profile, features = CAST(:features AS jsonb)" if has_menu_columns else ""
|
|
params = {
|
|
"module_id": ModuleId,
|
|
"name": Body.name.strip() if Body.name is not None else current["name"],
|
|
"description": Body.description.strip() if Body.description is not None else current.get("description"),
|
|
"route_path": incoming_route_path.strip() if incoming_route_path is not None else current.get("path"),
|
|
"areas": self._legacyAreasJson(normalized_tenants),
|
|
"menu_profile": menu_profile,
|
|
"features": json.dumps(features, ensure_ascii=False),
|
|
}
|
|
row = (
|
|
await session.execute(
|
|
text(
|
|
f"""
|
|
UPDATE leaudit_entry_modules
|
|
SET
|
|
name = :name,
|
|
description = :description,
|
|
path = :route_path,
|
|
areas = CAST(:areas AS jsonb),
|
|
updated_at = NOW()
|
|
{menu_update_sql}
|
|
WHERE id = :module_id
|
|
AND deleted_at IS NULL
|
|
RETURNING id
|
|
"""
|
|
),
|
|
params,
|
|
)
|
|
).mappings().first()
|
|
if not row:
|
|
await session.rollback()
|
|
raise LeauditException(StatusCodeEnum.HTTP_404_NOT_FOUND, "入口模块不存在")
|
|
|
|
await self._syncModuleTenants(session, ModuleId, normalized_tenants)
|
|
await session.commit()
|
|
|
|
return await self.GetModule(ModuleId)
|
|
|
|
async def DeleteModule(self, ModuleId: int) -> None:
|
|
"""删除入口模块。"""
|
|
async with GetAsyncSession() as session:
|
|
await session.execute(
|
|
text(
|
|
"""
|
|
UPDATE leaudit_entry_modules
|
|
SET deleted_at = NOW(), updated_at = NOW()
|
|
WHERE id = :module_id AND deleted_at IS NULL
|
|
"""
|
|
),
|
|
{"module_id": ModuleId},
|
|
)
|
|
if await self._entry_module_tenant_table_exists():
|
|
await session.execute(
|
|
text(
|
|
"""
|
|
UPDATE leaudit_entry_module_tenants
|
|
SET deleted_at = NOW(), updated_at = NOW()
|
|
WHERE entry_module_id = :module_id AND deleted_at IS NULL
|
|
"""
|
|
),
|
|
{"module_id": ModuleId},
|
|
)
|
|
await session.commit()
|
|
|
|
async def UploadModuleImage(self, ModuleId: int, FileName: str, ContentType: str, Content: bytes) -> EntryModuleImageUploadVO:
|
|
"""上传入口模块图标。"""
|
|
module = await self._getModuleRow(ModuleId)
|
|
suffix = Path(FileName).suffix.lower() or ".png"
|
|
object_key = f"documents/mz/static/img/entry_module_{ModuleId}{suffix}"
|
|
await self.OssService.UploadBytes(ObjectKey=object_key, Content=Content, ContentType=ContentType or "application/octet-stream")
|
|
|
|
async with GetAsyncSession() as session:
|
|
await session.execute(
|
|
text(
|
|
"""
|
|
UPDATE leaudit_entry_modules
|
|
SET icon_path = :icon_path, updated_at = NOW()
|
|
WHERE id = :module_id AND deleted_at IS NULL
|
|
"""
|
|
),
|
|
{"module_id": ModuleId, "icon_path": object_key},
|
|
)
|
|
await session.commit()
|
|
|
|
return EntryModuleImageUploadVO(
|
|
module_id=ModuleId,
|
|
path=object_key,
|
|
url=f"{OSS_BASE_URL.rstrip('/')}/{OSS_BUCKET}/{object_key}",
|
|
message=f"入口模块 {module['name']} 图标上传成功",
|
|
)
|
|
|
|
async def _getModuleRow(self, ModuleId: int):
|
|
"""查询入口模块原始记录。"""
|
|
has_tenant_mapping_table = await self._entry_module_tenant_table_exists()
|
|
tenant_select_sql = (
|
|
"""
|
|
COALESCE(
|
|
(
|
|
SELECT jsonb_agg(
|
|
jsonb_build_object(
|
|
'tenant_code', emt.tenant_code,
|
|
'tenant_name', emt.tenant_name,
|
|
'enabled', emt.is_enabled,
|
|
'sort_order', emt.sort_order
|
|
)
|
|
ORDER BY emt.sort_order ASC, emt.id ASC
|
|
)
|
|
FROM leaudit_entry_module_tenants emt
|
|
WHERE emt.entry_module_id = em.id
|
|
AND emt.deleted_at IS NULL
|
|
),
|
|
'[]'::jsonb
|
|
) AS tenants
|
|
"""
|
|
if has_tenant_mapping_table
|
|
else "'[]'::jsonb AS tenants"
|
|
)
|
|
menu_select_sql = await self._entry_module_menu_select_sql()
|
|
business_scope_select_sql = self._entry_module_business_scope_select_sql()
|
|
async with GetAsyncSession() as session:
|
|
row = (
|
|
await session.execute(
|
|
text(
|
|
f"""
|
|
SELECT
|
|
em.id,
|
|
em.name,
|
|
em.description,
|
|
em.path,
|
|
em.icon_path,
|
|
em.areas,
|
|
em.sort_order,
|
|
em.is_enabled,
|
|
em.created_at,
|
|
em.updated_at,
|
|
{menu_select_sql},
|
|
{business_scope_select_sql},
|
|
{tenant_select_sql}
|
|
FROM leaudit_entry_modules em
|
|
WHERE em.id = :module_id
|
|
AND em.deleted_at IS NULL
|
|
"""
|
|
),
|
|
{"module_id": ModuleId},
|
|
)
|
|
).mappings().first()
|
|
if not row:
|
|
raise LeauditException(StatusCodeEnum.HTTP_404_NOT_FOUND, "入口模块不存在")
|
|
return row
|
|
|
|
async def _nextSortOrder(self, Session) -> int:
|
|
"""获取下一个排序号。"""
|
|
max_sort = (
|
|
await Session.execute(text("SELECT COALESCE(MAX(sort_order), 0) FROM leaudit_entry_modules WHERE deleted_at IS NULL"))
|
|
).scalar_one()
|
|
return int(max_sort or 0) + 10
|
|
|
|
async def _toModuleVo(self, Row) -> EntryModuleVO:
|
|
"""把数据库记录转换为 VO。"""
|
|
tenants = await self._extractTenantsFromRow(Row)
|
|
return EntryModuleVO(
|
|
id=int(Row["id"]),
|
|
name=str(Row["name"] or ""),
|
|
description=Row.get("description"),
|
|
path=Row.get("icon_path"),
|
|
route_path=Row.get("path"),
|
|
menu_profile=self._safeMenuProfile(Row.get("menu_profile")),
|
|
features=self._parseFeatures(Row.get("features"), Row.get("menu_profile")),
|
|
sort_order=int(Row.get("sort_order") or 0),
|
|
is_enabled=bool(Row.get("is_enabled", True)),
|
|
tenants=tenants,
|
|
business_scope=self._parseBusinessScope(Row.get("business_scope")),
|
|
created_at=self._toIso(Row.get("created_at")),
|
|
updated_at=self._toIso(Row.get("updated_at")),
|
|
)
|
|
|
|
async def _extractTenantsFromRow(self, Row) -> list[EntryModuleTenantVO]:
|
|
raw_tenants = Row.get("tenants") or []
|
|
normalized: list[EntryModuleTenantVO] = []
|
|
if isinstance(raw_tenants, list) and raw_tenants:
|
|
for item in raw_tenants:
|
|
if not isinstance(item, dict) or not item.get("tenant_code"):
|
|
continue
|
|
normalized.append(
|
|
EntryModuleTenantVO(
|
|
tenant_code=str(item["tenant_code"]),
|
|
tenant_name=item.get("tenant_name"),
|
|
enabled=bool(item.get("enabled", True)),
|
|
sort_order=int(item.get("sort_order", 0)),
|
|
)
|
|
)
|
|
normalized.sort(key=lambda item: (item.sort_order, item.tenant_code))
|
|
if normalized:
|
|
return normalized
|
|
|
|
raw_areas = Row.get("areas") or []
|
|
if not isinstance(raw_areas, list):
|
|
return []
|
|
|
|
fallback_tenants: list[EntryModuleTenantVO] = []
|
|
for index, item in enumerate(raw_areas, start=1):
|
|
if not isinstance(item, dict) or not item.get("area"):
|
|
continue
|
|
resolution = await self._resolveLegacyTenantValue(
|
|
RawValue=str(item.get("area") or ""),
|
|
Source="entry_module_legacy_area",
|
|
)
|
|
fallback_tenants.append(
|
|
EntryModuleTenantVO(
|
|
tenant_code=resolution.tenant_code,
|
|
tenant_name=resolution.tenant_name,
|
|
enabled=bool(item.get("enabled", True)),
|
|
sort_order=int(item.get("sort_order", index)),
|
|
)
|
|
)
|
|
|
|
unique: dict[str, EntryModuleTenantVO] = {}
|
|
for item in fallback_tenants:
|
|
unique[item.tenant_code] = item
|
|
return sorted(unique.values(), key=lambda item: (item.sort_order, item.tenant_code))
|
|
|
|
async def _normalizeTenants(
|
|
self,
|
|
*,
|
|
Tenants: list[EntryModuleTenantDTO] | None,
|
|
Areas: list[EntryModuleAreaDTO] | None,
|
|
) -> list[dict[str, Any]]:
|
|
if Tenants is not None:
|
|
return await self._normalizeTenantDtos(Tenants)
|
|
if Areas is not None:
|
|
# 仅兼容旧请求体，优先要求前端使用 tenants。
|
|
return await self._normalizeAreas(Areas)
|
|
return []
|
|
|
|
async def _normalizeTenantDtos(self, Tenants: list[EntryModuleTenantDTO]) -> list[dict[str, Any]]:
|
|
if not Tenants:
|
|
return []
|
|
|
|
tenant_codes = [str(item.tenant_code).strip() for item in Tenants if str(item.tenant_code).strip()]
|
|
tenant_name_map = await self._loadTenantNameMap(tenant_codes)
|
|
|
|
normalized: dict[str, dict[str, Any]] = {}
|
|
for index, item in enumerate(Tenants, start=1):
|
|
tenant_code = str(item.tenant_code).strip()
|
|
if not tenant_code:
|
|
continue
|
|
if tenant_code not in tenant_name_map:
|
|
raise LeauditException(StatusCodeEnum.HTTP_400_BAD_REQUEST, f"未知租户编码: {tenant_code}")
|
|
normalized[tenant_code] = {
|
|
"tenant_code": tenant_code,
|
|
"tenant_name": str(item.tenant_name or tenant_name_map[tenant_code] or "").strip() or tenant_name_map[tenant_code],
|
|
"enabled": bool(item.enabled),
|
|
"sort_order": int(item.sort_order or index),
|
|
}
|
|
return sorted(normalized.values(), key=lambda item: (int(item["sort_order"]), str(item["tenant_code"])))
|
|
|
|
async def _normalizeAreas(self, Areas: list[EntryModuleAreaDTO]) -> list[dict[str, Any]]:
|
|
if not Areas:
|
|
return []
|
|
|
|
normalized: dict[str, dict[str, Any]] = {}
|
|
for index, item in enumerate(Areas, start=1):
|
|
area_name = str(item.area or "").strip()
|
|
if not area_name:
|
|
continue
|
|
resolution = await self._resolveLegacyTenantValue(
|
|
RawValue=area_name,
|
|
Source="entry_module_area_payload",
|
|
)
|
|
normalized[resolution.tenant_code] = {
|
|
"tenant_code": resolution.tenant_code,
|
|
"tenant_name": resolution.tenant_name or area_name,
|
|
"enabled": bool(item.enabled),
|
|
"sort_order": int(item.sort_order or index),
|
|
}
|
|
return sorted(normalized.values(), key=lambda item: (int(item["sort_order"]), str(item["tenant_code"])))
|
|
|
|
async def _loadTenantNameMap(self, TenantCodes: list[str]) -> dict[str, str]:
|
|
tenant_codes = [code for code in {str(item).strip() for item in TenantCodes} if code]
|
|
if not tenant_codes:
|
|
return {}
|
|
if not await self._tenant_table_exists():
|
|
return {
|
|
code: ("公共" if code == "PUBLIC" else "省局" if code == "PROVINCIAL" else code)
|
|
for code in tenant_codes
|
|
}
|
|
async with GetAsyncSession() as session:
|
|
rows = (
|
|
await session.execute(
|
|
text(
|
|
"""
|
|
SELECT tenant_code, tenant_name
|
|
FROM sys_tenants
|
|
WHERE tenant_code IN :tenant_codes
|
|
AND deleted_at IS NULL
|
|
AND is_enabled = TRUE
|
|
"""
|
|
).bindparams(bindparam("tenant_codes", expanding=True)),
|
|
{"tenant_codes": tenant_codes},
|
|
)
|
|
).mappings().all()
|
|
return {str(row["tenant_code"]): str(row["tenant_name"] or "") for row in rows}
|
|
|
|
async def _tenant_table_exists(self) -> bool:
|
|
"""兼容旧环境未落 sys_tenants 时的入口模块读写。"""
|
|
if self._tenant_table_exists_cache is not None:
|
|
return self._tenant_table_exists_cache
|
|
async with GetAsyncSession() as session:
|
|
exists = bool(
|
|
(
|
|
await session.execute(
|
|
text(
|
|
"""
|
|
SELECT EXISTS (
|
|
SELECT 1
|
|
FROM information_schema.tables
|
|
WHERE table_schema = current_schema()
|
|
AND table_name = 'sys_tenants'
|
|
)
|
|
"""
|
|
)
|
|
)
|
|
).scalar_one()
|
|
)
|
|
self._tenant_table_exists_cache = exists
|
|
return exists
|
|
|
|
async def _entry_module_tenant_table_exists(self) -> bool:
|
|
"""兼容旧环境未落入口模块租户映射表时的读写。"""
|
|
if self._entry_module_tenant_table_exists_cache is not None:
|
|
return self._entry_module_tenant_table_exists_cache
|
|
async with GetAsyncSession() as session:
|
|
exists = bool(
|
|
(
|
|
await session.execute(
|
|
text(
|
|
"""
|
|
SELECT EXISTS (
|
|
SELECT 1
|
|
FROM information_schema.tables
|
|
WHERE table_schema = current_schema()
|
|
AND table_name = 'leaudit_entry_module_tenants'
|
|
)
|
|
"""
|
|
)
|
|
)
|
|
).scalar_one()
|
|
)
|
|
self._entry_module_tenant_table_exists_cache = exists
|
|
return exists
|
|
|
|
async def _entry_module_menu_columns_exist(self) -> bool:
|
|
if self._entry_module_menu_columns_exist_cache is not None:
|
|
return self._entry_module_menu_columns_exist_cache
|
|
async with GetAsyncSession() as session:
|
|
count = int(
|
|
(
|
|
await session.execute(
|
|
text(
|
|
"""
|
|
SELECT COUNT(*)
|
|
FROM information_schema.columns
|
|
WHERE table_schema = current_schema()
|
|
AND table_name = 'leaudit_entry_modules'
|
|
AND column_name IN ('menu_profile', 'features')
|
|
"""
|
|
)
|
|
)
|
|
).scalar_one()
|
|
)
|
|
self._entry_module_menu_columns_exist_cache = count == 2
|
|
return self._entry_module_menu_columns_exist_cache
|
|
|
|
async def _entry_module_menu_select_sql(self) -> str:
|
|
if await self._entry_module_menu_columns_exist():
|
|
return "em.menu_profile, em.features"
|
|
return "'document_review'::varchar AS menu_profile, '[]'::jsonb AS features"
|
|
|
|
def _entry_module_business_scope_select_sql(self) -> str:
|
|
return """
|
|
COALESCE(
|
|
(
|
|
SELECT jsonb_build_object(
|
|
'category_count', COUNT(DISTINCT dt.id),
|
|
'business_type_count', GREATEST(
|
|
COUNT(DISTINCT child_by_type.id),
|
|
COALESCE(
|
|
(
|
|
SELECT COUNT(DISTINCT child_by_entry.id)
|
|
FROM leaudit_evaluation_point_groups root_by_entry
|
|
JOIN leaudit_evaluation_point_groups child_by_entry
|
|
ON child_by_entry.pid = root_by_entry.id
|
|
AND child_by_entry.deleted_at IS NULL
|
|
WHERE root_by_entry.entry_module_id = em.id
|
|
AND root_by_entry.pid = 0
|
|
AND root_by_entry.deleted_at IS NULL
|
|
),
|
|
0
|
|
)
|
|
),
|
|
'categories', COALESCE(
|
|
(
|
|
SELECT jsonb_agg(category_name ORDER BY category_name)
|
|
FROM (
|
|
SELECT DISTINCT dt2.name AS category_name
|
|
FROM leaudit_document_types dt2
|
|
WHERE dt2.entry_module_id = em.id
|
|
AND dt2.deleted_at IS NULL
|
|
AND dt2.is_enabled = TRUE
|
|
) category_rows
|
|
),
|
|
'[]'::jsonb
|
|
)
|
|
)
|
|
FROM leaudit_document_types dt
|
|
LEFT JOIN leaudit_evaluation_point_groups root
|
|
ON root.document_type_id = dt.id
|
|
AND root.pid = 0
|
|
AND root.deleted_at IS NULL
|
|
LEFT JOIN leaudit_evaluation_point_groups child_by_type
|
|
ON child_by_type.pid = root.id
|
|
AND child_by_type.deleted_at IS NULL
|
|
WHERE dt.entry_module_id = em.id
|
|
AND dt.deleted_at IS NULL
|
|
AND dt.is_enabled = TRUE
|
|
),
|
|
jsonb_build_object('category_count', 0, 'business_type_count', 0, 'categories', '[]'::jsonb)
|
|
) AS business_scope
|
|
"""
|
|
|
|
def _parseBusinessScope(self, RawValue: object) -> EntryModuleBusinessScopeVO:
|
|
if isinstance(RawValue, str):
|
|
try:
|
|
RawValue = json.loads(RawValue)
|
|
except json.JSONDecodeError:
|
|
RawValue = {}
|
|
if not isinstance(RawValue, dict):
|
|
RawValue = {}
|
|
|
|
categories_raw = RawValue.get("categories") or []
|
|
categories = [str(item).strip() for item in categories_raw if str(item or "").strip()] if isinstance(categories_raw, list) else []
|
|
return EntryModuleBusinessScopeVO(
|
|
category_count=int(RawValue.get("category_count") or len(categories)),
|
|
business_type_count=int(RawValue.get("business_type_count") or 0),
|
|
categories=categories,
|
|
)
|
|
|
|
async def _resolveLegacyTenantValue(self, *, RawValue: str, Source: str) -> TenantResolution:
|
|
resolution = await self.TenantResolver.Resolve(
|
|
RawValue=RawValue,
|
|
Source=Source,
|
|
)
|
|
if resolution.tenant_code:
|
|
return resolution
|
|
|
|
normalized = str(RawValue or "").strip()
|
|
if normalized in {"", "default", "省级", "公共"}:
|
|
public_resolution = await self.TenantResolver.Resolve(
|
|
RawValue="",
|
|
Source=Source,
|
|
)
|
|
if public_resolution.tenant_code:
|
|
return public_resolution
|
|
return TenantResolution(
|
|
tenant_code="PUBLIC",
|
|
tenant_name="公共",
|
|
tenant_type="PUBLIC",
|
|
raw_value=RawValue,
|
|
normalized_value=normalized,
|
|
source=Source,
|
|
is_public=True,
|
|
)
|
|
if normalized == "省局":
|
|
return TenantResolution(
|
|
tenant_code="PROVINCIAL",
|
|
tenant_name="省局",
|
|
tenant_type="PROVINCIAL",
|
|
raw_value=RawValue,
|
|
normalized_value=normalized,
|
|
source=Source,
|
|
is_public=False,
|
|
)
|
|
return TenantResolution(
|
|
tenant_code=normalized or None,
|
|
tenant_name=normalized or None,
|
|
tenant_type="LEGACY_AREA" if normalized else None,
|
|
raw_value=RawValue,
|
|
normalized_value=normalized,
|
|
source=Source,
|
|
is_public=False,
|
|
)
|
|
|
|
async def _syncModuleTenants(self, Session, ModuleId: int, Tenants: list[dict[str, Any]]) -> None:
|
|
if not await self._entry_module_tenant_table_exists():
|
|
return
|
|
tenant_codes = [str(item["tenant_code"]) for item in Tenants if item.get("tenant_code")]
|
|
|
|
if tenant_codes:
|
|
await Session.execute(
|
|
text(
|
|
"""
|
|
UPDATE leaudit_entry_module_tenants
|
|
SET deleted_at = NOW(), updated_at = NOW()
|
|
WHERE entry_module_id = :module_id
|
|
AND deleted_at IS NULL
|
|
AND tenant_code NOT IN :tenant_codes
|
|
"""
|
|
).bindparams(bindparam("tenant_codes", expanding=True)),
|
|
{"module_id": ModuleId, "tenant_codes": tenant_codes},
|
|
)
|
|
else:
|
|
await Session.execute(
|
|
text(
|
|
"""
|
|
UPDATE leaudit_entry_module_tenants
|
|
SET deleted_at = NOW(), updated_at = NOW()
|
|
WHERE entry_module_id = :module_id
|
|
AND deleted_at IS NULL
|
|
"""
|
|
),
|
|
{"module_id": ModuleId},
|
|
)
|
|
|
|
for item in Tenants:
|
|
await Session.execute(
|
|
text(
|
|
"""
|
|
INSERT INTO leaudit_entry_module_tenants (
|
|
entry_module_id, tenant_code, tenant_name, is_enabled, sort_order, created_at, updated_at, deleted_at
|
|
) VALUES (
|
|
:module_id, :tenant_code, :tenant_name, :is_enabled, :sort_order, NOW(), NOW(), NULL
|
|
)
|
|
ON CONFLICT (entry_module_id, tenant_code)
|
|
DO UPDATE SET
|
|
tenant_name = EXCLUDED.tenant_name,
|
|
is_enabled = EXCLUDED.is_enabled,
|
|
sort_order = EXCLUDED.sort_order,
|
|
updated_at = NOW(),
|
|
deleted_at = NULL
|
|
"""
|
|
),
|
|
{
|
|
"module_id": ModuleId,
|
|
"tenant_code": item["tenant_code"],
|
|
"tenant_name": item.get("tenant_name"),
|
|
"is_enabled": bool(item.get("enabled", True)),
|
|
"sort_order": int(item.get("sort_order", 0)),
|
|
},
|
|
)
|
|
|
|
async def _resolveFilterTenantCode(self, *, Area: str | None, TenantCode: str | None) -> str | None:
|
|
if TenantCode and TenantCode.strip():
|
|
return TenantCode.strip()
|
|
if Area and Area.strip():
|
|
resolution = await self._resolveLegacyTenantValue(
|
|
RawValue=Area.strip(),
|
|
Source="entry_module_filter_area",
|
|
)
|
|
return resolution.tenant_code
|
|
return None
|
|
|
|
@staticmethod
|
|
def _legacyAreasJson(Tenants: list[dict[str, Any]]) -> str:
|
|
# 继续回写 areas 仅用于兼容旧读链路，主配置来源是 leaudit_entry_module_tenants。
|
|
areas = [
|
|
{
|
|
"area": str(item.get("tenant_name") or item.get("tenant_code") or ""),
|
|
"enabled": bool(item.get("enabled", True)),
|
|
"sort_order": int(item.get("sort_order", 0)),
|
|
}
|
|
for item in Tenants
|
|
if item.get("tenant_code")
|
|
]
|
|
return json.dumps(areas, ensure_ascii=False)
|
|
|
|
@staticmethod
|
|
def _ensureTenantAssignments(Tenants: list[dict[str, Any]]) -> None:
|
|
if Tenants:
|
|
return
|
|
raise LeauditException(
|
|
StatusCodeEnum.HTTP_400_BAD_REQUEST,
|
|
"入口模块至少需要配置一个适用租户",
|
|
)
|
|
|
|
@staticmethod
|
|
def _normalizeMenuProfile(MenuProfile: str | None) -> str:
|
|
value = str(MenuProfile or "document_review").strip() or "document_review"
|
|
if value not in _ALLOWED_MENU_PROFILES:
|
|
raise LeauditException(
|
|
StatusCodeEnum.HTTP_400_BAD_REQUEST,
|
|
f"不支持的菜单模板: {value}",
|
|
)
|
|
return value
|
|
|
|
@staticmethod
|
|
def _safeMenuProfile(MenuProfile: str | None) -> str:
|
|
value = str(MenuProfile or "document_review").strip() or "document_review"
|
|
return value if value in _ALLOWED_MENU_PROFILES else "document_review"
|
|
|
|
@staticmethod
|
|
def _normalizeFeatures(Features: list[str] | None, MenuProfile: str) -> list[str]:
|
|
raw_features = Features if Features else _DEFAULT_FEATURES_BY_PROFILE.get(MenuProfile, _DEFAULT_FEATURES_BY_PROFILE["document_review"])
|
|
normalized: list[str] = []
|
|
invalid: list[str] = []
|
|
for item in raw_features:
|
|
feature = str(item or "").strip()
|
|
if not feature:
|
|
continue
|
|
if MenuProfile == "govdoc" and feature == "rule_groups":
|
|
feature = "rules"
|
|
if feature not in _ALLOWED_FEATURES:
|
|
invalid.append(feature)
|
|
continue
|
|
if feature not in normalized:
|
|
normalized.append(feature)
|
|
if invalid:
|
|
raise LeauditException(
|
|
StatusCodeEnum.HTTP_400_BAD_REQUEST,
|
|
f"不支持的功能编码: {', '.join(invalid)}",
|
|
)
|
|
return normalized or list(_DEFAULT_FEATURES_BY_PROFILE.get(MenuProfile, _DEFAULT_FEATURES_BY_PROFILE["document_review"]))
|
|
|
|
@classmethod
|
|
def _parseFeatures(cls, RawFeatures: Any, MenuProfile: str | None) -> list[str]:
|
|
menu_profile = cls._safeMenuProfile(MenuProfile)
|
|
if isinstance(RawFeatures, list):
|
|
return cls._filterFeatures([str(item) for item in RawFeatures], menu_profile)
|
|
if isinstance(RawFeatures, str) and RawFeatures.strip():
|
|
try:
|
|
parsed = json.loads(RawFeatures)
|
|
except json.JSONDecodeError:
|
|
parsed = []
|
|
if isinstance(parsed, list):
|
|
return cls._filterFeatures([str(item) for item in parsed], menu_profile)
|
|
return list(_DEFAULT_FEATURES_BY_PROFILE.get(menu_profile, _DEFAULT_FEATURES_BY_PROFILE["document_review"]))
|
|
|
|
@staticmethod
|
|
def _filterFeatures(Features: list[str], MenuProfile: str) -> list[str]:
|
|
normalized: list[str] = []
|
|
for item in Features:
|
|
feature = str(item or "").strip()
|
|
if MenuProfile == "govdoc" and feature == "rule_groups":
|
|
feature = "rules"
|
|
if feature in _ALLOWED_FEATURES and feature not in normalized:
|
|
normalized.append(feature)
|
|
return normalized or list(_DEFAULT_FEATURES_BY_PROFILE.get(MenuProfile, _DEFAULT_FEATURES_BY_PROFILE["document_review"]))
|
|
|
|
@staticmethod
|
|
def _toIso(Value) -> str | None:
|
|
"""时间转 ISO 字符串。"""
|
|
if Value is None:
|
|
return None
|
|
if isinstance(Value, datetime):
|
|
return Value.isoformat()
|
|
return str(Value)
|