"""规则配置页聚合服务实现。""" from __future__ import annotations import asyncio from collections import defaultdict import re import time from typing import Any 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 sqlalchemy import text from fastapi_modules.fastapi_leaudit.domian.vo.ruleConfigVo import ( RuleConfigPackListVO, RuleConfigPackRuleSummaryVO, RuleConfigPackVO, ) from fastapi_modules.fastapi_leaudit.leaudit_bridge.ruleValidator import RuleValidator from fastapi_modules.fastapi_leaudit.services import IOssService from fastapi_modules.fastapi_leaudit.services.impl.ossServiceImpl import OssServiceImpl from fastapi_modules.fastapi_leaudit.services.impl.ruleServiceImpl import GetRuleServiceSingleton from fastapi_modules.fastapi_leaudit.services.impl.ruleTenantScope import normalize_scoped_tenant_code, pick_effective_scoped_row from fastapi_modules.fastapi_leaudit.services.ruleConfigService import IRuleConfigService class RuleConfigServiceImpl(IRuleConfigService): """规则配置页聚合服务实现。""" _GLOBAL_YAML_SUMMARY_CACHE: dict[int, tuple[float, dict[str, Any]]] = {} _GLOBAL_PACK_SUMMARY_CACHE: dict[str, tuple[float, list[RuleConfigPackListVO]]] = {} _GLOBAL_WARM_LOCK: asyncio.Lock | None = None def __init__(self, OssService: IOssService | None = None) -> None: self.OssService = OssService or OssServiceImpl() self.RuleService = GetRuleServiceSingleton() self.Validator = RuleValidator() self._yaml_summary_cache = self.__class__._GLOBAL_YAML_SUMMARY_CACHE self._pack_summary_cache = self.__class__._GLOBAL_PACK_SUMMARY_CACHE @classmethod def _set_pack_summary_cache(cls, cache_key: str, value: tuple[float, list[RuleConfigPackListVO]] | None) -> None: if value is None: cls._GLOBAL_PACK_SUMMARY_CACHE.pop(cache_key, None) return cls._GLOBAL_PACK_SUMMARY_CACHE[cache_key] = value @classmethod def _get_warm_lock(cls) -> asyncio.Lock: if cls._GLOBAL_WARM_LOCK is None: cls._GLOBAL_WARM_LOCK = asyncio.Lock() return cls._GLOBAL_WARM_LOCK def InvalidateSummaryCaches(self, version_ids: list[int] | None = None) -> None: """清理规则摘要缓存；version_ids 为空时清空全部。""" self.__class__._GLOBAL_PACK_SUMMARY_CACHE.clear() if version_ids is None: self._yaml_summary_cache.clear() return for version_id in {int(item) for item in version_ids if item is not None}: self._yaml_summary_cache.pop(version_id, None) async def WarmPackSummaries(self, force: bool = False, CurrentUserId: int | None = None) -> list[RuleConfigPackListVO]: """预热规则列表摘要缓存。""" async with self.__class__._get_warm_lock(): if force: self.InvalidateSummaryCaches() return await self.ListPackSummaries(CurrentUserId=CurrentUserId) async def ListPacks(self, CurrentUserId: int | None = None) -> list[RuleConfigPackVO]: """列出规则配置页所需的全部 pack。""" rows = await self._load_pack_rows() rule_set_map = await self._load_rule_set_meta_map(CurrentUserId=CurrentUserId) return [await self._build_pack_vo(row, rule_set_map, CurrentUserId=CurrentUserId) for row in rows] async def ListPackSummaries(self, CurrentUserId: int | None = None) -> list[RuleConfigPackListVO]: """列出规则列表页所需的轻量 pack。""" cache_key = self._summary_cache_key(CurrentUserId) cached = self.__class__._GLOBAL_PACK_SUMMARY_CACHE.get(cache_key) now = time.monotonic() if cached and now - cached[0] <= 60: return cached[1] rows = await self._load_pack_rows() if not rows: return [] current_user = await self._load_current_user(CurrentUserId) group_ids = [int(row["group_id"]) for row in rows] binding_map = await self._load_effective_binding_map(group_ids, CurrentUserId=CurrentUserId) rule_set_ids = sorted({int(item["rule_set_id"]) for item in binding_map.values() if item.get("rule_set_id") is not None}) rule_set_map = await self._load_rule_set_meta_map_by_ids(rule_set_ids, CurrentUserId=CurrentUserId) latest_version_map = await self._load_latest_version_map(rule_set_ids) base_items: list[dict[str, Any]] = [] resolved_version_ids: set[int] = set() for row in rows: group_id = int(row["group_id"]) binding = binding_map.get(group_id) item = self._build_pack_summary_item( row=row, binding=binding, rule_set_map=rule_set_map, latest_version_map=latest_version_map, current_user=current_user, ) if item.get("resolvedVersionId") is not None: resolved_version_ids.add(int(item["resolvedVersionId"])) base_items.append(item) version_oss_map = await self._load_version_oss_map(sorted(resolved_version_ids)) yaml_summary_map = await self._load_yaml_summaries(version_oss_map) packs: list[RuleConfigPackListVO] = [] for item in base_items: summary = yaml_summary_map.get(item["resolvedVersionId"]) if item.get("resolvedVersionId") else None rules = summary["rules"] if summary else [] source_status = "empty" yaml_name = item.get("ruleName") or "" if item.get("resolvedVersionId") is not None: source_status = "ready" if summary and summary.get("loaded") else "missing" yaml_name = str(summary.get("yaml_name") or yaml_name or "") item["sourceStatus"] = source_status item["yamlName"] = yaml_name item["rules"] = [RuleConfigPackRuleSummaryVO(**rule) for rule in rules] item["usableRuleCount"] = len(rules) packs.append(RuleConfigPackListVO(**item)) cache_value = (time.monotonic(), packs) self.__class__._set_pack_summary_cache(cache_key, cache_value) self._pack_summary_cache = cache_value return packs async def GetPack(self, PackId: int, CurrentUserId: int | None = None) -> RuleConfigPackVO: """获取单个规则配置 pack。""" async with GetAsyncSession() as session: row = ( await session.execute( text( """ SELECT child.id AS group_id, child.name AS subtype, COALESCE(child.document_type_id, root.document_type_id) AS document_type_id, dt.name AS document_type_name, root.id AS root_group_id, COALESCE(root.name, child.name) AS main_type, em.name AS entry_module_name FROM leaudit_evaluation_point_groups child LEFT JOIN leaudit_evaluation_point_groups root ON root.id = child.pid AND root.deleted_at IS NULL LEFT JOIN leaudit_document_types dt ON dt.id = COALESCE(child.document_type_id, root.document_type_id) LEFT JOIN leaudit_entry_modules em ON em.id = COALESCE(child.entry_module_id, root.entry_module_id, dt.entry_module_id) WHERE child.id = :group_id AND child.deleted_at IS NULL AND COALESCE(child.pid, 0) <> 0 LIMIT 1 """ ), {"group_id": PackId}, ) ).mappings().first() if not row: raise LeauditException(StatusCodeEnum.HTTP_404_NOT_FOUND, "规则配置 pack 不存在") rule_set_map = await self._load_rule_set_meta_map(CurrentUserId=CurrentUserId) return await self._build_pack_vo(row, rule_set_map, CurrentUserId=CurrentUserId) async def _build_pack_vo( self, row, rule_set_map: dict[int, dict[str, object]], *, CurrentUserId: int | None = None, ) -> RuleConfigPackVO: """构建单个 pack 聚合对象。""" group_id = int(row["group_id"]) binding = await self._load_effective_binding(group_id, CurrentUserId=CurrentUserId) current_user = await self._load_current_user(CurrentUserId) document_type = str(row["document_type_name"] or "").strip() main_type = str(row["main_type"] or "").strip() subtype = str(row["subtype"] or "").strip() or "通用" module_type = str(row["entry_module_name"] or "").strip() or (f"{document_type}评查" if document_type else "规则配置") source_status = "empty" yaml_text = "" rule_set_id: int | None = None rule_type: str | None = None rule_name: str | None = None current_version_id: int | None = None fallback_version_id: int | None = None resolved_version_id: int | None = None has_usable_version = False usable_rule_count = 0 binding_id: int | None = None rules: list[RuleConfigPackRuleSummaryVO] = [] source_fields = self._resolve_source_fields(binding=binding, current_user=current_user) if binding: binding_id = int(binding["id"]) bound_rule_set_id = int(binding["rule_set_id"]) rule_set_meta = rule_set_map.get(bound_rule_set_id) if rule_set_meta: rule_set_id = bound_rule_set_id rule_type = str(rule_set_meta.get("rule_type") or "") or None rule_name = str(rule_set_meta.get("rule_name") or "") or None current_version_id = self._to_int(rule_set_meta.get("current_version_id")) fallback_version_id = self._to_int(rule_set_meta.get("fallback_version_id")) resolved_version_id = current_version_id or fallback_version_id has_usable_version = bool(rule_set_meta.get("has_usable_version")) usable_rule_count = int(rule_set_meta.get("usable_rule_count") or 0) if resolved_version_id is None: resolved_version_id = await self._load_latest_version_id(rule_set_id) if resolved_version_id is not None: yaml_text = await self._load_yaml_text_by_version_id(resolved_version_id) source_status = "ready" if yaml_text.strip() else "missing" version_oss_map = await self._load_version_oss_map([resolved_version_id]) summary = (await self._load_yaml_summaries(version_oss_map)).get(resolved_version_id) if summary and summary.get("loaded"): summary_rules = list(summary.get("rules") or []) rules = [RuleConfigPackRuleSummaryVO(**rule) for rule in summary_rules] usable_rule_count = len(rules) return RuleConfigPackVO( packId=group_id, groupId=group_id, rootGroupId=self._to_int(row.get("root_group_id")), bindingId=binding_id, ruleSetId=rule_set_id, effectiveTenantCode=source_fields["effectiveTenantCode"], effectiveScopeType=source_fields["effectiveScopeType"], isInherited=source_fields["isInherited"], sourceRuleSetId=self._to_int(rule_set_map.get(rule_set_id, {}).get("source_rule_set_id")) if rule_set_id is not None else None, ruleType=rule_type, ruleName=rule_name, currentVersionId=current_version_id, fallbackVersionId=fallback_version_id, resolvedVersionId=resolved_version_id, hasUsableVersion=has_usable_version, usableRuleCount=usable_rule_count, documentTypeId=self._to_int(row.get("document_type_id")), documentType=document_type, moduleType=module_type, mainType=main_type or document_type, subtype=subtype, yamlText=yaml_text, sourceStatus=source_status, rules=rules, ) async def _load_pack_rows(self): async with GetAsyncSession() as session: return ( await session.execute( text( """ SELECT child.id AS group_id, child.name AS subtype, COALESCE(child.document_type_id, root.document_type_id) AS document_type_id, dt.name AS document_type_name, root.id AS root_group_id, COALESCE(root.name, child.name) AS main_type, em.name AS entry_module_name FROM leaudit_evaluation_point_groups child LEFT JOIN leaudit_evaluation_point_groups root ON root.id = child.pid AND root.deleted_at IS NULL LEFT JOIN leaudit_document_types dt ON dt.id = COALESCE(child.document_type_id, root.document_type_id) LEFT JOIN leaudit_entry_modules em ON em.id = COALESCE(child.entry_module_id, root.entry_module_id, dt.entry_module_id) WHERE child.deleted_at IS NULL AND COALESCE(child.pid, 0) <> 0 ORDER BY COALESCE(root.sort_order, 0) ASC, root.id ASC, child.sort_order ASC, child.id ASC """ ) ) ).mappings().all() async def _load_effective_binding(self, group_id: int, CurrentUserId: int | None = None): """读取当前二级分组实际生效的规则集绑定。""" return (await self._load_effective_binding_map([group_id], CurrentUserId=CurrentUserId)).get(group_id) async def _load_effective_binding_map( self, group_ids: list[int], CurrentUserId: int | None = None, ) -> dict[int, dict[str, Any]]: if not group_ids: return {} async with GetAsyncSession() as session: current_user = await self.RuleService._get_current_user_context(session, CurrentUserId) binding_tenant_expr = ( "COALESCE(NULLIF(BTRIM(tenant_code), ''), 'PROVINCIAL')" if await self.RuleService._column_exists(session, "leaudit_rule_group_bindings", "tenant_code") else "'PROVINCIAL'" ) rows = ( await session.execute( text( f""" SELECT id, group_id, rule_set_id, priority, {binding_tenant_expr} AS tenant_code FROM leaudit_rule_group_bindings WHERE deleted_at IS NULL AND is_active = TRUE AND group_id = ANY(:group_ids) ORDER BY group_id ASC, priority DESC, id ASC """ ), {"group_ids": group_ids}, ) ).mappings().all() grouped: dict[int, list[dict[str, Any]]] = defaultdict(list) for row in rows: grouped[int(row["group_id"])].append(dict(row)) binding_map: dict[int, dict[str, Any]] = {} tenant_code = str(current_user.get("tenant_code") or "") or None if current_user else None for group_id, group_rows in grouped.items(): effective = pick_effective_scoped_row(group_rows, tenant_code) if effective is not None: binding_map[group_id] = dict(effective) return binding_map async def _load_current_user(self, CurrentUserId: int | None = None) -> dict[str, object] | None: async with GetAsyncSession() as session: return await self.RuleService._get_current_user_context(session, CurrentUserId) async def _load_rule_set_meta_map(self, CurrentUserId: int | None = None) -> dict[int, dict[str, object]]: items = await self.RuleService.ListSets(CurrentUserId=CurrentUserId) return { 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, "source_rule_set_id": getattr(item, "sourceRuleSetId", None), } for item in items } async def _load_rule_set_meta_map_by_ids( self, rule_set_ids: list[int], CurrentUserId: int | None = None, ) -> dict[int, dict[str, object]]: if not rule_set_ids: return {} items = await self.RuleService.ListSets(CurrentUserId=CurrentUserId) return { 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, "source_rule_set_id": getattr(item, "sourceRuleSetId", None), } for item in items if item.id in set(rule_set_ids) } def _build_pack_summary_item( self, *, row, binding: dict[str, Any] | None, rule_set_map: dict[int, dict[str, object]], latest_version_map: dict[int, int], current_user: dict[str, object] | None, ) -> dict[str, Any]: document_type = str(row["document_type_name"] or "").strip() main_type = str(row["main_type"] or "").strip() subtype = str(row["subtype"] or "").strip() or "通用" module_type = str(row["entry_module_name"] or "").strip() or (f"{document_type}评查" if document_type else "规则配置") binding_id: int | None = None rule_set_id: int | None = None rule_type: str | None = None rule_name: str | None = None current_version_id: int | None = None fallback_version_id: int | None = None resolved_version_id: int | None = None has_usable_version = False usable_rule_count = 0 source_rule_set_id: int | None = None source_fields = self._resolve_source_fields(binding=binding, current_user=current_user) if binding: binding_id = int(binding["id"]) bound_rule_set_id = int(binding["rule_set_id"]) rule_set_meta = rule_set_map.get(bound_rule_set_id) if rule_set_meta: rule_set_id = bound_rule_set_id rule_type = str(rule_set_meta.get("rule_type") or "") or None rule_name = str(rule_set_meta.get("rule_name") or "") or None current_version_id = self._to_int(rule_set_meta.get("current_version_id")) fallback_version_id = self._to_int(rule_set_meta.get("fallback_version_id")) has_usable_version = bool(rule_set_meta.get("has_usable_version")) source_rule_set_id = self._to_int(rule_set_meta.get("source_rule_set_id")) resolved_version_id = current_version_id or fallback_version_id or latest_version_map.get(rule_set_id) return { "packId": int(row["group_id"]), "groupId": int(row["group_id"]), "rootGroupId": self._to_int(row.get("root_group_id")), "bindingId": binding_id, "ruleSetId": rule_set_id, "effectiveTenantCode": source_fields["effectiveTenantCode"], "effectiveScopeType": source_fields["effectiveScopeType"], "isInherited": source_fields["isInherited"], "sourceRuleSetId": source_rule_set_id, "ruleType": rule_type, "ruleName": rule_name, "currentVersionId": current_version_id, "fallbackVersionId": fallback_version_id, "resolvedVersionId": resolved_version_id, "hasUsableVersion": has_usable_version, "usableRuleCount": usable_rule_count, "documentTypeId": self._to_int(row.get("document_type_id")), "documentType": document_type, "moduleType": module_type, "mainType": main_type or document_type, "subtype": subtype, } def _resolve_source_fields( self, *, binding: dict[str, Any] | None, current_user: dict[str, object] | None, ) -> dict[str, Any]: if not binding: return { "effectiveTenantCode": None, "effectiveScopeType": None, "isInherited": False, } effective_tenant_code = normalize_scoped_tenant_code(str(binding.get("tenant_code") or "")) effective_scope_type = self._scope_type_from_tenant_code(effective_tenant_code) is_tenant_user = bool(current_user) and not bool(current_user.get("is_global")) and bool(str(current_user.get("tenant_code") or "").strip()) is_inherited = is_tenant_user and effective_scope_type in {"PROVINCIAL", "PUBLIC"} return { "effectiveTenantCode": effective_tenant_code, "effectiveScopeType": effective_scope_type, "isInherited": is_inherited, } def _scope_type_from_tenant_code(self, tenant_code: str | None) -> str | None: normalized = normalize_scoped_tenant_code(tenant_code) if tenant_code is not None else None if not normalized: return None if normalized == "PUBLIC": return "PUBLIC" if normalized == "PROVINCIAL": return "PROVINCIAL" return "TENANT" async def _load_version_oss_map(self, version_ids: list[int]) -> dict[int, str]: if not version_ids: return {} async with GetAsyncSession() as session: rows = ( await session.execute( text( """ SELECT id, oss_url FROM leaudit_rule_versions WHERE id = ANY(:version_ids) AND deleted_at IS NULL """ ), {"version_ids": version_ids}, ) ).mappings().all() return {int(row["id"]): str(row["oss_url"] or "") for row in rows if row.get("oss_url")} async def _load_latest_version_map(self, rule_set_ids: list[int]) -> dict[int, int]: if not rule_set_ids: return {} async with GetAsyncSession() as session: rows = ( await session.execute( text( """ SELECT DISTINCT ON (rule_set_id) rule_set_id, id FROM leaudit_rule_versions WHERE rule_set_id = ANY(:rule_set_ids) AND deleted_at IS NULL ORDER BY rule_set_id, version_seq DESC, id DESC """ ), {"rule_set_ids": rule_set_ids}, ) ).mappings().all() return {int(row["rule_set_id"]): int(row["id"]) for row in rows} async def _load_yaml_text_by_version_id(self, version_id: int) -> str: async with GetAsyncSession() as session: row = ( await session.execute( text( """ SELECT oss_url FROM leaudit_rule_versions WHERE id = :version_id AND deleted_at IS NULL LIMIT 1 """ ), {"version_id": version_id}, ) ).mappings().first() if not row or not row["oss_url"]: return "" try: return (await self.OssService.DownloadBytes(row["oss_url"])).decode("utf-8") except Exception: return "" async def _load_yaml_summaries(self, version_oss_map: dict[int, str]) -> dict[int, dict[str, Any]]: def _extract_rule_dependencies(rule: Any) -> list[str]: dependencies: list[str] = [] for item in list(getattr(rule, "dependencies", []) or []): value = str(item or "").strip() if value: dependencies.append(value) for stage in list(getattr(rule, "stages", []) or []): field = str(getattr(stage, "field", "") or "").strip() if field: dependencies.append(field) for attr_name in ("seal_id", "signature_id", "element"): attr_value = str(getattr(stage, attr_name, "") or "").strip() if attr_value: dependencies.append(attr_value) for item in list(getattr(stage, "fields", []) or []): value = str(item or "").strip() if value: dependencies.append(value) prompt = str(getattr(stage, "prompt", "") or "") if prompt: dependencies.extend( match.strip() for match in re.findall(r"\{\{\s*([^}]+?)\s*\}\}", prompt) if match.strip() ) deduped: list[str] = [] seen: set[str] = set() for item in dependencies: if item in seen: continue seen.add(item) deduped.append(item) return deduped async def _load_one(version_id: int, oss_url: str): if not oss_url: return version_id, {"loaded": False, "yaml_name": "", "rules": []} cached = self._yaml_summary_cache.get(version_id) now = time.monotonic() if cached and now - cached[0] <= 120: return version_id, cached[1] try: yaml_text = (await self.OssService.DownloadBytes(oss_url)).decode("utf-8") if not yaml_text.strip(): summary = {"loaded": False, "yaml_name": "", "rules": []} self._yaml_summary_cache[version_id] = (time.monotonic(), summary) return version_id, summary rules_file = self.Validator.ParseValidated(yaml_text) groups: dict[str, str] = {} try: for group in getattr(rules_file, "rules", []) or []: group_name = getattr(group, "group", "") or "" for rule in getattr(group, "rules", []) or []: groups[getattr(rule, "rule_id", "") or ""] = group_name except Exception: groups = {} summaries = [] for rule in getattr(rules_file, "flat_rules", []) or []: stage_items = [] check_types = [] for idx, stage in enumerate(getattr(rule, "stages", []) or [], start=1): check = str(getattr(stage, "check", "") or getattr(stage, "type", "") or "") check_types.append(check) content = check if check == "ai": content = str(getattr(stage, "prompt", "") or "") elif hasattr(stage, "fields") and getattr(stage, "fields"): content = "、".join(str(item) for item in getattr(stage, "fields")[:3]) stage_items.append({"id": str(idx), "check": check, "content": content}) summaries.append({ "id": getattr(rule, "rule_id", "") or getattr(rule, "name", "") or "-", "ruleId": getattr(rule, "rule_id", "") or "-", "name": getattr(rule, "name", "") or getattr(rule, "rule_id", "") or "未命名规则", "group": groups.get(getattr(rule, "rule_id", "") or "", getattr(rule, "group", "") or "未分组"), "risk": str(getattr(rule, "risk", "medium") or "medium"), "score": str(getattr(rule, "score", "0") or "0"), "type": str(getattr(rule, "type", "deterministic") or "deterministic"), "checkTypes": [item for item in check_types if item], "logic": str(getattr(rule, "logic", "") or ""), "subRules": stage_items, "subRuleIds": list(getattr(rule, "rules", []) or []), "scope": list(getattr(rule, "scope", []) or []), "dependencies": _extract_rule_dependencies(rule), "stageCount": len(stage_items), "appliesIn": list(getattr(rule, "applies_in", []) or []), "prompt": stage_items[0]["content"] if len(stage_items) == 1 and stage_items[0]["check"] == "ai" else "", "description": str(getattr(rule, "desc", "") or ""), }) summary_map = { str(item.get("ruleId") or item.get("id") or ""): item for item in summaries if str(item.get("ruleId") or item.get("id") or "") } for item in summaries: if item.get("dependencies"): continue sub_rule_ids = [str(sub_rule_id or "").strip() for sub_rule_id in list(item.get("subRuleIds") or []) if str(sub_rule_id or "").strip()] if not sub_rule_ids: continue merged_dependencies: list[str] = [] seen_dependencies: set[str] = set() for sub_rule_id in sub_rule_ids: child_summary = summary_map.get(sub_rule_id) if not child_summary: continue for dependency in list(child_summary.get("dependencies") or []): normalized_dependency = str(dependency or "").strip() if not normalized_dependency or normalized_dependency in seen_dependencies: continue seen_dependencies.add(normalized_dependency) merged_dependencies.append(normalized_dependency) item["dependencies"] = merged_dependencies summary = { "loaded": True, "yaml_name": str(getattr(getattr(rules_file, "metadata", None), "name", "") or ""), "rules": summaries, } self._yaml_summary_cache[version_id] = (time.monotonic(), summary) return version_id, summary except Exception: summary = {"loaded": False, "yaml_name": "", "rules": []} self._yaml_summary_cache[version_id] = (time.monotonic(), summary) return version_id, summary results = await asyncio.gather(*[_load_one(version_id, oss_url) for version_id, oss_url in version_oss_map.items()]) return dict(results) async def _load_latest_version_id(self, rule_set_id: int) -> int | None: async with GetAsyncSession() as session: row = ( await session.execute( text( """ SELECT id FROM leaudit_rule_versions WHERE rule_set_id = :rule_set_id AND deleted_at IS NULL ORDER BY version_seq DESC, id DESC LIMIT 1 """ ), {"rule_set_id": rule_set_id}, ) ).mappings().first() return self._to_int(row.get("id")) if row else None async def _load_version_seq_by_id(self, version_id: int | None) -> int: if version_id is None: return -1 async with GetAsyncSession() as session: row = ( await session.execute( text( """ SELECT version_seq FROM leaudit_rule_versions WHERE id = :version_id AND deleted_at IS NULL LIMIT 1 """ ), {"version_id": version_id}, ) ).mappings().first() return int(row.get("version_seq") or -1) if row else -1 def _to_int(self, value) -> int | None: if value is None: return None return int(value) @staticmethod def _summary_cache_key(CurrentUserId: int | None) -> str: return f"user:{CurrentUserId or 0}" _RULE_CONFIG_SERVICE_SINGLETON: RuleConfigServiceImpl | None = None def GetRuleConfigServiceSingleton() -> RuleConfigServiceImpl: """返回共享的规则配置服务实例，供控制器和预热任务共用缓存。""" global _RULE_CONFIG_SERVICE_SINGLETON if _RULE_CONFIG_SERVICE_SINGLETON is None: _RULE_CONFIG_SERVICE_SINGLETON = RuleConfigServiceImpl() return _RULE_CONFIG_SERVICE_SINGLETON