style: 使用ruff格式化角色管理模块，优化导入

ruoyi-fastapi-backend/module_admin/controller/role_controller.py

@@ -1,26 +1,35 @@
-from fastapi import APIRouter, Request
+from datetime import datetime
-from fastapi import Depends
+from fastapi import APIRouter, Depends, Request
 from pydantic_validation_decorator import ValidateFields
+from sqlalchemy.ext.asyncio import AsyncSession
+from config.enums import BusinessType
 from config.get_db import get_db
-from module_admin.service.login_service import LoginService, CurrentUserModel
-from module_admin.service.role_service import *
-from module_admin.service.dept_service import DeptService, DeptModel
-from module_admin.service.user_service import UserService, UserRoleQueryModel, UserRolePageQueryModel, CrudUserRoleModel
-from module_admin.aspect.interface_auth import CheckUserInterfaceAuth
-from module_admin.aspect.data_scope import GetDataScope
 from module_admin.annotation.log_annotation import log_decorator
-from config.enums import BusinessType
+from module_admin.aspect.data_scope import GetDataScope
-from utils.response_util import *
+from module_admin.aspect.interface_auth import CheckUserInterfaceAuth
-from utils.log_util import *
+from module_admin.entity.vo.dept_vo import DeptModel
-from utils.page_util import PageResponseModel
+from module_admin.entity.vo.role_vo import AddRoleModel, DeleteRoleModel, RoleModel, RolePageQueryModel
+from module_admin.entity.vo.user_vo import CrudUserRoleModel, CurrentUserModel, UserRolePageQueryModel
+from module_admin.service.dept_service import DeptService
+from module_admin.service.login_service import LoginService
+from module_admin.service.role_service import RoleService
+from module_admin.service.user_service import UserService
 from utils.common_util import bytes2file_response
+from utils.log_util import logger
+from utils.page_util import PageResponseModel
+from utils.response_util import ResponseUtil
 
 
 roleController = APIRouter(prefix='/system/role', dependencies=[Depends(LoginService.get_current_user)])
 
 
-@roleController.get("/deptTree/{role_id}", dependencies=[Depends(CheckUserInterfaceAuth('system:role:query'))])
+@roleController.get('/deptTree/{role_id}', dependencies=[Depends(CheckUserInterfaceAuth('system:role:query'))])
-async def get_system_role_dept_tree(request: Request, role_id: int, query_db: AsyncSession = Depends(get_db), data_scope_sql: str = Depends(GetDataScope('SysDept'))):
+async def get_system_role_dept_tree(
+    request: Request,
+    role_id: int,
+    query_db: AsyncSession = Depends(get_db),
+    data_scope_sql: str = Depends(GetDataScope('SysDept')),
+):
     dept_query_result = await DeptService.get_dept_tree_services(query_db, DeptModel(**{}), data_scope_sql)
     role_dept_query_result = await RoleService.get_role_dept_tree_services(query_db, role_id)
     role_dept_query_result.depts = dept_query_result
