!12 RuoYi-Vue3-FastAPI v1.2.1

Merge pull request !12 from insistence/develop

README.md

@@ -1,12 +1,12 @@
 <p align="center">
 	<img alt="logo" src="https://oscimg.oschina.net/oscnet/up-d3d0a9303e11d522a06cd263f3079027715.png">
 </p>
-<h1 align="center" style="margin: 30px 0 30px; font-weight: bold;">RuoYi-Vue3-FastAPI v1.1.2</h1>
+<h1 align="center" style="margin: 30px 0 30px; font-weight: bold;">RuoYi-Vue3-FastAPI v1.2.1</h1>
 <h4 align="center">基于RuoYi-Vue3+FastAPI前后端分离的快速开发框架</h4>
 <p align="center">
 	<a href="https://gitee.com/insistence2022/RuoYi-Vue3-FastAPI/stargazers"><img src="https://gitee.com/insistence2022/RuoYi-Vue3-FastAPI/badge/star.svg?theme=dark"></a>
     <a href="https://github.com/insistence/RuoYi-Vue3-FastAPI"><img src="https://img.shields.io/github/stars/insistence/RuoYi-Vue3-FastAPI?style=social"></a>
-	<a href="https://gitee.com/insistence2022/RuoYi-Vue3-FastAPI"><img src="https://img.shields.io/badge/RuoYiVue3FastAPI-v1.1.2-brightgreen.svg"></a>
+	<a href="https://gitee.com/insistence2022/RuoYi-Vue3-FastAPI"><img src="https://img.shields.io/badge/RuoYiVue3FastAPI-v1.2.1-brightgreen.svg"></a>
 	<a href="https://gitee.com/insistence2022/RuoYi-Vue3-FastAPI/blob/master/LICENSE"><img src="https://img.shields.io/github/license/mashape/apistatus.svg"></a>
     <img src="https://img.shields.io/badge/python-≥3.8-blue">
     <img src="https://img.shields.io/badge/MySQL-≥5.7-blue">
@@ -17,7 +17,6 @@
 
 
 
-
 ## 平台简介
 
 RuoYi-Vue3-FastAPI是一套全部开源的快速开发平台，毫无保留给个人及企业免费使用。

ruoyi-fastapi-backend/.env.dev

@@ -10,7 +10,7 @@ APP_HOST = '0.0.0.0'
 # 应用端口
 APP_PORT = 9099
 # 应用版本
-APP_VERSION= '1.1.2'
+APP_VERSION= '1.2.1'
 # 应用是否开启热重载
 APP_RELOAD = true
 # 应用是否开启IP归属区域查询

ruoyi-fastapi-backend/.env.prod

@@ -10,13 +10,13 @@ APP_HOST = '0.0.0.0'
 # 应用端口
 APP_PORT = 9099
 # 应用版本
-APP_VERSION= '1.1.2'
+APP_VERSION= '1.2.1'
 # 应用是否开启热重载
 APP_RELOAD = false
 # 应用是否开启IP归属区域查询
 APP_IP_LOCATION_QUERY = true
 # 应用是否允许账号同时登录
-APP_SAMETIME_LOGIN = true
+APP_SAME_TIME_LOGIN = true
 
 # -------- Jwt配置 --------
 # Jwt秘钥

ruoyi-fastapi-backend/config/database.py

@@ -1,19 +1,23 @@
-from sqlalchemy import create_engine
+from sqlalchemy.ext.asyncio import create_async_engine
-from sqlalchemy.ext.declarative import declarative_base
+from sqlalchemy.ext.asyncio import async_sessionmaker
-from sqlalchemy.orm import sessionmaker
+from sqlalchemy.ext.asyncio import AsyncAttrs
+from sqlalchemy.orm import DeclarativeBase
 from urllib.parse import quote_plus
 from config.env import DataBaseConfig
 
-SQLALCHEMY_DATABASE_URL = f"mysql+pymysql://{DataBaseConfig.db_username}:{quote_plus(DataBaseConfig.db_password)}@" \
+ASYNC_SQLALCHEMY_DATABASE_URL = f"mysql+asyncmy://{DataBaseConfig.db_username}:{quote_plus(DataBaseConfig.db_password)}@" \
                           f"{DataBaseConfig.db_host}:{DataBaseConfig.db_port}/{DataBaseConfig.db_database}"
 
-engine = create_engine(
+async_engine = create_async_engine(
-    SQLALCHEMY_DATABASE_URL,
+    ASYNC_SQLALCHEMY_DATABASE_URL,
     echo=DataBaseConfig.db_echo,
     max_overflow=DataBaseConfig.db_max_overflow,
     pool_size=DataBaseConfig.db_pool_size,
     pool_recycle=DataBaseConfig.db_pool_recycle,
     pool_timeout=DataBaseConfig.db_pool_timeout
 )
-SessionLocal = sessionmaker(autocommit=False, autoflush=False, bind=engine)
+AsyncSessionLocal = async_sessionmaker(autocommit=False, autoflush=False, bind=async_engine)
-Base = declarative_base()
+
+
+class Base(AsyncAttrs, DeclarativeBase):
+    pass

ruoyi-fastapi-backend/config/get_db.py

@@ -2,16 +2,13 @@ from config.database import *
 from utils.log_util import logger
 
 
-def get_db_pro():
+async def get_db():
     """
     每一个请求处理完毕后会关闭当前连接，不同的请求使用不同的连接
     :return:
     """
-    current_db = SessionLocal()
+    async with AsyncSessionLocal() as current_db:
-    try:
         yield current_db
-    finally:
-        current_db.close()
 
 
 async def init_create_table():
@@ -20,8 +17,6 @@ async def init_create_table():
     :return:
     """
     logger.info("初始化数据库连接...")
-    Base.metadata.create_all(bind=engine)
+    async with async_engine.begin() as conn:
+        await conn.run_sync(Base.metadata.create_all)
     logger.info("数据库连接成功")
-
-
-get_db = get_db_pro

ruoyi-fastapi-backend/config/get_redis.py

@@ -3,7 +3,7 @@ from redis.exceptions import AuthenticationError, TimeoutError, RedisError
 from module_admin.service.dict_service import DictDataService
 from module_admin.service.config_service import ConfigService
 from config.env import RedisConfig
-from config.database import SessionLocal
+from config.database import AsyncSessionLocal
 from utils.log_util import logger
 
 
@@ -59,10 +59,8 @@ class RedisUtil:
         :param redis: redis对象
         :return:
         """
-        session = SessionLocal()
+        async with AsyncSessionLocal() as session:
-        await DictDataService.init_cache_sys_dict_services(session, redis)
+            await DictDataService.init_cache_sys_dict_services(session, redis)
-
-        session.close()
 
     @classmethod
     async def init_sys_config(cls, redis):
@@ -71,7 +69,5 @@ class RedisUtil:
         :param redis: redis对象
         :return:
         """
-        session = SessionLocal()
+        async with AsyncSessionLocal() as session:
-        await ConfigService.init_cache_sys_config_services(session, redis)
+            await ConfigService.init_cache_sys_config_services(session, redis)
-
-        session.close()

ruoyi-fastapi-backend/config/get_scheduler.py

@@ -1,3 +1,4 @@
+import json
 from apscheduler.schedulers.background import BackgroundScheduler
 from apscheduler.jobstores.sqlalchemy import SQLAlchemyJobStore
 from apscheduler.jobstores.memory import MemoryJobStore
@@ -5,12 +6,13 @@ from apscheduler.jobstores.redis import RedisJobStore
 from apscheduler.executors.pool import ThreadPoolExecutor, ProcessPoolExecutor
 from apscheduler.triggers.cron import CronTrigger
 from apscheduler.events import EVENT_ALL
-import json
+from sqlalchemy.engine import create_engine
+from sqlalchemy.orm import sessionmaker
 from datetime import datetime, timedelta
-from config.database import engine, SQLALCHEMY_DATABASE_URL, SessionLocal
+from config.database import quote_plus, AsyncSessionLocal
-from config.env import RedisConfig
+from config.env import DataBaseConfig, RedisConfig
 from module_admin.service.job_log_service import JobLogService, JobLogModel
-from module_admin.dao.job_dao import Session, JobDao
+from module_admin.dao.job_dao import JobDao
 from utils.log_util import logger
 import module_task
 
@@ -65,6 +67,17 @@ class MyCronTrigger(CronTrigger):
                     diff += 1
 
 
+SQLALCHEMY_DATABASE_URL = f"mysql+pymysql://{DataBaseConfig.db_username}:{quote_plus(DataBaseConfig.db_password)}@" \
+                          f"{DataBaseConfig.db_host}:{DataBaseConfig.db_port}/{DataBaseConfig.db_database}"
+engine = create_engine(
+    SQLALCHEMY_DATABASE_URL,
+    echo=DataBaseConfig.db_echo,
+    max_overflow=DataBaseConfig.db_max_overflow,
+    pool_size=DataBaseConfig.db_pool_size,
+    pool_recycle=DataBaseConfig.db_pool_recycle,
+    pool_timeout=DataBaseConfig.db_pool_timeout
+)
+SessionLocal = sessionmaker(autocommit=False, autoflush=False, bind=engine)
 job_stores = {
     'default': MemoryJobStore(),
     'sqlalchemy': SQLAlchemyJobStore(url=SQLALCHEMY_DATABASE_URL, engine=engine),
@@ -96,20 +109,20 @@ class SchedulerUtil:
     """
 
     @classmethod
-    async def init_system_scheduler(cls, query_db: Session = SessionLocal()):
+    async def init_system_scheduler(cls):
         """
         应用启动时初始化定时任务
         :return:
         """
         logger.info("开始启动定时任务...")
         scheduler.start()
-        job_list = JobDao.get_job_list_for_scheduler(query_db)
+        async with AsyncSessionLocal() as session:
-        for item in job_list:
+            job_list = await JobDao.get_job_list_for_scheduler(session)
-            query_job = cls.get_scheduler_job(job_id=str(item.job_id))
+            for item in job_list:
-            if query_job:
+                query_job = cls.get_scheduler_job(job_id=str(item.job_id))
-                cls.remove_scheduler_job(job_id=str(item.job_id))
+                if query_job:
-            cls.add_scheduler_job(item)
+                    cls.remove_scheduler_job(job_id=str(item.job_id))
-        query_db.close()
+                cls.add_scheduler_job(item)
         scheduler.add_listener(cls.scheduler_event_listener, EVENT_ALL)
         logger.info("系统初始定时任务加载成功")
 
@@ -225,7 +238,8 @@ class SchedulerUtil:
                 jobTrigger=job_trigger,
                 jobMessage=job_message,
                 status=status,
-                exceptionInfo=exception_info
+                exceptionInfo=exception_info,
+                createTime=datetime.now()
             )
             session = SessionLocal()
             JobLogService.add_job_log_services(session, job_log)

