refactor: 重构数据库orm为异步 #I9MRQS

ruoyi-fastapi-backend/module_admin/annotation/log_annotation.py

@@ -131,7 +131,7 @@ def log_decorator(title: str, business_type: int, log_type: Optional[str] = 'ope
                     login_log['status'] = str(status)
                     login_log['msg'] = result_dict.get('msg')
 
-                    LoginLogService.add_login_log_services(query_db, LogininforModel(**login_log))
+                    await LoginLogService.add_login_log_services(query_db, LogininforModel(**login_log))
             else:
                 current_user = await LoginService.get_current_user(request, token, query_db)
                 oper_name = current_user.user.user_name
@@ -154,7 +154,7 @@ def log_decorator(title: str, business_type: int, log_type: Optional[str] = 'ope
                     operTime=oper_time,
                     costTime=int(cost_time)
                 )
-                OperationLogService.add_operation_log_services(query_db, operation_log)
+                await OperationLogService.add_operation_log_services(query_db, operation_log)
 
             return result
 

ruoyi-fastapi-backend/module_admin/aspect/data_scope.py

@@ -24,11 +24,11 @@ class GetDataScope:
         if self.query_alias == '' or max_data_scope == 1 or user_id == 1:
             param_sql = '1 == 1'
         elif max_data_scope == 2:
-            param_sql = f"{self.query_alias}.{self.dept_alias}.in_({self.db_alias}.query(SysRoleDept.dept_id).filter(SysRoleDept.role_id == {max_role_id})) if hasattr({self.query_alias}, '{self.dept_alias}') else 1 == 1"
+            param_sql = f"{self.query_alias}.{self.dept_alias}.in_(select(SysRoleDept.dept_id).where(SysRoleDept.role_id == {max_role_id})) if hasattr({self.query_alias}, '{self.dept_alias}') else 1 == 1"
         elif max_data_scope == 3:
             param_sql = f"{self.query_alias}.{self.dept_alias} == {dept_id} if hasattr({self.query_alias}, '{self.dept_alias}') else 1 == 1"
         elif max_data_scope == 4:
-            param_sql = f"{self.query_alias}.{self.dept_alias}.in_({self.db_alias}.query(SysDept.dept_id).filter(or_(SysDept.dept_id == {dept_id}, func.find_in_set({dept_id}, SysDept.ancestors)))) if hasattr({self.query_alias}, '{self.dept_alias}') else 1 == 1"
+            param_sql = f"{self.query_alias}.{self.dept_alias}.in_(select(SysDept.dept_id).where(or_(SysDept.dept_id == {dept_id}, func.find_in_set({dept_id}, SysDept.ancestors)))) if hasattr({self.query_alias}, '{self.dept_alias}') else 1 == 1"
         elif max_data_scope == 5:
             param_sql = f"{self.query_alias}.{self.user_alias} == {user_id} if hasattr({self.query_alias}, '{self.user_alias}') else 1 == 1"
         else:

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

@@ -26,7 +26,7 @@ async def get_monitor_cache_info(request: Request):
 async def get_monitor_cache_name(request: Request):
     try:
         # 获取全量数据
-        cache_name_list_result = CacheService.get_cache_monitor_cache_name_services()
+        cache_name_list_result = await CacheService.get_cache_monitor_cache_name_services()
         logger.info('获取成功')
         return ResponseUtil.success(data=cache_name_list_result)
     except Exception as e:

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

@@ -18,7 +18,7 @@ async def get_captcha_image(request: Request):
         register_enabled = True if await request.app.state.redis.get(
             f"{RedisInitKeyConfig.SYS_CONFIG.get('key')}:sys.account.registerUser") == 'true' else False
         session_id = str(uuid.uuid4())
-        captcha_result = CaptchaService.create_captcha_image_service()
+        captcha_result = await CaptchaService.create_captcha_image_service()
         image = captcha_result[0]
         computed_result = captcha_result[1]
         await request.app.state.redis.set(f"{RedisInitKeyConfig.CAPTCHA_CODES.get('key')}:{session_id}", computed_result, ex=timedelta(minutes=2))

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

@@ -11,7 +11,7 @@ commonController = APIRouter(prefix='/common', dependencies=[Depends(LoginServic
 @commonController.post("/upload")
 async def common_upload(request: Request, file: UploadFile = File(...)):
     try:
-        upload_result = CommonService.upload_service(request, file)
+        upload_result = await CommonService.upload_service(request, file)
         if upload_result.is_success:
             logger.info('上传成功')
             return ResponseUtil.success(model_content=upload_result.result)
@@ -26,7 +26,7 @@ async def common_upload(request: Request, file: UploadFile = File(...)):
 @commonController.get("/download")
 async def common_download(request: Request, background_tasks: BackgroundTasks, file_name: str = Query(alias='fileName'), delete: bool = Query()):
     try:
-        download_result = CommonService.download_services(background_tasks, file_name, delete)
+        download_result = await CommonService.download_services(background_tasks, file_name, delete)
         if download_result.is_success:
             logger.info(download_result.message)
             return ResponseUtil.streaming(data=download_result.result)
@@ -41,7 +41,7 @@ async def common_download(request: Request, background_tasks: BackgroundTasks, f
 @commonController.get("/download/resource")
 async def common_download(request: Request, resource: str = Query()):
     try:
-        download_resource_result = CommonService.download_resource_services(resource)
+        download_resource_result = await CommonService.download_resource_services(resource)
         if download_resource_result.is_success:
             logger.info(download_resource_result.message)
             return ResponseUtil.streaming(data=download_resource_result.result)

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

@@ -15,10 +15,10 @@ configController = APIRouter(prefix='/system/config', dependencies=[Depends(Logi
 
 
 @configController.get("/list", response_model=PageResponseModel, dependencies=[Depends(CheckUserInterfaceAuth('system:config:list'))])
-async def get_system_config_list(request: Request, config_page_query: ConfigPageQueryModel = Depends(ConfigPageQueryModel.as_query), query_db: Session = Depends(get_db)):
+async def get_system_config_list(request: Request, config_page_query: ConfigPageQueryModel = Depends(ConfigPageQueryModel.as_query), query_db: AsyncSession = Depends(get_db)):
     try:
         # 获取分页数据
-        config_page_query_result = ConfigService.get_config_list_services(query_db, config_page_query, is_page=True)
+        config_page_query_result = await ConfigService.get_config_list_services(query_db, config_page_query, is_page=True)
         logger.info('获取成功')
         return ResponseUtil.success(model_content=config_page_query_result)
     except Exception as e:
@@ -28,7 +28,7 @@ async def get_system_config_list(request: Request, config_page_query: ConfigPage
 
 @configController.post("", dependencies=[Depends(CheckUserInterfaceAuth('system:config:add'))])
 @log_decorator(title='参数管理', business_type=1)
-async def add_system_config(request: Request, add_config: ConfigModel, query_db: Session = Depends(get_db), current_user: CurrentUserModel = Depends(LoginService.get_current_user)):
+async def add_system_config(request: Request, add_config: ConfigModel, query_db: AsyncSession = Depends(get_db), current_user: CurrentUserModel = Depends(LoginService.get_current_user)):
     try:
         add_config.create_by = current_user.user.user_name
         add_config.update_by = current_user.user.user_name
@@ -46,7 +46,7 @@ async def add_system_config(request: Request, add_config: ConfigModel, query_db:
 
 @configController.put("", dependencies=[Depends(CheckUserInterfaceAuth('system:config:edit'))])
 @log_decorator(title='参数管理', business_type=2)
-async def edit_system_config(request: Request, edit_config: ConfigModel, query_db: Session = Depends(get_db), current_user: CurrentUserModel = Depends(LoginService.get_current_user)):
+async def edit_system_config(request: Request, edit_config: ConfigModel, query_db: AsyncSession = Depends(get_db), current_user: CurrentUserModel = Depends(LoginService.get_current_user)):
     try:
         edit_config.update_by = current_user.user.user_name
         edit_config.update_time = datetime.now()
@@ -64,7 +64,7 @@ async def edit_system_config(request: Request, edit_config: ConfigModel, query_d
 
 @configController.delete("/refreshCache", dependencies=[Depends(CheckUserInterfaceAuth('system:config:remove'))])
 @log_decorator(title='参数管理', business_type=2)
-async def refresh_system_config(request: Request, query_db: Session = Depends(get_db)):
+async def refresh_system_config(request: Request, query_db: AsyncSession = Depends(get_db)):
     try:
         refresh_config_result = await ConfigService.refresh_sys_config_services(request, query_db)
         if refresh_config_result.is_success:
@@ -80,7 +80,7 @@ async def refresh_system_config(request: Request, query_db: Session = Depends(ge
 
 @configController.delete("/{config_ids}", dependencies=[Depends(CheckUserInterfaceAuth('system:config:remove'))])
 @log_decorator(title='参数管理', business_type=3)
-async def delete_system_config(request: Request, config_ids: str, query_db: Session = Depends(get_db)):
+async def delete_system_config(request: Request, config_ids: str, query_db: AsyncSession = Depends(get_db)):
     try:
         delete_config = DeleteConfigModel(configIds=config_ids)
         delete_config_result = await ConfigService.delete_config_services(request, query_db, delete_config)
@@ -96,9 +96,9 @@ async def delete_system_config(request: Request, config_ids: str, query_db: Sess
 
 
 @configController.get("/{config_id}", response_model=ConfigModel, dependencies=[Depends(CheckUserInterfaceAuth('system:config:query'))])
-async def query_detail_system_config(request: Request, config_id: int, query_db: Session = Depends(get_db)):
+async def query_detail_system_config(request: Request, config_id: int, query_db: AsyncSession = Depends(get_db)):
     try:
-        config_detail_result = ConfigService.config_detail_services(query_db, config_id)
+        config_detail_result = await ConfigService.config_detail_services(query_db, config_id)
         logger.info(f'获取config_id为{config_id}的信息成功')
         return ResponseUtil.success(data=config_detail_result)
     except Exception as e:
@@ -120,11 +120,11 @@ async def query_system_config(request: Request, config_key: str):
 
 @configController.post("/export", dependencies=[Depends(CheckUserInterfaceAuth('system:config:export'))])
 @log_decorator(title='参数管理', business_type=5)
-async def export_system_config_list(request: Request, config_page_query: ConfigPageQueryModel = Depends(ConfigPageQueryModel.as_form), query_db: Session = Depends(get_db)):
+async def export_system_config_list(request: Request, config_page_query: ConfigPageQueryModel = Depends(ConfigPageQueryModel.as_form), query_db: AsyncSession = Depends(get_db)):
     try:
         # 获取全量数据
-        config_query_result = ConfigService.get_config_list_services(query_db, config_page_query, is_page=False)
-        config_export_result = ConfigService.export_config_list_services(config_query_result)
+        config_query_result = await ConfigService.get_config_list_services(query_db, config_page_query, is_page=False)
+        config_export_result = await ConfigService.export_config_list_services(config_query_result)
         logger.info('导出成功')
         return ResponseUtil.streaming(data=bytes2file_response(config_export_result))
     except Exception as e:

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

@@ -14,10 +14,10 @@ deptController = APIRouter(prefix='/system/dept', dependencies=[Depends(LoginSer
 
 
 @deptController.get("/list/exclude/{dept_id}", response_model=List[DeptModel], dependencies=[Depends(CheckUserInterfaceAuth('system:dept:list'))])
-async def get_system_dept_tree_for_edit_option(request: Request, dept_id: int, query_db: Session = Depends(get_db), data_scope_sql: str = Depends(GetDataScope('SysDept'))):
+async def get_system_dept_tree_for_edit_option(request: Request, dept_id: int, query_db: AsyncSession = Depends(get_db), data_scope_sql: str = Depends(GetDataScope('SysDept'))):
     try:
         dept_query = DeptModel(deptId=dept_id)
-        dept_query_result = DeptService.get_dept_for_edit_option_services(query_db, dept_query, data_scope_sql)
+        dept_query_result = await DeptService.get_dept_for_edit_option_services(query_db, dept_query, data_scope_sql)
         logger.info('获取成功')
         return ResponseUtil.success(data=dept_query_result)
     except Exception as e:
@@ -26,9 +26,9 @@ async def get_system_dept_tree_for_edit_option(request: Request, dept_id: int, q
 
 
 @deptController.get("/list", response_model=List[DeptModel], dependencies=[Depends(CheckUserInterfaceAuth('system:dept:list'))])
-async def get_system_dept_list(request: Request, dept_query: DeptQueryModel = Depends(DeptQueryModel.as_query), query_db: Session = Depends(get_db), data_scope_sql: str = Depends(GetDataScope('SysDept'))):
+async def get_system_dept_list(request: Request, dept_query: DeptQueryModel = Depends(DeptQueryModel.as_query), query_db: AsyncSession = Depends(get_db), data_scope_sql: str = Depends(GetDataScope('SysDept'))):
     try:
-        dept_query_result = DeptService.get_dept_list_services(query_db, dept_query, data_scope_sql)
+        dept_query_result = await DeptService.get_dept_list_services(query_db, dept_query, data_scope_sql)
         logger.info('获取成功')
         return ResponseUtil.success(data=dept_query_result)
     except Exception as e:
@@ -38,11 +38,11 @@ async def get_system_dept_list(request: Request, dept_query: DeptQueryModel = De
 
 @deptController.post("", dependencies=[Depends(CheckUserInterfaceAuth('system:dept:add'))])
 @log_decorator(title='部门管理', business_type=1)
-async def add_system_dept(request: Request, add_dept: DeptModel, query_db: Session = Depends(get_db), current_user: CurrentUserModel = Depends(LoginService.get_current_user)):
+async def add_system_dept(request: Request, add_dept: DeptModel, query_db: AsyncSession = Depends(get_db), current_user: CurrentUserModel = Depends(LoginService.get_current_user)):
     try:
         add_dept.create_by = current_user.user.user_name
         add_dept.update_by = current_user.user.user_name
-        add_dept_result = DeptService.add_dept_services(query_db, add_dept)
+        add_dept_result = await DeptService.add_dept_services(query_db, add_dept)
         if add_dept_result.is_success:
             logger.info(add_dept_result.message)
             return ResponseUtil.success(data=add_dept_result)
@@ -56,11 +56,11 @@ async def add_system_dept(request: Request, add_dept: DeptModel, query_db: Sessi
 
 @deptController.put("", dependencies=[Depends(CheckUserInterfaceAuth('system:dept:edit'))])
 @log_decorator(title='部门管理', business_type=2)
-async def edit_system_dept(request: Request, edit_dept: DeptModel, query_db: Session = Depends(get_db), current_user: CurrentUserModel = Depends(LoginService.get_current_user)):
+async def edit_system_dept(request: Request, edit_dept: DeptModel, query_db: AsyncSession = Depends(get_db), current_user: CurrentUserModel = Depends(LoginService.get_current_user)):
     try:
         edit_dept.update_by = current_user.user.user_name
         edit_dept.update_time = datetime.now()
-        edit_dept_result = DeptService.edit_dept_services(query_db, edit_dept)
+        edit_dept_result = await DeptService.edit_dept_services(query_db, edit_dept)
         if edit_dept_result.is_success:
             logger.info(edit_dept_result.message)
             return ResponseUtil.success(msg=edit_dept_result.message)
@@ -74,12 +74,12 @@ async def edit_system_dept(request: Request, edit_dept: DeptModel, query_db: Ses
 
 @deptController.delete("/{dept_ids}", dependencies=[Depends(CheckUserInterfaceAuth('system:dept:remove'))])
 @log_decorator(title='部门管理', business_type=3)
-async def delete_system_dept(request: Request, dept_ids: str, query_db: Session = Depends(get_db), current_user: CurrentUserModel = Depends(LoginService.get_current_user)):
+async def delete_system_dept(request: Request, dept_ids: str, query_db: AsyncSession = Depends(get_db), current_user: CurrentUserModel = Depends(LoginService.get_current_user)):
     try:
         delete_dept = DeleteDeptModel(deptIds=dept_ids)
         delete_dept.update_by = current_user.user.user_name
         delete_dept.update_time = datetime.now()
-        delete_dept_result = DeptService.delete_dept_services(query_db, delete_dept)
+        delete_dept_result = await DeptService.delete_dept_services(query_db, delete_dept)
         if delete_dept_result.is_success:
             logger.info(delete_dept_result.message)
             return ResponseUtil.success(msg=delete_dept_result.message)
@@ -92,9 +92,9 @@ async def delete_system_dept(request: Request, dept_ids: str, query_db: Session
 
 
 @deptController.get("/{dept_id}", response_model=DeptModel, dependencies=[Depends(CheckUserInterfaceAuth('system:dept:query'))])
-async def query_detail_system_dept(request: Request, dept_id: int, query_db: Session = Depends(get_db)):
+async def query_detail_system_dept(request: Request, dept_id: int, query_db: AsyncSession = Depends(get_db)):
     try:
-        detail_dept_result = DeptService.dept_detail_services(query_db, dept_id)
+        detail_dept_result = await DeptService.dept_detail_services(query_db, dept_id)
         logger.info(f'获取dept_id为{dept_id}的信息成功')
         return ResponseUtil.success(data=detail_dept_result)
     except Exception as e:

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

@@ -15,10 +15,10 @@ dictController = APIRouter(prefix='/system/dict', dependencies=[Depends(LoginSer
 
 
 @dictController.get("/type/list", response_model=PageResponseModel, dependencies=[Depends(CheckUserInterfaceAuth('system:dict:list'))])
-async def get_system_dict_type_list(request: Request, dict_type_page_query: DictTypePageQueryModel = Depends(DictTypePageQueryModel.as_query), query_db: Session = Depends(get_db)):
+async def get_system_dict_type_list(request: Request, dict_type_page_query: DictTypePageQueryModel = Depends(DictTypePageQueryModel.as_query), query_db: AsyncSession = Depends(get_db)):
     try:
         # 获取分页数据
-        dict_type_page_query_result = DictTypeService.get_dict_type_list_services(query_db, dict_type_page_query, is_page=True)
+        dict_type_page_query_result = await DictTypeService.get_dict_type_list_services(query_db, dict_type_page_query, is_page=True)
         logger.info('获取成功')
         return ResponseUtil.success(model_content=dict_type_page_query_result)
     except Exception as e:
@@ -28,7 +28,7 @@ async def get_system_dict_type_list(request: Request, dict_type_page_query: Dict
 
 @dictController.post("/type", dependencies=[Depends(CheckUserInterfaceAuth('system:dict:add'))])
 @log_decorator(title='字典管理', business_type=1)
-async def add_system_dict_type(request: Request, add_dict_type: DictTypeModel, query_db: Session = Depends(get_db), current_user: CurrentUserModel = Depends(LoginService.get_current_user)):
+async def add_system_dict_type(request: Request, add_dict_type: DictTypeModel, query_db: AsyncSession = Depends(get_db), current_user: CurrentUserModel = Depends(LoginService.get_current_user)):
     try:
         add_dict_type.create_by = current_user.user.user_name
         add_dict_type.update_by = current_user.user.user_name
@@ -46,7 +46,7 @@ async def add_system_dict_type(request: Request, add_dict_type: DictTypeModel, q
 
 @dictController.put("/type", dependencies=[Depends(CheckUserInterfaceAuth('system:dict:edit'))])
 @log_decorator(title='字典管理', business_type=2)
-async def edit_system_dict_type(request: Request, edit_dict_type: DictTypeModel, query_db: Session = Depends(get_db), current_user: CurrentUserModel = Depends(LoginService.get_current_user)):
+async def edit_system_dict_type(request: Request, edit_dict_type: DictTypeModel, query_db: AsyncSession = Depends(get_db), current_user: CurrentUserModel = Depends(LoginService.get_current_user)):
     try:
         edit_dict_type.update_by = current_user.user.user_name
         edit_dict_type.update_time = datetime.now()
@@ -64,7 +64,7 @@ async def edit_system_dict_type(request: Request, edit_dict_type: DictTypeModel,
 
 @dictController.delete("/type/refreshCache", dependencies=[Depends(CheckUserInterfaceAuth('system:dict:remove'))])
 @log_decorator(title='字典管理', business_type=2)
-async def refresh_system_dict(request: Request, query_db: Session = Depends(get_db)):
+async def refresh_system_dict(request: Request, query_db: AsyncSession = Depends(get_db)):
     try:
         refresh_dict_result = await DictTypeService.refresh_sys_dict_services(request, query_db)
         if refresh_dict_result.is_success:
@@ -80,7 +80,7 @@ async def refresh_system_dict(request: Request, query_db: Session = Depends(get_
 
 @dictController.delete("/type/{dict_ids}", dependencies=[Depends(CheckUserInterfaceAuth('system:dict:remove'))])
 @log_decorator(title='字典管理', business_type=3)
-async def delete_system_dict_type(request: Request, dict_ids: str, query_db: Session = Depends(get_db)):
+async def delete_system_dict_type(request: Request, dict_ids: str, query_db: AsyncSession = Depends(get_db)):
     try:
         delete_dict_type = DeleteDictTypeModel(dictIds=dict_ids)
         delete_dict_type_result = await DictTypeService.delete_dict_type_services(request, query_db, delete_dict_type)
@@ -96,9 +96,9 @@ async def delete_system_dict_type(request: Request, dict_ids: str, query_db: Ses
 
 
 @dictController.get("/type/optionselect", response_model=List[DictTypeModel])
-async def query_system_dict_type_options(request: Request, query_db: Session = Depends(get_db)):
+async def query_system_dict_type_options(request: Request, query_db: AsyncSession = Depends(get_db)):
     try:
-        dict_type_query_result = DictTypeService.get_dict_type_list_services(query_db, DictTypePageQueryModel(**dict()), is_page=False)
+        dict_type_query_result = await DictTypeService.get_dict_type_list_services(query_db, DictTypePageQueryModel(**dict()), is_page=False)
         logger.info(f'获取成功')
         return ResponseUtil.success(data=dict_type_query_result)
     except Exception as e:
@@ -107,9 +107,9 @@ async def query_system_dict_type_options(request: Request, query_db: Session = D
 
 
 @dictController.get("/type/{dict_id}", response_model=DictTypeModel, dependencies=[Depends(CheckUserInterfaceAuth('system:dict:query'))])
-async def query_detail_system_dict_type(request: Request, dict_id: int, query_db: Session = Depends(get_db)):
+async def query_detail_system_dict_type(request: Request, dict_id: int, query_db: AsyncSession = Depends(get_db)):
     try:
-        dict_type_detail_result = DictTypeService.dict_type_detail_services(query_db, dict_id)
+        dict_type_detail_result = await DictTypeService.dict_type_detail_services(query_db, dict_id)
         logger.info(f'获取dict_id为{dict_id}的信息成功')
         return ResponseUtil.success(data=dict_type_detail_result)
     except Exception as e:
@@ -119,11 +119,11 @@ async def query_detail_system_dict_type(request: Request, dict_id: int, query_db
 
 @dictController.post("/type/export", dependencies=[Depends(CheckUserInterfaceAuth('system:dict:export'))])
 @log_decorator(title='字典管理', business_type=5)
-async def export_system_dict_type_list(request: Request, dict_type_page_query: DictTypePageQueryModel = Depends(DictTypePageQueryModel.as_form), query_db: Session = Depends(get_db)):
+async def export_system_dict_type_list(request: Request, dict_type_page_query: DictTypePageQueryModel = Depends(DictTypePageQueryModel.as_form), query_db: AsyncSession = Depends(get_db)):
     try:
         # 获取全量数据
-        dict_type_query_result = DictTypeService.get_dict_type_list_services(query_db, dict_type_page_query, is_page=False)
-        dict_type_export_result = DictTypeService.export_dict_type_list_services(dict_type_query_result)
+        dict_type_query_result = await DictTypeService.get_dict_type_list_services(query_db, dict_type_page_query, is_page=False)
+        dict_type_export_result = await DictTypeService.export_dict_type_list_services(dict_type_query_result)
         logger.info('导出成功')
         return ResponseUtil.streaming(data=bytes2file_response(dict_type_export_result))
     except Exception as e:
@@ -132,7 +132,7 @@ async def export_system_dict_type_list(request: Request, dict_type_page_query: D
 
 
 @dictController.get("/data/type/{dict_type}")
-async def query_system_dict_type_data(request: Request, dict_type: str, query_db: Session = Depends(get_db)):
+async def query_system_dict_type_data(request: Request, dict_type: str, query_db: AsyncSession = Depends(get_db)):
     try:
         # 获取全量数据
         dict_data_query_result = await DictDataService.query_dict_data_list_from_cache_services(request.app.state.redis, dict_type)
@@ -144,10 +144,10 @@ async def query_system_dict_type_data(request: Request, dict_type: str, query_db
 
 
 @dictController.get("/data/list", response_model=PageResponseModel, dependencies=[Depends(CheckUserInterfaceAuth('system:dict:list'))])
-async def get_system_dict_data_list(request: Request, dict_data_page_query: DictDataPageQueryModel = Depends(DictDataPageQueryModel.as_query), query_db: Session = Depends(get_db)):
+async def get_system_dict_data_list(request: Request, dict_data_page_query: DictDataPageQueryModel = Depends(DictDataPageQueryModel.as_query), query_db: AsyncSession = Depends(get_db)):
     try:
         # 获取分页数据
-        dict_data_page_query_result = DictDataService.get_dict_data_list_services(query_db, dict_data_page_query, is_page=True)
+        dict_data_page_query_result = await DictDataService.get_dict_data_list_services(query_db, dict_data_page_query, is_page=True)
         logger.info('获取成功')
         return ResponseUtil.success(model_content=dict_data_page_query_result)
     except Exception as e:
@@ -157,7 +157,7 @@ async def get_system_dict_data_list(request: Request, dict_data_page_query: Dict
 
 @dictController.post("/data", dependencies=[Depends(CheckUserInterfaceAuth('system:dict:add'))])
 @log_decorator(title='字典管理', business_type=1)
-async def add_system_dict_data(request: Request, add_dict_data: DictDataModel, query_db: Session = Depends(get_db), current_user: CurrentUserModel = Depends(LoginService.get_current_user)):
+async def add_system_dict_data(request: Request, add_dict_data: DictDataModel, query_db: AsyncSession = Depends(get_db), current_user: CurrentUserModel = Depends(LoginService.get_current_user)):
     try:
         add_dict_data.create_by = current_user.user.user_name
         add_dict_data.update_by = current_user.user.user_name
@@ -175,7 +175,7 @@ async def add_system_dict_data(request: Request, add_dict_data: DictDataModel, q
 
 @dictController.put("/data", dependencies=[Depends(CheckUserInterfaceAuth('system:dict:edit'))])
 @log_decorator(title='字典管理', business_type=2)
-async def edit_system_dict_data(request: Request, edit_dict_data: DictDataModel, query_db: Session = Depends(get_db), current_user: CurrentUserModel = Depends(LoginService.get_current_user)):
+async def edit_system_dict_data(request: Request, edit_dict_data: DictDataModel, query_db: AsyncSession = Depends(get_db), current_user: CurrentUserModel = Depends(LoginService.get_current_user)):
     try:
         edit_dict_data.update_by = current_user.user.user_name
         edit_dict_data.update_time = datetime.now()
@@ -193,7 +193,7 @@ async def edit_system_dict_data(request: Request, edit_dict_data: DictDataModel,
 
 @dictController.delete("/data/{dict_codes}", dependencies=[Depends(CheckUserInterfaceAuth('system:dict:remove'))])
 @log_decorator(title='字典管理', business_type=3)
-async def delete_system_dict_data(request: Request, dict_codes: str, query_db: Session = Depends(get_db)):
+async def delete_system_dict_data(request: Request, dict_codes: str, query_db: AsyncSession = Depends(get_db)):
     try:
         delete_dict_data = DeleteDictDataModel(dictCodes=dict_codes)
         delete_dict_data_result = await DictDataService.delete_dict_data_services(request, query_db, delete_dict_data)
@@ -209,9 +209,9 @@ async def delete_system_dict_data(request: Request, dict_codes: str, query_db: S
 
 
 @dictController.get("/data/{dict_code}", response_model=DictDataModel, dependencies=[Depends(CheckUserInterfaceAuth('system:dict:query'))])
-async def query_detail_system_dict_data(request: Request, dict_code: int, query_db: Session = Depends(get_db)):
+async def query_detail_system_dict_data(request: Request, dict_code: int, query_db: AsyncSession = Depends(get_db)):
     try:
-        detail_dict_data_result = DictDataService.dict_data_detail_services(query_db, dict_code)
+        detail_dict_data_result = await DictDataService.dict_data_detail_services(query_db, dict_code)
         logger.info(f'获取dict_code为{dict_code}的信息成功')
         return ResponseUtil.success(data=detail_dict_data_result)
     except Exception as e:
@@ -221,11 +221,11 @@ async def query_detail_system_dict_data(request: Request, dict_code: int, query_
 
 @dictController.post("/data/export", dependencies=[Depends(CheckUserInterfaceAuth('system:dict:export'))])
 @log_decorator(title='字典管理', business_type=5)
-async def export_system_dict_data_list(request: Request, dict_data_page_query: DictDataPageQueryModel = Depends(DictDataPageQueryModel.as_form), query_db: Session = Depends(get_db)):
+async def export_system_dict_data_list(request: Request, dict_data_page_query: DictDataPageQueryModel = Depends(DictDataPageQueryModel.as_form), query_db: AsyncSession = Depends(get_db)):
     try:
         # 获取全量数据
-        dict_data_query_result = DictDataService.get_dict_data_list_services(query_db, dict_data_page_query, is_page=False)
-        dict_data_export_result = DictDataService.export_dict_data_list_services(dict_data_query_result)
+        dict_data_query_result = await DictDataService.get_dict_data_list_services(query_db, dict_data_page_query, is_page=False)
+        dict_data_export_result = await DictDataService.export_dict_data_list_services(dict_data_query_result)
         logger.info('导出成功')
         return ResponseUtil.streaming(data=bytes2file_response(dict_data_export_result))
     except Exception as e:

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

@@ -16,10 +16,10 @@ jobController = APIRouter(prefix='/monitor', dependencies=[Depends(LoginService.
 
 
 @jobController.get("/job/list", response_model=PageResponseModel, dependencies=[Depends(CheckUserInterfaceAuth('monitor:job:list'))])
-async def get_system_job_list(request: Request, job_page_query: JobPageQueryModel = Depends(JobPageQueryModel.as_query), query_db: Session = Depends(get_db)):
+async def get_system_job_list(request: Request, job_page_query: JobPageQueryModel = Depends(JobPageQueryModel.as_query), query_db: AsyncSession = Depends(get_db)):
     try:
         # 获取分页数据
-        notice_page_query_result = JobService.get_job_list_services(query_db, job_page_query, is_page=True)
+        notice_page_query_result = await JobService.get_job_list_services(query_db, job_page_query, is_page=True)
         logger.info('获取成功')
         return ResponseUtil.success(model_content=notice_page_query_result)
     except Exception as e:
@@ -29,11 +29,11 @@ async def get_system_job_list(request: Request, job_page_query: JobPageQueryMode
 
 @jobController.post("/job", dependencies=[Depends(CheckUserInterfaceAuth('monitor:job:add'))])
 @log_decorator(title='定时任务管理', business_type=1)
-async def add_system_job(request: Request, add_job: JobModel, query_db: Session = Depends(get_db), current_user: CurrentUserModel = Depends(LoginService.get_current_user)):
+async def add_system_job(request: Request, add_job: JobModel, query_db: AsyncSession = Depends(get_db), current_user: CurrentUserModel = Depends(LoginService.get_current_user)):
     try:
         add_job.create_by = current_user.user.user_name
         add_job.update_by = current_user.user.user_name
-        add_job_result = JobService.add_job_services(query_db, add_job)
+        add_job_result = await JobService.add_job_services(query_db, add_job)
         if add_job_result.is_success:
             logger.info(add_job_result.message)
             return ResponseUtil.success(msg=add_job_result.message)
@@ -47,11 +47,11 @@ async def add_system_job(request: Request, add_job: JobModel, query_db: Session
 
 @jobController.put("/job", dependencies=[Depends(CheckUserInterfaceAuth('monitor:job:edit'))])
 @log_decorator(title='定时任务管理', business_type=2)
-async def edit_system_job(request: Request, edit_job: EditJobModel, query_db: Session = Depends(get_db), current_user: CurrentUserModel = Depends(LoginService.get_current_user)):
+async def edit_system_job(request: Request, edit_job: EditJobModel, query_db: AsyncSession = Depends(get_db), current_user: CurrentUserModel = Depends(LoginService.get_current_user)):
     try:
         edit_job.update_by = current_user.user.user_name
         edit_job.update_time = datetime.now()
-        edit_job_result = JobService.edit_job_services(query_db, edit_job)
+        edit_job_result = await JobService.edit_job_services(query_db, edit_job)
         if edit_job_result.is_success:
             logger.info(edit_job_result.message)
             return ResponseUtil.success(msg=edit_job_result.message)
@@ -65,12 +65,12 @@ async def edit_system_job(request: Request, edit_job: EditJobModel, query_db: Se
 
 @jobController.put("/job/changeStatus", dependencies=[Depends(CheckUserInterfaceAuth('monitor:job:changeStatus'))])
 @log_decorator(title='定时任务管理', business_type=2)
-async def edit_system_job(request: Request, edit_job: EditJobModel, query_db: Session = Depends(get_db), current_user: CurrentUserModel = Depends(LoginService.get_current_user)):
+async def edit_system_job(request: Request, edit_job: EditJobModel, query_db: AsyncSession = Depends(get_db), current_user: CurrentUserModel = Depends(LoginService.get_current_user)):
     try:
         edit_job.update_by = current_user.user.user_name
         edit_job.update_time = datetime.now()
         edit_job.type = 'status'
-        edit_job_result = JobService.edit_job_services(query_db, edit_job)
+        edit_job_result = await JobService.edit_job_services(query_db, edit_job)
         if edit_job_result.is_success:
             logger.info(edit_job_result.message)
             return ResponseUtil.success(msg=edit_job_result.message)
@@ -84,9 +84,9 @@ async def edit_system_job(request: Request, edit_job: EditJobModel, query_db: Se
 
 @jobController.put("/job/run", dependencies=[Depends(CheckUserInterfaceAuth('monitor:job:changeStatus'))])
 @log_decorator(title='定时任务管理', business_type=2)
-async def execute_system_job(request: Request, execute_job: JobModel, query_db: Session = Depends(get_db)):
+async def execute_system_job(request: Request, execute_job: JobModel, query_db: AsyncSession = Depends(get_db)):
     try:
-        execute_job_result = JobService.execute_job_once_services(query_db, execute_job)
+        execute_job_result = await JobService.execute_job_once_services(query_db, execute_job)
         if execute_job_result.is_success:
             logger.info(execute_job_result.message)
             return ResponseUtil.success(msg=execute_job_result.message)
@@ -100,10 +100,10 @@ async def execute_system_job(request: Request, execute_job: JobModel, query_db:
 
 @jobController.delete("/job/{job_ids}", dependencies=[Depends(CheckUserInterfaceAuth('monitor:job:remove'))])
 @log_decorator(title='定时任务管理', business_type=3)
-async def delete_system_job(request: Request, job_ids: str, query_db: Session = Depends(get_db)):
+async def delete_system_job(request: Request, job_ids: str, query_db: AsyncSession = Depends(get_db)):
     try:
         delete_job = DeleteJobModel(jobIds=job_ids)
-        delete_job_result = JobService.delete_job_services(query_db, delete_job)
+        delete_job_result = await JobService.delete_job_services(query_db, delete_job)
         if delete_job_result.is_success:
             logger.info(delete_job_result.message)
             return ResponseUtil.success(msg=delete_job_result.message)
@@ -116,9 +116,9 @@ async def delete_system_job(request: Request, job_ids: str, query_db: Session =
 
 
 @jobController.get("/job/{job_id}", response_model=JobModel, dependencies=[Depends(CheckUserInterfaceAuth('monitor:job:query'))])
-async def query_detail_system_job(request: Request, job_id: int, query_db: Session = Depends(get_db)):
+async def query_detail_system_job(request: Request, job_id: int, query_db: AsyncSession = Depends(get_db)):
     try:
-        job_detail_result = JobService.job_detail_services(query_db, job_id)
+        job_detail_result = await JobService.job_detail_services(query_db, job_id)
         logger.info(f'获取job_id为{job_id}的信息成功')
         return ResponseUtil.success(data=job_detail_result)
     except Exception as e:
@@ -128,10 +128,10 @@ async def query_detail_system_job(request: Request, job_id: int, query_db: Sessi
 
 @jobController.post("/job/export", dependencies=[Depends(CheckUserInterfaceAuth('monitor:job:export'))])
 @log_decorator(title='定时任务管理', business_type=5)
-async def export_system_job_list(request: Request, job_page_query: JobPageQueryModel = Depends(JobPageQueryModel.as_form), query_db: Session = Depends(get_db)):
+async def export_system_job_list(request: Request, job_page_query: JobPageQueryModel = Depends(JobPageQueryModel.as_form), query_db: AsyncSession = Depends(get_db)):
     try:
         # 获取全量数据
-        job_query_result = JobService.get_job_list_services(query_db, job_page_query, is_page=False)
+        job_query_result = await JobService.get_job_list_services(query_db, job_page_query, is_page=False)
         job_export_result = await JobService.export_job_list_services(request, job_query_result)
         logger.info('导出成功')
         return ResponseUtil.streaming(data=bytes2file_response(job_export_result))
@@ -141,10 +141,10 @@ async def export_system_job_list(request: Request, job_page_query: JobPageQueryM
 
 
 @jobController.get("/jobLog/list", response_model=PageResponseModel, dependencies=[Depends(CheckUserInterfaceAuth('monitor:job:list'))])
-async def get_system_job_log_list(request: Request, job_log_page_query: JobLogPageQueryModel = Depends(JobLogPageQueryModel.as_query), query_db: Session = Depends(get_db)):
+async def get_system_job_log_list(request: Request, job_log_page_query: JobLogPageQueryModel = Depends(JobLogPageQueryModel.as_query), query_db: AsyncSession = Depends(get_db)):
     try:
         # 获取分页数据
-        job_log_page_query_result = JobLogService.get_job_log_list_services(query_db, job_log_page_query, is_page=True)
+        job_log_page_query_result = await JobLogService.get_job_log_list_services(query_db, job_log_page_query, is_page=True)
         logger.info('获取成功')
         return ResponseUtil.success(model_content=job_log_page_query_result)
     except Exception as e:
@@ -154,10 +154,10 @@ async def get_system_job_log_list(request: Request, job_log_page_query: JobLogPa
 
 @jobController.delete("/jobLog/{job_log_ids}", dependencies=[Depends(CheckUserInterfaceAuth('monitor:job:remove'))])
 @log_decorator(title='定时任务日志管理', business_type=3)
-async def delete_system_job_log(request: Request, job_log_ids: str, query_db: Session = Depends(get_db)):
+async def delete_system_job_log(request: Request, job_log_ids: str, query_db: AsyncSession = Depends(get_db)):
     try:
         delete_job_log = DeleteJobLogModel(jobLogIds=job_log_ids)
-        delete_job_log_result = JobLogService.delete_job_log_services(query_db, delete_job_log)
+        delete_job_log_result = await JobLogService.delete_job_log_services(query_db, delete_job_log)
         if delete_job_log_result.is_success:
             logger.info(delete_job_log_result.message)
             return ResponseUtil.success(msg=delete_job_log_result.message)
@@ -169,11 +169,11 @@ async def delete_system_job_log(request: Request, job_log_ids: str, query_db: Se
         return ResponseUtil.error(msg=str(e))
 
 
-@jobController.post("/jobLog/clean", dependencies=[Depends(CheckUserInterfaceAuth('monitor:job:remove'))])
+@jobController.delete("/jobLog/clean", dependencies=[Depends(CheckUserInterfaceAuth('monitor:job:remove'))])
 @log_decorator(title='定时任务日志管理', business_type=9)
-async def clear_system_job_log(request: Request, query_db: Session = Depends(get_db)):
+async def clear_system_job_log(request: Request, query_db: AsyncSession = Depends(get_db)):
     try:
-        clear_job_log_result = JobLogService.clear_job_log_services(query_db)
+        clear_job_log_result = await JobLogService.clear_job_log_services(query_db)
         if clear_job_log_result.is_success:
             logger.info(clear_job_log_result.message)
             return ResponseUtil.success(msg=clear_job_log_result.message)
@@ -187,10 +187,10 @@ async def clear_system_job_log(request: Request, query_db: Session = Depends(get
 
 @jobController.post("/jobLog/export", dependencies=[Depends(CheckUserInterfaceAuth('monitor:job:export'))])
 @log_decorator(title='定时任务日志管理', business_type=5)
-async def export_system_job_log_list(request: Request, job_log_page_query: JobLogPageQueryModel = Depends(JobLogPageQueryModel.as_form), query_db: Session = Depends(get_db)):
+async def export_system_job_log_list(request: Request, job_log_page_query: JobLogPageQueryModel = Depends(JobLogPageQueryModel.as_form), query_db: AsyncSession = Depends(get_db)):
     try:
         # 获取全量数据
-        job_log_query_result = JobLogService.get_job_log_list_services(query_db, job_log_page_query, is_page=False)
+        job_log_query_result = await JobLogService.get_job_log_list_services(query_db, job_log_page_query, is_page=False)
         job_log_export_result = await JobLogService.export_job_log_list_services(request, job_log_query_result)
         logger.info('导出成功')
         return ResponseUtil.streaming(data=bytes2file_response(job_log_export_result))

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

@@ -15,10 +15,10 @@ logController = APIRouter(prefix='/monitor', dependencies=[Depends(LoginService.
 
 
 @logController.get("/operlog/list", response_model=PageResponseModel, dependencies=[Depends(CheckUserInterfaceAuth('monitor:operlog:list'))])
-async def get_system_operation_log_list(request: Request, operation_log_page_query: OperLogPageQueryModel = Depends(OperLogPageQueryModel.as_query), query_db: Session = Depends(get_db)):
+async def get_system_operation_log_list(request: Request, operation_log_page_query: OperLogPageQueryModel = Depends(OperLogPageQueryModel.as_query), query_db: AsyncSession = Depends(get_db)):
     try:
         # 获取分页数据
-        operation_log_page_query_result = OperationLogService.get_operation_log_list_services(query_db, operation_log_page_query, is_page=True)
+        operation_log_page_query_result = await OperationLogService.get_operation_log_list_services(query_db, operation_log_page_query, is_page=True)
         logger.info('获取成功')
         return ResponseUtil.success(model_content=operation_log_page_query_result)
     except Exception as e:
@@ -28,9 +28,9 @@ async def get_system_operation_log_list(request: Request, operation_log_page_que
 
 @logController.delete("/operlog/clean", dependencies=[Depends(CheckUserInterfaceAuth('monitor:operlog:remove'))])
 @log_decorator(title='操作日志管理', business_type=9)
-async def clear_system_operation_log(request: Request, query_db: Session = Depends(get_db)):
+async def clear_system_operation_log(request: Request, query_db: AsyncSession = Depends(get_db)):
     try:
-        clear_operation_log_result = OperationLogService.clear_operation_log_services(query_db)
+        clear_operation_log_result = await OperationLogService.clear_operation_log_services(query_db)
         if clear_operation_log_result.is_success:
             logger.info(clear_operation_log_result.message)
             return ResponseUtil.success(msg=clear_operation_log_result.message)
@@ -44,10 +44,10 @@ async def clear_system_operation_log(request: Request, query_db: Session = Depen
 
 @logController.delete("/operlog/{oper_ids}", dependencies=[Depends(CheckUserInterfaceAuth('monitor:operlog:remove'))])
 @log_decorator(title='操作日志管理', business_type=3)
-async def delete_system_operation_log(request: Request, oper_ids: str, query_db: Session = Depends(get_db)):
+async def delete_system_operation_log(request: Request, oper_ids: str, query_db: AsyncSession = Depends(get_db)):
     try:
         delete_operation_log = DeleteOperLogModel(operIds=oper_ids)
-        delete_operation_log_result = OperationLogService.delete_operation_log_services(query_db, delete_operation_log)
+        delete_operation_log_result = await OperationLogService.delete_operation_log_services(query_db, delete_operation_log)
         if delete_operation_log_result.is_success:
             logger.info(delete_operation_log_result.message)
             return ResponseUtil.success(msg=delete_operation_log_result.message)
@@ -61,10 +61,10 @@ async def delete_system_operation_log(request: Request, oper_ids: str, query_db:
 
 @logController.post("/operlog/export", dependencies=[Depends(CheckUserInterfaceAuth('monitor:operlog:export'))])
 @log_decorator(title='操作日志管理', business_type=5)
-async def export_system_operation_log_list(request: Request, operation_log_page_query: OperLogPageQueryModel = Depends(OperLogPageQueryModel.as_form), query_db: Session = Depends(get_db)):
+async def export_system_operation_log_list(request: Request, operation_log_page_query: OperLogPageQueryModel = Depends(OperLogPageQueryModel.as_form), query_db: AsyncSession = Depends(get_db)):
     try:
         # 获取全量数据
-        operation_log_query_result = OperationLogService.get_operation_log_list_services(query_db, operation_log_page_query, is_page=False)
+        operation_log_query_result = await OperationLogService.get_operation_log_list_services(query_db, operation_log_page_query, is_page=False)
         operation_log_export_result = await OperationLogService.export_operation_log_list_services(request, operation_log_query_result)
         logger.info('导出成功')
         return ResponseUtil.streaming(data=bytes2file_response(operation_log_export_result))
@@ -74,10 +74,10 @@ async def export_system_operation_log_list(request: Request, operation_log_page_
 
 
 @logController.get("/logininfor/list", response_model=PageResponseModel, dependencies=[Depends(CheckUserInterfaceAuth('monitor:logininfor:list'))])
-async def get_system_login_log_list(request: Request, login_log_page_query: LoginLogPageQueryModel = Depends(LoginLogPageQueryModel.as_query), query_db: Session = Depends(get_db)):
+async def get_system_login_log_list(request: Request, login_log_page_query: LoginLogPageQueryModel = Depends(LoginLogPageQueryModel.as_query), query_db: AsyncSession = Depends(get_db)):
     try:
         # 获取分页数据
-        login_log_page_query_result = LoginLogService.get_login_log_list_services(query_db, login_log_page_query, is_page=True)
+        login_log_page_query_result = await LoginLogService.get_login_log_list_services(query_db, login_log_page_query, is_page=True)
         logger.info('获取成功')
         return ResponseUtil.success(model_content=login_log_page_query_result)
     except Exception as e:
@@ -87,9 +87,9 @@ async def get_system_login_log_list(request: Request, login_log_page_query: Logi
 
 @logController.delete("/logininfor/clean", dependencies=[Depends(CheckUserInterfaceAuth('monitor:logininfor:remove'))])
 @log_decorator(title='登录日志管理', business_type=9)
-async def clear_system_login_log(request: Request, query_db: Session = Depends(get_db)):
+async def clear_system_login_log(request: Request, query_db: AsyncSession = Depends(get_db)):
     try:
-        clear_login_log_result = LoginLogService.clear_login_log_services(query_db)
+        clear_login_log_result = await LoginLogService.clear_login_log_services(query_db)
         if clear_login_log_result.is_success:
             logger.info(clear_login_log_result.message)
             return ResponseUtil.success(msg=clear_login_log_result.message)
@@ -103,10 +103,10 @@ async def clear_system_login_log(request: Request, query_db: Session = Depends(g
 
 @logController.delete("/logininfor/{info_ids}", dependencies=[Depends(CheckUserInterfaceAuth('monitor:logininfor:remove'))])
 @log_decorator(title='登录日志管理', business_type=3)
-async def delete_system_login_log(request: Request, info_ids: str, query_db: Session = Depends(get_db)):
+async def delete_system_login_log(request: Request, info_ids: str, query_db: AsyncSession = Depends(get_db)):
     try:
         delete_login_log = DeleteLoginLogModel(infoIds=info_ids)
-        delete_login_log_result = LoginLogService.delete_login_log_services(query_db, delete_login_log)
+        delete_login_log_result = await LoginLogService.delete_login_log_services(query_db, delete_login_log)
         if delete_login_log_result.is_success:
             logger.info(delete_login_log_result.message)
             return ResponseUtil.success(msg=delete_login_log_result.message)
@@ -120,7 +120,7 @@ async def delete_system_login_log(request: Request, info_ids: str, query_db: Ses
 
 @logController.get("/logininfor/unlock/{user_name}", dependencies=[Depends(CheckUserInterfaceAuth('monitor:logininfor:unlock'))])
 @log_decorator(title='登录日志管理', business_type=0)
-async def clear_system_login_log(request: Request, user_name: str, query_db: Session = Depends(get_db)):
+async def clear_system_login_log(request: Request, user_name: str, query_db: AsyncSession = Depends(get_db)):
     try:
         unlock_user = UnlockUser(userName=user_name)
         unlock_user_result = await LoginLogService.unlock_user_services(request, unlock_user)
@@ -137,11 +137,11 @@ async def clear_system_login_log(request: Request, user_name: str, query_db: Ses
 
 @logController.post("/logininfor/export", dependencies=[Depends(CheckUserInterfaceAuth('monitor:logininfor:export'))])
 @log_decorator(title='登录日志管理', business_type=5)
-async def export_system_login_log_list(request: Request, login_log_page_query: LoginLogPageQueryModel = Depends(LoginLogPageQueryModel.as_form), query_db: Session = Depends(get_db)):
+async def export_system_login_log_list(request: Request, login_log_page_query: LoginLogPageQueryModel = Depends(LoginLogPageQueryModel.as_form), query_db: AsyncSession = Depends(get_db)):
     try:
         # 获取全量数据
-        login_log_query_result = LoginLogService.get_login_log_list_services(query_db, login_log_page_query, is_page=False)
-        login_log_export_result = LoginLogService.export_login_log_list_services(login_log_query_result)
+        login_log_query_result = await LoginLogService.get_login_log_list_services(query_db, login_log_page_query, is_page=False)
+        login_log_export_result = await LoginLogService.export_login_log_list_services(login_log_query_result)
         logger.info('导出成功')
         return ResponseUtil.streaming(data=bytes2file_response(login_log_export_result))
     except Exception as e:

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

@@ -14,7 +14,7 @@ loginController = APIRouter()
 
 @loginController.post("/login", response_model=Token)
 @log_decorator(title='用户登录', business_type=0, log_type='login')
-async def login(request: Request, form_data: CustomOAuth2PasswordRequestForm = Depends(), query_db: Session = Depends(get_db)):
+async def login(request: Request, form_data: CustomOAuth2PasswordRequestForm = Depends(), query_db: AsyncSession = Depends(get_db)):
     captcha_enabled = True if await request.app.state.redis.get(f"{RedisInitKeyConfig.SYS_CONFIG.get('key')}:sys.account.captchaEnabled") == 'true' else False
     user = UserLogin(
         userName=form_data.username,
@@ -31,7 +31,7 @@ async def login(request: Request, form_data: CustomOAuth2PasswordRequestForm = D
     try:
         access_token_expires = timedelta(minutes=JwtConfig.jwt_expire_minutes)
         session_id = str(uuid.uuid4())
-        access_token = LoginService.create_access_token(
+        access_token = await LoginService.create_access_token(
             data={
                 "user_id": str(result[0].user_id),
                 "user_name": result[0].user_name,
@@ -48,7 +48,7 @@ async def login(request: Request, form_data: CustomOAuth2PasswordRequestForm = D
             # 此方法可实现同一账号同一时间只能登录一次
             await request.app.state.redis.set(f"{RedisInitKeyConfig.ACCESS_TOKEN.get('key')}:{result[0].user_id}", access_token,
                                               ex=timedelta(minutes=JwtConfig.jwt_redis_expire_minutes))
-        UserService.edit_user_services(query_db, EditUserModel(userId=result[0].user_id, loginDate=datetime.now(), type='status'))
+        await UserService.edit_user_services(query_db, EditUserModel(userId=result[0].user_id, loginDate=datetime.now(), type='status'))
         logger.info('登录成功')
         # 判断请求是否来自于api文档，如果是返回指定格式的结果，用于修复api文档认证成功后token显示undefined的bug
         request_from_swagger = request.headers.get('referer').endswith('docs') if request.headers.get('referer') else False
@@ -75,7 +75,7 @@ async def get_login_user_info(request: Request, current_user: CurrentUserModel =
 
 
 @loginController.get("/getRouters")
-async def get_login_user_routers(request: Request, current_user: CurrentUserModel = Depends(LoginService.get_current_user), query_db: Session = Depends(get_db)):
+async def get_login_user_routers(request: Request, current_user: CurrentUserModel = Depends(LoginService.get_current_user), query_db: AsyncSession = Depends(get_db)):
     try:
         logger.info('获取成功')
         user_routers = await LoginService.get_current_user_routers(current_user.user.user_id, query_db)
@@ -86,7 +86,7 @@ async def get_login_user_routers(request: Request, current_user: CurrentUserMode
 
 
 @loginController.post("/register", response_model=CrudResponseModel)
-async def register_user(request: Request, user_register: UserRegister, query_db: Session = Depends(get_db)):
+async def register_user(request: Request, user_register: UserRegister, query_db: AsyncSession = Depends(get_db)):
     try:
         user_register_result = await LoginService.register_user_services(request, query_db, user_register)
         if user_register_result.is_success:
@@ -101,7 +101,7 @@ async def register_user(request: Request, user_register: UserRegister, query_db:
 
 
 # @loginController.post("/getSmsCode", response_model=SmsCode)
-# async def get_sms_code(request: Request, user: ResetUserModel, query_db: Session = Depends(get_db)):
+# async def get_sms_code(request: Request, user: ResetUserModel, query_db: AsyncSession = Depends(get_db)):
 #     try:
 #         sms_result = await LoginService.get_sms_code_services(request, query_db, user)
 #         if sms_result.is_success:
@@ -116,7 +116,7 @@ async def register_user(request: Request, user_register: UserRegister, query_db:
 #
 #
 # @loginController.post("/forgetPwd", response_model=CrudResponseModel)
-# async def forget_user_pwd(request: Request, forget_user: ResetUserModel, query_db: Session = Depends(get_db)):
+# async def forget_user_pwd(request: Request, forget_user: ResetUserModel, query_db: AsyncSession = Depends(get_db)):
 #     try:
 #         forget_user_result = await LoginService.forget_user_services(request, query_db, forget_user)
 #         if forget_user_result.is_success:

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

@@ -13,9 +13,9 @@ menuController = APIRouter(prefix='/system/menu', dependencies=[Depends(LoginSer
 
 
 @menuController.get("/treeselect")
-async def get_system_menu_tree(request: Request, query_db: Session = Depends(get_db), current_user: CurrentUserModel = Depends(LoginService.get_current_user)):
+async def get_system_menu_tree(request: Request, query_db: AsyncSession = Depends(get_db), current_user: CurrentUserModel = Depends(LoginService.get_current_user)):
     try:
-        menu_query_result = MenuService.get_menu_tree_services(query_db, current_user)
+        menu_query_result = await MenuService.get_menu_tree_services(query_db, current_user)
         logger.info('获取成功')
         return ResponseUtil.success(data=menu_query_result)
     except Exception as e:
@@ -24,9 +24,9 @@ async def get_system_menu_tree(request: Request, query_db: Session = Depends(get
 
 
 @menuController.get("/roleMenuTreeselect/{role_id}")
-async def get_system_role_menu_tree(request: Request, role_id: int, query_db: Session = Depends(get_db), current_user: CurrentUserModel = Depends(LoginService.get_current_user)):
+async def get_system_role_menu_tree(request: Request, role_id: int, query_db: AsyncSession = Depends(get_db), current_user: CurrentUserModel = Depends(LoginService.get_current_user)):
     try:
-        role_menu_query_result = MenuService.get_role_menu_tree_services(query_db, role_id, current_user)
+        role_menu_query_result = await MenuService.get_role_menu_tree_services(query_db, role_id, current_user)
         logger.info('获取成功')
         return ResponseUtil.success(model_content=role_menu_query_result)
     except Exception as e:
@@ -35,9 +35,9 @@ async def get_system_role_menu_tree(request: Request, role_id: int, query_db: Se
 
 
 @menuController.get("/list", response_model=List[MenuModel], dependencies=[Depends(CheckUserInterfaceAuth('system:menu:list'))])
-async def get_system_menu_list(request: Request, menu_query: MenuQueryModel = Depends(MenuQueryModel.as_query), query_db: Session = Depends(get_db), current_user: CurrentUserModel = Depends(LoginService.get_current_user)):
+async def get_system_menu_list(request: Request, menu_query: MenuQueryModel = Depends(MenuQueryModel.as_query), query_db: AsyncSession = Depends(get_db), current_user: CurrentUserModel = Depends(LoginService.get_current_user)):
     try:
-        menu_query_result = MenuService.get_menu_list_services(query_db, menu_query, current_user)
+        menu_query_result = await MenuService.get_menu_list_services(query_db, menu_query, current_user)
         logger.info('获取成功')
         return ResponseUtil.success(data=menu_query_result)
     except Exception as e:
@@ -47,11 +47,11 @@ async def get_system_menu_list(request: Request, menu_query: MenuQueryModel = De
 
 @menuController.post("", dependencies=[Depends(CheckUserInterfaceAuth('system:menu:add'))])
 @log_decorator(title='菜单管理', business_type=1)
-async def add_system_menu(request: Request, add_menu: MenuModel, query_db: Session = Depends(get_db), current_user: CurrentUserModel = Depends(LoginService.get_current_user)):
+async def add_system_menu(request: Request, add_menu: MenuModel, query_db: AsyncSession = Depends(get_db), current_user: CurrentUserModel = Depends(LoginService.get_current_user)):
     try:
         add_menu.create_by = current_user.user.user_name
         add_menu.update_by = current_user.user.user_name
-        add_menu_result = MenuService.add_menu_services(query_db, add_menu)
+        add_menu_result = await MenuService.add_menu_services(query_db, add_menu)
         if add_menu_result.is_success:
             logger.info(add_menu_result.message)
             return ResponseUtil.success(msg=add_menu_result.message)
@@ -65,11 +65,11 @@ async def add_system_menu(request: Request, add_menu: MenuModel, query_db: Sessi
 
 @menuController.put("", dependencies=[Depends(CheckUserInterfaceAuth('system:menu:edit'))])
 @log_decorator(title='菜单管理', business_type=2)
-async def edit_system_menu(request: Request, edit_menu: MenuModel, query_db: Session = Depends(get_db), current_user: CurrentUserModel = Depends(LoginService.get_current_user)):
+async def edit_system_menu(request: Request, edit_menu: MenuModel, query_db: AsyncSession = Depends(get_db), current_user: CurrentUserModel = Depends(LoginService.get_current_user)):
     try:
         edit_menu.update_by = current_user.user.user_name
         edit_menu.update_time = datetime.now()
-        edit_menu_result = MenuService.edit_menu_services(query_db, edit_menu)
+        edit_menu_result = await MenuService.edit_menu_services(query_db, edit_menu)
         if edit_menu_result.is_success:
             logger.info(edit_menu_result.message)
             return ResponseUtil.success(msg=edit_menu_result.message)
@@ -83,10 +83,10 @@ async def edit_system_menu(request: Request, edit_menu: MenuModel, query_db: Ses
 
 @menuController.delete("/{menu_ids}", dependencies=[Depends(CheckUserInterfaceAuth('system:menu:remove'))])
 @log_decorator(title='菜单管理', business_type=3)
-async def delete_system_menu(request: Request, menu_ids: str, query_db: Session = Depends(get_db)):
+async def delete_system_menu(request: Request, menu_ids: str, query_db: AsyncSession = Depends(get_db)):
     try:
         delete_menu = DeleteMenuModel(menuIds=menu_ids)
-        delete_menu_result = MenuService.delete_menu_services(query_db, delete_menu)
+        delete_menu_result = await MenuService.delete_menu_services(query_db, delete_menu)
         if delete_menu_result.is_success:
             logger.info(delete_menu_result.message)
             return ResponseUtil.success(msg=delete_menu_result.message)
@@ -99,9 +99,9 @@ async def delete_system_menu(request: Request, menu_ids: str, query_db: Session
 
 
 @menuController.get("/{menu_id}", response_model=MenuModel, dependencies=[Depends(CheckUserInterfaceAuth('system:menu:query'))])
-async def query_detail_system_menu(request: Request, menu_id: int, query_db: Session = Depends(get_db)):
+async def query_detail_system_menu(request: Request, menu_id: int, query_db: AsyncSession = Depends(get_db)):
     try:
-        menu_detail_result = MenuService.menu_detail_services(query_db, menu_id)
+        menu_detail_result = await MenuService.menu_detail_services(query_db, menu_id)
         logger.info(f'获取menu_id为{menu_id}的信息成功')
         return ResponseUtil.success(data=menu_detail_result)
     except Exception as e:

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

@@ -14,10 +14,10 @@ noticeController = APIRouter(prefix='/system/notice', dependencies=[Depends(Logi
 
 
 @noticeController.get("/list", response_model=PageResponseModel, dependencies=[Depends(CheckUserInterfaceAuth('system:notice:list'))])
-async def get_system_notice_list(request: Request, notice_page_query: NoticePageQueryModel = Depends(NoticePageQueryModel.as_query), query_db: Session = Depends(get_db)):
+async def get_system_notice_list(request: Request, notice_page_query: NoticePageQueryModel = Depends(NoticePageQueryModel.as_query), query_db: AsyncSession = Depends(get_db)):
     try:
         # 获取分页数据
-        notice_page_query_result = NoticeService.get_notice_list_services(query_db, notice_page_query, is_page=True)
+        notice_page_query_result = await NoticeService.get_notice_list_services(query_db, notice_page_query, is_page=True)
         logger.info('获取成功')
         return ResponseUtil.success(model_content=notice_page_query_result)
     except Exception as e:
@@ -27,11 +27,11 @@ async def get_system_notice_list(request: Request, notice_page_query: NoticePage
 
 @noticeController.post("", dependencies=[Depends(CheckUserInterfaceAuth('system:notice:add'))])
 @log_decorator(title='通知公告管理', business_type=1)
-async def add_system_notice(request: Request, add_notice: NoticeModel, query_db: Session = Depends(get_db), current_user: CurrentUserModel = Depends(LoginService.get_current_user)):
+async def add_system_notice(request: Request, add_notice: NoticeModel, query_db: AsyncSession = Depends(get_db), current_user: CurrentUserModel = Depends(LoginService.get_current_user)):
     try:
         add_notice.create_by = current_user.user.user_name
         add_notice.update_by = current_user.user.user_name
-        add_notice_result = NoticeService.add_notice_services(query_db, add_notice)
+        add_notice_result = await NoticeService.add_notice_services(query_db, add_notice)
         if add_notice_result.is_success:
             logger.info(add_notice_result.message)
             return ResponseUtil.success(msg=add_notice_result.message)
@@ -45,11 +45,11 @@ async def add_system_notice(request: Request, add_notice: NoticeModel, query_db:
 
 @noticeController.put("", dependencies=[Depends(CheckUserInterfaceAuth('system:notice:edit'))])
 @log_decorator(title='通知公告管理', business_type=2)
-async def edit_system_notice(request: Request, edit_notice: NoticeModel, query_db: Session = Depends(get_db), current_user: CurrentUserModel = Depends(LoginService.get_current_user)):
+async def edit_system_notice(request: Request, edit_notice: NoticeModel, query_db: AsyncSession = Depends(get_db), current_user: CurrentUserModel = Depends(LoginService.get_current_user)):
     try:
         edit_notice.update_by = current_user.user.user_name
         edit_notice.update_time = datetime.now()
-        edit_notice_result = NoticeService.edit_notice_services(query_db, edit_notice)
+        edit_notice_result = await NoticeService.edit_notice_services(query_db, edit_notice)
         if edit_notice_result.is_success:
             logger.info(edit_notice_result.message)
             return ResponseUtil.success(msg=edit_notice_result.message)
@@ -63,10 +63,10 @@ async def edit_system_notice(request: Request, edit_notice: NoticeModel, query_d
 
 @noticeController.delete("/{notice_ids}", dependencies=[Depends(CheckUserInterfaceAuth('system:notice:remove'))])
 @log_decorator(title='通知公告管理', business_type=3)
-async def delete_system_notice(request: Request, notice_ids: str, query_db: Session = Depends(get_db)):
+async def delete_system_notice(request: Request, notice_ids: str, query_db: AsyncSession = Depends(get_db)):
     try:
         delete_notice = DeleteNoticeModel(noticeIds=notice_ids)
-        delete_notice_result = NoticeService.delete_notice_services(query_db, delete_notice)
+        delete_notice_result = await NoticeService.delete_notice_services(query_db, delete_notice)
         if delete_notice_result.is_success:
             logger.info(delete_notice_result.message)
             return ResponseUtil.success(msg=delete_notice_result.message)
@@ -79,9 +79,9 @@ async def delete_system_notice(request: Request, notice_ids: str, query_db: Sess
 
 
 @noticeController.get("/{notice_id}", response_model=NoticeModel, dependencies=[Depends(CheckUserInterfaceAuth('system:notice:query'))])
-async def query_detail_system_post(request: Request, notice_id: int, query_db: Session = Depends(get_db)):
+async def query_detail_system_post(request: Request, notice_id: int, query_db: AsyncSession = Depends(get_db)):
     try:
-        notice_detail_result = NoticeService.notice_detail_services(query_db, notice_id)
+        notice_detail_result = await NoticeService.notice_detail_services(query_db, notice_id)
         logger.info(f'获取notice_id为{notice_id}的信息成功')
         return ResponseUtil.success(data=notice_detail_result)
     except Exception as e:

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

@@ -1,7 +1,7 @@
 from fastapi import APIRouter
 from fastapi import Depends
 from config.get_db import get_db
-from module_admin.service.login_service import LoginService, Session
+from module_admin.service.login_service import LoginService, AsyncSession
 from module_admin.service.online_service import *
 from utils.response_util import *
 from utils.log_util import *
@@ -27,7 +27,7 @@ async def get_monitor_online_list(request: Request, online_page_query: OnlineQue
 
 @onlineController.delete("/{token_ids}", dependencies=[Depends(CheckUserInterfaceAuth('monitor:online:forceLogout'))])
 @log_decorator(title='在线用户', business_type=7)
-async def delete_monitor_online(request: Request, token_ids: str, query_db: Session = Depends(get_db)):
+async def delete_monitor_online(request: Request, token_ids: str, query_db: AsyncSession = Depends(get_db)):
     try:
         delete_online = DeleteOnlineModel(tokenIds=token_ids)
         delete_online_result = await OnlineService.delete_online_services(request, delete_online)

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

@@ -16,10 +16,10 @@ postController = APIRouter(prefix='/system/post', dependencies=[Depends(LoginSer
 
 
 @postController.get("/list", response_model=PageResponseModel, dependencies=[Depends(CheckUserInterfaceAuth('system:post:list'))])
-async def get_system_post_list(request: Request, post_page_query: PostPageQueryModel = Depends(PostPageQueryModel.as_query), query_db: Session = Depends(get_db)):
+async def get_system_post_list(request: Request, post_page_query: PostPageQueryModel = Depends(PostPageQueryModel.as_query), query_db: AsyncSession = Depends(get_db)):
     try:
         # 获取分页数据
-        post_page_query_result = PostService.get_post_list_services(query_db, post_page_query, is_page=True)
+        post_page_query_result = await PostService.get_post_list_services(query_db, post_page_query, is_page=True)
         logger.info('获取成功')
         return ResponseUtil.success(model_content=post_page_query_result)
     except Exception as e:
@@ -29,11 +29,11 @@ async def get_system_post_list(request: Request, post_page_query: PostPageQueryM
 
 @postController.post("", dependencies=[Depends(CheckUserInterfaceAuth('system:post:add'))])
 @log_decorator(title='岗位管理', business_type=1)
-async def add_system_post(request: Request, add_post: PostModel, query_db: Session = Depends(get_db), current_user: CurrentUserModel = Depends(LoginService.get_current_user)):
+async def add_system_post(request: Request, add_post: PostModel, query_db: AsyncSession = Depends(get_db), current_user: CurrentUserModel = Depends(LoginService.get_current_user)):
     try:
         add_post.create_by = current_user.user.user_name
         add_post.update_by = current_user.user.user_name
-        add_post_result = PostService.add_post_services(query_db, add_post)
+        add_post_result = await PostService.add_post_services(query_db, add_post)
         if add_post_result.is_success:
             logger.info(add_post_result.message)
             return ResponseUtil.success(msg=add_post_result.message)
@@ -47,11 +47,11 @@ async def add_system_post(request: Request, add_post: PostModel, query_db: Sessi
 
 @postController.put("", dependencies=[Depends(CheckUserInterfaceAuth('system:post:edit'))])
 @log_decorator(title='岗位管理', business_type=2)
-async def edit_system_post(request: Request, edit_post: PostModel, query_db: Session = Depends(get_db), current_user: CurrentUserModel = Depends(LoginService.get_current_user)):
+async def edit_system_post(request: Request, edit_post: PostModel, query_db: AsyncSession = Depends(get_db), current_user: CurrentUserModel = Depends(LoginService.get_current_user)):
     try:
         edit_post.update_by = current_user.user.user_name
         edit_post.update_time = datetime.now()
-        edit_post_result = PostService.edit_post_services(query_db, edit_post)
+        edit_post_result = await PostService.edit_post_services(query_db, edit_post)
         if edit_post_result.is_success:
             logger.info(edit_post_result.message)
             return ResponseUtil.success(msg=edit_post_result.message)
@@ -65,10 +65,10 @@ async def edit_system_post(request: Request, edit_post: PostModel, query_db: Ses
 
 @postController.delete("/{post_ids}", dependencies=[Depends(CheckUserInterfaceAuth('system:post:remove'))])
 @log_decorator(title='岗位管理', business_type=3)
-async def delete_system_post(request: Request, post_ids: str, query_db: Session = Depends(get_db)):
+async def delete_system_post(request: Request, post_ids: str, query_db: AsyncSession = Depends(get_db)):
     try:
         delete_post = DeletePostModel(postIds=post_ids)
-        delete_post_result = PostService.delete_post_services(query_db, delete_post)
+        delete_post_result = await PostService.delete_post_services(query_db, delete_post)
         if delete_post_result.is_success:
             logger.info(delete_post_result.message)
             return ResponseUtil.success(msg=delete_post_result.message)
@@ -81,9 +81,9 @@ async def delete_system_post(request: Request, post_ids: str, query_db: Session
 
 
 @postController.get("/{post_id}", response_model=PostModel, dependencies=[Depends(CheckUserInterfaceAuth('system:post:query'))])
-async def query_detail_system_post(request: Request, post_id: int, query_db: Session = Depends(get_db)):
+async def query_detail_system_post(request: Request, post_id: int, query_db: AsyncSession = Depends(get_db)):
     try:
-        post_detail_result = PostService.post_detail_services(query_db, post_id)
+        post_detail_result = await PostService.post_detail_services(query_db, post_id)
         logger.info(f'获取post_id为{post_id}的信息成功')
         return ResponseUtil.success(data=post_detail_result)
     except Exception as e:
@@ -93,11 +93,11 @@ async def query_detail_system_post(request: Request, post_id: int, query_db: Ses
 
 @postController.post("/export", dependencies=[Depends(CheckUserInterfaceAuth('system:post:export'))])
 @log_decorator(title='岗位管理', business_type=5)
-async def export_system_post_list(request: Request, post_page_query: PostPageQueryModel = Depends(PostPageQueryModel.as_form), query_db: Session = Depends(get_db)):
+async def export_system_post_list(request: Request, post_page_query: PostPageQueryModel = Depends(PostPageQueryModel.as_form), query_db: AsyncSession = Depends(get_db)):
     try:
         # 获取全量数据
-        post_query_result = PostService.get_post_list_services(query_db, post_page_query, is_page=False)
-        post_export_result = PostService.export_post_list_services(post_query_result)
+        post_query_result = await PostService.get_post_list_services(query_db, post_page_query, is_page=False)
+        post_export_result = await PostService.export_post_list_services(post_query_result)
         logger.info('导出成功')
         return ResponseUtil.streaming(data=bytes2file_response(post_export_result))
     except Exception as e:

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

@@ -18,10 +18,10 @@ 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: Session = 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 = DeptService.get_dept_tree_services(query_db, DeptModel(**{}), data_scope_sql)
-        role_dept_query_result = RoleService.get_role_dept_tree_services(query_db, role_id)
+        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)
@@ -31,9 +31,9 @@ async def get_system_role_dept_tree(request: Request, role_id: int, query_db: Se
     
     
 @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: Session = 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)):
     try:
-        role_page_query_result = RoleService.get_role_list_services(query_db, role_page_query, is_page=True)
+        role_page_query_result = await RoleService.get_role_list_services(query_db, role_page_query, is_page=True)
         logger.info('获取成功')
         return ResponseUtil.success(model_content=role_page_query_result)
     except Exception as e:
@@ -43,11 +43,11 @@ async def get_system_role_list(request: Request, role_page_query: RolePageQueryM
     
 @roleController.post("", dependencies=[Depends(CheckUserInterfaceAuth('system:role:add'))])
 @log_decorator(title='角色管理', business_type=1)
-async def add_system_role(request: Request, add_role: AddRoleModel, query_db: Session = 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.update_by = current_user.user.user_name
-        add_role_result = RoleService.add_role_services(query_db, add_role)
+        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)
@@ -61,11 +61,11 @@ async def add_system_role(request: Request, add_role: AddRoleModel, query_db: Se
     
 @roleController.put("", dependencies=[Depends(CheckUserInterfaceAuth('system:role:edit'))])
 @log_decorator(title='角色管理', business_type=2)
-async def edit_system_role(request: Request, edit_role: AddRoleModel, query_db: Session = 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)):
     try:
         edit_role.update_by = current_user.user.user_name
         edit_role.update_time = datetime.now()
-        edit_role_result = RoleService.edit_role_services(query_db, edit_role)
+        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)
@@ -79,11 +79,11 @@ async def edit_system_role(request: Request, edit_role: AddRoleModel, query_db:
 
 @roleController.put("/dataScope", dependencies=[Depends(CheckUserInterfaceAuth('system:role:edit'))])
 @log_decorator(title='角色管理', business_type=4)
-async def edit_system_role_datascope(request: Request, role_data_scope: AddRoleModel, query_db: Session = 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)):
     try:
         role_data_scope.update_by = current_user.user.user_name
         role_data_scope.update_time = datetime.now()
-        role_data_scope_result = RoleService.role_datascope_services(query_db, role_data_scope)
+        role_data_scope_result = await RoleService.role_datascope_services(query_db, role_data_scope)
         if role_data_scope_result.is_success:
             logger.info(role_data_scope_result.message)
             return ResponseUtil.success(msg=role_data_scope_result.message)
@@ -97,14 +97,14 @@ async def edit_system_role_datascope(request: Request, role_data_scope: AddRoleM
     
 @roleController.delete("/{role_ids}", dependencies=[Depends(CheckUserInterfaceAuth('system:role:remove'))])
 @log_decorator(title='角色管理', business_type=3)
-async def delete_system_role(request: Request, role_ids: str, query_db: Session = 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)):
     try:
         delete_role = DeleteRoleModel(
             roleIds=role_ids,
             updateBy=current_user.user.user_name,
             updateTime=datetime.now()
         )
-        delete_role_result = RoleService.delete_role_services(query_db, delete_role)
+        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)
@@ -117,9 +117,9 @@ async def delete_system_role(request: Request, role_ids: str, query_db: Session
     
     
 @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: Session = Depends(get_db)):
+async def query_detail_system_role(request: Request, role_id: int, query_db: AsyncSession = Depends(get_db)):
     try:
-        role_detail_result = RoleService.role_detail_services(query_db, role_id)
+        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:
@@ -129,11 +129,11 @@ async def query_detail_system_role(request: Request, role_id: int, query_db: Ses
 
 @roleController.post("/export", dependencies=[Depends(CheckUserInterfaceAuth('system:role:export'))])
 @log_decorator(title='角色管理', business_type=5)
-async def export_system_role_list(request: Request, role_page_query: RolePageQueryModel = Depends(RolePageQueryModel.as_form), query_db: Session = 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)):
     try:
         # 获取全量数据
-        role_query_result = RoleService.get_role_list_services(query_db, role_page_query, is_page=False)
-        role_export_result = RoleService.export_role_list_services(role_query_result)
+        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)
         logger.info('导出成功')
         return ResponseUtil.streaming(data=bytes2file_response(role_export_result))
     except Exception as e:
@@ -143,12 +143,12 @@ async def export_system_role_list(request: Request, role_page_query: RolePageQue
 
 @roleController.put("/changeStatus", dependencies=[Depends(CheckUserInterfaceAuth('system:role:edit'))])
 @log_decorator(title='角色管理', business_type=2)
-async def reset_system_role_status(request: Request, edit_role: AddRoleModel, query_db: Session = Depends(get_db), current_user: CurrentUserModel = Depends(LoginService.get_current_user)):
+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'
-        edit_role_result = RoleService.edit_role_services(query_db, edit_role)
+        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)
@@ -161,9 +161,9 @@ async def reset_system_role_status(request: Request, edit_role: AddRoleModel, qu
 
 
 @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: Session = 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)):
     try:
-        role_user_allocated_page_query_result = RoleService.get_role_user_allocated_list_services(query_db, user_role, 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('获取成功')
         return ResponseUtil.success(model_content=role_user_allocated_page_query_result)
     except Exception as e:
@@ -172,9 +172,9 @@ async def get_system_allocated_user_list(request: Request, user_role: UserRolePa
 
 
 @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: Session = 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)):
     try:
-        role_user_unallocated_page_query_result = RoleService.get_role_user_unallocated_list_services(query_db, user_role, 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('获取成功')
         return ResponseUtil.success(model_content=role_user_unallocated_page_query_result)
     except Exception as e:
@@ -184,9 +184,9 @@ async def get_system_unallocated_user_list(request: Request, user_role: UserRole
 
 @roleController.put("/authUser/selectAll", dependencies=[Depends(CheckUserInterfaceAuth('system:role:edit'))])
 @log_decorator(title='角色管理', business_type=4)
-async def add_system_role_user(request: Request, add_role_user: CrudUserRoleModel = Depends(CrudUserRoleModel.as_query), query_db: Session = 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)):
     try:
-        add_role_user_result = UserService.add_user_role_services(query_db, add_role_user)
+        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)
@@ -200,9 +200,9 @@ async def add_system_role_user(request: Request, add_role_user: CrudUserRoleMode
 
 @roleController.put("/authUser/cancel", dependencies=[Depends(CheckUserInterfaceAuth('system:role:edit'))])
 @log_decorator(title='角色管理', business_type=4)
-async def cancel_system_role_user(request: Request, cancel_user_role: CrudUserRoleModel, query_db: Session = 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 = 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)
         if cancel_user_role_result.is_success:
             logger.info(cancel_user_role_result.message)
             return ResponseUtil.success(msg=cancel_user_role_result.message)
@@ -216,9 +216,9 @@ async def cancel_system_role_user(request: Request, cancel_user_role: CrudUserRo
 
 @roleController.put("/authUser/cancelAll", dependencies=[Depends(CheckUserInterfaceAuth('system:role:edit'))])
 @log_decorator(title='角色管理', business_type=4)
-async def batch_cancel_system_role_user(request: Request, batch_cancel_user_role: CrudUserRoleModel = Depends(CrudUserRoleModel.as_query), query_db: Session = 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 = 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)
         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)

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

@@ -14,7 +14,7 @@ serverController = APIRouter(prefix='/monitor/server', dependencies=[Depends(Log
 async def get_monitor_server_info(request: Request):
     try:
         # 获取全量数据
-        server_info_query_result = ServerService.get_server_monitor_info()
+        server_info_query_result = await ServerService.get_server_monitor_info()
         logger.info('获取成功')
         return ResponseUtil.success(data=server_info_query_result)
     except Exception as e:

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

@@ -19,9 +19,9 @@ 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: Session = Depends(get_db), data_scope_sql: str = Depends(GetDataScope('SysDept'))):
+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 = 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('获取成功')
         return ResponseUtil.success(data=dept_query_result)
     except Exception as e:
@@ -30,10 +30,10 @@ async def get_system_dept_tree(request: Request, query_db: Session = Depends(get
 
 
 @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: Session = Depends(get_db), data_scope_sql: str = Depends(GetDataScope('SysUser'))):
+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 = 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('获取成功')
         return ResponseUtil.success(model_content=user_page_query_result)
     except Exception as e:
@@ -43,12 +43,12 @@ async def get_system_user_list(request: Request, user_page_query: UserPageQueryM
 
 @userController.post("", dependencies=[Depends(CheckUserInterfaceAuth('system:user:add'))])
 @log_decorator(title='用户管理', business_type=1)
-async def add_system_user(request: Request, add_user: AddUserModel, query_db: Session = Depends(get_db), current_user: CurrentUserModel = Depends(LoginService.get_current_user)):
+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.create_by = current_user.user.user_name
         add_user.update_by = current_user.user.user_name
-        add_user_result = UserService.add_user_services(query_db, add_user)
+        add_user_result = await UserService.add_user_services(query_db, add_user)
         if add_user_result.is_success:
             logger.info(add_user_result.message)
             return ResponseUtil.success(msg=add_user_result.message)
@@ -62,11 +62,11 @@ async def add_system_user(request: Request, add_user: AddUserModel, query_db: Se
 
 @userController.put("", dependencies=[Depends(CheckUserInterfaceAuth('system:user:edit'))])
 @log_decorator(title='用户管理', business_type=2)
-async def edit_system_user(request: Request, edit_user: EditUserModel, query_db: Session = 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)):
     try:
         edit_user.update_by = current_user.user.user_name
         edit_user.update_time = datetime.now()
-        edit_user_result = UserService.edit_user_services(query_db, edit_user)
+        edit_user_result = await UserService.edit_user_services(query_db, edit_user)
         if edit_user_result.is_success:
             logger.info(edit_user_result.message)
             return ResponseUtil.success(msg=edit_user_result.message)
@@ -80,14 +80,14 @@ async def edit_system_user(request: Request, edit_user: EditUserModel, query_db:
 
 @userController.delete("/{user_ids}", dependencies=[Depends(CheckUserInterfaceAuth('system:user:remove'))])
 @log_decorator(title='用户管理', business_type=3)
-async def delete_system_user(request: Request, user_ids: str, query_db: Session = 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)):
     try:
         delete_user = DeleteUserModel(
             userIds=user_ids,
             updateBy=current_user.user.user_name,
             updateTime=datetime.now()
         )
-        delete_user_result = UserService.delete_user_services(query_db, delete_user)
+        delete_user_result = await UserService.delete_user_services(query_db, delete_user)
         if delete_user_result.is_success:
             logger.info(delete_user_result.message)
             return ResponseUtil.success(msg=delete_user_result.message)
@@ -101,13 +101,13 @@ async def delete_system_user(request: Request, user_ids: str, query_db: Session
 
 @userController.put("/resetPwd", dependencies=[Depends(CheckUserInterfaceAuth('system:user:resetPwd'))])
 @log_decorator(title='用户管理', business_type=2)
-async def reset_system_user_pwd(request: Request, edit_user: EditUserModel, query_db: Session = Depends(get_db), current_user: CurrentUserModel = Depends(LoginService.get_current_user)):
+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)):
     try:
         edit_user.password = PwdUtil.get_password_hash(edit_user.password)
         edit_user.update_by = current_user.user.user_name
         edit_user.update_time = datetime.now()
         edit_user.type = 'pwd'
-        edit_user_result = UserService.edit_user_services(query_db, edit_user)
+        edit_user_result = await UserService.edit_user_services(query_db, edit_user)
         if edit_user_result.is_success:
             logger.info(edit_user_result.message)
             return ResponseUtil.success(msg=edit_user_result.message)
@@ -121,12 +121,12 @@ async def reset_system_user_pwd(request: Request, edit_user: EditUserModel, quer
 
 @userController.put("/changeStatus", dependencies=[Depends(CheckUserInterfaceAuth('system:user:edit'))])
 @log_decorator(title='用户管理', business_type=2)
-async def change_system_user_status(request: Request, edit_user: EditUserModel, query_db: Session = Depends(get_db), current_user: CurrentUserModel = Depends(LoginService.get_current_user)):
+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)):
     try:
         edit_user.update_by = current_user.user.user_name
         edit_user.update_time = datetime.now()
         edit_user.type = 'status'
-        edit_user_result = UserService.edit_user_services(query_db, edit_user)
+        edit_user_result = await UserService.edit_user_services(query_db, edit_user)
         if edit_user_result.is_success:
             logger.info(edit_user_result.message)
             return ResponseUtil.success(msg=edit_user_result.message)
@@ -139,9 +139,9 @@ async def change_system_user_status(request: Request, edit_user: EditUserModel,
 
 
 @userController.get("/profile", response_model=UserProfileModel)
-async def query_detail_system_user(request: Request, query_db: Session = Depends(get_db), current_user: CurrentUserModel = Depends(LoginService.get_current_user)):
+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 = 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}的信息成功')
         return ResponseUtil.success(model_content=profile_user_result)
     except Exception as e:
@@ -151,9 +151,9 @@ async def query_detail_system_user(request: Request, query_db: Session = Depends
 
 @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: Session = Depends(get_db), current_user: CurrentUserModel = Depends(LoginService.get_current_user)):
+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 = 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}的信息成功')
         return ResponseUtil.success(model_content=detail_user_result)
     except Exception as e:
@@ -163,7 +163,7 @@ async def query_detail_system_user(request: Request, user_id: Optional[Union[int
 
 @userController.post("/profile/avatar")
 @log_decorator(title='个人信息', business_type=2)
-async def change_system_user_profile_avatar(request: Request, avatarfile: bytes = File(), query_db: Session = Depends(get_db), current_user: CurrentUserModel = Depends(LoginService.get_current_user)):
+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:
         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)
@@ -182,7 +182,7 @@ async def change_system_user_profile_avatar(request: Request, avatarfile: bytes
             updateTime=datetime.now(),
             type='avatar'
         )
-        edit_user_result = UserService.edit_user_services(query_db, edit_user)
+        edit_user_result = await UserService.edit_user_services(query_db, edit_user)
         if edit_user_result.is_success:
             logger.info(edit_user_result.message)
             return ResponseUtil.success(dict_content={'imgUrl': edit_user.avatar}, msg=edit_user_result.message)
@@ -196,7 +196,7 @@ async def change_system_user_profile_avatar(request: Request, avatarfile: bytes
 
 @userController.put("/profile")
 @log_decorator(title='个人信息', business_type=2)
-async def change_system_user_profile_info(request: Request, user_info: UserInfoModel, query_db: Session = Depends(get_db), current_user: CurrentUserModel = Depends(LoginService.get_current_user)):
+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(
             **user_info.model_dump(
@@ -212,7 +212,7 @@ async def change_system_user_profile_info(request: Request, user_info: UserInfoM
             postIds=current_user.user.post_ids.split(',') if current_user.user.post_ids else [],
             role=current_user.user.role
         )
-        edit_user_result = UserService.edit_user_services(query_db, edit_user)
+        edit_user_result = await UserService.edit_user_services(query_db, edit_user)
         if edit_user_result.is_success:
             logger.info(edit_user_result.message)
             return ResponseUtil.success(msg=edit_user_result.message)
@@ -226,7 +226,7 @@ async def change_system_user_profile_info(request: Request, user_info: UserInfoM
 
 @userController.put("/profile/updatePwd")
 @log_decorator(title='个人信息', business_type=2)
-async def reset_system_user_password(request: Request, reset_password: ResetPasswordModel = Depends(ResetPasswordModel.as_query), query_db: Session = Depends(get_db), current_user: CurrentUserModel = Depends(LoginService.get_current_user)):
+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(
             userId=current_user.user.user_id,
@@ -235,7 +235,7 @@ async def reset_system_user_password(request: Request, reset_password: ResetPass
             updateBy=current_user.user.user_name,
             updateTime=datetime.now()
         )
-        reset_user_result = UserService.reset_user_services(query_db, reset_user)
+        reset_user_result = await UserService.reset_user_services(query_db, reset_user)
         if reset_user_result.is_success:
             logger.info(reset_user_result.message)
             return ResponseUtil.success(msg=reset_user_result.message)
@@ -249,7 +249,7 @@ async def reset_system_user_password(request: Request, reset_password: ResetPass
 
 @userController.post("/importData", dependencies=[Depends(CheckUserInterfaceAuth('system:user:import'))])
 @log_decorator(title='用户管理', business_type=6)
-async def batch_import_system_user(request: Request, file: UploadFile = File(...), update_support: bool = Query(alias='updateSupport'), query_db: Session = Depends(get_db), current_user: CurrentUserModel = Depends(LoginService.get_current_user)):
+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)
         if batch_import_result.is_success:
@@ -264,9 +264,9 @@ async def batch_import_system_user(request: Request, file: UploadFile = File(...
 
 
 @userController.post("/importTemplate", dependencies=[Depends(CheckUserInterfaceAuth('system:user:import'))])
-async def export_system_user_template(request: Request, query_db: Session = Depends(get_db)):
+async def export_system_user_template(request: Request, query_db: AsyncSession = Depends(get_db)):
     try:
-        user_import_template_result = UserService.get_user_import_template_services()
+        user_import_template_result = await UserService.get_user_import_template_services()
         logger.info('获取成功')
         return ResponseUtil.streaming(data=bytes2file_response(user_import_template_result))
     except Exception as e:
@@ -276,11 +276,11 @@ async def export_system_user_template(request: Request, query_db: Session = Depe
 
 @userController.post("/export", dependencies=[Depends(CheckUserInterfaceAuth('system:user:export'))])
 @log_decorator(title='用户管理', business_type=5)
-async def export_system_user_list(request: Request, user_page_query: UserPageQueryModel = Depends(UserPageQueryModel.as_form), query_db: Session = Depends(get_db), data_scope_sql: str = Depends(GetDataScope('SysUser'))):
+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 = UserService.get_user_list_services(query_db, user_page_query, data_scope_sql, is_page=False)
-        user_export_result = UserService.export_user_list_services(user_query_result)
+        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)
         logger.info('导出成功')
         return ResponseUtil.streaming(data=bytes2file_response(user_export_result))
     except Exception as e:
@@ -289,10 +289,10 @@ async def export_system_user_list(request: Request, user_page_query: UserPageQue
 
 
 @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: Session = Depends(get_db)):
+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_allocated_query_result = 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('获取成功')
         return ResponseUtil.success(model_content=user_role_allocated_query_result)
     except Exception as e:
@@ -301,9 +301,9 @@ async def get_system_allocated_role_list(request: Request, user_id: int, query_d
 
 
 @userController.put("/authRole", response_model=UserRoleResponseModel, dependencies=[Depends(CheckUserInterfaceAuth('system:user:edit'))])
-async def update_system_role_user(request: Request, user_id: int = Query(alias='userId'), role_ids: str = Query(alias='roleIds'), query_db: Session = 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)):
     try:
-        add_user_role_result = UserService.add_user_role_services(query_db, CrudUserRoleModel(userId=user_id, roleIds=role_ids))
+        add_user_role_result = await UserService.add_user_role_services(query_db, CrudUserRoleModel(userId=user_id, roleIds=role_ids))
         if add_user_role_result.is_success:
             logger.info(add_user_role_result.message)
             return ResponseUtil.success(msg=add_user_role_result.message)

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

@@ -1,4 +1,5 @@
-from sqlalchemy.orm import Session
+from sqlalchemy import select, update, delete
+from sqlalchemy.ext.asyncio import AsyncSession
 from module_admin.entity.do.config_do import SysConfig
 from module_admin.entity.vo.config_vo import *
 from utils.page_util import PageUtil
@@ -11,36 +12,38 @@ class ConfigDao:
     """
 
     @classmethod
-    def get_config_detail_by_id(cls, db: Session, config_id: int):
+    async def get_config_detail_by_id(cls, db: AsyncSession, config_id: int):
         """
         根据参数配置id获取参数配置详细信息
         :param db: orm对象
         :param config_id: 参数配置id
         :return: 参数配置信息对象
         """
-        config_info = db.query(SysConfig) \
-            .filter(SysConfig.config_id == config_id) \
-            .first()
+        config_info = (await db.execute(
+            select(SysConfig)
+                .where(SysConfig.config_id == config_id)
+        )).scalars().first()
 
         return config_info
 
     @classmethod
-    def get_config_detail_by_info(cls, db: Session, config: ConfigModel):
+    async def get_config_detail_by_info(cls, db: AsyncSession, config: ConfigModel):
         """
         根据参数配置参数获取参数配置信息
         :param db: orm对象
         :param config: 参数配置参数对象
         :return: 参数配置信息对象
         """
-        config_info = db.query(SysConfig) \
-            .filter(SysConfig.config_key == config.config_key if config.config_key else True,
-                    SysConfig.config_value == config.config_value if config.config_value else True) \
-            .first()
+        config_info = (await db.execute(
+            select(SysConfig)
+                .where(SysConfig.config_key == config.config_key if config.config_key else True,
+                       SysConfig.config_value == config.config_value if config.config_value else True)
+        )).scalars().first()
 
         return config_info
 
     @classmethod
-    def get_config_list(cls, db: Session, query_object: ConfigPageQueryModel, is_page: bool = False):
+    async def get_config_list(cls, db: AsyncSession, query_object: ConfigPageQueryModel, is_page: bool = False):
         """
         根据查询参数获取参数配置列表信息
         :param db: orm对象
@@ -48,22 +51,21 @@ class ConfigDao:
         :param is_page: 是否开启分页
         :return: 参数配置列表信息对象
         """
-        query = db.query(SysConfig) \
-            .filter(SysConfig.config_name.like(f'%{query_object.config_name}%') if query_object.config_name else True,
-                    SysConfig.config_key.like(f'%{query_object.config_key}%') if query_object.config_key else True,
-                    SysConfig.config_type == query_object.config_type if query_object.config_type else True,
-                    SysConfig.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
-                    ) \
+        query = select(SysConfig) \
+            .where(SysConfig.config_name.like(f'%{query_object.config_name}%') if query_object.config_name else True,
+                   SysConfig.config_key.like(f'%{query_object.config_key}%') if query_object.config_key else True,
+                   SysConfig.config_type == query_object.config_type if query_object.config_type else True,
+                   SysConfig.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) \
             .distinct()
-        config_list = PageUtil.paginate(query, query_object.page_num, query_object.page_size, is_page)
+        config_list = await PageUtil.paginate(db, query, query_object.page_num, query_object.page_size, is_page)
 
         return config_list
 
     @classmethod
-    def add_config_dao(cls, db: Session, config: ConfigModel):
+    async def add_config_dao(cls, db: AsyncSession, config: ConfigModel):
         """
         新增参数配置数据库操作
         :param db: orm对象
@@ -72,30 +74,32 @@ class ConfigDao:
         """
         db_config = SysConfig(**config.model_dump())
         db.add(db_config)
-        db.flush()
+        await db.flush()
 
         return db_config
 
     @classmethod
-    def edit_config_dao(cls, db: Session, config: dict):
+    async def edit_config_dao(cls, db: AsyncSession, config: dict):
         """
         编辑参数配置数据库操作
         :param db: orm对象
         :param config: 需要更新的参数配置字典
         :return:
         """
-        db.query(SysConfig) \
-            .filter(SysConfig.config_id == config.get('config_id')) \
-            .update(config)
+        await db.execute(
+            update(SysConfig),
+            [config]
+        )
 
     @classmethod
-    def delete_config_dao(cls, db: Session, config: ConfigModel):
+    async def delete_config_dao(cls, db: AsyncSession, config: ConfigModel):
         """
         删除参数配置数据库操作
         :param db: orm对象
         :param config: 参数配置对象
         :return:
         """
-        db.query(SysConfig) \
-            .filter(SysConfig.config_id == config.config_id) \
-            .delete()
+        await db.execute(
+            delete(SysConfig)
+                .where(SysConfig.config_id.in_([config.config_id]))
+        )

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

@@ -1,4 +1,5 @@
-from sqlalchemy.orm import Session
+from sqlalchemy import select, update, delete
+from sqlalchemy.ext.asyncio import AsyncSession
 from module_admin.entity.do.dept_do import SysDept
 from module_admin.entity.do.role_do import SysRoleDept
 from module_admin.entity.vo.dept_vo import *
@@ -11,68 +12,72 @@ class DeptDao:
     """
 
     @classmethod
-    def get_dept_by_id(cls, db: Session, dept_id: int):
+    async def get_dept_by_id(cls, db: AsyncSession, dept_id: int):
         """
         根据部门id获取在用部门信息
         :param db: orm对象
         :param dept_id: 部门id
         :return: 在用部门信息对象
         """
-        dept_info = db.query(SysDept) \
-            .filter(SysDept.dept_id == dept_id,
-                    SysDept.status == 0,
-                    SysDept.del_flag == 0) \
-            .first()
+        dept_info = (await db.execute(
+            select(SysDept)
+                .where(SysDept.dept_id == dept_id,
+                       SysDept.status == 0,
+                       SysDept.del_flag == 0)
+        )).scalars().first()
 
         return dept_info
 
     @classmethod
-    def get_dept_by_id_for_list(cls, db: Session, dept_id: int):
+    async def get_dept_by_id_for_list(cls, db: AsyncSession, dept_id: int):
         """
         用于获取部门列表的工具方法
         :param db: orm对象
         :param dept_id: 部门id
         :return: 部门id对应的信息对象
         """
-        dept_info = db.query(SysDept) \
-            .filter(SysDept.dept_id == dept_id,
-                    SysDept.del_flag == 0) \
-            .first()
+        dept_info = (await db.execute(
+            select(SysDept)
+                .where(SysDept.dept_id == dept_id,
+                       SysDept.del_flag == 0)
+        )).scalars().first()
 
         return dept_info
 
     @classmethod
-    def get_dept_detail_by_id(cls, db: Session, dept_id: int):
+    async def get_dept_detail_by_id(cls, db: AsyncSession, dept_id: int):
         """
         根据部门id获取部门详细信息
         :param db: orm对象
         :param dept_id: 部门id
         :return: 部门信息对象
         """
-        dept_info = db.query(SysDept) \
-            .filter(SysDept.dept_id == dept_id,
-                    SysDept.del_flag == 0) \
-            .first()
+        dept_info = (await db.execute(
+            select(SysDept)
+                .where(SysDept.dept_id == dept_id,
+                       SysDept.del_flag == 0)
+        )).scalars().first()
 
         return dept_info
 
     @classmethod
-    def get_dept_detail_by_info(cls, db: Session, dept: DeptModel):
+    async def get_dept_detail_by_info(cls, db: AsyncSession, dept: DeptModel):
         """
         根据部门参数获取部门信息
         :param db: orm对象
         :param dept: 部门参数对象
         :return: 部门信息对象
         """
-        dept_info = db.query(SysDept) \
-            .filter(SysDept.parent_id == dept.parent_id if dept.parent_id else True,
-                    SysDept.dept_name == dept.dept_name if dept.dept_name else True) \
-            .first()
+        dept_info = (await db.execute(
+            select(SysDept)
+                .where(SysDept.parent_id == dept.parent_id if dept.parent_id else True,
+                       SysDept.dept_name == dept.dept_name if dept.dept_name else True)
+        )).scalars().first()
 
         return dept_info
 
     @classmethod
-    def get_dept_info_for_edit_option(cls, db: Session, dept_info: DeptModel, data_scope_sql: str):
+    async def get_dept_info_for_edit_option(cls, db: AsyncSession, dept_info: DeptModel, data_scope_sql: str):
         """
         获取部门编辑对应的在用部门列表信息
         :param db: orm对象
@@ -80,46 +85,50 @@ class DeptDao:
         :param data_scope_sql: 数据权限对应的查询sql语句
         :return: 部门列表信息
         """
-        dept_result = db.query(SysDept) \
-            .filter(SysDept.dept_id != dept_info.dept_id,
-                    SysDept.parent_id != dept_info.dept_id,
-                    SysDept.del_flag == 0, SysDept.status == 0,
-                    eval(data_scope_sql)) \
-            .order_by(SysDept.order_num) \
-            .distinct().all()
+        dept_result = (await db.execute(
+            select(SysDept)
+                .where(SysDept.dept_id != dept_info.dept_id,
+                       SysDept.parent_id != dept_info.dept_id,
+                       SysDept.del_flag == 0, SysDept.status == 0,
+                       eval(data_scope_sql))
+                .order_by(SysDept.order_num)
+                .distinct()
+        )).scalars().all()
 
         return list_format_datetime(dept_result)
 
     @classmethod
-    def get_children_dept(cls, db: Session, dept_id: int):
+    async def get_children_dept(cls, db: AsyncSession, dept_id: int):
         """
         根据部门id查询当前部门的子部门列表信息
         :param db: orm对象
         :param dept_id: 部门id
         :return: 子部门信息列表
         """
-        dept_result = db.query(SysDept) \
-            .filter(SysDept.parent_id == dept_id,
-                    SysDept.del_flag == 0) \
-            .all()
+        dept_result = (await db.execute(
+            select(SysDept)
+                .where(SysDept.parent_id == dept_id,
+                       SysDept.del_flag == 0)
+        )).scalars().all()
 
         return list_format_datetime(dept_result)
 
     @classmethod
-    def get_dept_all_ancestors(cls, db: Session):
+    async def get_dept_all_ancestors(cls, db: AsyncSession):
         """
         获取所有部门的ancestors信息
         :param db: orm对象
         :return: ancestors信息列表
         """
-        ancestors = db.query(SysDept.ancestors)\
-            .filter(SysDept.del_flag == 0)\
-            .all()
+        ancestors = (await db.execute(
+            select(SysDept.ancestors)
+                .where(SysDept.del_flag == 0)
+        )).scalars().all()
 
         return ancestors
 
     @classmethod
-    def get_dept_list_for_tree(cls, db: Session, dept_info: DeptModel, data_scope_sql: str):
+    async def get_dept_list_for_tree(cls, db: AsyncSession, dept_info: DeptModel, data_scope_sql: str):
         """
         获取所有在用部门列表信息
         :param db: orm对象
@@ -127,18 +136,20 @@ class DeptDao:
         :param data_scope_sql: 数据权限对应的查询sql语句
         :return: 在用部门列表信息
         """
-        dept_result = db.query(SysDept) \
-            .filter(SysDept.status == 0,
-                    SysDept.del_flag == 0,
-                    SysDept.dept_name.like(f'%{dept_info.dept_name}%') if dept_info.dept_name else True,
-                    eval(data_scope_sql)) \
-            .order_by(SysDept.order_num) \
-            .distinct().all()
+        dept_result = (await db.execute(
+            select(SysDept)
+                .where(SysDept.status == 0,
+                       SysDept.del_flag == 0,
+                       SysDept.dept_name.like(f'%{dept_info.dept_name}%') if dept_info.dept_name else True,
+                       eval(data_scope_sql))
+                .order_by(SysDept.order_num)
+                .distinct()
+        )).scalars().all()
 
         return dept_result
 
     @classmethod
-    def get_dept_list(cls, db: Session, page_object: DeptModel, data_scope_sql: str):
+    async def get_dept_list(cls, db: AsyncSession, page_object: DeptModel, data_scope_sql: str):
         """
         根据查询参数获取部门列表信息
         :param db: orm对象
@@ -146,18 +157,20 @@ class DeptDao:
         :param data_scope_sql: 数据权限对应的查询sql语句
         :return: 部门列表信息对象
         """
-        dept_result = db.query(SysDept) \
-            .filter(SysDept.del_flag == 0,
-                    SysDept.status == page_object.status if page_object.status else True,
-                    SysDept.dept_name.like(f'%{page_object.dept_name}%') if page_object.dept_name else True,
-                    eval(data_scope_sql)) \
-            .order_by(SysDept.order_num) \
-            .distinct().all()
+        dept_result = (await db.execute(
+            select(SysDept)
+                .where(SysDept.del_flag == 0,
+                       SysDept.status == page_object.status if page_object.status else True,
+                       SysDept.dept_name.like(f'%{page_object.dept_name}%') if page_object.dept_name else True,
+                       eval(data_scope_sql))
+                .order_by(SysDept.order_num)
+                .distinct()
+        )).scalars().all()
 
         return dept_result
 
     @classmethod
-    def add_dept_dao(cls, db: Session, dept: DeptModel):
+    async def add_dept_dao(cls, db: AsyncSession, dept: DeptModel):
         """
         新增部门数据库操作
         :param db: orm对象
@@ -166,30 +179,33 @@ class DeptDao:
         """
         db_dept = SysDept(**dept.model_dump())
         db.add(db_dept)
-        db.flush()
+        await db.flush()
 
         return db_dept
 
     @classmethod
-    def edit_dept_dao(cls, db: Session, dept: dict):
+    async def edit_dept_dao(cls, db: AsyncSession, dept: dict):
         """
         编辑部门数据库操作
         :param db: orm对象
         :param dept: 需要更新的部门字典
         :return: 编辑校验结果
         """
-        db.query(SysDept) \
-            .filter(SysDept.dept_id == dept.get('dept_id')) \
-            .update(dept)
+        await db.execute(
+            update(SysDept),
+            [dept]
+        )
 
     @classmethod
-    def delete_dept_dao(cls, db: Session, dept: DeptModel):
+    async def delete_dept_dao(cls, db: AsyncSession, dept: DeptModel):
         """
         删除部门数据库操作
         :param db: orm对象
         :param dept: 部门对象
         :return:
         """
-        db.query(SysDept) \
-            .filter(SysDept.dept_id == dept.dept_id) \
-            .update({SysDept.del_flag: '2', SysDept.update_by: dept.update_by, SysDept.update_time: dept.update_time})
+        await db.execute(
+            update(SysDept)
+                .where(SysDept.dept_id == dept.dept_id)
+                .values(del_flag='2', update_by=dept.update_by, update_time=dept.update_time)
+        )

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

@@ -1,5 +1,5 @@
-from sqlalchemy import and_
-from sqlalchemy.orm import Session
+from sqlalchemy import select, update, delete, and_
+from sqlalchemy.ext.asyncio import AsyncSession
 from module_admin.entity.do.dict_do import SysDictType, SysDictData
 from module_admin.entity.vo.dict_vo import *
 from utils.time_format_util import list_format_datetime
@@ -13,47 +13,51 @@ class DictTypeDao:
     """
 
     @classmethod
-    def get_dict_type_detail_by_id(cls, db: Session, dict_id: int):
+    async def get_dict_type_detail_by_id(cls, db: AsyncSession, dict_id: int):
         """
         根据字典类型id获取字典类型详细信息
         :param db: orm对象
         :param dict_id: 字典类型id
         :return: 字典类型信息对象
         """
-        dict_type_info = db.query(SysDictType) \
-            .filter(SysDictType.dict_id == dict_id) \
-            .first()
+        dict_type_info = (await db.execute(
+            select(SysDictType)
+                .where(SysDictType.dict_id == dict_id)
+        )).scalars().first()
 
         return dict_type_info
 
     @classmethod
-    def get_dict_type_detail_by_info(cls, db: Session, dict_type: DictTypeModel):
+    async def get_dict_type_detail_by_info(cls, db: AsyncSession, dict_type: DictTypeModel):
         """
         根据字典类型参数获取字典类型信息
         :param db: orm对象
         :param dict_type: 字典类型参数对象
         :return: 字典类型信息对象
         """
-        dict_type_info = db.query(SysDictType) \
-            .filter(SysDictType.dict_type == dict_type.dict_type if dict_type.dict_type else True,
-                    SysDictType.dict_name == dict_type.dict_name if dict_type.dict_name else True) \
-            .first()
+        dict_type_info = (await db.execute(
+            select(SysDictType)
+                .where(SysDictType.dict_type == dict_type.dict_type if dict_type.dict_type else True,
+                       SysDictType.dict_name == dict_type.dict_name if dict_type.dict_name else True)
+        )).scalars().first()
 
         return dict_type_info
 
     @classmethod
-    def get_all_dict_type(cls, db: Session):
+    async def get_all_dict_type(cls, db: AsyncSession):
         """
         获取所有的字典类型信息
         :param db: orm对象
         :return: 字典类型信息列表对象
         """
-        dict_type_info = db.query(SysDictType).all()
+        dict_type_info = (await db.execute(
+            select(SysDictType)
+        )).scalars().all()
 
         return list_format_datetime(dict_type_info)
 
     @classmethod
-    def get_dict_type_list(cls, db: Session, query_object: DictTypePageQueryModel, is_page: bool = False):
+    async def get_dict_type_list(cls, db: AsyncSession, query_object: DictTypePageQueryModel, is_page: bool = False):
         """
         根据查询参数获取字典类型列表信息
         :param db: orm对象
@@ -61,57 +65,58 @@ class DictTypeDao:
         :param is_page: 是否开启分页
         :return: 字典类型列表信息对象
         """
-        query = db.query(SysDictType) \
-            .filter(SysDictType.dict_name.like(f'%{query_object.dict_name}%') if query_object.dict_name else True,
-                    SysDictType.dict_type.like(f'%{query_object.dict_type}%') if query_object.dict_type else True,
-                    SysDictType.status == query_object.status if query_object.status else True,
-                    SysDictType.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
-                    ) \
+        query = select(SysDictType) \
+            .where(SysDictType.dict_name.like(f'%{query_object.dict_name}%') if query_object.dict_name else True,
+                   SysDictType.dict_type.like(f'%{query_object.dict_type}%') if query_object.dict_type else True,
+                   SysDictType.status == query_object.status if query_object.status else True,
+                   SysDictType.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) \
             .distinct()
-        dict_type_list = PageUtil.paginate(query, query_object.page_num, query_object.page_size, is_page)
+        dict_type_list = await PageUtil.paginate(db, query, query_object.page_num, query_object.page_size, is_page)
 
         return dict_type_list
 
     @classmethod
-    def add_dict_type_dao(cls, db: Session, dict_type: DictTypeModel):
+    async def add_dict_type_dao(cls, db: AsyncSession, dict_type: DictTypeModel):
         """
         新增字典类型数据库操作
         :param db: orm对象
         :param dict_type: 字典类型对象
         :return:
         """
-        db_dict_type = SysDictType(**dict_type.dict())
+        db_dict_type = SysDictType(**dict_type.model_dump())
         db.add(db_dict_type)
-        db.flush()
+        await db.flush()
 
         return db_dict_type
 
     @classmethod
-    def edit_dict_type_dao(cls, db: Session, dict_type: dict):
+    async def edit_dict_type_dao(cls, db: AsyncSession, dict_type: dict):
         """
         编辑字典类型数据库操作
         :param db: orm对象
         :param dict_type: 需要更新的字典类型字典
         :return:
         """
-        db.query(SysDictType) \
-            .filter(SysDictType.dict_id == dict_type.get('dict_id')) \
-            .update(dict_type)
+        await db.execute(
+            update(SysDictType),
+            [dict_type]
+        )
 
     @classmethod
-    def delete_dict_type_dao(cls, db: Session, dict_type: DictTypeModel):
+    async def delete_dict_type_dao(cls, db: AsyncSession, dict_type: DictTypeModel):
         """
         删除字典类型数据库操作
         :param db: orm对象
         :param dict_type: 字典类型对象
         :return:
         """
-        db.query(SysDictType) \
-            .filter(SysDictType.dict_id == dict_type.dict_id) \
-            .delete()
+        await db.execute(
+            delete(SysDictType)
+                .where(SysDictType.dict_id.in_([dict_type.dict_id]))
+        )
 
 
 class DictDataDao:
@@ -120,37 +125,39 @@ class DictDataDao:
     """
 
     @classmethod
-    def get_dict_data_detail_by_id(cls, db: Session, dict_code: int):
+    async def get_dict_data_detail_by_id(cls, db: AsyncSession, dict_code: int):
         """
         根据字典数据id获取字典数据详细信息
         :param db: orm对象
         :param dict_code: 字典数据id
         :return: 字典数据信息对象
         """
-        dict_data_info = db.query(SysDictData) \
-            .filter(SysDictData.dict_code == dict_code) \
-            .first()
+        dict_data_info = (await db.execute(
+            select(SysDictData)
+                .where(SysDictData.dict_code == dict_code)
+        )).scalars().first()
 
         return dict_data_info
 
     @classmethod
-    def get_dict_data_detail_by_info(cls, db: Session, dict_data: DictDataModel):
+    async def get_dict_data_detail_by_info(cls, db: AsyncSession, dict_data: DictDataModel):
         """
         根据字典数据参数获取字典数据信息
         :param db: orm对象
         :param dict_data: 字典数据参数对象
         :return: 字典数据信息对象
         """
-        dict_data_info = db.query(SysDictData) \
-            .filter(SysDictData.dict_type == dict_data.dict_type if dict_data.dict_type else True,
-                    SysDictData.dict_label == dict_data.dict_label if dict_data.dict_label else True,
-                    SysDictData.dict_value == dict_data.dict_value if dict_data.dict_value else True) \
-            .first()
+        dict_data_info = (await db.execute(
+            select(SysDictData)
+                .where(SysDictData.dict_type == dict_data.dict_type if dict_data.dict_type else True,
+                       SysDictData.dict_label == dict_data.dict_label if dict_data.dict_label else True,
+                       SysDictData.dict_value == dict_data.dict_value if dict_data.dict_value else True)
+        )).scalars().first()
 
         return dict_data_info
 
     @classmethod
-    def get_dict_data_list(cls, db: Session, query_object: DictDataPageQueryModel, is_page: bool = False):
+    async def get_dict_data_list(cls, db: AsyncSession, query_object: DictDataPageQueryModel, is_page: bool = False):
         """
         根据查询参数获取字典数据列表信息
         :param db: orm对象
@@ -158,35 +165,37 @@ class DictDataDao:
         :param is_page: 是否开启分页
         :return: 字典数据列表信息对象
         """
-        query = db.query(SysDictData) \
-            .filter(SysDictData.dict_type == query_object.dict_type if query_object.dict_type else True,
-                    SysDictData.dict_label.like(f'%{query_object.dict_label}%') if query_object.dict_label else True,
-                    SysDictData.status == query_object.status if query_object.status else True
-                    ) \
-            .order_by(SysDictData.dict_sort) \
+        query = select(SysDictData) \
+            .where(SysDictData.dict_type == query_object.dict_type if query_object.dict_type else True,
+                   SysDictData.dict_label.like(f'%{query_object.dict_label}%') if query_object.dict_label else True,
+                   SysDictData.status == query_object.status if query_object.status else True)\
+            .order_by(SysDictData.dict_sort)\
             .distinct()
-        dict_data_list = PageUtil.paginate(query, query_object.page_num, query_object.page_size, is_page)
+        dict_data_list = await PageUtil.paginate(db, query, query_object.page_num, query_object.page_size, is_page)
 
         return dict_data_list
 
     @classmethod
-    def query_dict_data_list(cls, db: Session, dict_type: str):
+    async def query_dict_data_list(cls, db: AsyncSession, dict_type: str):
         """
         根据查询参数获取字典数据列表信息
         :param db: orm对象
         :param dict_type: 字典类型
         :return: 字典数据列表信息对象
         """
-        dict_data_list = db.query(SysDictData).select_from(SysDictType) \
-            .filter(SysDictType.dict_type == dict_type if dict_type else True, SysDictType.status == 0) \
-            .outerjoin(SysDictData, and_(SysDictType.dict_type == SysDictData.dict_type, SysDictData.status == 0)) \
-            .order_by(SysDictData.dict_sort) \
-            .distinct().all()
+        dict_data_list = (await db.execute(
+            select(SysDictData)
+                .select_from(SysDictType)
+                .where(SysDictType.dict_type == dict_type if dict_type else True, SysDictType.status == 0)
+                .join(SysDictData, and_(SysDictType.dict_type == SysDictData.dict_type, SysDictData.status == 0), isouter=True)
+                .order_by(SysDictData.dict_sort)
+                .distinct()
+        )).scalars().all()
 
         return dict_data_list
 
     @classmethod
-    def add_dict_data_dao(cls, db: Session, dict_data: DictDataModel):
+    async def add_dict_data_dao(cls, db: AsyncSession, dict_data: DictDataModel):
         """
         新增字典数据数据库操作
         :param db: orm对象
@@ -195,30 +204,32 @@ class DictDataDao:
         """
         db_data_type = SysDictData(**dict_data.dict())
         db.add(db_data_type)
-        db.flush()
+        await db.flush()
 
         return db_data_type
 
     @classmethod
-    def edit_dict_data_dao(cls, db: Session, dict_data: dict):
+    async def edit_dict_data_dao(cls, db: AsyncSession, dict_data: dict):
         """
         编辑字典数据数据库操作
         :param db: orm对象
         :param dict_data: 需要更新的字典数据字典
         :return:
         """
-        db.query(SysDictData) \
-            .filter(SysDictData.dict_code == dict_data.get('dict_code')) \
-            .update(dict_data)
+        await db.execute(
+            update(SysDictData),
+            [dict_data]
+        )
 
     @classmethod
-    def delete_dict_data_dao(cls, db: Session, dict_data: DictDataModel):
+    async def delete_dict_data_dao(cls, db: AsyncSession, dict_data: DictDataModel):
         """
         删除字典数据数据库操作
         :param db: orm对象
         :param dict_data: 字典数据对象
         :return:
         """
-        db.query(SysDictData) \
-            .filter(SysDictData.dict_code == dict_data.dict_code) \
-            .delete()
+        await db.execute(
+            delete(SysDictData)
+                .where(SysDictData.dict_code.in_([dict_data.dict_code]))
+        )

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

@@ -1,4 +1,5 @@
-from sqlalchemy.orm import Session
+from sqlalchemy import select, update, delete
+from sqlalchemy.ext.asyncio import AsyncSession
 from module_admin.entity.do.job_do import SysJob
 from module_admin.entity.vo.job_vo import *
 from utils.page_util import PageUtil
@@ -10,38 +11,40 @@ class JobDao:
     """
 
     @classmethod
-    def get_job_detail_by_id(cls, db: Session, job_id: int):
+    async def get_job_detail_by_id(cls, db: AsyncSession, job_id: int):
         """
         根据定时任务id获取定时任务详细信息
         :param db: orm对象
         :param job_id: 定时任务id
         :return: 定时任务信息对象
         """
-        job_info = db.query(SysJob) \
-            .filter(SysJob.job_id == job_id) \
-            .first()
+        job_info = (await db.execute(
+            select(SysJob)
+                .where(SysJob.job_id == job_id)
+        )).scalars().first()
 
         return job_info
 
     @classmethod
-    def get_job_detail_by_info(cls, db: Session, job: JobModel):
+    async def get_job_detail_by_info(cls, db: AsyncSession, job: JobModel):
         """
         根据定时任务参数获取定时任务信息
         :param db: orm对象
         :param job: 定时任务参数对象
         :return: 定时任务信息对象
         """
-        job_info = db.query(SysJob) \
-            .filter(SysJob.job_name == job.job_name if job.job_name else True,
-                    SysJob.job_group == job.job_group if job.job_group else True,
-                    SysJob.invoke_target == job.invoke_target if job.invoke_target else True,
-                    SysJob.cron_expression == job.cron_expression if job.cron_expression else True) \
-            .first()
+        job_info = (await db.execute(
+            select(SysJob)
+                .where(SysJob.job_name == job.job_name if job.job_name else True,
+                       SysJob.job_group == job.job_group if job.job_group else True,
+                       SysJob.invoke_target == job.invoke_target if job.invoke_target else True,
+                       SysJob.cron_expression == job.cron_expression if job.cron_expression else True)
+        )).scalars().first()
 
         return job_info
 
     @classmethod
-    def get_job_list(cls, db: Session, query_object: JobPageQueryModel, is_page: bool = False):
+    async def get_job_list(cls, db: AsyncSession, query_object: JobPageQueryModel, is_page: bool = False):
         """
         根据查询参数获取定时任务列表信息
         :param db: orm对象
@@ -49,31 +52,32 @@ class JobDao:
         :param is_page: 是否开启分页
         :return: 定时任务列表信息对象
         """
-        query = db.query(SysJob) \
-            .filter(SysJob.job_name.like(f'%{query_object.job_name}%') if query_object.job_name else True,
-                    SysJob.job_group == query_object.job_group if query_object.job_group else True,
-                    SysJob.status == query_object.status if query_object.status else True
-                    ) \
+        query = select(SysJob) \
+            .where(SysJob.job_name.like(f'%{query_object.job_name}%') if query_object.job_name else True,
+                   SysJob.job_group == query_object.job_group if query_object.job_group else True,
+                   SysJob.status == query_object.status if query_object.status else True) \
             .distinct()
-        job_list = PageUtil.paginate(query, query_object.page_num, query_object.page_size, is_page)
+        job_list = await PageUtil.paginate(db, query, query_object.page_num, query_object.page_size, is_page)
 
         return job_list
 
     @classmethod
-    def get_job_list_for_scheduler(cls, db: Session):
+    async def get_job_list_for_scheduler(cls, db: AsyncSession):
         """
         获取定时任务列表信息
         :param db: orm对象
         :return: 定时任务列表信息对象
         """
-        job_list = db.query(SysJob) \
-            .filter(SysJob.status == 0) \
-            .distinct().all()
+        job_list = (await db.execute(
+            select(SysJob)
+                .where(SysJob.status == 0)
+                .distinct()
+        )).scalars().all()
 
         return job_list
 
     @classmethod
-    def add_job_dao(cls, db: Session, job: JobModel):
+    async def add_job_dao(cls, db: AsyncSession, job: JobModel):
         """
         新增定时任务数据库操作
         :param db: orm对象
@@ -82,30 +86,32 @@ class JobDao:
         """
         db_job = SysJob(**job.model_dump())
         db.add(db_job)
-        db.flush()
+        await db.flush()
 
         return db_job
 
     @classmethod
-    def edit_job_dao(cls, db: Session, job: dict):
+    async def edit_job_dao(cls, db: AsyncSession, job: dict):
         """
         编辑定时任务数据库操作
         :param db: orm对象
         :param job: 需要更新的定时任务字典
         :return:
         """
-        db.query(SysJob) \
-            .filter(SysJob.job_id == job.get('job_id')) \
-            .update(job)
+        await db.execute(
+            update(SysJob),
+            [job]
+        )
 
     @classmethod
-    def delete_job_dao(cls, db: Session, job: JobModel):
+    async def delete_job_dao(cls, db: AsyncSession, job: JobModel):
         """
         删除定时任务数据库操作
         :param db: orm对象
         :param job: 定时任务对象
         :return:
         """
-        db.query(SysJob) \
-            .filter(SysJob.job_id == job.job_id) \
-            .delete()
+        await db.execute(
+            delete(SysJob)
+                .where(SysJob.job_id.in_([job.job_id]))
+        )

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

@@ -1,3 +1,5 @@
+from sqlalchemy import select, delete
+from sqlalchemy.ext.asyncio import AsyncSession
 from sqlalchemy.orm import Session
 from module_admin.entity.do.job_do import SysJobLog
 from module_admin.entity.vo.job_vo import *
@@ -11,7 +13,7 @@ class JobLogDao:
     """
 
     @classmethod
-    def get_job_log_list(cls, db: Session, query_object: JobLogPageQueryModel, is_page: bool = False):
+    async def get_job_log_list(cls, db: AsyncSession, query_object: JobLogPageQueryModel, is_page: bool = False):
         """
         根据查询参数获取定时任务日志列表信息
         :param db: orm对象
@@ -19,17 +21,16 @@ class JobLogDao:
         :param is_page: 是否开启分页
         :return: 定时任务日志列表信息对象
         """
-        query = db.query(SysJobLog) \
-            .filter(SysJobLog.job_name.like(f'%{query_object.job_name}%') if query_object.job_name else True,
-                    SysJobLog.job_group == query_object.job_group if query_object.job_group else True,
-                    SysJobLog.status == query_object.status if query_object.status else True,
-                    SysJobLog.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
-                    ) \
+        query = select(SysJobLog) \
+            .where(SysJobLog.job_name.like(f'%{query_object.job_name}%') if query_object.job_name else True,
+                   SysJobLog.job_group == query_object.job_group if query_object.job_group else True,
+                   SysJobLog.status == query_object.status if query_object.status else True,
+                   SysJobLog.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) \
             .distinct()
-        job_log_list = PageUtil.paginate(query, query_object.page_num, query_object.page_size, is_page)
+        job_log_list = await PageUtil.paginate(db, query, query_object.page_num, query_object.page_size, is_page)
 
         return job_log_list
 
@@ -48,23 +49,25 @@ class JobLogDao:
         return db_job_log
 
     @classmethod
-    def delete_job_log_dao(cls, db: Session, job_log: JobLogModel):
+    async def delete_job_log_dao(cls, db: AsyncSession, job_log: JobLogModel):
         """
         删除定时任务日志数据库操作
         :param db: orm对象
         :param job_log: 定时任务日志对象
         :return:
         """
-        db.query(SysJobLog) \
-            .filter(SysJobLog.job_log_id == job_log.job_log_id) \
-            .delete()
+        await db.execute(
+            delete(SysJobLog)
+                .where(SysJobLog.job_log_id.in_([job_log.job_log_id]))
+        )
 
     @classmethod
-    def clear_job_log_dao(cls, db: Session):
+    async def clear_job_log_dao(cls, db: AsyncSession):
         """
         清除定时任务日志数据库操作
         :param db: orm对象
         :return:
         """
-        db.query(SysJobLog) \
-            .delete()
+        await db.execute(
+            delete(SysJobLog)
+        )

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

@@ -1,5 +1,5 @@
-from sqlalchemy import asc, desc
-from sqlalchemy.orm import Session
+from sqlalchemy import select, update, delete, asc, desc
+from sqlalchemy.ext.asyncio import AsyncSession
 from module_admin.entity.do.log_do import SysOperLog, SysLogininfor
 from module_admin.entity.vo.log_vo import *
 from utils.page_util import PageUtil
@@ -11,8 +11,9 @@ class OperationLogDao:
     """
     操作日志管理模块数据库操作层
     """
+
     @classmethod
-    def get_operation_log_list(cls, db: Session, query_object: OperLogPageQueryModel, is_page: bool = False):
+    async def get_operation_log_list(cls, db: AsyncSession, query_object: OperLogPageQueryModel, is_page: bool = False):
         """
         根据查询参数获取操作日志列表信息
         :param db: orm对象
@@ -23,26 +24,27 @@ class OperationLogDao:
         if query_object.is_asc == 'ascending':
             order_by_column = asc(getattr(SysOperLog, CamelCaseUtil.camel_to_snake(query_object.order_by_column), None))
         elif query_object.is_asc == 'descending':
-            order_by_column = desc(getattr(SysOperLog, CamelCaseUtil.camel_to_snake(query_object.order_by_column), None))
+            order_by_column = desc(
+                getattr(SysOperLog, CamelCaseUtil.camel_to_snake(query_object.order_by_column), None))
         else:
             order_by_column = desc(SysOperLog.oper_time)
-        query = db.query(SysOperLog) \
-            .filter(SysOperLog.title.like(f'%{query_object.title}%') if query_object.title else True,
-                    SysOperLog.oper_name.like(f'%{query_object.oper_name}%') if query_object.oper_name else True,
-                    SysOperLog.business_type == query_object.business_type if query_object.business_type else True,
-                    SysOperLog.status == query_object.status if query_object.status else True,
-                    SysOperLog.oper_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
-                    )\
-            .distinct().order_by(order_by_column)
-        operation_log_list = PageUtil.paginate(query, query_object.page_num, query_object.page_size, is_page)
+        query = select(SysOperLog) \
+            .where(SysOperLog.title.like(f'%{query_object.title}%') if query_object.title else True,
+                   SysOperLog.oper_name.like(f'%{query_object.oper_name}%') if query_object.oper_name else True,
+                   SysOperLog.business_type == query_object.business_type if query_object.business_type else True,
+                   SysOperLog.status == query_object.status if query_object.status else True,
+                   SysOperLog.oper_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) \
+            .distinct() \
+            .order_by(order_by_column)
+        operation_log_list = await PageUtil.paginate(db, query, query_object.page_num, query_object.page_size, is_page)
 
         return operation_log_list
 
     @classmethod
-    def add_operation_log_dao(cls, db: Session, operation_log: OperLogModel):
+    async def add_operation_log_dao(cls, db: AsyncSession, operation_log: OperLogModel):
         """
         新增操作日志数据库操作
         :param db: orm对象
@@ -51,31 +53,33 @@ class OperationLogDao:
         """
         db_operation_log = SysOperLog(**operation_log.model_dump())
         db.add(db_operation_log)
-        db.flush()
+        await db.flush()
 
         return db_operation_log
 
     @classmethod
-    def delete_operation_log_dao(cls, db: Session, operation_log: OperLogModel):
+    async def delete_operation_log_dao(cls, db: AsyncSession, operation_log: OperLogModel):
         """
         删除操作日志数据库操作
         :param db: orm对象
         :param operation_log: 操作日志对象
         :return:
         """
-        db.query(SysOperLog) \
-            .filter(SysOperLog.oper_id == operation_log.oper_id) \
-            .delete()
+        await db.execute(
+            delete(SysOperLog)
+                .where(SysOperLog.oper_id.in_([operation_log.oper_id]))
+        )
 
     @classmethod
-    def clear_operation_log_dao(cls, db: Session):
+    async def clear_operation_log_dao(cls, db: AsyncSession):
         """
         清除操作日志数据库操作
         :param db: orm对象
         :return:
         """
-        db.query(SysOperLog) \
-            .delete()
+        await db.execute(
+            delete(SysOperLog)
+        )
 
 
 class LoginLogDao:
@@ -84,7 +88,7 @@ class LoginLogDao:
     """
 
     @classmethod
-    def get_login_log_list(cls, db: Session, query_object: LoginLogPageQueryModel, is_page: bool = False):
+    async def get_login_log_list(cls, db: AsyncSession, query_object: LoginLogPageQueryModel, is_page: bool = False):
         """
         根据查询参数获取登录日志列表信息
         :param db: orm对象
@@ -93,27 +97,29 @@ class LoginLogDao:
         :return: 登录日志列表信息对象
         """
         if query_object.is_asc == 'ascending':
-            order_by_column = asc(getattr(SysLogininfor, CamelCaseUtil.camel_to_snake(query_object.order_by_column), None))
+            order_by_column = asc(
+                getattr(SysLogininfor, CamelCaseUtil.camel_to_snake(query_object.order_by_column), None))
         elif query_object.is_asc == 'descending':
-            order_by_column = desc(getattr(SysLogininfor, CamelCaseUtil.camel_to_snake(query_object.order_by_column), None))
+            order_by_column = desc(
+                getattr(SysLogininfor, CamelCaseUtil.camel_to_snake(query_object.order_by_column), None))
         else:
             order_by_column = desc(SysLogininfor.login_time)
-        query = db.query(SysLogininfor) \
-            .filter(SysLogininfor.ipaddr.like(f'%{query_object.ipaddr}%') if query_object.ipaddr else True,
-                    SysLogininfor.user_name.like(f'%{query_object.user_name}%') if query_object.user_name else True,
-                    SysLogininfor.status == query_object.status if query_object.status else True,
-                    SysLogininfor.login_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
-                    )\
-            .distinct().order_by(order_by_column)
-        login_log_list = PageUtil.paginate(query, query_object.page_num, query_object.page_size, is_page)
+        query = select(SysLogininfor) \
+            .where(SysLogininfor.ipaddr.like(f'%{query_object.ipaddr}%') if query_object.ipaddr else True,
+                   SysLogininfor.user_name.like(f'%{query_object.user_name}%') if query_object.user_name else True,
+                   SysLogininfor.status == query_object.status if query_object.status else True,
+                   SysLogininfor.login_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) \
+            .distinct() \
+            .order_by(order_by_column)
+        login_log_list = await PageUtil.paginate(db, query, query_object.page_num, query_object.page_size, is_page)
 
         return login_log_list
 
     @classmethod
-    def add_login_log_dao(cls, db: Session, login_log: LogininforModel):
+    async def add_login_log_dao(cls, db: AsyncSession, login_log: LogininforModel):
         """
         新增登录日志数据库操作
         :param db: orm对象
@@ -122,28 +128,30 @@ class LoginLogDao:
         """
         db_login_log = SysLogininfor(**login_log.model_dump())
         db.add(db_login_log)
-        db.flush()
+        await db.flush()
 
         return db_login_log
 
     @classmethod
-    def delete_login_log_dao(cls, db: Session, login_log: LogininforModel):
+    async def delete_login_log_dao(cls, db: AsyncSession, login_log: LogininforModel):
         """
         删除登录日志数据库操作
         :param db: orm对象
         :param login_log: 登录日志对象
         :return:
         """
-        db.query(SysLogininfor) \
-            .filter(SysLogininfor.info_id == login_log.info_id) \
-            .delete()
+        await db.execute(
+            delete(SysLogininfor)
+                .where(SysLogininfor.info_id.in_([login_log.info_id]))
+        )
 
     @classmethod
-    def clear_login_log_dao(cls, db: Session):
+    async def clear_login_log_dao(cls, db: AsyncSession):
         """
         清除登录日志数据库操作
         :param db: orm对象
         :return:
         """
-        db.query(SysLogininfor) \
-            .delete()
+        await db.execute(
+            delete(SysLogininfor)
+        )

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

@@ -1,20 +1,21 @@
-from sqlalchemy.orm import Session
-from sqlalchemy import and_
+from sqlalchemy import select, and_
+from sqlalchemy.ext.asyncio import AsyncSession
 from module_admin.entity.do.user_do import SysUser
 from module_admin.entity.do.dept_do import SysDept
 
 
-def login_by_account(db: Session, user_name: str):
+async def login_by_account(db: AsyncSession, user_name: str):
     """
     根据用户名查询用户信息
     :param db: orm对象
     :param user_name: 用户名
     :return: 用户对象
     """
-    user = db.query(SysUser, SysDept)\
-        .filter(SysUser.user_name == user_name, SysUser.del_flag == '0') \
-        .outerjoin(SysDept, and_(SysUser.dept_id == SysDept.dept_id, SysDept.status == 0, SysDept.del_flag == 0)) \
-        .distinct() \
-        .first()
+    user = (await db.execute(
+        select(SysUser, SysDept)
+            .where(SysUser.user_name == user_name, SysUser.del_flag == '0')
+            .join(SysDept, and_(SysUser.dept_id == SysDept.dept_id, SysDept.status == 0, SysDept.del_flag == 0), isouter=True)
+            .distinct()
+    )).first()
 
     return user

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

@@ -1,5 +1,5 @@
-from sqlalchemy import and_
-from sqlalchemy.orm import Session
+from sqlalchemy import select, update, delete, and_
+from sqlalchemy.ext.asyncio import AsyncSession
 from module_admin.entity.do.menu_do import SysMenu
 from module_admin.entity.do.user_do import SysUser, SysUserRole
 from module_admin.entity.do.role_do import SysRole, SysRoleMenu
@@ -12,37 +12,39 @@ class MenuDao:
     """
 
     @classmethod
-    def get_menu_detail_by_id(cls, db: Session, menu_id: int):
+    async def get_menu_detail_by_id(cls, db: AsyncSession, menu_id: int):
         """
         根据菜单id获取菜单详细信息
         :param db: orm对象
         :param menu_id: 菜单id
         :return: 菜单信息对象
         """
-        menu_info = db.query(SysMenu) \
-            .filter(SysMenu.menu_id == menu_id) \
-            .first()
+        menu_info = (await db.execute(
+            select(SysMenu)
+                .where(SysMenu.menu_id == menu_id)
+        )).scalars().first()
 
         return menu_info
 
     @classmethod
-    def get_menu_detail_by_info(cls, db: Session, menu: MenuModel):
+    async def get_menu_detail_by_info(cls, db: AsyncSession, menu: MenuModel):
         """
         根据菜单参数获取菜单信息
         :param db: orm对象
         :param menu: 菜单参数对象
         :return: 菜单信息对象
         """
-        menu_info = db.query(SysMenu) \
-            .filter(SysMenu.parent_id == menu.parent_id if menu.parent_id else True,
-                    SysMenu.menu_name == menu.menu_name if menu.menu_name else True,
-                    SysMenu.menu_type == menu.menu_type if menu.menu_type else True) \
-            .first()
+        menu_info = (await db.execute(
+            select(SysMenu)
+                .where(SysMenu.parent_id == menu.parent_id if menu.parent_id else True,
+                       SysMenu.menu_name == menu.menu_name if menu.menu_name else True,
+                       SysMenu.menu_type == menu.menu_type if menu.menu_type else True)
+        )).scalars().first()
 
         return menu_info
 
     @classmethod
-    def get_menu_list_for_tree(cls, db: Session, user_id: int, role: list):
+    async def get_menu_list_for_tree(cls, db: AsyncSession, user_id: int, role: list):
         """
         根据角色信息获取所有在用菜单列表信息
         :param db: orm对象
@@ -52,25 +54,31 @@ class MenuDao:
         """
         role_id_list = [item.role_id for item in role]
         if 1 in role_id_list:
-            menu_query_all = db.query(SysMenu) \
-                .filter(SysMenu.status == 0) \
-                .order_by(SysMenu.order_num) \
-                .distinct().all()
+            menu_query_all = (await db.execute(
+                select(SysMenu)
+                    .where(SysMenu.status == 0)
+                    .order_by(SysMenu.order_num)
+                    .distinct()
+            )).scalars().all()
         else:
-            menu_query_all = db.query(SysMenu).select_from(SysUser) \
-                .filter(SysUser.status == 0, SysUser.del_flag == 0, SysUser.user_id == user_id) \
-                .outerjoin(SysUserRole, SysUser.user_id == SysUserRole.user_id) \
-                .outerjoin(SysRole,
-                           and_(SysUserRole.role_id == SysRole.role_id, SysRole.status == 0, SysRole.del_flag == 0)) \
-                .outerjoin(SysRoleMenu, SysRole.role_id == SysRoleMenu.role_id) \
-                .join(SysMenu, and_(SysRoleMenu.menu_id == SysMenu.menu_id, SysMenu.status == 0,)) \
-                .order_by(SysMenu.order_num) \
-                .distinct().all()
+            menu_query_all = (await db.execute(
+                select(SysMenu)
+                    .select_from(SysUser)
+                    .where(SysUser.status == 0, SysUser.del_flag == 0, SysUser.user_id == user_id)
+                    .join(SysUserRole, SysUser.user_id == SysUserRole.user_id, isouter=True)
+                    .join(SysRole,
+                          and_(SysUserRole.role_id == SysRole.role_id, SysRole.status == 0, SysRole.del_flag == 0),
+                          isouter=True)
+                    .join(SysRoleMenu, SysRole.role_id == SysRoleMenu.role_id, isouter=True)
+                    .join(SysMenu, and_(SysRoleMenu.menu_id == SysMenu.menu_id, SysMenu.status == 0))
+                    .order_by(SysMenu.order_num)
+                    .distinct()
+            )).scalars().all()
 
         return menu_query_all
 
     @classmethod
-    def get_menu_list(cls, db: Session, page_object: MenuQueryModel, user_id: int, role: list):
+    async def get_menu_list(cls, db: AsyncSession, page_object: MenuQueryModel, user_id: int, role: list):
         """
         根据查询参数获取菜单列表信息
         :param db: orm对象
@@ -81,30 +89,36 @@ class MenuDao:
         """
         role_id_list = [item.role_id for item in role]
         if 1 in role_id_list:
-            menu_query_all = db.query(SysMenu) \
-                .filter(SysMenu.status == page_object.status if page_object.status else True,
-                        SysMenu.menu_name.like(
-                            f'%{page_object.menu_name}%') if page_object.menu_name else True) \
-                .order_by(SysMenu.order_num) \
-                .distinct().all()
+            menu_query_all = (await db.execute(
+                select(SysMenu)
+                    .where(SysMenu.status == page_object.status if page_object.status else True,
+                           SysMenu.menu_name.like(
+                               f'%{page_object.menu_name}%') if page_object.menu_name else True)
+                    .order_by(SysMenu.order_num)
+                    .distinct()
+            )).scalars().all()
         else:
-            menu_query_all = db.query(SysMenu).select_from(SysUser) \
-                .filter(SysUser.status == 0, SysUser.del_flag == 0, SysUser.user_id == user_id) \
-                .outerjoin(SysUserRole, SysUser.user_id == SysUserRole.user_id) \
-                .outerjoin(SysRole,
-                           and_(SysUserRole.role_id == SysRole.role_id, SysRole.status == 0, SysRole.del_flag == 0)) \
-                .outerjoin(SysRoleMenu, SysRole.role_id == SysRoleMenu.role_id) \
-                .join(SysMenu, and_(SysRoleMenu.menu_id == SysMenu.menu_id,
-                                    SysMenu.status == page_object.status if page_object.status else True,
-                                    SysMenu.menu_name.like(
-                                        f'%{page_object.menu_name}%') if page_object.menu_name else True)) \
-                .order_by(SysMenu.order_num) \
-                .distinct().all()
+            menu_query_all = (await db.execute(
+                select(SysMenu)
+                    .select_from(SysUser)
+                    .where(SysUser.status == 0, SysUser.del_flag == 0, SysUser.user_id == user_id)
+                    .join(SysUserRole, SysUser.user_id == SysUserRole.user_id, isouter=True)
+                    .join(SysRole,
+                          and_(SysUserRole.role_id == SysRole.role_id, SysRole.status == 0, SysRole.del_flag == 0),
+                          isouter=True)
+                    .join(SysRoleMenu, SysRole.role_id == SysRoleMenu.role_id, isouter=True)
+                    .join(SysMenu, and_(SysRoleMenu.menu_id == SysMenu.menu_id,
+                                        SysMenu.status == page_object.status if page_object.status else True,
+                                        SysMenu.menu_name.like(
+                                            f'%{page_object.menu_name}%') if page_object.menu_name else True))
+                    .order_by(SysMenu.order_num)
+                    .distinct()
+            )).scalars().all()
 
         return menu_query_all
 
     @classmethod
-    def add_menu_dao(cls, db: Session, menu: MenuModel):
+    async def add_menu_dao(cls, db: AsyncSession, menu: MenuModel):
         """
         新增菜单数据库操作
         :param db: orm对象
@@ -113,30 +127,32 @@ class MenuDao:
         """
         db_menu = SysMenu(**menu.model_dump())
         db.add(db_menu)
-        db.flush()
+        await db.flush()
 
         return db_menu
 
     @classmethod
-    def edit_menu_dao(cls, db: Session, menu: dict):
+    async def edit_menu_dao(cls, db: AsyncSession, menu: dict):
         """
         编辑菜单数据库操作
         :param db: orm对象
         :param menu: 需要更新的菜单字典
         :return:
         """
-        db.query(SysMenu) \
-            .filter(SysMenu.menu_id == menu.get('menu_id')) \
-            .update(menu)
+        await db.execute(
+            update(SysMenu),
+            [menu]
+        )
 
     @classmethod
-    def delete_menu_dao(cls, db: Session, menu: MenuModel):
+    async def delete_menu_dao(cls, db: AsyncSession, menu: MenuModel):
         """
         删除菜单数据库操作
         :param db: orm对象
         :param menu: 菜单对象
         :return:
         """
-        db.query(SysMenu) \
-            .filter(SysMenu.menu_id == menu.menu_id) \
-            .delete()
+        await db.execute(
+            delete(SysMenu)
+                .where(SysMenu.menu_id.in_([menu.menu_id]))
+        )

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

@@ -1,4 +1,5 @@
-from sqlalchemy.orm import Session
+from sqlalchemy import select, update, delete
+from sqlalchemy.ext.asyncio import AsyncSession
 from module_admin.entity.do.notice_do import SysNotice
 from module_admin.entity.vo.notice_vo import *
 from utils.page_util import PageUtil
@@ -11,37 +12,39 @@ class NoticeDao:
     """
 
     @classmethod
-    def get_notice_detail_by_id(cls, db: Session, notice_id: int):
+    async def get_notice_detail_by_id(cls, db: AsyncSession, notice_id: int):
         """
         根据通知公告id获取通知公告详细信息
         :param db: orm对象
         :param notice_id: 通知公告id
         :return: 通知公告信息对象
         """
-        notice_info = db.query(SysNotice) \
-            .filter(SysNotice.notice_id == notice_id) \
-            .first()
+        notice_info = (await db.execute(
+            select(SysNotice)
+                .where(SysNotice.notice_id == notice_id)
+        )).scalars().first()
 
         return notice_info
 
     @classmethod
-    def get_notice_detail_by_info(cls, db: Session, notice: NoticeModel):
+    async def get_notice_detail_by_info(cls, db: AsyncSession, notice: NoticeModel):
         """
         根据通知公告参数获取通知公告信息
         :param db: orm对象
         :param notice: 通知公告参数对象
         :return: 通知公告信息对象
         """
-        notice_info = db.query(SysNotice) \
-            .filter(SysNotice.notice_title == notice.notice_title if notice.notice_title else True,
-                    SysNotice.notice_type == notice.notice_type if notice.notice_type else True,
-                    SysNotice.notice_content == notice.notice_content if notice.notice_content else True) \
-            .first()
+        notice_info = (await db.execute(
+            select(SysNotice)
+                .where(SysNotice.notice_title == notice.notice_title if notice.notice_title else True,
+                       SysNotice.notice_type == notice.notice_type if notice.notice_type else True,
+                       SysNotice.notice_content == notice.notice_content if notice.notice_content else True)
+        )).scalars().first()
 
         return notice_info
 
     @classmethod
-    def get_notice_list(cls, db: Session, query_object: NoticePageQueryModel, is_page: bool = False):
+    async def get_notice_list(cls, db: AsyncSession, query_object: NoticePageQueryModel, is_page: bool = False):
         """
         根据查询参数获取通知公告列表信息
         :param db: orm对象
@@ -49,22 +52,21 @@ class NoticeDao:
         :param is_page: 是否开启分页
         :return: 通知公告列表信息对象
         """
-        query = db.query(SysNotice) \
-            .filter(SysNotice.notice_title.like(f'%{query_object.notice_title}%') if query_object.notice_title else True,
-                    SysNotice.create_by.like(f'%{query_object.create_by}%') if query_object.create_by else True,
-                    SysNotice.notice_type == query_object.notice_type if query_object.notice_type else True,
-                    SysNotice.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
-                    ) \
+        query = select(SysNotice) \
+            .where(SysNotice.notice_title.like(f'%{query_object.notice_title}%') if query_object.notice_title else True,
+                   SysNotice.create_by.like(f'%{query_object.create_by}%') if query_object.create_by else True,
+                   SysNotice.notice_type == query_object.notice_type if query_object.notice_type else True,
+                   SysNotice.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) \
             .distinct()
-        notice_list = PageUtil.paginate(query, query_object.page_num, query_object.page_size, is_page)
+        notice_list = await PageUtil.paginate(db, query, query_object.page_num, query_object.page_size, is_page)
 
         return notice_list
 
     @classmethod
-    def add_notice_dao(cls, db: Session, notice: NoticeModel):
+    async def add_notice_dao(cls, db: AsyncSession, notice: NoticeModel):
         """
         新增通知公告数据库操作
         :param db: orm对象
@@ -73,30 +75,32 @@ class NoticeDao:
         """
         db_notice = SysNotice(**notice.model_dump())
         db.add(db_notice)
-        db.flush()
+        await db.flush()
 
         return db_notice
 
     @classmethod
-    def edit_notice_dao(cls, db: Session, notice: dict):
+    async def edit_notice_dao(cls, db: AsyncSession, notice: dict):
         """
         编辑通知公告数据库操作
         :param db: orm对象
         :param notice: 需要更新的通知公告字典
         :return:
         """
-        db.query(SysNotice) \
-            .filter(SysNotice.notice_id == notice.get('notice_id')) \
-            .update(notice)
+        await db.execute(
+            update(SysNotice),
+            [notice]
+        )
 
     @classmethod
-    def delete_notice_dao(cls, db: Session, notice: NoticeModel):
+    async def delete_notice_dao(cls, db: AsyncSession, notice: NoticeModel):
         """
         删除通知公告数据库操作
         :param db: orm对象
         :param notice: 通知公告对象
         :return:
         """
-        db.query(SysNotice) \
-            .filter(SysNotice.notice_id == notice.notice_id) \
-            .delete()
+        await db.execute(
+            delete(SysNotice)
+                .where(SysNotice.notice_id.in_([notice.notice_id]))
+        )

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

@@ -1,4 +1,5 @@
-from sqlalchemy.orm import Session
+from sqlalchemy import select, update, delete
+from sqlalchemy.ext.asyncio import AsyncSession
 from module_admin.entity.do.post_do import SysPost
 from module_admin.entity.vo.post_vo import *
 from utils.page_util import PageUtil
@@ -10,52 +11,55 @@ class PostDao:
     """
 
     @classmethod
-    def get_post_by_id(cls, db: Session, post_id: int):
+    async def get_post_by_id(cls, db: AsyncSession, post_id: int):
         """
         根据岗位id获取在用岗位详细信息
         :param db: orm对象
         :param post_id: 岗位id
         :return: 在用岗位信息对象
         """
-        post_info = db.query(SysPost) \
-            .filter(SysPost.post_id == post_id,
-                    SysPost.status == 0) \
-            .first()
+        post_info = (await db.execute(
+            select(SysPost)
+                .where(SysPost.post_id == post_id,
+                       SysPost.status == 0)
+        )).scalars().first()
 
         return post_info
 
     @classmethod
-    def get_post_detail_by_id(cls, db: Session, post_id: int):
+    async def get_post_detail_by_id(cls, db: AsyncSession, post_id: int):
         """
         根据岗位id获取岗位详细信息
         :param db: orm对象
         :param post_id: 岗位id
         :return: 岗位信息对象
         """
-        post_info = db.query(SysPost) \
-            .filter(SysPost.post_id == post_id) \
-            .first()
+        post_info = (await db.execute(
+            select(SysPost)
+                .where(SysPost.post_id == post_id)
+        )).scalars().first()
 
         return post_info
 
     @classmethod
-    def get_post_detail_by_info(cls, db: Session, post: PostModel):
+    async def get_post_detail_by_info(cls, db: AsyncSession, post: PostModel):
         """
         根据岗位参数获取岗位信息
         :param db: orm对象
         :param post: 岗位参数对象
         :return: 岗位信息对象
         """
-        post_info = db.query(SysPost) \
-            .filter(SysPost.post_name == post.post_name if post.post_name else True,
-                    SysPost.post_code == post.post_code if post.post_code else True,
-                    SysPost.post_sort == post.post_sort if post.post_sort else True) \
-            .first()
+        post_info = (await db.execute(
+            select(SysPost)
+                .where(SysPost.post_name == post.post_name if post.post_name else True,
+                       SysPost.post_code == post.post_code if post.post_code else True,
+                       SysPost.post_sort == post.post_sort if post.post_sort else True)
+        )).scalars().first()
 
         return post_info
 
     @classmethod
-    def get_post_list(cls, db: Session, query_object: PostPageQueryModel, is_page: bool = False):
+    async def get_post_list(cls, db: AsyncSession, query_object: PostPageQueryModel, is_page: bool = False):
         """
         根据查询参数获取岗位列表信息
         :param db: orm对象
@@ -63,19 +67,18 @@ class PostDao:
         :param is_page: 是否开启分页
         :return: 岗位列表信息对象
         """
-        query = db.query(SysPost) \
-            .filter(SysPost.post_code.like(f'%{query_object.post_code}%') if query_object.post_code else True,
-                    SysPost.post_name.like(f'%{query_object.post_name}%') if query_object.post_name else True,
-                    SysPost.status == query_object.status if query_object.status else True
-                    ) \
+        query = select(SysPost) \
+            .where(SysPost.post_code.like(f'%{query_object.post_code}%') if query_object.post_code else True,
+                   SysPost.post_name.like(f'%{query_object.post_name}%') if query_object.post_name else True,
+                   SysPost.status == query_object.status if query_object.status else True) \
             .order_by(SysPost.post_sort) \
             .distinct()
-        post_list = PageUtil.paginate(query, query_object.page_num, query_object.page_size, is_page)
+        post_list = await PageUtil.paginate(db, query, query_object.page_num, query_object.page_size, is_page)
 
         return post_list
 
     @classmethod
-    def add_post_dao(cls, db: Session, post: PostModel):
+    async def add_post_dao(cls, db: AsyncSession, post: PostModel):
         """
         新增岗位数据库操作
         :param db: orm对象
@@ -84,30 +87,32 @@ class PostDao:
         """
         db_post = SysPost(**post.model_dump())
         db.add(db_post)
-        db.flush()
+        await db.flush()
 
         return db_post
 
     @classmethod
-    def edit_post_dao(cls, db: Session, post: dict):
+    async def edit_post_dao(cls, db: AsyncSession, post: dict):
         """
         编辑岗位数据库操作
         :param db: orm对象
         :param post: 需要更新的岗位字典
         :return:
         """
-        db.query(SysPost) \
-            .filter(SysPost.post_id == post.get('post_id')) \
-            .update(post)
+        await db.execute(
+            update(SysPost),
+            [post]
+        )
 
     @classmethod
-    def delete_post_dao(cls, db: Session, post: PostModel):
+    async def delete_post_dao(cls, db: AsyncSession, post: PostModel):
         """
         删除岗位数据库操作
         :param db: orm对象
         :param post: 岗位对象
         :return:
         """
-        db.query(SysPost) \
-            .filter(SysPost.post_id == post.post_id) \
-            .delete()
+        await db.execute(
+            delete(SysPost)
+                .where(SysPost.post_id.in_([post.post_id]))
+        )

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

@@ -1,5 +1,5 @@
-from sqlalchemy import desc, func
-from sqlalchemy.orm import Session
+from sqlalchemy import select, update, delete, desc, func
+from sqlalchemy.ext.asyncio import AsyncSession
 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 *
@@ -13,80 +13,90 @@ class RoleDao:
     """
 
     @classmethod
-    def get_role_by_name(cls, db: Session, role_name: str):
+    async def get_role_by_name(cls, db: AsyncSession, role_name: str):
         """
         根据角色名获取在用角色信息
         :param db: orm对象
         :param role_name: 角色名
         :return: 当前角色名的角色信息对象
         """
-        query_role_info = db.query(SysRole) \
-            .filter(SysRole.status == 0, SysRole.del_flag == 0, SysRole.role_name == role_name) \
-            .order_by(desc(SysRole.create_time)).distinct().first()
+        query_role_info = (await db.execute(
+            select(SysRole)
+                .where(SysRole.status == 0, SysRole.del_flag == 0, SysRole.role_name == role_name)
+                .order_by(desc(SysRole.create_time))
+                .distinct()
+        )).scalars().first()
 
         return query_role_info
 
     @classmethod
-    def get_role_by_info(cls, db: Session, role: RoleModel):
+    async def get_role_by_info(cls, db: AsyncSession, role: RoleModel):
         """
         根据角色参数获取角色信息
         :param db: orm对象
         :param role: 角色参数
         :return: 当前角色参数的角色信息对象
         """
-        query_role_info = db.query(SysRole) \
-            .filter(SysRole.del_flag == 0,
-                    SysRole.role_name == role.role_name if role.role_name else True,
-                    SysRole.role_key == role.role_key if role.role_key else True) \
-            .order_by(desc(SysRole.create_time)).distinct().first()
+        query_role_info = (await db.execute(
+            select(SysRole)
+                .where(SysRole.del_flag == 0,
+                       SysRole.role_name == role.role_name if role.role_name else True,
+                       SysRole.role_key == role.role_key if role.role_key else True)
+                .order_by(desc(SysRole.create_time))
+                .distinct()
+        )).scalars().first()
 
         return query_role_info
 
     @classmethod
-    def get_role_by_id(cls, db: Session, role_id: int):
+    async def get_role_by_id(cls, db: AsyncSession, role_id: int):
         """
         根据角色id获取在用角色信息
         :param db: orm对象
         :param role_id: 角色id
         :return: 当前角色id的角色信息对象
         """
-        role_info = db.query(SysRole) \
-            .filter(SysRole.role_id == role_id,
-                    SysRole.status == 0,
-                    SysRole.del_flag == 0) \
-            .first()
+        role_info = (await db.execute(
+            select(SysRole)
+                .where(SysRole.role_id == role_id,
+                       SysRole.status == 0,
+                       SysRole.del_flag == 0)
+        )).scalars().first()
 
         return role_info
 
     @classmethod
-    def get_role_detail_by_id(cls, db: Session, role_id: int):
+    async def get_role_detail_by_id(cls, db: AsyncSession, role_id: int):
         """
         根据role_id获取角色详细信息
         :param db: orm对象
         :param role_id: 角色id
         :return: 当前role_id的角色信息对象
         """
-        query_role_info = db.query(SysRole) \
-            .filter(SysRole.del_flag == 0, SysRole.role_id == role_id) \
-            .distinct().first()
+        query_role_info = (await db.execute(
+            select(SysRole)
+                .where(SysRole.del_flag == 0, SysRole.role_id == role_id)
+                .distinct()
+        )).scalars().first()
 
         return query_role_info
 
     @classmethod
-    def get_role_select_option_dao(cls, db: Session):
+    async def get_role_select_option_dao(cls, db: AsyncSession):
         """
         获取编辑页面对应的在用角色列表信息
         :param db: orm对象
         :return: 角色列表信息
         """
-        role_info = db.query(SysRole) \
-            .filter(SysRole.role_id != 1, SysRole.status == 0, SysRole.del_flag == 0) \
-            .all()
+        role_info = (await db.execute(
+            select(SysRole)
+                .where(SysRole.role_id != 1, SysRole.status == 0, SysRole.del_flag == 0)
+        )).scalars().all()
 
         return role_info
 
     @classmethod
-    def get_role_list(cls, db: Session, query_object: RolePageQueryModel, is_page: bool = False):
+    async def get_role_list(cls, db: AsyncSession, query_object: RolePageQueryModel, is_page: bool = False):
         """
         根据查询参数获取角色列表信息
         :param db: orm对象
@@ -94,24 +104,23 @@ class RoleDao:
         :param is_page: 是否开启分页
         :return: 角色列表信息对象
         """
-        query = db.query(SysRole) \
-            .filter(SysRole.del_flag == 0,
-                    SysRole.role_name.like(f'%{query_object.role_name}%') if query_object.role_name else True,
-                    SysRole.role_key.like(f'%{query_object.role_key}%') if query_object.role_key else True,
-                    SysRole.status == query_object.status if query_object.status else True,
-                    SysRole.create_time.between(
-                        datetime.combine(datetime.strptime(query_object.begin_time, '%Y-%m-%d'), time(00, 00, 00)),
-                        datetime.combine(datetime.strptime(query_object.end_time, '%Y-%m-%d'), time(23, 59, 59)))
-                    if query_object.begin_time and query_object.end_time else True
-                    ) \
+        query = select(SysRole) \
+            .where(SysRole.del_flag == 0,
+                   SysRole.role_name.like(f'%{query_object.role_name}%') if query_object.role_name else True,
+                   SysRole.role_key.like(f'%{query_object.role_key}%') if query_object.role_key else True,
+                   SysRole.status == query_object.status if query_object.status else True,
+                   SysRole.create_time.between(
+                       datetime.combine(datetime.strptime(query_object.begin_time, '%Y-%m-%d'), time(00, 00, 00)),
+                       datetime.combine(datetime.strptime(query_object.end_time, '%Y-%m-%d'), time(23, 59, 59)))
+                   if query_object.begin_time and query_object.end_time else True) \
             .order_by(SysRole.role_sort) \
             .distinct()
-        role_list = PageUtil.paginate(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
 
     @classmethod
-    def add_role_dao(cls, db: Session, role: RoleModel):
+    async def add_role_dao(cls, db: AsyncSession, role: RoleModel):
         """
         新增角色数据库操作
         :param db: orm对象
@@ -120,50 +129,55 @@ class RoleDao:
         """
         db_role = SysRole(**role.model_dump(exclude={'admin'}))
         db.add(db_role)
-        db.flush()
+        await db.flush()
 
         return db_role
 
     @classmethod
-    def edit_role_dao(cls, db: Session, role: dict):
+    async def edit_role_dao(cls, db: AsyncSession, role: dict):
         """
         编辑角色数据库操作
         :param db: orm对象
         :param role: 需要更新的角色字典
         :return:
         """
-        db.query(SysRole) \
-            .filter(SysRole.role_id == role.get('role_id')) \
-            .update(role)
+        await db.execute(
+            update(SysRole),
+            [role]
+        )
 
     @classmethod
-    def delete_role_dao(cls, db: Session, role: RoleModel):
+    async def delete_role_dao(cls, db: AsyncSession, role: RoleModel):
         """
         删除角色数据库操作
         :param db: orm对象
         :param role: 角色对象
         :return:
         """
-        db.query(SysRole) \
-            .filter(SysRole.role_id == role.role_id) \
-            .update({SysRole.del_flag: '2', SysRole.update_by: role.update_by, SysRole.update_time: role.update_time})
+        await db.execute(
+            update(SysRole)
+                .where(SysRole.role_id == role.role_id)
+                .values(del_flag='2', update_by=role.update_by, update_time=role.update_time)
+        )
 
     @classmethod
-    def get_role_menu_dao(cls, db: Session, role_id: int):
+    async def get_role_menu_dao(cls, db: AsyncSession, role_id: int):
         """
         根据角色id获取角色菜单关联列表信息
         :param db: orm对象
         :param role_id: 角色id
         :return: 角色菜单关联列表信息
         """
-        role_menu_query_all = db.query(SysRoleMenu) \
-            .filter(SysRoleMenu.role_id == role_id) \
-            .distinct().all()
+        role_menu_query_all = (await db.execute(
+            select(SysRoleMenu)
+                .where(SysRoleMenu.role_id == role_id)
+                .distinct()
+        )).scalars().all()
 
         return role_menu_query_all
 
     @classmethod
-    def add_role_menu_dao(cls, db: Session, role_menu: RoleMenuModel):
+    async def add_role_menu_dao(cls, db: AsyncSession, role_menu: RoleMenuModel):
         """
         新增角色菜单关联信息数据库操作
         :param db: orm对象
@@ -174,35 +188,37 @@ class RoleDao:
         db.add(db_role_menu)
 
     @classmethod
-    def delete_role_menu_dao(cls, db: Session, role_menu: RoleMenuModel):
+    async def delete_role_menu_dao(cls, db: AsyncSession, role_menu: RoleMenuModel):
         """
         删除角色菜单关联信息数据库操作
         :param db: orm对象
         :param role_menu: 角色菜单关联对象
         :return:
         """
-        db.query(SysRoleMenu) \
-            .filter(SysRoleMenu.role_id == role_menu.role_id) \
-            .delete()
+        await db.execute(
+            delete(SysRoleMenu)
+                .where(SysRoleMenu.role_id.in_([role_menu.role_id]))
+        )
 
     @classmethod
-    def get_role_dept_dao(cls, db: Session, role_id: int):
+    async def get_role_dept_dao(cls, db: AsyncSession, role_id: int):
         """
         根据角色id获取角色部门关联列表信息
         :param db: orm对象
         :param role_id: 角色id
         :return: 角色部门关联列表信息
         """
-        role_dept_query_all = db.query(SysRoleDept) \
-            .filter(SysRoleDept.role_id == role_id,
-                    ~db.query(SysDept).filter(func.find_in_set(SysRoleDept.dept_id, SysDept.ancestors)).exists()
-                    ) \
-            .distinct().all()
+        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()
+        )).scalars().all()
 
         return role_dept_query_all
 
     @classmethod
-    def add_role_dept_dao(cls, db: Session, role_dept: RoleDeptModel):
+    async def add_role_dept_dao(cls, db: AsyncSession, role_dept: RoleDeptModel):
         """
         新增角色部门关联信息数据库操作
         :param db: orm对象
@@ -213,13 +229,14 @@ class RoleDao:
         db.add(db_role_dept)
 
     @classmethod
-    def delete_role_dept_dao(cls, db: Session, role_dept: RoleDeptModel):
+    async def delete_role_dept_dao(cls, db: AsyncSession, role_dept: RoleDeptModel):
         """
         删除角色部门关联信息数据库操作
         :param db: orm对象
         :param role_dept: 角色部门关联对象
         :return:
         """
-        db.query(SysRoleDept) \
-            .filter(SysRoleDept.role_id == role_dept.role_id) \
-            .delete()
+        await db.execute(
+            delete(SysRoleDept)
+                .where(SysRoleDept.role_id.in_([role_dept.role_id]))
+        )

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

@@ -1,5 +1,5 @@
-from sqlalchemy import and_, or_, desc, func
-from sqlalchemy.orm import Session
+from sqlalchemy import select, update, delete, and_, or_, desc, func
+from sqlalchemy.ext.asyncio import AsyncSession
 from module_admin.entity.do.user_do import SysUser, SysUserRole, SysUserPost
 from module_admin.entity.do.role_do import SysRole, SysRoleDept, SysRoleMenu
 from module_admin.entity.do.dept_do import SysDept
@@ -16,73 +16,96 @@ class UserDao:
     """
 
     @classmethod
-    def get_user_by_name(cls, db: Session, user_name: str):
+    async def get_user_by_name(cls, db: AsyncSession, user_name: str):
         """
         根据用户名获取用户信息
         :param db: orm对象
         :param user_name: 用户名
         :return: 当前用户名的用户信息对象
         """
-        query_user_info = db.query(SysUser) \
-            .filter(SysUser.status == 0, SysUser.del_flag == 0, SysUser.user_name == user_name) \
-            .order_by(desc(SysUser.create_time)).distinct().first()
+        query_user_info = (await db.execute(
+            select(SysUser)
+                .where(SysUser.status == 0, SysUser.del_flag == 0, SysUser.user_name == user_name)
+                .order_by(desc(SysUser.create_time))
+                .distinct()
+        )).scalars().first()
 
         return query_user_info
 
     @classmethod
-    def get_user_by_info(cls, db: Session, user: UserModel):
+    async def get_user_by_info(cls, db: AsyncSession, user: UserModel):
         """
         根据用户参数获取用户信息
         :param db: orm对象
         :param user: 用户参数
         :return: 当前用户参数的用户信息对象
         """
-        query_user_info = db.query(SysUser) \
-            .filter(SysUser.del_flag == 0,
-                    SysUser.user_name == user.user_name) \
-            .order_by(desc(SysUser.create_time)).distinct().first()
+        query_user_info = (await db.execute(
+            select(SysUser)
+                .where(SysUser.del_flag == 0, SysUser.user_name == user.user_name)
+                .order_by(desc(SysUser.create_time))
+                .distinct()
+        )).scalars().first()
 
         return query_user_info
 
     @classmethod
-    def get_user_by_id(cls, db: Session, user_id: int):
+    async def get_user_by_id(cls, db: AsyncSession, user_id: int):
         """
         根据user_id获取用户信息
         :param db: orm对象
         :param user_id: 用户id
         :return: 当前user_id的用户信息对象
         """
-        query_user_basic_info = db.query(SysUser) \
-            .filter(SysUser.status == 0, SysUser.del_flag == 0, SysUser.user_id == user_id) \
-            .distinct().first()
-        query_user_dept_info = db.query(SysDept).select_from(SysUser) \
-            .filter(SysUser.status == 0, SysUser.del_flag == 0, SysUser.user_id == user_id) \
-            .join(SysDept, and_(SysUser.dept_id == SysDept.dept_id, SysDept.status == 0, SysDept.del_flag == 0)) \
-            .distinct().first()
-        query_user_role_info = db.query(SysRole).select_from(SysUser) \
-            .filter(SysUser.status == 0, SysUser.del_flag == 0, SysUser.user_id == user_id) \
-            .outerjoin(SysUserRole, SysUser.user_id == SysUserRole.user_id) \
-            .join(SysRole, and_(SysUserRole.role_id == SysRole.role_id, SysRole.status == 0, SysRole.del_flag == 0)) \
-            .distinct().all()
-        query_user_post_info = db.query(SysPost).select_from(SysUser) \
-            .filter(SysUser.status == 0, SysUser.del_flag == 0, SysUser.user_id == user_id) \
-            .outerjoin(SysUserPost, SysUser.user_id == SysUserPost.user_id) \
-            .join(SysPost, and_(SysUserPost.post_id == SysPost.post_id, SysPost.status == 0)) \
-            .distinct().all()
+        query_user_basic_info = (await db.execute(
+            select(SysUser)
+                .where(SysUser.status == 0, SysUser.del_flag == 0, SysUser.user_id == user_id)
+                .distinct()
+        )).scalars().first()
+        query_user_dept_info = (await db.execute(
+            select(SysDept)
+                .select_from(SysUser)
+                .where(SysUser.status == 0, SysUser.del_flag == 0, SysUser.user_id == user_id)
+                .join(SysDept, and_(SysUser.dept_id == SysDept.dept_id, SysDept.status == 0, SysDept.del_flag == 0))
+                .distinct()
+        )).scalars().first()
+        query_user_role_info = (await db.execute(
+            select(SysRole)
+                .select_from(SysUser)
+                .where(SysUser.status == 0, SysUser.del_flag == 0, SysUser.user_id == user_id)
+                .join(SysUserRole, SysUser.user_id == SysUserRole.user_id, isouter=True)
+                .join(SysRole, and_(SysUserRole.role_id == SysRole.role_id, SysRole.status == 0, SysRole.del_flag == 0))
+                .distinct()
+        )).scalars().all()
+        query_user_post_info = (await db.execute(
+            select(SysPost)
+                .select_from(SysUser)
+                .where(SysUser.status == 0, SysUser.del_flag == 0, SysUser.user_id == user_id)
+                .join(SysUserPost, SysUser.user_id == SysUserPost.user_id, isouter=True)
+                .join(SysPost, and_(SysUserPost.post_id == SysPost.post_id, SysPost.status == 0))
+                .distinct()
+        )).scalars().all()
         role_id_list = [item.role_id for item in query_user_role_info]
         if 1 in role_id_list:
-            query_user_menu_info = db.query(SysMenu) \
-                .filter(SysMenu.status == 0) \
-                .distinct().all()
+            query_user_menu_info = (await db.execute(
+                select(SysMenu)
+                    .where(SysMenu.status == 0)
+                    .distinct()
+            )).scalars().all()
         else:
-            query_user_menu_info = db.query(SysMenu).select_from(SysUser) \
-                .filter(SysUser.status == 0, SysUser.del_flag == 0, SysUser.user_id == user_id) \
-                .outerjoin(SysUserRole, SysUser.user_id == SysUserRole.user_id) \
-                .outerjoin(SysRole, and_(SysUserRole.role_id == SysRole.role_id, SysRole.status == 0, SysRole.del_flag == 0)) \
-                .outerjoin(SysRoleMenu, SysRole.role_id == SysRoleMenu.role_id) \
-                .join(SysMenu, and_(SysRoleMenu.menu_id == SysMenu.menu_id, SysMenu.status == 0)) \
-                .order_by(SysMenu.order_num) \
-                .distinct().all()
+            query_user_menu_info = (await db.execute(
+                select(SysMenu)
+                    .select_from(SysUser)
+                    .where(SysUser.status == 0, SysUser.del_flag == 0, SysUser.user_id == user_id)
+                    .join(SysUserRole, SysUser.user_id == SysUserRole.user_id, isouter=True)
+                    .join(SysRole,
+                          and_(SysUserRole.role_id == SysRole.role_id, SysRole.status == 0, SysRole.del_flag == 0),
+                          isouter=True)
+                    .join(SysRoleMenu, SysRole.role_id == SysRoleMenu.role_id, isouter=True)
+                    .join(SysMenu, and_(SysRoleMenu.menu_id == SysMenu.menu_id, SysMenu.status == 0))
+                    .order_by(SysMenu.order_num)
+                    .distinct()
+            )).scalars().all()
 
         results = dict(
             user_basic_info=query_user_basic_info,
@@ -95,37 +118,52 @@ class UserDao:
         return results
 
     @classmethod
-    def get_user_detail_by_id(cls, db: Session, user_id: int):
+    async def get_user_detail_by_id(cls, db: AsyncSession, user_id: int):
         """
         根据user_id获取用户详细信息
         :param db: orm对象
         :param user_id: 用户id
         :return: 当前user_id的用户信息对象
         """
-        query_user_basic_info = db.query(SysUser) \
-            .filter(SysUser.del_flag == 0, SysUser.user_id == user_id) \
-            .distinct().first()
-        query_user_dept_info = db.query(SysDept).select_from(SysUser) \
-            .filter(SysUser.del_flag == 0, SysUser.user_id == user_id) \
-            .join(SysDept, and_(SysUser.dept_id == SysDept.dept_id, SysDept.status == 0, SysDept.del_flag == 0)) \
-            .distinct().first()
-        query_user_role_info = db.query(SysRole).select_from(SysUser) \
-            .filter(SysUser.del_flag == 0, SysUser.user_id == user_id) \
-            .outerjoin(SysUserRole, SysUser.user_id == SysUserRole.user_id) \
-            .join(SysRole, and_(SysUserRole.role_id == SysRole.role_id, SysRole.status == 0, SysRole.del_flag == 0)) \
-            .distinct().all()
-        query_user_post_info = db.query(SysPost).select_from(SysUser) \
-            .filter(SysUser.del_flag == 0, SysUser.user_id == user_id) \
-            .outerjoin(SysUserPost, SysUser.user_id == SysUserPost.user_id) \
-            .join(SysPost, and_(SysUserPost.post_id == SysPost.post_id, SysPost.status == 0)) \
-            .distinct().all()
-        query_user_menu_info = db.query(SysMenu).select_from(SysUser) \
-            .filter(SysUser.del_flag == 0, SysUser.user_id == user_id) \
-            .outerjoin(SysUserRole, SysUser.user_id == SysUserRole.user_id) \
-            .outerjoin(SysRole, and_(SysUserRole.role_id == SysRole.role_id, SysRole.status == 0, SysRole.del_flag == 0)) \
-            .outerjoin(SysRoleMenu, SysRole.role_id == SysRoleMenu.role_id) \
-            .join(SysMenu, and_(SysRoleMenu.menu_id == SysMenu.menu_id, SysMenu.status == 0)) \
-            .distinct().all()
+        query_user_basic_info = (await db.execute(
+            select(SysUser)
+                .where(SysUser.del_flag == 0, SysUser.user_id == user_id)
+                .distinct()
+        )).scalars().first()
+        query_user_dept_info = (await db.execute(
+            select(SysDept)
+                .select_from(SysUser)
+                .where(SysUser.del_flag == 0, SysUser.user_id == user_id)
+                .join(SysDept, and_(SysUser.dept_id == SysDept.dept_id, SysDept.status == 0, SysDept.del_flag == 0))
+                .distinct()
+        )).scalars().first()
+        query_user_role_info = (await db.execute(
+            select(SysRole)
+                .select_from(SysUser)
+                .where(SysUser.del_flag == 0, SysUser.user_id == user_id)
+                .join(SysUserRole, SysUser.user_id == SysUserRole.user_id, isouter=True)
+                .join(SysRole, and_(SysUserRole.role_id == SysRole.role_id, SysRole.status == 0, SysRole.del_flag == 0))
+                .distinct()
+        )).scalars().all()
+        query_user_post_info = (await db.execute(
+            select(SysPost)
+                .select_from(SysUser)
+                .where(SysUser.del_flag == 0, SysUser.user_id == user_id)
+                .join(SysUserPost, SysUser.user_id == SysUserPost.user_id, isouter=True)
+                .join(SysPost, and_(SysUserPost.post_id == SysPost.post_id, SysPost.status == 0))
+                .distinct()
+        )).scalars().all()
+        query_user_menu_info = (await db.execute(
+            select(SysMenu)
+                .select_from(SysUser)
+                .where(SysUser.del_flag == 0, SysUser.user_id == user_id)
+                .join(SysUserRole, SysUser.user_id == SysUserRole.user_id, isouter=True)
+                .join(SysRole, and_(SysUserRole.role_id == SysRole.role_id, SysRole.status == 0, SysRole.del_flag == 0),
+                      isouter=True)
+                .join(SysRoleMenu, SysRole.role_id == SysRoleMenu.role_id, isouter=True)
+                .join(SysMenu, and_(SysRoleMenu.menu_id == SysMenu.menu_id, SysMenu.status == 0))
+                .distinct()
+        )).scalars().all()
         results = dict(
             user_basic_info=query_user_basic_info,
             user_dept_info=query_user_dept_info,
@@ -137,7 +175,8 @@ class UserDao:
         return results
 
     @classmethod
-    def get_user_list(cls, db: Session, query_object: UserPageQueryModel, data_scope_sql: str, is_page: bool = False):
+    async def get_user_list(cls, db: AsyncSession, query_object: UserPageQueryModel, data_scope_sql: str,
+                            is_page: bool = False):
         """
         根据查询参数获取用户列表信息
         :param db: orm对象
@@ -146,31 +185,32 @@ class UserDao:
         :param is_page: 是否开启分页
         :return: 用户列表信息对象
         """
-        query = db.query(SysUser, SysDept) \
-            .filter(SysUser.del_flag == 0,
-                    or_(SysUser.dept_id == query_object.dept_id, SysUser.dept_id.in_(
-                        db.query(SysDept.dept_id).filter(func.find_in_set(query_object.dept_id, SysDept.ancestors))
-                    )) if query_object.dept_id 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,
-                    SysUser.phonenumber.like(f'%{query_object.phonenumber}%') if query_object.phonenumber else True,
-                    SysUser.status == query_object.status if query_object.status else True,
-                    SysUser.sex == query_object.sex if query_object.sex else True,
-                    SysUser.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,
-                    eval(data_scope_sql)
-                    ) \
-            .outerjoin(SysDept, and_(SysUser.dept_id == SysDept.dept_id, SysDept.status == 0, SysDept.del_flag == 0)) \
+        query = select(SysUser, SysDept) \
+            .where(SysUser.del_flag == 0,
+                   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_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,
+                   SysUser.phonenumber.like(f'%{query_object.phonenumber}%') if query_object.phonenumber else True,
+                   SysUser.status == query_object.status if query_object.status else True,
+                   SysUser.sex == query_object.sex if query_object.sex else True,
+                   SysUser.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,
+                   eval(data_scope_sql)
+                   ) \
+            .join(SysDept, and_(SysUser.dept_id == SysDept.dept_id, SysDept.status == 0, SysDept.del_flag == 0),
+                  isouter=True) \
             .distinct()
-        user_list = PageUtil.paginate(query, query_object.page_num, query_object.page_size, is_page)
+        user_list = await PageUtil.paginate(db, query, query_object.page_num, query_object.page_size, is_page)
 
         return user_list
 
     @classmethod
-    def add_user_dao(cls, db: Session, user: UserModel):
+    async def add_user_dao(cls, db: AsyncSession, user: UserModel):
         """
         新增用户数据库操作
         :param db: orm对象
@@ -179,57 +219,62 @@ class UserDao:
         """
         db_user = SysUser(**user.model_dump(exclude={'admin'}))
         db.add(db_user)
-        db.flush()
+        await db.flush()
 
         return db_user
 
     @classmethod
-    def edit_user_dao(cls, db: Session, user: dict):
+    async def edit_user_dao(cls, db: AsyncSession, user: dict):
         """
         编辑用户数据库操作
         :param db: orm对象
         :param user: 需要更新的用户字典
         :return: 编辑校验结果
         """
-        db.query(SysUser) \
-            .filter(SysUser.user_id == user.get('user_id')) \
-            .update(user)
+        await db.execute(
+            update(SysUser),
+            [user]
+        )
 
     @classmethod
-    def delete_user_dao(cls, db: Session, user: UserModel):
+    async def delete_user_dao(cls, db: AsyncSession, user: UserModel):
         """
         删除用户数据库操作
         :param db: orm对象
         :param user: 用户对象
         :return:
         """
-        db.query(SysUser) \
-            .filter(SysUser.user_id == user.user_id) \
-            .update({SysUser.del_flag: '2', SysUser.update_by: user.update_by, SysUser.update_time: user.update_time})
+        await db.execute(
+            update(SysUser)
+                .where(SysUser.user_id == user.user_id)
+                .values(del_flag='2', update_by=user.update_by, update_time=user.update_time)
+        )
 
     @classmethod
-    def get_user_role_allocated_list_by_user_id(cls, db: Session, query_object: UserRoleQueryModel):
+    async def get_user_role_allocated_list_by_user_id(cls, db: AsyncSession, query_object: UserRoleQueryModel):
         """
         根据用户id获取用户已分配的角色列表信息数据库操作
         :param db: orm对象
         :param query_object: 用户角色查询对象
         :return: 用户已分配的角色列表信息
         """
-        allocated_role_list = db.query(SysRole) \
-            .filter(
-            SysRole.del_flag == 0,
-            SysRole.role_id != 1,
-            SysRole.role_name == query_object.role_name if query_object.role_name else True,
-            SysRole.role_key == query_object.role_key if query_object.role_key else True,
-            SysRole.role_id.in_(
-                db.query(SysUserRole.role_id).filter(SysUserRole.user_id == query_object.user_id)
-            )
-        ).distinct().all()
+        allocated_role_list = (await db.execute(
+            select(SysRole)
+                .where(SysRole.del_flag == 0,
+                       SysRole.role_id != 1,
+                       SysRole.role_name == query_object.role_name if query_object.role_name else True,
+                       SysRole.role_key == query_object.role_key if query_object.role_key else True,
+                       SysRole.role_id.in_(
+                           select(SysUserRole.role_id).where(SysUserRole.user_id == query_object.user_id)
+                       ))
+                .distinct()
+        )).scalars().all()
 
         return allocated_role_list
 
     @classmethod
-    def get_user_role_allocated_list_by_role_id(cls, db: Session, query_object: UserRolePageQueryModel, is_page: bool = False):
+    async def get_user_role_allocated_list_by_role_id(cls, db: AsyncSession, query_object: UserRolePageQueryModel,
+                                                      is_page: bool = False):
         """
         根据角色id获取已分配的用户列表信息
         :param db: orm对象
@@ -237,22 +282,22 @@ class UserDao:
         :param is_page: 是否开启分页
         :return: 角色已分配的用户列表信息
         """
-        query = db.query(SysUser) \
-            .filter(
-            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_(
-                db.query(SysUserRole.user_id).filter(SysUserRole.role_id == query_object.role_id)
-            )
-        ).distinct()
-        allocated_user_list = PageUtil.paginate(query, query_object.page_num, query_object.page_size, is_page)
+        query = select(SysUser) \
+            .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)
+                   )) \
+            .distinct()
+        allocated_user_list = await PageUtil.paginate(db, query, query_object.page_num, query_object.page_size, is_page)
 
         return allocated_user_list
 
     @classmethod
-    def get_user_role_unallocated_list_by_role_id(cls, db: Session, query_object: UserRolePageQueryModel, is_page: bool = False):
+    async def get_user_role_unallocated_list_by_role_id(cls, db: AsyncSession, query_object: UserRolePageQueryModel,
+                                                        is_page: bool = False):
         """
         根据角色id获取未分配的用户列表信息
         :param db: orm对象
@@ -260,22 +305,22 @@ class UserDao:
         :param is_page: 是否开启分页
         :return: 角色未分配的用户列表信息
         """
-        query = db.query(SysUser) \
-            .filter(
-            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_(
-                db.query(SysUserRole.user_id).filter(SysUserRole.role_id == query_object.role_id)
-            )
-        ).distinct()
-        unallocated_user_list = PageUtil.paginate(query, query_object.page_num, query_object.page_size, is_page)
+        query = select(SysUser) \
+            .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)
+                   )) \
+            .distinct()
+        unallocated_user_list = await PageUtil.paginate(db, query, query_object.page_num, query_object.page_size,
+                                                        is_page)
 
         return unallocated_user_list
 
     @classmethod
-    def add_user_role_dao(cls, db: Session, user_role: UserRoleModel):
+    async def add_user_role_dao(cls, db: AsyncSession, user_role: UserRoleModel):
         """
         新增用户角色关联信息数据库操作
         :param db: orm对象
@@ -286,46 +331,50 @@ class UserDao:
         db.add(db_user_role)
 
     @classmethod
-    def delete_user_role_dao(cls, db: Session, user_role: UserRoleModel):
+    async def delete_user_role_dao(cls, db: AsyncSession, user_role: UserRoleModel):
         """
         删除用户角色关联信息数据库操作
         :param db: orm对象
         :param user_role: 用户角色关联对象
         :return:
         """
-        db.query(SysUserRole) \
-            .filter(SysUserRole.user_id == user_role.user_id) \
-            .delete()
+        await db.execute(
+            delete(SysUserRole)
+                .where(SysUserRole.user_id.in_([user_role.user_id]))
+        )
 
     @classmethod
-    def delete_user_role_by_user_and_role_dao(cls, db: Session, user_role: UserRoleModel):
+    async def delete_user_role_by_user_and_role_dao(cls, db: AsyncSession, user_role: UserRoleModel):
         """
         根据用户id及角色id删除用户角色关联信息数据库操作
         :param db: orm对象
         :param user_role: 用户角色关联对象
         :return:
         """
-        db.query(SysUserRole) \
-            .filter(SysUserRole.user_id == user_role.user_id,
-                    SysUserRole.role_id == user_role.role_id if user_role.role_id else True) \
-            .delete()
+        await db.execute(
+            delete(SysUserRole)
+                .where(SysUserRole.user_id.in_([user_role.user_id]),
+                       SysUserRole.role_id == user_role.role_id if user_role.role_id else True)
+        )
 
     @classmethod
-    def get_user_role_detail(cls, db: Session, user_role: UserRoleModel):
+    async def get_user_role_detail(cls, db: AsyncSession, user_role: UserRoleModel):
         """
         根据用户角色关联获取用户角色关联详细信息
         :param db: orm对象
         :param user_role: 用户角色关联对象
         :return: 用户角色关联信息
         """
-        user_role_info = db.query(SysUserRole) \
-            .filter(SysUserRole.user_id == user_role.user_id, SysUserRole.role_id == user_role.role_id) \
-            .distinct().first()
+        user_role_info = (await db.execute(
+            select(SysUserRole)
+                .where(SysUserRole.user_id == user_role.user_id, SysUserRole.role_id == user_role.role_id)
+                .distinct()
+        )).scalars().first()
 
         return user_role_info
 
     @classmethod
-    def add_user_post_dao(cls, db: Session, user_post: UserPostModel):
+    async def add_user_post_dao(cls, db: AsyncSession, user_post: UserPostModel):
         """
         新增用户岗位关联信息数据库操作
         :param db: orm对象
@@ -336,22 +385,24 @@ class UserDao:
         db.add(db_user_post)
 
     @classmethod
-    def delete_user_post_dao(cls, db: Session, user_post: UserPostModel):
+    async def delete_user_post_dao(cls, db: AsyncSession, user_post: UserPostModel):
         """
         删除用户岗位关联信息数据库操作
         :param db: orm对象
         :param user_post: 用户岗位关联对象
         :return:
         """
-        db.query(SysUserPost) \
-            .filter(SysUserPost.user_id == user_post.user_id) \
-            .delete()
+        await db.execute(
+            delete(SysUserPost)
+                .where(SysUserPost.user_id.in_([user_post.user_id]))
+        )
 
     @classmethod
-    def get_user_dept_info(cls, db: Session, dept_id: int):
-        dept_basic_info = db.query(SysDept) \
-            .filter(SysDept.dept_id == dept_id,
-                    SysDept.status == 0,
-                    SysDept.del_flag == 0) \
-            .first()
+    async def get_user_dept_info(cls, db: AsyncSession, dept_id: int):
+        dept_basic_info = (await db.execute(
+            select(SysDept)
+                .where(SysDept.dept_id == dept_id,
+                       SysDept.status == 0,
+                       SysDept.del_flag == 0)
+        )).scalars().first()
         return dept_basic_info

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

@@ -4,6 +4,7 @@ from config.env import RedisInitKeyConfig
 from config.get_redis import RedisUtil
 from module_admin.entity.vo.common_vo import CrudResponseModel
 
+
 class CacheService:
     """
     缓存监控模块服务层
@@ -30,7 +31,7 @@ class CacheService:
         return result
 
     @classmethod
-    def get_cache_monitor_cache_name_services(cls):
+    async def get_cache_monitor_cache_name_services(cls):
         """
         获取缓存名称列表信息service
         :return: 缓存名称列表信息

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

@@ -11,7 +11,7 @@ class CaptchaService:
     """
 
     @classmethod
-    def create_captcha_image_service(cls):
+    async def create_captcha_image_service(cls):
         # 创建空白图像
         image = Image.new('RGB', (160, 60), color='#EAEAEA')
 

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

@@ -13,7 +13,7 @@ class CommonService:
     """
 
     @classmethod
-    def upload_service(cls, request: Request, file: UploadFile):
+    async def upload_service(cls, request: Request, file: UploadFile):
         """
         通用上传service
         :param request: Request对象
@@ -50,7 +50,7 @@ class CommonService:
         return CrudResponseModel(**result)
 
     @classmethod
-    def download_services(cls, background_tasks: BackgroundTasks, file_name, delete: bool):
+    async def download_services(cls, background_tasks: BackgroundTasks, file_name, delete: bool):
         """
         下载下载目录文件service
         :param background_tasks: 后台任务对象
@@ -70,7 +70,7 @@ class CommonService:
         return CrudResponseModel(**result)
 
     @classmethod
-    def download_resource_services(cls, resource: str):
+    async def download_resource_services(cls, resource: str):
         """
         下载上传目录文件service
         :param resource: 下载的文件名称

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

@@ -11,7 +11,7 @@ class ConfigService:
     """
 
     @classmethod
-    def get_config_list_services(cls, query_db: Session, query_object: ConfigPageQueryModel, is_page: bool = False):
+    async def get_config_list_services(cls, query_db: AsyncSession, query_object: ConfigPageQueryModel, is_page: bool = False):
         """
         获取参数配置列表信息service
         :param query_db: orm对象
@@ -19,12 +19,12 @@ class ConfigService:
         :param is_page: 是否开启分页
         :return: 参数配置列表信息对象
         """
-        config_list_result = ConfigDao.get_config_list(query_db, query_object, is_page)
+        config_list_result = await ConfigDao.get_config_list(query_db, query_object, is_page)
 
         return config_list_result
 
     @classmethod
-    async def init_cache_sys_config_services(cls, query_db: Session, redis):
+    async def init_cache_sys_config_services(cls, query_db: AsyncSession, redis):
         """
         应用初始化：获取所有参数配置对应的键值对信息并缓存service
         :param query_db: orm对象
@@ -36,7 +36,7 @@ class ConfigService:
         # 删除匹配的键
         if keys:
             await redis.delete(*keys)
-        config_all = ConfigDao.get_config_list(query_db, ConfigPageQueryModel(**dict()), is_page=False)
+        config_all = await ConfigDao.get_config_list(query_db, ConfigPageQueryModel(**dict()), is_page=False)
         for config_obj in config_all:
             if config_obj.get('configType') == 'Y':
                 await redis.set(f"{RedisInitKeyConfig.SYS_CONFIG.get('key')}:{config_obj.get('configKey')}", config_obj.get('configValue'))
@@ -54,7 +54,7 @@ class ConfigService:
         return result
 
     @classmethod
-    async def add_config_services(cls, request: Request, query_db: Session, page_object: ConfigModel):
+    async def add_config_services(cls, request: Request, query_db: AsyncSession, page_object: ConfigModel):
         """
         新增参数配置信息service
         :param request: Request对象
@@ -62,23 +62,23 @@ class ConfigService:
         :param page_object: 新增参数配置对象
         :return: 新增参数配置校验结果
         """
-        config = ConfigDao.get_config_detail_by_info(query_db, ConfigModel(configKey=page_object.config_key))
+        config = await ConfigDao.get_config_detail_by_info(query_db, ConfigModel(configKey=page_object.config_key))
         if config:
             result = dict(is_success=False, message='参数键名已存在')
         else:
             try:
-                ConfigDao.add_config_dao(query_db, page_object)
-                query_db.commit()
+                await ConfigDao.add_config_dao(query_db, page_object)
+                await query_db.commit()
                 await cls.init_cache_sys_config_services(query_db, request.app.state.redis)
                 result = dict(is_success=True, message='新增成功')
             except Exception as e:
-                query_db.rollback()
+                await query_db.rollback()
                 raise e
 
         return CrudResponseModel(**result)
 
     @classmethod
-    async def edit_config_services(cls, request: Request, query_db: Session, page_object: ConfigModel):
+    async def edit_config_services(cls, request: Request, query_db: AsyncSession, page_object: ConfigModel):
         """
         编辑参数配置信息service
         :param request: Request对象
@@ -87,20 +87,20 @@ class ConfigService:
         :return: 编辑参数配置校验结果
         """
         edit_config = page_object.model_dump(exclude_unset=True)
-        config_info = cls.config_detail_services(query_db, edit_config.get('config_id'))
+        config_info = await cls.config_detail_services(query_db, edit_config.get('config_id'))
         if config_info:
             if config_info.config_key != page_object.config_key or config_info.config_value != page_object.config_value:
-                config = ConfigDao.get_config_detail_by_info(query_db, page_object)
+                config = await ConfigDao.get_config_detail_by_info(query_db, page_object)
                 if config:
                     result = dict(is_success=False, message='参数配置已存在')
                     return CrudResponseModel(**result)
             try:
-                ConfigDao.edit_config_dao(query_db, edit_config)
-                query_db.commit()
+                await ConfigDao.edit_config_dao(query_db, edit_config)
+                await query_db.commit()
                 await cls.init_cache_sys_config_services(query_db, request.app.state.redis)
                 result = dict(is_success=True, message='更新成功')
             except Exception as e:
-                query_db.rollback()
+                await query_db.rollback()
                 raise e
         else:
             result = dict(is_success=False, message='参数配置不存在')
@@ -108,7 +108,7 @@ class ConfigService:
         return CrudResponseModel(**result)
 
     @classmethod
-    async def delete_config_services(cls, request: Request, query_db: Session, page_object: DeleteConfigModel):
+    async def delete_config_services(cls, request: Request, query_db: AsyncSession, page_object: DeleteConfigModel):
         """
         删除参数配置信息service
         :param request: Request对象
@@ -120,32 +120,32 @@ class ConfigService:
             config_id_list = page_object.config_ids.split(',')
             try:
                 for config_id in config_id_list:
-                    ConfigDao.delete_config_dao(query_db, ConfigModel(configId=config_id))
-                query_db.commit()
+                    await ConfigDao.delete_config_dao(query_db, ConfigModel(configId=config_id))
+                await query_db.commit()
                 await cls.init_cache_sys_config_services(query_db, request.app.state.redis)
                 result = dict(is_success=True, message='删除成功')
             except Exception as e:
-                query_db.rollback()
+                await query_db.rollback()
                 raise e
         else:
             result = dict(is_success=False, message='传入字典数据id为空')
         return CrudResponseModel(**result)
 
     @classmethod
-    def config_detail_services(cls, query_db: Session, config_id: int):
+    async def config_detail_services(cls, query_db: AsyncSession, config_id: int):
         """
         获取参数配置详细信息service
         :param query_db: orm对象
         :param config_id: 参数配置id
         :return: 参数配置id对应的信息
         """
-        config = ConfigDao.get_config_detail_by_id(query_db, config_id=config_id)
+        config = await ConfigDao.get_config_detail_by_id(query_db, config_id=config_id)
         result = ConfigModel(**CamelCaseUtil.transform_result(config))
 
         return result
 
     @staticmethod
-    def export_config_list_services(config_list: List):
+    async def export_config_list_services(config_list: List):
         """
         导出参数配置信息service
         :param config_list: 参数配置信息列表
@@ -178,7 +178,7 @@ class ConfigService:
         return binary_data
 
     @classmethod
-    async def refresh_sys_config_services(cls, request: Request, query_db: Session):
+    async def refresh_sys_config_services(cls, request: Request, query_db: AsyncSession):
         """
         刷新字典缓存信息service
         :param request: Request对象

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

@@ -9,7 +9,7 @@ class DeptService:
     """
 
     @classmethod
-    def get_dept_tree_services(cls, query_db: Session, page_object: DeptModel, data_scope_sql: str):
+    async def get_dept_tree_services(cls, query_db: AsyncSession, page_object: DeptModel, data_scope_sql: str):
         """
         获取部门树信息service
         :param query_db: orm对象
@@ -17,13 +17,14 @@ class DeptService:
         :param data_scope_sql: 数据权限对应的查询sql语句
         :return: 部门树信息对象
         """
-        dept_list_result = DeptDao.get_dept_list_for_tree(query_db, page_object, data_scope_sql)
+        dept_list_result = await DeptDao.get_dept_list_for_tree(query_db, page_object, data_scope_sql)
         dept_tree_result = cls.list_to_tree(dept_list_result)
 
         return dept_tree_result
 
     @classmethod
-    def get_dept_for_edit_option_services(cls, query_db: Session, page_object: DeptModel, data_scope_sql: str):
+    async def get_dept_for_edit_option_services(cls, query_db: AsyncSession, page_object: DeptModel,
+                                                data_scope_sql: str):
         """
         获取部门编辑部门树信息service
         :param query_db: orm对象
@@ -31,12 +32,12 @@ class DeptService:
         :param data_scope_sql: 数据权限对应的查询sql语句
         :return: 部门树信息对象
         """
-        dept_list_result = DeptDao.get_dept_info_for_edit_option(query_db, page_object, data_scope_sql)
+        dept_list_result = await DeptDao.get_dept_info_for_edit_option(query_db, page_object, data_scope_sql)
 
         return CamelCaseUtil.transform_result(dept_list_result)
 
     @classmethod
-    def get_dept_list_services(cls, query_db: Session, page_object: DeptModel, data_scope_sql: str):
+    async def get_dept_list_services(cls, query_db: AsyncSession, page_object: DeptModel, data_scope_sql: str):
         """
         获取部门列表信息service
         :param query_db: orm对象
@@ -44,72 +45,72 @@ class DeptService:
         :param data_scope_sql: 数据权限对应的查询sql语句
         :return: 部门列表信息对象
         """
-        dept_list_result = DeptDao.get_dept_list(query_db, page_object, data_scope_sql)
+        dept_list_result = await DeptDao.get_dept_list(query_db, page_object, data_scope_sql)
 
         return CamelCaseUtil.transform_result(dept_list_result)
 
     @classmethod
-    def add_dept_services(cls, query_db: Session, page_object: DeptModel):
+    async def add_dept_services(cls, query_db: AsyncSession, page_object: DeptModel):
         """
         新增部门信息service
         :param query_db: orm对象
         :param page_object: 新增部门对象
         :return: 新增部门校验结果
         """
-        parent_info = DeptDao.get_dept_by_id(query_db, page_object.parent_id)
+        parent_info = await DeptDao.get_dept_by_id(query_db, page_object.parent_id)
         if parent_info:
             page_object.ancestors = f'{parent_info.ancestors},{page_object.parent_id}'
         else:
             page_object.ancestors = '0'
-        dept = DeptDao.get_dept_detail_by_info(query_db, DeptModel(parentId=page_object.parent_id,
-                                                                   deptName=page_object.dept_name))
+        dept = await DeptDao.get_dept_detail_by_info(query_db, DeptModel(parentId=page_object.parent_id,
+                                                                         deptName=page_object.dept_name))
         if dept:
             result = dict(is_success=False, message='同一部门下不允许存在同名的部门')
         else:
             try:
-                DeptDao.add_dept_dao(query_db, page_object)
-                query_db.commit()
+                await DeptDao.add_dept_dao(query_db, page_object)
+                await query_db.commit()
                 result = dict(is_success=True, message='新增成功')
             except Exception as e:
-                query_db.rollback()
+                await query_db.rollback()
                 raise e
 
         return CrudResponseModel(**result)
 
     @classmethod
-    def edit_dept_services(cls, query_db: Session, page_object: DeptModel):
+    async def edit_dept_services(cls, query_db: AsyncSession, page_object: DeptModel):
         """
         编辑部门信息service
         :param query_db: orm对象
         :param page_object: 编辑部门对象
         :return: 编辑部门校验结果
         """
-        parent_info = DeptDao.get_dept_by_id(query_db, page_object.parent_id)
+        parent_info = await DeptDao.get_dept_by_id(query_db, page_object.parent_id)
         if parent_info:
             page_object.ancestors = f'{parent_info.ancestors},{page_object.parent_id}'
         else:
             page_object.ancestors = '0'
         edit_dept = page_object.model_dump(exclude_unset=True)
-        dept_info = cls.dept_detail_services(query_db, edit_dept.get('dept_id'))
+        dept_info = await cls.dept_detail_services(query_db, edit_dept.get('dept_id'))
         if dept_info:
             if dept_info.parent_id != page_object.parent_id or dept_info.dept_name != page_object.dept_name:
-                dept = DeptDao.get_dept_detail_by_info(query_db, DeptModel(parentId=page_object.parent_id,
-                                                                           deptName=page_object.dept_name))
+                dept = await DeptDao.get_dept_detail_by_info(query_db, DeptModel(parentId=page_object.parent_id,
+                                                                                 deptName=page_object.dept_name))
                 if dept:
                     result = dict(is_success=False, message='同一部门下不允许存在同名的部门')
                     return CrudResponseModel(**result)
             try:
-                DeptDao.edit_dept_dao(query_db, edit_dept)
-                cls.update_children_info(query_db, DeptModel(deptId=page_object.dept_id,
-                                                             ancestors=page_object.ancestors,
-                                                             updateBy=page_object.update_by,
-                                                             updateTime=page_object.update_time
-                                                             )
-                                         )
-                query_db.commit()
+                await DeptDao.edit_dept_dao(query_db, edit_dept)
+                await cls.update_children_info(query_db, DeptModel(deptId=page_object.dept_id,
+                                                                   ancestors=page_object.ancestors,
+                                                                   updateBy=page_object.update_by,
+                                                                   updateTime=page_object.update_time
+                                                                   )
+                                               )
+                await query_db.commit()
                 result = dict(is_success=True, message='更新成功')
             except Exception as e:
-                query_db.rollback()
+                await query_db.rollback()
                 raise e
         else:
             result = dict(is_success=False, message='部门不存在')
@@ -117,7 +118,7 @@ class DeptService:
         return CrudResponseModel(**result)
 
     @classmethod
-    def delete_dept_services(cls, query_db: Session, page_object: DeleteDeptModel):
+    async def delete_dept_services(cls, query_db: AsyncSession, page_object: DeleteDeptModel):
         """
         删除部门信息service
         :param query_db: orm对象
@@ -126,7 +127,7 @@ class DeptService:
         """
         if page_object.dept_ids.split(','):
             dept_id_list = page_object.dept_ids.split(',')
-            ancestors = DeptDao.get_dept_all_ancestors(query_db)
+            ancestors = await DeptDao.get_dept_all_ancestors(query_db)
             try:
                 for dept_id in dept_id_list:
                     for ancestor in ancestors:
@@ -135,25 +136,25 @@ class DeptService:
 
                             return CrudResponseModel(**result)
 
-                    DeptDao.delete_dept_dao(query_db, DeptModel(deptId=dept_id))
-                query_db.commit()
+                    await DeptDao.delete_dept_dao(query_db, DeptModel(deptId=dept_id))
+                await query_db.commit()
                 result = dict(is_success=True, message='删除成功')
             except Exception as e:
-                query_db.rollback()
+                await query_db.rollback()
                 raise e
         else:
             result = dict(is_success=False, message='传入部门id为空')
         return CrudResponseModel(**result)
 
     @classmethod
-    def dept_detail_services(cls, query_db: Session, dept_id: int):
+    async def dept_detail_services(cls, query_db: AsyncSession, dept_id: int):
         """
         获取部门详细信息service
         :param query_db: orm对象
         :param dept_id: 部门id
         :return: 部门id对应的信息
         """
-        dept = DeptDao.get_dept_detail_by_id(query_db, dept_id=dept_id)
+        dept = await DeptDao.get_dept_detail_by_id(query_db, dept_id=dept_id)
         result = DeptModel(**CamelCaseUtil.transform_result(dept))
 
         return result
@@ -188,26 +189,26 @@ class DeptService:
         return container
 
     @classmethod
-    def update_children_info(cls, query_db, page_object):
+    async def update_children_info(cls, query_db, page_object):
         """
         工具方法：递归更新子部门信息
         :param query_db: orm对象
         :param page_object: 编辑部门对象
         :return:
         """
-        children_info = DeptDao.get_children_dept(query_db, page_object.dept_id)
+        children_info = await DeptDao.get_children_dept(query_db, page_object.dept_id)
         if children_info:
             for child in children_info:
                 child.ancestors = f'{page_object.ancestors},{page_object.dept_id}'
-                DeptDao.edit_dept_dao(query_db,
-                                      dict(dept_id=child.dept_id,
-                                           ancestors=child.ancestors,
-                                           update_by=page_object.update_by,
-                                           update_time=page_object.update_time
-                                           )
-                                      )
-                cls.update_children_info(query_db, DeptModel(dept_id=child.dept_id,
-                                                             ancestors=child.ancestors,
-                                                             update_by=page_object.update_by,
-                                                             update_time=page_object.update_time
-                                                             ))
+                await DeptDao.edit_dept_dao(query_db,
+                                            dict(dept_id=child.dept_id,
+                                                 ancestors=child.ancestors,
+                                                 update_by=page_object.update_by,
+                                                 update_time=page_object.update_time
+                                                 )
+                                            )
+                await cls.update_children_info(query_db, DeptModel(dept_id=child.dept_id,
+                                                                   ancestors=child.ancestors,
+                                                                   update_by=page_object.update_by,
+                                                                   update_time=page_object.update_time
+                                                                   ))

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

@@ -12,7 +12,7 @@ class DictTypeService:
     """
 
     @classmethod
-    def get_dict_type_list_services(cls, query_db: Session, query_object: DictTypePageQueryModel, is_page: bool = False):
+    async def get_dict_type_list_services(cls, query_db: AsyncSession, query_object: DictTypePageQueryModel, is_page: bool = False):
         """
         获取字典类型列表信息service
         :param query_db: orm对象
@@ -20,12 +20,12 @@ class DictTypeService:
         :param is_page: 是否开启分页
         :return: 字典类型列表信息对象
         """
-        dict_type_list_result = DictTypeDao.get_dict_type_list(query_db, query_object, is_page)
+        dict_type_list_result = await DictTypeDao.get_dict_type_list(query_db, query_object, is_page)
 
         return dict_type_list_result
 
     @classmethod
-    async def add_dict_type_services(cls, request: Request, query_db: Session, page_object: DictTypeModel):
+    async def add_dict_type_services(cls, request: Request, query_db: AsyncSession, page_object: DictTypeModel):
         """
         新增字典类型信息service
         :param request: Request对象
@@ -33,23 +33,23 @@ class DictTypeService:
         :param page_object: 新增岗位对象
         :return: 新增字典类型校验结果
         """
-        dict_type = DictTypeDao.get_dict_type_detail_by_info(query_db, DictTypeModel(dictType=page_object.dict_type))
+        dict_type = await DictTypeDao.get_dict_type_detail_by_info(query_db, DictTypeModel(dictType=page_object.dict_type))
         if dict_type:
             result = dict(is_success=False, message='字典类型已存在')
         else:
             try:
-                DictTypeDao.add_dict_type_dao(query_db, page_object)
-                query_db.commit()
+                await DictTypeDao.add_dict_type_dao(query_db, page_object)
+                await query_db.commit()
                 await DictDataService.init_cache_sys_dict_services(query_db, request.app.state.redis)
                 result = dict(is_success=True, message='新增成功')
             except Exception as e:
-                query_db.rollback()
+                await query_db.rollback()
                 raise e
 
         return CrudResponseModel(**result)
 
     @classmethod
-    async def edit_dict_type_services(cls, request: Request, query_db: Session, page_object: DictTypeModel):
+    async def edit_dict_type_services(cls, request: Request, query_db: AsyncSession, page_object: DictTypeModel):
         """
         编辑字典类型信息service
         :param request: Request对象
@@ -58,26 +58,26 @@ class DictTypeService:
         :return: 编辑字典类型校验结果
         """
         edit_dict_type = page_object.model_dump(exclude_unset=True)
-        dict_type_info = cls.dict_type_detail_services(query_db, edit_dict_type.get('dict_id'))
+        dict_type_info = await cls.dict_type_detail_services(query_db, edit_dict_type.get('dict_id'))
         if dict_type_info:
             if dict_type_info.dict_type != page_object.dict_type or dict_type_info.dict_name != page_object.dict_name:
-                dict_type = DictTypeDao.get_dict_type_detail_by_info(query_db, DictTypeModel(dictType=page_object.dict_type))
+                dict_type = await DictTypeDao.get_dict_type_detail_by_info(query_db, DictTypeModel(dictType=page_object.dict_type))
                 if dict_type:
                     result = dict(is_success=False, message='字典类型已存在')
                     return CrudResponseModel(**result)
             try:
                 if dict_type_info.dict_type != page_object.dict_type:
-                    query_dict_data = DictDataModel(dictType=dict_type_info.dict_type)
-                    dict_data_list = DictDataDao.get_dict_data_list(query_db, query_dict_data)
+                    query_dict_data = await DictDataModel(dictType=dict_type_info.dict_type)
+                    dict_data_list = await DictDataDao.get_dict_data_list(query_db, query_dict_data)
                     for dict_data in dict_data_list:
                         edit_dict_data = DictDataModel(dictCode=dict_data.dict_code, dictType=page_object.dict_type, updateBy=page_object.update_by).model_dump(exclude_unset=True)
-                        DictDataDao.edit_dict_data_dao(query_db, edit_dict_data)
-                DictTypeDao.edit_dict_type_dao(query_db, edit_dict_type)
-                query_db.commit()
+                        await DictDataDao.edit_dict_data_dao(query_db, edit_dict_data)
+                await DictTypeDao.edit_dict_type_dao(query_db, edit_dict_type)
+                await query_db.commit()
                 await DictDataService.init_cache_sys_dict_services(query_db, request.app.state.redis)
                 result = dict(is_success=True, message='更新成功')
             except Exception as e:
-                query_db.rollback()
+                await query_db.rollback()
                 raise e
         else:
             result = dict(is_success=False, message='字典类型不存在')
@@ -85,7 +85,7 @@ class DictTypeService:
         return CrudResponseModel(**result)
 
     @classmethod
-    async def delete_dict_type_services(cls, request: Request, query_db: Session, page_object: DeleteDictTypeModel):
+    async def delete_dict_type_services(cls, request: Request, query_db: AsyncSession, page_object: DeleteDictTypeModel):
         """
         删除字典类型信息service
         :param request: Request对象
@@ -97,32 +97,32 @@ class DictTypeService:
             dict_id_list = page_object.dict_ids.split(',')
             try:
                 for dict_id in dict_id_list:
-                    DictTypeDao.delete_dict_type_dao(query_db, DictTypeModel(dictId=dict_id))
-                query_db.commit()
+                    await DictTypeDao.delete_dict_type_dao(query_db, DictTypeModel(dictId=dict_id))
+                await query_db.commit()
                 await DictDataService.init_cache_sys_dict_services(query_db, request.app.state.redis)
                 result = dict(is_success=True, message='删除成功')
             except Exception as e:
-                query_db.rollback()
+                await query_db.rollback()
                 raise e
         else:
             result = dict(is_success=False, message='传入字典类型id为空')
         return CrudResponseModel(**result)
 
     @classmethod
-    def dict_type_detail_services(cls, query_db: Session, dict_id: int):
+    async def dict_type_detail_services(cls, query_db: AsyncSession, dict_id: int):
         """
         获取字典类型详细信息service
         :param query_db: orm对象
         :param dict_id: 字典类型id
         :return: 字典类型id对应的信息
         """
-        dict_type = DictTypeDao.get_dict_type_detail_by_id(query_db, dict_id=dict_id)
+        dict_type = await DictTypeDao.get_dict_type_detail_by_id(query_db, dict_id=dict_id)
         result = DictTypeModel(**CamelCaseUtil.transform_result(dict_type))
 
         return result
 
     @staticmethod
-    def export_dict_type_list_services(dict_type_list: List):
+    async def export_dict_type_list_services(dict_type_list: List):
         """
         导出字典类型信息service
         :param dict_type_list: 字典信息列表
@@ -154,7 +154,7 @@ class DictTypeService:
         return binary_data
 
     @classmethod
-    async def refresh_sys_dict_services(cls, request: Request, query_db: Session):
+    async def refresh_sys_dict_services(cls, request: Request, query_db: AsyncSession):
         """
         刷新字典缓存信息service
         :param request: Request对象
@@ -173,7 +173,7 @@ class DictDataService:
     """
 
     @classmethod
-    def get_dict_data_list_services(cls, query_db: Session, query_object: DictDataPageQueryModel, is_page: bool = False):
+    async def get_dict_data_list_services(cls, query_db: AsyncSession, query_object: DictDataPageQueryModel, is_page: bool = False):
         """
         获取字典数据列表信息service
         :param query_db: orm对象
@@ -181,24 +181,24 @@ class DictDataService:
         :param is_page: 是否开启分页
         :return: 字典数据列表信息对象
         """
-        dict_data_list_result = DictDataDao.get_dict_data_list(query_db, query_object, is_page)
+        dict_data_list_result = await DictDataDao.get_dict_data_list(query_db, query_object, is_page)
 
         return dict_data_list_result
 
     @classmethod
-    def query_dict_data_list_services(cls, query_db: Session, dict_type: str):
+    async def query_dict_data_list_services(cls, query_db: AsyncSession, dict_type: str):
         """
         获取字典数据列表信息service
         :param query_db: orm对象
         :param dict_type: 字典类型
         :return: 字典数据列表信息对象
         """
-        dict_data_list_result = DictDataDao.query_dict_data_list(query_db, dict_type)
+        dict_data_list_result = await DictDataDao.query_dict_data_list(query_db, dict_type)
 
         return dict_data_list_result
 
     @classmethod
-    async def init_cache_sys_dict_services(cls, query_db: Session, redis):
+    async def init_cache_sys_dict_services(cls, query_db: AsyncSession, redis):
         """
         应用初始化：获取所有字典类型对应的字典数据信息并缓存service
         :param query_db: orm对象
@@ -210,10 +210,10 @@ class DictDataService:
         # 删除匹配的键
         if keys:
             await redis.delete(*keys)
-        dict_type_all = DictTypeDao.get_all_dict_type(query_db)
+        dict_type_all = await DictTypeDao.get_all_dict_type(query_db)
         for dict_type_obj in [item for item in dict_type_all if item.status == '0']:
             dict_type = dict_type_obj.dict_type
-            dict_data_list = DictDataDao.query_dict_data_list(query_db, dict_type)
+            dict_data_list = await DictDataDao.query_dict_data_list(query_db, dict_type)
             dict_data = [CamelCaseUtil.transform_result(row) for row in dict_data_list if row]
             await redis.set(f"{RedisInitKeyConfig.SYS_DICT.get('key')}:{dict_type}", json.dumps(dict_data, ensure_ascii=False, default=str))
 
@@ -233,7 +233,7 @@ class DictDataService:
         return CamelCaseUtil.transform_result(result)
 
     @classmethod
-    async def add_dict_data_services(cls, request: Request, query_db: Session, page_object: DictDataModel):
+    async def add_dict_data_services(cls, request: Request, query_db: AsyncSession, page_object: DictDataModel):
         """
         新增字典数据信息service
         :param request: Request对象
@@ -241,23 +241,23 @@ class DictDataService:
         :param page_object: 新增岗位对象
         :return: 新增字典数据校验结果
         """
-        dict_data = DictDataDao.get_dict_data_detail_by_info(query_db, page_object)
+        dict_data = await DictDataDao.get_dict_data_detail_by_info(query_db, page_object)
         if dict_data:
             result = dict(is_success=False, message='字典数据已存在')
         else:
             try:
-                DictDataDao.add_dict_data_dao(query_db, page_object)
-                query_db.commit()
+                await DictDataDao.add_dict_data_dao(query_db, page_object)
+                await query_db.commit()
                 await cls.init_cache_sys_dict_services(query_db, request.app.state.redis)
                 result = dict(is_success=True, message='新增成功')
             except Exception as e:
-                query_db.rollback()
+                await query_db.rollback()
                 raise e
 
         return CrudResponseModel(**result)
 
     @classmethod
-    async def edit_dict_data_services(cls, request: Request, query_db: Session, page_object: DictDataModel):
+    async def edit_dict_data_services(cls, request: Request, query_db: AsyncSession, page_object: DictDataModel):
         """
         编辑字典数据信息service
         :param request: Request对象
@@ -266,20 +266,20 @@ class DictDataService:
         :return: 编辑字典数据校验结果
         """
         edit_data_type = page_object.model_dump(exclude_unset=True)
-        dict_data_info = cls.dict_data_detail_services(query_db, edit_data_type.get('dict_code'))
+        dict_data_info = await cls.dict_data_detail_services(query_db, edit_data_type.get('dict_code'))
         if dict_data_info:
             if dict_data_info.dict_type != page_object.dict_type or dict_data_info.dict_label != page_object.dict_label or dict_data_info.dict_value != page_object.dict_value:
-                dict_data = DictDataDao.get_dict_data_detail_by_info(query_db, page_object)
+                dict_data = await DictDataDao.get_dict_data_detail_by_info(query_db, page_object)
                 if dict_data:
                     result = dict(is_success=False, message='字典数据已存在')
                     return CrudResponseModel(**result)
             try:
-                DictDataDao.edit_dict_data_dao(query_db, edit_data_type)
-                query_db.commit()
+                await DictDataDao.edit_dict_data_dao(query_db, edit_data_type)
+                await query_db.commit()
                 await cls.init_cache_sys_dict_services(query_db, request.app.state.redis)
                 result = dict(is_success=True, message='更新成功')
             except Exception as e:
-                query_db.rollback()
+                await query_db.rollback()
                 raise e
         else:
             result = dict(is_success=False, message='字典数据不存在')
@@ -287,7 +287,7 @@ class DictDataService:
         return CrudResponseModel(**result)
 
     @classmethod
-    async def delete_dict_data_services(cls, request: Request, query_db: Session, page_object: DeleteDictDataModel):
+    async def delete_dict_data_services(cls, request: Request, query_db: AsyncSession, page_object: DeleteDictDataModel):
         """
         删除字典数据信息service
         :param request: Request对象
@@ -299,32 +299,32 @@ class DictDataService:
             dict_code_list = page_object.dict_codes.split(',')
             try:
                 for dict_code in dict_code_list:
-                    DictDataDao.delete_dict_data_dao(query_db, DictDataModel(dictCode=dict_code))
-                query_db.commit()
+                    await DictDataDao.delete_dict_data_dao(query_db, DictDataModel(dictCode=dict_code))
+                await query_db.commit()
                 await cls.init_cache_sys_dict_services(query_db, request.app.state.redis)
                 result = dict(is_success=True, message='删除成功')
             except Exception as e:
-                query_db.rollback()
+                await query_db.rollback()
                 raise e
         else:
             result = dict(is_success=False, message='传入字典数据id为空')
         return CrudResponseModel(**result)
 
     @classmethod
-    def dict_data_detail_services(cls, query_db: Session, dict_code: int):
+    async def dict_data_detail_services(cls, query_db: AsyncSession, dict_code: int):
         """
         获取字典数据详细信息service
         :param query_db: orm对象
         :param dict_code: 字典数据id
         :return: 字典数据id对应的信息
         """
-        dict_data = DictDataDao.get_dict_data_detail_by_id(query_db, dict_code=dict_code)
+        dict_data = await DictDataDao.get_dict_data_detail_by_id(query_db, dict_code=dict_code)
         result = DictDataModel(**CamelCaseUtil.transform_result(dict_data))
 
         return result
 
     @staticmethod
-    def export_dict_data_list_services(dict_data_list: List):
+    async def export_dict_data_list_services(dict_data_list: List):
         """
         导出字典数据信息service
         :param dict_data_list: 字典数据信息列表

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

@@ -10,7 +10,7 @@ class JobLogService:
     """
 
     @classmethod
-    def get_job_log_list_services(cls, query_db: Session, query_object: JobLogPageQueryModel, is_page: bool = False):
+    async def get_job_log_list_services(cls, query_db: AsyncSession, query_object: JobLogPageQueryModel, is_page: bool = False):
         """
         获取定时任务日志列表信息service
         :param query_db: orm对象
@@ -18,7 +18,7 @@ class JobLogService:
         :param is_page: 是否开启分页
         :return: 定时任务日志列表信息对象
         """
-        job_log_list_result = JobLogDao.get_job_log_list(query_db, query_object, is_page)
+        job_log_list_result = await JobLogDao.get_job_log_list(query_db, query_object, is_page)
 
         return job_log_list_result
 
@@ -41,7 +41,7 @@ class JobLogService:
         return CrudResponseModel(**result)
 
     @classmethod
-    def delete_job_log_services(cls, query_db: Session, page_object: DeleteJobLogModel):
+    async def delete_job_log_services(cls, query_db: AsyncSession, page_object: DeleteJobLogModel):
         """
         删除定时任务日志信息service
         :param query_db: orm对象
@@ -52,29 +52,29 @@ class JobLogService:
             job_log_id_list = page_object.job_log_ids.split(',')
             try:
                 for job_log_id in job_log_id_list:
-                    JobLogDao.delete_job_log_dao(query_db, JobLogModel(jobLogId=job_log_id))
-                query_db.commit()
+                    await JobLogDao.delete_job_log_dao(query_db, JobLogModel(jobLogId=job_log_id))
+                await query_db.commit()
                 result = dict(is_success=True, message='删除成功')
             except Exception as e:
-                query_db.rollback()
+                await query_db.rollback()
                 raise e
         else:
             result = dict(is_success=False, message='传入定时任务日志id为空')
         return CrudResponseModel(**result)
 
     @classmethod
-    def clear_job_log_services(cls, query_db: Session):
+    async def clear_job_log_services(cls, query_db: AsyncSession):
         """
         清除定时任务日志信息service
         :param query_db: orm对象
         :return: 清除定时任务日志校验结果
         """
         try:
-            JobLogDao.clear_job_log_dao(query_db)
-            query_db.commit()
+            await JobLogDao.clear_job_log_dao(query_db)
+            await query_db.commit()
             result = dict(is_success=True, message='清除成功')
         except Exception as e:
-            query_db.rollback()
+            await query_db.rollback()
             raise e
 
         return CrudResponseModel(**result)

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

@@ -11,7 +11,7 @@ class JobService:
     """
 
     @classmethod
-    def get_job_list_services(cls, query_db: Session, query_object: JobPageQueryModel, is_page: bool = False):
+    async def get_job_list_services(cls, query_db: AsyncSession, query_object: JobPageQueryModel, is_page: bool = False):
         """
         获取定时任务列表信息service
         :param query_db: orm对象
@@ -19,37 +19,37 @@ class JobService:
         :param is_page: 是否开启分页
         :return: 定时任务列表信息对象
         """
-        job_list_result = JobDao.get_job_list(query_db, query_object, is_page)
+        job_list_result = await JobDao.get_job_list(query_db, query_object, is_page)
 
         return job_list_result
 
     @classmethod
-    def add_job_services(cls, query_db: Session, page_object: JobModel):
+    async def add_job_services(cls, query_db: AsyncSession, page_object: JobModel):
         """
         新增定时任务信息service
         :param query_db: orm对象
         :param page_object: 新增定时任务对象
         :return: 新增定时任务校验结果
         """
-        job = JobDao.get_job_detail_by_info(query_db, page_object)
+        job = await JobDao.get_job_detail_by_info(query_db, page_object)
         if job:
             result = dict(is_success=False, message='定时任务已存在')
         else:
             try:
-                JobDao.add_job_dao(query_db, page_object)
-                job_info = JobDao.get_job_detail_by_info(query_db, page_object)
+                await JobDao.add_job_dao(query_db, page_object)
+                job_info = await JobDao.get_job_detail_by_info(query_db, page_object)
                 if job_info.status == '0':
                     SchedulerUtil.add_scheduler_job(job_info=job_info)
-                query_db.commit()
+                await query_db.commit()
                 result = dict(is_success=True, message='新增成功')
             except Exception as e:
-                query_db.rollback()
+                await query_db.rollback()
                 raise e
 
         return CrudResponseModel(**result)
 
     @classmethod
-    def edit_job_services(cls, query_db: Session, page_object: EditJobModel):
+    async def edit_job_services(cls, query_db: AsyncSession, page_object: EditJobModel):
         """
         编辑定时任务信息service
         :param query_db: orm对象
@@ -59,25 +59,25 @@ class JobService:
         edit_job = page_object.model_dump(exclude_unset=True)
         if page_object.type == 'status':
             del edit_job['type']
-        job_info = cls.job_detail_services(query_db, edit_job.get('job_id'))
+        job_info = await cls.job_detail_services(query_db, edit_job.get('job_id'))
         if job_info:
             if page_object.type != 'status' and (job_info.job_name != page_object.job_name or job_info.job_group != page_object.job_group or job_info.invoke_target != page_object.invoke_target or job_info.cron_expression != page_object.cron_expression):
-                job = JobDao.get_job_detail_by_info(query_db, page_object)
+                job = await JobDao.get_job_detail_by_info(query_db, page_object)
                 if job:
                     result = dict(is_success=False, message='定时任务已存在')
                     return CrudResponseModel(**result)
             try:
-                JobDao.edit_job_dao(query_db, edit_job)
+                await JobDao.edit_job_dao(query_db, edit_job)
                 query_job = SchedulerUtil.get_scheduler_job(job_id=edit_job.get('job_id'))
                 if query_job:
                     SchedulerUtil.remove_scheduler_job(job_id=edit_job.get('job_id'))
                 if edit_job.get('status') == '0':
-                    job_info = cls.job_detail_services(query_db, edit_job.get('job_id'))
+                    job_info = await cls.job_detail_services(query_db, edit_job.get('job_id'))
                     SchedulerUtil.add_scheduler_job(job_info=job_info)
-                query_db.commit()
+                await query_db.commit()
                 result = dict(is_success=True, message='更新成功')
             except Exception as e:
-                query_db.rollback()
+                await query_db.rollback()
                 raise e
         else:
             result = dict(is_success=False, message='定时任务不存在')
@@ -85,7 +85,7 @@ class JobService:
         return CrudResponseModel(**result)
 
     @classmethod
-    def execute_job_once_services(cls, query_db: Session, page_object: JobModel):
+    async def execute_job_once_services(cls, query_db: AsyncSession, page_object: JobModel):
         """
         执行一次定时任务service
         :param query_db: orm对象
@@ -95,7 +95,7 @@ class JobService:
         query_job = SchedulerUtil.get_scheduler_job(job_id=page_object.job_id)
         if query_job:
             SchedulerUtil.remove_scheduler_job(job_id=page_object.job_id)
-        job_info = cls.job_detail_services(query_db, page_object.job_id)
+        job_info = await cls.job_detail_services(query_db, page_object.job_id)
         if job_info:
             SchedulerUtil.execute_scheduler_job_once(job_info=job_info)
             result = dict(is_success=True, message='执行成功')
@@ -105,7 +105,7 @@ class JobService:
         return CrudResponseModel(**result)
 
     @classmethod
-    def delete_job_services(cls, query_db: Session, page_object: DeleteJobModel):
+    async def delete_job_services(cls, query_db: AsyncSession, page_object: DeleteJobModel):
         """
         删除定时任务信息service
         :param query_db: orm对象
@@ -116,25 +116,25 @@ class JobService:
             job_id_list = page_object.job_ids.split(',')
             try:
                 for job_id in job_id_list:
-                    JobDao.delete_job_dao(query_db, JobModel(jobId=job_id))
-                query_db.commit()
+                    await JobDao.delete_job_dao(query_db, JobModel(jobId=job_id))
+                await query_db.commit()
                 result = dict(is_success=True, message='删除成功')
             except Exception as e:
-                query_db.rollback()
+                await query_db.rollback()
                 raise e
         else:
             result = dict(is_success=False, message='传入定时任务id为空')
         return CrudResponseModel(**result)
 
     @classmethod
-    def job_detail_services(cls, query_db: Session, job_id: int):
+    async def job_detail_services(cls, query_db: AsyncSession, job_id: int):
         """
         获取定时任务详细信息service
         :param query_db: orm对象
         :param job_id: 定时任务id
         :return: 定时任务id对应的信息
         """
-        job = JobDao.get_job_detail_by_id(query_db, job_id=job_id)
+        job = await JobDao.get_job_detail_by_id(query_db, job_id=job_id)
         result = JobModel(**CamelCaseUtil.transform_result(job))
 
         return result

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

@@ -10,7 +10,7 @@ class OperationLogService:
     """
 
     @classmethod
-    def get_operation_log_list_services(cls, query_db: Session, query_object: OperLogPageQueryModel, is_page: bool = False):
+    async def get_operation_log_list_services(cls, query_db: AsyncSession, query_object: OperLogPageQueryModel, is_page: bool = False):
         """
         获取操作日志列表信息service
         :param query_db: orm对象
@@ -18,12 +18,12 @@ class OperationLogService:
         :param is_page: 是否开启分页
         :return: 操作日志列表信息对象
         """
-        operation_log_list_result = OperationLogDao.get_operation_log_list(query_db, query_object, is_page)
+        operation_log_list_result = await OperationLogDao.get_operation_log_list(query_db, query_object, is_page)
 
         return operation_log_list_result
 
     @classmethod
-    def add_operation_log_services(cls, query_db: Session, page_object: OperLogModel):
+    async def add_operation_log_services(cls, query_db: AsyncSession, page_object: OperLogModel):
         """
         新增操作日志service
         :param query_db: orm对象
@@ -31,17 +31,17 @@ class OperationLogService:
         :return: 新增操作日志校验结果
         """
         try:
-            OperationLogDao.add_operation_log_dao(query_db, page_object)
-            query_db.commit()
+            await OperationLogDao.add_operation_log_dao(query_db, page_object)
+            await query_db.commit()
             result = dict(is_success=True, message='新增成功')
         except Exception as e:
-            query_db.rollback()
+            await query_db.rollback()
             result = dict(is_success=False, message=str(e))
 
         return CrudResponseModel(**result)
 
     @classmethod
-    def delete_operation_log_services(cls, query_db: Session, page_object: DeleteOperLogModel):
+    async def delete_operation_log_services(cls, query_db: AsyncSession, page_object: DeleteOperLogModel):
         """
         删除操作日志信息service
         :param query_db: orm对象
@@ -52,29 +52,29 @@ class OperationLogService:
             oper_id_list = page_object.oper_ids.split(',')
             try:
                 for oper_id in oper_id_list:
-                    OperationLogDao.delete_operation_log_dao(query_db, OperLogModel(operId=oper_id))
-                query_db.commit()
+                    await OperationLogDao.delete_operation_log_dao(query_db, OperLogModel(operId=oper_id))
+                await query_db.commit()
                 result = dict(is_success=True, message='删除成功')
             except Exception as e:
-                query_db.rollback()
+                await query_db.rollback()
                 raise e
         else:
             result = dict(is_success=False, message='传入操作日志id为空')
         return CrudResponseModel(**result)
 
     @classmethod
-    def clear_operation_log_services(cls, query_db: Session):
+    async def clear_operation_log_services(cls, query_db: AsyncSession):
         """
         清除操作日志信息service
         :param query_db: orm对象
         :return: 清除操作日志校验结果
         """
         try:
-            OperationLogDao.clear_operation_log_dao(query_db)
-            query_db.commit()
+            await OperationLogDao.clear_operation_log_dao(query_db)
+            await query_db.commit()
             result = dict(is_success=True, message='清除成功')
         except Exception as e:
-            query_db.rollback()
+            await query_db.rollback()
             raise e
 
         return CrudResponseModel(**result)
@@ -132,7 +132,7 @@ class LoginLogService:
     """
 
     @classmethod
-    def get_login_log_list_services(cls, query_db: Session, query_object: LoginLogPageQueryModel, is_page: bool = False):
+    async def get_login_log_list_services(cls, query_db: AsyncSession, query_object: LoginLogPageQueryModel, is_page: bool = False):
         """
         获取登录日志列表信息service
         :param query_db: orm对象
@@ -140,12 +140,12 @@ class LoginLogService:
         :param is_page: 是否开启分页
         :return: 登录日志列表信息对象
         """
-        operation_log_list_result = LoginLogDao.get_login_log_list(query_db, query_object, is_page)
+        operation_log_list_result = await LoginLogDao.get_login_log_list(query_db, query_object, is_page)
 
         return operation_log_list_result
 
     @classmethod
-    def add_login_log_services(cls, query_db: Session, page_object: LogininforModel):
+    async def add_login_log_services(cls, query_db: AsyncSession, page_object: LogininforModel):
         """
         新增登录日志service
         :param query_db: orm对象
@@ -153,17 +153,17 @@ class LoginLogService:
         :return: 新增登录日志校验结果
         """
         try:
-            LoginLogDao.add_login_log_dao(query_db, page_object)
-            query_db.commit()
+            await LoginLogDao.add_login_log_dao(query_db, page_object)
+            await query_db.commit()
             result = dict(is_success=True, message='新增成功')
         except Exception as e:
-            query_db.rollback()
+            await query_db.rollback()
             result = dict(is_success=False, message=str(e))
 
         return CrudResponseModel(**result)
 
     @classmethod
-    def delete_login_log_services(cls, query_db: Session, page_object: DeleteLoginLogModel):
+    async def delete_login_log_services(cls, query_db: AsyncSession, page_object: DeleteLoginLogModel):
         """
         删除操作日志信息service
         :param query_db: orm对象
@@ -174,29 +174,29 @@ class LoginLogService:
             info_id_list = page_object.info_ids.split(',')
             try:
                 for info_id in info_id_list:
-                    LoginLogDao.delete_login_log_dao(query_db, LogininforModel(infoId=info_id))
-                query_db.commit()
+                    await LoginLogDao.delete_login_log_dao(query_db, LogininforModel(infoId=info_id))
+                await query_db.commit()
                 result = dict(is_success=True, message='删除成功')
             except Exception as e:
-                query_db.rollback()
+                await query_db.rollback()
                 raise e
         else:
             result = dict(is_success=False, message='传入登录日志id为空')
         return CrudResponseModel(**result)
 
     @classmethod
-    def clear_login_log_services(cls, query_db: Session):
+    async def clear_login_log_services(cls, query_db: AsyncSession):
         """
         清除操作日志信息service
         :param query_db: orm对象
         :return: 清除操作日志校验结果
         """
         try:
-            LoginLogDao.clear_login_log_dao(query_db)
-            query_db.commit()
+            await LoginLogDao.clear_login_log_dao(query_db)
+            await query_db.commit()
             result = dict(is_success=True, message='清除成功')
         except Exception as e:
-            query_db.rollback()
+            await query_db.rollback()
             raise e
 
         return CrudResponseModel(**result)
@@ -212,7 +212,7 @@ class LoginLogService:
         return CrudResponseModel(**result)
 
     @staticmethod
-    def export_login_log_list_services(login_log_list: List):
+    async def export_login_log_list_services(login_log_list: List):
         """
         导出登录日志信息service
         :param login_log_list: 登录日志信息列表

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

@@ -48,7 +48,7 @@ class LoginService:
     登录模块服务层
     """
     @classmethod
-    async def authenticate_user(cls, request: Request, query_db: Session, login_user: UserLogin):
+    async def authenticate_user(cls, request: Request, query_db: AsyncSession, login_user: UserLogin):
         """
         根据用户名密码校验用户登录
         :param request: Request对象
@@ -70,7 +70,8 @@ class LoginService:
             pass
         else:
             await cls.__check_login_captcha(request, login_user)
-        user = login_by_account(query_db, login_user.user_name)
+        user = await login_by_account(query_db, login_user.user_name)
+        print(user)
         if not user:
             logger.warning("用户不存在")
             raise LoginException(data="", message="用户不存在")
@@ -135,7 +136,7 @@ class LoginService:
         return True
 
     @classmethod
-    def create_access_token(cls, data: dict, expires_delta: Union[timedelta, None] = None):
+    async def create_access_token(cls, data: dict, expires_delta: Union[timedelta, None] = None):
         """
         根据登录信息创建当前用户token
         :param data: 登录信息
@@ -153,7 +154,7 @@ class LoginService:
 
     @classmethod
     async def get_current_user(cls, request: Request = Request, token: str = Depends(oauth2_scheme),
-                               query_db: Session = Depends(get_db)):
+                               query_db: AsyncSession = Depends(get_db)):
         """
         根据token获取当前用户信息
         :param request: Request对象
@@ -178,7 +179,7 @@ class LoginService:
         except JWTError:
             logger.warning("用户token已失效，请重新登录")
             raise AuthException(data="", message="用户token已失效，请重新登录")
-        query_user = UserDao.get_user_by_id(query_db, user_id=token_data.user_id)
+        query_user = await UserDao.get_user_by_id(query_db, user_id=token_data.user_id)
         if query_user.get('user_basic_info') is None:
             logger.warning("用户token不合法")
             raise AuthException(data="", message="用户token不合法")
@@ -221,14 +222,14 @@ class LoginService:
             raise AuthException(data="", message="用户token已失效，请重新登录")
 
     @classmethod
-    async def get_current_user_routers(cls, user_id: int, query_db: Session):
+    async def get_current_user_routers(cls, user_id: int, query_db: AsyncSession):
         """
         根据用户id获取当前用户路由信息
         :param user_id: 用户id
         :param query_db: orm对象
         :return: 当前用户路由信息对象
         """
-        query_user = UserDao.get_user_by_id(query_db, user_id=user_id)
+        query_user = await UserDao.get_user_by_id(query_db, user_id=user_id)
         user_router_menu = sorted([row for row in query_user.get('user_menu_info') if row.menu_type in ['M', 'C']], key=lambda x: x.order_num)
         user_router = cls.__generate_user_router_menu(0, user_router_menu)
         return user_router
@@ -285,7 +286,7 @@ class LoginService:
         return router_list
 
     @classmethod
-    async def register_user_services(cls, request: Request, query_db: Session, user_register: UserRegister):
+    async def register_user_services(cls, request: Request, query_db: AsyncSession, user_register: UserRegister):
         """
         用户注册services
         :param request: Request对象
@@ -313,7 +314,7 @@ class LoginService:
                     nickName=user_register.username,
                     password=PwdUtil.get_password_hash(user_register.password)
                 )
-                result = UserService.add_user_services(query_db, add_user)
+                result = await UserService.add_user_services(query_db, add_user)
                 return result
             else:
                 result = dict(is_success=False, message='注册程序已关闭，禁止注册')
@@ -323,7 +324,7 @@ class LoginService:
         return CrudResponseModel(**result)
 
     @classmethod
-    async def get_sms_code_services(cls, request: Request, query_db: Session, user: ResetUserModel):
+    async def get_sms_code_services(cls, request: Request, query_db: AsyncSession, user: ResetUserModel):
         """
         获取短信验证码service
         :param request: Request对象
@@ -335,7 +336,7 @@ class LoginService:
             f"{RedisInitKeyConfig.SMS_CODE.get('key')}:{user.session_id}")
         if redis_sms_result:
             return SmsCode(**dict(is_success=False, sms_code='', session_id='', message='短信验证码仍在有效期内'))
-        is_user = UserDao.get_user_by_name(query_db, user.user_name)
+        is_user = await UserDao.get_user_by_name(query_db, user.user_name)
         if is_user:
             sms_code = str(random.randint(100000, 999999))
             session_id = str(uuid.uuid4())
@@ -349,7 +350,7 @@ class LoginService:
         return SmsCode(**dict(is_success=False, sms_code='', session_id='', message='用户不存在'))
 
     @classmethod
-    async def forget_user_services(cls, request: Request, query_db: Session, forget_user: ResetUserModel):
+    async def forget_user_services(cls, request: Request, query_db: AsyncSession, forget_user: ResetUserModel):
         """
         用户忘记密码services
         :param request: Request对象
@@ -361,8 +362,8 @@ class LoginService:
             f"{RedisInitKeyConfig.SMS_CODE.get('key')}:{forget_user.session_id}")
         if forget_user.sms_code == redis_sms_result:
             forget_user.password = PwdUtil.get_password_hash(forget_user.password)
-            forget_user.user_id = UserDao.get_user_by_name(query_db, forget_user.user_name).user_id
-            edit_result = UserService.reset_user_services(query_db, forget_user)
+            forget_user.user_id = (await UserDao.get_user_by_name(query_db, forget_user.user_name)).user_id
+            edit_result = await UserService.reset_user_services(query_db, forget_user)
             result = edit_result.dict()
         elif not redis_sms_result:
             result = dict(is_success=False, message='短信验证码已过期')

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

@@ -12,20 +12,20 @@ class MenuService:
     """
 
     @classmethod
-    def get_menu_tree_services(cls, query_db: Session, current_user: Optional[CurrentUserModel] = None):
+    async def get_menu_tree_services(cls, query_db: AsyncSession, current_user: Optional[CurrentUserModel] = None):
         """
         获取菜单树信息service
         :param query_db: orm对象
         :param current_user: 当前用户对象
         :return: 菜单树信息对象
         """
-        menu_list_result = MenuDao.get_menu_list_for_tree(query_db, current_user.user.user_id, current_user.user.role)
+        menu_list_result = await MenuDao.get_menu_list_for_tree(query_db, current_user.user.user_id, current_user.user.role)
         menu_tree_result = cls.list_to_tree(menu_list_result)
 
         return menu_tree_result
 
     @classmethod
-    def get_role_menu_tree_services(cls, query_db: Session, role_id: int, current_user: Optional[CurrentUserModel] = None):
+    async def get_role_menu_tree_services(cls, query_db: AsyncSession, role_id: int, current_user: Optional[CurrentUserModel] = None):
         """
         根据角色id获取菜单树信息service
         :param query_db: orm对象
@@ -33,9 +33,9 @@ class MenuService:
         :param current_user: 当前用户对象
         :return: 当前角色id的菜单树信息对象
         """
-        menu_list_result = MenuDao.get_menu_list_for_tree(query_db, current_user.user.user_id, current_user.user.role)
+        menu_list_result = await MenuDao.get_menu_list_for_tree(query_db, current_user.user.user_id, current_user.user.role)
         menu_tree_result = cls.list_to_tree(menu_list_result)
-        role_menu_list = RoleDao.get_role_menu_dao(query_db, role_id)
+        role_menu_list = await RoleDao.get_role_menu_dao(query_db, role_id)
         checked_keys = [row.menu_id for row in role_menu_list]
         result = RoleMenuQueryModel(
             menus=menu_tree_result,
@@ -45,7 +45,7 @@ class MenuService:
         return result
 
     @classmethod
-    def get_menu_list_services(cls, query_db: Session, page_object: MenuQueryModel, current_user: Optional[CurrentUserModel] = None):
+    async def get_menu_list_services(cls, query_db: AsyncSession, page_object: MenuQueryModel, current_user: Optional[CurrentUserModel] = None):
         """
         获取菜单列表信息service
         :param query_db: orm对象
@@ -53,34 +53,34 @@ class MenuService:
         :param current_user: 当前用户对象
         :return: 菜单列表信息对象
         """
-        menu_list_result = MenuDao.get_menu_list(query_db, page_object, current_user.user.user_id, current_user.user.role)
+        menu_list_result = await MenuDao.get_menu_list(query_db, page_object, current_user.user.user_id, current_user.user.role)
 
         return CamelCaseUtil.transform_result(menu_list_result)
 
     @classmethod
-    def add_menu_services(cls, query_db: Session, page_object: MenuModel):
+    async def add_menu_services(cls, query_db: AsyncSession, page_object: MenuModel):
         """
         新增菜单信息service
         :param query_db: orm对象
         :param page_object: 新增菜单对象
         :return: 新增菜单校验结果
         """
-        menu = MenuDao.get_menu_detail_by_info(query_db, MenuModel(parentId=page_object.parent_id, menuName=page_object.menu_name, menuType=page_object.menu_type))
+        menu = await MenuDao.get_menu_detail_by_info(query_db, MenuModel(parentId=page_object.parent_id, menuName=page_object.menu_name, menuType=page_object.menu_type))
         if menu:
             result = dict(is_success=False, message='同一目录下不允许存在同名同类型的菜单')
         else:
             try:
-                MenuDao.add_menu_dao(query_db, page_object)
-                query_db.commit()
+                await MenuDao.add_menu_dao(query_db, page_object)
+                await query_db.commit()
                 result = dict(is_success=True, message='新增成功')
             except Exception as e:
-                query_db.rollback()
+                await query_db.rollback()
                 raise e
 
         return CrudResponseModel(**result)
 
     @classmethod
-    def edit_menu_services(cls, query_db: Session, page_object: MenuModel):
+    async def edit_menu_services(cls, query_db: AsyncSession, page_object: MenuModel):
         """
         编辑菜单信息service
         :param query_db: orm对象
@@ -88,19 +88,19 @@ class MenuService:
         :return: 编辑菜单校验结果
         """
         edit_menu = page_object.model_dump(exclude_unset=True)
-        menu_info = cls.menu_detail_services(query_db, edit_menu.get('menu_id'))
+        menu_info = await cls.menu_detail_services(query_db, edit_menu.get('menu_id'))
         if menu_info:
             if menu_info.parent_id != page_object.parent_id or menu_info.menu_name != page_object.menu_name or menu_info.menu_type != page_object.menu_type:
-                menu = MenuDao.get_menu_detail_by_info(query_db, MenuModel(parentId=page_object.parent_id, menuName=page_object.menu_name, menuType=page_object.menu_type))
+                menu = await MenuDao.get_menu_detail_by_info(query_db, MenuModel(parentId=page_object.parent_id, menuName=page_object.menu_name, menuType=page_object.menu_type))
                 if menu:
                     result = dict(is_success=False, message='同一目录下不允许存在同名同类型的菜单')
                     return CrudResponseModel(**result)
             try:
-                MenuDao.edit_menu_dao(query_db, edit_menu)
-                query_db.commit()
+                await MenuDao.edit_menu_dao(query_db, edit_menu)
+                await query_db.commit()
                 result = dict(is_success=True, message='更新成功')
             except Exception as e:
-                query_db.rollback()
+                await query_db.rollback()
                 raise e
         else:
             result = dict(is_success=False, message='菜单不存在')
@@ -108,7 +108,7 @@ class MenuService:
         return CrudResponseModel(**result)
 
     @classmethod
-    def delete_menu_services(cls, query_db: Session, page_object: DeleteMenuModel):
+    async def delete_menu_services(cls, query_db: AsyncSession, page_object: DeleteMenuModel):
         """
         删除菜单信息service
         :param query_db: orm对象
@@ -119,25 +119,25 @@ class MenuService:
             menu_id_list = page_object.menu_ids.split(',')
             try:
                 for menu_id in menu_id_list:
-                    MenuDao.delete_menu_dao(query_db, MenuModel(menuId=menu_id))
-                query_db.commit()
+                    await MenuDao.delete_menu_dao(query_db, MenuModel(menuId=menu_id))
+                await query_db.commit()
                 result = dict(is_success=True, message='删除成功')
             except Exception as e:
-                query_db.rollback()
+                await query_db.rollback()
                 raise e
         else:
             result = dict(is_success=False, message='传入菜单id为空')
         return CrudResponseModel(**result)
 
     @classmethod
-    def menu_detail_services(cls, query_db: Session, menu_id: int):
+    async def menu_detail_services(cls, query_db: AsyncSession, menu_id: int):
         """
         获取菜单详细信息service
         :param query_db: orm对象
         :param menu_id: 菜单id
         :return: 菜单id对应的信息
         """
-        menu = MenuDao.get_menu_detail_by_id(query_db, menu_id=menu_id)
+        menu = await MenuDao.get_menu_detail_by_id(query_db, menu_id=menu_id)
         result = MenuModel(**CamelCaseUtil.transform_result(menu))
 
         return result

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

@@ -9,7 +9,7 @@ class NoticeService:
     """
 
     @classmethod
-    def get_notice_list_services(cls, query_db: Session, query_object: NoticePageQueryModel, is_page: bool = True):
+    async def get_notice_list_services(cls, query_db: AsyncSession, query_object: NoticePageQueryModel, is_page: bool = True):
         """
         获取通知公告列表信息service
         :param query_db: orm对象
@@ -17,34 +17,34 @@ class NoticeService:
         :param is_page: 是否开启分页
         :return: 通知公告列表信息对象
         """
-        notice_list_result = NoticeDao.get_notice_list(query_db, query_object, is_page)
+        notice_list_result = await NoticeDao.get_notice_list(query_db, query_object, is_page)
 
         return notice_list_result
 
     @classmethod
-    def add_notice_services(cls, query_db: Session, page_object: NoticeModel):
+    async def add_notice_services(cls, query_db: AsyncSession, page_object: NoticeModel):
         """
         新增通知公告信息service
         :param query_db: orm对象
         :param page_object: 新增通知公告对象
         :return: 新增通知公告校验结果
         """
-        notice = NoticeDao.get_notice_detail_by_info(query_db, page_object)
+        notice = await NoticeDao.get_notice_detail_by_info(query_db, page_object)
         if notice:
             result = dict(is_success=False, message='通知公告已存在')
         else:
             try:
-                NoticeDao.add_notice_dao(query_db, page_object)
-                query_db.commit()
+                await NoticeDao.add_notice_dao(query_db, page_object)
+                await query_db.commit()
                 result = dict(is_success=True, message='新增成功')
             except Exception as e:
-                query_db.rollback()
+                await query_db.rollback()
                 raise e
 
         return CrudResponseModel(**result)
 
     @classmethod
-    def edit_notice_services(cls, query_db: Session, page_object: NoticeModel):
+    async def edit_notice_services(cls, query_db: AsyncSession, page_object: NoticeModel):
         """
         编辑通知公告信息service
         :param query_db: orm对象
@@ -52,19 +52,19 @@ class NoticeService:
         :return: 编辑通知公告校验结果
         """
         edit_notice = page_object.model_dump(exclude_unset=True)
-        notice_info = cls.notice_detail_services(query_db, edit_notice.get('notice_id'))
+        notice_info = await cls.notice_detail_services(query_db, edit_notice.get('notice_id'))
         if notice_info:
             if notice_info.notice_title != page_object.notice_title or notice_info.notice_type != page_object.notice_type or notice_info.notice_content != page_object.notice_content:
-                notice = NoticeDao.get_notice_detail_by_info(query_db, page_object)
+                notice = await NoticeDao.get_notice_detail_by_info(query_db, page_object)
                 if notice:
                     result = dict(is_success=False, message='通知公告已存在')
                     return CrudResponseModel(**result)
             try:
-                NoticeDao.edit_notice_dao(query_db, edit_notice)
-                query_db.commit()
+                await NoticeDao.edit_notice_dao(query_db, edit_notice)
+                await query_db.commit()
                 result = dict(is_success=True, message='更新成功')
             except Exception as e:
-                query_db.rollback()
+                await query_db.rollback()
                 raise e
         else:
             result = dict(is_success=False, message='通知公告不存在')
@@ -72,7 +72,7 @@ class NoticeService:
         return CrudResponseModel(**result)
 
     @classmethod
-    def delete_notice_services(cls, query_db: Session, page_object: DeleteNoticeModel):
+    async def delete_notice_services(cls, query_db: AsyncSession, page_object: DeleteNoticeModel):
         """
         删除通知公告信息service
         :param query_db: orm对象
@@ -83,25 +83,25 @@ class NoticeService:
             notice_id_list = page_object.notice_ids.split(',')
             try:
                 for notice_id in notice_id_list:
-                    NoticeDao.delete_notice_dao(query_db, NoticeModel(noticeId=notice_id))
-                query_db.commit()
+                    await NoticeDao.delete_notice_dao(query_db, NoticeModel(noticeId=notice_id))
+                await query_db.commit()
                 result = dict(is_success=True, message='删除成功')
             except Exception as e:
-                query_db.rollback()
+                await query_db.rollback()
                 raise e
         else:
             result = dict(is_success=False, message='传入通知公告id为空')
         return CrudResponseModel(**result)
 
     @classmethod
-    def notice_detail_services(cls, query_db: Session, notice_id: int):
+    async def notice_detail_services(cls, query_db: AsyncSession, notice_id: int):
         """
         获取通知公告详细信息service
         :param query_db: orm对象
         :param notice_id: 通知公告id
         :return: 通知公告id对应的信息
         """
-        notice = NoticeDao.get_notice_detail_by_id(query_db, notice_id=notice_id)
+        notice = await NoticeDao.get_notice_detail_by_id(query_db, notice_id=notice_id)
         result = NoticeModel(**CamelCaseUtil.transform_result(notice))
 
         return result

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

@@ -8,7 +8,7 @@ class PostService:
     岗位管理模块服务层
     """
     @classmethod
-    def get_post_list_services(cls, query_db: Session, query_object: PostPageQueryModel, is_page: bool = False):
+    async def get_post_list_services(cls, query_db: AsyncSession, query_object: PostPageQueryModel, is_page: bool = False):
         """
         获取岗位列表信息service
         :param query_db: orm对象
@@ -16,34 +16,34 @@ class PostService:
         :param is_page: 是否开启分页
         :return: 岗位列表信息对象
         """
-        post_list_result = PostDao.get_post_list(query_db, query_object, is_page)
+        post_list_result = await PostDao.get_post_list(query_db, query_object, is_page)
 
         return post_list_result
 
     @classmethod
-    def add_post_services(cls, query_db: Session, page_object: PostModel):
+    async def add_post_services(cls, query_db: AsyncSession, page_object: PostModel):
         """
         新增岗位信息service
         :param query_db: orm对象
         :param page_object: 新增岗位对象
         :return: 新增岗位校验结果
         """
-        post = PostDao.get_post_detail_by_info(query_db, PostModel(postName=page_object.post_name))
+        post = await PostDao.get_post_detail_by_info(query_db, PostModel(postName=page_object.post_name))
         if post:
             result = dict(is_success=False, message='岗位名称已存在')
         else:
             try:
-                PostDao.add_post_dao(query_db, page_object)
-                query_db.commit()
+                await PostDao.add_post_dao(query_db, page_object)
+                await query_db.commit()
                 result = dict(is_success=True, message='新增成功')
             except Exception as e:
-                query_db.rollback()
+                await query_db.rollback()
                 raise e
 
         return CrudResponseModel(**result)
 
     @classmethod
-    def edit_post_services(cls, query_db: Session, page_object: PostModel):
+    async def edit_post_services(cls, query_db: AsyncSession, page_object: PostModel):
         """
         编辑岗位信息service
         :param query_db: orm对象
@@ -51,19 +51,19 @@ class PostService:
         :return: 编辑岗位校验结果
         """
         edit_post = page_object.model_dump(exclude_unset=True)
-        post_info = cls.post_detail_services(query_db, edit_post.get('post_id'))
+        post_info = await cls.post_detail_services(query_db, edit_post.get('post_id'))
         if post_info:
             if post_info.post_name != page_object.post_name:
-                post = PostDao.get_post_detail_by_info(query_db, PostModel(postName=page_object.post_name))
+                post = await PostDao.get_post_detail_by_info(query_db, PostModel(postName=page_object.post_name))
                 if post:
                     result = dict(is_success=False, message='岗位名称已存在')
                     return CrudResponseModel(**result)
             try:
-                PostDao.edit_post_dao(query_db, edit_post)
-                query_db.commit()
+                await PostDao.edit_post_dao(query_db, edit_post)
+                await query_db.commit()
                 result = dict(is_success=True, message='更新成功')
             except Exception as e:
-                query_db.rollback()
+                await query_db.rollback()
                 raise e
         else:
             result = dict(is_success=False, message='岗位不存在')
@@ -71,7 +71,7 @@ class PostService:
         return CrudResponseModel(**result)
 
     @classmethod
-    def delete_post_services(cls, query_db: Session, page_object: DeletePostModel):
+    async def delete_post_services(cls, query_db: AsyncSession, page_object: DeletePostModel):
         """
         删除岗位信息service
         :param query_db: orm对象
@@ -82,31 +82,31 @@ class PostService:
             post_id_list = page_object.post_ids.split(',')
             try:
                 for post_id in post_id_list:
-                    PostDao.delete_post_dao(query_db, PostModel(postId=post_id))
-                query_db.commit()
+                    await PostDao.delete_post_dao(query_db, PostModel(postId=post_id))
+                await query_db.commit()
                 result = dict(is_success=True, message='删除成功')
             except Exception as e:
-                query_db.rollback()
+                await query_db.rollback()
                 raise e
         else:
             result = dict(is_success=False, message='传入岗位id为空')
         return CrudResponseModel(**result)
 
     @classmethod
-    def post_detail_services(cls, query_db: Session, post_id: int):
+    async def post_detail_services(cls, query_db: AsyncSession, post_id: int):
         """
         获取岗位详细信息service
         :param query_db: orm对象
         :param post_id: 岗位id
         :return: 岗位id对应的信息
         """
-        post = PostDao.get_post_detail_by_id(query_db, post_id=post_id)
+        post = await PostDao.get_post_detail_by_id(query_db, post_id=post_id)
         result = PostModel(**CamelCaseUtil.transform_result(post))
 
         return result
 
     @staticmethod
-    def export_post_list_services(post_list: List):
+    async def export_post_list_services(post_list: List):
         """
         导出岗位信息service
         :param post_list: 岗位信息列表

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

@@ -12,25 +12,25 @@ class RoleService:
     """
 
     @classmethod
-    def get_role_select_option_services(cls, query_db: Session):
+    async def get_role_select_option_services(cls, query_db: AsyncSession):
         """
         获取角色列表不分页信息service
         :param query_db: orm对象
         :return: 角色列表不分页信息对象
         """
-        role_list_result = RoleDao.get_role_select_option_dao(query_db)
+        role_list_result = await RoleDao.get_role_select_option_dao(query_db)
 
         return CamelCaseUtil.transform_result(role_list_result)
 
     @classmethod
-    def get_role_dept_tree_services(cls, query_db: Session, role_id: int):
+    async def get_role_dept_tree_services(cls, query_db: AsyncSession, role_id: int):
         """
         根据角色id获取部门树信息service
         :param query_db: orm对象
         :param role_id: 角色id
         :return: 当前角色id的部门树信息对象
         """
-        role_dept_list = RoleDao.get_role_dept_dao(query_db, role_id)
+        role_dept_list = await RoleDao.get_role_dept_dao(query_db, role_id)
         checked_keys = [row.dept_id for row in role_dept_list]
         result = RoleDeptQueryModel(
             checkedKeys=checked_keys
@@ -39,7 +39,7 @@ class RoleService:
         return result
 
     @classmethod
-    def get_role_list_services(cls, query_db: Session, query_object: RolePageQueryModel, is_page: bool = False):
+    async def get_role_list_services(cls, query_db: AsyncSession, query_object: RolePageQueryModel, is_page: bool = False):
         """
         获取角色列表信息service
         :param query_db: orm对象
@@ -47,12 +47,12 @@ class RoleService:
         :param is_page: 是否开启分页
         :return: 角色列表信息对象
         """
-        role_list_result = RoleDao.get_role_list(query_db, query_object, is_page)
+        role_list_result = await RoleDao.get_role_list(query_db, query_object, is_page)
 
         return role_list_result
 
     @classmethod
-    def add_role_services(cls, query_db: Session, page_object: AddRoleModel):
+    async def add_role_services(cls, query_db: AsyncSession, page_object: AddRoleModel):
         """
         新增角色信息service
         :param query_db: orm对象
@@ -60,29 +60,29 @@ class RoleService:
         :return: 新增角色校验结果
         """
         add_role = RoleModel(**page_object.model_dump(by_alias=True))
-        role_name = RoleDao.get_role_by_info(query_db, RoleModel(roleName=page_object.role_name))
-        role_key = RoleDao.get_role_by_info(query_db, RoleModel(roleKey=page_object.role_key))
+        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='权限字符已存在')
         else:
             try:
-                add_result = RoleDao.add_role_dao(query_db, add_role)
+                add_result = await RoleDao.add_role_dao(query_db, add_role)
                 role_id = add_result.role_id
                 if page_object.menu_ids:
                     for menu in page_object.menu_ids:
-                        RoleDao.add_role_menu_dao(query_db, RoleMenuModel(roleId=role_id, menuId=menu))
-                query_db.commit()
+                        await RoleDao.add_role_menu_dao(query_db, RoleMenuModel(roleId=role_id, menuId=menu))
+                await query_db.commit()
                 result = dict(is_success=True, message='新增成功')
             except Exception as e:
-                query_db.rollback()
+                await query_db.rollback()
                 raise e
 
         return CrudResponseModel(**result)
 
     @classmethod
-    def edit_role_services(cls, query_db: Session, page_object: AddRoleModel):
+    async def edit_role_services(cls, query_db: AsyncSession, page_object: AddRoleModel):
         """
         编辑角色信息service
         :param query_db: orm对象
@@ -94,29 +94,29 @@ class RoleService:
             del edit_role['menu_ids']
         if page_object.type == 'status':
             del edit_role['type']
-        role_info = 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 page_object.type != 'status' and role_info.role_name != page_object.role_name:
-                role_name = RoleDao.get_role_by_info(query_db, RoleModel(roleName=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 = RoleDao.get_role_by_info(query_db, RoleModel(roleKey=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:
-                RoleDao.edit_role_dao(query_db, edit_role)
+                await RoleDao.edit_role_dao(query_db, edit_role)
                 if page_object.type != 'status':
-                    RoleDao.delete_role_menu_dao(query_db, RoleMenuModel(roleId=page_object.role_id))
+                    await RoleDao.delete_role_menu_dao(query_db, RoleMenuModel(roleId=page_object.role_id))
                     if page_object.menu_ids:
                         for menu in page_object.menu_ids:
-                            RoleDao.add_role_menu_dao(query_db, RoleMenuModel(roleId=page_object.role_id, menuId=menu))
-                query_db.commit()
+                            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='更新成功')
             except Exception as e:
-                query_db.rollback()
+                await query_db.rollback()
                 raise e
         else:
             result = dict(is_success=False, message='角色不存在')
@@ -124,7 +124,7 @@ class RoleService:
         return CrudResponseModel(**result)
 
     @classmethod
-    def role_datascope_services(cls, query_db: Session, page_object: AddRoleModel):
+    async def role_datascope_services(cls, query_db: AsyncSession, page_object: AddRoleModel):
         """
         分配角色数据权限service
         :param query_db: orm对象
@@ -133,28 +133,28 @@ class RoleService:
         """
         edit_role = page_object.model_dump(exclude_unset=True, exclude={'admin'})
         del edit_role['dept_ids']
-        role_info = 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.role_name != page_object.role_name:
-                role_name = RoleDao.get_role_by_info(query_db, RoleModel(roleName=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 = RoleDao.get_role_by_info(query_db, RoleModel(roleKey=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:
-                RoleDao.edit_role_dao(query_db, edit_role)
-                RoleDao.delete_role_dept_dao(query_db, RoleDeptModel(roleId=page_object.role_id))
+                await RoleDao.edit_role_dao(query_db, edit_role)
+                await RoleDao.delete_role_dept_dao(query_db, RoleDeptModel(roleId=page_object.role_id))
                 if page_object.dept_ids and page_object.data_scope == '2':
                     for dept in page_object.dept_ids:
-                        RoleDao.add_role_dept_dao(query_db, RoleDeptModel(roleId=page_object.role_id, deptId=dept))
-                query_db.commit()
+                        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='分配成功')
             except Exception as e:
-                query_db.rollback()
+                await query_db.rollback()
                 raise e
         else:
             result = dict(is_success=False, message='角色不存在')
@@ -162,7 +162,7 @@ class RoleService:
         return CrudResponseModel(**result)
 
     @classmethod
-    def delete_role_services(cls, query_db: Session, page_object: DeleteRoleModel):
+    async def delete_role_services(cls, query_db: AsyncSession, page_object: DeleteRoleModel):
         """
         删除角色信息service
         :param query_db: orm对象
@@ -174,32 +174,32 @@ class RoleService:
             try:
                 for role_id in role_id_list:
                     role_id_dict = dict(roleId=role_id, updateBy=page_object.update_by, updateTime=page_object.update_time)
-                    RoleDao.delete_role_menu_dao(query_db, RoleMenuModel(**role_id_dict))
-                    RoleDao.delete_role_dao(query_db, RoleModel(**role_id_dict))
-                query_db.commit()
+                    await RoleDao.delete_role_menu_dao(query_db, RoleMenuModel(**role_id_dict))
+                    await RoleDao.delete_role_dao(query_db, RoleModel(**role_id_dict))
+                await query_db.commit()
                 result = dict(is_success=True, message='删除成功')
             except Exception as e:
-                query_db.rollback()
+                await query_db.rollback()
                 raise e
         else:
             result = dict(is_success=False, message='传入角色id为空')
         return CrudResponseModel(**result)
 
     @classmethod
-    def role_detail_services(cls, query_db: Session, role_id: int):
+    async def role_detail_services(cls, query_db: AsyncSession, role_id: int):
         """
         获取角色详细信息service
         :param query_db: orm对象
         :param role_id: 角色id
         :return: 角色id对应的信息
         """
-        role = 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))
 
         return result
 
     @staticmethod
-    def export_role_list_services(role_list: List):
+    async def export_role_list_services(role_list: List):
         """
         导出角色列表信息service
         :param role_list: 角色信息列表
@@ -232,7 +232,7 @@ class RoleService:
         return binary_data
 
     @classmethod
-    def get_role_user_allocated_list_services(cls, query_db: Session, page_object: UserRolePageQueryModel, is_page: bool = False):
+    async def get_role_user_allocated_list_services(cls, query_db: AsyncSession, page_object: UserRolePageQueryModel, is_page: bool = False):
         """
         根据角色id获取已分配用户列表
         :param query_db: orm对象
@@ -240,7 +240,7 @@ class RoleService:
         :param is_page: 是否开启分页
         :return: 已分配用户列表
         """
-        query_user_list = 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, is_page)
         allocated_list = PageResponseModel(
             **{
                 **query_user_list.model_dump(by_alias=True),
@@ -251,7 +251,7 @@ class RoleService:
         return allocated_list
 
     @classmethod
-    def get_role_user_unallocated_list_services(cls, query_db: Session, page_object: UserRolePageQueryModel, is_page: bool = False):
+    async def get_role_user_unallocated_list_services(cls, query_db: AsyncSession, page_object: UserRolePageQueryModel, is_page: bool = False):
         """
         根据角色id获取未分配用户列表
         :param query_db: orm对象
@@ -259,7 +259,7 @@ class RoleService:
         :param is_page: 是否开启分页
         :return: 未分配用户列表
         """
-        query_user_list = 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, is_page)
         unallocated_list = PageResponseModel(
             **{
                 **query_user_list.model_dump(by_alias=True),

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

@@ -13,7 +13,7 @@ class ServerService:
     """
 
     @staticmethod
-    def get_server_monitor_info():
+    async def get_server_monitor_info():
         # CPU信息
         # 获取CPU总核心数
         cpu_num = psutil.cpu_count(logical=True)

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

@@ -14,7 +14,7 @@ class UserService:
     """
 
     @classmethod
-    def get_user_list_services(cls, query_db: Session, query_object: UserPageQueryModel, data_scope_sql: str, is_page: bool = False):
+    async def get_user_list_services(cls, query_db: AsyncSession, query_object: UserPageQueryModel, data_scope_sql: str, is_page: bool = False):
         """
         获取用户列表信息service
         :param query_db: orm对象
@@ -23,7 +23,7 @@ class UserService:
         :param is_page: 是否开启分页
         :return: 用户列表信息对象
         """
-        query_result = UserDao.get_user_list(query_db, query_object, data_scope_sql, is_page)
+        query_result = await UserDao.get_user_list(query_db, query_object, data_scope_sql, is_page)
         if is_page:
             user_list_result = PageResponseModel(
                 **{
@@ -39,7 +39,7 @@ class UserService:
         return user_list_result
 
     @classmethod
-    def add_user_services(cls, query_db: Session, page_object: AddUserModel):
+    async def add_user_services(cls, query_db: AsyncSession, page_object: AddUserModel):
         """
         新增用户信息service
         :param query_db: orm对象
@@ -47,29 +47,29 @@ class UserService:
         :return: 新增用户校验结果
         """
         add_user = UserModel(**page_object.model_dump(by_alias=True))
-        user = UserDao.get_user_by_info(query_db, UserModel(userName=page_object.user_name))
+        user = await UserDao.get_user_by_info(query_db, UserModel(userName=page_object.user_name))
         if user:
             result = dict(is_success=False, message='用户名已存在')
         else:
             try:
-                add_result = UserDao.add_user_dao(query_db, add_user)
+                add_result = await UserDao.add_user_dao(query_db, add_user)
                 user_id = add_result.user_id
                 if page_object.role_ids:
                     for role in page_object.role_ids:
-                        UserDao.add_user_role_dao(query_db, UserRoleModel(userId=user_id, roleId=role))
+                        await UserDao.add_user_role_dao(query_db, UserRoleModel(userId=user_id, roleId=role))
                 if page_object.post_ids:
                     for post in page_object.post_ids:
-                        UserDao.add_user_post_dao(query_db, UserPostModel(userId=user_id, postId=post))
-                query_db.commit()
+                        await UserDao.add_user_post_dao(query_db, UserPostModel(userId=user_id, postId=post))
+                await query_db.commit()
                 result = dict(is_success=True, message='新增成功')
             except Exception as e:
-                query_db.rollback()
+                await query_db.rollback()
                 raise e
 
         return CrudResponseModel(**result)
 
     @classmethod
-    def edit_user_services(cls, query_db: Session, page_object: EditUserModel):
+    async def edit_user_services(cls, query_db: AsyncSession, page_object: EditUserModel):
         """
         编辑用户信息service
         :param query_db: orm对象
@@ -83,28 +83,28 @@ class UserService:
             del edit_user['role']
         if page_object.type == 'status' or page_object.type == 'avatar' or page_object.type == 'pwd':
             del edit_user['type']
-        user_info = cls.user_detail_services(query_db, edit_user.get('user_id'))
+        user_info = await cls.user_detail_services(query_db, edit_user.get('user_id'))
         if user_info:
             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:
-                user = UserDao.get_user_by_info(query_db, UserModel(userName=page_object.user_name))
+                user = await UserDao.get_user_by_info(query_db, UserModel(userName=page_object.user_name))
                 if user:
                     result = dict(is_success=False, message='用户名已存在')
                     return CrudResponseModel(**result)
             try:
-                UserDao.edit_user_dao(query_db, edit_user)
+                await UserDao.edit_user_dao(query_db, edit_user)
                 if page_object.type != 'status' and page_object.type != 'avatar':
-                    UserDao.delete_user_role_dao(query_db, UserRoleModel(userId=page_object.user_id))
-                    UserDao.delete_user_post_dao(query_db, UserPostModel(userId=page_object.user_id))
+                    await UserDao.delete_user_role_dao(query_db, UserRoleModel(userId=page_object.user_id))
+                    await UserDao.delete_user_post_dao(query_db, UserPostModel(userId=page_object.user_id))
                     if page_object.role_ids:
                         for role in page_object.role_ids:
-                            UserDao.add_user_role_dao(query_db, UserRoleModel(userId=page_object.user_id, roleId=role))
+                            await UserDao.add_user_role_dao(query_db, UserRoleModel(userId=page_object.user_id, roleId=role))
                     if page_object.post_ids:
                         for post in page_object.post_ids:
-                            UserDao.add_user_post_dao(query_db, UserPostModel(userId=page_object.user_id, postId=post))
-                query_db.commit()
+                            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='更新成功')
             except Exception as e:
-                query_db.rollback()
+                await query_db.rollback()
                 raise e
         else:
             result = dict(is_success=False, message='用户不存在')
@@ -112,7 +112,7 @@ class UserService:
         return CrudResponseModel(**result)
 
     @classmethod
-    def delete_user_services(cls, query_db: Session, page_object: DeleteUserModel):
+    async def delete_user_services(cls, query_db: AsyncSession, page_object: DeleteUserModel):
         """
         删除用户信息service
         :param query_db: orm对象
@@ -124,30 +124,30 @@ class UserService:
             try:
                 for user_id in user_id_list:
                     user_id_dict = dict(userId=user_id, updateBy=page_object.update_by, updateTime=page_object.update_time)
-                    UserDao.delete_user_role_dao(query_db, UserRoleModel(**user_id_dict))
-                    UserDao.delete_user_post_dao(query_db, UserPostModel(**user_id_dict))
-                    UserDao.delete_user_dao(query_db, UserModel(**user_id_dict))
-                query_db.commit()
+                    await UserDao.delete_user_role_dao(query_db, UserRoleModel(**user_id_dict))
+                    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='删除成功')
             except Exception as e:
-                query_db.rollback()
+                await query_db.rollback()
                 raise e
         else:
             result = dict(is_success=False, message='传入用户id为空')
         return CrudResponseModel(**result)
 
     @classmethod
-    def user_detail_services(cls, query_db: Session, user_id: Union[int, str]):
+    async def user_detail_services(cls, query_db: AsyncSession, user_id: Union[int, str]):
         """
         获取用户详细信息service
         :param query_db: orm对象
         :param user_id: 用户id
         :return: 用户id对应的信息
         """
-        posts = PostService.get_post_list_services(query_db, PostPageQueryModel(**{}), is_page=False)
-        roles = RoleService.get_role_select_option_services(query_db)
+        posts = await PostService.get_post_list_services(query_db, PostPageQueryModel(**{}), is_page=False)
+        roles = await RoleService.get_role_select_option_services(query_db)
         if user_id != '':
-            query_user = UserDao.get_user_detail_by_id(query_db, user_id=user_id)
+            query_user = await UserDao.get_user_detail_by_id(query_db, user_id=user_id)
             post_ids = ','.join([str(row.post_id) for row in query_user.get('user_post_info')])
             post_ids_list = [row.post_id for row in query_user.get('user_post_info')]
             role_ids = ','.join([str(row.role_id) for row in query_user.get('user_role_info')])
@@ -173,14 +173,14 @@ class UserService:
         )
 
     @classmethod
-    def user_profile_services(cls, query_db: Session, user_id: int):
+    async def user_profile_services(cls, query_db: AsyncSession, user_id: int):
         """
         获取用户详细信息service
         :param query_db: orm对象
         :param user_id: 用户id
         :return: 用户id对应的信息
         """
-        query_user = UserDao.get_user_detail_by_id(query_db, user_id=user_id)
+        query_user = await UserDao.get_user_detail_by_id(query_db, user_id=user_id)
         post_ids = ','.join([str(row.post_id) for row in query_user.get('user_post_info')])
         post_group = ','.join([row.post_name for row in query_user.get('user_post_info')])
         role_ids = ','.join([str(row.role_id) for row in query_user.get('user_role_info')])
@@ -199,7 +199,7 @@ class UserService:
         )
 
     @classmethod
-    def reset_user_services(cls, query_db: Session, page_object: ResetUserModel):
+    async def reset_user_services(cls, query_db: AsyncSession, page_object: ResetUserModel):
         """
         重置用户密码service
         :param query_db: orm对象
@@ -208,7 +208,7 @@ class UserService:
         """
         reset_user = page_object.model_dump(exclude_unset=True, exclude={'admin'})
         if page_object.old_password:
-            user = UserDao.get_user_detail_by_id(query_db, user_id=page_object.user_id).get('user_basic_info')
+            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='旧密码不正确')
                 return CrudResponseModel(**result)
@@ -218,17 +218,17 @@ class UserService:
             del reset_user['sms_code']
             del reset_user['session_id']
         try:
-            UserDao.edit_user_dao(query_db, reset_user)
-            query_db.commit()
+            await UserDao.edit_user_dao(query_db, reset_user)
+            await query_db.commit()
             result = dict(is_success=True, message='重置成功')
         except Exception as e:
-            query_db.rollback()
+            await query_db.rollback()
             raise e
 
         return CrudResponseModel(**result)
 
     @classmethod
-    async def batch_import_user_services(cls, query_db: Session, file: UploadFile, update_support: bool, current_user: CurrentUserModel):
+    async def batch_import_user_services(cls, query_db: AsyncSession, file: UploadFile, update_support: bool, current_user: CurrentUserModel):
         """
         批量导入用户service
         :param query_db: orm对象
@@ -277,7 +277,7 @@ class UserService:
                     createBy=current_user.user.user_name,
                     updateBy=current_user.user.user_name
                 )
-                user_info = UserDao.get_user_by_info(query_db, UserModel(userName=row['user_name']))
+                user_info = await UserDao.get_user_by_info(query_db, UserModel(userName=row['user_name']))
                 if user_info:
                     if update_support:
                         edit_user = UserModel(
@@ -291,21 +291,21 @@ class UserService:
                             status=row['status'],
                             updateBy=current_user.user.user_name
                         ).model_dump(exclude_unset=True)
-                        UserDao.edit_user_dao(query_db, edit_user)
+                        await UserDao.edit_user_dao(query_db, edit_user)
                     else:
                         add_error_result.append(f"{count}.用户账号{row['user_name']}已存在")
                 else:
-                    UserDao.add_user_dao(query_db, add_user)
-            query_db.commit()
+                    await UserDao.add_user_dao(query_db, add_user)
+            await query_db.commit()
             result = dict(is_success=True, message='\n'.join(add_error_result))
         except Exception as e:
-            query_db.rollback()
+            await query_db.rollback()
             raise e
 
         return CrudResponseModel(**result)
 
     @staticmethod
-    def get_user_import_template_services():
+    async def get_user_import_template_services():
         """
         获取用户导入模板service
         :return: 用户导入模板excel的二进制数据
@@ -318,7 +318,7 @@ class UserService:
         return binary_data
 
     @staticmethod
-    def export_user_list_services(user_list: List):
+    async def export_user_list_services(user_list: List):
         """
         导出用户信息service
         :param user_list: 用户信息列表
@@ -360,14 +360,14 @@ class UserService:
         return binary_data
 
     @classmethod
-    def get_user_role_allocated_list_services(cls, query_db: Session, page_object: UserRoleQueryModel):
+    async def get_user_role_allocated_list_services(cls, query_db: AsyncSession, page_object: UserRoleQueryModel):
         """
         根据用户id获取已分配角色列表
         :param query_db: orm对象
         :param page_object: 用户关联角色对象
         :return: 已分配角色列表
         """
-        query_user = UserDao.get_user_detail_by_id(query_db, page_object.user_id)
+        query_user = await UserDao.get_user_detail_by_id(query_db, page_object.user_id)
         post_ids = ','.join([str(row.post_id) for row in query_user.get('user_post_info')])
         role_ids = ','.join([str(row.role_id) for row in query_user.get('user_role_info')])
         user = UserInfoModel(
@@ -377,7 +377,7 @@ class UserService:
             dept=CamelCaseUtil.transform_result(query_user.get('user_dept_info')),
             role=CamelCaseUtil.transform_result(query_user.get('user_role_info'))
         )
-        query_role_list = [SelectedRoleModel(**row) for row in RoleService.get_role_select_option_services(query_db)]
+        query_role_list = [SelectedRoleModel(**row) for row in await RoleService.get_role_select_option_services(query_db)]
         for model_a in query_role_list:
             for model_b in user.role:
                 if model_a.role_id == model_b.role_id:
@@ -390,7 +390,7 @@ class UserService:
         return result
 
     @classmethod
-    def add_user_role_services(cls, query_db: Session, page_object: CrudUserRoleModel):
+    async def add_user_role_services(cls, query_db: AsyncSession, page_object: CrudUserRoleModel):
         """
         新增用户关联角色信息service
         :param query_db: orm对象
@@ -401,37 +401,37 @@ class UserService:
             role_id_list = page_object.role_ids.split(',')
             try:
                 for role_id in role_id_list:
-                    user_role = cls.detail_user_role_services(query_db, UserRoleModel(userId=page_object.user_id, roleId=role_id))
+                    user_role = await cls.detail_user_role_services(query_db, UserRoleModel(userId=page_object.user_id, roleId=role_id))
                     if user_role:
                         continue
                     else:
-                        UserDao.add_user_role_dao(query_db, UserRoleModel(userId=page_object.user_id, roleId=role_id))
-                query_db.commit()
+                        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='分配成功')
             except Exception as e:
-                query_db.rollback()
+                await query_db.rollback()
                 raise e
         elif page_object.user_id and not page_object.role_ids:
             try:
-                UserDao.delete_user_role_by_user_and_role_dao(query_db, UserRoleModel(userId=page_object.user_id))
-                query_db.commit()
+                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='分配成功')
             except Exception as e:
-                query_db.rollback()
+                await query_db.rollback()
                 raise e
         elif page_object.user_ids and page_object.role_id:
             user_id_list = page_object.user_ids.split(',')
             try:
                 for user_id in user_id_list:
-                    user_role = cls.detail_user_role_services(query_db, UserRoleModel(userId=user_id, roleId=page_object.role_id))
+                    user_role = await cls.detail_user_role_services(query_db, UserRoleModel(userId=user_id, roleId=page_object.role_id))
                     if user_role:
                         continue
                     else:
-                        UserDao.add_user_role_dao(query_db, UserRoleModel(userId=user_id, roleId=page_object.role_id))
-                query_db.commit()
+                        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='新增成功')
             except Exception as e:
-                query_db.rollback()
+                await query_db.rollback()
                 raise e
         else:
             result = dict(is_success=False, message='不满足新增条件')
@@ -439,7 +439,7 @@ class UserService:
         return CrudResponseModel(**result)
 
     @classmethod
-    def delete_user_role_services(cls, query_db: Session, page_object: CrudUserRoleModel):
+    async def delete_user_role_services(cls, query_db: AsyncSession, page_object: CrudUserRoleModel):
         """
         删除用户关联角色信息service
         :param query_db: orm对象
@@ -449,21 +449,21 @@ class UserService:
         if (page_object.user_id and page_object.role_id) or (page_object.user_ids and page_object.role_id):
             if page_object.user_id and page_object.role_id:
                 try:
-                    UserDao.delete_user_role_by_user_and_role_dao(query_db, UserRoleModel(userId=page_object.user_id, roleId=page_object.role_id))
-                    query_db.commit()
+                    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='删除成功')
                 except Exception as e:
-                    query_db.rollback()
+                    await query_db.rollback()
                     raise e
             elif page_object.user_ids and page_object.role_id:
                 user_id_list = page_object.user_ids.split(',')
                 try:
                     for user_id in user_id_list:
-                        UserDao.delete_user_role_by_user_and_role_dao(query_db, UserRoleModel(userId=user_id, roleId=page_object.role_id))
-                    query_db.commit()
+                        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='删除成功')
                 except Exception as e:
-                    query_db.rollback()
+                    await query_db.rollback()
                     raise e
             else:
                 result = dict(is_success=False, message='不满足删除条件')
@@ -473,13 +473,13 @@ class UserService:
         return CrudResponseModel(**result)
 
     @classmethod
-    def detail_user_role_services(cls, query_db: Session, page_object: UserRoleModel):
+    async def detail_user_role_services(cls, query_db: AsyncSession, page_object: UserRoleModel):
         """
         获取用户关联角色详细信息service
         :param query_db: orm对象
         :param page_object: 用户关联角色对象
         :return: 用户关联角色详细信息
         """
-        user_role = UserDao.get_user_role_detail(query_db, page_object)
+        user_role = await UserDao.get_user_role_detail(query_db, page_object)
 
         return user_role