developers
/
vue-fastapi-admin
3
0
Fork 0
Code Issues Pull Requests Projects Releases Wiki Activity
Browse Source

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

master
insistence 7 months ago
parent
013ea25731
commit
1bd4bba2f5
7 changed files with 275 additions and 239 deletions
Whitespace
Show all changes Ignore whitespace when comparing lines Ignore changes in amount of whitespace Ignore changes in whitespace at EOL
Unified View
Diff Options
Show Stats Download Patch File Download Diff File
  1. 274
      ruoyi-fastapi-backend/module_admin/controller/role_controller.py
  2. 4
      ruoyi-fastapi-backend/module_admin/controller/user_controller.py
  3. 2
      ruoyi-fastapi-backend/module_admin/dao/dept_dao.py
  4. 53
      ruoyi-fastapi-backend/module_admin/dao/role_dao.py
  5. 32
      ruoyi-fastapi-backend/module_admin/dao/user_dao.py
  6. 2
      ruoyi-fastapi-backend/module_admin/entity/vo/role_vo.py
  7. 147
      ruoyi-fastapi-backend/module_admin/service/role_service.py

274
ruoyi-fastapi-backend/module_admin/controller/role_controller.py
View File

@ -21,216 +21,170 @@ roleController = APIRouter(prefix='/system/role', dependencies=[Depends(LoginSer
@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'))):
try: dept_query_result = await DeptService.get_dept_tree_services(query_db, DeptModel(**{}), data_scope_sql)
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 = await RoleService.get_role_dept_tree_services(query_db, role_id) role_dept_query_result.depts = dept_query_result
role_dept_query_result.depts = dept_query_result logger.info('获取成功')
logger.info('获取成功')
return ResponseUtil.success(model_content=role_dept_query_result) 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'))]) @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)): 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'))):
try: role_page_query_result = await RoleService.get_role_list_services(query_db, role_page_query, data_scope_sql, is_page=True)
role_page_query_result = await RoleService.get_role_list_services(query_db, role_page_query, is_page=True) logger.info('获取成功')
logger.info('获取成功')
return ResponseUtil.success(model_content=role_page_query_result) 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'))]) @roleController.post("", dependencies=[Depends(CheckUserInterfaceAuth('system:role:add'))])
@ValidateFields(validate_model='add_role') @ValidateFields(validate_model='add_role')
@log_decorator(title='角色管理', business_type=BusinessType.INSERT) @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)):
try: add_role.create_by = current_user.user.user_name
add_role.create_by = current_user.user.user_name add_role.create_time = datetime.now()
add_role.create_time = datetime.now() add_role.update_by = current_user.user.user_name
add_role.update_by = current_user.user.user_name add_role.update_time = datetime.now()
add_role.update_time = datetime.now() add_role_result = await RoleService.add_role_services(query_db, add_role)
add_role_result = await RoleService.add_role_services(query_db, add_role) logger.info(add_role_result.message)
if add_role_result.is_success:
logger.info(add_role_result.message) return ResponseUtil.success(msg=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'))]) @roleController.put("", dependencies=[Depends(CheckUserInterfaceAuth('system:role:edit'))])
@ValidateFields(validate_model='edit_role') @ValidateFields(validate_model='edit_role')
@log_decorator(title='角色管理', business_type=BusinessType.UPDATE) @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)): 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'))):
try: await RoleService.check_role_allowed_services(edit_role)
edit_role.update_by = current_user.user.user_name if not current_user.user.admin:
edit_role.update_time = datetime.now() await RoleService.check_role_data_scope_services(query_db, edit_role.role_id, data_scope_sql)
edit_role_result = await RoleService.edit_role_services(query_db, edit_role) edit_role.update_by = current_user.user.user_name
if edit_role_result.is_success: edit_role.update_time = datetime.now()
logger.info(edit_role_result.message) edit_role_result = await RoleService.edit_role_services(query_db, edit_role)
return ResponseUtil.success(msg=edit_role_result.message) logger.info(edit_role_result.message)
else:
logger.warning(edit_role_result.message) return ResponseUtil.success(msg=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'))]) @roleController.put("/dataScope", dependencies=[Depends(CheckUserInterfaceAuth('system:role:edit'))])
@log_decorator(title='角色管理', business_type=BusinessType.GRANT) @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)): 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'))):
try: await RoleService.check_role_allowed_services(role_data_scope)
role_data_scope.update_by = current_user.user.user_name if not current_user.user.admin:
role_data_scope.update_time = datetime.now() await RoleService.check_role_data_scope_services(query_db, role_data_scope.role_id, data_scope_sql)
role_data_scope_result = await RoleService.role_datascope_services(query_db, role_data_scope) edit_role = AddRoleModel(
if role_data_scope_result.is_success: roleId=role_data_scope.role_id,
logger.info(role_data_scope_result.message) dataScope=role_data_scope.data_scope,
return ResponseUtil.success(msg=role_data_scope_result.message) deptIds=role_data_scope.dept_ids,
else: deptCheckStrictly=role_data_scope.dept_check_strictly,
logger.warning(role_data_scope_result.message) updateBy=current_user.user.user_name,
return ResponseUtil.failure(msg=role_data_scope_result.message) updateTime=datetime.now()
except Exception as e: )
logger.exception(e) role_data_scope_result = await RoleService.role_datascope_services(query_db, edit_role)
return ResponseUtil.error(msg=str(e)) logger.info(role_data_scope_result.message)
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) @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)): 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'))):
try: role_id_list = role_ids.split(',')
delete_role = DeleteRoleModel( for role_id in role_id_list:
roleIds=role_ids, await RoleService.check_role_allowed_services(RoleModel(roleId=int(role_id)))
updateBy=current_user.user.user_name, if not current_user.user.admin:
updateTime=datetime.now() await RoleService.check_role_data_scope_services(query_db, int(role_id), data_scope_sql)
) delete_role = DeleteRoleModel(
delete_role_result = await RoleService.delete_role_services(query_db, delete_role) roleIds=role_ids,
if delete_role_result.is_success: updateBy=current_user.user.user_name,
logger.info(delete_role_result.message) updateTime=datetime.now()
return ResponseUtil.success(msg=delete_role_result.message) )
else: delete_role_result = await RoleService.delete_role_services(query_db, delete_role)
logger.warning(delete_role_result.message) logger.info(delete_role_result.message)
return ResponseUtil.failure(msg=delete_role_result.message)
except Exception as e: return ResponseUtil.success(msg=delete_role_result.message)
logger.exception(e)
return ResponseUtil.error(msg=str(e))
@roleController.get("/{role_id}", response_model=RoleModel, dependencies=[Depends(CheckUserInterfaceAuth('system:role:query'))]) @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)): 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'))):
try: if not current_user.user.admin:
role_detail_result = await RoleService.role_detail_services(query_db, role_id) await RoleService.check_role_data_scope_services(query_db, role_id, data_scope_sql)
logger.info(f'获取role_id为{role_id}的信息成功') role_detail_result = await RoleService.role_detail_services(query_db, role_id)
return ResponseUtil.success(data=role_detail_result.model_dump(by_alias=True)) logger.info(f'获取role_id为{role_id}的信息成功')
except Exception as e:
logger.exception(e) return ResponseUtil.success(data=role_detail_result.model_dump(by_alias=True))
return ResponseUtil.error(msg=str(e))
@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) @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)): 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'))):
try: # 获取全量数据
# 获取全量数据 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, is_page=False) role_export_result = await RoleService.export_role_list_services(role_query_result)
role_export_result = await RoleService.export_role_list_services(role_query_result) logger.info('导出成功')
logger.info('导出成功')
return ResponseUtil.streaming(data=bytes2file_response(role_export_result)) 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'))]) @roleController.put("/changeStatus", dependencies=[Depends(CheckUserInterfaceAuth('system:role:edit'))])
@log_decorator(title='角色管理', business_type=BusinessType.UPDATE) @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)): 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'))):
try: await RoleService.check_role_allowed_services(change_role)
edit_role.update_by = current_user.user.user_name if not current_user.user.admin:
edit_role.update_time = datetime.now() await RoleService.check_role_data_scope_services(query_db, change_role.role_id, data_scope_sql)
edit_role.type = 'status' edit_role = AddRoleModel(
edit_role_result = await RoleService.edit_role_services(query_db, edit_role) roleId=change_role.role_id,
if edit_role_result.is_success: status=change_role.status,
logger.info(edit_role_result.message) updateBy=current_user.user.user_name,
return ResponseUtil.success(msg=edit_role_result.message) updateTime=datetime.now(),
else: type='status'
logger.warning(edit_role_result.message) )
return ResponseUtil.failure(msg=edit_role_result.message) edit_role_result = await RoleService.edit_role_services(query_db, edit_role)
except Exception as e: logger.info(edit_role_result.message)
logger.exception(e)
return ResponseUtil.error(msg=str(e)) return ResponseUtil.success(msg=edit_role_result.message)
@roleController.get("/authUser/allocatedList", response_model=PageResponseModel, dependencies=[Depends(CheckUserInterfaceAuth('system:role:list'))]) @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)): 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'))):
try: role_user_allocated_page_query_result = await RoleService.get_role_user_allocated_list_services(query_db, user_role, data_scope_sql, is_page=True)
role_user_allocated_page_query_result = await RoleService.get_role_user_allocated_list_services(query_db, user_role, is_page=True) logger.info('获取成功')
logger.info('获取成功')
return ResponseUtil.success(model_content=role_user_allocated_page_query_result) 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'))]) @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)): 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'))):
try: role_user_unallocated_page_query_result = await RoleService.get_role_user_unallocated_list_services(query_db, user_role, data_scope_sql, is_page=True)
role_user_unallocated_page_query_result = await RoleService.get_role_user_unallocated_list_services(query_db, user_role, is_page=True) logger.info('获取成功')
logger.info('获取成功')
return ResponseUtil.success(model_content=role_user_unallocated_page_query_result) 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'))]) @roleController.put("/authUser/selectAll", dependencies=[Depends(CheckUserInterfaceAuth('system:role:edit'))])
@log_decorator(title='角色管理', business_type=BusinessType.GRANT) @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)): 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'))):
try: if not current_user.user.admin:
add_role_user_result = await UserService.add_user_role_services(query_db, add_role_user) await RoleService.check_role_data_scope_services(query_db, add_role_user.role_id, data_scope_sql)
if add_role_user_result.is_success: add_role_user_result = await UserService.add_user_role_services(query_db, add_role_user)
logger.info(add_role_user_result.message) logger.info(add_role_user_result.message)
return ResponseUtil.success(msg=add_role_user_result.message)
else: return ResponseUtil.success(msg=add_role_user_result.message)
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'))]) @roleController.put("/authUser/cancel", dependencies=[Depends(CheckUserInterfaceAuth('system:role:edit'))])
@log_decorator(title='角色管理', business_type=BusinessType.GRANT) @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)):
try: cancel_user_role_result = await UserService.delete_user_role_services(query_db, cancel_user_role)
cancel_user_role_result = await UserService.delete_user_role_services(query_db, cancel_user_role) logger.info(cancel_user_role_result.message)
if cancel_user_role_result.is_success:
logger.info(cancel_user_role_result.message) return ResponseUtil.success(msg=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'))]) @roleController.put("/authUser/cancelAll", dependencies=[Depends(CheckUserInterfaceAuth('system:role:edit'))])
@log_decorator(title='角色管理', business_type=BusinessType.GRANT) @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)):
try: batch_cancel_user_role_result = await UserService.delete_user_role_services(query_db, batch_cancel_user_role)
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)
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)
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))

