perf: 优化用户管理模块service层及异常处理

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

@@ -22,155 +22,133 @@ userController = APIRouter(prefix='/system/user', dependencies=[Depends(LoginSer
 
 @userController.get("/deptTree", dependencies=[Depends(CheckUserInterfaceAuth('system:user:list'))])
 async def get_system_dept_tree(request: Request, 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)
+    logger.info('获取成功')
-        logger.info('获取成功')
+
-        return ResponseUtil.success(data=dept_query_result)
+    return ResponseUtil.success(data=dept_query_result)
-    except Exception as e:
-        logger.exception(e)
-        return ResponseUtil.error(msg=str(e))
 
 
 @userController.get("/list", response_model=PageResponseModel, dependencies=[Depends(CheckUserInterfaceAuth('system:user:list'))])
 async def get_system_user_list(request: Request, user_page_query: UserPageQueryModel = Depends(UserPageQueryModel.as_query), query_db: AsyncSession = Depends(get_db), data_scope_sql: str = Depends(GetDataScope('SysUser'))):
-    try:
+    # 获取分页数据
-        # 获取分页数据
+    user_page_query_result = await UserService.get_user_list_services(query_db, user_page_query, data_scope_sql, is_page=True)
-        user_page_query_result = await UserService.get_user_list_services(query_db, user_page_query, data_scope_sql, is_page=True)
+    logger.info('获取成功')
-        logger.info('获取成功')
+
-        return ResponseUtil.success(model_content=user_page_query_result)
+    return ResponseUtil.success(model_content=user_page_query_result)
-    except Exception as e:
-        logger.exception(e)
-        return ResponseUtil.error(msg=str(e))
 
 
 @userController.post("", dependencies=[Depends(CheckUserInterfaceAuth('system:user:add'))])
 @ValidateFields(validate_model='add_user')
 @log_decorator(title='用户管理', business_type=BusinessType.INSERT)
 async def add_system_user(request: Request, add_user: AddUserModel, query_db: AsyncSession = Depends(get_db), current_user: CurrentUserModel = Depends(LoginService.get_current_user)):
-    try:
+    add_user.password = PwdUtil.get_password_hash(add_user.password)
-        add_user.password = PwdUtil.get_password_hash(add_user.password)
+    add_user.create_by = current_user.user.user_name
-        add_user.create_by = current_user.user.user_name
+    add_user.create_time = datetime.now()
-        add_user.create_time = datetime.now()
+    add_user.update_by = current_user.user.user_name
-        add_user.update_by = current_user.user.user_name
+    add_user.update_time = datetime.now()
-        add_user.update_time = datetime.now()
+    add_user_result = await UserService.add_user_services(query_db, add_user)
-        add_user_result = await UserService.add_user_services(query_db, add_user)
+    logger.info(add_user_result.message)
-        if add_user_result.is_success:
+
-            logger.info(add_user_result.message)
+    return ResponseUtil.success(msg=add_user_result.message)
-            return ResponseUtil.success(msg=add_user_result.message)
-        else:
-            logger.warning(add_user_result.message)
-            return ResponseUtil.failure(msg=add_user_result.message)
-    except Exception as e:
-        logger.exception(e)
-        return ResponseUtil.error(msg=str(e))
 
 
 @userController.put("", dependencies=[Depends(CheckUserInterfaceAuth('system:user:edit'))])
 @ValidateFields(validate_model='edit_user')
 @log_decorator(title='用户管理', business_type=BusinessType.UPDATE)
-async def edit_system_user(request: Request, edit_user: EditUserModel, query_db: AsyncSession = Depends(get_db), current_user: CurrentUserModel = Depends(LoginService.get_current_user)):
+async def edit_system_user(request: Request, edit_user: EditUserModel, query_db: AsyncSession = Depends(get_db), current_user: CurrentUserModel = Depends(LoginService.get_current_user), data_scope_sql: str = Depends(GetDataScope('SysUser'))):
-    try:
+    await UserService.check_user_allowed_services(edit_user)
-        edit_user.update_by = current_user.user.user_name
+    if not current_user.user.admin:
-        edit_user.update_time = datetime.now()
+        await UserService.check_user_data_scope_services(query_db, edit_user.user_id, data_scope_sql)
-        edit_user_result = await UserService.edit_user_services(query_db, edit_user)
+    edit_user.update_by = current_user.user.user_name
-        if edit_user_result.is_success:
+    edit_user.update_time = datetime.now()
-            logger.info(edit_user_result.message)
+    edit_user_result = await UserService.edit_user_services(query_db, edit_user)
-            return ResponseUtil.success(msg=edit_user_result.message)
+    logger.info(edit_user_result.message)
-        else:
+
-            logger.warning(edit_user_result.message)
+    return ResponseUtil.success(msg=edit_user_result.message)
-            return ResponseUtil.failure(msg=edit_user_result.message)
-    except Exception as e:
-        logger.exception(e)
-        return ResponseUtil.error(msg=str(e))
 
 
 @userController.delete("/{user_ids}", dependencies=[Depends(CheckUserInterfaceAuth('system:user:remove'))])
 @log_decorator(title='用户管理', business_type=BusinessType.DELETE)
-async def delete_system_user(request: Request, user_ids: str, query_db: AsyncSession = Depends(get_db), current_user: CurrentUserModel = Depends(LoginService.get_current_user)):
+async def delete_system_user(request: Request, user_ids: str, query_db: AsyncSession = Depends(get_db), current_user: CurrentUserModel = Depends(LoginService.get_current_user), data_scope_sql: str = Depends(GetDataScope('SysUser'))):
-    try:
+    user_id_list = user_ids.split(',')
-        delete_user = DeleteUserModel(
+    if current_user.user.user_id in user_id_list:
-            userIds=user_ids,
+        logger.warning('当前登录用户不能删除')
-            updateBy=current_user.user.user_name,
+
-            updateTime=datetime.now()
+        return ResponseUtil.failure(msg='当前登录用户不能删除')
-        )
+    for user_id in user_id_list:
-        delete_user_result = await UserService.delete_user_services(query_db, delete_user)
+        if not current_user.user.admin:
-        if delete_user_result.is_success:
+            await UserService.check_user_allowed_services(UserModel(userId=int(user_id)))
-            logger.info(delete_user_result.message)
+        await UserService.check_user_data_scope_services(query_db, int(user_id), data_scope_sql)
-            return ResponseUtil.success(msg=delete_user_result.message)
+    delete_user = DeleteUserModel(
-        else:
+        userIds=user_ids,
-            logger.warning(delete_user_result.message)
+        updateBy=current_user.user.user_name,
-            return ResponseUtil.failure(msg=delete_user_result.message)
+        updateTime=datetime.now()
-    except Exception as e:
+    )
-        logger.exception(e)
+    delete_user_result = await UserService.delete_user_services(query_db, delete_user)
-        return ResponseUtil.error(msg=str(e))
+    logger.info(delete_user_result.message)
+
+    return ResponseUtil.success(msg=delete_user_result.message)
 
 
 @userController.put("/resetPwd", dependencies=[Depends(CheckUserInterfaceAuth('system:user:resetPwd'))])
 @log_decorator(title='用户管理', business_type=BusinessType.UPDATE)
-async def reset_system_user_pwd(request: Request, edit_user: EditUserModel, query_db: AsyncSession = Depends(get_db), current_user: CurrentUserModel = Depends(LoginService.get_current_user)):
+async def reset_system_user_pwd(request: Request, reset_user: EditUserModel, query_db: AsyncSession = Depends(get_db), current_user: CurrentUserModel = Depends(LoginService.get_current_user), data_scope_sql: str = Depends(GetDataScope('SysUser'))):
-    try:
+    await UserService.check_user_allowed_services(reset_user)
-        edit_user.password = PwdUtil.get_password_hash(edit_user.password)
+    if not current_user.user.admin:
-        edit_user.update_by = current_user.user.user_name
+        await UserService.check_user_data_scope_services(query_db, reset_user.user_id, data_scope_sql)
-        edit_user.update_time = datetime.now()
+    edit_user = EditUserModel(
-        edit_user.type = 'pwd'
+        userId=reset_user.user_id,
-        edit_user_result = await UserService.edit_user_services(query_db, edit_user)
+        password=PwdUtil.get_password_hash(reset_user.password),
-        if edit_user_result.is_success:
+        updateBy=current_user.user.user_name,
-            logger.info(edit_user_result.message)
+        updateTime=datetime.now(),
-            return ResponseUtil.success(msg=edit_user_result.message)
+        type='pwd'
-        else:
+    )
-            logger.warning(edit_user_result.message)
+    edit_user_result = await UserService.edit_user_services(query_db, edit_user)
-            return ResponseUtil.failure(msg=edit_user_result.message)
+    logger.info(edit_user_result.message)
-    except Exception as e:
+
-        logger.exception(e)
+    return ResponseUtil.success(msg=edit_user_result.message)
-        return ResponseUtil.error(msg=str(e))
 
 
 @userController.put("/changeStatus", dependencies=[Depends(CheckUserInterfaceAuth('system:user:edit'))])
 @log_decorator(title='用户管理', business_type=BusinessType.UPDATE)
-async def change_system_user_status(request: Request, edit_user: EditUserModel, query_db: AsyncSession = Depends(get_db), current_user: CurrentUserModel = Depends(LoginService.get_current_user)):
+async def change_system_user_status(request: Request, change_user: EditUserModel, query_db: AsyncSession = Depends(get_db), current_user: CurrentUserModel = Depends(LoginService.get_current_user), data_scope_sql: str = Depends(GetDataScope('SysUser'))):
-    try:
+    await UserService.check_user_allowed_services(change_user)
-        edit_user.update_by = current_user.user.user_name
+    if not current_user.user.admin:
-        edit_user.update_time = datetime.now()
+        await UserService.check_user_data_scope_services(query_db, change_user.user_id, data_scope_sql)
-        edit_user.type = 'status'
+    edit_user = EditUserModel(
-        edit_user_result = await UserService.edit_user_services(query_db, edit_user)
+        userId=change_user.user_id,
-        if edit_user_result.is_success:
+        status=change_user.status,
-            logger.info(edit_user_result.message)
+        updateBy=current_user.user.user_name,
-            return ResponseUtil.success(msg=edit_user_result.message)
+        updateTime=datetime.now(),
-        else:
+        type='status'
-            logger.warning(edit_user_result.message)
+    )
-            return ResponseUtil.failure(msg=edit_user_result.message)
+    edit_user_result = await UserService.edit_user_services(query_db, edit_user)
-    except Exception as e:
+    logger.info(edit_user_result.message)
-        logger.exception(e)
+
-        return ResponseUtil.error(msg=str(e))
+    return ResponseUtil.success(msg=edit_user_result.message)
 
 
 @userController.get("/profile", response_model=UserProfileModel)
 async def query_detail_system_user(request: Request, query_db: AsyncSession = Depends(get_db), current_user: CurrentUserModel = Depends(LoginService.get_current_user)):
-    try:
+    profile_user_result = await UserService.user_profile_services(query_db, current_user.user.user_id)
-        profile_user_result = await UserService.user_profile_services(query_db, current_user.user.user_id)
+    logger.info(f'获取user_id为{current_user.user.user_id}的信息成功')
-        logger.info(f'获取user_id为{current_user.user.user_id}的信息成功')
+
-        return ResponseUtil.success(model_content=profile_user_result)
+    return ResponseUtil.success(model_content=profile_user_result)
-    except Exception as e:
-        logger.exception(e)
-        return ResponseUtil.error(msg=str(e))
 
 
 @userController.get("/{user_id}", response_model=UserDetailModel, dependencies=[Depends(CheckUserInterfaceAuth('system:user:query'))])
 @userController.get("/", response_model=UserDetailModel, dependencies=[Depends(CheckUserInterfaceAuth('system:user:query'))])
 async def query_detail_system_user(request: Request, user_id: Optional[Union[int, str]] = '', query_db: AsyncSession = Depends(get_db), current_user: CurrentUserModel = Depends(LoginService.get_current_user)):
-    try:
+    detail_user_result = await UserService.user_detail_services(query_db, user_id)
-        detail_user_result = await UserService.user_detail_services(query_db, user_id)
+    logger.info(f'获取user_id为{user_id}的信息成功')
-        logger.info(f'获取user_id为{user_id}的信息成功')
+
-        return ResponseUtil.success(model_content=detail_user_result)
+    return ResponseUtil.success(model_content=detail_user_result)
-    except Exception as e:
-        logger.exception(e)
-        return ResponseUtil.error(msg=str(e))
 
 
 @userController.post("/profile/avatar")
 @log_decorator(title='个人信息', business_type=BusinessType.UPDATE)
 async def change_system_user_profile_avatar(request: Request, avatarfile: bytes = File(), query_db: AsyncSession = Depends(get_db), current_user: CurrentUserModel = Depends(LoginService.get_current_user)):
-    try:
+    if avatarfile:
         relative_path = f'avatar/{datetime.now().strftime("%Y")}/{datetime.now().strftime("%m")}/{datetime.now().strftime("%d")}'
         dir_path = os.path.join(UploadConfig.UPLOAD_PATH, relative_path)
         try:
@@ -189,134 +167,94 @@ async def change_system_user_profile_avatar(request: Request, avatarfile: bytes
             type='avatar'
         )
         edit_user_result = await UserService.edit_user_services(query_db, edit_user)
-        if edit_user_result.is_success:
+        logger.info(edit_user_result.message)
-            logger.info(edit_user_result.message)
+
-            return ResponseUtil.success(dict_content={'imgUrl': edit_user.avatar}, msg=edit_user_result.message)
+        return ResponseUtil.success(dict_content={'imgUrl': edit_user.avatar}, msg=edit_user_result.message)
-        else:
+    return ResponseUtil.failure(msg='上传图片异常，请联系管理员')
-            logger.warning(edit_user_result.message)
-            return ResponseUtil.failure(msg=edit_user_result.message)
-    except Exception as e:
-        logger.exception(e)
-        return ResponseUtil.error(msg=str(e))
 
 
 @userController.put("/profile")
 @log_decorator(title='个人信息', business_type=BusinessType.UPDATE)
 async def change_system_user_profile_info(request: Request, user_info: UserInfoModel, query_db: AsyncSession = Depends(get_db), current_user: CurrentUserModel = Depends(LoginService.get_current_user)):
-    try:
+    edit_user = EditUserModel(
-        edit_user = EditUserModel(
+        **user_info.model_dump(
-            **user_info.model_dump(
+            exclude_unset=True,
-                exclude_unset=True,
+            by_alias=True,
-                by_alias=True,
+            exclude={'role_ids', 'post_ids'}
-                exclude={'role_ids', 'post_ids'}
+        ),
-            ),
+        userId=current_user.user.user_id,
-            userId=current_user.user.user_id,
+        userName=current_user.user.user_name,
-            userName=current_user.user.user_name,
+        updateBy=current_user.user.user_name,
-            updateBy=current_user.user.user_name,
+        updateTime=datetime.now(),
-            updateTime=datetime.now(),
+        roleIds=current_user.user.role_ids.split(',') if current_user.user.role_ids else [],
-            roleIds=current_user.user.role_ids.split(',') if current_user.user.role_ids else [],
+        postIds=current_user.user.post_ids.split(',') if current_user.user.post_ids else [],
-            postIds=current_user.user.post_ids.split(',') if current_user.user.post_ids else [],
+        role=current_user.user.role
-            role=current_user.user.role
+    )
-        )
+    edit_user_result = await UserService.edit_user_services(query_db, edit_user)
-        edit_user_result = await UserService.edit_user_services(query_db, edit_user)
+    logger.info(edit_user_result.message)
-        if edit_user_result.is_success:
+
-            logger.info(edit_user_result.message)
+    return ResponseUtil.success(msg=edit_user_result.message)
-            return ResponseUtil.success(msg=edit_user_result.message)
-        else:
-            logger.warning(edit_user_result.message)
-            return ResponseUtil.failure(msg=edit_user_result.message)
-    except Exception as e:
-        logger.exception(e)
-        return ResponseUtil.error(msg=str(e))
 
 
 @userController.put("/profile/updatePwd")
 @log_decorator(title='个人信息', business_type=BusinessType.UPDATE)
 async def reset_system_user_password(request: Request, reset_password: ResetPasswordModel = Depends(ResetPasswordModel.as_query), query_db: AsyncSession = Depends(get_db), current_user: CurrentUserModel = Depends(LoginService.get_current_user)):
-    try:
+    reset_user = ResetUserModel(
-        reset_user = ResetUserModel(
+        userId=current_user.user.user_id,
-            userId=current_user.user.user_id,
+        oldPassword=reset_password.old_password,
-            oldPassword=reset_password.old_password,
+        password=PwdUtil.get_password_hash(reset_password.new_password),
-            password=PwdUtil.get_password_hash(reset_password.new_password),
+        updateBy=current_user.user.user_name,
-            updateBy=current_user.user.user_name,
+        updateTime=datetime.now()
-            updateTime=datetime.now()
+    )
-        )
+    reset_user_result = await UserService.reset_user_services(query_db, reset_user)
-        reset_user_result = await UserService.reset_user_services(query_db, reset_user)
+    logger.info(reset_user_result.message)
-        if reset_user_result.is_success:
+
-            logger.info(reset_user_result.message)
+    return ResponseUtil.success(msg=reset_user_result.message)
-            return ResponseUtil.success(msg=reset_user_result.message)
-        else:
-            logger.warning(reset_user_result.message)
-            return ResponseUtil.failure(msg=reset_user_result.message)
-    except Exception as e:
-        logger.exception(e)
-        return ResponseUtil.error(msg=str(e))
 
 
 @userController.post("/importData", dependencies=[Depends(CheckUserInterfaceAuth('system:user:import'))])
 @log_decorator(title='用户管理', business_type=BusinessType.IMPORT)
 async def batch_import_system_user(request: Request, file: UploadFile = File(...), update_support: bool = Query(alias='updateSupport'), query_db: AsyncSession = Depends(get_db), current_user: CurrentUserModel = Depends(LoginService.get_current_user)):
-    try:
+    batch_import_result = await UserService.batch_import_user_services(query_db, file, update_support, current_user)
-        batch_import_result = await UserService.batch_import_user_services(query_db, file, update_support, current_user)
+    logger.info(batch_import_result.message)
-        if batch_import_result.is_success:
+
-            logger.info(batch_import_result.message)
+    return ResponseUtil.success(msg=batch_import_result.message)
-            return ResponseUtil.success(msg=batch_import_result.message)
-        else:
-            logger.warning(batch_import_result.message)
-            return ResponseUtil.failure(msg=batch_import_result.message)
-    except Exception as e:
-        logger.exception(e)
-        return ResponseUtil.error(msg=str(e))
 
 
 @userController.post("/importTemplate", dependencies=[Depends(CheckUserInterfaceAuth('system:user:import'))])
 async def export_system_user_template(request: Request, query_db: AsyncSession = Depends(get_db)):
-    try:
+    user_import_template_result = await UserService.get_user_import_template_services()
-        user_import_template_result = await UserService.get_user_import_template_services()
+    logger.info('获取成功')
-        logger.info('获取成功')
+
-        return ResponseUtil.streaming(data=bytes2file_response(user_import_template_result))
+    return ResponseUtil.streaming(data=bytes2file_response(user_import_template_result))
-    except Exception as e:
-        logger.exception(e)
-        return ResponseUtil.error(msg=str(e))
 
 
 @userController.post("/export", dependencies=[Depends(CheckUserInterfaceAuth('system:user:export'))])
 @log_decorator(title='用户管理', business_type=BusinessType.EXPORT)
 async def export_system_user_list(request: Request, user_page_query: UserPageQueryModel = Depends(UserPageQueryModel.as_form), query_db: AsyncSession = Depends(get_db), data_scope_sql: str = Depends(GetDataScope('SysUser'))):
-    try:
+    # 获取全量数据
-        # 获取全量数据
+    user_query_result = await UserService.get_user_list_services(query_db, user_page_query, data_scope_sql, is_page=False)
-        user_query_result = await UserService.get_user_list_services(query_db, user_page_query, data_scope_sql, is_page=False)
+    user_export_result = await UserService.export_user_list_services(user_query_result)
-        user_export_result = await UserService.export_user_list_services(user_query_result)
+    logger.info('导出成功')
-        logger.info('导出成功')
+
-        return ResponseUtil.streaming(data=bytes2file_response(user_export_result))
+    return ResponseUtil.streaming(data=bytes2file_response(user_export_result))
-    except Exception as e:
-        logger.exception(e)
-        return ResponseUtil.error(msg=str(e))
 
 
 @userController.get("/authRole/{user_id}", response_model=UserRoleResponseModel, dependencies=[Depends(CheckUserInterfaceAuth('system:user:query'))])
 async def get_system_allocated_role_list(request: Request, user_id: int, query_db: AsyncSession = Depends(get_db)):
-    try:
+    user_role_query = UserRoleQueryModel(userId=user_id)
-        user_role_query = UserRoleQueryModel(userId=user_id)
+    user_role_allocated_query_result = await UserService.get_user_role_allocated_list_services(query_db, user_role_query)
-        user_role_allocated_query_result = await UserService.get_user_role_allocated_list_services(query_db, user_role_query)
+    logger.info('获取成功')
-        logger.info('获取成功')
+
-        return ResponseUtil.success(model_content=user_role_allocated_query_result)
+    return ResponseUtil.success(model_content=user_role_allocated_query_result)
-    except Exception as e:
-        logger.exception(e)
-        return ResponseUtil.error(msg=str(e))
 
 
 @userController.put("/authRole", response_model=UserRoleResponseModel, dependencies=[Depends(CheckUserInterfaceAuth('system:user:edit'))])
 @log_decorator(title='用户管理', business_type=BusinessType.GRANT)
-async def update_system_role_user(request: Request, user_id: int = Query(alias='userId'), role_ids: str = Query(alias='roleIds'), query_db: AsyncSession = Depends(get_db)):
+async def update_system_role_user(request: Request, user_id: int = Query(alias='userId'), role_ids: str = Query(alias='roleIds'), query_db: AsyncSession = Depends(get_db), current_user: CurrentUserModel = Depends(LoginService.get_current_user), data_scope_sql: str = Depends(GetDataScope('SysUser'))):
-    try:
+    if not current_user.user.admin:
-        add_user_role_result = await UserService.add_user_role_services(query_db, CrudUserRoleModel(userId=user_id, roleIds=role_ids))
+        await UserService.check_user_data_scope_services(query_db, user_id, data_scope_sql)
-        if add_user_role_result.is_success:
+    add_user_role_result = await UserService.add_user_role_services(query_db, CrudUserRoleModel(userId=user_id, roleIds=role_ids))
-            logger.info(add_user_role_result.message)
+    logger.info(add_user_role_result.message)
-            return ResponseUtil.success(msg=add_user_role_result.message)
+
-        else:
+    return ResponseUtil.success(msg=add_user_role_result.message)
-            logger.warning(add_user_role_result.message)
-            return ResponseUtil.failure(msg=add_user_role_result.message)
-    except Exception as e:
-        logger.exception(e)
-        return ResponseUtil.error(msg=str(e))

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

@@ -42,7 +42,10 @@ class UserDao:
         """
         query_user_info = (await db.execute(
             select(SysUser)
-                .where(SysUser.del_flag == '0', SysUser.user_name == user.user_name)
+                .where(SysUser.del_flag == '0',
+                       SysUser.user_name == user.user_name if user.user_name else True,
+                       SysUser.phonenumber == user.phonenumber if user.phonenumber else True,
+                       SysUser.email == user.email if user.email else True)
                 .order_by(desc(SysUser.create_time))
                 .distinct()
         )).scalars().first()
@@ -190,6 +193,7 @@ class UserDao:
                    or_(SysUser.dept_id == query_object.dept_id, SysUser.dept_id.in_(
                        select(SysDept.dept_id).where(func.find_in_set(query_object.dept_id, SysDept.ancestors))
                    )) if query_object.dept_id else True,
+                   SysUser.user_id == query_object.user_id if query_object.user_id is not None else True,
                    SysUser.user_name.like(f'%{query_object.user_name}%') if query_object.user_name else True,
                    SysUser.nick_name.like(f'%{query_object.nick_name}%') if query_object.nick_name else True,
                    SysUser.email.like(f'%{query_object.email}%') if query_object.email else True,

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

@@ -3,6 +3,8 @@ from module_admin.service.role_service import RoleService
 from module_admin.service.post_service import PostService, PostPageQueryModel
 from module_admin.entity.vo.common_vo import CrudResponseModel
 from module_admin.dao.user_dao import *
+from config.constant import CommonConstant
+from exceptions.exception import ServiceException
 from utils.page_util import PageResponseModel
 from utils.pwd_util import *
 from utils.common_util import *
@@ -38,6 +40,75 @@ class UserService:
 
         return user_list_result
 
+    @classmethod
+    async def check_user_allowed_services(cls, check_user: UserModel):
+        """
+        校验用户是否允许操作service
+        :param check_user: 用户信息
+        :return: 校验结果
+        """
+        if check_user.admin:
+            raise ServiceException(message='不允许操作超级管理员用户')
+        else:
+            return CrudResponseModel(is_success=True, message='校验通过')
+
+    @classmethod
+    async def check_user_data_scope_services(cls, query_db: AsyncSession, user_id: int, data_scope_sql: str):
+        """
+        校验用户数据权限service
+        :param query_db: orm对象
+        :param user_id: 用户id
+        :param data_scope_sql: 数据权限对应的查询sql语句
+        :return: 校验结果
+        """
+        users = await UserDao.get_user_list(query_db, UserPageQueryModel(userId=user_id), data_scope_sql, is_page=False)
+        if users:
+            return CrudResponseModel(is_success=True, message='校验通过')
+        else:
+            raise ServiceException(message='没有权限访问用户数据')
+
+    @classmethod
+    async def check_user_name_unique_services(cls, query_db: AsyncSession, page_object: UserModel):
+        """
+        校验用户名是否唯一service
+        :param query_db: orm对象
+        :param page_object: 用户对象
+        :return: 校验结果
+        """
+        user_id = -1 if page_object.user_id is None else page_object.user_id
+        user = await UserDao.get_user_by_info(query_db, UserModel(userName=page_object.user_name))
+        if user and user.user_id != user_id:
+            return CommonConstant.NOT_UNIQUE
+        return CommonConstant.UNIQUE
+
+    @classmethod
+    async def check_phonenumber_unique_services(cls, query_db: AsyncSession, page_object: UserModel):
+        """
+        校验用户手机号是否唯一service
+        :param query_db: orm对象
+        :param page_object: 用户对象
+        :return: 校验结果
+        """
+        user_id = -1 if page_object.user_id is None else page_object.user_id
+        user = await UserDao.get_user_by_info(query_db, UserModel(phonenumber=page_object.phonenumber))
+        if user and user.user_id != user_id:
+            return CommonConstant.NOT_UNIQUE
+        return CommonConstant.UNIQUE
+
+    @classmethod
+    async def check_email_unique_services(cls, query_db: AsyncSession, page_object: UserModel):
+        """
+        校验用户邮箱是否唯一service
+        :param query_db: orm对象
+        :param page_object: 用户对象
+        :return: 校验结果
+        """
+        user_id = -1 if page_object.user_id is None else page_object.user_id
+        user = await UserDao.get_user_by_info(query_db, UserModel(email=page_object.email))
+        if user and user.user_id != user_id:
+            return CommonConstant.NOT_UNIQUE
+        return CommonConstant.UNIQUE
+
     @classmethod
     async def add_user_services(cls, query_db: AsyncSession, page_object: AddUserModel):
         """
@@ -47,9 +118,12 @@ class UserService:
         :return: 新增用户校验结果
         """
         add_user = UserModel(**page_object.model_dump(by_alias=True))
-        user = await UserDao.get_user_by_info(query_db, UserModel(userName=page_object.user_name))
+        if not await cls.check_user_name_unique_services(query_db, page_object):
-        if user:
+            raise ServiceException(message=f'新增用户{page_object.user_name}失败，登录账号已存在')
-            result = dict(is_success=False, message='用户名已存在')
+        elif page_object.phonenumber and not await cls.check_phonenumber_unique_services(query_db, page_object):
+            raise ServiceException(message=f'新增用户{page_object.user_name}失败，手机号码已存在')
+        elif page_object.email and not await cls.check_email_unique_services(query_db, page_object):
+            raise ServiceException(message=f'新增用户{page_object.user_name}失败，邮箱账号已存在')
         else:
             try:
                 add_result = await UserDao.add_user_dao(query_db, add_user)
@@ -61,13 +135,11 @@ class UserService:
                     for post in page_object.post_ids:
                         await UserDao.add_user_post_dao(query_db, UserPostModel(userId=user_id, postId=post))
                 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_user_services(cls, query_db: AsyncSession, page_object: EditUserModel):
         """
@@ -84,12 +156,14 @@ class UserService:
         if page_object.type == 'status' or page_object.type == 'avatar' or page_object.type == 'pwd':
             del edit_user['type']
         user_info = await cls.user_detail_services(query_db, edit_user.get('user_id'))
-        if user_info:
+        if user_info.data and user_info.data.user_id:
-            if page_object.type != 'status' and page_object.type != 'avatar' and page_object.type == 'pwd' and user_info.data.user_name != page_object.user_name:
+            if page_object.type != 'status' and page_object.type != 'avatar' and page_object.type != 'pwd':
-                user = await UserDao.get_user_by_info(query_db, UserModel(userName=page_object.user_name))
+                if not await cls.check_user_name_unique_services(query_db, page_object):
-                if user:
+                    raise ServiceException(message=f'修改用户{page_object.user_name}失败，登录账号已存在')
-                    result = dict(is_success=False, message='用户名已存在')
+                elif page_object.phonenumber and not await cls.check_phonenumber_unique_services(query_db, page_object):
-                    return CrudResponseModel(**result)
+                    raise ServiceException(message=f'修改用户{page_object.user_name}失败，手机号码已存在')
+                elif page_object.email and not await cls.check_email_unique_services(query_db, page_object):
+                    raise ServiceException(message=f'修改用户{page_object.user_name}失败，邮箱账号已存在')
             try:
                 await UserDao.edit_user_dao(query_db, edit_user)
                 if page_object.type != 'status' and page_object.type != 'avatar' and page_object.type != 'pwd':
@@ -102,14 +176,12 @@ class UserService:
                         for post in page_object.post_ids:
                             await UserDao.add_user_post_dao(query_db, UserPostModel(userId=page_object.user_id, postId=post))
                 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='用户不存在')
+            raise ServiceException(message='用户不存在')
-
-        return CrudResponseModel(**result)
 
     @classmethod
     async def delete_user_services(cls, query_db: AsyncSession, page_object: DeleteUserModel):
@@ -128,13 +200,12 @@ class UserService:
                     await UserDao.delete_user_post_dao(query_db, UserPostModel(**user_id_dict))
                     await UserDao.delete_user_dao(query_db, UserModel(**user_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为空')
+            raise ServiceException(message='传入用户id为空')
-        return CrudResponseModel(**result)
 
     @classmethod
     async def user_detail_services(cls, query_db: AsyncSession, user_id: Union[int, str]):
@@ -210,8 +281,9 @@ class UserService:
         if page_object.old_password:
             user = (await UserDao.get_user_detail_by_id(query_db, user_id=page_object.user_id)).get('user_basic_info')
             if not PwdUtil.verify_password(page_object.old_password, user.password):
-                result = dict(is_success=False, message='旧密码不正确')
+                raise ServiceException(message='修改密码失败，旧密码错误')
-                return CrudResponseModel(**result)
+            elif PwdUtil.verify_password(page_object.password, user.password):
+                raise ServiceException(message='新密码不能与旧密码相同')
             else:
                 del reset_user['old_password']
         if page_object.sms_code and page_object.session_id:
@@ -220,13 +292,11 @@ class UserService:
         try:
             await UserDao.edit_user_dao(query_db, reset_user)
             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 batch_import_user_services(cls, query_db: AsyncSession, file: UploadFile, update_support: bool, current_user: CurrentUserModel):
         """
@@ -300,13 +370,11 @@ class UserService:
                 else:
                     await UserDao.add_user_dao(query_db, add_user)
             await query_db.commit()
-            result = dict(is_success=True, message='\n'.join(add_error_result))
+            return CrudResponseModel(is_success=True, message='\n'.join(add_error_result))
         except Exception as e:
             await query_db.rollback()
             raise e
 
-        return CrudResponseModel(**result)
-
     @staticmethod
     async def get_user_import_template_services():
         """
@@ -410,7 +478,7 @@ class UserService:
                     else:
                         await UserDao.add_user_role_dao(query_db, UserRoleModel(userId=page_object.user_id, roleId=role_id))
                 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
@@ -418,7 +486,7 @@ class UserService:
             try:
                 await UserDao.delete_user_role_by_user_and_role_dao(query_db, UserRoleModel(userId=page_object.user_id))
                 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
@@ -432,14 +500,12 @@ class UserService:
                     else:
                         await UserDao.add_user_role_dao(query_db, UserRoleModel(userId=user_id, roleId=page_object.role_id))
                 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='不满足新增条件')
+            raise ServiceException(message='不满足新增条件')
-
-        return CrudResponseModel(**result)
 
     @classmethod
     async def delete_user_role_services(cls, query_db: AsyncSession, page_object: CrudUserRoleModel):
@@ -454,7 +520,7 @@ class UserService:
                 try:
                     await UserDao.delete_user_role_by_user_and_role_dao(query_db, UserRoleModel(userId=page_object.user_id, roleId=page_object.role_id))
                     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
@@ -464,16 +530,14 @@ class UserService:
                     for user_id in user_id_list:
                         await UserDao.delete_user_role_by_user_and_role_dao(query_db, UserRoleModel(userId=user_id, roleId=page_object.role_id))
                     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='不满足删除条件')
+                raise ServiceException(message='不满足删除条件')
         else:
-            result = dict(is_success=False, message='传入用户角色关联信息为空')
+            raise ServiceException(message='传入用户角色关联信息为空')
-
-        return CrudResponseModel(**result)
 
     @classmethod
     async def detail_user_role_services(cls, query_db: AsyncSession, page_object: UserRoleModel):