ruoyi-fastapi-backend/exceptions/exception.py

@@ -26,3 +26,13 @@ class PermissionException(Exception):
     def __init__(self, data: str = None, message: str = None):
         self.data = data
         self.message = message
+
+
+class ModelValidatorException(Exception):
+    """
+    自定义模型校验异常ModelValidatorException
+    """
+
+    def __init__(self, data: str = None, message: str = None):
+        self.data = data
+        self.message = message

ruoyi-fastapi-backend/exceptions/handle.py

@@ -1,6 +1,6 @@
 from fastapi import FastAPI, Request
 from fastapi.exceptions import HTTPException
-from exceptions.exception import AuthException, PermissionException
+from exceptions.exception import AuthException, PermissionException, ModelValidatorException
 from utils.response_util import ResponseUtil, JSONResponse, jsonable_encoder
 
 
@@ -18,6 +18,11 @@ def handle_exception(app: FastAPI):
     async def permission_exception_handler(request: Request, exc: PermissionException):
         return ResponseUtil.forbidden(data=exc.data, msg=exc.message)
 
+    # 自定义模型检验异常
+    @app.exception_handler(ModelValidatorException)
+    async def model_validator_exception_handler(request: Request, exc: ModelValidatorException):
+        return ResponseUtil.failure(data=exc.data, msg=exc.message)
+
     # 处理其他http请求异常
     @app.exception_handler(HTTPException)
     async def http_exception_handler(request: Request, exc: HTTPException):

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

