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

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