refactor: 大规模代码整理与功能优化

1. 重构后端API路由、CRUD与模块结构，整合日志管理，移除废弃demo代码
2. 优化前端组件类型定义、样式与路由配置，修复权限判断逻辑
3. 调整默认排序规则、滚动条样式与工具类函数，更新依赖与配置文件
4. 修复多处类型不匹配与默认值问题，完善表单与菜单验证逻辑

backend/app/api/v1/module_system/dict/controller.py

@@ -2,14 +2,14 @@ from typing import Annotated
 
 from fastapi import APIRouter, Body, Depends, Path
 from fastapi.responses import JSONResponse, StreamingResponse
+from fastapi_cache import FastAPICache
+from fastapi_cache.decorator import cache
 from redis.asyncio.client import Redis
 
-from app.api.v1.module_system.auth.schema import AuthSchema
 from app.common.response import ResponseSchema, StreamResponse, SuccessResponse
 from app.core.base_params import PaginationQueryParam
-from app.core.base_schema import BatchSetAvailable
+from app.core.base_schema import AuthSchema, BatchSetAvailable, PageResultSchema
 from app.core.dependencies import AuthPermission, redis_getter
-from app.core.logger import log
 from app.core.router_class import OperationLogRoute
 from app.utils.common_util import bytes2file_response
 
@@ -25,18 +25,19 @@ from .schema import (
 )
 from .service import DictDataService, DictTypeService
 
-DictRouter = APIRouter(route_class=OperationLogRoute, prefix="/dict", tags=["字典管理"])
+DictRouter = APIRouter(route_class=OperationLogRoute, prefix="/dict", tags=["系统管理/字典管理"])
+
+_DICT_TYPE_NS = "dict_type"
 
 
 @DictRouter.get(
     "/type/detail/{id}",
     summary="获取字典类型详情",
-    description="获取字典类型详情",
     response_model=ResponseSchema[DictTypeOutSchema],
 )
 async def get_type_detail_controller(
     id: Annotated[int, Path(description="字典类型ID", ge=1)],
-    auth: Annotated[AuthSchema, Depends(AuthPermission(["module_system:dict_type:detail"]))],
+    auth: Annotated[AuthSchema, Depends(AuthPermission(['module_system:dict_type:detail']))],
 ) -> JSONResponse:
     """
     获取字典类型详情
@@ -52,20 +53,18 @@ async def get_type_detail_controller(
     - CustomException: 获取字典类型详情失败时抛出异常。
     """
     result_dict = await DictTypeService.get_obj_detail_service(id=id, auth=auth)
-    log.info(f"获取字典类型详情成功 {id}")
     return SuccessResponse(data=result_dict, msg="获取字典类型详情成功")
 
 
 @DictRouter.get(
     "/type/list",
     summary="查询字典类型",
-    description="查询字典类型",
-    response_model=ResponseSchema[list[DictTypeOutSchema]],
+    response_model=ResponseSchema[PageResultSchema[DictTypeOutSchema]],
 )
 async def get_type_list_controller(
     page: Annotated[PaginationQueryParam, Depends()],
     search: Annotated[DictTypeQueryParam, Depends()],
-    auth: Annotated[AuthSchema, Depends(AuthPermission(["module_system:dict_type:query"]))],
+    auth: Annotated[AuthSchema, Depends(AuthPermission(['module_system:dict_type:query']))],
 ) -> JSONResponse:
     """
     查询字典类型
@@ -88,18 +87,17 @@ async def get_type_list_controller(
         search=search,
         order_by=page.order_by,
     )
-    log.info("查询字典类型列表成功")
     return SuccessResponse(data=result_dict, msg="查询字典类型列表成功")
 
 
 @DictRouter.get(
     "/type/optionselect",
     summary="获取全部字典类型",
-    description="获取全部字典类型",
     response_model=ResponseSchema[list[DictTypeOutSchema]],
 )
-async def get_type_loptionselect_controller(
-    auth: Annotated[AuthSchema, Depends(AuthPermission(["module_system:dict_type:query"]))],
+@cache(expire=300, namespace=_DICT_TYPE_NS)
+async def get_type_optionselect_controller(
+    auth: Annotated[AuthSchema, Depends(AuthPermission(['module_system:dict_type:query']))],
 ) -> JSONResponse:
     """
     获取全部字典类型