4
ruoyi-fastapi-backend/module_admin/controller/user_controller.py
View File

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

2
ruoyi-fastapi-backend/module_admin/dao/dept_dao.py
View File

@ -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 sqlalchemy.ext.asyncio import AsyncSession
from module_admin.entity.do.dept_do import SysDept from module_admin.entity.do.dept_do import SysDept
from module_admin.entity.do.role_do import SysRoleDept from module_admin.entity.do.role_do import SysRoleDept

53
ruoyi-fastapi-backend/module_admin/dao/role_dao.py
View File

@ -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 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.role_do import SysRole, SysRoleMenu, SysRoleDept
from module_admin.entity.do.dept_do import SysDept from module_admin.entity.do.dept_do import SysDept
from module_admin.entity.vo.role_vo import * from module_admin.entity.vo.role_vo import *
@ -96,15 +97,19 @@ class RoleDao:
return role_info return role_info
@classmethod @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 db: orm对象
:param query_object: 查询参数对象 :param query_object: 查询参数对象
:param data_scope_sql: 数据权限对应的查询sql语句
:param is_page: 是否开启分页 :param is_page: 是否开启分页
:return: 角色列表信息对象 :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', .where(SysRole.del_flag == '0',
SysRole.role_name.like(f'%{query_object.role_name}%') if query_object.role_name else True, 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.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( 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.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) \ if query_object.begin_time and query_object.end_time else True)
.order_by(SysRole.role_sort) \ .order_by(SysRole.role_sort)).subquery()
.distinct() 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) role_list = await PageUtil.paginate(db, query, query_object.page_num, query_object.page_size, is_page)
return role_list return role_list
@ -201,18 +209,23 @@ class RoleDao:
) )
@classmethod @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获取角色部门关联列表信息 根据角色id获取角色部门关联列表信息
:param db: orm对象 :param db: orm对象
:param role_id: 角色id :param role: 角色对象
:return: 角色部门关联列表信息 :return: 角色部门关联列表信息
""" """
role_dept_query_all = (await db.execute( role_dept_query_all = (await db.execute(
select(SysRoleDept) select(SysDept)
.where(SysRoleDept.role_id == role_id, .join(SysRoleDept, SysRoleDept.dept_id == SysDept.dept_id)
~select(SysDept).where(func.find_in_set(SysRoleDept.dept_id, SysDept.ancestors)).exists()) .where(SysRoleDept.role_id == role.role_id,
.distinct() ~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() )).scalars().all()
return role_dept_query_all return role_dept_query_all
@ -240,3 +253,19 @@ class RoleDao:
delete(SysRoleDept) delete(SysRoleDept)
.where(SysRoleDept.role_id.in_([role_dept.role_id])) .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

32
ruoyi-fastapi-backend/module_admin/dao/user_dao.py
View File

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

2
ruoyi-fastapi-backend/module_admin/entity/vo/role_vo.py
View File

@ -16,7 +16,7 @@ class RoleModel(BaseModel):
role_name: Optional[str] = Field(default=None, description='角色名称') role_name: Optional[str] = Field(default=None, description='角色名称')
role_key: Optional[str] = Field(default=None, description='角色权限字符串') role_key: Optional[str] = Field(default=None, description='角色权限字符串')
role_sort: Optional[int] = 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='菜单树选择项是否关联显示') menu_check_strictly: Optional[Union[int, bool]] = Field(default=None, description='菜单树选择项是否关联显示')
dept_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停用）') status: Optional[Literal['0', '1']] = Field(default=None, description='角色状态（0正常 1停用）')

147
ruoyi-fastapi-backend/module_admin/service/role_service.py
View File

@ -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.entity.vo.common_vo import CrudResponseModel
from module_admin.dao.user_dao import UserDao from module_admin.dao.user_dao import UserDao
from module_admin.dao.role_dao import * 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.page_util import PageResponseModel
from utils.common_util import export_list2excel, CamelCaseUtil from utils.common_util import export_list2excel, CamelCaseUtil
@ -30,7 +32,8 @@ class RoleService:
:param role_id: 角色id :param role_id: 角色id
:return: 当前角色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] checked_keys = [row.dept_id for row in role_dept_list]
result = RoleDeptQueryModel( result = RoleDeptQueryModel(
checkedKeys=checked_keys checkedKeys=checked_keys
@ -39,18 +42,74 @@ class RoleService:
return result return result
@classmethod @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 获取角色列表信息service
:param query_db: orm对象 :param query_db: orm对象
:param query_object: 查询参数对象 :param query_object: 查询参数对象
:param data_scope_sql: 数据权限对应的查询sql语句
:param is_page: 是否开启分页 :param is_page: 是否开启分页
:return: 角色列表信息对象 :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 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 @classmethod
async def add_role_services(cls, query_db: AsyncSession, page_object: AddRoleModel): async def add_role_services(cls, query_db: AsyncSession, page_object: AddRoleModel):
""" """
@ -60,12 +119,10 @@ class RoleService:
:return: 新增角色校验结果 :return: 新增角色校验结果
""" """
add_role = RoleModel(**page_object.model_dump(by_alias=True)) 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)) if not await cls.check_role_name_unique_services(query_db, page_object):
role_key = await RoleDao.get_role_by_info(query_db, RoleModel(roleKey=page_object.role_key)) raise ServiceException(message=f'新增角色{page_object.post_name}失败，角色名称已存在')
if role_name: elif not await cls.check_role_key_unique_services(query_db, page_object):
result = dict(is_success=False, message='角色名称已存在') raise ServiceException(message=f'新增角色{page_object.post_name}失败，角色权限已存在')
elif role_key:
result = dict(is_success=False, message='权限字符已存在')
else: else:
try: try:
add_result = await RoleDao.add_role_dao(query_db, add_role) add_result = await RoleDao.add_role_dao(query_db, add_role)
@ -74,13 +131,11 @@ class RoleService:
for menu in page_object.menu_ids: for menu in page_object.menu_ids:
await RoleDao.add_role_menu_dao(query_db, RoleMenuModel(roleId=role_id, menuId=menu)) await RoleDao.add_role_menu_dao(query_db, RoleMenuModel(roleId=role_id, menuId=menu))
await query_db.commit() await query_db.commit()
result = dict(is_success=True, message='新增成功') return CrudResponseModel(is_success=True, message='新增成功')
except Exception as e: except Exception as e:
await query_db.rollback() await query_db.rollback()
raise e raise e
return CrudResponseModel(**result)
@classmethod @classmethod
async def edit_role_services(cls, query_db: AsyncSession, page_object: AddRoleModel): async def edit_role_services(cls, query_db: AsyncSession, page_object: AddRoleModel):
""" """
@ -96,16 +151,11 @@ class RoleService:
del edit_role['type'] del edit_role['type']
role_info = await cls.role_detail_services(query_db, edit_role.get('role_id')) role_info = await cls.role_detail_services(query_db, edit_role.get('role_id'))
if role_info: if role_info:
if page_object.type != 'status' and role_info.role_name != page_object.role_name: if page_object.type != 'status':
role_name = await RoleDao.get_role_by_info(query_db, RoleModel(roleName=page_object.role_name)) if not await cls.check_role_name_unique_services(query_db, page_object):
if role_name: raise ServiceException(message=f'修改角色{page_object.post_name}失败，角色名称已存在')
result = dict(is_success=False, message='角色名称已存在') elif not await cls.check_role_key_unique_services(query_db, page_object):
return CrudResponseModel(**result) raise ServiceException(message=f'修改角色{page_object.post_name}失败，角色权限已存在')
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)
try: try:
await RoleDao.edit_role_dao(query_db, edit_role) await RoleDao.edit_role_dao(query_db, edit_role)
if page_object.type != 'status': if page_object.type != 'status':
@ -114,14 +164,12 @@ class RoleService:
for menu in 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() await query_db.commit()
result = dict(is_success=True, message='更新成功') return CrudResponseModel(is_success=True, message='更新成功')
except Exception as e: except Exception as e:
await query_db.rollback() await query_db.rollback()
raise e raise e
else: else:
result = dict(is_success=False, message='角色不存在') raise ServiceException(message='角色不存在')
return CrudResponseModel(**result)
@classmethod @classmethod
async def role_datascope_services(cls, query_db: AsyncSession, page_object: AddRoleModel): async def role_datascope_services(cls, query_db: AsyncSession, page_object: AddRoleModel):
@ -131,20 +179,9 @@ class RoleService:
:param page_object: 角色数据权限对象 :param page_object: 角色数据权限对象
:return: 分配角色数据权限结果 :return: 分配角色数据权限结果
""" """
edit_role = page_object.model_dump(exclude_unset=True, exclude={'admin'}) edit_role = page_object.model_dump(exclude_unset=True, exclude={'admin', 'dept_ids'})
del edit_role['dept_ids'] role_info = await cls.role_detail_services(query_db, page_object.role_id)
role_info = await cls.role_detail_services(query_db, edit_role.get('role_id')) if role_info.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)
try: try:
await RoleDao.edit_role_dao(query_db, edit_role) await RoleDao.edit_role_dao(query_db, edit_role)
await RoleDao.delete_role_dept_dao(query_db, RoleDeptModel(roleId=page_object.role_id)) 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: 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() await query_db.commit()
result = dict(is_success=True, message='分配成功') return CrudResponseModel(is_success=True, message='分配成功')
except Exception as e: except Exception as e:
await query_db.rollback() await query_db.rollback()
raise e raise e
else: else:
result = dict(is_success=False, message='角色不存在') raise ServiceException(message='角色不存在')
return CrudResponseModel(**result)
@classmethod @classmethod
async def delete_role_services(cls, query_db: AsyncSession, page_object: DeleteRoleModel): 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(',') role_id_list = page_object.role_ids.split(',')
try: try:
for role_id in role_id_list: 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) 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_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 RoleDao.delete_role_dao(query_db, RoleModel(**role_id_dict))
await query_db.commit() await query_db.commit()
result = dict(is_success=True, message='删除成功') return CrudResponseModel(is_success=True, message='删除成功')
except Exception as e: except Exception as e:
await query_db.rollback() await query_db.rollback()
raise e raise e
else: else:
result = dict(is_success=False, message='传入角色id为空') raise ServiceException(message='传入角色id为空')
return CrudResponseModel(**result)
@classmethod @classmethod
async def role_detail_services(cls, query_db: AsyncSession, role_id: int): async def role_detail_services(cls, query_db: AsyncSession, role_id: int):
@ -194,7 +232,10 @@ class RoleService:
:return: 角色id对应的信息 :return: 角色id对应的信息
""" """
role = await RoleDao.get_role_detail_by_id(query_db, role_id=role_id) role = await RoleDao.get_role_detail_by_id(query_db, role_id=role_id)
result = RoleModel(**CamelCaseUtil.transform_result(role)) if role:
result = RoleModel(**CamelCaseUtil.transform_result(role))
else:
result = RoleModel(**dict())
return result return result
@ -232,15 +273,16 @@ class RoleService:
return binary_data return binary_data
@classmethod @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获取已分配用户列表 根据角色id获取已分配用户列表
:param query_db: orm对象 :param query_db: orm对象
:param page_object: 用户关联角色对象 :param page_object: 用户关联角色对象
:param data_scope_sql: 数据权限对应的查询sql语句
:param is_page: 是否开启分页 :param is_page: 是否开启分页
:return: 已分配用户列表 :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( allocated_list = PageResponseModel(
**{ **{
**query_user_list.model_dump(by_alias=True), **query_user_list.model_dump(by_alias=True),
@ -251,15 +293,16 @@ class RoleService:
return allocated_list return allocated_list
@classmethod @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获取未分配用户列表 根据角色id获取未分配用户列表
:param query_db: orm对象 :param query_db: orm对象
:param page_object: 用户关联角色对象 :param page_object: 用户关联角色对象
:param data_scope_sql: 数据权限对应的查询sql语句
:param is_page: 是否开启分页 :param is_page: 是否开启分页
:return: 未分配用户列表 :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( unallocated_list = PageResponseModel(
**{ **{
**query_user_list.model_dump(by_alias=True), **query_user_list.model_dump(by_alias=True),

Write Preview
Loading…
Cancel
Save