@@ -18,10 +18,10 @@ roleController = APIRouter(prefix='/system/role', dependencies=[Depends(LoginSer
 
 
 @roleController.get("/deptTree/{role_id}", dependencies=[Depends(CheckUserInterfaceAuth('system:role:query'))])
-async def get_system_role_dept_tree(request: Request, role_id: int, query_db: Session = Depends(get_db), data_scope_sql: str = Depends(GetDataScope('SysDept'))):
+async def get_system_role_dept_tree(request: Request, role_id: int, query_db: AsyncSession = Depends(get_db), data_scope_sql: str = Depends(GetDataScope('SysDept'))):
     try:
-        dept_query_result = DeptService.get_dept_tree_services(query_db, DeptModel(**{}), data_scope_sql)
+        dept_query_result = await DeptService.get_dept_tree_services(query_db, DeptModel(**{}), data_scope_sql)
-        role_dept_query_result = RoleService.get_role_dept_tree_services(query_db, role_id)
+        role_dept_query_result = await RoleService.get_role_dept_tree_services(query_db, role_id)
         role_dept_query_result.depts = dept_query_result
         logger.info('获取成功')
         return ResponseUtil.success(model_content=role_dept_query_result)
@@ -31,9 +31,9 @@ async def get_system_role_dept_tree(request: Request, role_id: int, query_db: Se
     
     
 @roleController.get("/list", response_model=PageResponseModel, dependencies=[Depends(CheckUserInterfaceAuth('system:role:list'))])
-async def get_system_role_list(request: Request, role_page_query: RolePageQueryModel = Depends(RolePageQueryModel.as_query), query_db: Session = Depends(get_db)):
+async def get_system_role_list(request: Request, role_page_query: RolePageQueryModel = Depends(RolePageQueryModel.as_query), query_db: AsyncSession = Depends(get_db)):
     try:
-        role_page_query_result = RoleService.get_role_list_services(query_db, role_page_query, is_page=True)
+        role_page_query_result = await RoleService.get_role_list_services(query_db, role_page_query, is_page=True)
         logger.info('获取成功')
         return ResponseUtil.success(model_content=role_page_query_result)
     except Exception as e:
@@ -43,11 +43,13 @@ async def get_system_role_list(request: Request, role_page_query: RolePageQueryM
     
 @roleController.post("", dependencies=[Depends(CheckUserInterfaceAuth('system:role:add'))])
 @log_decorator(title='角色管理', business_type=1)
-async def add_system_role(request: Request, add_role: AddRoleModel, query_db: Session = Depends(get_db), current_user: CurrentUserModel = Depends(LoginService.get_current_user)):
+async def add_system_role(request: Request, add_role: AddRoleModel, query_db: AsyncSession = Depends(get_db), current_user: CurrentUserModel = Depends(LoginService.get_current_user)):
     try:
         add_role.create_by = current_user.user.user_name
+        add_role.create_time = datetime.now()
         add_role.update_by = current_user.user.user_name
-        add_role_result = RoleService.add_role_services(query_db, add_role)
+        add_role.update_time = datetime.now()
+        add_role_result = await RoleService.add_role_services(query_db, add_role)
         if add_role_result.is_success:
             logger.info(add_role_result.message)
             return ResponseUtil.success(msg=add_role_result.message)
@@ -61,11 +63,11 @@ async def add_system_role(request: Request, add_role: AddRoleModel, query_db: Se
     
 @roleController.put("", dependencies=[Depends(CheckUserInterfaceAuth('system:role:edit'))])
 @log_decorator(title='角色管理', business_type=2)
-async def edit_system_role(request: Request, edit_role: AddRoleModel, query_db: Session = Depends(get_db), current_user: CurrentUserModel = Depends(LoginService.get_current_user)):
+async def edit_system_role(request: Request, edit_role: AddRoleModel, query_db: AsyncSession = Depends(get_db), current_user: CurrentUserModel = Depends(LoginService.get_current_user)):
     try:
         edit_role.update_by = current_user.user.user_name
         edit_role.update_time = datetime.now()
-        edit_role_result = RoleService.edit_role_services(query_db, edit_role)
+        edit_role_result = await RoleService.edit_role_services(query_db, edit_role)
         if edit_role_result.is_success:
             logger.info(edit_role_result.message)
             return ResponseUtil.success(msg=edit_role_result.message)
@@ -79,11 +81,11 @@ async def edit_system_role(request: Request, edit_role: AddRoleModel, query_db:
 
 @roleController.put("/dataScope", dependencies=[Depends(CheckUserInterfaceAuth('system:role:edit'))])
 @log_decorator(title='角色管理', business_type=4)
-async def edit_system_role_datascope(request: Request, role_data_scope: AddRoleModel, query_db: Session = Depends(get_db), current_user: CurrentUserModel = Depends(LoginService.get_current_user)):
+async def edit_system_role_datascope(request: Request, role_data_scope: AddRoleModel, query_db: AsyncSession = Depends(get_db), current_user: CurrentUserModel = Depends(LoginService.get_current_user)):
     try:
         role_data_scope.update_by = current_user.user.user_name
         role_data_scope.update_time = datetime.now()
-        role_data_scope_result = RoleService.role_datascope_services(query_db, role_data_scope)
+        role_data_scope_result = await RoleService.role_datascope_services(query_db, role_data_scope)
         if role_data_scope_result.is_success:
             logger.info(role_data_scope_result.message)
             return ResponseUtil.success(msg=role_data_scope_result.message)
@@ -97,14 +99,14 @@ async def edit_system_role_datascope(request: Request, role_data_scope: AddRoleM
     
 @roleController.delete("/{role_ids}", dependencies=[Depends(CheckUserInterfaceAuth('system:role:remove'))])
 @log_decorator(title='角色管理', business_type=3)
-async def delete_system_role(request: Request, role_ids: str, query_db: Session = Depends(get_db), current_user: CurrentUserModel = Depends(LoginService.get_current_user)):
+async def delete_system_role(request: Request, role_ids: str, query_db: AsyncSession = Depends(get_db), current_user: CurrentUserModel = Depends(LoginService.get_current_user)):
     try:
         delete_role = DeleteRoleModel(
             roleIds=role_ids,
             updateBy=current_user.user.user_name,
             updateTime=datetime.now()
         )
-        delete_role_result = RoleService.delete_role_services(query_db, delete_role)
+        delete_role_result = await RoleService.delete_role_services(query_db, delete_role)
         if delete_role_result.is_success:
             logger.info(delete_role_result.message)
             return ResponseUtil.success(msg=delete_role_result.message)
@@ -117,9 +119,9 @@ async def delete_system_role(request: Request, role_ids: str, query_db: Session
     
     
 @roleController.get("/{role_id}", response_model=RoleModel, dependencies=[Depends(CheckUserInterfaceAuth('system:role:query'))])
-async def query_detail_system_role(request: Request, role_id: int, query_db: Session = Depends(get_db)):
+async def query_detail_system_role(request: Request, role_id: int, query_db: AsyncSession = Depends(get_db)):
     try:
-        role_detail_result = RoleService.role_detail_services(query_db, role_id)
+        role_detail_result = await RoleService.role_detail_services(query_db, role_id)
         logger.info(f'获取role_id为{role_id}的信息成功')
         return ResponseUtil.success(data=role_detail_result.model_dump(by_alias=True))
     except Exception as e:
@@ -129,11 +131,11 @@ async def query_detail_system_role(request: Request, role_id: int, query_db: Ses
 
 @roleController.post("/export", dependencies=[Depends(CheckUserInterfaceAuth('system:role:export'))])
 @log_decorator(title='角色管理', business_type=5)
-async def export_system_role_list(request: Request, role_page_query: RolePageQueryModel = Depends(RolePageQueryModel.as_form), query_db: Session = Depends(get_db)):
+async def export_system_role_list(request: Request, role_page_query: RolePageQueryModel = Depends(RolePageQueryModel.as_form), query_db: AsyncSession = Depends(get_db)):
     try:
         # 获取全量数据
-        role_query_result = RoleService.get_role_list_services(query_db, role_page_query, is_page=False)
+        role_query_result = await RoleService.get_role_list_services(query_db, role_page_query, is_page=False)
-        role_export_result = RoleService.export_role_list_services(role_query_result)
+        role_export_result = await RoleService.export_role_list_services(role_query_result)
         logger.info('导出成功')
         return ResponseUtil.streaming(data=bytes2file_response(role_export_result))
     except Exception as e:
@@ -143,12 +145,12 @@ async def export_system_role_list(request: Request, role_page_query: RolePageQue
 
 @roleController.put("/changeStatus", dependencies=[Depends(CheckUserInterfaceAuth('system:role:edit'))])
 @log_decorator(title='角色管理', business_type=2)
-async def reset_system_role_status(request: Request, edit_role: AddRoleModel, query_db: Session = Depends(get_db), current_user: CurrentUserModel = Depends(LoginService.get_current_user)):
+async def reset_system_role_status(request: Request, edit_role: AddRoleModel, query_db: AsyncSession = Depends(get_db), current_user: CurrentUserModel = Depends(LoginService.get_current_user)):
     try:
         edit_role.update_by = current_user.user.user_name
         edit_role.update_time = datetime.now()
         edit_role.type = 'status'
-        edit_role_result = RoleService.edit_role_services(query_db, edit_role)
+        edit_role_result = await RoleService.edit_role_services(query_db, edit_role)
         if edit_role_result.is_success:
             logger.info(edit_role_result.message)
             return ResponseUtil.success(msg=edit_role_result.message)
@@ -161,9 +163,9 @@ async def reset_system_role_status(request: Request, edit_role: AddRoleModel, qu
 
 
 @roleController.get("/authUser/allocatedList", response_model=PageResponseModel, dependencies=[Depends(CheckUserInterfaceAuth('system:role:list'))])
-async def get_system_allocated_user_list(request: Request, user_role: UserRolePageQueryModel = Depends(UserRolePageQueryModel.as_query), query_db: Session = Depends(get_db)):
+async def get_system_allocated_user_list(request: Request, user_role: UserRolePageQueryModel = Depends(UserRolePageQueryModel.as_query), query_db: AsyncSession = Depends(get_db)):
     try:
-        role_user_allocated_page_query_result = RoleService.get_role_user_allocated_list_services(query_db, user_role, is_page=True)
+        role_user_allocated_page_query_result = await RoleService.get_role_user_allocated_list_services(query_db, user_role, is_page=True)
         logger.info('获取成功')
         return ResponseUtil.success(model_content=role_user_allocated_page_query_result)
     except Exception as e:
@@ -172,9 +174,9 @@ async def get_system_allocated_user_list(request: Request, user_role: UserRolePa
 
 
 @roleController.get("/authUser/unallocatedList", response_model=PageResponseModel, dependencies=[Depends(CheckUserInterfaceAuth('system:role:list'))])
-async def get_system_unallocated_user_list(request: Request, user_role: UserRolePageQueryModel = Depends(UserRolePageQueryModel.as_query), query_db: Session = Depends(get_db)):
+async def get_system_unallocated_user_list(request: Request, user_role: UserRolePageQueryModel = Depends(UserRolePageQueryModel.as_query), query_db: AsyncSession = Depends(get_db)):
     try:
-        role_user_unallocated_page_query_result = RoleService.get_role_user_unallocated_list_services(query_db, user_role, is_page=True)
+        role_user_unallocated_page_query_result = await RoleService.get_role_user_unallocated_list_services(query_db, user_role, is_page=True)
         logger.info('获取成功')
         return ResponseUtil.success(model_content=role_user_unallocated_page_query_result)
     except Exception as e:
@@ -184,9 +186,9 @@ async def get_system_unallocated_user_list(request: Request, user_role: UserRole
 
 @roleController.put("/authUser/selectAll", dependencies=[Depends(CheckUserInterfaceAuth('system:role:edit'))])
 @log_decorator(title='角色管理', business_type=4)
-async def add_system_role_user(request: Request, add_role_user: CrudUserRoleModel = Depends(CrudUserRoleModel.as_query), query_db: Session = Depends(get_db)):
+async def add_system_role_user(request: Request, add_role_user: CrudUserRoleModel = Depends(CrudUserRoleModel.as_query), query_db: AsyncSession = Depends(get_db)):
     try:
-        add_role_user_result = UserService.add_user_role_services(query_db, add_role_user)
+        add_role_user_result = await UserService.add_user_role_services(query_db, add_role_user)
         if add_role_user_result.is_success:
             logger.info(add_role_user_result.message)
             return ResponseUtil.success(msg=add_role_user_result.message)
@@ -200,9 +202,9 @@ async def add_system_role_user(request: Request, add_role_user: CrudUserRoleMode
 
 @roleController.put("/authUser/cancel", dependencies=[Depends(CheckUserInterfaceAuth('system:role:edit'))])
 @log_decorator(title='角色管理', business_type=4)
-async def cancel_system_role_user(request: Request, cancel_user_role: CrudUserRoleModel, query_db: Session = Depends(get_db)):
+async def cancel_system_role_user(request: Request, cancel_user_role: CrudUserRoleModel, query_db: AsyncSession = Depends(get_db)):
     try:
-        cancel_user_role_result = UserService.delete_user_role_services(query_db, cancel_user_role)
+        cancel_user_role_result = await UserService.delete_user_role_services(query_db, cancel_user_role)
         if cancel_user_role_result.is_success:
             logger.info(cancel_user_role_result.message)
             return ResponseUtil.success(msg=cancel_user_role_result.message)
@@ -216,9 +218,9 @@ async def cancel_system_role_user(request: Request, cancel_user_role: CrudUserRo
 
 @roleController.put("/authUser/cancelAll", dependencies=[Depends(CheckUserInterfaceAuth('system:role:edit'))])
 @log_decorator(title='角色管理', business_type=4)
-async def batch_cancel_system_role_user(request: Request, batch_cancel_user_role: CrudUserRoleModel = Depends(CrudUserRoleModel.as_query), query_db: Session = Depends(get_db)):
+async def batch_cancel_system_role_user(request: Request, batch_cancel_user_role: CrudUserRoleModel = Depends(CrudUserRoleModel.as_query), query_db: AsyncSession = Depends(get_db)):
     try:
-        batch_cancel_user_role_result = UserService.delete_user_role_services(query_db, batch_cancel_user_role)
+        batch_cancel_user_role_result = await UserService.delete_user_role_services(query_db, batch_cancel_user_role)
         if batch_cancel_user_role_result.is_success:
             logger.info(batch_cancel_user_role_result.message)
             return ResponseUtil.success(msg=batch_cancel_user_role_result.message)

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

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

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

@@ -19,9 +19,9 @@ userController = APIRouter(prefix='/system/user', dependencies=[Depends(LoginSer
 
 
 @userController.get("/deptTree", dependencies=[Depends(CheckUserInterfaceAuth('system:user:list'))])
-async def get_system_dept_tree(request: Request, query_db: Session = Depends(get_db), data_scope_sql: str = Depends(GetDataScope('SysDept'))):
+async def get_system_dept_tree(request: Request, query_db: AsyncSession = Depends(get_db), data_scope_sql: str = Depends(GetDataScope('SysDept'))):
     try:
-        dept_query_result = DeptService.get_dept_tree_services(query_db, DeptModel(**{}), data_scope_sql)
+        dept_query_result = await DeptService.get_dept_tree_services(query_db, DeptModel(**{}), data_scope_sql)
         logger.info('获取成功')
         return ResponseUtil.success(data=dept_query_result)
     except Exception as e:
@@ -30,10 +30,10 @@ async def get_system_dept_tree(request: Request, query_db: Session = Depends(get
 
 
 @userController.get("/list", response_model=PageResponseModel, dependencies=[Depends(CheckUserInterfaceAuth('system:user:list'))])
-async def get_system_user_list(request: Request, user_page_query: UserPageQueryModel = Depends(UserPageQueryModel.as_query), query_db: Session = Depends(get_db), data_scope_sql: str = Depends(GetDataScope('SysUser'))):
+async def get_system_user_list(request: Request, user_page_query: UserPageQueryModel = Depends(UserPageQueryModel.as_query), query_db: AsyncSession = Depends(get_db), data_scope_sql: str = Depends(GetDataScope('SysUser'))):
     try:
         # 获取分页数据
-        user_page_query_result = UserService.get_user_list_services(query_db, user_page_query, data_scope_sql, is_page=True)
+        user_page_query_result = await UserService.get_user_list_services(query_db, user_page_query, data_scope_sql, is_page=True)
         logger.info('获取成功')
         return ResponseUtil.success(model_content=user_page_query_result)
     except Exception as e:
@@ -43,12 +43,14 @@ async def get_system_user_list(request: Request, user_page_query: UserPageQueryM
 
 @userController.post("", dependencies=[Depends(CheckUserInterfaceAuth('system:user:add'))])
 @log_decorator(title='用户管理', business_type=1)
-async def add_system_user(request: Request, add_user: AddUserModel, query_db: Session = Depends(get_db), current_user: CurrentUserModel = Depends(LoginService.get_current_user)):
+async def add_system_user(request: Request, add_user: AddUserModel, query_db: AsyncSession = Depends(get_db), current_user: CurrentUserModel = Depends(LoginService.get_current_user)):
     try:
         add_user.password = PwdUtil.get_password_hash(add_user.password)
         add_user.create_by = current_user.user.user_name
+        add_user.create_time = datetime.now()
         add_user.update_by = current_user.user.user_name
-        add_user_result = UserService.add_user_services(query_db, add_user)
+        add_user.update_time = datetime.now()
+        add_user_result = await UserService.add_user_services(query_db, add_user)
         if add_user_result.is_success:
             logger.info(add_user_result.message)
             return ResponseUtil.success(msg=add_user_result.message)
@@ -62,11 +64,11 @@ async def add_system_user(request: Request, add_user: AddUserModel, query_db: Se
 
 @userController.put("", dependencies=[Depends(CheckUserInterfaceAuth('system:user:edit'))])
 @log_decorator(title='用户管理', business_type=2)
-async def edit_system_user(request: Request, edit_user: EditUserModel, query_db: Session = Depends(get_db), current_user: CurrentUserModel = Depends(LoginService.get_current_user)):
+async def edit_system_user(request: Request, edit_user: EditUserModel, query_db: AsyncSession = Depends(get_db), current_user: CurrentUserModel = Depends(LoginService.get_current_user)):
     try:
         edit_user.update_by = current_user.user.user_name
         edit_user.update_time = datetime.now()
-        edit_user_result = UserService.edit_user_services(query_db, edit_user)
+        edit_user_result = await UserService.edit_user_services(query_db, edit_user)
         if edit_user_result.is_success:
             logger.info(edit_user_result.message)
             return ResponseUtil.success(msg=edit_user_result.message)
@@ -80,14 +82,14 @@ async def edit_system_user(request: Request, edit_user: EditUserModel, query_db:
 
 @userController.delete("/{user_ids}", dependencies=[Depends(CheckUserInterfaceAuth('system:user:remove'))])
 @log_decorator(title='用户管理', business_type=3)
-async def delete_system_user(request: Request, user_ids: str, query_db: Session = Depends(get_db), current_user: CurrentUserModel = Depends(LoginService.get_current_user)):
+async def delete_system_user(request: Request, user_ids: str, query_db: AsyncSession = Depends(get_db), current_user: CurrentUserModel = Depends(LoginService.get_current_user)):
     try:
         delete_user = DeleteUserModel(
             userIds=user_ids,
             updateBy=current_user.user.user_name,
             updateTime=datetime.now()
         )
-        delete_user_result = UserService.delete_user_services(query_db, delete_user)
+        delete_user_result = await UserService.delete_user_services(query_db, delete_user)
         if delete_user_result.is_success:
             logger.info(delete_user_result.message)
             return ResponseUtil.success(msg=delete_user_result.message)
@@ -101,13 +103,13 @@ async def delete_system_user(request: Request, user_ids: str, query_db: Session
 
 @userController.put("/resetPwd", dependencies=[Depends(CheckUserInterfaceAuth('system:user:resetPwd'))])
 @log_decorator(title='用户管理', business_type=2)
-async def reset_system_user_pwd(request: Request, edit_user: EditUserModel, query_db: Session = Depends(get_db), current_user: CurrentUserModel = Depends(LoginService.get_current_user)):
+async def reset_system_user_pwd(request: Request, edit_user: EditUserModel, query_db: AsyncSession = Depends(get_db), current_user: CurrentUserModel = Depends(LoginService.get_current_user)):
     try:
         edit_user.password = PwdUtil.get_password_hash(edit_user.password)
         edit_user.update_by = current_user.user.user_name
         edit_user.update_time = datetime.now()
         edit_user.type = 'pwd'
-        edit_user_result = UserService.edit_user_services(query_db, edit_user)
+        edit_user_result = await UserService.edit_user_services(query_db, edit_user)
         if edit_user_result.is_success:
             logger.info(edit_user_result.message)
             return ResponseUtil.success(msg=edit_user_result.message)
@@ -121,12 +123,12 @@ async def reset_system_user_pwd(request: Request, edit_user: EditUserModel, quer
 
 @userController.put("/changeStatus", dependencies=[Depends(CheckUserInterfaceAuth('system:user:edit'))])
 @log_decorator(title='用户管理', business_type=2)
-async def change_system_user_status(request: Request, edit_user: EditUserModel, query_db: Session = Depends(get_db), current_user: CurrentUserModel = Depends(LoginService.get_current_user)):
+async def change_system_user_status(request: Request, edit_user: EditUserModel, query_db: AsyncSession = Depends(get_db), current_user: CurrentUserModel = Depends(LoginService.get_current_user)):
     try:
         edit_user.update_by = current_user.user.user_name
         edit_user.update_time = datetime.now()
         edit_user.type = 'status'
-        edit_user_result = UserService.edit_user_services(query_db, edit_user)
+        edit_user_result = await UserService.edit_user_services(query_db, edit_user)
         if edit_user_result.is_success:
             logger.info(edit_user_result.message)
             return ResponseUtil.success(msg=edit_user_result.message)
@@ -139,9 +141,9 @@ async def change_system_user_status(request: Request, edit_user: EditUserModel,
 
 
 @userController.get("/profile", response_model=UserProfileModel)
-async def query_detail_system_user(request: Request, query_db: Session = Depends(get_db), current_user: CurrentUserModel = Depends(LoginService.get_current_user)):
+async def query_detail_system_user(request: Request, query_db: AsyncSession = Depends(get_db), current_user: CurrentUserModel = Depends(LoginService.get_current_user)):
     try:
-        profile_user_result = UserService.user_profile_services(query_db, current_user.user.user_id)
+        profile_user_result = await UserService.user_profile_services(query_db, current_user.user.user_id)
         logger.info(f'获取user_id为{current_user.user.user_id}的信息成功')
         return ResponseUtil.success(model_content=profile_user_result)
     except Exception as e:
@@ -151,9 +153,9 @@ async def query_detail_system_user(request: Request, query_db: Session = Depends
 
 @userController.get("/{user_id}", response_model=UserDetailModel, dependencies=[Depends(CheckUserInterfaceAuth('system:user:query'))])
 @userController.get("/", response_model=UserDetailModel, dependencies=[Depends(CheckUserInterfaceAuth('system:user:query'))])
-async def query_detail_system_user(request: Request, user_id: Optional[Union[int, str]] = '', query_db: Session = Depends(get_db), current_user: CurrentUserModel = Depends(LoginService.get_current_user)):
+async def query_detail_system_user(request: Request, user_id: Optional[Union[int, str]] = '', query_db: AsyncSession = Depends(get_db), current_user: CurrentUserModel = Depends(LoginService.get_current_user)):
     try:
-        detail_user_result = UserService.user_detail_services(query_db, user_id)
+        detail_user_result = await UserService.user_detail_services(query_db, user_id)
         logger.info(f'获取user_id为{user_id}的信息成功')
         return ResponseUtil.success(model_content=detail_user_result)
     except Exception as e:
@@ -163,7 +165,7 @@ async def query_detail_system_user(request: Request, user_id: Optional[Union[int
 
 @userController.post("/profile/avatar")
 @log_decorator(title='个人信息', business_type=2)
-async def change_system_user_profile_avatar(request: Request, avatarfile: bytes = File(), query_db: Session = Depends(get_db), current_user: CurrentUserModel = Depends(LoginService.get_current_user)):
+async def change_system_user_profile_avatar(request: Request, avatarfile: bytes = File(), query_db: AsyncSession = Depends(get_db), current_user: CurrentUserModel = Depends(LoginService.get_current_user)):
     try:
         relative_path = f'avatar/{datetime.now().strftime("%Y")}/{datetime.now().strftime("%m")}/{datetime.now().strftime("%d")}'
         dir_path = os.path.join(UploadConfig.UPLOAD_PATH, relative_path)
@@ -182,7 +184,7 @@ async def change_system_user_profile_avatar(request: Request, avatarfile: bytes
             updateTime=datetime.now(),
             type='avatar'
         )
-        edit_user_result = UserService.edit_user_services(query_db, edit_user)
+        edit_user_result = await UserService.edit_user_services(query_db, edit_user)
         if edit_user_result.is_success:
             logger.info(edit_user_result.message)
             return ResponseUtil.success(dict_content={'imgUrl': edit_user.avatar}, msg=edit_user_result.message)
@@ -196,14 +198,23 @@ async def change_system_user_profile_avatar(request: Request, avatarfile: bytes
 
 @userController.put("/profile")
 @log_decorator(title='个人信息', business_type=2)
-async def change_system_user_profile_info(request: Request, user_info: UserInfoModel, query_db: Session = Depends(get_db), current_user: CurrentUserModel = Depends(LoginService.get_current_user)):
+async def change_system_user_profile_info(request: Request, user_info: UserInfoModel, query_db: AsyncSession = Depends(get_db), current_user: CurrentUserModel = Depends(LoginService.get_current_user)):
     try:
-        edit_user = EditUserModel(**user_info.model_dump(by_alias=True, exclude={'role_ids', 'post_ids'}), roleIds=user_info.role_ids.split(','), postIds=user_info.post_ids.split(','))
+        edit_user = EditUserModel(
-        edit_user.user_id = current_user.user.user_id
+            **user_info.model_dump(
-        edit_user.update_by = current_user.user.user_name
+                exclude_unset=True,
-        edit_user.update_time = datetime.now()
+                by_alias=True,
-        print(edit_user.model_dump())
+                exclude={'role_ids', 'post_ids'}
-        edit_user_result = UserService.edit_user_services(query_db, edit_user)
+            ),
+            userId=current_user.user.user_id,
+            userName=current_user.user.user_name,
+            updateBy=current_user.user.user_name,
+            updateTime=datetime.now(),
+            roleIds=current_user.user.role_ids.split(',') if current_user.user.role_ids else [],
+            postIds=current_user.user.post_ids.split(',') if current_user.user.post_ids else [],
+            role=current_user.user.role
+        )
+        edit_user_result = await UserService.edit_user_services(query_db, edit_user)
         if edit_user_result.is_success:
             logger.info(edit_user_result.message)
             return ResponseUtil.success(msg=edit_user_result.message)
@@ -217,16 +228,16 @@ async def change_system_user_profile_info(request: Request, user_info: UserInfoM
 
 @userController.put("/profile/updatePwd")
 @log_decorator(title='个人信息', business_type=2)
-async def reset_system_user_password(request: Request, old_password: str = Query(alias='oldPassword'), new_password: str = Query(alias='newPassword'), query_db: Session = Depends(get_db), current_user: CurrentUserModel = Depends(LoginService.get_current_user)):
+async def reset_system_user_password(request: Request, reset_password: ResetPasswordModel = Depends(ResetPasswordModel.as_query), query_db: AsyncSession = Depends(get_db), current_user: CurrentUserModel = Depends(LoginService.get_current_user)):
     try:
         reset_user = ResetUserModel(
             userId=current_user.user.user_id,
-            oldPassword=old_password,
+            oldPassword=reset_password.old_password,
-            password=PwdUtil.get_password_hash(new_password),
+            password=PwdUtil.get_password_hash(reset_password.new_password),
             updateBy=current_user.user.user_name,
             updateTime=datetime.now()
         )
-        reset_user_result = UserService.reset_user_services(query_db, reset_user)
+        reset_user_result = await UserService.reset_user_services(query_db, reset_user)
         if reset_user_result.is_success:
             logger.info(reset_user_result.message)
             return ResponseUtil.success(msg=reset_user_result.message)
@@ -240,7 +251,7 @@ async def reset_system_user_password(request: Request, old_password: str = Query
 
 @userController.post("/importData", dependencies=[Depends(CheckUserInterfaceAuth('system:user:import'))])
 @log_decorator(title='用户管理', business_type=6)
-async def batch_import_system_user(request: Request, file: UploadFile = File(...), update_support: bool = Query(alias='updateSupport'), query_db: Session = Depends(get_db), current_user: CurrentUserModel = Depends(LoginService.get_current_user)):
+async def batch_import_system_user(request: Request, file: UploadFile = File(...), update_support: bool = Query(alias='updateSupport'), query_db: AsyncSession = Depends(get_db), current_user: CurrentUserModel = Depends(LoginService.get_current_user)):
     try:
         batch_import_result = await UserService.batch_import_user_services(query_db, file, update_support, current_user)
         if batch_import_result.is_success:
@@ -255,9 +266,9 @@ async def batch_import_system_user(request: Request, file: UploadFile = File(...
 
 
 @userController.post("/importTemplate", dependencies=[Depends(CheckUserInterfaceAuth('system:user:import'))])
-async def export_system_user_template(request: Request, query_db: Session = Depends(get_db)):
+async def export_system_user_template(request: Request, query_db: AsyncSession = Depends(get_db)):
     try:
-        user_import_template_result = UserService.get_user_import_template_services()
+        user_import_template_result = await UserService.get_user_import_template_services()
         logger.info('获取成功')
         return ResponseUtil.streaming(data=bytes2file_response(user_import_template_result))
     except Exception as e:
@@ -267,11 +278,11 @@ async def export_system_user_template(request: Request, query_db: Session = Depe
 
 @userController.post("/export", dependencies=[Depends(CheckUserInterfaceAuth('system:user:export'))])
 @log_decorator(title='用户管理', business_type=5)
-async def export_system_user_list(request: Request, user_page_query: UserPageQueryModel = Depends(UserPageQueryModel.as_form), query_db: Session = Depends(get_db), data_scope_sql: str = Depends(GetDataScope('SysUser'))):
+async def export_system_user_list(request: Request, user_page_query: UserPageQueryModel = Depends(UserPageQueryModel.as_form), query_db: AsyncSession = Depends(get_db), data_scope_sql: str = Depends(GetDataScope('SysUser'))):
     try:
         # 获取全量数据
-        user_query_result = UserService.get_user_list_services(query_db, user_page_query, data_scope_sql, is_page=False)
+        user_query_result = await UserService.get_user_list_services(query_db, user_page_query, data_scope_sql, is_page=False)
-        user_export_result = UserService.export_user_list_services(user_query_result)
+        user_export_result = await UserService.export_user_list_services(user_query_result)
         logger.info('导出成功')
         return ResponseUtil.streaming(data=bytes2file_response(user_export_result))
     except Exception as e:
@@ -280,10 +291,10 @@ async def export_system_user_list(request: Request, user_page_query: UserPageQue
 
 
 @userController.get("/authRole/{user_id}", response_model=UserRoleResponseModel, dependencies=[Depends(CheckUserInterfaceAuth('system:user:query'))])
-async def get_system_allocated_role_list(request: Request, user_id: int, query_db: Session = Depends(get_db)):
+async def get_system_allocated_role_list(request: Request, user_id: int, query_db: AsyncSession = Depends(get_db)):
     try:
         user_role_query = UserRoleQueryModel(userId=user_id)
-        user_role_allocated_query_result = UserService.get_user_role_allocated_list_services(query_db, user_role_query)
+        user_role_allocated_query_result = await UserService.get_user_role_allocated_list_services(query_db, user_role_query)
         logger.info('获取成功')
         return ResponseUtil.success(model_content=user_role_allocated_query_result)
     except Exception as e:
@@ -292,9 +303,9 @@ async def get_system_allocated_role_list(request: Request, user_id: int, query_d
 
 
 @userController.put("/authRole", response_model=UserRoleResponseModel, dependencies=[Depends(CheckUserInterfaceAuth('system:user:edit'))])
-async def update_system_role_user(request: Request, user_id: int = Query(alias='userId'), role_ids: str = Query(alias='roleIds'), query_db: Session = Depends(get_db)):
+async def update_system_role_user(request: Request, user_id: int = Query(alias='userId'), role_ids: str = Query(alias='roleIds'), query_db: AsyncSession = Depends(get_db)):
     try:
-        add_user_role_result = UserService.add_user_role_services(query_db, CrudUserRoleModel(userId=user_id, roleIds=role_ids))
+        add_user_role_result = await UserService.add_user_role_services(query_db, CrudUserRoleModel(userId=user_id, roleIds=role_ids))
         if add_user_role_result.is_success:
             logger.info(add_user_role_result.message)
             return ResponseUtil.success(msg=add_user_role_result.message)

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

@@ -1,6 +1,9 @@
-from pydantic import BaseModel, ConfigDict
+import re
+from pydantic import BaseModel, ConfigDict, model_validator
 from pydantic.alias_generators import to_camel
-from typing import Optional
+from typing import Optional, List, Union
+from exceptions.exception import ModelValidatorException
+from module_admin.entity.vo.menu_vo import MenuModel
 
 
 class UserLogin(BaseModel):
@@ -23,6 +26,14 @@ class UserRegister(BaseModel):
     code: Optional[str] = None
     uuid: Optional[str] = None
 
+    @model_validator(mode='after')
+    def check_password(self) -> 'UserRegister':
+        pattern = r'''^[^<>"'|\\]+$'''
+        if self.password is None or re.match(pattern, self.password):
+            return self
+        else:
+            raise ModelValidatorException(message="密码不能包含非法字符：< > \" ' \\ |")
+
 
 class Token(BaseModel):
     access_token: str
@@ -42,4 +53,31 @@ class SmsCode(BaseModel):
     is_success: Optional[bool] = None
     sms_code: str
     session_id: str
-    message: Optional[str] = None
+    message: Optional[str] = None
+
+
+class MenuTreeModel(MenuModel):
+    children: Optional[Union[List['MenuTreeModel'], None]] = None
+
+
+class MetaModel(BaseModel):
+    model_config = ConfigDict(alias_generator=to_camel)
+
+    title: Optional[str] = None
+    icon: Optional[str] = None
+    no_cache: Optional[bool] = None
+    link: Optional[str] = None
+
+
+class RouterModel(BaseModel):
+    model_config = ConfigDict(alias_generator=to_camel)
+
+    name: Optional[str] = None
+    path: Optional[str] = None
+    hidden: Optional[bool] = None
+    redirect: Optional[str] = None
+    component: Optional[str] = None
+    query: Optional[str] = None
+    always_show: Optional[bool] = None
+    meta: Optional[MetaModel] = None
+    children: Optional[Union[List['RouterModel'], None]] = None

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

@@ -1,3 +1,4 @@
+import re
 from pydantic import BaseModel, ConfigDict, model_validator
 from pydantic.alias_generators import to_camel
 from typing import Union, Optional, List
@@ -6,6 +7,7 @@ from module_admin.entity.vo.role_vo import RoleModel
 from module_admin.entity.vo.dept_vo import DeptModel
 from module_admin.entity.vo.post_vo import PostModel
 from module_admin.annotation.pydantic_annotation import as_query, as_form
+from exceptions.exception import ModelValidatorException
 
 
 class TokenData(BaseModel):
@@ -42,6 +44,14 @@ class UserModel(BaseModel):
     remark: Optional[str] = None
     admin: Optional[bool] = False
 
+    @model_validator(mode='after')
+    def check_password(self) -> 'UserModel':
+        pattern = r'''^[^<>"'|\\]+$'''
+        if self.password is None or re.match(pattern, self.password):
+            return self
+        else:
+            raise ModelValidatorException(message="密码不能包含非法字符：< > \" ' \\ |")
+
     @model_validator(mode='after')
     def check_admin(self) -> 'UserModel':
         if self.user_id == 1:
@@ -144,6 +154,25 @@ class EditUserModel(AddUserModel):
     role: Optional[List] = []
 
 
+@as_query
+class ResetPasswordModel(BaseModel):
+    """
+    重置密码模型
+    """
+    model_config = ConfigDict(alias_generator=to_camel)
+
+    old_password: Optional[str] = None
+    new_password: Optional[str] = None
+
+    @model_validator(mode='after')
+    def check_new_password(self) -> 'ResetPasswordModel':
+        pattern = r'''^[^<>"'|\\]+$'''
+        if self.new_password is None or re.match(pattern, self.new_password):
+            return self
+        else:
+            raise ModelValidatorException(message="密码不能包含非法字符：< > \" ' \\ |")
+
+
 class ResetUserModel(UserModel):
     """
     重置用户密码模型

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)
+                await ConfigDao.add_config_dao(query_db, page_object)
-                query_db.commit()
+                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)
+                await ConfigDao.edit_config_dao(query_db, edit_config)
-                query_db.commit()
+                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))
+                    await ConfigDao.delete_config_dao(query_db, ConfigModel(configId=config_id))
-                query_db.commit()
+                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,
+        dept = await DeptDao.get_dept_detail_by_info(query_db, DeptModel(parentId=page_object.parent_id,
-                                                                   deptName=page_object.dept_name))
+                                                                         deptName=page_object.dept_name))
         if dept:
             result = dict(is_success=False, message='同一部门下不允许存在同名的部门')
         else:
             try:
-                DeptDao.add_dept_dao(query_db, page_object)
+                await DeptDao.add_dept_dao(query_db, page_object)
-                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_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,
+                dept = await DeptDao.get_dept_detail_by_info(query_db, DeptModel(parentId=page_object.parent_id,
-                                                                           deptName=page_object.dept_name))
+                                                                                 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)
+                await DeptDao.edit_dept_dao(query_db, edit_dept)
-                cls.update_children_info(query_db, DeptModel(deptId=page_object.dept_id,
+                await cls.update_children_info(query_db, DeptModel(deptId=page_object.dept_id,
-                                                             ancestors=page_object.ancestors,
+                                                                   ancestors=page_object.ancestors,
-                                                             updateBy=page_object.update_by,
+                                                                   updateBy=page_object.update_by,
-                                                             updateTime=page_object.update_time
+                                                                   updateTime=page_object.update_time
-                                                             )
+                                                                   )
-                                         )
+                                               )
-                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='部门不存在')
@@ -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))
+                    await DeptDao.delete_dept_dao(query_db, DeptModel(deptId=dept_id))
-                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='传入部门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,
+                await DeptDao.edit_dept_dao(query_db,
-                                      dict(dept_id=child.dept_id,
+                                            dict(dept_id=child.dept_id,
-                                           ancestors=child.ancestors,
+                                                 ancestors=child.ancestors,
-                                           update_by=page_object.update_by,
+                                                 update_by=page_object.update_by,
-                                           update_time=page_object.update_time
+                                                 update_time=page_object.update_time
-                                           )
+                                                 )
-                                      )
+                                            )
-                cls.update_children_info(query_db, DeptModel(dept_id=child.dept_id,
+                await cls.update_children_info(query_db, DeptModel(dept_id=child.dept_id,
-                                                             ancestors=child.ancestors,
+                                                                   ancestors=child.ancestors,
-                                                             update_by=page_object.update_by,
+                                                                   update_by=page_object.update_by,
-                                                             update_time=page_object.update_time
+                                                                   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)
+                await DictTypeDao.add_dict_type_dao(query_db, page_object)
-                query_db.commit()
+                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)
+                    query_dict_data = await DictDataModel(dictType=dict_type_info.dict_type)
-                    dict_data_list = DictDataDao.get_dict_data_list(query_db, query_dict_data)
+                    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)
+                        await DictDataDao.edit_dict_data_dao(query_db, edit_dict_data)
-                DictTypeDao.edit_dict_type_dao(query_db, edit_dict_type)
+                await DictTypeDao.edit_dict_type_dao(query_db, edit_dict_type)
-                query_db.commit()
+                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))
+                    await DictTypeDao.delete_dict_type_dao(query_db, DictTypeModel(dictId=dict_id))
-                query_db.commit()
+                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)
+                await DictDataDao.add_dict_data_dao(query_db, page_object)
-                query_db.commit()
+                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)
+                await DictDataDao.edit_dict_data_dao(query_db, edit_data_type)
-                query_db.commit()
+                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))
+                    await DictDataDao.delete_dict_data_dao(query_db, DictDataModel(dictCode=dict_code))
-                query_db.commit()
+                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))
+                    await JobLogDao.delete_job_log_dao(query_db, JobLogModel(jobLogId=job_log_id))
-                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='传入定时任务日志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)
+            await JobLogDao.clear_job_log_dao(query_db)
-            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)

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)
+                await JobDao.add_job_dao(query_db, page_object)
-                job_info = JobDao.get_job_detail_by_info(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))
+                    await JobDao.delete_job_dao(query_db, JobModel(jobId=job_id))
-                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='传入定时任务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)
+            await OperationLogDao.add_operation_log_dao(query_db, page_object)
-            query_db.commit()
+            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))
+                    await OperationLogDao.delete_operation_log_dao(query_db, OperLogModel(operId=oper_id))
-                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='传入操作日志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)
+            await OperationLogDao.clear_operation_log_dao(query_db)
-            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)
@@ -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)
+            await LoginLogDao.add_login_log_dao(query_db, page_object)
-            query_db.commit()
+            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))
+                    await LoginLogDao.delete_login_log_dao(query_db, LogininforModel(infoId=info_id))
-                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='传入登录日志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)
+            await LoginLogDao.clear_login_log_dao(query_db)
-            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)
@@ -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

@@ -24,6 +24,7 @@ class CustomOAuth2PasswordRequestForm(OAuth2PasswordRequestForm):
     """
     自定义OAuth2PasswordRequestForm类，增加验证码及会话编号参数
     """
+
     def __init__(
             self,
             grant_type: str = Form(default=None, regex="password"),
@@ -47,8 +48,9 @@ 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 +72,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 +138,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 +156,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 +181,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,71 +224,109 @@ 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)
+        menus = cls.__generate_menus(0, user_router_menu)
-        return user_router
+        user_router = cls.__generate_user_router_menu(menus)
+        return [router.model_dump(exclude_unset=True, by_alias=True) for router in user_router]
 
     @classmethod
-    def __generate_user_router_menu(cls, pid: int, permission_list):
+    def __generate_menus(cls, pid: int, permission_list: List[SysMenu]):
         """
-        工具方法：根据菜单信息生成路由信息树形嵌套数据
+        工具方法：根据菜单信息生成菜单信息树形嵌套数据
         :param pid: 菜单id
         :param permission_list: 菜单列表信息
-        :return: 路由信息树形嵌套数据
+        :return: 菜单信息树形嵌套数据
         """
-        router_list = []
+        menu_list: List[MenuTreeModel] = []
         for permission in permission_list:
             if permission.parent_id == pid:
-                children = cls.__generate_user_router_menu(permission.menu_id, permission_list)
+                children = cls.__generate_menus(permission.menu_id, permission_list)
-                router_list_data = {}
+                menu_list_data = MenuTreeModel(**CamelCaseUtil.transform_result(permission))
-                if permission.menu_type == 'M':
+                if children:
-                    router_list_data['name'] = permission.path.capitalize()
+                    menu_list_data.children = children
-                    router_list_data['hidden'] = False if permission.visible == '0' else True
+                menu_list.append(menu_list_data)
-                    if permission.parent_id == 0:
+
-                        router_list_data['component'] = 'Layout'
+        return menu_list
-                        router_list_data['path'] = f'/{permission.path}'
+
-                    else:
+    @classmethod
-                        router_list_data['component'] = 'ParentView'
+    def __generate_user_router_menu(cls, permission_list: List[MenuTreeModel]):
-                        router_list_data['path'] = permission.path
+        """
-                    if permission.is_frame == 1:
+        工具方法：根据菜单树信息生成路由信息树形嵌套数据
-                        router_list_data['redirect'] = 'noRedirect'
+        :param permission_list: 菜单树列表信息
-                    else:
+        :return: 路由信息树形嵌套数据
-                        router_list_data['path'] = permission.path
+        """
-                    if children:
+        router_list: List[RouterModel] = []
-                        router_list_data['alwaysShow'] = True
+        for permission in permission_list:
-                        router_list_data['children'] = children
+            router = RouterModel(
-                    router_list_data['meta'] = {
+                hidden=True if permission.visible == '1' else False,
-                        'title': permission.menu_name,
+                name=RouterUtil.get_router_name(permission),
-                        'icon': permission.icon,
+                path=RouterUtil.get_router_path(permission),
-                        'noCache': False if permission.is_cache == '0' else True,
+                component=RouterUtil.get_component(permission),
-                        'link': permission.path if permission.is_frame == 0 else None
+                query=permission.query,
-                    }
+                meta=MetaModel(
-                elif permission.menu_type == 'C':
+                    title=permission.menu_name,
-                    router_list_data['name'] = permission.path.capitalize()
+                    icon=permission.icon,
-                    router_list_data['path'] = permission.path
+                    noCache=True if permission.is_cache == 1 else False,
-                    router_list_data['query'] = permission.query
+                    link=permission.path if RouterUtil.is_http(permission.path) else None
-                    router_list_data['hidden'] = False if permission.visible == '0' else True
+                )
-                    router_list_data['component'] = permission.component
+            )
-                    router_list_data['meta'] = {
+            c_menus = permission.children
-                        'title': permission.menu_name,
+            if c_menus and permission.menu_type == 'M':
-                        'icon': permission.icon,
+                router.always_show = True
-                        'noCache': False if permission.is_cache == '0' else True,
+                router.redirect = 'noRedirect'
-                        'link': permission.path if permission.is_frame == 0 else None
+                router.children = cls.__generate_user_router_menu(c_menus)
-                    }
+            elif RouterUtil.is_menu_frame(permission):
-                router_list.append(router_list_data)
+                router.meta = None
+                children_list: List[RouterModel] = []
+                children = RouterModel(
+                    path=permission.path,
+                    component=permission.component,
+                    name=permission.path.capitalize(),
+                    meta=MetaModel(
+                        title=permission.menu_name,
+                        icon=permission.icon,
+                        noCache=True if permission.is_cache == 1 else False,
+                        link=permission.path if RouterUtil.is_http(permission.path) else None
+                    ),
+                    query=permission.query
+                )
+                children_list.append(children)
+                router.children = children_list
+            elif permission.parent_id == 0 and RouterUtil.is_inner_link(permission):
+                router.meta = MetaModel(
+                    title=permission.menu_name,
+                    icon=permission.icon
+                )
+                router.path = '/'
+                children_list: List[RouterModel] = []
+                router_path = RouterUtil.inner_link_replace_each(permission.path)
+                children = RouterModel(
+                    path=router_path,
+                    component='InnerLink',
+                    name=router_path.capitalize(),
+                    meta=MetaModel(
+                        title=permission.menu_name,
+                        icon=permission.icon,
+                        link=permission.path if RouterUtil.is_http(permission.path) else None
+                    )
+                )
+                children_list.append(children)
+                router.children = children_list
+
+            router_list.append(router)
 
         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 +354,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 +364,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 +376,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 +390,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 +402,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
+            forget_user.user_id = (await UserDao.get_user_by_name(query_db, forget_user.user_name)).user_id
-            edit_result = UserService.reset_user_services(query_db, forget_user)
+            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='短信验证码已过期')
@@ -385,3 +426,106 @@ class LoginService:
         # await request.app.state.redis.delete(f'{current_user.user.user_id}_session_id')
 
         return True
+
+
+class RouterUtil:
+    """
+    路由处理工具类
+    """
+
+    @classmethod
+    def get_router_name(cls, menu: MenuTreeModel):
+        """
+        获取路由名称
+        :param menu: 菜单数对象
+        :return: 路由名称
+        """
+        router_name = menu.path.capitalize()
+        if cls.is_menu_frame(menu):
+            router_name = ''
+
+        return router_name
+
+    @classmethod
+    def get_router_path(cls, menu: MenuTreeModel):
+        """
+        获取路由地址
+        :param menu: 菜单数对象
+        :return: 路由地址
+        """
+        # 内链打开外网方式
+        router_path = menu.path
+        if menu.parent_id != 0 and cls.is_inner_link(menu):
+            router_path = cls.inner_link_replace_each(router_path)
+        # 非外链并且是一级目录（类型为目录）
+        if menu.parent_id == 0 and menu.menu_type == 'M' and menu.is_frame == 1:
+            router_path = f'/{menu.path}'
+        # 非外链并且是一级目录（类型为菜单）
+        elif cls.is_menu_frame(menu):
+            router_path = '/'
+        return router_path
+
+    @classmethod
+    def get_component(cls, menu: MenuTreeModel):
+        """
+        获取组件信息
+        :param menu: 菜单数对象
+        :return: 组件信息
+        """
+        component = 'Layout'
+        if menu.component and not cls.is_menu_frame(menu):
+            component = menu.component
+        elif menu.component and menu.parent_id != 0 and cls.is_inner_link(menu):
+            component = 'InnerLink'
+        elif menu.component and cls.is_parent_view(menu):
+            component = 'ParentView'
+        return component
+
+    @classmethod
+    def is_menu_frame(cls, menu: MenuTreeModel):
+        """
+        判断是否为菜单内部跳转
+        :param menu: 菜单数对象
+        :return: 是否为菜单内部跳转
+        """
+        return menu.parent_id == 0 and menu.menu_type == 'C' and menu.is_frame == 1
+
+    @classmethod
+    def is_inner_link(cls, menu: MenuTreeModel):
+        """
+        判断是否为内链组件
+        :param menu: 菜单数对象
+        :return: 是否为内链组件
+        """
+        return menu.is_frame == 1 and cls.is_http(menu.path)
+
+    @classmethod
+    def is_parent_view(cls, menu: MenuTreeModel):
+        """
+        判断是否为parent_view组件
+        :param menu: 菜单数对象
+        :return: 是否为parent_view组件
+        """
+        return menu.parent_id != 0 and menu.menu_type == 'M'
+
+    @classmethod
+    def is_http(cls, link: str):
+        """
+        判断是否为http(s)://开头
+        :param link: 链接
+        :return: 是否为http(s)://开头
+        """
+        return link.startswith('http://') or link.startswith('https://')
+
+    @classmethod
+    def inner_link_replace_each(cls, path: str):
+        """
+        内链域名特殊字符替换
+        :param path: 内链域名
+        :return: 替换后的内链域名
+        """
+        old_values = ["http://", "https://", "www.", ".", ":"]
+        new_values = ["", "", "", "/", "/"]
+        for old, new in zip(old_values, new_values):
+            path = path.replace(old, new)
+        return path

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)
+                await MenuDao.add_menu_dao(query_db, page_object)
-                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_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)
+                await MenuDao.edit_menu_dao(query_db, edit_menu)
-                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='菜单不存在')
@@ -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))
+                    await MenuDao.delete_menu_dao(query_db, MenuModel(menuId=menu_id))
-                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='传入菜单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)
+                await NoticeDao.add_notice_dao(query_db, page_object)
-                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_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)
+                await NoticeDao.edit_notice_dao(query_db, edit_notice)
-                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='通知公告不存在')
@@ -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))
+                    await NoticeDao.delete_notice_dao(query_db, NoticeModel(noticeId=notice_id))
-                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='传入通知公告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)
+                await PostDao.add_post_dao(query_db, page_object)
-                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_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)
+                await PostDao.edit_post_dao(query_db, edit_post)
-                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='岗位不存在')
@@ -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))
+                    await PostDao.delete_post_dao(query_db, PostModel(postId=post_id))
-                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='传入岗位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_name = await 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_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))
+                        await RoleDao.add_role_menu_dao(query_db, RoleMenuModel(roleId=role_id, menuId=menu))
-                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_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))
+                            await RoleDao.add_role_menu_dao(query_db, RoleMenuModel(roleId=page_object.role_id, menuId=menu))
-                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='角色不存在')
@@ -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)
+                await RoleDao.edit_role_dao(query_db, edit_role)
-                RoleDao.delete_role_dept_dao(query_db, RoleDeptModel(roleId=page_object.role_id))
+                await RoleDao.delete_role_dept_dao(query_db, RoleDeptModel(roleId=page_object.role_id))
                 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))
+                        await RoleDao.add_role_dept_dao(query_db, RoleDeptModel(roleId=page_object.role_id, deptId=dept))
-                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='角色不存在')
@@ -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))
+                    await RoleDao.delete_role_menu_dao(query_db, RoleMenuModel(**role_id_dict))
-                    RoleDao.delete_role_dao(query_db, RoleModel(**role_id_dict))
+                    await RoleDao.delete_role_dao(query_db, RoleModel(**role_id_dict))
-                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='传入角色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))
+                        await UserDao.add_user_post_dao(query_db, UserPostModel(userId=user_id, postId=post))
-                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_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':
+                if page_object.type != 'status' and page_object.type != 'avatar' and page_object.type != 'pwd':
-                    UserDao.delete_user_role_dao(query_db, UserRoleModel(userId=page_object.user_id))
+                    await 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_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))
+                            await UserDao.add_user_post_dao(query_db, UserPostModel(userId=page_object.user_id, postId=post))
-                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='用户不存在')
@@ -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))
+                    await UserDao.delete_user_role_dao(query_db, UserRoleModel(**user_id_dict))
-                    UserDao.delete_user_post_dao(query_db, UserPostModel(**user_id_dict))
+                    await UserDao.delete_user_post_dao(query_db, UserPostModel(**user_id_dict))
-                    UserDao.delete_user_dao(query_db, UserModel(**user_id_dict))
+                    await UserDao.delete_user_dao(query_db, UserModel(**user_id_dict))
-                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='传入用户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)
+        posts = await PostService.get_post_list_services(query_db, PostPageQueryModel(**{}), is_page=False)
-        roles = RoleService.get_role_select_option_services(query_db)
+        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)
+            await UserDao.edit_user_dao(query_db, reset_user)
-            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
-    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对象
@@ -275,9 +275,11 @@ class UserService:
                     sex=row['sex'],
                     status=row['status'],
                     createBy=current_user.user.user_name,
-                    updateBy=current_user.user.user_name
+                    createTime=datetime.now(),
+                    updateBy=current_user.user.user_name,
+                    updateTime=datetime.now()
                 )
-                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(
@@ -289,23 +291,24 @@ class UserService:
                             phonenumber=str(row['phonenumber']),
                             sex=row['sex'],
                             status=row['status'],
-                            updateBy=current_user.user.user_name
+                            updateBy=current_user.user.user_name,
+                            updateTime=datetime.now()
                         ).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)
+                    await UserDao.add_user_dao(query_db, add_user)
-            query_db.commit()
+            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 +321,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 +363,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 +380,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 +393,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 +404,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))
+                        await UserDao.add_user_role_dao(query_db, UserRoleModel(userId=page_object.user_id, roleId=role_id))
-                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
         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))
+                await UserDao.delete_user_role_by_user_and_role_dao(query_db, UserRoleModel(userId=page_object.user_id))
-                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
         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))
+                        await UserDao.add_user_role_dao(query_db, UserRoleModel(userId=user_id, roleId=page_object.role_id))
-                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='不满足新增条件')
@@ -439,7 +442,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 +452,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))
+                    await 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 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))
+                        await UserDao.delete_user_role_by_user_and_role_dao(query_db, UserRoleModel(userId=user_id, roleId=page_object.role_id))
-                    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='不满足删除条件')
@@ -473,13 +476,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

ruoyi-fastapi-backend/requirements.txt

@@ -1,4 +1,5 @@
 APScheduler==3.10.4
+asyncmy==0.2.9
 DateTime==5.4
 fastapi[all]==0.109.1
 loguru==0.7.2
@@ -11,5 +12,5 @@ PyMySQL==1.1.0
 python-jose[cryptography]==3.3.0
 redis==5.0.1
 requests==2.31.0
-SQLAlchemy==2.0.25
+SQLAlchemy[asyncio]==2.0.25
 user-agents==2.2.0

ruoyi-fastapi-backend/utils/common_util.py

@@ -40,19 +40,8 @@ def worship():
 
 class CamelCaseUtil:
     """
-    小驼峰形式(camelCase)与下划线形式(snake_case)互相转换工具方法
+    下划线形式(snake_case)转小驼峰形式(camelCase)工具方法
     """
-    @classmethod
-    def camel_to_snake(cls, camel_str):
-        """
-        小驼峰形式字符串(camelCase)转换为下划线形式字符串(snake_case)
-        :param camel_str: 小驼峰形式字符串
-        :return: 下划线形式字符串
-        """
-        # 在大写字母前添加一个下划线，然后将整个字符串转为小写
-        words = re.sub('(.)([A-Z][a-z]+)', r'\1_\2', camel_str)
-        return re.sub('([a-z0-9])([A-Z])', r'\1_\2', words).lower()
-
     @classmethod
     def snake_to_camel(cls, snake_str):
         """
@@ -88,6 +77,44 @@ class CamelCaseUtil:
             return cls.transform_result({c.name: getattr(result, c.name) for c in result.__table__.columns})
 
 
+class SnakeCaseUtil:
+    """
+    小驼峰形式(camelCase)转下划线形式(snake_case)工具方法
+    """
+    @classmethod
+    def camel_to_snake(cls, camel_str):
+        """
+        小驼峰形式字符串(camelCase)转换为下划线形式字符串(snake_case)
+        :param camel_str: 小驼峰形式字符串
+        :return: 下划线形式字符串
+        """
+        # 在大写字母前添加一个下划线，然后将整个字符串转为小写
+        words = re.sub('(.)([A-Z][a-z]+)', r'\1_\2', camel_str)
+        return re.sub('([a-z0-9])([A-Z])', r'\1_\2', words).lower()
+
+    @classmethod
+    def transform_result(cls, result):
+        """
+        针对不同类型将下划线形式(snake_case)批量转换为小驼峰形式(camelCase)方法
+        :param result: 输入数据
+        :return: 小驼峰形式结果
+        """
+        if result is None:
+            return result
+        # 如果是字典，直接转换键
+        elif isinstance(result, dict):
+            return {cls.camel_to_snake(k): v for k, v in result.items()}
+        # 如果是一组字典或其他类型的列表，遍历列表进行转换
+        elif isinstance(result, list):
+            return [cls.transform_result(row) if isinstance(row, (dict, Row)) else (cls.transform_result({c.name: getattr(row, c.name) for c in row.__table__.columns}) if row else row) for row in result]
+        # 如果是sqlalchemy的Row实例，遍历Row进行转换
+        elif isinstance(result, Row):
+            return [cls.transform_result(row) if isinstance(row, dict) else (cls.transform_result({c.name: getattr(row, c.name) for c in row.__table__.columns}) if row else row) for row in result]
+        # 如果是其他类型，如模型实例，先转换为字典
+        else:
+            return cls.transform_result({c.name: getattr(result, c.name) for c in result.__table__.columns})
+
+
 def bytes2human(n, format_str="%(value).1f%(symbol)s"):
     """Used by various scripts. See:
     http://goo.gl/zeJZl

ruoyi-fastapi-backend/utils/page_util.py

@@ -1,6 +1,7 @@
 import math
 from typing import Optional, List
-from sqlalchemy.orm.query import Query
+from sqlalchemy import Select, select, func
+from sqlalchemy.ext.asyncio import AsyncSession
 from pydantic import BaseModel, ConfigDict
 from pydantic.alias_generators import to_camel
 from utils.common_util import CamelCaseUtil
@@ -52,9 +53,10 @@ class PageUtil:
         return result
 
     @classmethod
-    def paginate(cls, query: Query, page_num: int, page_size: int, is_page: bool = False):
+    async def paginate(cls, db: AsyncSession, query: Select, page_num: int, page_size: int, is_page: bool = False):
         """
         输入查询语句和分页信息，返回分页数据列表结果
+        :param db: orm对象
         :param query: sqlalchemy查询语句
         :param page_num: 当前页码
         :param page_size: 当前页面数据量
@@ -62,8 +64,14 @@ class PageUtil:
         :return: 分页数据对象
         """
         if is_page:
-            total = query.count()
+            total = (await db.execute(select(func.count('*')).select_from(query.subquery()))).scalar()
-            paginated_data = query.offset((page_num - 1) * page_size).limit(page_size).all()
+            query_result = (await db.execute(query.offset((page_num - 1) * page_size).limit(page_size)))
+            paginated_data = []
+            for row in query_result:
+                if row and len(row) == 1:
+                    paginated_data.append(row[0])
+                else:
+                    paginated_data.append(row)
             has_next = True if math.ceil(len(paginated_data) / page_size) > page_num else False
             result = PageResponseModel(
                 rows=CamelCaseUtil.transform_result(paginated_data),
@@ -73,7 +81,13 @@ class PageUtil:
                 hasNext=has_next
             )
         else:
-            no_paginated_data = query.all()
+            query_result = await db.execute(query)
+            no_paginated_data = []
+            for row in query_result:
+                if row and len(row) == 1:
+                    no_paginated_data.append(row[0])
+                else:
+                    no_paginated_data.append(row)
             result = CamelCaseUtil.transform_result(no_paginated_data)
 
         return result

ruoyi-fastapi-frontend/package.json

@@ -1,6 +1,6 @@
 {
   "name": "vfadmin",
-  "version": "1.1.2",
+  "version": "1.2.1",
   "description": "vfadmin管理系统",
   "author": "insistence",
   "license": "MIT",

ruoyi-fastapi-frontend/src/views/register.vue

@@ -105,7 +105,8 @@ const registerRules = {
   ],
   password: [
     { required: true, trigger: "blur", message: "请输入您的密码" },
-    { min: 5, max: 20, message: "用户密码长度必须介于 5 和 20 之间", trigger: "blur" }
+    { min: 5, max: 20, message: "用户密码长度必须介于 5 和 20 之间", trigger: "blur" },
+    { pattern: /^[^<>"'|\\]+$/, message: "不能包含非法字符：< > \" ' \\\ |", trigger: "blur" }
   ],
   confirmPassword: [
     { required: true, trigger: "blur", message: "请再次输入您的密码" },

ruoyi-fastapi-frontend/src/views/system/user/index.vue

@@ -391,7 +391,7 @@ const data = reactive({
   rules: {
     userName: [{ required: true, message: "用户名称不能为空", trigger: "blur" }, { min: 2, max: 20, message: "用户名称长度必须介于 2 和 20 之间", trigger: "blur" }],
     nickName: [{ required: true, message: "用户昵称不能为空", trigger: "blur" }],
-    password: [{ required: true, message: "用户密码不能为空", trigger: "blur" }, { min: 5, max: 20, message: "用户密码长度必须介于 5 和 20 之间", trigger: "blur" }],
+    password: [{ required: true, message: "用户密码不能为空", trigger: "blur" }, { min: 5, max: 20, message: "用户密码长度必须介于 5 和 20 之间", trigger: "blur" }, { pattern: /^[^<>"'|\\]+$/, message: "不能包含非法字符：< > \" ' \\\ |", trigger: "blur" }],
     email: [{ type: "email", message: "请输入正确的邮箱地址", trigger: ["blur", "change"] }],
     phonenumber: [{ pattern: /^1[3|4|5|6|7|8|9][0-9]\d{8}$/, message: "请输入正确的手机号码", trigger: "blur" }]
   }
@@ -494,6 +494,11 @@ function handleResetPwd(row) {
     closeOnClickModal: false,
     inputPattern: /^.{5,20}$/,
     inputErrorMessage: "用户密码长度必须介于 5 和 20 之间",
+    inputValidator: (value) => {
+      if (/<|>|"|'|\||\\/.test(value)) {
+        return "不能包含非法字符：< > \" ' \\\ |"
+      }
+    },
   }).then(({ value }) => {
     resetUserPwd(row.userId, value).then(response => {
       proxy.$modal.msgSuccess("修改成功，新密码是：" + value);

ruoyi-fastapi-frontend/src/views/system/user/profile/resetPwd.vue

@@ -36,7 +36,7 @@ const equalToPassword = (rule, value, callback) => {
 };
 const rules = ref({
   oldPassword: [{ required: true, message: "旧密码不能为空", trigger: "blur" }],
-  newPassword: [{ required: true, message: "新密码不能为空", trigger: "blur" }, { min: 6, max: 20, message: "长度在 6 到 20 个字符", trigger: "blur" }],
+  newPassword: [{ required: true, message: "新密码不能为空", trigger: "blur" }, { min: 6, max: 20, message: "长度在 6 到 20 个字符", trigger: "blur" }, { pattern: /^[^<>"'|\\]+$/, message: "不能包含非法字符：< > \" ' \\\ |", trigger: "blur" }],
   confirmPassword: [{ required: true, message: "确认密码不能为空", trigger: "blur" }, { required: true, validator: equalToPassword, trigger: "blur" }]
 });
 

ruoyi-fastapi-frontend/vite.config.js

@@ -31,7 +31,7 @@ export default defineConfig(({ mode, command }) => {
       proxy: {
         // https://cn.vitejs.dev/config/#server-proxy
         '/dev-api': {
-          target: 'http://localhost:9099',
+          target: 'http://127.0.0.1:9099',
           changeOrigin: true,
           rewrite: (p) => p.replace(/^\/dev-api/, '')
         }