@@ -29,18 +38,32 @@ async def get_system_role_dept_tree(request: Request, role_id: int, query_db: As
     return ResponseUtil.success(model_content=role_dept_query_result)
 
 
-@roleController.get("/list", response_model=PageResponseModel, dependencies=[Depends(CheckUserInterfaceAuth('system:role:list'))])
+@roleController.get(
-async def get_system_role_list(request: Request, role_page_query: RolePageQueryModel = Depends(RolePageQueryModel.as_query), query_db: AsyncSession = Depends(get_db), data_scope_sql: str = Depends(GetDataScope('SysDept'))):
+    '/list', response_model=PageResponseModel, dependencies=[Depends(CheckUserInterfaceAuth('system:role:list'))]
-    role_page_query_result = await RoleService.get_role_list_services(query_db, role_page_query, data_scope_sql, is_page=True)
+)
+async def get_system_role_list(
+    request: Request,
+    role_page_query: RolePageQueryModel = Depends(RolePageQueryModel.as_query),
+    query_db: AsyncSession = Depends(get_db),
+    data_scope_sql: str = Depends(GetDataScope('SysDept')),
+):
+    role_page_query_result = await RoleService.get_role_list_services(
+        query_db, role_page_query, data_scope_sql, is_page=True
+    )
     logger.info('获取成功')
 
     return ResponseUtil.success(model_content=role_page_query_result)
 
 
-@roleController.post("", dependencies=[Depends(CheckUserInterfaceAuth('system:role:add'))])
+@roleController.post('', dependencies=[Depends(CheckUserInterfaceAuth('system:role:add'))])
 @ValidateFields(validate_model='add_role')
 @log_decorator(title='角色管理', business_type=BusinessType.INSERT)
-async def add_system_role(request: Request, add_role: AddRoleModel, query_db: AsyncSession = Depends(get_db), current_user: CurrentUserModel = Depends(LoginService.get_current_user)):
+async def add_system_role(
+    request: Request,
+    add_role: AddRoleModel,
+    query_db: AsyncSession = Depends(get_db),
+    current_user: CurrentUserModel = Depends(LoginService.get_current_user),
+):
     add_role.create_by = current_user.user.user_name
     add_role.create_time = datetime.now()
     add_role.update_by = current_user.user.user_name
@@ -51,10 +74,16 @@ async def add_system_role(request: Request, add_role: AddRoleModel, query_db: As
     return ResponseUtil.success(msg=add_role_result.message)
 
 
-@roleController.put("", dependencies=[Depends(CheckUserInterfaceAuth('system:role:edit'))])
+@roleController.put('', dependencies=[Depends(CheckUserInterfaceAuth('system:role:edit'))])
 @ValidateFields(validate_model='edit_role')
 @log_decorator(title='角色管理', business_type=BusinessType.UPDATE)
-async def edit_system_role(request: Request, edit_role: AddRoleModel, query_db: AsyncSession = Depends(get_db), current_user: CurrentUserModel = Depends(LoginService.get_current_user), data_scope_sql: str = Depends(GetDataScope('SysDept'))):
+async def edit_system_role(
+    request: Request,
+    edit_role: AddRoleModel,
+    query_db: AsyncSession = Depends(get_db),
+    current_user: CurrentUserModel = Depends(LoginService.get_current_user),
+    data_scope_sql: str = Depends(GetDataScope('SysDept')),
+):
     await RoleService.check_role_allowed_services(edit_role)
     if not current_user.user.admin:
         await RoleService.check_role_data_scope_services(query_db, str(edit_role.role_id), data_scope_sql)
@@ -66,9 +95,15 @@ async def edit_system_role(request: Request, edit_role: AddRoleModel, query_db:
     return ResponseUtil.success(msg=edit_role_result.message)
 
 
-@roleController.put("/dataScope", dependencies=[Depends(CheckUserInterfaceAuth('system:role:edit'))])
+@roleController.put('/dataScope', dependencies=[Depends(CheckUserInterfaceAuth('system:role:edit'))])
 @log_decorator(title='角色管理', business_type=BusinessType.GRANT)
-async def edit_system_role_datascope(request: Request, role_data_scope: AddRoleModel, query_db: AsyncSession = Depends(get_db), current_user: CurrentUserModel = Depends(LoginService.get_current_user), data_scope_sql: str = Depends(GetDataScope('SysDept'))):
+async def edit_system_role_datascope(
+    request: Request,
+    role_data_scope: AddRoleModel,
+    query_db: AsyncSession = Depends(get_db),
+    current_user: CurrentUserModel = Depends(LoginService.get_current_user),
+    data_scope_sql: str = Depends(GetDataScope('SysDept')),
+):
     await RoleService.check_role_allowed_services(role_data_scope)
     if not current_user.user.admin:
         await RoleService.check_role_data_scope_services(query_db, str(role_data_scope.role_id), data_scope_sql)
@@ -78,7 +113,7 @@ async def edit_system_role_datascope(request: Request, role_data_scope: AddRoleM
         deptIds=role_data_scope.dept_ids,
         deptCheckStrictly=role_data_scope.dept_check_strictly,
         updateBy=current_user.user.user_name,
-        updateTime=datetime.now()
+        updateTime=datetime.now(),
     )
     role_data_scope_result = await RoleService.role_datascope_services(query_db, edit_role)
     logger.info(role_data_scope_result.message)
@@ -86,27 +121,37 @@ async def edit_system_role_datascope(request: Request, role_data_scope: AddRoleM
     return ResponseUtil.success(msg=role_data_scope_result.message)
 
 
-@roleController.delete("/{role_ids}", dependencies=[Depends(CheckUserInterfaceAuth('system:role:remove'))])
+@roleController.delete('/{role_ids}', dependencies=[Depends(CheckUserInterfaceAuth('system:role:remove'))])
 @log_decorator(title='角色管理', business_type=BusinessType.DELETE)
-async def delete_system_role(request: Request, role_ids: str, query_db: AsyncSession = Depends(get_db), current_user: CurrentUserModel = Depends(LoginService.get_current_user), data_scope_sql: str = Depends(GetDataScope('SysDept'))):
+async def delete_system_role(
+    request: Request,
+    role_ids: str,
+    query_db: AsyncSession = Depends(get_db),
+    current_user: CurrentUserModel = Depends(LoginService.get_current_user),
+    data_scope_sql: str = Depends(GetDataScope('SysDept')),
+):
     role_id_list = role_ids.split(',')
     for role_id in role_id_list:
         await RoleService.check_role_allowed_services(RoleModel(roleId=int(role_id)))
         if not current_user.user.admin:
             await RoleService.check_role_data_scope_services(query_db, role_id, data_scope_sql)
-    delete_role = DeleteRoleModel(
+    delete_role = DeleteRoleModel(roleIds=role_ids, updateBy=current_user.user.user_name, updateTime=datetime.now())
-        roleIds=role_ids,
-        updateBy=current_user.user.user_name,
-        updateTime=datetime.now()
-    )
     delete_role_result = await RoleService.delete_role_services(query_db, delete_role)
     logger.info(delete_role_result.message)
 
     return ResponseUtil.success(msg=delete_role_result.message)
 
 
-@roleController.get("/{role_id}", response_model=RoleModel, dependencies=[Depends(CheckUserInterfaceAuth('system:role:query'))])
+@roleController.get(
-async def query_detail_system_role(request: Request, role_id: int, query_db: AsyncSession = Depends(get_db), current_user: CurrentUserModel = Depends(LoginService.get_current_user), data_scope_sql: str = Depends(GetDataScope('SysDept'))):
+    '/{role_id}', response_model=RoleModel, dependencies=[Depends(CheckUserInterfaceAuth('system:role:query'))]
+)
+async def query_detail_system_role(
+    request: Request,
+    role_id: int,
+    query_db: AsyncSession = Depends(get_db),
+    current_user: CurrentUserModel = Depends(LoginService.get_current_user),
+    data_scope_sql: str = Depends(GetDataScope('SysDept')),
+):
     if not current_user.user.admin:
         await RoleService.check_role_data_scope_services(query_db, str(role_id), data_scope_sql)
     role_detail_result = await RoleService.role_detail_services(query_db, role_id)
@@ -115,20 +160,33 @@ async def query_detail_system_role(request: Request, role_id: int, query_db: Asy
     return ResponseUtil.success(data=role_detail_result.model_dump(by_alias=True))
 
 
-@roleController.post("/export", dependencies=[Depends(CheckUserInterfaceAuth('system:role:export'))])
+@roleController.post('/export', dependencies=[Depends(CheckUserInterfaceAuth('system:role:export'))])
 @log_decorator(title='角色管理', business_type=BusinessType.EXPORT)
-async def export_system_role_list(request: Request, role_page_query: RolePageQueryModel = Depends(RolePageQueryModel.as_form), query_db: AsyncSession = Depends(get_db), data_scope_sql: str = Depends(GetDataScope('SysDept'))):
+async def export_system_role_list(
+    request: Request,
+    role_page_query: RolePageQueryModel = Depends(RolePageQueryModel.as_form),
+    query_db: AsyncSession = Depends(get_db),
+    data_scope_sql: str = Depends(GetDataScope('SysDept')),
+):
     # 获取全量数据
-    role_query_result = await RoleService.get_role_list_services(query_db, role_page_query, data_scope_sql, is_page=False)
+    role_query_result = await RoleService.get_role_list_services(
+        query_db, role_page_query, data_scope_sql, is_page=False
+    )
     role_export_result = await RoleService.export_role_list_services(role_query_result)
     logger.info('导出成功')
 
     return ResponseUtil.streaming(data=bytes2file_response(role_export_result))
 
 
-@roleController.put("/changeStatus", dependencies=[Depends(CheckUserInterfaceAuth('system:role:edit'))])
+@roleController.put('/changeStatus', dependencies=[Depends(CheckUserInterfaceAuth('system:role:edit'))])
 @log_decorator(title='角色管理', business_type=BusinessType.UPDATE)
-async def reset_system_role_status(request: Request, change_role: AddRoleModel, query_db: AsyncSession = Depends(get_db), current_user: CurrentUserModel = Depends(LoginService.get_current_user), data_scope_sql: str = Depends(GetDataScope('SysDept'))):
+async def reset_system_role_status(
+    request: Request,
+    change_role: AddRoleModel,
+    query_db: AsyncSession = Depends(get_db),
+    current_user: CurrentUserModel = Depends(LoginService.get_current_user),
+    data_scope_sql: str = Depends(GetDataScope('SysDept')),
+):
     await RoleService.check_role_allowed_services(change_role)
     if not current_user.user.admin:
         await RoleService.check_role_data_scope_services(query_db, str(change_role.role_id), data_scope_sql)
@@ -137,7 +195,7 @@ async def reset_system_role_status(request: Request, change_role: AddRoleModel,
         status=change_role.status,
         updateBy=current_user.user.user_name,
         updateTime=datetime.now(),
-        type='status'
+        type='status',
     )
     edit_role_result = await RoleService.edit_role_services(query_db, edit_role)
     logger.info(edit_role_result.message)
@@ -145,25 +203,53 @@ async def reset_system_role_status(request: Request, change_role: AddRoleModel,
     return ResponseUtil.success(msg=edit_role_result.message)
 
 
-@roleController.get("/authUser/allocatedList", response_model=PageResponseModel, dependencies=[Depends(CheckUserInterfaceAuth('system:role:list'))])
+@roleController.get(
-async def get_system_allocated_user_list(request: Request, user_role: UserRolePageQueryModel = Depends(UserRolePageQueryModel.as_query), query_db: AsyncSession = Depends(get_db), data_scope_sql: str = Depends(GetDataScope('SysUser'))):
+    '/authUser/allocatedList',
-    role_user_allocated_page_query_result = await RoleService.get_role_user_allocated_list_services(query_db, user_role, data_scope_sql, is_page=True)
+    response_model=PageResponseModel,
+    dependencies=[Depends(CheckUserInterfaceAuth('system:role:list'))],
+)
+async def get_system_allocated_user_list(
+    request: Request,
+    user_role: UserRolePageQueryModel = Depends(UserRolePageQueryModel.as_query),
+    query_db: AsyncSession = Depends(get_db),
+    data_scope_sql: str = Depends(GetDataScope('SysUser')),
+):
+    role_user_allocated_page_query_result = await RoleService.get_role_user_allocated_list_services(
+        query_db, user_role, data_scope_sql, is_page=True
+    )
     logger.info('获取成功')
 
     return ResponseUtil.success(model_content=role_user_allocated_page_query_result)
 
 
-@roleController.get("/authUser/unallocatedList", response_model=PageResponseModel, dependencies=[Depends(CheckUserInterfaceAuth('system:role:list'))])
+@roleController.get(
-async def get_system_unallocated_user_list(request: Request, user_role: UserRolePageQueryModel = Depends(UserRolePageQueryModel.as_query), query_db: AsyncSession = Depends(get_db), data_scope_sql: str = Depends(GetDataScope('SysUser'))):
+    '/authUser/unallocatedList',
-    role_user_unallocated_page_query_result = await RoleService.get_role_user_unallocated_list_services(query_db, user_role, data_scope_sql, is_page=True)
+    response_model=PageResponseModel,
+    dependencies=[Depends(CheckUserInterfaceAuth('system:role:list'))],
+)
+async def get_system_unallocated_user_list(
+    request: Request,
+    user_role: UserRolePageQueryModel = Depends(UserRolePageQueryModel.as_query),
+    query_db: AsyncSession = Depends(get_db),
+    data_scope_sql: str = Depends(GetDataScope('SysUser')),
+):
+    role_user_unallocated_page_query_result = await RoleService.get_role_user_unallocated_list_services(
+        query_db, user_role, data_scope_sql, is_page=True
+    )
     logger.info('获取成功')
 
     return ResponseUtil.success(model_content=role_user_unallocated_page_query_result)
 
 
-@roleController.put("/authUser/selectAll", dependencies=[Depends(CheckUserInterfaceAuth('system:role:edit'))])
+@roleController.put('/authUser/selectAll', dependencies=[Depends(CheckUserInterfaceAuth('system:role:edit'))])
 @log_decorator(title='角色管理', business_type=BusinessType.GRANT)
-async def add_system_role_user(request: Request, add_role_user: CrudUserRoleModel = Depends(CrudUserRoleModel.as_query), query_db: AsyncSession = Depends(get_db), current_user: CurrentUserModel = Depends(LoginService.get_current_user), data_scope_sql: str = Depends(GetDataScope('SysDept'))):
+async def add_system_role_user(
+    request: Request,
+    add_role_user: CrudUserRoleModel = Depends(CrudUserRoleModel.as_query),
+    query_db: AsyncSession = Depends(get_db),
+    current_user: CurrentUserModel = Depends(LoginService.get_current_user),
+    data_scope_sql: str = Depends(GetDataScope('SysDept')),
+):
     if not current_user.user.admin:
         await RoleService.check_role_data_scope_services(query_db, str(add_role_user.role_id), data_scope_sql)
     add_role_user_result = await UserService.add_user_role_services(query_db, add_role_user)
@@ -172,18 +258,24 @@ async def add_system_role_user(request: Request, add_role_user: CrudUserRoleMode
     return ResponseUtil.success(msg=add_role_user_result.message)
 
 
-@roleController.put("/authUser/cancel", dependencies=[Depends(CheckUserInterfaceAuth('system:role:edit'))])
+@roleController.put('/authUser/cancel', dependencies=[Depends(CheckUserInterfaceAuth('system:role:edit'))])
 @log_decorator(title='角色管理', business_type=BusinessType.GRANT)
-async def cancel_system_role_user(request: Request, cancel_user_role: CrudUserRoleModel, query_db: AsyncSession = Depends(get_db)):
+async def cancel_system_role_user(
+    request: Request, cancel_user_role: CrudUserRoleModel, query_db: AsyncSession = Depends(get_db)
+):
     cancel_user_role_result = await UserService.delete_user_role_services(query_db, cancel_user_role)
     logger.info(cancel_user_role_result.message)
 
     return ResponseUtil.success(msg=cancel_user_role_result.message)
 
 
-@roleController.put("/authUser/cancelAll", dependencies=[Depends(CheckUserInterfaceAuth('system:role:edit'))])
+@roleController.put('/authUser/cancelAll', dependencies=[Depends(CheckUserInterfaceAuth('system:role:edit'))])
 @log_decorator(title='角色管理', business_type=BusinessType.GRANT)
-async def batch_cancel_system_role_user(request: Request, batch_cancel_user_role: CrudUserRoleModel = Depends(CrudUserRoleModel.as_query), query_db: AsyncSession = Depends(get_db)):
+async def batch_cancel_system_role_user(
+    request: Request,
+    batch_cancel_user_role: CrudUserRoleModel = Depends(CrudUserRoleModel.as_query),
+    query_db: AsyncSession = Depends(get_db),
+):
     batch_cancel_user_role_result = await UserService.delete_user_role_services(query_db, batch_cancel_user_role)
     logger.info(batch_cancel_user_role_result.message)
 

ruoyi-fastapi-backend/module_admin/dao/role_dao.py

@@ -1,12 +1,12 @@
-from sqlalchemy import select, update, delete, desc, and_, or_, func
+from datetime import datetime, time
+from sqlalchemy import and_, delete, desc, func, or_, select, update  # noqa: F401
 from sqlalchemy.ext.asyncio import AsyncSession
-from module_admin.entity.do.user_do import SysUser, SysUserRole
-from module_admin.entity.do.role_do import SysRole, SysRoleMenu, SysRoleDept
 from module_admin.entity.do.dept_do import SysDept
 from module_admin.entity.do.menu_do import SysMenu
-from module_admin.entity.vo.role_vo import *
+from module_admin.entity.do.role_do import SysRole, SysRoleMenu, SysRoleDept
+from module_admin.entity.do.user_do import SysUser, SysUserRole
+from module_admin.entity.vo.role_vo import RoleDeptModel, RoleMenuModel, RoleModel, RolePageQueryModel
 from utils.page_util import PageUtil
-from datetime import datetime, time
 
 
 class RoleDao:
@@ -22,12 +22,18 @@ class RoleDao:
         :param role_name: 角色名
         :return: 当前角色名的角色信息对象
         """
-        query_role_info = (await db.execute(
+        query_role_info = (
+            (
+                await db.execute(
                     select(SysRole)
                     .where(SysRole.status == '0', SysRole.del_flag == '0', SysRole.role_name == role_name)
                     .order_by(desc(SysRole.create_time))
                     .distinct()
-        )).scalars().first()
+                )
+            )
+            .scalars()
+            .first()
+        )
 
         return query_role_info
 
@@ -39,14 +45,22 @@ class RoleDao:
         :param role: 角色参数
         :return: 当前角色参数的角色信息对象
         """
-        query_role_info = (await db.execute(
+        query_role_info = (
+            (
+                await db.execute(
                     select(SysRole)
-                .where(SysRole.del_flag == '0',
+                    .where(
+                        SysRole.del_flag == '0',
                         SysRole.role_name == role.role_name if role.role_name else True,
-                       SysRole.role_key == role.role_key if role.role_key else True)
+                        SysRole.role_key == role.role_key if role.role_key else True,
+                    )
                     .order_by(desc(SysRole.create_time))
                     .distinct()
-        )).scalars().first()
+                )
+            )
+            .scalars()
+            .first()
+        )
 
         return query_role_info
 
@@ -58,12 +72,15 @@ class RoleDao:
         :param role_id: 角色id
         :return: 当前角色id的角色信息对象
         """
-        role_info = (await db.execute(
+        role_info = (
-            select(SysRole)
+            (
-                .where(SysRole.role_id == role_id,
+                await db.execute(
-                       SysRole.status == '0',
+                    select(SysRole).where(SysRole.role_id == role_id, SysRole.status == '0', SysRole.del_flag == '0')
-                       SysRole.del_flag == '0')
+                )
-        )).scalars().first()
+            )
+            .scalars()
+            .first()
+        )
 
         return role_info
 
@@ -75,11 +92,11 @@ class RoleDao:
         :param role_id: 角色id
         :return: 当前role_id的角色信息对象
         """
-        query_role_info = (await db.execute(
+        query_role_info = (
-            select(SysRole)
+            (await db.execute(select(SysRole).where(SysRole.del_flag == '0', SysRole.role_id == role_id).distinct()))
-                .where(SysRole.del_flag == '0', SysRole.role_id == role_id)
+            .scalars()
-                .distinct()
+            .first()
-        )).scalars().first()
+        )
 
         return query_role_info
 
@@ -90,15 +107,22 @@ class RoleDao:
         :param db: orm对象
         :return: 角色列表信息
         """
-        role_info = (await db.execute(
+        role_info = (
-            select(SysRole)
+            (
-                .where(SysRole.role_id != 1, SysRole.status == '0', SysRole.del_flag == '0')
+                await db.execute(
-        )).scalars().all()
+                    select(SysRole).where(SysRole.role_id != 1, SysRole.status == '0', SysRole.del_flag == '0')
+                )
+            )
+            .scalars()
+            .all()
+        )
 
         return role_info
 
     @classmethod
-    async def get_role_list(cls, db: AsyncSession, query_object: RolePageQueryModel, data_scope_sql: str, is_page: bool = False):
+    async def get_role_list(
+        cls, db: AsyncSession, query_object: RolePageQueryModel, data_scope_sql: str, is_page: bool = False
+    ):
         """
         根据查询参数获取角色列表信息
         :param db: orm对象
@@ -107,21 +131,27 @@ class RoleDao:
         :param is_page: 是否开启分页
         :return: 角色列表信息对象
         """
-        query = select(SysRole) \
+        query = (
-            .join(SysUserRole, SysUserRole.role_id == SysRole.role_id, isouter=True) \
+            select(SysRole)
-            .join(SysUser, SysUser.user_id == SysUserRole.user_id, isouter=True) \
+            .join(SysUserRole, SysUserRole.role_id == SysRole.role_id, isouter=True)
-            .join(SysDept, SysDept.dept_id == SysUser.dept_id, isouter=True) \
+            .join(SysUser, SysUser.user_id == SysUserRole.user_id, isouter=True)
-            .where(SysRole.del_flag == '0',
+            .join(SysDept, SysDept.dept_id == SysUser.dept_id, isouter=True)
+            .where(
+                SysRole.del_flag == '0',
                 SysRole.role_name.like(f'%{query_object.role_name}%') if query_object.role_name else True,
                 SysRole.role_key.like(f'%{query_object.role_key}%') if query_object.role_key else True,
                 SysRole.status == query_object.status if query_object.status else True,
                 SysRole.create_time.between(
                     datetime.combine(datetime.strptime(query_object.begin_time, '%Y-%m-%d'), time(00, 00, 00)),
-                       datetime.combine(datetime.strptime(query_object.end_time, '%Y-%m-%d'), time(23, 59, 59)))
+                    datetime.combine(datetime.strptime(query_object.end_time, '%Y-%m-%d'), time(23, 59, 59)),
-                   if query_object.begin_time and query_object.end_time else True,
+                )
-                   eval(data_scope_sql)) \
+                if query_object.begin_time and query_object.end_time
-            .order_by(SysRole.role_sort) \
+                else True,
+                eval(data_scope_sql),
+            )
+            .order_by(SysRole.role_sort)
             .distinct()
+        )
         role_list = await PageUtil.paginate(db, query, query_object.page_num, query_object.page_size, is_page)
 
         return role_list
@@ -148,10 +178,7 @@ class RoleDao:
         :param role: 需要更新的角色字典
         :return:
         """
-        await db.execute(
+        await db.execute(update(SysRole), [role])
-            update(SysRole),
-            [role]
-        )
 
     @classmethod
     async def delete_role_dao(cls, db: AsyncSession, role: RoleModel):
@@ -175,18 +202,30 @@ class RoleDao:
         :param role: 角色对象
         :return: 角色菜单关联列表信息
         """
-        role_menu_query_all = (await db.execute(
+        role_menu_query_all = (
+            (
+                await db.execute(
                     select(SysMenu)
                     .join(SysRoleMenu, SysRoleMenu.menu_id == SysMenu.menu_id)
-                .where(SysRoleMenu.role_id == role.role_id,
+                    .where(
+                        SysRoleMenu.role_id == role.role_id,
                         ~SysMenu.menu_id.in_(
                             select(SysMenu.parent_id)
                             .select_from(SysMenu)
-                               .join(SysRoleMenu,
+                            .join(
-                                     and_(SysRoleMenu.menu_id == SysMenu.menu_id, SysRoleMenu.role_id == role.role_id))
+                                SysRoleMenu,
-                       ) if role.menu_check_strictly else True)
+                                and_(SysRoleMenu.menu_id == SysMenu.menu_id, SysRoleMenu.role_id == role.role_id),
+                            )
+                        )
+                        if role.menu_check_strictly
+                        else True,
+                    )
                     .order_by(SysMenu.parent_id, SysMenu.order_num)
-        )).scalars().all()
+                )
+            )
+            .scalars()
+            .all()
+        )
 
         return role_menu_query_all
 
@@ -209,10 +248,7 @@ class RoleDao:
         :param role_menu: 角色菜单关联对象
         :return:
         """
-        await db.execute(
+        await db.execute(delete(SysRoleMenu).where(SysRoleMenu.role_id.in_([role_menu.role_id])))
-            delete(SysRoleMenu)
-                .where(SysRoleMenu.role_id.in_([role_menu.role_id]))
-        )
 
     @classmethod
     async def get_role_dept_dao(cls, db: AsyncSession, role: RoleModel):
@@ -222,17 +258,30 @@ class RoleDao:
         :param role: 角色对象
         :return: 角色部门关联列表信息
         """
-        role_dept_query_all = (await db.execute(
+        role_dept_query_all = (
+            (
+                await db.execute(
                     select(SysDept)
                     .join(SysRoleDept, SysRoleDept.dept_id == SysDept.dept_id)
-                .where(SysRoleDept.role_id == role.role_id,
+                    .where(
+                        SysRoleDept.role_id == role.role_id,
                         ~SysDept.dept_id.in_(
                             select(SysDept.parent_id)
                             .select_from(SysDept)
-                               .join(SysRoleDept, and_(SysRoleDept.dept_id == SysDept.dept_id, SysRoleDept.role_id == role.role_id))
+                            .join(
-                       ) if role.dept_check_strictly else True)
+                                SysRoleDept,
+                                and_(SysRoleDept.dept_id == SysDept.dept_id, SysRoleDept.role_id == role.role_id),
+                            )
+                        )
+                        if role.dept_check_strictly
+                        else True,
+                    )
                     .order_by(SysDept.parent_id, SysDept.order_num)
-        )).scalars().all()
+                )
+            )
+            .scalars()
+            .all()
+        )
 
         return role_dept_query_all
 
@@ -255,10 +304,7 @@ class RoleDao:
         :param role_dept: 角色部门关联对象
         :return:
         """
-        await db.execute(
+        await db.execute(delete(SysRoleDept).where(SysRoleDept.role_id.in_([role_dept.role_id])))
-            delete(SysRoleDept)
-                .where(SysRoleDept.role_id.in_([role_dept.role_id]))
-        )
 
     @classmethod
     async def count_user_role_dao(cls, db: AsyncSession, role_id: int):
@@ -268,10 +314,8 @@ class RoleDao:
         :param role_id: 角色id
         :return: 角色关联用户数量
         """
-        user_count = (await db.execute(
+        user_count = (
-            select(func.count('*'))
+            await db.execute(select(func.count('*')).select_from(SysUserRole).where(SysUserRole.role_id == role_id))
-                .select_from(SysUserRole)
+        ).scalar()
-                .where(SysUserRole.role_id == role_id)
-        )).scalar()
 
         return user_count

ruoyi-fastapi-backend/module_admin/entity/do/role_do.py

@@ -1,19 +1,24 @@
-from sqlalchemy import Column, Integer, String, DateTime
-from config.database import Base
 from datetime import datetime
+from sqlalchemy import Column, DateTime, Integer, String
+from config.database import Base
 
 
 class SysRole(Base):
     """
     角色信息表
     """
+
     __tablename__ = 'sys_role'
 
     role_id = Column(Integer, primary_key=True, autoincrement=True, comment='角色ID')
     role_name = Column(String(30, collation='utf8_general_ci'), nullable=False, comment='角色名称')
     role_key = Column(String(100, collation='utf8_general_ci'), nullable=False, comment='角色权限字符串')
     role_sort = Column(Integer, nullable=False, comment='显示顺序')
-    data_scope = Column(String(1, collation='utf8_general_ci'), default='1', comment='数据范围（1：全部数据权限 2：自定数据权限 3：本部门数据权限 4：本部门及以下数据权限）')
+    data_scope = Column(
+        String(1, collation='utf8_general_ci'),
+        default='1',
+        comment='数据范围（1：全部数据权限 2：自定数据权限 3：本部门数据权限 4：本部门及以下数据权限）',
+    )
     menu_check_strictly = Column(Integer, default=1, comment='菜单树选择项是否关联显示')
     dept_check_strictly = Column(Integer, default=1, comment='部门树选择项是否关联显示')
     status = Column(String(1, collation='utf8_general_ci'), nullable=False, comment='角色状态（0正常 1停用）')
@@ -29,6 +34,7 @@ class SysRoleDept(Base):
     """
     角色和部门关联表
     """
+
     __tablename__ = 'sys_role_dept'
 
     role_id = Column(Integer, primary_key=True, nullable=False, comment='角色ID')
@@ -39,6 +45,7 @@ class SysRoleMenu(Base):
     """
     角色和菜单关联表
     """
+
     __tablename__ = 'sys_role_menu'
 
     role_id = Column(Integer, primary_key=True, nullable=False, comment='角色ID')

ruoyi-fastapi-backend/module_admin/entity/vo/role_vo.py

@@ -1,22 +1,26 @@
+from datetime import datetime
 from pydantic import BaseModel, ConfigDict, Field, field_validator, model_validator
 from pydantic.alias_generators import to_camel
 from pydantic_validation_decorator import NotBlank, Size
-from typing import Union, Optional, List, Literal
+from typing import List, Literal, Optional, Union
-from datetime import datetime
+from module_admin.annotation.pydantic_annotation import as_form, as_query
-from module_admin.annotation.pydantic_annotation import as_query, as_form
 
 
 class RoleModel(BaseModel):
     """
     角色表对应pydantic模型
     """
+
     model_config = ConfigDict(alias_generator=to_camel, from_attributes=True)
 
     role_id: Optional[int] = Field(default=None, description='角色ID')
     role_name: Optional[str] = Field(default=None, description='角色名称')
     role_key: Optional[str] = Field(default=None, description='角色权限字符串')
     role_sort: Optional[int] = Field(default=None, description='显示顺序')
-    data_scope: Optional[Literal['1', '2', '3', '4', '5']] = Field(default=None, description='数据范围（1：全部数据权限 2：自定数据权限 3：本部门数据权限 4：本部门及以下数据权限 5：仅本人数据权限）')
+    data_scope: Optional[Literal['1', '2', '3', '4', '5']] = Field(
+        default=None,
+        description='数据范围（1：全部数据权限 2：自定数据权限 3：本部门数据权限 4：本部门及以下数据权限 5：仅本人数据权限）',
+    )
     menu_check_strictly: Optional[Union[int, bool]] = Field(default=None, description='菜单树选择项是否关联显示')
     dept_check_strictly: Optional[Union[int, bool]] = Field(default=None, description='部门树选择项是否关联显示')
     status: Optional[Literal['0', '1']] = Field(default=None, description='角色状态（0正常 1停用）')
@@ -73,6 +77,7 @@ class RoleMenuModel(BaseModel):
     """
     角色和菜单关联表对应pydantic模型
     """
+
     model_config = ConfigDict(alias_generator=to_camel, from_attributes=True)
 
     role_id: Optional[int] = Field(default=None, description='角色ID')
@@ -83,6 +88,7 @@ class RoleDeptModel(BaseModel):
     """
     角色和部门关联表对应pydantic模型
     """
+
     model_config = ConfigDict(alias_generator=to_camel, from_attributes=True)
 
     role_id: Optional[int] = Field(default=None, description='角色ID')
@@ -93,6 +99,7 @@ class RoleQueryModel(RoleModel):
     """
     角色管理不分页查询模型
     """
+
     begin_time: Optional[str] = Field(default=None, description='开始时间')
     end_time: Optional[str] = Field(default=None, description='结束时间')
 
@@ -103,6 +110,7 @@ class RolePageQueryModel(RoleQueryModel):
     """
     角色管理分页查询模型
     """
+
     page_num: int = Field(default=1, description='当前页码')
     page_size: int = Field(default=10, description='每页记录数')
 
@@ -111,6 +119,7 @@ class RoleMenuQueryModel(BaseModel):
     """
     角色菜单查询模型
     """
+
     model_config = ConfigDict(alias_generator=to_camel)
 
     menus: List = Field(default=[], description='菜单信息')
@@ -121,6 +130,7 @@ class RoleDeptQueryModel(BaseModel):
     """
     角色部门查询模型
     """
+
     model_config = ConfigDict(alias_generator=to_camel)
 
     depts: List = Field(default=[], description='部门信息')
@@ -131,6 +141,7 @@ class AddRoleModel(RoleModel):
     """
     新增角色模型
     """
+
     dept_ids: List = Field(default=[], description='部门ID信息')
     menu_ids: List = Field(default=[], description='菜单ID信息')
     type: Optional[str] = Field(default=None, description='操作类型')
@@ -140,6 +151,7 @@ class DeleteRoleModel(BaseModel):
     """
     删除角色模型
     """
+
     model_config = ConfigDict(alias_generator=to_camel)
 
     role_ids: str = Field(description='需要删除的菜单ID')

ruoyi-fastapi-backend/module_admin/service/role_service.py

@@ -1,11 +1,22 @@
-from module_admin.entity.vo.user_vo import UserInfoModel, UserRolePageQueryModel
+from sqlalchemy.ext.asyncio import AsyncSession
-from module_admin.entity.vo.common_vo import CrudResponseModel
+from typing import List
-from module_admin.dao.user_dao import UserDao
-from module_admin.dao.role_dao import *
 from config.constant import CommonConstant
 from exceptions.exception import ServiceException
+from module_admin.entity.vo.common_vo import CrudResponseModel
+from module_admin.entity.vo.role_vo import (
+    AddRoleModel,
+    DeleteRoleModel,
+    RoleDeptModel,
+    RoleDeptQueryModel,
+    RoleMenuModel,
+    RoleModel,
+    RolePageQueryModel,
+)
+from module_admin.entity.vo.user_vo import UserInfoModel, UserRolePageQueryModel
+from module_admin.dao.role_dao import RoleDao
+from module_admin.dao.user_dao import UserDao
+from utils.common_util import CamelCaseUtil, export_list2excel
 from utils.page_util import PageResponseModel
-from utils.common_util import export_list2excel, CamelCaseUtil
 
 
 class RoleService:
@@ -35,14 +46,14 @@ class RoleService:
         role = await cls.role_detail_services(query_db, role_id)
         role_dept_list = await RoleDao.get_role_dept_dao(query_db, role)
         checked_keys = [row.dept_id for row in role_dept_list]
-        result = RoleDeptQueryModel(
+        result = RoleDeptQueryModel(checkedKeys=checked_keys)
-            checkedKeys=checked_keys
-        )
 
         return result
 
     @classmethod
-    async def get_role_list_services(cls, query_db: AsyncSession, query_object: RolePageQueryModel, data_scope_sql: str, is_page: bool = False):
+    async def get_role_list_services(
+        cls, query_db: AsyncSession, query_object: RolePageQueryModel, data_scope_sql: str, is_page: bool = False
+    ):
         """
         获取角色列表信息service
         :param query_db: orm对象
@@ -77,7 +88,9 @@ class RoleService:
         :return: 校验结果
         """
         for role_id in role_ids.split(','):
-            roles = await RoleDao.get_role_list(query_db, RolePageQueryModel(roleId=int(role_id)), data_scope_sql, is_page=False)
+            roles = await RoleDao.get_role_list(
+                query_db, RolePageQueryModel(roleId=int(role_id)), data_scope_sql, is_page=False
+            )
             if roles:
                 return CrudResponseModel(is_success=True, message='校验通过')
             else:
@@ -163,7 +176,9 @@ class RoleService:
                     await RoleDao.delete_role_menu_dao(query_db, RoleMenuModel(roleId=page_object.role_id))
                     if page_object.menu_ids:
                         for menu in page_object.menu_ids:
-                            await RoleDao.add_role_menu_dao(query_db, RoleMenuModel(roleId=page_object.role_id, menuId=menu))
+                            await RoleDao.add_role_menu_dao(
+                                query_db, RoleMenuModel(roleId=page_object.role_id, menuId=menu)
+                            )
                 await query_db.commit()
                 return CrudResponseModel(is_success=True, message='更新成功')
             except Exception as e:
@@ -188,7 +203,9 @@ class RoleService:
                 await RoleDao.delete_role_dept_dao(query_db, RoleDeptModel(roleId=page_object.role_id))
                 if page_object.dept_ids and page_object.data_scope == '2':
                     for dept in page_object.dept_ids:
-                        await RoleDao.add_role_dept_dao(query_db, RoleDeptModel(roleId=page_object.role_id, deptId=dept))
+                        await RoleDao.add_role_dept_dao(
+                            query_db, RoleDeptModel(roleId=page_object.role_id, deptId=dept)
+                        )
                 await query_db.commit()
                 return CrudResponseModel(is_success=True, message='分配成功')
             except Exception as e:
@@ -212,7 +229,9 @@ class RoleService:
                     role = await cls.role_detail_services(query_db, int(role_id))
                     if (await RoleDao.count_user_role_dao(query_db, int(role_id))) > 0:
                         raise ServiceException(message=f'角色{role.role_name}已分配,不能删除')
-                    role_id_dict = dict(roleId=role_id, updateBy=page_object.update_by, updateTime=page_object.update_time)
+                    role_id_dict = dict(
+                        roleId=role_id, updateBy=page_object.update_by, updateTime=page_object.update_time
+                    )
                     await RoleDao.delete_role_menu_dao(query_db, RoleMenuModel(**role_id_dict))
                     await RoleDao.delete_role_dept_dao(query_db, RoleDeptModel(**role_id_dict))
                     await RoleDao.delete_role_dao(query_db, RoleModel(**role_id_dict))
@@ -249,16 +268,16 @@ class RoleService:
         """
         # 创建一个映射字典，将英文键映射到中文键
         mapping_dict = {
-            "roleId": "角色编号",
+            'roleId': '角色编号',
-            "roleName": "角色名称",
+            'roleName': '角色名称',
-            "roleKey": "权限字符",
+            'roleKey': '权限字符',
-            "roleSort": "显示顺序",
+            'roleSort': '显示顺序',
-            "status": "状态",
+            'status': '状态',
-            "createBy": "创建者",
+            'createBy': '创建者',
-            "createTime": "创建时间",
+            'createTime': '创建时间',
-            "updateBy": "更新者",
+            'updateBy': '更新者',
-            "updateTime": "更新时间",
+            'updateTime': '更新时间',
-            "remark": "备注",
+            'remark': '备注',
         }
 
         data = role_list
@@ -268,13 +287,17 @@ class RoleService:
                 item['status'] = '正常'
             else:
                 item['status'] = '停用'
-        new_data = [{mapping_dict.get(key): value for key, value in item.items() if mapping_dict.get(key)} for item in data]
+        new_data = [
+            {mapping_dict.get(key): value for key, value in item.items() if mapping_dict.get(key)} for item in data
+        ]
         binary_data = export_list2excel(new_data)
 
         return binary_data
 
     @classmethod
-    async def get_role_user_allocated_list_services(cls, query_db: AsyncSession, page_object: UserRolePageQueryModel, data_scope_sql: str, is_page: bool = False):
+    async def get_role_user_allocated_list_services(
+        cls, query_db: AsyncSession, page_object: UserRolePageQueryModel, data_scope_sql: str, is_page: bool = False
+    ):
         """
         根据角色id获取已分配用户列表
         :param query_db: orm对象
@@ -283,18 +306,22 @@ class RoleService:
         :param is_page: 是否开启分页
         :return: 已分配用户列表
         """
-        query_user_list = await UserDao.get_user_role_allocated_list_by_role_id(query_db, page_object, data_scope_sql, is_page)
+        query_user_list = await UserDao.get_user_role_allocated_list_by_role_id(
+            query_db, page_object, data_scope_sql, is_page
+        )
         allocated_list = PageResponseModel(
             **{
                 **query_user_list.model_dump(by_alias=True),
-                'rows': [UserInfoModel(**row) for row in query_user_list.rows]
+                'rows': [UserInfoModel(**row) for row in query_user_list.rows],
             }
         )
 
         return allocated_list
 
     @classmethod
-    async def get_role_user_unallocated_list_services(cls, query_db: AsyncSession, page_object: UserRolePageQueryModel, data_scope_sql: str, is_page: bool = False):
+    async def get_role_user_unallocated_list_services(
+        cls, query_db: AsyncSession, page_object: UserRolePageQueryModel, data_scope_sql: str, is_page: bool = False
+    ):
         """
         根据角色id获取未分配用户列表
         :param query_db: orm对象
@@ -303,11 +330,13 @@ class RoleService:
         :param is_page: 是否开启分页
         :return: 未分配用户列表
         """
-        query_user_list = await UserDao.get_user_role_unallocated_list_by_role_id(query_db, page_object, data_scope_sql, is_page)
+        query_user_list = await UserDao.get_user_role_unallocated_list_by_role_id(
+            query_db, page_object, data_scope_sql, is_page
+        )
         unallocated_list = PageResponseModel(
             **{
                 **query_user_list.model_dump(by_alias=True),
-                'rows': [UserInfoModel(**row) for row in query_user_list.rows]
+                'rows': [UserInfoModel(**row) for row in query_user_list.rows],
             }
         )