@@ -114,20 +112,18 @@ async def get_type_loptionselect_controller(
     - CustomException: 获取字典类型列表失败时抛出异常。
     """
     result_dict_list = await DictTypeService.get_obj_list_service(auth=auth)
-    log.info("获取字典类型列表成功")
     return SuccessResponse(data=result_dict_list, msg="获取字典类型列表成功")
 
 
 @DictRouter.post(
     "/type/create",
     summary="创建字典类型",
-    description="创建字典类型",
     response_model=ResponseSchema[DictTypeOutSchema],
 )
 async def create_type_controller(
     data: DictTypeCreateSchema,
     redis: Annotated[Redis, Depends(redis_getter)],
-    auth: Annotated[AuthSchema, Depends(AuthPermission(["module_system:dict_type:create"]))],
+    auth: Annotated[AuthSchema, Depends(AuthPermission(['module_system:dict_type:create']))],
 ) -> JSONResponse:
     """
     创建字典类型
@@ -144,21 +140,20 @@ async def create_type_controller(
     - CustomException: 创建字典类型失败时抛出异常。
     """
     result_dict = await DictTypeService.create_obj_service(auth=auth, redis=redis, data=data)
-    log.info(f"创建字典类型成功: {result_dict}")
+    await FastAPICache.clear(namespace=_DICT_TYPE_NS)
     return SuccessResponse(data=result_dict, msg="创建字典类型成功")
 
 
 @DictRouter.put(
     "/type/update/{id}",
     summary="修改字典类型",
-    description="修改字典类型",
     response_model=ResponseSchema[DictTypeOutSchema],
 )
 async def update_type_controller(
     data: DictTypeUpdateSchema,
     redis: Annotated[Redis, Depends(redis_getter)],
     id: Annotated[int, Path(description="字典类型ID", ge=1)],
-    auth: Annotated[AuthSchema, Depends(AuthPermission(["module_system:dict_type:update"]))],
+    auth: Annotated[AuthSchema, Depends(AuthPermission(['module_system:dict_type:update']))],
 ) -> JSONResponse:
     """
     修改字典类型
@@ -176,20 +171,19 @@ async def update_type_controller(
     - CustomException: 修改字典类型失败时抛出异常。
     """
     result_dict = await DictTypeService.update_obj_service(auth=auth, redis=redis, id=id, data=data)
-    log.info(f"修改字典类型成功: {result_dict}")
+    await FastAPICache.clear(namespace=_DICT_TYPE_NS)
     return SuccessResponse(data=result_dict, msg="修改字典类型成功")
 
 
 @DictRouter.delete(
     "/type/delete",
     summary="删除字典类型",
-    description="删除字典类型",
     response_model=ResponseSchema[None],
 )
 async def delete_type_controller(
     redis: Annotated[Redis, Depends(redis_getter)],
     ids: Annotated[list[int], Body(description="ID列表")],
-    auth: Annotated[AuthSchema, Depends(AuthPermission(["module_system:dict_type:delete"]))],
+    auth: Annotated[AuthSchema, Depends(AuthPermission(['module_system:dict_type:delete']))],
 ) -> JSONResponse:
     """
     删除字典类型
@@ -206,19 +200,18 @@ async def delete_type_controller(
     - CustomException: 删除字典类型失败时抛出异常。
     """
     await DictTypeService.delete_obj_service(auth=auth, redis=redis, ids=ids)
-    log.info(f"删除字典类型成功: {ids}")
+    await FastAPICache.clear(namespace=_DICT_TYPE_NS)
     return SuccessResponse(msg="删除字典类型成功")
 
 
 @DictRouter.patch(
     "/type/status/batch",
     summary="批量修改字典类型状态",
-    description="批量修改字典类型状态",
     response_model=ResponseSchema[None],
 )
 async def batch_set_available_dict_type_controller(
     data: BatchSetAvailable,
-    auth: Annotated[AuthSchema, Depends(AuthPermission(["module_system:dict_type:patch"]))],
+    auth: Annotated[AuthSchema, Depends(AuthPermission(['module_system:dict_type:patch']))],
 ) -> JSONResponse:
     """
     批量修改字典类型状态
@@ -234,19 +227,18 @@ async def batch_set_available_dict_type_controller(
     - CustomException: 批量修改字典类型状态失败时抛出异常。
     """
     await DictTypeService.set_obj_available_service(auth=auth, data=data)
-    log.info(f"批量修改字典类型状态成功: {data.ids}")
+    await FastAPICache.clear(namespace=_DICT_TYPE_NS)
     return SuccessResponse(msg="批量修改字典类型状态成功")
 
 
 @DictRouter.post(
     "/type/export",
     summary="导出字典类型",
-    description="导出字典类型",
     response_model=ResponseSchema[None],
 )
 async def export_type_list_controller(
     search: Annotated[DictTypeQueryParam, Depends()],
-    auth: Annotated[AuthSchema, Depends(AuthPermission(["module_system:dict_type:export"]))],
+    auth: Annotated[AuthSchema, Depends(AuthPermission(['module_system:dict_type:export']))],
 ) -> StreamingResponse:
     """
     导出字典类型
@@ -261,10 +253,10 @@ async def export_type_list_controller(
     异常:
     - CustomException: 导出字典类型失败时抛出异常。
     """
-    # 获取全量数据
+    # 获取全量数据并转为dict列表
     result_dict_list = await DictTypeService.get_obj_list_service(search=search, auth=auth)
-    export_result = await DictTypeService.export_obj_service(data_list=result_dict_list)
-    log.info("导出字典类型成功")
+    export_data = [item.model_dump() for item in result_dict_list]
+    export_result = await DictTypeService.export_obj_service(data_list=export_data)
 
     return StreamResponse(
         data=bytes2file_response(export_result),
@@ -276,12 +268,11 @@ async def export_type_list_controller(
 @DictRouter.get(
     "/data/detail/{id}",
     summary="获取字典数据详情",
-    description="获取字典数据详情",
     response_model=ResponseSchema[DictDataOutSchema],
 )
 async def get_data_detail_controller(
     id: Annotated[int, Path(description="字典数据ID", ge=1)],
-    auth: Annotated[AuthSchema, Depends(AuthPermission(["module_system:dict_data:detail"]))],
+    auth: Annotated[AuthSchema, Depends(AuthPermission(['module_system:dict_data:detail']))],
 ) -> JSONResponse:
     """
     获取字典数据详情
@@ -297,20 +288,18 @@ async def get_data_detail_controller(
     - CustomException: 获取字典数据详情失败时抛出异常。
     """
     result_dict = await DictDataService.get_obj_detail_service(id=id, auth=auth)
-    log.info(f"获取字典数据详情成功 {id}")
     return SuccessResponse(data=result_dict, msg="获取字典数据详情成功")
 
 
 @DictRouter.get(
     "/data/list",
     summary="查询字典数据",
-    description="查询字典数据",
-    response_model=ResponseSchema[list[DictDataOutSchema]],
+    response_model=ResponseSchema[PageResultSchema[DictDataOutSchema]],
 )
 async def get_data_list_controller(
     page: Annotated[PaginationQueryParam, Depends()],
     search: Annotated[DictDataQueryParam, Depends()],
-    auth: Annotated[AuthSchema, Depends(AuthPermission(["module_system:dict_data:query"]))],
+    auth: Annotated[AuthSchema, Depends(AuthPermission(['module_system:dict_data:query']))],
 ) -> JSONResponse:
     """
     查询字典数据
@@ -336,20 +325,18 @@ async def get_data_list_controller(
         search=search,
         order_by=order_by,
     )
-    log.info("查询字典数据列表成功")
     return SuccessResponse(data=result_dict, msg="查询字典数据列表成功")
 
 
 @DictRouter.post(
     "/data/create",
     summary="创建字典数据",
-    description="创建字典数据",
     response_model=ResponseSchema[DictDataOutSchema],
 )
 async def create_data_controller(
     data: DictDataCreateSchema,
     redis: Annotated[Redis, Depends(redis_getter)],
-    auth: Annotated[AuthSchema, Depends(AuthPermission(["module_system:dict_data:create"]))],
+    auth: Annotated[AuthSchema, Depends(AuthPermission(['module_system:dict_data:create']))],
 ) -> JSONResponse:
     """
     创建字典数据
@@ -366,21 +353,19 @@ async def create_data_controller(
     - CustomException: 创建字典数据失败时抛出异常。
     """
     result_dict = await DictDataService.create_obj_service(auth=auth, redis=redis, data=data)
-    log.info(f"创建字典数据成功: {result_dict}")
     return SuccessResponse(data=result_dict, msg="创建字典数据成功")
 
 
 @DictRouter.put(
     "/data/update/{id}",
     summary="修改字典数据",
-    description="修改字典数据",
     response_model=ResponseSchema[DictDataOutSchema],
 )
 async def update_data_controller(
     data: DictDataUpdateSchema,
     redis: Annotated[Redis, Depends(redis_getter)],
     id: Annotated[int, Path(description="字典数据ID")],
-    auth: Annotated[AuthSchema, Depends(AuthPermission(["module_system:dict_data:update"]))],
+    auth: Annotated[AuthSchema, Depends(AuthPermission(['module_system:dict_data:update']))],
 ) -> JSONResponse:
     """
     修改字典数据
@@ -398,20 +383,18 @@ async def update_data_controller(
     - CustomException: 修改字典数据失败时抛出异常。
     """
     result_dict = await DictDataService.update_obj_service(auth=auth, redis=redis, id=id, data=data)
-    log.info(f"修改字典数据成功: {result_dict}")
     return SuccessResponse(data=result_dict, msg="修改字典数据成功")
 
 
 @DictRouter.delete(
     "/data/delete",
     summary="删除字典数据",
-    description="删除字典数据",
     response_model=ResponseSchema[None],
 )
 async def delete_data_controller(
     redis: Annotated[Redis, Depends(redis_getter)],
     ids: Annotated[list[int], Body(description="ID列表")],
-    auth: Annotated[AuthSchema, Depends(AuthPermission(["module_system:dict_data:delete"]))],
+    auth: Annotated[AuthSchema, Depends(AuthPermission(['module_system:dict_data:delete']))],
 ) -> JSONResponse:
     """
     删除字典数据
@@ -428,19 +411,17 @@ async def delete_data_controller(
     - CustomException: 删除字典数据失败时抛出异常。
     """
     await DictDataService.delete_obj_service(auth=auth, redis=redis, ids=ids)
-    log.info(f"删除字典数据成功: {ids}")
     return SuccessResponse(msg="删除字典数据成功")
 
 
 @DictRouter.patch(
     "/data/status/batch",
     summary="批量修改字典数据状态",
-    description="批量修改字典数据状态",
     response_model=ResponseSchema[None],
 )
 async def batch_set_available_dict_data_controller(
     data: BatchSetAvailable,
-    auth: Annotated[AuthSchema, Depends(AuthPermission(["module_system:dict_data:patch"]))],
+    auth: Annotated[AuthSchema, Depends(AuthPermission(['module_system:dict_data:patch']))],
 ) -> JSONResponse:
     """
     批量修改字典数据状态
@@ -456,20 +437,18 @@ async def batch_set_available_dict_data_controller(
     - CustomException: 批量修改字典数据状态失败时抛出异常。
     """
     await DictDataService.set_obj_available_service(auth=auth, data=data)
-    log.info(f"批量修改字典数据状态成功: {data.ids}")
     return SuccessResponse(msg="批量修改字典数据状态成功")
 
 
 @DictRouter.post(
     "/data/export",
     summary="导出字典数据",
-    description="导出字典数据",
     response_model=ResponseSchema[None],
 )
 async def export_data_list_controller(
     search: Annotated[DictDataQueryParam, Depends()],
     page: Annotated[PaginationQueryParam, Depends()],
-    auth: Annotated[AuthSchema, Depends(AuthPermission(["module_system:dict_data:export"]))],
+    auth: Annotated[AuthSchema, Depends(AuthPermission(['module_system:dict_data:export']))],
 ) -> StreamingResponse:
     """
     导出字典数据
@@ -488,8 +467,8 @@ async def export_data_list_controller(
     result_dict_list = await DictDataService.get_obj_list_service(
         auth=auth, search=search, order_by=page.order_by
     )
-    export_result = await DictDataService.export_obj_service(data_list=result_dict_list)
-    log.info("导出字典数据成功")
+    export_data = [item.model_dump() for item in result_dict_list]
+    export_result = await DictDataService.export_obj_service(data_list=export_data)
 
     return StreamResponse(
         data=bytes2file_response(export_result),
@@ -501,7 +480,6 @@ async def export_data_list_controller(
 @DictRouter.get(
     "/data/info/{dict_type}",
     summary="根据字典类型获取数据",
-    description="根据字典类型获取数据",
     response_model=ResponseSchema[list[DictDataOutSchema]],
 )
 async def get_init_dict_data_controller(
@@ -523,6 +501,5 @@ async def get_init_dict_data_controller(
     dict_data_query_result = await DictDataService.get_init_dict_service(
         redis=redis, dict_type=dict_type, tenant_id=1
     )
-    log.info(f"获取初始化字典数据成功：{dict_data_query_result}")
 
     return SuccessResponse(data=dict_data_query_result, msg="获取初始化字典数据成功")

backend/app/api/v1/module_system/dict/crud.py

@@ -1,6 +1,5 @@
 from collections.abc import Sequence
 
-from app.api.v1.module_system.auth.schema import AuthSchema
 from app.api.v1.module_system.dict.model import DictDataModel, DictTypeModel
 from app.api.v1.module_system.dict.schema import (
     DictDataCreateSchema,
@@ -9,6 +8,7 @@ from app.api.v1.module_system.dict.schema import (
     DictTypeUpdateSchema,
 )
 from app.core.base_crud import CRUDBase
+from app.core.base_schema import AuthSchema
 
 
 class DictTypeCRUD(CRUDBase[DictTypeModel, DictTypeCreateSchema, DictTypeUpdateSchema]):
@@ -24,112 +24,8 @@ class DictTypeCRUD(CRUDBase[DictTypeModel, DictTypeCreateSchema, DictTypeUpdateS
         返回:
         - None
         """
-        self.auth = auth
         super().__init__(model=DictTypeModel, auth=auth)
 
-    async def get_obj_by_id_crud(
-        self, id: int, preload: list | None = None
-    ) -> DictTypeModel | None:
-        """
-        获取数据字典类型详情
-
-        参数:
-        - id (int): 数据字典类型ID
-        - preload (list | None): 预加载关系，未提供时使用模型默认项
-
-        返回:
-        - DictTypeModel | None: 数据字典类型模型,如果不存在则为None
-        """
-        # 添加默认预加载字典数据关系
-        if preload is None:
-            preload = []
-        return await self.get(id=id, preload=preload)
-
-    async def get_obj_list_crud(
-        self,
-        search: dict | None = None,
-        order_by: list[dict] | None = None,
-        preload: list | None = None,
-    ) -> Sequence[DictTypeModel]:
-        """
-        获取数据字典类型列表
-
-        参数:
-        - search (dict | None): 查询参数,默认值为None
-        - order_by (list[dict] | None): 排序参数,默认值为None
-        - preload (list | None): 预加载关系，未提供时使用模型默认项
-
-        返回:
-        - Sequence[DictTypeModel]: 数据字典类型模型序列
-        """
-        # 添加默认预加载字典数据关系
-        if preload is None:
-            preload = []
-        return await self.list(search=search, order_by=order_by, preload=preload)
-
-    async def create_obj_crud(self, data: DictTypeCreateSchema) -> DictTypeModel | None:
-        """
-        创建数据字典类型
-
-        参数:
-        - data (DictTypeCreateSchema): 数据字典类型创建模型
-
-        返回:
-        - DictTypeModel | None: 创建的数据字典类型模型,如果创建失败则为None
-        """
-        return await self.create(data=data)
-
-    async def update_obj_crud(self, id: int, data: DictTypeUpdateSchema) -> DictTypeModel | None:
-        """
-        更新数据字典类型
-
-        参数:
-        - id (int): 数据字典类型ID
-        - data (DictTypeUpdateSchema): 数据字典类型更新模型
-
-        返回:
-        - DictTypeModel | None: 更新的数据字典类型模型,如果更新失败则为None
-        """
-        return await self.update(id=id, data=data)
-
-    async def delete_obj_crud(self, ids: list[int]) -> None:
-        """
-        删除数据字典类型
-
-        参数:
-        - ids (list[int]): 数据字典类型ID列表
-
-        返回:
-        - None
-        """
-        return await self.delete(ids=ids)
-
-    async def set_obj_available_crud(self, ids: list[int], status: str) -> None:
-        """
-        设置数据字典类型的可用状态
-
-        参数:
-        - ids (list[int]): 数据字典类型ID列表
-        - status (str): 可用状态,0表示正常,1表示停用
-
-        返回:
-        - None
-        """
-        return await self.set(ids=ids, status=status)
-
-    async def batch_delete_obj_crud(self, ids: list[int]) -> int:
-        """
-        批量删除数据字典类型
-
-        参数:
-        - ids (list[int]): 数据字典类型ID列表
-
-        返回:
-        - int: 删除的记录数量
-        """
-        await self.delete(ids=ids)
-        return len(ids)
-
 
 class DictDataCRUD(CRUDBase[DictDataModel, DictDataCreateSchema, DictDataUpdateSchema]):
     """数据字典数据层"""
@@ -144,100 +40,11 @@ class DictDataCRUD(CRUDBase[DictDataModel, DictDataCreateSchema, DictDataUpdateS
         返回:
         - None
         """
-        self.auth = auth
         super().__init__(model=DictDataModel, auth=auth)
 
-    async def get_obj_by_id_crud(
-        self, id: int, preload: list | None = None
-    ) -> DictDataModel | None:
-        """
-        获取数据字典数据详情
-
-        参数:
-        - id (int): 数据字典数据ID
-        - preload (list | None): 预加载关系，未提供时使用模型默认项
-
-        返回:
-        - DictDataModel | None: 数据字典数据模型,如果不存在则为None
-        """
-        # 添加默认预加载字典类型关系
-        if preload is None:
-            preload = []
-        return await self.get(id=id, preload=preload)
-
-    async def get_obj_list_crud(
-        self,
-        search: dict | None = None,
-        order_by: list[dict] | None = None,
-        preload: list | None = None,
-    ) -> Sequence[DictDataModel]:
-        """
-        获取数据字典数据列表
-
-        参数:
-        - search (dict | None): 查询参数,默认值为None
-        - order_by (list[dict] | None): 排序参数,默认值为None
-        - preload (list | None): 预加载关系，未提供时使用模型默认项
-
-        返回:
-        - Sequence[DictDataModel]: 数据字典数据模型序列
-        """
-        # 添加默认预加载字典类型关系
-        if preload is None:
-            preload = []
-        return await self.list(search=search, order_by=order_by, preload=preload)
-
-    async def create_obj_crud(self, data: DictDataCreateSchema) -> DictDataModel | None:
-        """
-        创建数据字典数据
-
-        参数:
-        - data (DictDataCreateSchema): 数据字典数据创建模型
-
-        返回:
-        - DictDataModel | None: 创建的数据字典数据模型,如果创建失败则为None
-        """
-        return await self.create(data=data)
-
-    async def update_obj_crud(self, id: int, data: DictDataUpdateSchema) -> DictDataModel | None:
-        """
-        更新数据字典数据
-
-        参数:
-        - id (int): 数据字典数据ID
-        - data (DictDataUpdateSchema): 数据字典数据更新模型
-
-        返回:
-        - DictDataModel | None: 更新的数据字典数据模型,如果更新失败则为None
-        """
-        return await self.update(id=id, data=data)
-
-    async def delete_obj_crud(self, ids: list[int]) -> None:
-        """
-        删除数据字典数据
-
-        参数:
-        - ids (list[int]): 数据字典数据ID列表
-
-        返回:
-        - None
-        """
-        return await self.delete(ids=ids)
-
-    async def set_obj_available_crud(self, ids: list[int], status: str) -> None:
-        """
-        设置数据字典数据的可用状态
-
-        参数:
-        - ids (list[int]): 数据字典数据ID列表
-        - status (str): 可用状态,0表示正常,1表示停用
-
-        返回:
-        - None
-        """
-        return await self.set(ids=ids, status=status)
-
-    async def batch_delete_obj_crud(self, ids: list[int], exclude_system: bool = True) -> int:
+    async def batch_delete(
+        self, ids: list[int], exclude_system: bool = True
+    ) -> int:
         """
         批量删除数据字典数据
 
@@ -248,25 +55,20 @@ class DictDataCRUD(CRUDBase[DictDataModel, DictDataCreateSchema, DictDataUpdateS
         返回:
         - int: 删除的记录数量
         """
-        # 如果需要排除系统默认数据，可以在这里添加过滤逻辑
-        # 假设系统默认数据在remark字段中包含"系统默认"字符串
         if exclude_system:
-            # 获取非系统默认数据的ID
-            system_data_filter = {
+            system_data = await self.list(search={
                 "id__in": ids,
                 "remark__contains": "系统默认",
-            }
-            system_data = await self.list(search=system_data_filter)
+            })
             system_ids = [item.id for item in system_data]
-            # 从待删除ID列表中排除系统默认数据
             ids = [id for id in ids if id not in system_ids]
 
         if ids:
             await self.delete(ids=ids)
         return len(ids)
 
-    async def get_obj_list_by_dict_type_crud(
-        self, dict_type: str, status: str | None = "0"
+    async def get_list_by_dict_type(
+        self, dict_type: str, status: int | None = 0
     ) -> Sequence[DictDataModel]:
         """
         根据字典类型获取字典数据列表
@@ -281,5 +83,4 @@ class DictDataCRUD(CRUDBase[DictDataModel, DictDataCreateSchema, DictDataUpdateS
         search = {"dict_type": dict_type}
         if status is not None:
             search["status"] = status
-        order_by = [{"id": "asc"}]
-        return await self.list(search=search, order_by=order_by)
+        return await self.list(search=search, order_by=[{"id": "asc"}])

backend/app/api/v1/module_system/dict/schema.py

@@ -21,17 +21,18 @@ class DictTypeCreateSchema(BaseModel):
 
     dict_name: str = Field(..., min_length=1, max_length=64, description="字典名称")
     dict_type: str = Field(..., min_length=1, max_length=255, description="字典类型编码")
-    status: str = Field(default="0", max_length=1, description="状态(0:正常 1:停用)")
+    status: int = Field(default=0, ge=0, le=1, description="状态(0:正常 1:停用)")
     description: str | None = Field(default=None, max_length=255, description="描述")
 
     @field_validator("status")
     @classmethod
-    def validate_status(cls, value: str):
-        if value not in {"0", "1"}:
+    def validate_status(cls, value: int):
+        if value not in {0, 1}:
             raise ValueError("状态仅支持 0(正常) 或 1(停用)")
         return value
 
     @field_validator("dict_name")
+    @classmethod
     def validate_dict_name(cls, value: str):
         """
         校验字典名称为非空字符串。
@@ -50,6 +51,7 @@ class DictTypeCreateSchema(BaseModel):
         return value.strip()
 
     @field_validator("dict_type")
+    @classmethod
     def validate_dict_type(cls, value: str):
         """
         校验字典类型：小写字母开头，仅包含小写字母/数字/下划线。
@@ -100,7 +102,6 @@ class DictTypeQueryParam:
             examples=["2025-01-01 00:00:00", "2025-12-31 23:59:59"],
         ),
     ) -> None:
-        super().__init__()
 
         # 模糊查询字段
         self.dict_name = (QueueEnum.like.value, dict_name)
@@ -131,13 +132,13 @@ class DictDataCreateSchema(BaseModel):
     )
     list_class: str | None = Field(default=None, max_length=255, description="表格回显样式")
     is_default: bool = Field(default=False, description="是否默认")
-    status: str = Field(default="0", max_length=1, description="状态(0:正常 1:停用)")
+    status: int = Field(default=0, ge=0, le=1, description="状态(0:正常 1:停用)")
     description: str | None = Field(default=None, max_length=255, description="描述")
 
     @field_validator("status")
     @classmethod
-    def validate_status(cls, value: str):
-        if value not in {"0", "1"}:
+    def validate_status(cls, value: int) -> int:
+        if value not in (0, 1):
             raise ValueError("状态仅支持 0(正常) 或 1(停用)")
         return value
 

backend/app/api/v1/module_system/dict/service.py

@@ -2,12 +2,11 @@ import json
 
 from redis.asyncio.client import Redis
 
-from app.api.v1.module_system.auth.schema import AuthSchema
 from app.common.enums import RedisInitKeyConfig
-from app.core.base_schema import BatchSetAvailable
+from app.core.base_schema import AuthSchema, BatchSetAvailable
 from app.core.database import async_db_session
 from app.core.exceptions import CustomException
-from app.core.logger import log
+from app.core.logger import logger
 from app.core.redis_crud import RedisCURD
 from app.utils.excel_util import ExcelUtil
 
@@ -30,7 +29,7 @@ class DictTypeService:
     """
 
     @classmethod
-    async def get_obj_detail_service(cls, auth: AuthSchema, id: int) -> dict:
+    async def get_obj_detail_service(cls, auth: AuthSchema, id: int) -> DictTypeOutSchema:
         """
         获取数据字典类型详情
 
@@ -41,8 +40,10 @@ class DictTypeService:
         返回:
         - dict: 数据字典类型详情字典
         """
-        obj = await DictTypeCRUD(auth).get_obj_by_id_crud(id=id)
-        return DictTypeOutSchema.model_validate(obj).model_dump()
+        obj = await DictTypeCRUD(auth).get(id=id)
+        if not obj:
+            raise CustomException(msg="字典类型不存在")
+        return DictTypeOutSchema.model_validate(obj)
 
     @classmethod
     async def get_obj_list_service(
@@ -50,7 +51,7 @@ class DictTypeService:
         auth: AuthSchema,
         search: DictTypeQueryParam | None = None,
         order_by: list[dict] | None = None,
-    ) -> list[dict]:
+    ) -> list[DictTypeOutSchema]:
         """
         获取数据字典类型列表
 
@@ -60,12 +61,12 @@ class DictTypeService:
         - order_by (list[dict] | None): 排序字段列表
 
         返回:
-        - list[dict]: 数据字典类型详情字典列表
+        - list[DictTypeOutSchema]: 数据字典类型
         """
-        obj_list = await DictTypeCRUD(auth).get_obj_list_crud(
-            search=search.__dict__, order_by=order_by
+        obj_list = await DictTypeCRUD(auth).list(
+            search=search.__dict__ if search else {}, order_by=order_by
         )
-        return [DictTypeOutSchema.model_validate(obj).model_dump() for obj in obj_list]
+        return [DictTypeOutSchema.model_validate(obj) for obj in obj_list]
 
     @classmethod
     async def get_obj_page_service(
@@ -101,7 +102,7 @@ class DictTypeService:
     @classmethod
     async def create_obj_service(
         cls, auth: AuthSchema, redis: Redis, data: DictTypeCreateSchema
-    ) -> dict:
+    ) -> DictTypeOutSchema:
         """
         创建数据字典类型
 
@@ -116,21 +117,21 @@ class DictTypeService:
         exist_obj = await DictTypeCRUD(auth).get(dict_name=data.dict_name)
         if exist_obj:
             raise CustomException(msg="创建失败，该数据字典类型已存在")
-        obj = await DictTypeCRUD(auth).create_obj_crud(data=data)
+        obj = await DictTypeCRUD(auth).create(data=data)
 
-        new_obj_dict = DictTypeOutSchema.model_validate(obj).model_dump()
+        new_obj_dict = DictTypeOutSchema.model_validate(obj)
 
         redis_key = f"{RedisInitKeyConfig.SYSTEM_DICT.key}:{auth.user.tenant_id}:{data.dict_type}"
 
         try:
             await RedisCURD(redis).set(
                 key=redis_key,
-                value="",
+                value="[]",
                 expire=None,
             )
-            log.info(f"创建字典类型成功: {new_obj_dict}")
+            logger.info(f"创建字典类型成功: {new_obj_dict}")
         except Exception as e:
-            log.error(f"创建字典类型失败: {e}")
+            logger.error(f"创建字典类型失败: {e}")
             raise CustomException(msg=f"创建字典类型失败 {e}")
 
         return new_obj_dict
@@ -142,7 +143,7 @@ class DictTypeService:
         redis: Redis,
         id: int,
         data: DictTypeUpdateSchema,
-    ) -> dict:
+    ) -> DictTypeOutSchema:
         """
         更新数据字典类型
 
@@ -155,16 +156,14 @@ class DictTypeService:
         返回:
         - dict: 数据字典类型详情字典
         """
-        exist_obj = await DictTypeCRUD(auth).get_obj_by_id_crud(id=id)
+        exist_obj = await DictTypeCRUD(auth).get(id=id)
         if not exist_obj:
             raise CustomException(msg="更新失败，该数据字典类型不存在")
         if exist_obj.dict_name != data.dict_name:
             raise CustomException(msg="更新失败，数据字典类型名称不可以修改")
 
-        dict_data_list = []
-        # 如果字典类型修改或状态变更，则修改对应字典数据的类型和状态，并更新Redis缓存
+        # 如果字典类型修改或状态变更，则修改对应字典数据的类型和状态
         if exist_obj.dict_type != data.dict_type or exist_obj.status != data.status:
-            # 检查字典数据类型是否被修改
             exist_obj_type_list = await DictDataCRUD(auth).list(
                 search={"dict_type": exist_obj.dict_type}
             )
@@ -183,17 +182,16 @@ class DictTypeService:
                         status=data.status,
                         description=item.description,
                     )
-                    obj = await DictDataCRUD(auth).update_obj_crud(id=item.id, data=dict_data)
-                    dict_data_list.append(DictDataOutSchema.model_validate(obj).model_dump())
+                    await DictDataCRUD(auth).update(id=item.id, data=dict_data)
 
-        obj = await DictTypeCRUD(auth).update_obj_crud(id=id, data=data)
+        obj = await DictTypeCRUD(auth).update(id=id, data=data)
 
-        new_obj_dict = DictTypeOutSchema.model_validate(obj).model_dump()
+        new_obj_dict = DictTypeOutSchema.model_validate(obj)
 
         redis_key = f"{RedisInitKeyConfig.SYSTEM_DICT.key}:{auth.user.tenant_id}:{data.dict_type}"
         try:
             # 获取当前字典类型的所有字典数据，确保包含最新状态
-            dict_data_list = await DictDataCRUD(auth).get_obj_list_crud(
+            dict_data_list = await DictDataCRUD(auth).list(
                 search={"dict_type": data.dict_type}
             )
             dict_data = [
@@ -208,9 +206,9 @@ class DictTypeService:
                 value=value,
                 expire=None,
             )
-            log.info(f"更新字典类型成功并刷新缓存: {new_obj_dict}")
+            logger.info(f"更新字典类型成功并刷新缓存: {new_obj_dict}")
         except Exception as e:
-            log.error(f"更新字典类型缓存失败: {e}")
+            logger.error(f"更新字典类型缓存失败: {e}")
             raise CustomException(msg=f"更新字典类型缓存失败 {e}")
 
         return new_obj_dict
@@ -230,12 +228,14 @@ class DictTypeService:
         """
         if len(ids) < 1:
             raise CustomException(msg="删除失败，删除对象不能为空")
-        for id in ids:
-            exist_obj = await DictTypeCRUD(auth).get_obj_by_id_crud(id=id)
-            if not exist_obj:
+        existing = await DictTypeCRUD(auth).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="删除失败，该数据字典类型不存在")
+            exist_obj = existing_map[nid]
             # 检查是否有字典数据
-            exist_obj_type_list = await DictDataCRUD(auth).list(search={"dict_type": id})
+            exist_obj_type_list = await DictDataCRUD(auth).list(search={"dict_type": exist_obj.dict_type})
             if len(exist_obj_type_list) > 0:
                 # 如果有字典数据，不能删除
                 raise CustomException(msg="删除失败，该数据字典类型下存在字典数据")
@@ -245,11 +245,11 @@ class DictTypeService:
             )
             try:
                 await RedisCURD(redis).delete(redis_key)
-                log.info(f"删除字典类型成功: {id}")
+                logger.info(f"删除字典类型成功: {nid}")
             except Exception as e:
-                log.error(f"删除字典类型失败: {e}")
+                logger.error(f"删除字典类型失败: {e}")
                 raise CustomException(msg="删除字典类型失败")
-        await DictTypeCRUD(auth).delete_obj_crud(ids=ids)
+        await DictTypeCRUD(auth).delete(ids=ids)
 
     @classmethod
     async def set_obj_available_service(cls, auth: AuthSchema, data: BatchSetAvailable) -> None:
@@ -263,7 +263,7 @@ class DictTypeService:
         返回:
         - None
         """
-        await DictTypeCRUD(auth).set_obj_available_crud(ids=data.ids, status=data.status)
+        await DictTypeCRUD(auth).set(ids=data.ids, status=data.status)
 
     @classmethod
     async def export_obj_service(cls, data_list: list[dict]) -> bytes:
@@ -292,12 +292,7 @@ class DictTypeService:
         data = data_list.copy()
         for item in data:
             # 处理状态
-            item["status"] = "启用" if item.get("status") == "0" else "停用"
-            item["creator"] = (
-                item.get("creator", {}).get("name", "未知")
-                if isinstance(item.get("creator"), dict)
-                else "未知"
-            )
+            item["status"] = "启用" if item.get("status") == 0 else "停用"
 
         return ExcelUtil.export_list2excel(list_data=data, mapping_dict=mapping_dict)
 
@@ -308,7 +303,7 @@ class DictDataService:
     """
 
     @classmethod
-    async def get_obj_detail_service(cls, auth: AuthSchema, id: int) -> dict:
+    async def get_obj_detail_service(cls, auth: AuthSchema, id: int) -> DictDataOutSchema:
         """
         获取数据字典数据详情
 
@@ -319,8 +314,10 @@ class DictDataService:
         返回:
         - dict: 数据字典数据详情字典
         """
-        obj = await DictDataCRUD(auth).get_obj_by_id_crud(id=id)
-        return DictDataOutSchema.model_validate(obj).model_dump()
+        obj = await DictDataCRUD(auth).get(id=id)
+        if not obj:
+            raise CustomException(msg="字典数据不存在")
+        return DictDataOutSchema.model_validate(obj)
 
     @classmethod
     async def get_obj_list_service(
@@ -328,7 +325,7 @@ class DictDataService:
         auth: AuthSchema,
         search: DictDataQueryParam | None = None,
         order_by: list[dict] | None = None,
-    ) -> list[dict]:
+    ) -> list[DictDataOutSchema]:
         """
         获取数据字典数据列表
 
@@ -338,12 +335,12 @@ class DictDataService:
         - order_by (list[dict] | None): 排序字段列表
 
         返回:
-        - list[dict]: 数据字典数据详情字典列表
+        - list[DictDataOutSchema]: 数据字典数据
         """
-        obj_list = await DictDataCRUD(auth).get_obj_list_crud(
-            search=search.__dict__, order_by=order_by
+        obj_list = await DictDataCRUD(auth).list(
+            search=search.__dict__ if search else {}, order_by=order_by
         )
-        return [DictDataOutSchema.model_validate(obj).model_dump() for obj in obj_list]
+        return [DictDataOutSchema.model_validate(obj) for obj in obj_list]
 
     @classmethod
     async def get_obj_page_service(
@@ -391,16 +388,16 @@ class DictDataService:
             async with async_db_session() as session:
                 async with session.begin():
                     auth = AuthSchema(db=session, check_data_scope=False)
-                    obj_list = await DictTypeCRUD(auth).get_obj_list_crud()
+                    obj_list = await DictTypeCRUD(auth).list()
                     if not obj_list:
-                        log.warning("未找到任何字典类型数据")
+                        logger.warning("未找到任何字典类型数据")
                         return
 
                     for obj in obj_list:
                         dict_type = obj.dict_type
                         tenant_id = obj.tenant_id
                         try:
-                            dict_data_list = await DictDataCRUD(auth).get_obj_list_crud(
+                            dict_data_list = await DictDataCRUD(auth).list(
                                 search={"dict_type": dict_type, "tenant_id": tenant_id}
                             )
                             dict_data = [
@@ -418,10 +415,10 @@ class DictDataService:
                                 expire=None,
                             )
                         except Exception as e:
-                            log.error(f"❌ 初始化字典数据失败 [{dict_type}]: {e}")
+                            logger.error(f"❌ 初始化字典数据失败 [{dict_type}]: {e}")
 
         except Exception as e:
-            log.error(f"字典初始化过程发生错误: {e}")
+            logger.error(f"字典初始化过程发生错误: {e}")
             raise CustomException(msg=f"字典数据初始化失败: {e!s}")
 
     @classmethod
@@ -448,7 +445,7 @@ class DictDataService:
                     try:
                         return json.loads(obj_list_dict)
                     except json.JSONDecodeError:
-                        log.warning(f"字典数据反序列化失败，尝试重新初始化缓存: {dict_type}")
+                        logger.warning(f"字典数据反序列化失败，尝试重新初始化缓存: {dict_type}")
                 elif isinstance(obj_list_dict, list):
                     return obj_list_dict
 
@@ -467,13 +464,13 @@ class DictDataService:
         except CustomException:
             raise
         except Exception as e:
-            log.error(f"获取字典缓存失败: {e!s}")
+            logger.error(f"获取字典缓存失败: {e!s}")
             raise CustomException(msg=f"获取字典数据失败: {e!s}")
 
     @classmethod
     async def create_obj_service(
         cls, auth: AuthSchema, redis: Redis, data: DictDataCreateSchema
-    ) -> dict:
+    ) -> DictDataOutSchema:
         """
         创建数据字典数据
 
@@ -499,12 +496,12 @@ class DictDataService:
         if exist_value_obj:
             raise CustomException(msg=f'创建失败，该字典类型下的字典键值"{data.dict_value}"已存在')
 
-        obj = await DictDataCRUD(auth).create_obj_crud(data=data)
+        obj = await DictDataCRUD(auth).create(data=data)
 
         redis_key = f"{RedisInitKeyConfig.SYSTEM_DICT.key}:{auth.user.tenant_id}:{data.dict_type}"
         try:
             # 获取当前字典类型的所有字典数据
-            dict_data_list = await DictDataCRUD(auth).get_obj_list_crud(
+            dict_data_list = await DictDataCRUD(auth).list(
                 search={"dict_type": data.dict_type}
             )
             dict_data = [
@@ -519,12 +516,12 @@ class DictDataService:
                 value=value,
                 expire=None,
             )
-            log.info(f"创建字典数据写入缓存成功: {obj}")
+            logger.info(f"创建字典数据写入缓存成功: {obj}")
         except Exception as e:
-            log.error(f"创建字典数据写入缓存失败: {e}")
+            logger.error(f"创建字典数据写入缓存失败: {e}")
             raise CustomException(msg=f"创建字典数据失败 {e}")
 
-        return DictDataOutSchema.model_validate(obj).model_dump()
+        return DictDataOutSchema.model_validate(obj)
 
     @classmethod
     async def update_obj_service(
@@ -533,7 +530,7 @@ class DictDataService:
         redis: Redis,
         id: int,
         data: DictDataUpdateSchema,
-    ) -> dict:
+    ) -> DictDataOutSchema:
         """
         更新数据字典数据
 
@@ -546,7 +543,7 @@ class DictDataService:
         返回:
         - Dict: 数据字典数据详情字典
         """
-        exist_obj = await DictDataCRUD(auth).get_obj_by_id_crud(id=id)
+        exist_obj = await DictDataCRUD(auth).get(id=id)
         if not exist_obj:
             raise CustomException(msg="更新失败，该字典数据不存在")
 
@@ -576,7 +573,7 @@ class DictDataService:
             if dict_type:
                 redis_key = f"{RedisInitKeyConfig.SYSTEM_DICT.key}:{auth.user.tenant_id}:{dict_type.dict_type}"
                 try:
-                    dict_data_list = await DictDataCRUD(auth).get_obj_list_crud(
+                    dict_data_list = await DictDataCRUD(auth).list(
                         search={"dict_type": dict_type.dict_type}
                     )
                     dict_data = [
@@ -591,13 +588,13 @@ class DictDataService:
                         expire=None,
                     )
                 except Exception as e:
-                    log.error(f"更新字典数据类型变更时刷新旧缓存失败: {e}")
+                    logger.error(f"更新字典数据类型变更时刷新旧缓存失败: {e}")
 
-        obj = await DictDataCRUD(auth).update_obj_crud(id=id, data=data)
+        obj = await DictDataCRUD(auth).update(id=id, data=data)
         redis_key = f"{RedisInitKeyConfig.SYSTEM_DICT.key}:{auth.user.tenant_id}:{data.dict_type}"
         try:
             # 获取当前字典类型的所有字典数据
-            dict_data_list = await DictDataCRUD(auth).get_obj_list_crud(
+            dict_data_list = await DictDataCRUD(auth).list(
                 search={"dict_type": data.dict_type}
             )
             dict_data = [
@@ -612,12 +609,12 @@ class DictDataService:
                 value=value,
                 expire=None,
             )
-            log.info(f"更新字典数据写入缓存成功: {obj}")
+            logger.info(f"更新字典数据写入缓存成功: {obj}")
         except Exception as e:
-            log.error(f"更新字典数据写入缓存失败: {e}")
+            logger.error(f"更新字典数据写入缓存失败: {e}")
             raise CustomException(msg=f"更新字典数据失败 {e}")
 
-        return DictDataOutSchema.model_validate(obj).model_dump()
+        return DictDataOutSchema.model_validate(obj)
 
     @classmethod
     async def delete_obj_service(cls, auth: AuthSchema, redis: Redis, ids: list[int]) -> None:
@@ -636,24 +633,22 @@ class DictDataService:
             if len(ids) < 1:
                 raise CustomException(msg="删除失败，删除对象不能为空")
 
-            # 首先检查是否包含系统默认数据
-            for id in ids:
-                exist_obj = await DictDataCRUD(auth).get_obj_by_id_crud(id=id)
-                if not exist_obj:
-                    raise CustomException(msg=f"{id} 删除失败，该字典数据不存在")
+            # 批量查询所有待删除项
+            existing = await DictDataCRUD(auth).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=f"{nid} 删除失败，该字典数据不存在")
+                exist_obj = existing_map[nid]
                 # 系统默认字典数据不允许删除
                 if exist_obj.is_default:
-                    raise CustomException(msg=f"删除失败，ID为{id}的系统默认字典数据不允许删除")
+                    raise CustomException(msg=f"删除失败，ID为{nid}的系统默认字典数据不允许删除")
 
-            # 获取所有需要清除的缓存键
-            dict_types_to_clear = set()
-            for id in ids:
-                exist_obj = await DictDataCRUD(auth).get_obj_by_id_crud(id=id)
-                if exist_obj:
-                    dict_types_to_clear.add(exist_obj.dict_type)
+            # 从批量查询结果中收集缓存键
+            dict_types_to_clear = {obj.dict_type for obj in existing}
 
             # 执行删除操作
-            await DictDataCRUD(auth).delete_obj_crud(ids=ids)
+            await DictDataCRUD(auth).delete(ids=ids)
 
             # 清除缓存
             for dict_type in dict_types_to_clear:
@@ -662,17 +657,17 @@ class DictDataService:
                         f"{RedisInitKeyConfig.SYSTEM_DICT.key}:{auth.user.tenant_id}:{dict_type}"
                     )
                     await RedisCURD(redis).delete(redis_key)
-                    log.info(f"清除字典缓存成功: {dict_type}")
+                    logger.info(f"清除字典缓存成功: {dict_type}")
                 except Exception as e:
-                    log.warning(f"清除字典缓存失败: {e}")
+                    logger.warning(f"清除字典缓存失败: {e}")
                     # 缓存清除失败不影响删除操作
 
-            log.info(f"删除字典数据成功，ID列表: {ids}")
+            logger.info(f"删除字典数据成功，ID列表: {ids}")
 
         except CustomException:
             raise
         except Exception as e:
-            log.error(f"删除字典数据失败: {e!s}")
+            logger.error(f"删除字典数据失败: {e!s}")
             raise CustomException(msg=f"删除字典数据失败: {e!s}")
 
     @classmethod
@@ -687,7 +682,7 @@ class DictDataService:
         返回:
         - None
         """
-        await DictDataCRUD(auth).set_obj_available_crud(ids=data.ids, status=data.status)
+        await DictDataCRUD(auth).set(ids=data.ids, status=data.status)
 
     @classmethod
     async def export_obj_service(cls, data_list: list[dict]) -> bytes:
@@ -721,13 +716,8 @@ class DictDataService:
         data = data_list.copy()
         for item in data:
             # 处理状态
-            item["status"] = "启用" if item.get("status") == "0" else "停用"
+            item["status"] = "启用" if item.get("status") == 0 else "停用"
             # 处理是否默认
             item["is_default"] = "是" if item.get("is_default") else "否"
-            item["creator"] = (
-                item.get("creator", {}).get("name", "未知")
-                if isinstance(item.get("creator"), dict)
-                else "未知"
-            )
 
         return ExcelUtil.export_list2excel(list_data=data, mapping_dict=mapping_dict)