perf: 优化角色管理模块service层及异常处理

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

@@ -21,216 +21,170 @@ roleController = APIRouter(prefix='/system/role', dependencies=[Depends(LoginSer
 
 @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'))):
-    try:
     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
     logger.info('获取成功')
+
     return ResponseUtil.success(model_content=role_dept_query_result)
-    except Exception as e:
-        logger.exception(e)
-        return ResponseUtil.error(msg=str(e))
     
     
 @roleController.get("/list", response_model=PageResponseModel, dependencies=[Depends(CheckUserInterfaceAuth('system:role:list'))])
-async def get_system_role_list(request: Request, role_page_query: RolePageQueryModel = Depends(RolePageQueryModel.as_query), query_db: AsyncSession = Depends(get_db)):
-    try:
-        role_page_query_result = await RoleService.get_role_list_services(query_db, role_page_query, 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('role_query.columns'))):
+    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)
-    except Exception as e:
-        logger.exception(e)
-        return ResponseUtil.error(msg=str(e))
     
     
 @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)):
-    try:
     add_role.create_by = current_user.user.user_name
     add_role.create_time = datetime.now()
     add_role.update_by = current_user.user.user_name
     add_role.update_time = datetime.now()
     add_role_result = await RoleService.add_role_services(query_db, add_role)
-        if add_role_result.is_success:
     logger.info(add_role_result.message)
+
     return ResponseUtil.success(msg=add_role_result.message)
-        else:
-            logger.warning(add_role_result.message)
-            return ResponseUtil.failure(msg=add_role_result.message)
-    except Exception as e:
-        logger.exception(e)
-        return ResponseUtil.error(msg=str(e))
     
     
 @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)):
-    try:
+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('role_query'))):
+    await RoleService.check_role_allowed_services(edit_role)
+    if not current_user.user.admin:
+        await RoleService.check_role_data_scope_services(query_db, edit_role.role_id, data_scope_sql)
     edit_role.update_by = current_user.user.user_name
     edit_role.update_time = datetime.now()
     edit_role_result = await RoleService.edit_role_services(query_db, edit_role)
-        if edit_role_result.is_success:
     logger.info(edit_role_result.message)
+
     return ResponseUtil.success(msg=edit_role_result.message)
-        else:
-            logger.warning(edit_role_result.message)
-            return ResponseUtil.failure(msg=edit_role_result.message)
-    except Exception as e:
-        logger.exception(e)
-        return ResponseUtil.error(msg=str(e))
 
 
 @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)):
-    try:
-        role_data_scope.update_by = current_user.user.user_name
-        role_data_scope.update_time = datetime.now()
-        role_data_scope_result = await RoleService.role_datascope_services(query_db, role_data_scope)
-        if role_data_scope_result.is_success:
+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('role_query'))):
+    await RoleService.check_role_allowed_services(role_data_scope)
+    if not current_user.user.admin:
+        await RoleService.check_role_data_scope_services(query_db, role_data_scope.role_id, data_scope_sql)
+    edit_role = AddRoleModel(
+        roleId=role_data_scope.role_id,
+        dataScope=role_data_scope.data_scope,
+        deptIds=role_data_scope.dept_ids,
+        deptCheckStrictly=role_data_scope.dept_check_strictly,
+        updateBy=current_user.user.user_name,
+        updateTime=datetime.now()
+    )
+    role_data_scope_result = await RoleService.role_datascope_services(query_db, edit_role)
     logger.info(role_data_scope_result.message)
+
     return ResponseUtil.success(msg=role_data_scope_result.message)
-        else:
-            logger.warning(role_data_scope_result.message)
-            return ResponseUtil.failure(msg=role_data_scope_result.message)
-    except Exception as e:
-        logger.exception(e)
-        return ResponseUtil.error(msg=str(e))
     
     
 @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)):
-    try:
+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('role_query'))):
+    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, int(role_id), data_scope_sql)
     delete_role = DeleteRoleModel(
         roleIds=role_ids,
         updateBy=current_user.user.user_name,
         updateTime=datetime.now()
     )
     delete_role_result = await RoleService.delete_role_services(query_db, delete_role)
