Optimize the userinfo cache cleaning logic

backend/app/admin/api/v1/sys/__init__.py

@@ -17,7 +17,7 @@
 router.include_router(menu_router, prefix='/menus', tags=['系统菜单'])
 router.include_router(role_router, prefix='/roles', tags=['系统角色'])
 router.include_router(user_router, prefix='/users', tags=['系统用户'])
-router.include_router(data_rule_router, prefix='/data-rules', tags=['系统数据权限规则'])
+router.include_router(data_rule_router, prefix='/data-rules', tags=['系统数据规则'])
 router.include_router(token_router, prefix='/tokens', tags=['系统令牌'])
 router.include_router(upload_router, prefix='/upload', tags=['系统上传'])
 router.include_router(plugin_router, prefix='/plugin', tags=['系统插件'])

backend/app/admin/api/v1/sys/data_rule.py

@@ -2,7 +2,7 @@
 # -*- coding: utf-8 -*-
 from typing import Annotated
 
-from fastapi import APIRouter, Depends, Path, Query, Request
+from fastapi import APIRouter, Depends, Path, Query
 
 from backend.app.admin.schema.data_rule import CreateDataRuleParam, GetDataRuleDetail, UpdateDataRuleParam
 from backend.app.admin.service.data_rule_service import data_rule_service
@@ -16,13 +16,13 @@
 router = APIRouter()
 
 
-@router.get('/models', summary='获取支持过滤的数据库模型', dependencies=[DependsJwtAuth])
+@router.get('/models', summary='获取数据规则可用模型', dependencies=[DependsJwtAuth])
 async def get_data_rule_models() -> ResponseSchemaModel[list[str]]:
     models = await data_rule_service.get_models()
     return response_base.success(data=models)
 
 
-@router.get('/model/{model}/columns', summary='获取支持过滤的数据库模型列', dependencies=[DependsJwtAuth])
+@router.get('/model/{model}/columns', summary='获取数据规则可用模型列', dependencies=[DependsJwtAuth])
 async def get_data_rule_model_columns(
     model: Annotated[str, Path(description='模型名称')],
 ) -> ResponseSchemaModel[list[str]]:
@@ -36,7 +36,7 @@ async def get_all_data_rules() -> ResponseSchemaModel[list[GetDataRuleDetail]]:
     return response_base.success(data=data)
 
 
-@router.get('/{pk}', summary='获取数据权限规则详情', dependencies=[DependsJwtAuth])
+@router.get('/{pk}', summary='获取数据规则详情', dependencies=[DependsJwtAuth])
 async def get_data_rule(
     pk: Annotated[int, Path(description='数据规则 ID')],
 ) -> ResponseSchemaModel[GetDataRuleDetail]:
