import json import random import string import sqlalchemy as sa from redis.asyncio.client import Redis from app.common.enums import RedisInitKeyConfig from app.core.base_schema import AuthSchema, BatchSetAvailable from app.core.dependencies import require_superadmin from app.core.exceptions import CustomException from app.core.logger import logger from app.core.redis_crud import RedisCURD from app.utils.hash_bcrpy_util import PwdUtil from .crud import TenantCRUD from .model import TenantModel, TenantUserModel from .schema import ( PackageChangePreviewOut, TenantConfigOutSchema, TenantCreateSchema, TenantOutSchema, TenantQueryParam, TenantUpdateSchema, TenantUserAddSchema, TenantUserOutSchema, ) class TenantService: """ 租户管理服务（查询操作租户可见，写操作仅超级管理员可操作） 设计：实例方法承载「当前用户上下文 (auth)」，``redis`` 仍是方法参数。 内部跨方法调用从 ``cls.xxx(auth, ...)`` 改为 ``self.xxx(...)``。 定时任务方法与静态工具方法保持 ``@staticmethod``（无 auth）。 """ def __init__(self, auth: AuthSchema) -> None: self.auth = auth async def detail(self, id: int) -> TenantOutSchema: """ 租户详情 参数: - id (int): 租户ID 返回: - TenantOutSchema: 租户详情 """ return await TenantCRUD(self.auth).get_or_404(id=id, out_schema=TenantOutSchema) async def page( self, page_no: int, page_size: int, search: TenantQueryParam | None = None, order_by: list[dict[str, str]] | None = None, ) -> dict: return await TenantCRUD(self.auth).page( offset=(page_no - 1) * page_size, limit=page_size, order_by=order_by or [{"id": "asc"}], search=vars(search) if search else None, out_schema=TenantOutSchema, ) @require_superadmin async def create(self, data: TenantCreateSchema) -> TenantOutSchema: if await TenantCRUD(self.auth).get(name=data.name): raise CustomException(msg="创建失败，名称已存在") if await TenantCRUD(self.auth).get(code=data.code): raise CustomException(msg="创建失败，编码已存在") tenant_obj = await TenantCRUD(self.auth).create(data=data) if not tenant_obj: raise CustomException(msg="创建租户失败") # 创建租户初始管理员 # 1. 生成初始管理员用户名 # 2. 检查用户名是否已存在 # 3. 创建初始管理员用户 username = f"{tenant_obj.code}_admin" from app.api.v1.module_system.user.crud import UserCRUD if await UserCRUD(self.auth).get(username=username): raise CustomException(msg=f"初始管理员用户名已存在: {username}，请更换租户编码后重试") password_length = 12 characters = string.ascii_letters + string.digits + "!@#$%^&*" password = "".join(random.choice(characters) for _ in range(password_length)) admin_data = { "username": username, "password": PwdUtil.hash_password(password=password), "name": f"{tenant_obj.name}管理员", "tenant_id": tenant_obj.id, "status": 0, "is_superuser": False, } try: user_obj = await UserCRUD(self.auth).create(data=admin_data) if not user_obj: raise CustomException(msg="创建租户初始管理员失败") except CustomException: raise except Exception as e: logger.error(f"为租户[{tenant_obj.name}]创建初始管理员失败: {e!s}") raise CustomException(msg="创建租户初始管理员失败") from e logger.info(f"为租户[{tenant_obj.name}]创建初始管理员成功，用户名: {username}，临时密码: {password}") await self.auth.db.refresh(tenant_obj) result = TenantOutSchema.model_validate(tenant_obj) return result @require_superadmin async def update(self, id: int, data: TenantUpdateSchema) -> TenantOutSchema: """ 更新租户 参数: - id (int): 租户ID - data (TenantUpdateSchema): 租户更新模型 返回: - TenantOutSchema: 租户详情 """ obj = await TenantCRUD(self.auth).get_or_404(id=id) old_package_id = obj.package_id if id == 1: if data.code is not None and data.code != obj.code: raise CustomException(msg="系统租户编码不可修改") if data.status is not None and data.status == 1: raise CustomException(msg="系统租户不允许禁用") # 套餐变更：仅超管可操作，防止租户管理员自行升级/降级套餐 if data.package_id is not None and data.package_id != old_package_id: if not self.auth.user or not self.auth.user.is_superuser: raise CustomException(msg="仅平台管理员可变更租户套餐") if data.name is not None: exist = await TenantCRUD(self.auth).get(name=data.name) if exist and exist.id != id: raise CustomException(msg="更新失败，名称重复") if data.code is not None: exist = await TenantCRUD(self.auth).get(code=data.code) if exist and exist.id != id: raise CustomException(msg="更新失败，编码重复") updated = await TenantCRUD(self.auth).update(id=id, data=data) if not updated: raise CustomException(msg="更新失败") # 套餐变更后：清理角色中不再可用的菜单关联，防止用户看到空白菜单 if data.package_id is not None and data.package_id != old_package_id: from sqlalchemy import delete as sa_delete from sqlalchemy import select from app.api.v1.module_platform.package.service import PackageService from app.api.v1.module_system.role.model import RoleMenusModel, RoleModel available_ids = await PackageService(self.auth).get_tenant_available_menu_ids(id) if available_ids: role_ids_stmt = select(RoleModel.id).where(RoleModel.tenant_id == id) result = await self.auth.db.execute(role_ids_stmt) tenant_role_ids = [row[0] for row in result.all()] if tenant_role_ids: await self.auth.db.execute( sa_delete(RoleMenusModel).where( RoleMenusModel.role_id.in_(tenant_role_ids), RoleMenusModel.menu_id.notin_(available_ids), ) ) await self.auth.db.flush() logger.info( f"租户[{id}]套餐变更：已清理角色中不再可用的菜单关联, " f"available_menus={len(available_ids)}, roles_affected={len(tenant_role_ids)}" ) result = TenantOutSchema.model_validate(updated) return result @require_superadmin async def delete(self, ids: list[int]) -> None: """ 批量删除租户（含级联资源检查：用户/部门/角色/岗位） 参数: - ids (list[int]): 租户ID列表 返回: - None """ if not ids: raise CustomException(msg="删除失败，删除对象不能为空") if 1 in ids: raise CustomException(msg="系统租户不允许删除") from app.api.v1.module_system.dept.crud import DeptCRUD from app.api.v1.module_system.position.crud import PositionCRUD from app.api.v1.module_system.role.crud import RoleCRUD from app.api.v1.module_system.user.crud import UserCRUD for tid in ids: reasons: list[str] = [] if await UserCRUD(self.auth).get_list(search={"tenant_id": tid}): reasons.append("用户") if await DeptCRUD(self.auth).get_list(search={"tenant_id": tid}): reasons.append("部门") if await RoleCRUD(self.auth).get_list(search={"tenant_id": tid}): reasons.append("角色") if await PositionCRUD(self.auth).get_list(search={"tenant_id": tid}): reasons.append("岗位") if reasons: raise CustomException(msg=f"租户下已存在{'/'.join(reasons)}，操作失败") await TenantCRUD(self.auth).delete(ids=ids) async def set_available(self, data: BatchSetAvailable) -> None: """ 批量设置租户状态 参数: - data (BatchSetAvailable): 批量状态设置 返回: - None """ if data.status == 1 and 1 in data.ids: raise CustomException(msg="系统租户不允许禁用") await TenantCRUD(self.auth).set(ids=data.ids, status=data.status) async def toggle_status(self, id: int) -> None: """ 切换单个租户的启用/禁用状态 参数: - id (int): 租户ID 返回: - None """ obj = await TenantCRUD(self.auth).get_or_404(id=id) if id == 1: raise CustomException(msg="系统租户不允许禁用") new_status = 0 if obj.status == 1 else 1 await TenantCRUD(self.auth).set(ids=[id], status=new_status) async def get_tenant_users(self, tenant_id: int) -> list[TenantUserOutSchema]: """获取租户下的用户列表""" from sqlalchemy import select from app.api.v1.module_system.user.model import UserModel stmt = ( select(TenantUserModel, UserModel) .join(UserModel, UserModel.id == TenantUserModel.user_id) .where(TenantUserModel.tenant_id == tenant_id) .order_by(TenantUserModel.is_default.desc(), TenantUserModel.id) ) result = await self.auth.db.execute(stmt) rows = result.all() users = [] for tu, u in rows: users.append( TenantUserOutSchema( id=tu.id, user_id=tu.user_id, tenant_id=tu.tenant_id, role=tu.role, is_default=tu.is_default, create_time=tu.create_time, username=u.username, name=u.name, ) ) return users async def add_tenant_user(self, tenant_id: int, data: TenantUserAddSchema) -> None: """ 向租户添加用户 参数: - tenant_id (int): 租户ID - data (TenantUserAddSchema): 用户添加参数 返回: - None """ # 验证租户存在 tenant = await TenantCRUD(self.auth).get(id=tenant_id) if not tenant: raise CustomException(msg="该数据不存在") # 验证用户存在 from app.api.v1.module_system.user.crud import UserCRUD user = await UserCRUD(self.auth).get(id=data.user_id) if not user: raise CustomException(msg="该数据不存在") # 检查是否已关联 from sqlalchemy import select exist_stmt = ( select(TenantUserModel) .where( TenantUserModel.user_id == data.user_id, TenantUserModel.tenant_id == tenant_id, ) .limit(1) ) result = await self.auth.db.execute(exist_stmt) if result.scalar_one_or_none(): raise CustomException(msg="该用户已关联此租户") # 如果设为默认租户，先取消其他默认 if data.is_default == 1: await self.auth.db.execute( sa.update(TenantUserModel).where(TenantUserModel.user_id == data.user_id).values(is_default=0) ) elif data.is_default == 0: # 检查是否是该用户的第一个租户关联 count_result = await self.auth.db.execute( select(sa.func.count()).select_from(TenantUserModel).where(TenantUserModel.user_id == data.user_id) ) count = count_result.scalar() if count == 0: # 第一个租户自动设为默认 data.is_default = 1 from datetime import datetime tu = TenantUserModel( user_id=data.user_id, tenant_id=tenant_id, role=data.role, is_default=data.is_default, create_time=datetime.now(), ) self.auth.db.add(tu) await self.auth.db.flush() logger.info(f"向租户[{tenant.name}]添加用户[{user.username}]成功, role={data.role}") async def remove_tenant_user(self, tenant_id: int, user_id: int) -> None: """ 从租户移除用户 参数: - tenant_id (int): 租户ID - user_id (int): 用户ID 返回: - None """ from sqlalchemy import select # 查找关联记录 exist_stmt = ( select(TenantUserModel) .where( TenantUserModel.user_id == user_id, TenantUserModel.tenant_id == tenant_id, ) .limit(1) ) result = await self.auth.db.execute(exist_stmt) tu = result.scalar_one_or_none() if not tu: raise CustomException(msg="该用户未关联此租户") # 不允许移除租户最后一个 owner if tu.role == "owner": count_result = await self.auth.db.execute( select(sa.func.count()) .select_from(TenantUserModel) .where( TenantUserModel.tenant_id == tenant_id, TenantUserModel.role == "owner", ) ) owner_count = count_result.scalar() if owner_count <= 1: raise CustomException(msg="租户至少需要保留一个拥有者(owner)") await self.auth.db.delete(tu) await self.auth.db.flush() logger.info(f"从租户[{tenant_id}]移除用户[{user_id}]成功") async def get_quota(self, tenant_id: int) -> dict: """ 获取租户配额（从关联套餐读取，系统租户返回无限配额） 参数: - tenant_id (int): 租户ID 返回: - dict: 配额信息 """ if tenant_id == 1: return { "tenant_id": 1, "max_users": 999999, "max_roles": 999999, "max_storage_mb": 999999, "max_depts": 999999, "package_name": "系统租户(无限)", } tenant = await TenantCRUD(self.auth).get(id=tenant_id) if not tenant: raise CustomException(msg="该数据不存在") if not tenant.package_id: return { "tenant_id": tenant.id, "max_users": 0, "max_roles": 0, "max_storage_mb": 0, "max_depts": 0, "package_name": "未绑定套餐", } from app.api.v1.module_platform.package.crud import PackageCRUD pkg = await PackageCRUD(self.auth).get(id=tenant.package_id) if not pkg: return { "tenant_id": tenant.id, "max_users": 0, "max_roles": 0, "max_storage_mb": 0, "max_depts": 0, "package_name": "套餐已删除", } return { "tenant_id": tenant.id, "max_users": pkg.max_users, "max_roles": pkg.max_roles, "max_storage_mb": getattr(pkg, "max_storage_mb", 0), "max_depts": pkg.max_depts, "package_name": pkg.name, } async def check_quota(self, tenant_id: int, resource_type: str) -> None: """检查租户配额是否充足，不足时抛出异常（系统租户跳过检查）""" if tenant_id == 1: return from sqlalchemy import func, select tenant = await TenantCRUD(self.auth).get(id=tenant_id) if not tenant or not tenant.package_id: return from app.api.v1.module_platform.package.crud import PackageCRUD pkg = await PackageCRUD(self.auth).get(id=tenant.package_id) if not pkg: return field_map = { "user": "max_users", "role": "max_roles", "dept": "max_depts", "storage": "max_storage_mb", } if resource_type not in field_map: return max_field = field_map[resource_type] max_limit = getattr(pkg, max_field, None) if max_limit is None or max_limit == 0: return if resource_type == "user": from app.api.v1.module_system.user.model import UserModel count_stmt = ( select(func.count()) .select_from(UserModel) .where( UserModel.tenant_id == tenant_id, UserModel.is_deleted.is_(False), ) ) elif resource_type == "role": from app.api.v1.module_system.role.model import RoleModel count_stmt = ( select(func.count()) .select_from(RoleModel) .where( RoleModel.tenant_id == tenant_id, RoleModel.is_deleted.is_(False), ) ) elif resource_type == "dept": from app.api.v1.module_system.dept.model import DeptModel count_stmt = ( select(func.count()) .select_from(DeptModel) .where( DeptModel.tenant_id == tenant_id, DeptModel.is_deleted.is_(False), ) ) elif resource_type == "storage": # storage 的实际容量校验在文件上传时进行，此处仅检查是否有配额 return result = await self.auth.db.execute(count_stmt) current_count = result.scalar() or 0 if current_count >= max_limit: resource_labels = {"user": "用户", "role": "角色", "dept": "部门"} raise CustomException( msg=f"租户{resource_labels.get(resource_type, resource_type)}数量已达套餐上限（{max_limit}），无法继续创建" ) async def get_config(self, tenant_id: int) -> dict: """ 获取租户所有配置（从租户主表读取，返回原始 dict 供内部使用） 参数: - tenant_id (int): 租户ID 返回: - dict: 配置字典 """ tenant = await TenantCRUD(self.auth).get(id=tenant_id) if not tenant: raise CustomException(msg="该数据不存在") config_fields = [ "name", "description", "version", "logo_url", "favicon", "login_bg", "copyright", "keep_record", "help_doc", "privacy", "clause", "git_code", ] config = {field: getattr(tenant, field, None) for field in config_fields} return config async def get_config_items(self, tenant_id: int) -> list[TenantConfigOutSchema]: """获取租户所有配置（对外接口，返回结构化列表）""" config = await self.get_config(tenant_id) return [TenantConfigOutSchema(config_key=k, config_value=str(v) if v is not None else None) for k, v in config.items()] @staticmethod async def get_config_cache(redis: Redis, tenant_id: int) -> dict: """ 从 Redis 缓存获取租户配置，缓存未命中则从 DB 加载并回写缓存 参数: - redis (Redis): Redis 客户端实例 - tenant_id (int): 租户ID 返回: - dict: 租户配置字典 """ redis_key = f"{RedisInitKeyConfig.TENANT_CONFIG.key}:{tenant_id}" redis_config = await RedisCURD(redis).get(key=redis_key) if redis_config: try: return json.loads(redis_config) except Exception as e: logger.error(f"解析租户配置数据失败: {e}") logger.info(f"Redis 中没有租户[{tenant_id}]配置数据，从数据库中加载") from app.core.database import async_db_session async with async_db_session() as session: async with session.begin(): from app.core.base_schema import AuthSchema as _AuthSchema _auth = _AuthSchema(db=session, check_data_scope=False) svc = TenantService(_auth) config = await svc.get_config(tenant_id) await TenantService._sync_configs_to_redis(redis, tenant_id, config) logger.info("✅ 已从数据库加载租户配置到缓存") return config @staticmethod async def get_config_cache_items(redis: Redis, tenant_id: int) -> list[TenantConfigOutSchema]: """获取租户缓存配置（对外接口，返回结构化列表）""" config = await TenantService.get_config_cache(redis, tenant_id) return [TenantConfigOutSchema(config_key=k, config_value=str(v) if v is not None else None) for k, v in config.items()] @staticmethod async def _sync_configs_to_redis(redis: Redis, tenant_id: int, config: dict) -> None: """将租户配置写入 Redis 缓存""" redis_key = f"{RedisInitKeyConfig.TENANT_CONFIG.key}:{tenant_id}" value = json.dumps(config, ensure_ascii=False) await RedisCURD(redis).set(key=redis_key, value=value, expire=None) @staticmethod async def _del_configs_from_redis(redis: Redis, tenant_id: int) -> None: """删除租户配置的 Redis 缓存""" redis_key = f"{RedisInitKeyConfig.TENANT_CONFIG.key}:{tenant_id}" await RedisCURD(redis).delete(redis_key) async def update_config(self, redis: Redis, tenant_id: int, config: dict) -> list[TenantConfigOutSchema]: """ 更新租户配置（同步 Redis 缓存） 参数: - redis (Redis): Redis 客户端 - tenant_id (int): 租户ID - config (dict): 配置字典 返回: - list[TenantConfigOutSchema]: 更新后的配置项列表 """ tenant = await TenantCRUD(self.auth).get(id=tenant_id) if not tenant: raise CustomException(msg="该数据不存在") config_fields = [ "name", "description", "version", "logo_url", "favicon", "login_bg", "copyright", "keep_record", "help_doc", "privacy", "clause", "git_code", ] for field in config_fields: if field in config: setattr(tenant, field, config[field]) await self.auth.db.flush() # 刷新 DB 数据并同步到 Redis new_config = await self.get_config(tenant_id) await TenantService._sync_configs_to_redis(redis, tenant_id, new_config) logger.info(f"租户[{tenant_id}]配置已更新") return [TenantConfigOutSchema(config_key=k, config_value=str(v) if v is not None else None) for k, v in new_config.items()] @staticmethod async def init_cache(redis: Redis) -> None: """ 初始化所有租户配置到 Redis 缓存（应用启动时调用）。 参数: - redis (Redis): Redis 客户端实例 返回: - None """ from sqlalchemy import select from app.core.database import async_db_session async with async_db_session() as session: async with session.begin(): stmt = select(TenantModel) result = await session.execute(stmt) tenants = result.scalars().all() for tenant in tenants: config_fields = [ "name", "description", "version", "logo_url", "favicon", "login_bg", "copyright", "keep_record", "help_doc", "privacy", "clause", "git_code", ] config = {field: getattr(tenant, field, None) for field in config_fields} await TenantService._sync_configs_to_redis(redis, tenant.id, config) logger.info(f"✅ 租户[{tenant.name}](id={tenant.id}) 配置已缓存到 Redis") async def renew(self, tenant_id: int, end_time: str) -> TenantOutSchema: """租户续期：延长 end_time 并恢复为 active 状态 仅 active(0)/grace(1)/suspended(2) 状态可续期。 expired(4)/frozen(3)/archived(5) 不可续期。 参数: - tenant_id (int): 租户ID - end_time (str): 新的结束时间 返回: - dict: 更新后的租户信息 """ from datetime import datetime tenant = await TenantCRUD(self.auth).get(id=tenant_id) if not tenant: raise CustomException(msg="该数据不存在") if tenant.status not in (0, 1, 2): status_labels = {0: "正常", 1: "宽限期", 2: "暂停", 3: "冻结", 4: "过期", 5: "归档"} current_label = status_labels.get(str(tenant.status), str(tenant.status)) raise CustomException(msg=f"当前租户状态为「{current_label}」，仅正常/宽限期/暂停状态可续期") new_end = datetime.fromisoformat(end_time) if isinstance(end_time, str) else end_time if new_end <= datetime.now(): raise CustomException(msg="续期结束时间必须晚于当前时间") tenant.end_time = new_end tenant.status = 0 tenant.grace_start_time = None await self.auth.db.flush() logger.info(f"租户[{tenant.name}]续期成功, 新的结束时间: {end_time}") return TenantOutSchema.model_validate(tenant) async def package_change_preview(self, tenant_id: int, new_package_id: int) -> PackageChangePreviewOut: """ 套餐变更影响预览 返回受影响角色、菜单清单、配额对比等，供超管确认后再执行变更。 参数: - tenant_id (int): 租户ID - new_package_id (int): 目标套餐ID 返回: - PackageChangePreviewOut: 预览结果 """ from sqlalchemy import func, select from app.api.v1.module_platform.menu.model import MenuModel from app.api.v1.module_platform.package.crud import PackageCRUD from app.api.v1.module_platform.package.service import PackageService from app.api.v1.module_system.role.model import RoleMenusModel, RoleModel from app.api.v1.module_system.user.model import UserModel tenant = await TenantCRUD(self.auth).get(id=tenant_id) if not tenant: raise CustomException(msg="该数据不存在") new_package = await PackageCRUD(self.auth).get(id=new_package_id) if not new_package: raise CustomException(msg="该数据不存在") # 当前可用菜单 current_menu_ids = await PackageService(self.auth).get_tenant_available_menu_ids(tenant_id) # 新套餐可用菜单（直接取套餐菜单，不再包含自定义授权） new_menu_ids = set(await PackageService(self.auth).get_package_menu_ids(new_package_id)) final_menu_ids = new_menu_ids # 不再合并租户自定义菜单 # 差异计算 removed_ids = current_menu_ids - final_menu_ids added_ids = final_menu_ids - current_menu_ids removed_menus = [] added_menus = [] if removed_ids: menu_stmt = select(MenuModel).where(MenuModel.id.in_(removed_ids)) menu_result = await self.auth.db.execute(menu_stmt) removed_menus = [{"id": m.id, "name": m.name, "route_path": m.route_path} for m in menu_result.scalars().all()] if added_ids: menu_stmt = select(MenuModel).where(MenuModel.id.in_(added_ids)) menu_result = await self.auth.db.execute(menu_stmt) added_menus = [{"id": m.id, "name": m.name, "route_path": m.route_path} for m in menu_result.scalars().all()] # 受影响角色 role_stmt = select(RoleModel).where(RoleModel.tenant_id == tenant_id) role_result = await self.auth.db.execute(role_stmt) roles = role_result.scalars().all() affected_roles = [] total_affected_users = 0 for role in roles: # 查该角色下有多少菜单会被移除 role_menu_stmt = select(RoleMenusModel.menu_id).where(RoleMenusModel.role_id == role.id) rm_result = await self.auth.db.execute(role_menu_stmt) role_menu_ids = {row[0] for row in rm_result.all()} affected_menu_count = len(role_menu_ids & removed_ids) # 查该角色下用户数 user_count_stmt = select(func.count()).select_from(UserModel).join(UserModel.roles).where(RoleModel.id == role.id) uc_result = await self.auth.db.execute(user_count_stmt) user_count = uc_result.scalar() or 0 affected_roles.append( { "id": role.id, "name": role.name, "code": role.code, "affected_menu_count": affected_menu_count, "user_count": user_count, } ) total_affected_users += user_count # 配额对比（从套餐读取） old_pkg = None if tenant.package_id: old_pkg = await PackageCRUD(self.auth).get(id=tenant.package_id) quota_changes = { "max_users": { "current": old_pkg.max_users if old_pkg else 0, "new": new_package.max_users, }, "max_roles": { "current": old_pkg.max_roles if old_pkg else 0, "new": new_package.max_roles, }, "max_depts": { "current": old_pkg.max_depts if old_pkg else 0, "new": new_package.max_depts, }, } return PackageChangePreviewOut( new_package_id=new_package.id, new_package_name=new_package.name, affected_roles=affected_roles, removed_menus=removed_menus, added_menus=added_menus, quota_changes=quota_changes, total_affected_users=total_affected_users, ) @staticmethod async def check_tenant_expiry() -> None: """定时任务：多阶段租户到期自动处理 PRD §9 到期阶段： grace(1) → 到期后第 1-7 天，仅提醒 suspended(2) → 到期后第 8-14 天，禁用登录 frozen(3) → 到期后第 15-30 天，只读模式 expired(4) → 第 31 天起，归档候选 """ from datetime import datetime from sqlalchemy import text from app.core.database import async_db_session now = datetime.now() async with async_db_session() as session: # 获取所有已过期的活跃租户（status=0） rows = await session.execute( text( "SELECT id, name, contact_email, contact_name, end_time, status " "FROM platform_tenant WHERE status = '0' AND end_time IS NOT NULL AND end_time < :now" ), {"now": now}, ) expired_tenants = rows.fetchall() for t in expired_tenants: tenant_id, tenant_name, email, contact_name, end_time, cur_status = t days_past = (now - end_time).days if end_time else 0 if days_past <= 7: new_status, label = 1, "宽限期" elif days_past <= 14: new_status, label = 2, "已停用" elif days_past <= 30: new_status, label = 3, "已冻结" else: new_status, label = 4, "已过期" if new_status == cur_status: continue await session.execute( text("UPDATE platform_tenant SET status = :s WHERE id = :tid"), {"s": new_status, "tid": tenant_id}, ) logger.info(f"租户状态切换: id={tenant_id} name={tenant_name} status={cur_status}→{new_status} ({label})") # 发送通知邮件 if email: await TenantService._send_expiry_email( tenant_name, contact_name, email, end_time, days_past, label ) await session.commit() logger.info(f"到期检查完成，处理了 {len(expired_tenants)} 个过期租户") @staticmethod async def send_grace_reminders() -> None: """定时任务：向宽限期租户发送续费提醒邮件（每天 09:00）""" from datetime import datetime from sqlalchemy import text from app.core.database import async_db_session async with async_db_session() as session: rows = await session.execute( text( "SELECT id, name, contact_email, contact_name, end_time FROM platform_tenant " "WHERE status = '1' AND contact_email IS NOT NULL AND contact_email != ''" ) ) grace_tenants = rows.fetchall() sent = 0 for t in grace_tenants: tenant_id, name, email, contact_name, end_time = t days_past = (datetime.now() - end_time).days if end_time else 0 try: ok = await TenantService._send_renew_email(name, contact_name, email, days_past) if ok: sent += 1 except Exception as e: logger.warning(f"续费提醒邮件发送失败: tenant_id={tenant_id}, err={e}") logger.info(f"续费提醒完成，共发送 {sent}/{len(grace_tenants)} 封邮件") @staticmethod async def clean_expired_tenants() -> None: """定时任务：将过期超 90 天租户归档，清理旧审计日志（每月 1 号 02:00）""" from datetime import datetime, timedelta from sqlalchemy import text from app.core.database import async_db_session cutoff = datetime.now() - timedelta(days=90) async with async_db_session() as session: # 归档过期租户 result = await session.execute( text("SELECT COUNT(*) FROM platform_tenant WHERE status = '4' AND end_time < :cutoff"), {"cutoff": cutoff}, ) count = result.scalar() or 0 if count > 0: await session.execute( text("UPDATE platform_tenant SET status = '5' WHERE status = '4' AND end_time < :cutoff"), {"cutoff": cutoff}, ) await session.commit() logger.info(f"已将 {count} 个过期超过 90 天的租户标记为归档") await session.commit() @staticmethod async def _send_expiry_email( tenant_name: str, contact_name: str | None, email: str, end_time: object, days_past: int, label: str, ) -> None: """发送租户状态变更通知邮件""" from app.config.setting import settings from app.utils.email_util import render_template, send_email if not settings.SMTP_HOST: return smtp_config = { "host": settings.SMTP_HOST, "port": settings.SMTP_PORT, "username": settings.SMTP_USER, "password": settings.SMTP_PASSWORD, "from_addr": settings.SMTP_FROM, "starttls": settings.SMTP_TLS, "ssl_tls": settings.SMTP_SSL, } end_str = end_time.strftime("%Y-%m-%d") if hasattr(end_time, "strftime") else str(end_time) try: html_body = await render_template( "email/tenant_expiry_notice.html", tenant_name=tenant_name, contact_name=contact_name or "管理员", days_expired=days_past, status_name=label, end_time=end_str, site_url=getattr(settings, "SITE_URL", ""), ) await send_email( smtp_config=smtp_config, recipients=[email], subject=f"【重要】租户 {tenant_name} 服务状态变更通知", body=html_body, html=True, ) except Exception as e: logger.warning(f"到期通知邮件发送失败: tenant={tenant_name}, err={e}") @staticmethod async def _send_renew_email(name: str, contact_name: str | None, email: str, days_past: int) -> bool: """发送续费提醒邮件""" from app.config.setting import settings from app.utils.email_util import render_template, send_email if not settings.SMTP_HOST: return False smtp_config = { "host": settings.SMTP_HOST, "port": settings.SMTP_PORT, "username": settings.SMTP_USER, "password": settings.SMTP_PASSWORD, "from_addr": settings.SMTP_FROM, "starttls": settings.SMTP_TLS, "ssl_tls": settings.SMTP_SSL, } html_body = await render_template( "email/tenant_renew_reminder.html", tenant_name=name, contact_name=contact_name or "管理员", days_expired=days_past, renew_url=f"{getattr(settings, 'SITE_URL', '')}/tenant/order/create", ) return await send_email( smtp_config=smtp_config, recipients=[email], subject=f"【续费提醒】租户 {name} 服务即将到期", body=html_body, html=True, )