import json from typing import Any from redis.asyncio.client import Redis from sqlalchemy import update as sa_update from sqlalchemy.ext.asyncio import AsyncSession from app.api.v1.module_system.dict.model import DictDataModel from app.common.enums import RedisInitKeyConfig from app.core.base_schema import AuthSchema, BatchSetAvailable, PageResultSchema from app.core.database import async_db_session from app.core.exceptions import CustomException from app.core.logger import logger from app.core.redis_crud import RedisCURD from app.utils.common_util import search_to_dict from app.utils.excel_util import ExcelUtil from .crud import DictDataCRUD, DictTypeCRUD from .schema import ( DictDataCreateSchema, DictDataOutSchema, DictDataQueryParam, DictDataUpdateSchema, DictTypeCreateSchema, DictTypeOutSchema, DictTypeQueryParam, DictTypeUpdateSchema, ) class DictTypeService: """字典类型管理服务 设计：实例方法承载「当前用户上下文 (auth)」，``redis`` 仍是方法参数 （因为不是每个端点都用到）。调用方写法由 ``XxxService.method_service(auth=...)`` 改为 ``XxxService(auth).method(...)``。 """ def __init__(self, auth: AuthSchema, db: AsyncSession) -> None: self.auth = auth self.db = db async def detail(self, id: int) -> DictTypeOutSchema: """获取数据字典类型详情 参数: - id (int): 数据字典类型ID 返回: - DictTypeOutSchema: 字典类型响应模型 """ obj = await DictTypeCRUD(self.auth, self.db).get_or_404(id=id) return DictTypeOutSchema.model_validate(obj) async def get_list( self, search: DictTypeQueryParam | None = None, order_by: list[dict] | None = None, ) -> list[DictTypeOutSchema]: """获取数据字典类型列表 参数: - search (DictTypeQueryParam | None): 搜索条件模型 - order_by (list[dict] | None): 排序字段列表 返回: - list[DictTypeOutSchema]: 字典类型响应模型列表 """ obj_list = await DictTypeCRUD(self.auth, self.db).get_list(search=search_to_dict(search), order_by=order_by) return [DictTypeOutSchema.model_validate(obj) for obj in obj_list] @staticmethod def export_list(dict_type_list: list[dict[str, Any]]) -> bytes: """导出字典类型列表为 Excel。""" if not dict_type_list: raise CustomException(msg="没有数据可导出") mapping_dict = { "id": "字典类型ID", "dict_name": "字典名称", "dict_type": "字典类型编码", "status": "状态", "description": "描述", "created_time": "创建时间", "updated_time": "更新时间", } data = dict_type_list.copy() for item in data: item["status"] = "正常" if item.get("status") == 0 else "停用" return ExcelUtil.export_list2excel(list_data=data, mapping_dict=mapping_dict) async def page( self, page_no: int, page_size: int, search: DictTypeQueryParam | None = None, order_by: list[dict] | None = None, ) -> PageResultSchema[DictTypeOutSchema]: """分页查询字典类型（数据库 OFFSET/LIMIT）。 参数: - page_no (int): 页码（从 1 开始） - page_size (int): 每页条数 - search (DictTypeQueryParam | None): 查询条件 - order_by (list[dict] | None): 排序字段列表 返回: - PageResultSchema[DictTypeOutSchema]: 分页结果 """ offset = (page_no - 1) * page_size return await DictTypeCRUD(self.auth, self.db).page( offset=offset, limit=page_size, order_by=order_by or [{"id": "asc"}], search=search_to_dict(search), out_schema=DictTypeOutSchema, ) async def create(self, redis: Redis, data: DictTypeCreateSchema) -> DictTypeOutSchema: """创建数据字典类型 参数: - redis (Redis): Redis客户端 - data (DictTypeCreateSchema): 数据字典类型创建模型 返回: - DictTypeOutSchema: 字典类型响应模型 """ exist_obj = await DictTypeCRUD(self.auth, self.db).get(dict_name=data.dict_name) if exist_obj: raise CustomException(msg="创建失败，该数据已存在") obj = await DictTypeCRUD(self.auth, self.db).create(data=data) new_obj_dict = DictTypeOutSchema.model_validate(obj) redis_key = f"{RedisInitKeyConfig.SYSTEM_DICT.key}:1:{data.dict_type}" try: await RedisCURD(redis).set( key=redis_key, value="[]", expire=None, ) logger.info(f"创建字典类型成功: {new_obj_dict}") except Exception as e: logger.error(f"创建字典类型失败: {e}") raise CustomException(msg="同步字典类型缓存失败") from e return new_obj_dict async def update( self, redis: Redis, id: int, data: DictTypeUpdateSchema, ) -> DictTypeOutSchema: """更新数据字典类型 参数: - redis (Redis): Redis客户端 - id (int): 数据字典类型ID - data (DictTypeUpdateSchema): 数据字典类型更新模型 返回: - DictTypeOutSchema: 字典类型响应模型 """ exist_obj = await DictTypeCRUD(self.auth, self.db).get_or_404(id=id, msg="更新失败，该数据不存在") if exist_obj.dict_name != data.dict_name: raise CustomException(msg="更新失败，数据字典类型名称不可以修改") # 如果字典类型修改或状态变更，则修改对应字典数据的类型和状态 if exist_obj.dict_type != data.dict_type or exist_obj.status != data.status: # 批量更新所有关联字典数据 update_data: dict[str, Any] = {"status": data.status} if exist_obj.dict_type != data.dict_type: update_data["dict_type"] = data.dict_type stmt = ( sa_update(DictDataModel) .where(DictDataModel.dict_type == exist_obj.dict_type) .values(**update_data) ) await self.db.execute(stmt) await self.db.flush() obj = await DictTypeCRUD(self.auth, self.db).update(id=id, data=data) new_obj_dict = DictTypeOutSchema.model_validate(obj) redis_key = f"{RedisInitKeyConfig.SYSTEM_DICT.key}:1:{data.dict_type}" try: # 获取当前字典类型的所有字典数据，确保包含最新状态 dict_data_list = await DictDataCRUD(self.auth, self.db).get_list(search={"dict_type": data.dict_type}) dict_data = [DictDataOutSchema.model_validate(row).model_dump(mode="json") for row in dict_data_list if row] value = json.dumps(dict_data, ensure_ascii=False) await RedisCURD(redis).set( key=redis_key, value=value, expire=None, ) logger.info(f"更新字典类型成功并刷新缓存: {new_obj_dict}") except Exception as e: logger.error(f"更新字典类型缓存失败: {e}") raise CustomException(msg="同步字典类型缓存失败") from e return new_obj_dict async def delete(self, redis: Redis, ids: list[int]) -> None: """删除数据字典类型 参数: - redis (Redis): Redis客户端 - ids (list[int]): 数据字典类型ID列表 返回: - None """ if not ids: raise CustomException(msg="删除失败，删除对象不能为空") existing = await DictTypeCRUD(self.auth, self.db).get_list(search={"id": ("in", ids)}) existing_map = {obj.id: obj for obj in existing} # 收集所有 dict_type 去重后批量查询是否有字典数据 dict_types = {obj.dict_type for obj in existing if obj.id in ids} dict_type_has_data: set[str] = set() for dt in dict_types: if await DictDataCRUD(self.auth, self.db).get_list(search={"dict_type": dt}): dict_type_has_data.add(dt) for nid in ids: if nid not in existing_map: raise CustomException(msg="删除失败，该数据不存在") exist_obj = existing_map[nid] if exist_obj.dict_type in dict_type_has_data: raise CustomException(msg="删除失败，该数据字典类型下存在字典数据") # 验证通过后统一删除 Redis 缓存 existing_dict_types = {obj.dict_type for obj in existing if obj.id in ids} for dt in existing_dict_types: redis_key = f"{RedisInitKeyConfig.SYSTEM_DICT.key}:1:{dt}" try: await RedisCURD(redis).delete(redis_key) logger.info(f"删除字典类型缓存: {dt}") except Exception as e: logger.error(f"删除字典类型缓存失败: {e}") raise CustomException(msg="同步删除字典缓存失败") from e await DictTypeCRUD(self.auth, self.db).delete(ids=ids) async def set_available(self, data: BatchSetAvailable) -> None: """设置数据字典类型状态 参数: - data (BatchSetAvailable): 批量设置状态模型 返回: - None """ await DictTypeCRUD(self.auth, self.db).set(ids=data.ids, status=data.status) class DictDataService: """字典数据管理服务 设计同 DictTypeService：实例方法 + ``__init__(auth)``。 """ def __init__(self, auth: AuthSchema, db: AsyncSession) -> None: self.auth = auth self.db = db async def detail(self, id: int) -> DictDataOutSchema: """获取数据字典数据详情 参数: - id (int): 数据字典数据ID 返回: - DictDataOutSchema: 字典数据响应模型 """ obj = await DictDataCRUD(self.auth, self.db).get_or_404(id=id) return DictDataOutSchema.model_validate(obj) async def get_list( self, search: DictDataQueryParam | None = None, order_by: list[dict] | None = None, ) -> list[DictDataOutSchema]: """获取数据字典数据列表 参数: - search (DictDataQueryParam | None): 搜索条件模型 - order_by (list[dict] | None): 排序字段列表 返回: - list[DictDataOutSchema]: 字典数据响应模型列表 """ obj_list = await DictDataCRUD(self.auth, self.db).get_list(search=search_to_dict(search), order_by=order_by) return [DictDataOutSchema.model_validate(obj) for obj in obj_list] @staticmethod def export_list(dict_data_list: list[dict[str, Any]]) -> bytes: """导出字典数据列表为 Excel。""" if not dict_data_list: raise CustomException(msg="没有数据可导出") mapping_dict = { "id": "字典数据ID", "dict_type": "字典类型编码", "dict_sort": "排序", "dict_label": "字典标签", "dict_value": "字典键值", "is_default": "是否默认", "status": "状态", "description": "描述", "created_time": "创建时间", "updated_time": "更新时间", } data = dict_data_list.copy() for item in data: item["status"] = "正常" if item.get("status") == 0 else "停用" item["is_default"] = "是" if item.get("is_default") else "否" return ExcelUtil.export_list2excel(list_data=data, mapping_dict=mapping_dict) async def page( self, page_no: int, page_size: int, search: DictDataQueryParam | None = None, order_by: list[dict] | None = None, ) -> PageResultSchema[DictDataOutSchema]: """分页查询字典数据（数据库 OFFSET/LIMIT）。 参数: - page_no (int): 页码（从 1 开始） - page_size (int): 每页条数 - search (DictDataQueryParam | None): 查询条件 - order_by (list[dict] | None): 排序字段列表 返回: - PageResultSchema[DictDataOutSchema]: 分页结果 """ offset = (page_no - 1) * page_size return await DictDataCRUD(self.auth, self.db).page( offset=offset, limit=page_size, order_by=order_by or [{"id": "asc"}], search=search_to_dict(search), out_schema=DictDataOutSchema, ) @staticmethod async def init_cache(redis: Redis) -> None: """应用初始化: 获取所有字典类型对应的字典数据信息并按租户缓存（无 auth）。 参数: - redis (Redis): Redis客户端 返回: - None """ try: async with async_db_session() as session, session.begin(): init_auth = AuthSchema() obj_list = await DictTypeCRUD(init_auth, session).get_list() if not obj_list: logger.warning("未找到任何字典类型数据") return for obj in obj_list: dict_type = obj.dict_type try: dict_data_list = await DictDataCRUD(init_auth, session).get_list(search={"dict_type": dict_type}) dict_data = [DictDataOutSchema.model_validate(row).model_dump(mode="json") for row in dict_data_list if row] redis_key = f"{RedisInitKeyConfig.SYSTEM_DICT.key}:1:{dict_type}" value = json.dumps(dict_data, ensure_ascii=False) await RedisCURD(redis).set( key=redis_key, value=value, expire=None, ) except Exception as e: logger.error(f"❌ 初始化字典数据失败 [{dict_type}]: {e}") except Exception as e: logger.error(f"❌️ 字典初始化过程发生错误: {e}") raise CustomException(msg="字典数据初始化失败") from e @staticmethod async def _load_dict_type_from_db(dict_type: str) -> list[dict]: """Redis 不可用时直接从数据库读取字典数据（序列化与 init_cache 一致）。""" async with async_db_session() as session, session.begin(): init_auth = AuthSchema() data_list = await DictDataCRUD(init_auth, session).get_list(search={"dict_type": dict_type}) return [DictDataOutSchema.model_validate(row).model_dump(mode="json") for row in data_list if row] @staticmethod async def get_init_cache(redis: Redis, dict_type: str) -> list[dict]: """从缓存获取字典数据列表信息（无 auth）。 参数: - redis (Redis): Redis客户端（降级模式下为 None，直接回源数据库） - dict_type (str): 字典类型 返回: - list[dict]: 字典数据列表 """ if redis is None: return await DictDataService._load_dict_type_from_db(dict_type) def _parse(data: str | list | None) -> list[dict] | None: """尝试反序列化 Redis 返回的字典缓存数据""" if data is None: return None if isinstance(data, list): return data try: return json.loads(data) except (json.JSONDecodeError, TypeError): return None try: redis_key = f"{RedisInitKeyConfig.SYSTEM_DICT.key}:1:{dict_type}" obj_list_dict = await RedisCURD(redis).get(redis_key) result = _parse(obj_list_dict) if result is not None: return result # 缓存未命中或格式异常，重新初始化 logger.warning(f"字典缓存未命中或格式异常，重新初始化缓存: {dict_type}") await DictDataService.init_cache(redis) obj_list_dict = await RedisCURD(redis).get(redis_key) result = _parse(obj_list_dict) if result is None: raise CustomException(msg="该数据不存在") return result except CustomException: raise except Exception as e: logger.error(f"获取字典缓存失败: {e!s}") raise CustomException(msg="获取字典数据失败") from e async def _refresh_dict_cache(self, redis: Redis, dict_type: str) -> None: """刷新指定字典类型的 Redis 缓存 从数据库拉取全量数据，序列化后写入 Redis。 参数: - redis (Redis): Redis 客户端 - dict_type (str): 字典类型 """ redis_key = f"{RedisInitKeyConfig.SYSTEM_DICT.key}:1:{dict_type}" dict_data_list = await DictDataCRUD(self.auth, self.db).get_list(search={"dict_type": dict_type}) dict_data = [DictDataOutSchema.model_validate(row).model_dump(mode="json") for row in dict_data_list if row] value = json.dumps(dict_data, ensure_ascii=False) await RedisCURD(redis).set(key=redis_key, value=value, expire=None) async def create(self, redis: Redis, data: DictDataCreateSchema) -> DictDataOutSchema: """创建数据字典数据 参数: - redis (Redis): Redis客户端 - data (DictDataCreateSchema): 数据字典数据创建模型 返回: - DictDataOutSchema: 字典数据响应模型 """ # 检查相同字典类型下dict_label是否已存在 exist_label_obj = await DictDataCRUD(self.auth, self.db).get(dict_type=data.dict_type, dict_label=data.dict_label) if exist_label_obj: raise CustomException(msg=f'创建失败，该字典类型下的字典标签"{data.dict_label}"已存在') # 检查相同字典类型下dict_value是否已存在 exist_value_obj = await DictDataCRUD(self.auth, self.db).get(dict_type=data.dict_type, dict_value=data.dict_value) if exist_value_obj: raise CustomException(msg=f'创建失败，该字典类型下的字典键值"{data.dict_value}"已存在') obj = await DictDataCRUD(self.auth, self.db).create(data=data) try: await self._refresh_dict_cache(redis, data.dict_type) logger.info(f"创建字典数据写入缓存成功: {obj}") except Exception as e: logger.error(f"创建字典数据写入缓存失败: {e}") raise CustomException(msg="同步字典数据缓存失败") from e return DictDataOutSchema.model_validate(obj) async def update( self, redis: Redis, id: int, data: DictDataUpdateSchema, ) -> DictDataOutSchema: """更新数据字典数据 参数: - redis (Redis): Redis客户端 - id (int): 数据字典数据ID - data (DictDataUpdateSchema): 数据字典数据更新模型 返回: - DictDataOutSchema: 字典数据响应模型 """ exist_obj = await DictDataCRUD(self.auth, self.db).get_or_404(id=id, msg="更新失败，该数据不存在") # 检查相同字典类型下dict_label是否已存在（排除当前记录） if exist_obj.dict_label != data.dict_label: exist_label_obj = await DictDataCRUD(self.auth, self.db).get(dict_type=data.dict_type, dict_label=data.dict_label) if exist_label_obj: raise CustomException(msg=f'更新失败，该字典类型下的字典标签"{data.dict_label}"已存在') # 检查相同字典类型下dict_value是否已存在（排除当前记录） if exist_obj.dict_value != data.dict_value: exist_value_obj = await DictDataCRUD(self.auth, self.db).get(dict_type=data.dict_type, dict_value=data.dict_value) if exist_value_obj: raise CustomException(msg=f'更新失败，该字典类型下的字典键值"{data.dict_value}"已存在') # 如果字典类型变更，仅刷新旧类型缓存，不联动字典类型状态 if exist_obj.dict_type != data.dict_type: dict_type = await DictTypeCRUD(self.auth, self.db).get(dict_type=exist_obj.dict_type) if dict_type: try: await self._refresh_dict_cache(redis, dict_type.dict_type) except Exception as e: logger.error(f"刷新旧字典缓存失败: {e}") raise CustomException(msg="同步旧字典数据缓存失败") from e obj = await DictDataCRUD(self.auth, self.db).update(id=id, data=data) # 刷新新/当前字典类型缓存（仅一次） try: await self._refresh_dict_cache(redis, data.dict_type) logger.info(f"更新字典数据写入缓存成功: {obj}") except Exception as e: logger.error(f"更新字典数据写入缓存失败: {e}") raise CustomException(msg="同步字典数据缓存失败") from e return DictDataOutSchema.model_validate(obj) async def delete(self, redis: Redis, ids: list[int]) -> None: """删除数据字典数据 参数: - redis (Redis): Redis客户端 - ids (list[int]): 数据字典数据ID列表 返回: - None """ if not ids: raise CustomException(msg="删除失败，删除对象不能为空") existing = await DictDataCRUD(self.auth, self.db).get_list(search={"id": ("in", ids)}) existing_map = {obj.id: obj for obj in existing} for nid in ids: if nid not in existing_map: raise CustomException(msg="删除失败，该数据不存在") # 按 dict_type 分组，每组的缓存只刷新一次 type_groups: dict[str, list[int]] = {} for obj in existing: if obj.id in ids: type_groups.setdefault(obj.dict_type, []).append(obj.id) for dt in type_groups: try: await self._refresh_dict_cache(redis, dt) logger.info(f"删除字典数据并刷新缓存: dict_type={dt}") except Exception as e: logger.error(f"删除字典数据刷新缓存失败: {e}") raise CustomException(msg="同步删除字典数据缓存失败") from e await DictDataCRUD(self.auth, self.db).delete(ids=ids) async def set_available(self, data: BatchSetAvailable) -> None: """设置数据字典数据状态 参数: - data (BatchSetAvailable): 批量设置状态模型 返回: - None """ await DictDataCRUD(self.auth, self.db).set(ids=data.ids, status=data.status)