@@ -46,7 +46,7 @@ async def get_data_rule(
 
 @router.get(
     '',
-    summary='分页获取所有数据权限规则',
+    summary='分页获取所有数据规则',
     dependencies=[
         DependsJwtAuth,
         DependsPagination,
@@ -62,7 +62,7 @@ async def get_pagination_data_rules(
 
 @router.post(
     '',
-    summary='创建数据权限规则',
+    summary='创建数据规则',
     dependencies=[
         Depends(RequestPermission('data:rule:add')),
         DependsRBAC,
@@ -75,7 +75,7 @@ async def create_data_rule(obj: CreateDataRuleParam) -> ResponseModel:
 
 @router.put(
     '/{pk}',
-    summary='更新数据权限规则',
+    summary='更新数据规则',
     dependencies=[
         Depends(RequestPermission('data:rule:edit')),
         DependsRBAC,
@@ -92,16 +92,14 @@ async def update_data_rule(
 
 @router.delete(
     '',
-    summary='批量删除数据权限规则',
+    summary='批量删除数据规则',
     dependencies=[
         Depends(RequestPermission('data:rule:del')),
         DependsRBAC,
     ],
 )
-async def delete_data_rule(
-    request: Request, pk: Annotated[list[int], Query(description='数据规则 ID 列表')]
-) -> ResponseModel:
-    count = await data_rule_service.delete(request=request, pk=pk)
+async def delete_data_rule(pk: Annotated[list[int], Query(description='数据规则 ID 列表')]) -> ResponseModel:
+    count = await data_rule_service.delete(pk=pk)
     if count > 0:
         return response_base.success()
     return response_base.fail()

backend/app/admin/api/v1/sys/dept.py

@@ -2,7 +2,7 @@
 # -*- coding: utf-8 -*-
 from typing import Annotated, Any
 
-from fastapi import APIRouter, Depends, Path, Query, Request
+from fastapi import APIRouter, Depends, Path, Query
 
 from backend.app.admin.schema.dept import CreateDeptParam, GetDeptDetail, UpdateDeptParam
 from backend.app.admin.service.dept_service import dept_service
@@ -67,8 +67,8 @@ async def update_dept(pk: Annotated[int, Path(description='部门 ID')], obj: Up
         DependsRBAC,
     ],
 )
-async def delete_dept(request: Request, pk: Annotated[int, Path(description='部门 ID')]) -> ResponseModel:
-    count = await dept_service.delete(request=request, pk=pk)
+async def delete_dept(pk: Annotated[int, Path(description='部门 ID')]) -> ResponseModel:
+    count = await dept_service.delete(pk=pk)
     if count > 0:
         return response_base.success()
     return response_base.fail()

backend/app/admin/api/v1/sys/menu.py

@@ -71,8 +71,8 @@ async def update_menu(pk: Annotated[int, Path(description='菜单 ID')], obj: Up
         DependsRBAC,
     ],
 )
-async def delete_menu(request: Request, pk: Annotated[int, Path(description='菜单 ID 列表')]) -> ResponseModel:
-    count = await menu_service.delete(request=request, pk=pk)
+async def delete_menu(pk: Annotated[int, Path(description='菜单 ID 列表')]) -> ResponseModel:
+    count = await menu_service.delete(pk=pk)
     if count > 0:
         return response_base.success()
     return response_base.fail()

backend/app/admin/api/v1/sys/role.py

@@ -2,7 +2,7 @@
 # -*- coding: utf-8 -*-
 from typing import Annotated, Any
 
-from fastapi import APIRouter, Depends, Path, Query, Request
+from fastapi import APIRouter, Depends, Path, Query
 
 from backend.app.admin.schema.role import (
     CreateRoleParam,
@@ -116,26 +116,26 @@ async def update_role(pk: Annotated[int, Path(description='角色 ID')], obj: Up
     ],
 )
 async def update_role_menus(
-    request: Request, pk: Annotated[int, Path(description='角色 ID')], menu_ids: UpdateRoleMenuParam
+    pk: Annotated[int, Path(description='角色 ID')], menu_ids: UpdateRoleMenuParam
 ) -> ResponseModel:
-    count = await role_service.update_role_menu(request=request, pk=pk, menu_ids=menu_ids)
+    count = await role_service.update_role_menu(pk=pk, menu_ids=menu_ids)
     if count > 0:
         return response_base.success()
     return response_base.fail()
 
 
 @router.put(
     '/{pk}/rule',
-    summary='更新角色数据权限规则',
+    summary='更新角色数据规则',
     dependencies=[
         Depends(RequestPermission('sys:role:rule:edit')),
         DependsRBAC,
     ],
 )
 async def update_role_rules(
-    request: Request, pk: Annotated[int, Path(description='角色 ID')], rule_ids: UpdateRoleRuleParam
+    pk: Annotated[int, Path(description='角色 ID')], rule_ids: UpdateRoleRuleParam
 ) -> ResponseModel:
-    count = await role_service.update_role_rule(request=request, pk=pk, rule_ids=rule_ids)
+    count = await role_service.update_role_rule(pk=pk, rule_ids=rule_ids)
     if count > 0:
         return response_base.success()
     return response_base.fail()
@@ -149,8 +149,8 @@ async def update_role_rules(
         DependsRBAC,
     ],
 )
-async def delete_role(request: Request, pk: Annotated[list[int], Query(description='角色 ID 列表')]) -> ResponseModel:
-    count = await role_service.delete(request=request, pk=pk)
+async def delete_role(pk: Annotated[list[int], Query(description='角色 ID 列表')]) -> ResponseModel:
+    count = await role_service.delete(pk=pk)
     if count > 0:
         return response_base.success()
     return response_base.fail()

backend/app/admin/crud/crud_data_rule.py

@@ -12,7 +12,7 @@
 
 
 class CRUDDataRule(CRUDPlus[DataRule]):
-    """数据权限规则数据库操作类"""
+    """数据规则数据库操作类"""
 
     async def get(self, db: AsyncSession, pk: int) -> DataRule | None:
         """

backend/app/admin/model/data_rule.py

@@ -15,7 +15,7 @@
 
 
 class DataRule(Base):
-    """数据权限规则表"""
+    """数据规则表"""
 
     __tablename__ = 'sys_data_rule'
 

backend/app/admin/model/m2m.py

@@ -30,6 +30,6 @@
         Integer,
         ForeignKey('sys_data_rule.id', ondelete='CASCADE'),
         primary_key=True,
-        comment='数据权限规则ID',
+        comment='数据规则ID',
     ),
 )

backend/app/admin/model/role.py

@@ -34,5 +34,5 @@ class Role(Base):
     # 角色菜单多对多
     menus: Mapped[list[Menu]] = relationship(init=False, secondary=sys_role_menu, back_populates='roles')
 
-    # 角色数据权限规则多对多
+    # 角色数据规则多对多
     rules: Mapped[list[DataRule]] = relationship(init=False, secondary=sys_role_data_rule, back_populates='roles')

backend/app/admin/service/data_rule_service.py

@@ -2,7 +2,6 @@
 # -*- coding: utf-8 -*-
 from typing import Sequence
 
-from fastapi import Request
 from sqlalchemy import Select
 
 from backend.app.admin.crud.crud_data_rule import data_rule_dao
@@ -17,7 +16,7 @@
 
 
 class DataRuleService:
-    """数据权限规则服务类"""
+    """数据规则服务类"""
 
     @staticmethod
     async def get(*, pk: int) -> DataRule:
@@ -50,19 +49,19 @@ async def get_role_rules(*, pk: int) -> list[int]:
 
     @staticmethod
     async def get_models() -> list[str]:
-        """获取所有数据模型"""
+        """获取所有数据规则可用模型"""
         return list(settings.DATA_PERMISSION_MODELS.keys())
 
     @staticmethod
     async def get_columns(model: str) -> list[str]:
         """
-        获取数据模型的字段列表
+        获取数据规则可用模型的字段列表
 
         :param model: 模型名称
         :return:
         """
         if model not in settings.DATA_PERMISSION_MODELS:
-            raise errors.NotFoundError(msg='数据模型不存在')
+            raise errors.NotFoundError(msg='数据规则可用模型不存在')
         model_ins = dynamic_import_data_model(settings.DATA_PERMISSION_MODELS[model])
         model_columns = [
             key for key in model_ins.__table__.columns.keys() if key not in settings.DATA_PERMISSION_COLUMN_EXCLUDE
@@ -97,7 +96,7 @@ async def create(*, obj: CreateDataRuleParam) -> None:
         async with async_db_session.begin() as db:
             data_rule = await data_rule_dao.get_by_name(db, obj.name)
             if data_rule:
-                raise errors.ForbiddenError(msg='数据权限规则已存在')
+                raise errors.ForbiddenError(msg='数据规则已存在')
             await data_rule_dao.create(db, obj)
 
     @staticmethod
@@ -112,22 +111,29 @@ async def update(*, pk: int, obj: UpdateDataRuleParam) -> int:
         async with async_db_session.begin() as db:
             data_rule = await data_rule_dao.get(db, pk)
             if not data_rule:
-                raise errors.NotFoundError(msg='数据权限规则不存在')
+                raise errors.NotFoundError(msg='数据规则不存在')
             count = await data_rule_dao.update(db, pk, obj)
+            for role in await data_rule.awaitable_attrs.roles:
+                for user in await role.awaitable_attrs.users:
+                    await redis_client.delete(f'{settings.JWT_USER_REDIS_PREFIX}:{user.id}')
             return count
 
     @staticmethod
-    async def delete(*, request: Request, pk: list[int]) -> int:
+    async def delete(*, pk: list[int]) -> int:
         """
         删除数据规则
 
-        :param request: FastAPI 请求对象
         :param pk: 规则 ID 列表
         :return:
         """
         async with async_db_session.begin() as db:
             count = await data_rule_dao.delete(db, pk)
-            await redis_client.delete(f'{settings.JWT_USER_REDIS_PREFIX}:{request.user.id}')
+            for _pk in pk:
+                data_rule = await data_rule_dao.get(db, _pk)
+                if data_rule:
+                    for role in await data_rule.awaitable_attrs.roles:
+                        for user in await role.awaitable_attrs.users:
+                            await redis_client.delete(f'{settings.JWT_USER_REDIS_PREFIX}:{user.id}')
             return count
 
 

backend/app/admin/service/dept_service.py

@@ -2,8 +2,6 @@
 # -*- coding: utf-8 -*-
 from typing import Any
 
-from fastapi import Request
-
 from backend.app.admin.crud.crud_dept import dept_dao
 from backend.app.admin.model import Dept
 from backend.app.admin.schema.dept import CreateDeptParam, UpdateDeptParam
@@ -93,24 +91,23 @@ async def update(*, pk: int, obj: UpdateDeptParam) -> int:
             return count
 
     @staticmethod
-    async def delete(*, request: Request, pk: int) -> int:
+    async def delete(*, pk: int) -> int:
         """
         删除部门
 
-        :param request: FastAPI 请求对象
         :param pk: 部门 ID
         :return:
         """
         async with async_db_session.begin() as db:
             dept = await dept_dao.get_with_relation(db, pk)
-            dept_user = dept.users
-            if dept_user:
+            if dept.users:
                 raise errors.ForbiddenError(msg='部门下存在用户，无法删除')
             children = await dept_dao.get_children(db, pk)
             if children:
                 raise errors.ForbiddenError(msg='部门下存在子部门，无法删除')
             count = await dept_dao.delete(db, pk)
-            await redis_client.delete(f'{settings.JWT_USER_REDIS_PREFIX}:{request.user.id}')
+            for user in dept.users:
+                await redis_client.delete(f'{settings.JWT_USER_REDIS_PREFIX}:{user.id}')
             return count
 
 

backend/app/admin/service/menu_service.py

@@ -123,23 +123,29 @@ async def update(*, pk: int, obj: UpdateMenuParam) -> int:
             if obj.parent_id == menu.id:
                 raise errors.ForbiddenError(msg='禁止关联自身为父级')
             count = await menu_dao.update(db, pk, obj)
+            for role in await menu.awaitable_attrs.roles:
+                for user in await role.awaitable_attrs.users:
+                    await redis_client.delete(f'{settings.JWT_USER_REDIS_PREFIX}:{user.id}')
             return count
 
     @staticmethod
-    async def delete(*, request: Request, pk: int) -> int:
+    async def delete(*, pk: int) -> int:
         """
         删除菜单
 
-        :param request: FastAPI 请求对象
         :param pk: 菜单 ID
         :return:
         """
         async with async_db_session.begin() as db:
             children = await menu_dao.get_children(db, pk)
             if children:
                 raise errors.ForbiddenError(msg='菜单下存在子菜单，无法删除')
+            menu = await menu_dao.get(db, pk)
             count = await menu_dao.delete(db, pk)
-            await redis_client.delete(f'{settings.JWT_USER_REDIS_PREFIX}:{request.user.id}')
+            if menu:
+                for role in await menu.awaitable_attrs.roles:
+                    for user in await role.awaitable_attrs.users:
+                        await redis_client.delete(f'{settings.JWT_USER_REDIS_PREFIX}:{user.id}')
             return count