-        if delete_role_result.is_success:
     logger.info(delete_role_result.message)
+
     return ResponseUtil.success(msg=delete_role_result.message)
-        else:
-            logger.warning(delete_role_result.message)
-            return ResponseUtil.failure(msg=delete_role_result.message)
-    except Exception as e:
-        logger.exception(e)
-        return ResponseUtil.error(msg=str(e))
     
     
 @roleController.get("/{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)):
-    try:
+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('role_query'))):
+    if not current_user.user.admin:
+        await RoleService.check_role_data_scope_services(query_db, role_id, data_scope_sql)
     role_detail_result = await RoleService.role_detail_services(query_db, role_id)
     logger.info(f'获取role_id为{role_id}的信息成功')
+
     return ResponseUtil.success(data=role_detail_result.model_dump(by_alias=True))
-    except Exception as e:
-        logger.exception(e)
-        return ResponseUtil.error(msg=str(e))
 
 
 @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)):
-    try:
+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('role_query'))):
     # 获取全量数据
-        role_query_result = await RoleService.get_role_list_services(query_db, role_page_query, 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))
-    except Exception as e:
-        logger.exception(e)
-        return ResponseUtil.error(msg=str(e))
 
 
 @roleController.put("/changeStatus", dependencies=[Depends(CheckUserInterfaceAuth('system:role:edit'))])
 @log_decorator(title='角色管理', business_type=BusinessType.UPDATE)
-async def reset_system_role_status(request: Request, edit_role: AddRoleModel, query_db: AsyncSession = Depends(get_db), current_user: CurrentUserModel = Depends(LoginService.get_current_user)):
-    try:
-        edit_role.update_by = current_user.user.user_name
-        edit_role.update_time = datetime.now()
-        edit_role.type = 'status'
+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('role_query'))):
+    await RoleService.check_role_allowed_services(change_role)
+    if not current_user.user.admin:
+        await RoleService.check_role_data_scope_services(query_db, change_role.role_id, data_scope_sql)
+    edit_role = AddRoleModel(
+        roleId=change_role.role_id,
+        status=change_role.status,
+        updateBy=current_user.user.user_name,
+        updateTime=datetime.now(),
+        type='status'
+    )
     edit_role_result = await RoleService.edit_role_services(query_db, edit_role)
-        if edit_role_result.is_success:
     logger.info(edit_role_result.message)
+
     return ResponseUtil.success(msg=edit_role_result.message)
-        else:
-            logger.warning(edit_role_result.message)
-            return ResponseUtil.failure(msg=edit_role_result.message)
-    except Exception as e:
-        logger.exception(e)
-        return ResponseUtil.error(msg=str(e))
 
 
 @roleController.get("/authUser/allocatedList", 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)):
-    try:
-        role_user_allocated_page_query_result = await RoleService.get_role_user_allocated_list_services(query_db, user_role, is_page=True)
+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)
-    except Exception as e:
-        logger.exception(e)
-        return ResponseUtil.error(msg=str(e))
 
 
 @roleController.get("/authUser/unallocatedList", 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)):
-    try:
-        role_user_unallocated_page_query_result = await RoleService.get_role_user_unallocated_list_services(query_db, user_role, is_page=True)
+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)
-    except Exception as e:
-        logger.exception(e)
-        return ResponseUtil.error(msg=str(e))
 
 
 @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)):
-    try:
+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('role_query'))):
+    if not current_user.user.admin:
+        await RoleService.check_role_data_scope_services(query_db, add_role_user.role_id, data_scope_sql)
     add_role_user_result = await UserService.add_user_role_services(query_db, add_role_user)
-        if add_role_user_result.is_success:
     logger.info(add_role_user_result.message)
+
     return ResponseUtil.success(msg=add_role_user_result.message)
-        else:
-            logger.warning(add_role_user_result.message)
-            return ResponseUtil.failure(msg=add_role_user_result.message)
-    except Exception as e:
-        logger.exception(e)
-        return ResponseUtil.error(msg=str(e))
 
 
 @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)):
