wren
869 lines
36 KiB
Python
869 lines
36 KiB
Python
"""租户主数据服务实现。"""
|
||
|
||
from __future__ import annotations
|
||
|
||
from typing import Any
|
||
|
||
from sqlalchemy import text
|
||
|
||
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.tenantDto import (
|
||
TenantCreateDTO,
|
||
TenantStatusUpdateDTO,
|
||
TenantUpdateDTO,
|
||
)
|
||
from fastapi_modules.fastapi_leaudit.services.impl.ruleTenantMaterializer import (
|
||
GetRuleTenantMaterializerSingleton,
|
||
RuleTenantMaterializer,
|
||
)
|
||
from fastapi_modules.fastapi_leaudit.services.tenantService import ITenantService
|
||
|
||
|
||
class TenantServiceImpl(ITenantService):
|
||
"""租户主数据服务实现。"""
|
||
|
||
_BUILTIN_TENANT_CODES: tuple[str, ...] = ("PUBLIC", "PROVINCIAL")
|
||
_SUPPORTED_FEATURE_KEYS: tuple[str, ...] = (
|
||
"home.entry_module",
|
||
"documents.upload",
|
||
"rag.dataset",
|
||
)
|
||
|
||
def __init__(self, RuleTenantMaterializer: RuleTenantMaterializer | None = None) -> None:
|
||
self._table_exists_cache: dict[str, bool] = {}
|
||
self.RuleTenantMaterializer = RuleTenantMaterializer or GetRuleTenantMaterializerSingleton()
|
||
|
||
async def ListTenants(self, IncludeDisabled: bool = False) -> list[dict[str, Any]]:
|
||
if not await self._table_exists("sys_tenants"):
|
||
return await self._list_legacy_tenants()
|
||
filters = ["t.deleted_at IS NULL"]
|
||
params: dict[str, Any] = {}
|
||
if not IncludeDisabled:
|
||
filters.append("t.is_enabled = TRUE")
|
||
|
||
where_sql = " AND ".join(filters)
|
||
async with GetAsyncSession() as session:
|
||
rows = (
|
||
await session.execute(
|
||
text(
|
||
f"""
|
||
SELECT
|
||
t.tenant_code,
|
||
t.tenant_name,
|
||
t.tenant_short_name,
|
||
t.tenant_type,
|
||
t.parent_tenant_code,
|
||
t.display_order,
|
||
t.is_enabled,
|
||
t.is_builtin,
|
||
t.is_public,
|
||
t.can_host_entry_module,
|
||
t.can_host_documents,
|
||
t.can_host_rag,
|
||
t.can_host_templates,
|
||
t.ext,
|
||
COALESCE(
|
||
ARRAY(
|
||
SELECT f.feature_key
|
||
FROM sys_tenant_feature_flags f
|
||
WHERE f.tenant_code = t.tenant_code
|
||
AND f.deleted_at IS NULL
|
||
AND f.is_enabled = TRUE
|
||
ORDER BY f.feature_key ASC
|
||
),
|
||
ARRAY[]::VARCHAR[]
|
||
) AS feature_keys,
|
||
COALESCE(
|
||
ARRAY(
|
||
SELECT a.alias_value
|
||
FROM sys_tenant_aliases a
|
||
WHERE a.tenant_code = t.tenant_code
|
||
AND a.deleted_at IS NULL
|
||
AND a.is_enabled = TRUE
|
||
ORDER BY
|
||
CASE a.alias_type
|
||
WHEN 'DISPLAY' THEN 1
|
||
WHEN 'SHORT_NAME' THEN 2
|
||
WHEN 'LEGACY_AREA' THEN 3
|
||
ELSE 9
|
||
END ASC,
|
||
a.id ASC
|
||
),
|
||
ARRAY[]::VARCHAR[]
|
||
) AS alias_values
|
||
FROM sys_tenants t
|
||
WHERE {where_sql}
|
||
ORDER BY t.display_order ASC, t.id ASC
|
||
"""
|
||
),
|
||
params,
|
||
)
|
||
).mappings().all()
|
||
|
||
return [dict(row) for row in rows]
|
||
|
||
async def ListTenantOptions(self, FeatureKey: str | None = None) -> list[dict[str, Any]]:
|
||
if not await self._table_exists("sys_tenants"):
|
||
items = await self._list_legacy_tenant_options()
|
||
return items
|
||
filters = ["t.deleted_at IS NULL", "t.is_enabled = TRUE"]
|
||
params: dict[str, Any] = {}
|
||
join_sql = ""
|
||
if FeatureKey and FeatureKey.strip() and await self._table_exists("sys_tenant_feature_flags"):
|
||
join_sql = """
|
||
JOIN sys_tenant_feature_flags f
|
||
ON f.tenant_code = t.tenant_code
|
||
AND f.deleted_at IS NULL
|
||
AND f.is_enabled = TRUE
|
||
AND f.feature_key = :feature_key
|
||
"""
|
||
params["feature_key"] = FeatureKey.strip()
|
||
|
||
where_sql = " AND ".join(filters)
|
||
async with GetAsyncSession() as session:
|
||
rows = (
|
||
await session.execute(
|
||
text(
|
||
f"""
|
||
SELECT
|
||
t.tenant_code,
|
||
t.tenant_name,
|
||
t.tenant_short_name,
|
||
t.tenant_type,
|
||
t.is_public,
|
||
t.display_order
|
||
FROM sys_tenants t
|
||
{join_sql}
|
||
WHERE {where_sql}
|
||
ORDER BY t.display_order ASC, t.id ASC
|
||
"""
|
||
),
|
||
params,
|
||
)
|
||
).mappings().all()
|
||
return [dict(row) for row in rows]
|
||
|
||
async def GetTenant(self, TenantCode: str) -> dict[str, Any] | None:
|
||
tenant_code = str(TenantCode or "").strip()
|
||
if not tenant_code:
|
||
return None
|
||
if not await self._table_exists("sys_tenants"):
|
||
for item in await self._list_legacy_tenants():
|
||
if str(item.get("tenant_code") or "").strip() == tenant_code:
|
||
return item
|
||
return None
|
||
async with GetAsyncSession() as session:
|
||
row = (
|
||
await session.execute(
|
||
text(
|
||
"""
|
||
SELECT
|
||
t.tenant_code,
|
||
t.tenant_name,
|
||
t.tenant_short_name,
|
||
t.tenant_type,
|
||
t.parent_tenant_code,
|
||
t.display_order,
|
||
t.is_enabled,
|
||
t.is_builtin,
|
||
t.is_public,
|
||
t.can_host_entry_module,
|
||
t.can_host_documents,
|
||
t.can_host_rag,
|
||
t.can_host_templates,
|
||
t.ext
|
||
FROM sys_tenants t
|
||
WHERE t.tenant_code = :tenant_code
|
||
AND t.deleted_at IS NULL
|
||
LIMIT 1
|
||
"""
|
||
),
|
||
{"tenant_code": tenant_code},
|
||
)
|
||
).mappings().first()
|
||
return dict(row) if row else None
|
||
|
||
async def GetTenantFeatures(self, TenantCode: str) -> list[str]:
|
||
tenant_code = str(TenantCode or "").strip()
|
||
if not tenant_code:
|
||
return []
|
||
if not await self._table_exists("sys_tenant_feature_flags"):
|
||
return []
|
||
async with GetAsyncSession() as session:
|
||
rows = (
|
||
await session.execute(
|
||
text(
|
||
"""
|
||
SELECT feature_key
|
||
FROM sys_tenant_feature_flags
|
||
WHERE tenant_code = :tenant_code
|
||
AND deleted_at IS NULL
|
||
AND is_enabled = TRUE
|
||
ORDER BY feature_key ASC
|
||
"""
|
||
),
|
||
{"tenant_code": tenant_code},
|
||
)
|
||
).all()
|
||
return [str(row[0]) for row in rows]
|
||
|
||
async def GetTenantAliases(self, TenantCode: str) -> list[str]:
|
||
tenant_code = str(TenantCode or "").strip()
|
||
if not tenant_code:
|
||
return []
|
||
return await self._getTenantAliases(tenant_code)
|
||
|
||
async def CreateTenant(self, CurrentUserId: int, Body: TenantCreateDTO) -> dict[str, Any]:
|
||
del CurrentUserId
|
||
await self._ensureWritableTenantFoundation()
|
||
|
||
tenant_code = self._normalizeTenantCode(Body.tenant_code)
|
||
tenant_name = self._normalizeRequiredText(Body.tenant_name, "租户名称")
|
||
tenant_short_name = self._normalizeOptionalText(Body.tenant_short_name) or tenant_name
|
||
tenant_type = self._normalizeTenantType(Body.tenant_type)
|
||
parent_tenant_code = self._normalizeOptionalCode(Body.parent_tenant_code)
|
||
feature_keys = self._normalizeFeatureKeys(Body.feature_keys)
|
||
alias_values = self._normalizeAliasValues(Body.alias_values, tenant_name=tenant_name, tenant_short_name=tenant_short_name)
|
||
ext = Body.ext or {}
|
||
|
||
async with GetAsyncSession() as session:
|
||
exists = (
|
||
await session.execute(
|
||
text(
|
||
"""
|
||
SELECT 1
|
||
FROM sys_tenants
|
||
WHERE tenant_code = :tenant_code
|
||
AND deleted_at IS NULL
|
||
LIMIT 1
|
||
"""
|
||
),
|
||
{"tenant_code": tenant_code},
|
||
)
|
||
).scalar_one_or_none()
|
||
if exists:
|
||
raise LeauditException(StatusCodeEnum.HTTP_409_CONFLICT, f"租户编码已存在: {tenant_code}")
|
||
|
||
if parent_tenant_code:
|
||
await self._assertTenantExists(session, parent_tenant_code, "父级租户不存在")
|
||
|
||
await session.execute(
|
||
text(
|
||
"""
|
||
INSERT INTO sys_tenants (
|
||
tenant_code,
|
||
tenant_name,
|
||
tenant_short_name,
|
||
tenant_type,
|
||
parent_tenant_code,
|
||
display_order,
|
||
is_enabled,
|
||
is_builtin,
|
||
is_public,
|
||
can_host_entry_module,
|
||
can_host_documents,
|
||
can_host_rag,
|
||
can_host_templates,
|
||
ext,
|
||
created_at,
|
||
updated_at,
|
||
deleted_at
|
||
) VALUES (
|
||
:tenant_code,
|
||
:tenant_name,
|
||
:tenant_short_name,
|
||
:tenant_type,
|
||
:parent_tenant_code,
|
||
:display_order,
|
||
:is_enabled,
|
||
FALSE,
|
||
:is_public,
|
||
:can_host_entry_module,
|
||
:can_host_documents,
|
||
:can_host_rag,
|
||
:can_host_templates,
|
||
CAST(:ext AS jsonb),
|
||
NOW(),
|
||
NOW(),
|
||
NULL
|
||
)
|
||
"""
|
||
),
|
||
{
|
||
"tenant_code": tenant_code,
|
||
"tenant_name": tenant_name,
|
||
"tenant_short_name": tenant_short_name,
|
||
"tenant_type": tenant_type,
|
||
"parent_tenant_code": parent_tenant_code,
|
||
"display_order": int(Body.display_order or 0),
|
||
"is_enabled": bool(Body.is_enabled),
|
||
"is_public": bool(Body.is_public),
|
||
"can_host_entry_module": bool(Body.can_host_entry_module),
|
||
"can_host_documents": bool(Body.can_host_documents),
|
||
"can_host_rag": bool(Body.can_host_rag),
|
||
"can_host_templates": bool(Body.can_host_templates),
|
||
"ext": self._dumpJson(ext),
|
||
},
|
||
)
|
||
await self._replaceTenantAliases(session, tenant_code, alias_values)
|
||
await self._replaceTenantFeatures(session, tenant_code, feature_keys)
|
||
await session.commit()
|
||
|
||
await self.RuleTenantMaterializer.MaterializeTenant(tenant_code)
|
||
return await self._getTenantDetailOrFail(tenant_code)
|
||
|
||
async def UpdateTenant(self, CurrentUserId: int, TenantCode: str, Body: TenantUpdateDTO) -> dict[str, Any]:
|
||
del CurrentUserId
|
||
await self._ensureWritableTenantFoundation()
|
||
tenant_code = self._normalizeTenantCode(TenantCode)
|
||
|
||
async with GetAsyncSession() as session:
|
||
current = await self._loadTenantRow(session, tenant_code)
|
||
if not current:
|
||
raise LeauditException(StatusCodeEnum.HTTP_404_NOT_FOUND, "租户不存在")
|
||
|
||
is_builtin = bool(current.get("is_builtin"))
|
||
tenant_name = self._normalizeOptionalText(Body.tenant_name) if Body.tenant_name is not None else str(current.get("tenant_name") or "")
|
||
if not tenant_name:
|
||
raise LeauditException(StatusCodeEnum.HTTP_400_BAD_REQUEST, "租户名称不能为空")
|
||
tenant_short_name = (
|
||
self._normalizeOptionalText(Body.tenant_short_name)
|
||
if Body.tenant_short_name is not None
|
||
else self._normalizeOptionalText(current.get("tenant_short_name"))
|
||
) or tenant_name
|
||
tenant_type = self._normalizeTenantType(Body.tenant_type) if Body.tenant_type is not None else str(current.get("tenant_type") or "CUSTOM")
|
||
parent_tenant_code = self._normalizeOptionalCode(Body.parent_tenant_code) if Body.parent_tenant_code is not None else current.get("parent_tenant_code")
|
||
if parent_tenant_code == tenant_code:
|
||
raise LeauditException(StatusCodeEnum.HTTP_400_BAD_REQUEST, "父级租户不能指向自身")
|
||
if parent_tenant_code:
|
||
await self._assertTenantExists(session, str(parent_tenant_code), "父级租户不存在", exclude_tenant_code=tenant_code)
|
||
|
||
if is_builtin and tenant_code in self._BUILTIN_TENANT_CODES:
|
||
tenant_type = str(current.get("tenant_type") or tenant_type)
|
||
parent_tenant_code = current.get("parent_tenant_code")
|
||
|
||
await session.execute(
|
||
text(
|
||
"""
|
||
UPDATE sys_tenants
|
||
SET tenant_name = :tenant_name,
|
||
tenant_short_name = :tenant_short_name,
|
||
tenant_type = :tenant_type,
|
||
parent_tenant_code = :parent_tenant_code,
|
||
display_order = :display_order,
|
||
is_public = :is_public,
|
||
can_host_entry_module = :can_host_entry_module,
|
||
can_host_documents = :can_host_documents,
|
||
can_host_rag = :can_host_rag,
|
||
can_host_templates = :can_host_templates,
|
||
ext = CAST(:ext AS jsonb),
|
||
updated_at = NOW()
|
||
WHERE tenant_code = :tenant_code
|
||
AND deleted_at IS NULL
|
||
"""
|
||
),
|
||
{
|
||
"tenant_code": tenant_code,
|
||
"tenant_name": tenant_name,
|
||
"tenant_short_name": tenant_short_name,
|
||
"tenant_type": tenant_type,
|
||
"parent_tenant_code": parent_tenant_code,
|
||
"display_order": int(Body.display_order if Body.display_order is not None else current.get("display_order") or 0),
|
||
"is_public": bool(Body.is_public if Body.is_public is not None else current.get("is_public")),
|
||
"can_host_entry_module": bool(
|
||
Body.can_host_entry_module if Body.can_host_entry_module is not None else current.get("can_host_entry_module")
|
||
),
|
||
"can_host_documents": bool(
|
||
Body.can_host_documents if Body.can_host_documents is not None else current.get("can_host_documents")
|
||
),
|
||
"can_host_rag": bool(Body.can_host_rag if Body.can_host_rag is not None else current.get("can_host_rag")),
|
||
"can_host_templates": bool(
|
||
Body.can_host_templates if Body.can_host_templates is not None else current.get("can_host_templates")
|
||
),
|
||
"ext": self._dumpJson(Body.ext if Body.ext is not None else (current.get("ext") or {})),
|
||
},
|
||
)
|
||
|
||
if Body.alias_values is not None:
|
||
alias_values = self._normalizeAliasValues(Body.alias_values, tenant_name=tenant_name, tenant_short_name=tenant_short_name)
|
||
await self._replaceTenantAliases(session, tenant_code, alias_values)
|
||
if Body.feature_keys is not None:
|
||
feature_keys = self._normalizeFeatureKeys(Body.feature_keys)
|
||
await self._replaceTenantFeatures(session, tenant_code, feature_keys)
|
||
await session.commit()
|
||
|
||
return await self._getTenantDetailOrFail(tenant_code)
|
||
|
||
async def UpdateTenantStatus(self, CurrentUserId: int, TenantCode: str, Body: TenantStatusUpdateDTO) -> dict[str, Any]:
|
||
del CurrentUserId
|
||
await self._ensureWritableTenantFoundation()
|
||
tenant_code = self._normalizeTenantCode(TenantCode)
|
||
is_enabled = bool(Body.is_enabled)
|
||
|
||
async with GetAsyncSession() as session:
|
||
current = await self._loadTenantRow(session, tenant_code)
|
||
if not current:
|
||
raise LeauditException(StatusCodeEnum.HTTP_404_NOT_FOUND, "租户不存在")
|
||
if bool(current.get("is_builtin")) and tenant_code in self._BUILTIN_TENANT_CODES and not is_enabled:
|
||
raise LeauditException(StatusCodeEnum.HTTP_400_BAD_REQUEST, "内建核心租户不允许禁用")
|
||
if not is_enabled:
|
||
await self._assertTenantCanBeDisabled(session, tenant_code)
|
||
|
||
await session.execute(
|
||
text(
|
||
"""
|
||
UPDATE sys_tenants
|
||
SET is_enabled = :is_enabled,
|
||
updated_at = NOW()
|
||
WHERE tenant_code = :tenant_code
|
||
AND deleted_at IS NULL
|
||
"""
|
||
),
|
||
{"tenant_code": tenant_code, "is_enabled": is_enabled},
|
||
)
|
||
await session.commit()
|
||
|
||
return await self._getTenantDetailOrFail(tenant_code)
|
||
|
||
async def _table_exists(self, table_name: str) -> bool:
|
||
cached = self._table_exists_cache.get(table_name)
|
||
if cached is not None:
|
||
return cached
|
||
|
||
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 = :table_name
|
||
)
|
||
"""
|
||
),
|
||
{"table_name": table_name},
|
||
)
|
||
).scalar_one()
|
||
)
|
||
self._table_exists_cache[table_name] = exists
|
||
return exists
|
||
|
||
async def _list_legacy_tenants(self) -> list[dict[str, Any]]:
|
||
async with GetAsyncSession() as session:
|
||
user_rows = (
|
||
await session.execute(
|
||
text(
|
||
"""
|
||
SELECT DISTINCT COALESCE(NULLIF(area, ''), '') AS area
|
||
FROM sso_users
|
||
WHERE deleted_at IS NULL
|
||
AND COALESCE(NULLIF(area, ''), '') <> ''
|
||
ORDER BY COALESCE(NULLIF(area, ''), '') ASC
|
||
"""
|
||
)
|
||
)
|
||
).all()
|
||
|
||
items: list[dict[str, Any]] = [
|
||
{
|
||
"tenant_code": "PUBLIC",
|
||
"tenant_name": "公共",
|
||
"tenant_short_name": "公共",
|
||
"tenant_type": "PUBLIC",
|
||
"parent_tenant_code": None,
|
||
"display_order": 0,
|
||
"is_enabled": True,
|
||
"is_builtin": True,
|
||
"is_public": True,
|
||
"can_host_entry_module": True,
|
||
"can_host_documents": True,
|
||
"can_host_rag": True,
|
||
"can_host_templates": True,
|
||
"ext": {},
|
||
"feature_keys": [],
|
||
}
|
||
]
|
||
for index, row in enumerate(user_rows, start=1):
|
||
area = str(row[0] or "").strip()
|
||
if not area or area == "公共":
|
||
continue
|
||
items.append(
|
||
{
|
||
"tenant_code": area,
|
||
"tenant_name": area,
|
||
"tenant_short_name": area,
|
||
"tenant_type": "LEGACY_AREA",
|
||
"parent_tenant_code": None,
|
||
"display_order": index * 10,
|
||
"is_enabled": True,
|
||
"is_builtin": False,
|
||
"is_public": False,
|
||
"can_host_entry_module": True,
|
||
"can_host_documents": True,
|
||
"can_host_rag": True,
|
||
"can_host_templates": True,
|
||
"ext": {},
|
||
"feature_keys": [],
|
||
}
|
||
)
|
||
return items
|
||
|
||
async def _list_legacy_tenant_options(self) -> list[dict[str, Any]]:
|
||
return [
|
||
{
|
||
"tenant_code": str(item.get("tenant_code") or ""),
|
||
"tenant_name": str(item.get("tenant_name") or ""),
|
||
"tenant_short_name": item.get("tenant_short_name"),
|
||
"tenant_type": item.get("tenant_type"),
|
||
"is_public": bool(item.get("is_public")),
|
||
"display_order": item.get("display_order"),
|
||
}
|
||
for item in await self._list_legacy_tenants()
|
||
]
|
||
|
||
async def _ensureWritableTenantFoundation(self) -> None:
|
||
required_tables = ("sys_tenants", "sys_tenant_aliases", "sys_tenant_feature_flags")
|
||
missing = [table_name for table_name in required_tables if not await self._table_exists(table_name)]
|
||
if missing:
|
||
joined = ", ".join(missing)
|
||
raise LeauditException(StatusCodeEnum.HTTP_500_INTERNAL_SERVER_ERROR, f"租户主数据底座未初始化，缺少表: {joined}")
|
||
|
||
async def _getTenantDetailOrFail(self, tenant_code: str) -> dict[str, Any]:
|
||
item = await self.GetTenant(tenant_code)
|
||
if not item:
|
||
raise LeauditException(StatusCodeEnum.HTTP_404_NOT_FOUND, "租户不存在")
|
||
item["feature_keys"] = await self.GetTenantFeatures(tenant_code)
|
||
item["alias_values"] = await self.GetTenantAliases(tenant_code)
|
||
return item
|
||
|
||
async def _getTenantAliases(self, tenant_code: str) -> list[str]:
|
||
if not await self._table_exists("sys_tenant_aliases"):
|
||
return []
|
||
async with GetAsyncSession() as session:
|
||
rows = (
|
||
await session.execute(
|
||
text(
|
||
"""
|
||
SELECT alias_value
|
||
FROM sys_tenant_aliases
|
||
WHERE tenant_code = :tenant_code
|
||
AND deleted_at IS NULL
|
||
AND is_enabled = TRUE
|
||
ORDER BY
|
||
CASE alias_type
|
||
WHEN 'DISPLAY' THEN 1
|
||
WHEN 'SHORT_NAME' THEN 2
|
||
WHEN 'LEGACY_AREA' THEN 3
|
||
ELSE 9
|
||
END ASC,
|
||
id ASC
|
||
"""
|
||
),
|
||
{"tenant_code": tenant_code},
|
||
)
|
||
).all()
|
||
return [str(row[0]).strip() for row in rows if str(row[0] or "").strip()]
|
||
|
||
async def _loadTenantRow(self, session: Any, tenant_code: str) -> dict[str, Any] | None:
|
||
row = (
|
||
await session.execute(
|
||
text(
|
||
"""
|
||
SELECT
|
||
tenant_code,
|
||
tenant_name,
|
||
tenant_short_name,
|
||
tenant_type,
|
||
parent_tenant_code,
|
||
display_order,
|
||
is_enabled,
|
||
is_builtin,
|
||
is_public,
|
||
can_host_entry_module,
|
||
can_host_documents,
|
||
can_host_rag,
|
||
can_host_templates,
|
||
ext
|
||
FROM sys_tenants
|
||
WHERE tenant_code = :tenant_code
|
||
AND deleted_at IS NULL
|
||
LIMIT 1
|
||
"""
|
||
),
|
||
{"tenant_code": tenant_code},
|
||
)
|
||
).mappings().first()
|
||
return dict(row) if row else None
|
||
|
||
async def _assertTenantExists(
|
||
self,
|
||
session: Any,
|
||
tenant_code: str,
|
||
error_message: str,
|
||
exclude_tenant_code: str | None = None,
|
||
) -> None:
|
||
params: dict[str, Any] = {"tenant_code": tenant_code}
|
||
sql = """
|
||
SELECT 1
|
||
FROM sys_tenants
|
||
WHERE tenant_code = :tenant_code
|
||
AND deleted_at IS NULL
|
||
"""
|
||
if exclude_tenant_code:
|
||
sql += " AND tenant_code <> :exclude_tenant_code"
|
||
params["exclude_tenant_code"] = exclude_tenant_code
|
||
sql += " LIMIT 1"
|
||
exists = (await session.execute(text(sql), params)).scalar_one_or_none()
|
||
if not exists:
|
||
raise LeauditException(StatusCodeEnum.HTTP_400_BAD_REQUEST, error_message)
|
||
|
||
async def _assertTenantCanBeDisabled(self, session: Any, tenant_code: str) -> None:
|
||
references = await self._collectDisableReferences(session, tenant_code)
|
||
if not references:
|
||
return
|
||
joined = "；".join(references)
|
||
raise LeauditException(StatusCodeEnum.HTTP_400_BAD_REQUEST, f"当前租户仍被引用，不能禁用：{joined}")
|
||
|
||
async def _collectDisableReferences(self, session: Any, tenant_code: str) -> list[str]:
|
||
references: list[str] = []
|
||
|
||
if await self._table_exists("sys_tenants"):
|
||
child_count = int(
|
||
(
|
||
await session.execute(
|
||
text(
|
||
"""
|
||
SELECT COUNT(*)
|
||
FROM sys_tenants
|
||
WHERE parent_tenant_code = :tenant_code
|
||
AND deleted_at IS NULL
|
||
AND is_enabled = TRUE
|
||
"""
|
||
),
|
||
{"tenant_code": tenant_code},
|
||
)
|
||
).scalar_one()
|
||
)
|
||
if child_count > 0:
|
||
references.append(f"存在 {child_count} 个启用中的子租户")
|
||
|
||
if await self._table_exists("leaudit_entry_module_tenants"):
|
||
entry_module_count = int(
|
||
(
|
||
await session.execute(
|
||
text(
|
||
"""
|
||
SELECT COUNT(DISTINCT emt.entry_module_id)
|
||
FROM leaudit_entry_module_tenants emt
|
||
WHERE emt.tenant_code = :tenant_code
|
||
AND emt.deleted_at IS NULL
|
||
AND COALESCE(emt.is_enabled, TRUE) = TRUE
|
||
"""
|
||
),
|
||
{"tenant_code": tenant_code},
|
||
)
|
||
).scalar_one()
|
||
)
|
||
if entry_module_count > 0:
|
||
references.append(f"仍绑定 {entry_module_count} 个入口模块")
|
||
|
||
if await self._table_exists("sso_users") and await self._column_exists("sso_users", "tenant_code"):
|
||
user_count = int(
|
||
(
|
||
await session.execute(
|
||
text(
|
||
"""
|
||
SELECT COUNT(*)
|
||
FROM sso_users
|
||
WHERE tenant_code = :tenant_code
|
||
AND deleted_at IS NULL
|
||
AND status = 0
|
||
"""
|
||
),
|
||
{"tenant_code": tenant_code},
|
||
)
|
||
).scalar_one()
|
||
)
|
||
if user_count > 0:
|
||
references.append(f"仍有 {user_count} 个启用用户归属该租户")
|
||
|
||
return references
|
||
|
||
async def _replaceTenantAliases(self, session: Any, tenant_code: str, alias_values: list[str]) -> None:
|
||
await session.execute(
|
||
text(
|
||
"""
|
||
DELETE FROM sys_tenant_aliases
|
||
WHERE tenant_code = :tenant_code
|
||
"""
|
||
),
|
||
{"tenant_code": tenant_code},
|
||
)
|
||
for index, alias in enumerate(alias_values):
|
||
alias_type = "DISPLAY" if index == 0 else "SHORT_NAME"
|
||
await session.execute(
|
||
text(
|
||
"""
|
||
INSERT INTO sys_tenant_aliases (
|
||
tenant_code,
|
||
alias_type,
|
||
alias_value,
|
||
is_enabled,
|
||
created_at,
|
||
updated_at,
|
||
deleted_at
|
||
) VALUES (
|
||
:tenant_code,
|
||
:alias_type,
|
||
:alias_value,
|
||
TRUE,
|
||
NOW(),
|
||
NOW(),
|
||
NULL
|
||
)
|
||
"""
|
||
),
|
||
{
|
||
"tenant_code": tenant_code,
|
||
"alias_type": alias_type,
|
||
"alias_value": alias,
|
||
},
|
||
)
|
||
|
||
async def _replaceTenantFeatures(self, session: Any, tenant_code: str, feature_keys: list[str]) -> None:
|
||
await session.execute(
|
||
text(
|
||
"""
|
||
DELETE FROM sys_tenant_feature_flags
|
||
WHERE tenant_code = :tenant_code
|
||
"""
|
||
),
|
||
{"tenant_code": tenant_code},
|
||
)
|
||
for feature_key in feature_keys:
|
||
await session.execute(
|
||
text(
|
||
"""
|
||
INSERT INTO sys_tenant_feature_flags (
|
||
tenant_code,
|
||
feature_key,
|
||
is_enabled,
|
||
created_at,
|
||
updated_at,
|
||
deleted_at
|
||
) VALUES (
|
||
:tenant_code,
|
||
:feature_key,
|
||
TRUE,
|
||
NOW(),
|
||
NOW(),
|
||
NULL
|
||
)
|
||
"""
|
||
),
|
||
{
|
||
"tenant_code": tenant_code,
|
||
"feature_key": feature_key,
|
||
},
|
||
)
|
||
|
||
def _normalizeTenantCode(self, value: str | None) -> str:
|
||
tenant_code = str(value or "").strip()
|
||
if not tenant_code:
|
||
raise LeauditException(StatusCodeEnum.HTTP_400_BAD_REQUEST, "租户编码不能为空")
|
||
if len(tenant_code) > 64:
|
||
raise LeauditException(StatusCodeEnum.HTTP_400_BAD_REQUEST, "租户编码长度不能超过 64")
|
||
return tenant_code
|
||
|
||
def _normalizeOptionalCode(self, value: str | None) -> str | None:
|
||
normalized = self._normalizeOptionalText(value)
|
||
return normalized or None
|
||
|
||
def _normalizeRequiredText(self, value: str | None, field_name: str) -> str:
|
||
normalized = self._normalizeOptionalText(value)
|
||
if not normalized:
|
||
raise LeauditException(StatusCodeEnum.HTTP_400_BAD_REQUEST, f"{field_name}不能为空")
|
||
return normalized
|
||
|
||
@staticmethod
|
||
def _normalizeOptionalText(value: Any) -> str | None:
|
||
if value is None:
|
||
return None
|
||
text_value = str(value).strip()
|
||
return text_value or None
|
||
|
||
def _normalizeTenantType(self, value: str | None) -> str:
|
||
tenant_type = self._normalizeOptionalText(value) or "CUSTOM"
|
||
if len(tenant_type) > 32:
|
||
raise LeauditException(StatusCodeEnum.HTTP_400_BAD_REQUEST, "租户类型长度不能超过 32")
|
||
return tenant_type.upper()
|
||
|
||
def _normalizeFeatureKeys(self, values: list[str] | None) -> list[str]:
|
||
normalized: list[str] = []
|
||
seen: set[str] = set()
|
||
for item in values or []:
|
||
feature_key = self._normalizeOptionalText(item)
|
||
if not feature_key:
|
||
continue
|
||
if feature_key not in self._SUPPORTED_FEATURE_KEYS:
|
||
raise LeauditException(StatusCodeEnum.HTTP_400_BAD_REQUEST, f"不支持的功能标识: {feature_key}")
|
||
if feature_key in seen:
|
||
continue
|
||
seen.add(feature_key)
|
||
normalized.append(feature_key)
|
||
return normalized
|
||
|
||
def _normalizeAliasValues(self, values: list[str] | None, *, tenant_name: str, tenant_short_name: str) -> list[str]:
|
||
normalized: list[str] = []
|
||
seen: set[str] = set()
|
||
seeds = [tenant_name, tenant_short_name, *(values or [])]
|
||
for item in seeds:
|
||
alias = self._normalizeOptionalText(item)
|
||
if not alias or alias in seen:
|
||
continue
|
||
if len(alias) > 100:
|
||
raise LeauditException(StatusCodeEnum.HTTP_400_BAD_REQUEST, f"租户别名过长: {alias}")
|
||
seen.add(alias)
|
||
normalized.append(alias)
|
||
return normalized
|
||
|
||
async def _column_exists(self, table_name: str, column_name: str) -> bool:
|
||
cache_key = f"{table_name}.{column_name}"
|
||
cached = self._table_exists_cache.get(cache_key)
|
||
if cached is not None:
|
||
return cached
|
||
|
||
async with GetAsyncSession() as session:
|
||
exists = bool(
|
||
(
|
||
await session.execute(
|
||
text(
|
||
"""
|
||
SELECT EXISTS (
|
||
SELECT 1
|
||
FROM information_schema.columns
|
||
WHERE table_schema = current_schema()
|
||
AND table_name = :table_name
|
||
AND column_name = :column_name
|
||
)
|
||
"""
|
||
),
|
||
{"table_name": table_name, "column_name": column_name},
|
||
)
|
||
).scalar_one()
|
||
)
|
||
self._table_exists_cache[cache_key] = exists
|
||
return exists
|
||
|
||
@staticmethod
|
||
def _dumpJson(value: dict[str, Any]) -> str:
|
||
import json
|
||
|
||
return json.dumps(value, ensure_ascii=False)
|