Optimize more

Author: wu-clan

backend/app/admin/crud/crud_user.py

@@ -193,8 +193,7 @@ async def get_list(
             )
             .order_by(desc(self.model.join_time))
         )
-
-        # 构建过滤条件
+        
         filters = []
         if dept:
             filters.append(self.model.dept_id == dept)
@@ -204,8 +203,7 @@ async def get_list(
             filters.append(self.model.phone.like(f'%{phone}%'))
         if status is not None:
             filters.append(self.model.status == status)
-
-        # 应用过滤条件
+            
         if filters:
             stmt = stmt.where(and_(*filters))
 
@@ -257,44 +255,44 @@ async def get_multi_login(self, db: AsyncSession, user_id: int) -> bool:
 
     async def set_super(self, db: AsyncSession, user_id: int, is_super: bool) -> int:
         """
-        设置用户的超级管理员状态
+        设置用户超级管理员状态
 
         :param db: 数据库会话
         :param user_id: 用户 ID
-        :param is_super: 是否为超级管理员
+        :param is_super: 是否超级管理员
         :return:
         """
         return await self.update_model(db, user_id, {'is_superuser': is_super})
 
     async def set_staff(self, db: AsyncSession, user_id: int, is_staff: bool) -> int:
         """
-        设置用户的后台登录权限
+        设置用户后台登录状态
 
         :param db: 数据库会话
         :param user_id: 用户 ID
-        :param is_staff: 是否允许登录后台
+        :param is_staff: 是否可登录后台
         :return:
         """
         return await self.update_model(db, user_id, {'is_staff': is_staff})
 
-    async def set_status(self, db: AsyncSession, user_id: int, status: bool) -> int:
+    async def set_status(self, db: AsyncSession, user_id: int, status: int) -> int:
         """
-        设置用户的启用状态
+        设置用户状态
 
         :param db: 数据库会话
         :param user_id: 用户 ID
-        :param status: 是否启用用户
+        :param status: 状态
         :return:
         """
         return await self.update_model(db, user_id, {'status': status})
 
     async def set_multi_login(self, db: AsyncSession, user_id: int, multi_login: bool) -> int:
         """
-        设置用户的多点登录权限
+        设置用户多端登录状态
 
         :param db: 数据库会话
         :param user_id: 用户 ID
-        :param multi_login: 是否允许多点登录
+        :param multi_login: 是否允许多端登录
         :return:
         """
         return await self.update_model(db, user_id, {'is_multi_login': multi_login})
@@ -303,7 +301,7 @@ async def get_with_relation(
         self, db: AsyncSession, *, user_id: int | None = None, username: str | None = None
     ) -> User | None:
         """
-        获取用户及关联数据
+        获取用户关联信息
 
         :param db: 数据库会话
         :param user_id: 用户 ID
@@ -317,12 +315,18 @@ async def get_with_relation(
                 selectinload(Role.rules),
             ),
         )
+        
         filters = []
         if user_id:
             filters.append(self.model.id == user_id)
         if username:
             filters.append(self.model.username == username)
-        user = await db.execute(stmt.where(*filters))
+            
+        if filters:
+            stmt = stmt.where(and_(*filters))
+    
+        user = await db.execute(stmt)
+            
         return user.scalars().first()
 
 

backend/app/admin/model/user.py

@@ -5,7 +5,7 @@
 from datetime import datetime
 from typing import TYPE_CHECKING
 
-from sqlalchemy import VARBINARY, Boolean, DateTime, ForeignKey, String
+from sqlalchemy import VARBINARY, Boolean, DateTime, ForeignKey, String, Index
 from sqlalchemy.dialects.postgresql import BYTEA, INTEGER
 from sqlalchemy.orm import Mapped, mapped_column, relationship
 
@@ -38,7 +38,7 @@ class User(Base):
     is_staff: Mapped[bool] = mapped_column(
         Boolean().with_variant(INTEGER, 'postgresql'), default=False, comment='后台管理登陆(0否 1是)'
     )
-    status: Mapped[int] = mapped_column(default=1, comment='用户账号状态(0停用 1正常)')
+    status: Mapped[int] = mapped_column(default=1, index=True, comment='用户账号状态(0停用 1正常)')
     is_multi_login: Mapped[bool] = mapped_column(
         Boolean().with_variant(INTEGER, 'postgresql'), default=False, comment='是否重复登陆(0否 1是)'
     )

backend/app/admin/service/user_service.py

@@ -93,11 +93,11 @@ async def pwd_reset(*, request: Request, obj: ResetPasswordParam) -> int:
         """
         async with async_db_session.begin() as db:
             user = await user_dao.get(db, request.user.id)
+            if not user:
+                raise errors.NotFoundError(msg='用户不存在')
             if not password_verify(obj.old_password, user.password):
                 raise errors.ForbiddenError(msg='原密码错误')
-            np1 = obj.new_password
-            np2 = obj.confirm_password
-            if np1 != np2:
+            if obj.new_password != obj.confirm_password:
                 raise errors.ForbiddenError(msg='密码输入不一致')
             new_pwd = get_hash_password(obj.new_password, user.salt)
             count = await user_dao.reset_password(db, request.user.id, new_pwd)
@@ -135,9 +135,8 @@ async def update(*, request: Request, username: str, obj: UpdateUserParam) -> in
         :return:
         """
         async with async_db_session.begin() as db:
-            if not request.user.is_superuser:
-                if request.user.username != username:
-                    raise errors.ForbiddenError(msg='你只能修改自己的信息')
+            if not request.user.is_superuser and request.user.username != username:
+                raise errors.ForbiddenError(msg='你只能修改自己的信息')
             input_user = await user_dao.get_with_relation(db, username=username)
             if not input_user:
                 raise errors.NotFoundError(msg='用户不存在')
@@ -168,9 +167,8 @@ async def update_roles(*, request: Request, username: str, obj: UpdateUserRolePa
         :return:
         """
         async with async_db_session.begin() as db:
-            if not request.user.is_superuser:
-                if request.user.username != username:
-                    raise errors.AuthorizationError
+            if not request.user.is_superuser and request.user.username != username:
+                raise errors.AuthorizationError
             input_user = await user_dao.get_with_relation(db, username=username)
             if not input_user:
                 raise errors.NotFoundError(msg='用户不存在')
@@ -192,9 +190,8 @@ async def update_avatar(*, request: Request, username: str, avatar: AvatarParam)
         :return:
         """
         async with async_db_session.begin() as db:
-            if not request.user.is_superuser:
-                if request.user.username != username:
-                    raise errors.AuthorizationError
+            if not request.user.is_superuser and request.user.username != username:
+                raise errors.AuthorizationError
             input_user = await user_dao.get_by_username(db, username)
             if not input_user:
                 raise errors.NotFoundError(msg='用户不存在')
@@ -226,15 +223,15 @@ async def update_permission(*, request: Request, pk: int) -> int:
         """
         async with async_db_session.begin() as db:
             superuser_verify(request)
-            if not await user_dao.get(db, pk):
+            user = await user_dao.get(db, pk)
+            if not user:
                 raise errors.NotFoundError(msg='用户不存在')
-            else:
-                if pk == request.user.id:
-                    raise errors.ForbiddenError(msg='非法操作')
-                super_status = await user_dao.get_super(db, pk)
-                count = await user_dao.set_super(db, pk, False if super_status else True)
-                await redis_client.delete(f'{settings.JWT_USER_REDIS_PREFIX}:{pk}')
-                return count
+            if pk == request.user.id:
+                raise errors.ForbiddenError(msg='非法操作')
+            super_status = await user_dao.get_super(db, pk)
+            count = await user_dao.set_super(db, pk, not super_status)
+            await redis_client.delete(f'{settings.JWT_USER_REDIS_PREFIX}:{pk}')
+            return count
 
     @staticmethod
     async def update_staff(*, request: Request, pk: int) -> int:
@@ -247,15 +244,15 @@ async def update_staff(*, request: Request, pk: int) -> int:
         """
         async with async_db_session.begin() as db:
             superuser_verify(request)
-            if not await user_dao.get(db, pk):
+            user = await user_dao.get(db, pk)
+            if not user:
                 raise errors.NotFoundError(msg='用户不存在')
-            else:
-                if pk == request.user.id:
-                    raise errors.ForbiddenError(msg='非法操作')
-                staff_status = await user_dao.get_staff(db, pk)
-                count = await user_dao.set_staff(db, pk, False if staff_status else True)
-                await redis_client.delete(f'{settings.JWT_USER_REDIS_PREFIX}:{pk}')
-                return count
+            if pk == request.user.id:
+                raise errors.ForbiddenError(msg='非法操作')
+            staff_status = await user_dao.get_staff(db, pk)
+            count = await user_dao.set_staff(db, pk, not staff_status)
+            await redis_client.delete(f'{settings.JWT_USER_REDIS_PREFIX}:{pk}')
+            return count
 
     @staticmethod
     async def update_status(*, request: Request, pk: int) -> int:
@@ -268,15 +265,15 @@ async def update_status(*, request: Request, pk: int) -> int:
         """
         async with async_db_session.begin() as db:
             superuser_verify(request)
-            if not await user_dao.get(db, pk):
+            user = await user_dao.get(db, pk)
+            if not user:
                 raise errors.NotFoundError(msg='用户不存在')
-            else:
-                if pk == request.user.id:
-                    raise errors.ForbiddenError(msg='非法操作')
-                status = await user_dao.get_status(db, pk)
-                count = await user_dao.set_status(db, pk, False if status else True)
-                await redis_client.delete(f'{settings.JWT_USER_REDIS_PREFIX}:{pk}')
-                return count
+            if pk == request.user.id:
+                raise errors.ForbiddenError(msg='非法操作')
+            status = await user_dao.get_status(db, pk)
+            count = await user_dao.set_status(db, pk, 0 if status == 1 else 1)
+            await redis_client.delete(f'{settings.JWT_USER_REDIS_PREFIX}:{pk}')
+            return count
 
     @staticmethod
     async def update_multi_login(*, request: Request, pk: int) -> int:
@@ -289,37 +286,38 @@ async def update_multi_login(*, request: Request, pk: int) -> int:
         """
         async with async_db_session.begin() as db:
             superuser_verify(request)
-            if not await user_dao.get(db, pk):
+            user = await user_dao.get(db, pk)
+            if not user:
                 raise errors.NotFoundError(msg='用户不存在')
+            user_id = request.user.id
+            multi_login = await user_dao.get_multi_login(db, pk) if pk != user_id else request.user.is_multi_login
+            count = await user_dao.set_multi_login(db, pk, not multi_login)
+            # 删除当前用户缓存
+            await redis_client.delete(f'{settings.JWT_USER_REDIS_PREFIX}:{request.user.id}')
+            token = get_token(request)
+            token_payload = jwt_decode(token)
+            latest_multi_login = await user_dao.get_multi_login(db, pk)
+            # 超级用户修改自身时，除当前 token 外，其他 token 失效
+            if pk == user_id:
+                if not latest_multi_login:
+                    key_prefix = f'{settings.TOKEN_REDIS_PREFIX}:{pk}'
+                    await redis_client.delete_prefix(
+                        key_prefix, exclude=f'{key_prefix}:{token_payload.session_uuid}'
+                    )
+                    refresh_token = request.cookies.get(settings.COOKIE_REFRESH_TOKEN_KEY)
+                    if refresh_token:
+                        key_prefix = f'{settings.TOKEN_REFRESH_REDIS_PREFIX}:{pk}'
+                        await redis_client.delete_prefix(key_prefix, exclude=f'{key_prefix}:{refresh_token}')
+            # 超级用户修改他人时，其他 token 将全部失效
             else:
-                user_id = request.user.id
-                multi_login = await user_dao.get_multi_login(db, pk) if pk != user_id else request.user.is_multi_login
-                count = await user_dao.set_multi_login(db, pk, False if multi_login else True)
-                await redis_client.delete(f'{settings.JWT_USER_REDIS_PREFIX}:{request.user.id}')
-                token = get_token(request)
-                token_payload = jwt_decode(token)
-                latest_multi_login = await user_dao.get_multi_login(db, pk)
-                # 超级用户修改自身时，除当前token外，其他token失效
-                if pk == user_id:
-                    if not latest_multi_login:
-                        key_prefix = f'{settings.TOKEN_REDIS_PREFIX}:{pk}'
-                        await redis_client.delete_prefix(
-                            key_prefix, exclude=f'{key_prefix}:{token_payload.session_uuid}'
-                        )
-                        refresh_token = request.cookies.get(settings.COOKIE_REFRESH_TOKEN_KEY)
-                        if refresh_token:
-                            key_prefix = f'{settings.TOKEN_REFRESH_REDIS_PREFIX}:{pk}'
-                            await redis_client.delete_prefix(key_prefix, exclude=f'{key_prefix}:{refresh_token}')
-                # 超级用户修改他人时，其他token将全部失效
-                else:
-                    if not latest_multi_login:
-                        key_prefix = [f'{settings.TOKEN_REDIS_PREFIX}:{pk}']
-                        refresh_token = request.cookies.get(settings.COOKIE_REFRESH_TOKEN_KEY)
-                        if refresh_token:
-                            key_prefix.append(f'{settings.TOKEN_REFRESH_REDIS_PREFIX}:{pk}')
-                        for prefix in key_prefix:
-                            await redis_client.delete_prefix(prefix)
-                return count
+                if not latest_multi_login:
+                    key_prefix = [f'{settings.TOKEN_REDIS_PREFIX}:{pk}']
+                    refresh_token = request.cookies.get(settings.COOKIE_REFRESH_TOKEN_KEY)
+                    if refresh_token:
+                        key_prefix.append(f'{settings.TOKEN_REFRESH_REDIS_PREFIX}:{pk}')
+                    for prefix in key_prefix:
+                        await redis_client.delete_prefix(prefix)
+            return count
 
     @staticmethod
     async def delete(*, username: str) -> int:
@@ -330,13 +328,13 @@ async def delete(*, username: str) -> int:
         :return:
         """
         async with async_db_session.begin() as db:
-            input_user = await user_dao.get_by_username(db, username)
-            if not input_user:
+            user = await user_dao.get_by_username(db, username)
+            if not user:
                 raise errors.NotFoundError(msg='用户不存在')
-            count = await user_dao.delete(db, input_user.id)
+            count = await user_dao.delete(db, user.id)
             key_prefix = [
-                f'{settings.TOKEN_REDIS_PREFIX}:{input_user.id}',
-                f'{settings.TOKEN_REFRESH_REDIS_PREFIX}:{input_user.id}',
+                f'{settings.TOKEN_REDIS_PREFIX}:{user.id}',
+                f'{settings.TOKEN_REFRESH_REDIS_PREFIX}:{user.id}',
             ]
             for key in key_prefix:
                 await redis_client.delete_prefix(key)