-    try:
     cancel_user_role_result = await UserService.delete_user_role_services(query_db, cancel_user_role)
-        if cancel_user_role_result.is_success:
     logger.info(cancel_user_role_result.message)
+
     return ResponseUtil.success(msg=cancel_user_role_result.message)
-        else:
-            logger.warning(cancel_user_role_result.message)
-            return ResponseUtil.failure(msg=cancel_user_role_result.message)
-    except Exception as e:
-        logger.exception(e)
-        return ResponseUtil.error(msg=str(e))
 
 
 @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)):
-    try:
     batch_cancel_user_role_result = await UserService.delete_user_role_services(query_db, batch_cancel_user_role)
-        if batch_cancel_user_role_result.is_success:
     logger.info(batch_cancel_user_role_result.message)
+
     return ResponseUtil.success(msg=batch_cancel_user_role_result.message)
-        else:
-            logger.warning(batch_cancel_user_role_result.message)
-            return ResponseUtil.failure(msg=batch_cancel_user_role_result.message)
-    except Exception as e:
-        logger.exception(e)
-        return ResponseUtil.error(msg=str(e))

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

@@ -76,8 +76,8 @@ async def delete_system_user(request: Request, user_ids: str, query_db: AsyncSes
 
         return ResponseUtil.failure(msg='当前登录用户不能删除')
     for user_id in user_id_list:
-        if not current_user.user.admin:
         await UserService.check_user_allowed_services(UserModel(userId=int(user_id)))
+        if not current_user.user.admin:
             await UserService.check_user_data_scope_services(query_db, int(user_id), data_scope_sql)
     delete_user = DeleteUserModel(
         userIds=user_ids,

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

@@ -1,4 +1,4 @@
-from sqlalchemy import select, update, delete
+from sqlalchemy import select, update, delete, or_, func
 from sqlalchemy.ext.asyncio import AsyncSession
 from module_admin.entity.do.dept_do import SysDept
 from module_admin.entity.do.role_do import SysRoleDept

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

@@ -1,5 +1,6 @@
-from sqlalchemy import select, update, delete, desc, func
+from sqlalchemy import select, update, delete, desc, and_, or_, func
 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.vo.role_vo import *
@@ -96,15 +97,19 @@ class RoleDao:
         return role_info
 
     @classmethod
-    async def get_role_list(cls, db: AsyncSession, query_object: RolePageQueryModel, 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对象
         :param query_object: 查询参数对象
+        :param data_scope_sql: 数据权限对应的查询sql语句
         :param is_page: 是否开启分页
         :return: 角色列表信息对象
         """
-        query = select(SysRole) \
+        role_query = (select(SysRole, SysUser.user_id, SysDept.dept_id)
+            .join(SysUserRole, SysUserRole.role_id == SysRole.role_id, isouter=True)
+            .join(SysUser, SysUser.user_id == SysUserRole.user_id, isouter=True)
+            .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,
@@ -112,9 +117,12 @@ class RoleDao:
                    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)))
-                   if query_object.begin_time and query_object.end_time else True) \
-            .order_by(SysRole.role_sort) \
-            .distinct()
+                   if query_object.begin_time and query_object.end_time else True)
+            .order_by(SysRole.role_sort)).subquery()
+        query = select(SysRole) \
+            .select_from(role_query) \
+            .join(SysRole, SysRole.role_id == role_query.columns.role_id) \
+            .where(eval(data_scope_sql)).distinct()
         role_list = await PageUtil.paginate(db, query, query_object.page_num, query_object.page_size, is_page)
 
         return role_list
@@ -201,18 +209,23 @@ class RoleDao:
         )
 
     @classmethod
-    async def get_role_dept_dao(cls, db: AsyncSession, role_id: int):
+    async def get_role_dept_dao(cls, db: AsyncSession, role: RoleModel):
         """
         根据角色id获取角色部门关联列表信息
         :param db: orm对象
-        :param role_id: 角色id
+        :param role: 角色对象
         :return: 角色部门关联列表信息
         """
         role_dept_query_all = (await db.execute(
-            select(SysRoleDept)
-                .where(SysRoleDept.role_id == role_id,
-                       ~select(SysDept).where(func.find_in_set(SysRoleDept.dept_id, SysDept.ancestors)).exists())
-                .distinct()
+            select(SysDept)
+                .join(SysRoleDept, SysRoleDept.dept_id == SysDept.dept_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))
+                       ) if role.dept_check_strictly else True)
+                .order_by(SysDept.parent_id, SysDept.order_num)
         )).scalars().all()
 
         return role_dept_query_all
@@ -240,3 +253,19 @@ class RoleDao:
             delete(SysRoleDept)
                 .where(SysRoleDept.role_id.in_([role_dept.role_id]))
         )
+
+    @classmethod
+    async def count_user_role_dao(cls, db: AsyncSession, role_id: int):
+        """
+        根据角色id查询角色关联用户数量
+        :param db: orm对象
+        :param role_id: 角色id
+        :return: 角色关联用户数量
+        """
+        user_count = (await db.execute(
+            select(func.count('*'))
+                .select_from(SysUserRole)
+                .where(SysUserRole.role_id == role_id)
+        )).scalar()
+
+        return user_count

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

@@ -277,46 +277,56 @@ class UserDao:
         return allocated_role_list
 
     @classmethod
-    async def get_user_role_allocated_list_by_role_id(cls, db: AsyncSession, query_object: UserRolePageQueryModel,
-                                                      is_page: bool = False):
+    async def get_user_role_allocated_list_by_role_id(cls, db: AsyncSession, query_object: UserRolePageQueryModel, data_scope_sql: str, is_page: bool = False):
         """
         根据角色id获取已分配的用户列表信息
         :param db: orm对象
         :param query_object: 用户角色查询对象
+        :param data_scope_sql: 数据权限对应的查询sql语句
         :param is_page: 是否开启分页
         :return: 角色已分配的用户列表信息
         """
         query = select(SysUser) \
+            .join(SysDept, SysDept.dept_id == SysUser.dept_id, isouter=True) \
+            .join(SysUserRole, SysUserRole.user_id == SysUser.user_id, isouter=True) \
+            .join(SysRole, SysRole.role_id == SysUserRole.role_id, isouter=True) \
             .where(SysUser.del_flag == '0',
-                   SysUser.user_id != 1,
                    SysUser.user_name == query_object.user_name if query_object.user_name else True,
                    SysUser.phonenumber == query_object.phonenumber if query_object.phonenumber else True,
-                   SysUser.user_id.in_(
-                       select(SysUserRole.user_id).where(SysUserRole.role_id == query_object.role_id)
-                   )) \
+                   SysRole.role_id == query_object.role_id,
+                   eval(data_scope_sql)) \
             .distinct()
         allocated_user_list = await PageUtil.paginate(db, query, query_object.page_num, query_object.page_size, is_page)
 
         return allocated_user_list
 
     @classmethod
-    async def get_user_role_unallocated_list_by_role_id(cls, db: AsyncSession, query_object: UserRolePageQueryModel,
-                                                        is_page: bool = False):
+    async def get_user_role_unallocated_list_by_role_id(cls, db: AsyncSession, query_object: UserRolePageQueryModel, data_scope_sql: str, is_page: bool = False):
         """
         根据角色id获取未分配的用户列表信息
         :param db: orm对象
         :param query_object: 用户角色查询对象
+        :param data_scope_sql: 数据权限对应的查询sql语句
         :param is_page: 是否开启分页
         :return: 角色未分配的用户列表信息
         """
         query = select(SysUser) \
+            .join(SysDept, SysDept.dept_id == SysUser.dept_id, isouter=True) \
+            .join(SysUserRole, SysUserRole.user_id == SysUser.user_id, isouter=True) \
+            .join(SysRole, SysRole.role_id == SysUserRole.role_id, isouter=True) \
             .where(SysUser.del_flag == '0',
-                   SysUser.user_id != 1,
                    SysUser.user_name == query_object.user_name if query_object.user_name else True,
                    SysUser.phonenumber == query_object.phonenumber if query_object.phonenumber else True,
+                   or_(SysRole.role_id != query_object.role_id, SysRole.role_id is None),
                    ~SysUser.user_id.in_(
-                       select(SysUserRole.user_id).where(SysUserRole.role_id == query_object.role_id)
-                   )) \
+                       select(SysUser.user_id)
+                           .select_from(SysUser)
+                           .join(SysUserRole,
+                                 and_(SysUserRole.user_id == SysUser.user_id,
+                                      SysUserRole.role_id == query_object.role_id)
+                                 )
+                   ),
+                   eval(data_scope_sql)) \
             .distinct()
         unallocated_user_list = await PageUtil.paginate(db, query, query_object.page_num, query_object.page_size,
                                                         is_page)

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

@@ -16,7 +16,7 @@ class RoleModel(BaseModel):
     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']] = Field(default=None, description='数据范围（1：全部数据权限 2：自定数据权限 3：本部门数据权限 4：本部门及以下数据权限）')
+    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停用）')

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

@@ -2,6 +2,8 @@ from module_admin.entity.vo.user_vo import UserInfoModel, UserRolePageQueryModel
 from module_admin.entity.vo.common_vo import CrudResponseModel
 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 utils.page_util import PageResponseModel
 from utils.common_util import export_list2excel, CamelCaseUtil
 
@@ -30,7 +32,8 @@ class RoleService:
         :param role_id: 角色id
         :return: 当前角色id的部门树信息对象
         """
-        role_dept_list = await RoleDao.get_role_dept_dao(query_db, role_id)
+        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(
             checkedKeys=checked_keys
@@ -39,18 +42,74 @@ class RoleService:
         return result
 
     @classmethod
-    async def get_role_list_services(cls, query_db: AsyncSession, query_object: RolePageQueryModel, 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对象
         :param query_object: 查询参数对象
+        :param data_scope_sql: 数据权限对应的查询sql语句
         :param is_page: 是否开启分页
         :return: 角色列表信息对象
         """
-        role_list_result = await RoleDao.get_role_list(query_db, query_object, is_page)
+        role_list_result = await RoleDao.get_role_list(query_db, query_object, data_scope_sql, is_page)
 
         return role_list_result
 
+    @classmethod
+    async def check_role_allowed_services(cls, check_role: RoleModel):
+        """
+        校验角色是否允许操作service
+        :param check_role: 角色信息
+        :return: 校验结果
+        """
+        if check_role.admin:
+            raise ServiceException(message='不允许操作超级管理员角色')
+        else:
+            return CrudResponseModel(is_success=True, message='校验通过')
+
+    @classmethod
+    async def check_role_data_scope_services(cls, query_db: AsyncSession, role_id: int, data_scope_sql: str):
+        """
+        校验角色是否有数据权限service
+        :param query_db: orm对象
+        :param role_id: 角色id
+        :param data_scope_sql: 数据权限对应的查询sql语句
+        :return: 校验结果
+        """
+        roles = await RoleDao.get_role_list(query_db, RolePageQueryModel(roleId=role_id), data_scope_sql, is_page=False)
+        if roles:
+            return CrudResponseModel(is_success=True, message='校验通过')
+        else:
+            raise ServiceException(message='没有权限访问角色数据')
+
+    @classmethod
+    async def check_role_name_unique_services(cls, query_db: AsyncSession, page_object: RoleModel):
+        """
+        校验角色名称是否唯一service
+        :param query_db: orm对象
+        :param page_object: 角色对象
+        :return: 校验结果
+        """
+        role_id = -1 if page_object.role_id is None else page_object.role_id
+        role = await RoleDao.get_role_by_info(query_db, RoleModel(roleName=page_object.role_name))
+        if role and role.role_id != role_id:
+            return CommonConstant.NOT_UNIQUE
+        return CommonConstant.UNIQUE
+
+    @classmethod
+    async def check_role_key_unique_services(cls, query_db: AsyncSession, page_object: RoleModel):
+        """
+        校验角色权限字符是否唯一service
+        :param query_db: orm对象
+        :param page_object: 角色对象
+        :return: 校验结果
+        """
+        role_id = -1 if page_object.role_id is None else page_object.role_id
+        role = await RoleDao.get_role_by_info(query_db, RoleModel(roleKey=page_object.role_key))
+        if role and role.role_id != role_id:
+            return CommonConstant.NOT_UNIQUE
+        return CommonConstant.UNIQUE
+
     @classmethod
     async def add_role_services(cls, query_db: AsyncSession, page_object: AddRoleModel):
         """
@@ -60,12 +119,10 @@ class RoleService:
         :return: 新增角色校验结果
         """
         add_role = RoleModel(**page_object.model_dump(by_alias=True))
-        role_name = await RoleDao.get_role_by_info(query_db, RoleModel(roleName=page_object.role_name))
-        role_key = await RoleDao.get_role_by_info(query_db, RoleModel(roleKey=page_object.role_key))
-        if role_name:
-            result = dict(is_success=False, message='角色名称已存在')
-        elif role_key:
-            result = dict(is_success=False, message='权限字符已存在')
+        if not await cls.check_role_name_unique_services(query_db, page_object):
+            raise ServiceException(message=f'新增角色{page_object.post_name}失败，角色名称已存在')
+        elif not await cls.check_role_key_unique_services(query_db, page_object):
+            raise ServiceException(message=f'新增角色{page_object.post_name}失败，角色权限已存在')
         else:
             try:
                 add_result = await RoleDao.add_role_dao(query_db, add_role)
@@ -74,13 +131,11 @@ class RoleService:
                     for menu in page_object.menu_ids:
                         await RoleDao.add_role_menu_dao(query_db, RoleMenuModel(roleId=role_id, menuId=menu))
                 await query_db.commit()
-                result = dict(is_success=True, message='新增成功')
+                return CrudResponseModel(is_success=True, message='新增成功')
             except Exception as e:
                 await query_db.rollback()
                 raise e
 
-        return CrudResponseModel(**result)
-
     @classmethod
     async def edit_role_services(cls, query_db: AsyncSession, page_object: AddRoleModel):
         """
@@ -96,16 +151,11 @@ class RoleService:
             del edit_role['type']
         role_info = await cls.role_detail_services(query_db, edit_role.get('role_id'))
         if role_info:
-            if page_object.type != 'status' and role_info.role_name != page_object.role_name:
-                role_name = await RoleDao.get_role_by_info(query_db, RoleModel(roleName=page_object.role_name))
-                if role_name:
-                    result = dict(is_success=False, message='角色名称已存在')
-                    return CrudResponseModel(**result)
-            elif page_object.type != 'status' and role_info.role_key != page_object.role_key:
-                role_key = await RoleDao.get_role_by_info(query_db, RoleModel(roleKey=page_object.role_key))
-                if role_key:
-                    result = dict(is_success=False, message='权限字符已存在')
-                    return CrudResponseModel(**result)
+            if page_object.type != 'status':
+                if not await cls.check_role_name_unique_services(query_db, page_object):
+                    raise ServiceException(message=f'修改角色{page_object.post_name}失败，角色名称已存在')
+                elif not await cls.check_role_key_unique_services(query_db, page_object):
+                    raise ServiceException(message=f'修改角色{page_object.post_name}失败，角色权限已存在')
             try:
                 await RoleDao.edit_role_dao(query_db, edit_role)
                 if page_object.type != 'status':
@@ -114,14 +164,12 @@ class RoleService:
                         for menu in page_object.menu_ids:
                             await RoleDao.add_role_menu_dao(query_db, RoleMenuModel(roleId=page_object.role_id, menuId=menu))
                 await query_db.commit()
-                result = dict(is_success=True, message='更新成功')
+                return CrudResponseModel(is_success=True, message='更新成功')
             except Exception as e:
                 await query_db.rollback()
                 raise e
         else:
-            result = dict(is_success=False, message='角色不存在')
-
-        return CrudResponseModel(**result)
+            raise ServiceException(message='角色不存在')
 
     @classmethod
     async def role_datascope_services(cls, query_db: AsyncSession, page_object: AddRoleModel):
@@ -131,20 +179,9 @@ class RoleService:
         :param page_object: 角色数据权限对象
         :return: 分配角色数据权限结果
         """
-        edit_role = page_object.model_dump(exclude_unset=True, exclude={'admin'})
-        del edit_role['dept_ids']
-        role_info = await cls.role_detail_services(query_db, edit_role.get('role_id'))
-        if role_info:
-            if role_info.role_name != page_object.role_name:
-                role_name = await RoleDao.get_role_by_info(query_db, RoleModel(roleName=page_object.role_name))
-                if role_name:
-                    result = dict(is_success=False, message='角色名称已存在')
-                    return CrudResponseModel(**result)
-            elif role_info.role_key != page_object.role_key:
-                role_key = await RoleDao.get_role_by_info(query_db, RoleModel(roleKey=page_object.role_key))
-                if role_key:
-                    result = dict(is_success=False, message='权限字符已存在')
-                    return CrudResponseModel(**result)
+        edit_role = page_object.model_dump(exclude_unset=True, exclude={'admin', 'dept_ids'})
+        role_info = await cls.role_detail_services(query_db, page_object.role_id)
+        if role_info.role_id:
             try:
                 await RoleDao.edit_role_dao(query_db, edit_role)
                 await RoleDao.delete_role_dept_dao(query_db, RoleDeptModel(roleId=page_object.role_id))
@@ -152,14 +189,12 @@ class RoleService:
                     for dept in page_object.dept_ids:
                         await RoleDao.add_role_dept_dao(query_db, RoleDeptModel(roleId=page_object.role_id, deptId=dept))
                 await query_db.commit()
-                result = dict(is_success=True, message='分配成功')
+                return CrudResponseModel(is_success=True, message='分配成功')
             except Exception as e:
                 await query_db.rollback()
                 raise e
         else:
-            result = dict(is_success=False, message='角色不存在')
-
-        return CrudResponseModel(**result)
+            raise ServiceException(message='角色不存在')
 
     @classmethod
     async def delete_role_services(cls, query_db: AsyncSession, page_object: DeleteRoleModel):
@@ -173,17 +208,20 @@ class RoleService:
             role_id_list = page_object.role_ids.split(',')
             try:
                 for role_id in role_id_list:
+                    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)
                     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))
                 await query_db.commit()
-                result = dict(is_success=True, message='删除成功')
+                return CrudResponseModel(is_success=True, message='删除成功')
             except Exception as e:
                 await query_db.rollback()
                 raise e
         else:
-            result = dict(is_success=False, message='传入角色id为空')
-        return CrudResponseModel(**result)
+            raise ServiceException(message='传入角色id为空')
 
     @classmethod
     async def role_detail_services(cls, query_db: AsyncSession, role_id: int):
@@ -194,7 +232,10 @@ class RoleService:
         :return: 角色id对应的信息
         """
         role = await RoleDao.get_role_detail_by_id(query_db, role_id=role_id)
+        if role:
             result = RoleModel(**CamelCaseUtil.transform_result(role))
+        else:
+            result = RoleModel(**dict())
 
         return result
 
@@ -232,15 +273,16 @@ class RoleService:
         return binary_data
 
     @classmethod
-    async def get_role_user_allocated_list_services(cls, query_db: AsyncSession, page_object: UserRolePageQueryModel, 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对象
         :param page_object: 用户关联角色对象
+        :param data_scope_sql: 数据权限对应的查询sql语句
         :param is_page: 是否开启分页
         :return: 已分配用户列表
         """
-        query_user_list = await UserDao.get_user_role_allocated_list_by_role_id(query_db, page_object, 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),
@@ -251,15 +293,16 @@ class RoleService:
         return allocated_list
 
     @classmethod
-    async def get_role_user_unallocated_list_services(cls, query_db: AsyncSession, page_object: UserRolePageQueryModel, 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对象
         :param page_object: 用户关联角色对象
+        :param data_scope_sql: 数据权限对应的查询sql语句
         :param is_page: 是否开启分页
         :return: 未分配用户列表
         """
-        query_user_list = await UserDao.get_user_role_unallocated_list_by_role_id(query_db, page_object, 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),