diff --git a/README.md b/README.md
index 2b8d7f5ddaa074abc2e0f5eaad867acf87e0941e..648cfad725b99c26346b8dd219660bf263d0595a 100644
--- a/README.md
+++ b/README.md
@@ -1,12 +1,12 @@
-RuoYi-Vue-FastAPI v1.1.3
+RuoYi-Vue-FastAPI v1.2.0
基于RuoYi-Vue+FastAPI前后端分离的快速开发框架
- 
+ 
@@ -18,7 +18,6 @@
-
## 平台简介
RuoYi-Vue-FastAPI是一套全部开源的快速开发平台，毫无保留给个人及企业免费使用。
diff --git a/ruoyi-fastapi-backend/.env.dev b/ruoyi-fastapi-backend/.env.dev
index e3916a844f6681d669f614cf8f8dfa3f8c696c2c..f982a6c57b0edb1261d6323b7d352480315a6ab7 100644
--- a/ruoyi-fastapi-backend/.env.dev
+++ b/ruoyi-fastapi-backend/.env.dev
@@ -10,7 +10,7 @@ APP_HOST = '0.0.0.0'
# 应用端口
APP_PORT = 9099
# 应用版本
-APP_VERSION= '1.1.3'
+APP_VERSION= '1.2.0'
# 应用是否开启热重载
APP_RELOAD = true
# 应用是否开启IP归属区域查询
diff --git a/ruoyi-fastapi-backend/.env.prod b/ruoyi-fastapi-backend/.env.prod
index b9132b58be6b4a0fe36fe154c137cae1f2232766..c651f43575c8b67243746c80ee73401601f947bd 100644
--- a/ruoyi-fastapi-backend/.env.prod
+++ b/ruoyi-fastapi-backend/.env.prod
@@ -10,7 +10,7 @@ APP_HOST = '0.0.0.0'
# 应用端口
APP_PORT = 9099
# 应用版本
-APP_VERSION= '1.1.3'
+APP_VERSION= '1.2.0'
# 应用是否开启热重载
APP_RELOAD = false
# 应用是否开启IP归属区域查询
diff --git a/ruoyi-fastapi-backend/config/database.py b/ruoyi-fastapi-backend/config/database.py
index cb871ecb816a3ad308b6ca2758209f92da6d21e4..512ae1be0dbf7b240c4a5206016e09f9cef0478a 100644
--- a/ruoyi-fastapi-backend/config/database.py
+++ b/ruoyi-fastapi-backend/config/database.py
@@ -1,19 +1,23 @@
-from sqlalchemy import create_engine
-from sqlalchemy.ext.declarative import declarative_base
-from sqlalchemy.orm import sessionmaker
+from sqlalchemy.ext.asyncio import create_async_engine
+from sqlalchemy.ext.asyncio import async_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(
- SQLALCHEMY_DATABASE_URL,
+async_engine = create_async_engine(
+ 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)
-Base = declarative_base()
+AsyncSessionLocal = async_sessionmaker(autocommit=False, autoflush=False, bind=async_engine)
+
+
+class Base(AsyncAttrs, DeclarativeBase):
+ pass
diff --git a/ruoyi-fastapi-backend/config/get_db.py b/ruoyi-fastapi-backend/config/get_db.py
index 6d3a9cf40ff2f03fc33c327063fdaeb784825071..9c12561fb5583c2d01a1a75afff6ea8f19271038 100644
--- a/ruoyi-fastapi-backend/config/get_db.py
+++ b/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()
- try:
+ async with AsyncSessionLocal() as current_db:
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
diff --git a/ruoyi-fastapi-backend/config/get_redis.py b/ruoyi-fastapi-backend/config/get_redis.py
index 4c3ef800f881cae013ac0d3a76590b98d5860ceb..aa78f4ce52e6b7c8563289af65fba09758ff6651 100644
--- a/ruoyi-fastapi-backend/config/get_redis.py
+++ b/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()
- await DictDataService.init_cache_sys_dict_services(session, redis)
-
- session.close()
+ async with AsyncSessionLocal() as session:
+ await DictDataService.init_cache_sys_dict_services(session, redis)
@classmethod
async def init_sys_config(cls, redis):
@@ -71,7 +69,5 @@ class RedisUtil:
:param redis: redis对象
:return:
"""
- session = SessionLocal()
- await ConfigService.init_cache_sys_config_services(session, redis)
-
- session.close()
+ async with AsyncSessionLocal() as session:
+ await ConfigService.init_cache_sys_config_services(session, redis)
diff --git a/ruoyi-fastapi-backend/config/get_scheduler.py b/ruoyi-fastapi-backend/config/get_scheduler.py
index 17e5ae5bb8e6f8b4de759fee04c30de0cfb4acf5..ae4f9320cca8059840ba5ddd8695aec551a071b6 100644
--- a/ruoyi-fastapi-backend/config/get_scheduler.py
+++ b/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.env import RedisConfig
+from config.database import quote_plus, AsyncSessionLocal
+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)
- for item in job_list:
- query_job = cls.get_scheduler_job(job_id=str(item.job_id))
- if query_job:
- cls.remove_scheduler_job(job_id=str(item.job_id))
- cls.add_scheduler_job(item)
- query_db.close()
+ async with AsyncSessionLocal() as session:
+ job_list = await JobDao.get_job_list_for_scheduler(session)
+ for item in job_list:
+ query_job = cls.get_scheduler_job(job_id=str(item.job_id))
+ if query_job:
+ cls.remove_scheduler_job(job_id=str(item.job_id))
+ 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)
diff --git a/ruoyi-fastapi-backend/module_admin/annotation/log_annotation.py b/ruoyi-fastapi-backend/module_admin/annotation/log_annotation.py
index e86439159831e608f63938539d7f0c4344a73c59..fa7c1b3c275cacff7cda42268e758cadc46ccb7a 100644
--- a/ruoyi-fastapi-backend/module_admin/annotation/log_annotation.py
+++ b/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
diff --git a/ruoyi-fastapi-backend/module_admin/aspect/data_scope.py b/ruoyi-fastapi-backend/module_admin/aspect/data_scope.py
index 3e039181f7f4c0a96d3aa2b7ff9684b94fc92544..598170e2e985ae7fa0a092071d4d4d702f7a9a0f 100644
--- a/ruoyi-fastapi-backend/module_admin/aspect/data_scope.py
+++ b/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:
diff --git a/ruoyi-fastapi-backend/module_admin/aspect/interface_auth.py b/ruoyi-fastapi-backend/module_admin/aspect/interface_auth.py
index e13d0e6b702466bbd499a3cf675235c878f88d11..e688ad82ae289cc01def20f368abe9a24df2d691 100644
--- a/ruoyi-fastapi-backend/module_admin/aspect/interface_auth.py
+++ b/ruoyi-fastapi-backend/module_admin/aspect/interface_auth.py
@@ -56,3 +56,4 @@ class CheckRoleInterfaceAuth:
if any([role_key_str in user_role_key_list for role_key_str in self.role_key]):
return True
raise PermissionException(data="", message="该用户无此接口权限")
+
diff --git a/ruoyi-fastapi-backend/module_admin/controller/cache_controller.py b/ruoyi-fastapi-backend/module_admin/controller/cache_controller.py
index 7b7da4bf1f97ffffd4dc3a5b8737c4628438324f..b33a2873918fb1878731dfda54366c891b147c0e 100644
--- a/ruoyi-fastapi-backend/module_admin/controller/cache_controller.py
+++ b/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:
diff --git a/ruoyi-fastapi-backend/module_admin/controller/captcha_controller.py b/ruoyi-fastapi-backend/module_admin/controller/captcha_controller.py
index 4fc64b66b666dd2e8c21b5701ee218dbb35ed7f0..9d245ccc195ed7863555d047a6539badfec8b72f 100644
--- a/ruoyi-fastapi-backend/module_admin/controller/captcha_controller.py
+++ b/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))
diff --git a/ruoyi-fastapi-backend/module_admin/controller/common_controller.py b/ruoyi-fastapi-backend/module_admin/controller/common_controller.py
index d2981490d341ecf3a4b3546e99a6d114695a2467..5744f7075ae78932ee2d8bfe1552028291e7acd5 100644
--- a/ruoyi-fastapi-backend/module_admin/controller/common_controller.py
+++ b/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)
diff --git a/ruoyi-fastapi-backend/module_admin/controller/config_controller.py b/ruoyi-fastapi-backend/module_admin/controller/config_controller.py
index e7a93d47315c244c9be24782d7f0de6be5ac7848..576d62c4b3ac5f2c8c3af709dac275eb632232e8 100644
--- a/ruoyi-fastapi-backend/module_admin/controller/config_controller.py
+++ b/ruoyi-fastapi-backend/module_admin/controller/config_controller.py
@@ -15,10 +15,10 @@ configController = APIRouter(prefix='/system/config', dependencies=[Depends(Logi
@configController.get("/list", response_model=PageResponseModel, dependencies=[Depends(CheckUserInterfaceAuth('system:config:list'))])
-async def get_system_config_list(request: Request, config_page_query: ConfigPageQueryModel = Depends(ConfigPageQueryModel.as_query), query_db: Session = Depends(get_db)):
+async def get_system_config_list(request: Request, config_page_query: ConfigPageQueryModel = Depends(ConfigPageQueryModel.as_query), query_db: AsyncSession = Depends(get_db)):
try:
# 获取分页数据
- config_page_query_result = ConfigService.get_config_list_services(query_db, config_page_query, is_page=True)
+ config_page_query_result = await ConfigService.get_config_list_services(query_db, config_page_query, is_page=True)
logger.info('获取成功')
return ResponseUtil.success(model_content=config_page_query_result)
except Exception as e:
@@ -28,7 +28,7 @@ async def get_system_config_list(request: Request, config_page_query: ConfigPage
@configController.post("", dependencies=[Depends(CheckUserInterfaceAuth('system:config:add'))])
@log_decorator(title='参数管理', business_type=1)
-async def add_system_config(request: Request, add_config: ConfigModel, query_db: Session = Depends(get_db), current_user: CurrentUserModel = Depends(LoginService.get_current_user)):
+async def add_system_config(request: Request, add_config: ConfigModel, query_db: AsyncSession = Depends(get_db), current_user: CurrentUserModel = Depends(LoginService.get_current_user)):
try:
add_config.create_by = current_user.user.user_name
add_config.update_by = current_user.user.user_name
@@ -46,7 +46,7 @@ async def add_system_config(request: Request, add_config: ConfigModel, query_db:
@configController.put("", dependencies=[Depends(CheckUserInterfaceAuth('system:config:edit'))])
@log_decorator(title='参数管理', business_type=2)
-async def edit_system_config(request: Request, edit_config: ConfigModel, query_db: Session = Depends(get_db), current_user: CurrentUserModel = Depends(LoginService.get_current_user)):
+async def edit_system_config(request: Request, edit_config: ConfigModel, query_db: AsyncSession = Depends(get_db), current_user: CurrentUserModel = Depends(LoginService.get_current_user)):
try:
edit_config.update_by = current_user.user.user_name
edit_config.update_time = datetime.now()
@@ -64,7 +64,7 @@ async def edit_system_config(request: Request, edit_config: ConfigModel, query_d
@configController.delete("/refreshCache", dependencies=[Depends(CheckUserInterfaceAuth('system:config:remove'))])
@log_decorator(title='参数管理', business_type=2)
-async def refresh_system_config(request: Request, query_db: Session = Depends(get_db)):
+async def refresh_system_config(request: Request, query_db: AsyncSession = Depends(get_db)):
try:
refresh_config_result = await ConfigService.refresh_sys_config_services(request, query_db)
if refresh_config_result.is_success:
@@ -80,7 +80,7 @@ async def refresh_system_config(request: Request, query_db: Session = Depends(ge
@configController.delete("/{config_ids}", dependencies=[Depends(CheckUserInterfaceAuth('system:config:remove'))])
@log_decorator(title='参数管理', business_type=3)
-async def delete_system_config(request: Request, config_ids: str, query_db: Session = Depends(get_db)):
+async def delete_system_config(request: Request, config_ids: str, query_db: AsyncSession = Depends(get_db)):
try:
delete_config = DeleteConfigModel(configIds=config_ids)
delete_config_result = await ConfigService.delete_config_services(request, query_db, delete_config)
@@ -96,9 +96,9 @@ async def delete_system_config(request: Request, config_ids: str, query_db: Sess
@configController.get("/{config_id}", response_model=ConfigModel, dependencies=[Depends(CheckUserInterfaceAuth('system:config:query'))])
-async def query_detail_system_config(request: Request, config_id: int, query_db: Session = Depends(get_db)):
+async def query_detail_system_config(request: Request, config_id: int, query_db: AsyncSession = Depends(get_db)):
try:
- config_detail_result = ConfigService.config_detail_services(query_db, config_id)
+ config_detail_result = await ConfigService.config_detail_services(query_db, config_id)
logger.info(f'获取config_id为{config_id}的信息成功')
return ResponseUtil.success(data=config_detail_result)
except Exception as e:
@@ -120,11 +120,11 @@ async def query_system_config(request: Request, config_key: str):
@configController.post("/export", dependencies=[Depends(CheckUserInterfaceAuth('system:config:export'))])
@log_decorator(title='参数管理', business_type=5)
-async def export_system_config_list(request: Request, config_page_query: ConfigPageQueryModel = Depends(ConfigPageQueryModel.as_form), query_db: Session = Depends(get_db)):
+async def export_system_config_list(request: Request, config_page_query: ConfigPageQueryModel = Depends(ConfigPageQueryModel.as_form), query_db: AsyncSession = Depends(get_db)):
try:
# 获取全量数据
- config_query_result = ConfigService.get_config_list_services(query_db, config_page_query, is_page=False)
- config_export_result = ConfigService.export_config_list_services(config_query_result)
+ config_query_result = await ConfigService.get_config_list_services(query_db, config_page_query, is_page=False)
+ config_export_result = await ConfigService.export_config_list_services(config_query_result)
logger.info('导出成功')
return ResponseUtil.streaming(data=bytes2file_response(config_export_result))
except Exception as e:
diff --git a/ruoyi-fastapi-backend/module_admin/controller/dept_controller.py b/ruoyi-fastapi-backend/module_admin/controller/dept_controller.py
index efacd0d9606605b9a1d419dc1043d26fa35acee6..741dd7e1c8e1d4d8cad2cd73bc63bb5546e0a244 100644
--- a/ruoyi-fastapi-backend/module_admin/controller/dept_controller.py
+++ b/ruoyi-fastapi-backend/module_admin/controller/dept_controller.py
@@ -14,10 +14,10 @@ deptController = APIRouter(prefix='/system/dept', dependencies=[Depends(LoginSer
@deptController.get("/list/exclude/{dept_id}", response_model=List[DeptModel], dependencies=[Depends(CheckUserInterfaceAuth('system:dept:list'))])
-async def get_system_dept_tree_for_edit_option(request: Request, dept_id: int, query_db: Session = Depends(get_db), data_scope_sql: str = Depends(GetDataScope('SysDept'))):
+async def get_system_dept_tree_for_edit_option(request: Request, dept_id: int, query_db: AsyncSession = Depends(get_db), data_scope_sql: str = Depends(GetDataScope('SysDept'))):
try:
dept_query = DeptModel(deptId=dept_id)
- dept_query_result = DeptService.get_dept_for_edit_option_services(query_db, dept_query, data_scope_sql)
+ dept_query_result = await DeptService.get_dept_for_edit_option_services(query_db, dept_query, data_scope_sql)
logger.info('获取成功')
return ResponseUtil.success(data=dept_query_result)
except Exception as e:
@@ -26,9 +26,9 @@ async def get_system_dept_tree_for_edit_option(request: Request, dept_id: int, q
@deptController.get("/list", response_model=List[DeptModel], dependencies=[Depends(CheckUserInterfaceAuth('system:dept:list'))])
-async def get_system_dept_list(request: Request, dept_query: DeptQueryModel = Depends(DeptQueryModel.as_query), query_db: Session = Depends(get_db), data_scope_sql: str = Depends(GetDataScope('SysDept'))):
+async def get_system_dept_list(request: Request, dept_query: DeptQueryModel = Depends(DeptQueryModel.as_query), query_db: AsyncSession = Depends(get_db), data_scope_sql: str = Depends(GetDataScope('SysDept'))):
try:
- dept_query_result = DeptService.get_dept_list_services(query_db, dept_query, data_scope_sql)
+ dept_query_result = await DeptService.get_dept_list_services(query_db, dept_query, data_scope_sql)
logger.info('获取成功')
return ResponseUtil.success(data=dept_query_result)
except Exception as e:
@@ -38,11 +38,11 @@ async def get_system_dept_list(request: Request, dept_query: DeptQueryModel = De
@deptController.post("", dependencies=[Depends(CheckUserInterfaceAuth('system:dept:add'))])
@log_decorator(title='部门管理', business_type=1)
-async def add_system_dept(request: Request, add_dept: DeptModel, query_db: Session = Depends(get_db), current_user: CurrentUserModel = Depends(LoginService.get_current_user)):
+async def add_system_dept(request: Request, add_dept: DeptModel, query_db: AsyncSession = Depends(get_db), current_user: CurrentUserModel = Depends(LoginService.get_current_user)):
try:
add_dept.create_by = current_user.user.user_name
add_dept.update_by = current_user.user.user_name
- add_dept_result = DeptService.add_dept_services(query_db, add_dept)
+ add_dept_result = await DeptService.add_dept_services(query_db, add_dept)
if add_dept_result.is_success:
logger.info(add_dept_result.message)
return ResponseUtil.success(data=add_dept_result)
@@ -56,11 +56,11 @@ async def add_system_dept(request: Request, add_dept: DeptModel, query_db: Sessi
@deptController.put("", dependencies=[Depends(CheckUserInterfaceAuth('system:dept:edit'))])
@log_decorator(title='部门管理', business_type=2)
-async def edit_system_dept(request: Request, edit_dept: DeptModel, query_db: Session = Depends(get_db), current_user: CurrentUserModel = Depends(LoginService.get_current_user)):
+async def edit_system_dept(request: Request, edit_dept: DeptModel, query_db: AsyncSession = Depends(get_db), current_user: CurrentUserModel = Depends(LoginService.get_current_user)):
try:
edit_dept.update_by = current_user.user.user_name
edit_dept.update_time = datetime.now()
- edit_dept_result = DeptService.edit_dept_services(query_db, edit_dept)
+ edit_dept_result = await DeptService.edit_dept_services(query_db, edit_dept)
if edit_dept_result.is_success:
logger.info(edit_dept_result.message)
return ResponseUtil.success(msg=edit_dept_result.message)
@@ -74,12 +74,12 @@ async def edit_system_dept(request: Request, edit_dept: DeptModel, query_db: Ses
@deptController.delete("/{dept_ids}", dependencies=[Depends(CheckUserInterfaceAuth('system:dept:remove'))])
@log_decorator(title='部门管理', business_type=3)
-async def delete_system_dept(request: Request, dept_ids: str, query_db: Session = Depends(get_db), current_user: CurrentUserModel = Depends(LoginService.get_current_user)):
+async def delete_system_dept(request: Request, dept_ids: str, query_db: AsyncSession = Depends(get_db), current_user: CurrentUserModel = Depends(LoginService.get_current_user)):
try:
delete_dept = DeleteDeptModel(deptIds=dept_ids)
delete_dept.update_by = current_user.user.user_name
delete_dept.update_time = datetime.now()
- delete_dept_result = DeptService.delete_dept_services(query_db, delete_dept)
+ delete_dept_result = await DeptService.delete_dept_services(query_db, delete_dept)
if delete_dept_result.is_success:
logger.info(delete_dept_result.message)
return ResponseUtil.success(msg=delete_dept_result.message)
@@ -92,9 +92,9 @@ async def delete_system_dept(request: Request, dept_ids: str, query_db: Session
@deptController.get("/{dept_id}", response_model=DeptModel, dependencies=[Depends(CheckUserInterfaceAuth('system:dept:query'))])
-async def query_detail_system_dept(request: Request, dept_id: int, query_db: Session = Depends(get_db)):
+async def query_detail_system_dept(request: Request, dept_id: int, query_db: AsyncSession = Depends(get_db)):
try:
- detail_dept_result = DeptService.dept_detail_services(query_db, dept_id)
+ detail_dept_result = await DeptService.dept_detail_services(query_db, dept_id)
logger.info(f'获取dept_id为{dept_id}的信息成功')
return ResponseUtil.success(data=detail_dept_result)
except Exception as e:
diff --git a/ruoyi-fastapi-backend/module_admin/controller/dict_controller.py b/ruoyi-fastapi-backend/module_admin/controller/dict_controller.py
index 0ccd472c05b30d7da99c25745e9e18d07c57759d..fcf96ebfa332e61569a9873f5dd2782ea910bbb0 100644
--- a/ruoyi-fastapi-backend/module_admin/controller/dict_controller.py
+++ b/ruoyi-fastapi-backend/module_admin/controller/dict_controller.py
@@ -15,10 +15,10 @@ dictController = APIRouter(prefix='/system/dict', dependencies=[Depends(LoginSer
@dictController.get("/type/list", response_model=PageResponseModel, dependencies=[Depends(CheckUserInterfaceAuth('system:dict:list'))])
-async def get_system_dict_type_list(request: Request, dict_type_page_query: DictTypePageQueryModel = Depends(DictTypePageQueryModel.as_query), query_db: Session = Depends(get_db)):
+async def get_system_dict_type_list(request: Request, dict_type_page_query: DictTypePageQueryModel = Depends(DictTypePageQueryModel.as_query), query_db: AsyncSession = Depends(get_db)):
try:
# 获取分页数据
- dict_type_page_query_result = DictTypeService.get_dict_type_list_services(query_db, dict_type_page_query, is_page=True)
+ dict_type_page_query_result = await DictTypeService.get_dict_type_list_services(query_db, dict_type_page_query, is_page=True)
logger.info('获取成功')
return ResponseUtil.success(model_content=dict_type_page_query_result)
except Exception as e:
@@ -28,7 +28,7 @@ async def get_system_dict_type_list(request: Request, dict_type_page_query: Dict
@dictController.post("/type", dependencies=[Depends(CheckUserInterfaceAuth('system:dict:add'))])
@log_decorator(title='字典管理', business_type=1)
-async def add_system_dict_type(request: Request, add_dict_type: DictTypeModel, query_db: Session = Depends(get_db), current_user: CurrentUserModel = Depends(LoginService.get_current_user)):
+async def add_system_dict_type(request: Request, add_dict_type: DictTypeModel, query_db: AsyncSession = Depends(get_db), current_user: CurrentUserModel = Depends(LoginService.get_current_user)):
try:
add_dict_type.create_by = current_user.user.user_name
add_dict_type.update_by = current_user.user.user_name
@@ -46,7 +46,7 @@ async def add_system_dict_type(request: Request, add_dict_type: DictTypeModel, q
@dictController.put("/type", dependencies=[Depends(CheckUserInterfaceAuth('system:dict:edit'))])
@log_decorator(title='字典管理', business_type=2)
-async def edit_system_dict_type(request: Request, edit_dict_type: DictTypeModel, query_db: Session = Depends(get_db), current_user: CurrentUserModel = Depends(LoginService.get_current_user)):
+async def edit_system_dict_type(request: Request, edit_dict_type: DictTypeModel, query_db: AsyncSession = Depends(get_db), current_user: CurrentUserModel = Depends(LoginService.get_current_user)):
try:
edit_dict_type.update_by = current_user.user.user_name
edit_dict_type.update_time = datetime.now()
@@ -64,7 +64,7 @@ async def edit_system_dict_type(request: Request, edit_dict_type: DictTypeModel,
@dictController.delete("/type/refreshCache", dependencies=[Depends(CheckUserInterfaceAuth('system:dict:remove'))])
@log_decorator(title='字典管理', business_type=2)
-async def refresh_system_dict(request: Request, query_db: Session = Depends(get_db)):
+async def refresh_system_dict(request: Request, query_db: AsyncSession = Depends(get_db)):
try:
refresh_dict_result = await DictTypeService.refresh_sys_dict_services(request, query_db)
if refresh_dict_result.is_success:
@@ -80,7 +80,7 @@ async def refresh_system_dict(request: Request, query_db: Session = Depends(get_
@dictController.delete("/type/{dict_ids}", dependencies=[Depends(CheckUserInterfaceAuth('system:dict:remove'))])
@log_decorator(title='字典管理', business_type=3)
-async def delete_system_dict_type(request: Request, dict_ids: str, query_db: Session = Depends(get_db)):
+async def delete_system_dict_type(request: Request, dict_ids: str, query_db: AsyncSession = Depends(get_db)):
try:
delete_dict_type = DeleteDictTypeModel(dictIds=dict_ids)
delete_dict_type_result = await DictTypeService.delete_dict_type_services(request, query_db, delete_dict_type)
@@ -96,9 +96,9 @@ async def delete_system_dict_type(request: Request, dict_ids: str, query_db: Ses
@dictController.get("/type/optionselect", response_model=List[DictTypeModel])
-async def query_system_dict_type_options(request: Request, query_db: Session = Depends(get_db)):
+async def query_system_dict_type_options(request: Request, query_db: AsyncSession = Depends(get_db)):
try:
- dict_type_query_result = DictTypeService.get_dict_type_list_services(query_db, DictTypePageQueryModel(**dict()), is_page=False)
+ dict_type_query_result = await DictTypeService.get_dict_type_list_services(query_db, DictTypePageQueryModel(**dict()), is_page=False)
logger.info(f'获取成功')
return ResponseUtil.success(data=dict_type_query_result)
except Exception as e:
@@ -107,9 +107,9 @@ async def query_system_dict_type_options(request: Request, query_db: Session = D
@dictController.get("/type/{dict_id}", response_model=DictTypeModel, dependencies=[Depends(CheckUserInterfaceAuth('system:dict:query'))])
-async def query_detail_system_dict_type(request: Request, dict_id: int, query_db: Session = Depends(get_db)):
+async def query_detail_system_dict_type(request: Request, dict_id: int, query_db: AsyncSession = Depends(get_db)):
try:
- dict_type_detail_result = DictTypeService.dict_type_detail_services(query_db, dict_id)
+ dict_type_detail_result = await DictTypeService.dict_type_detail_services(query_db, dict_id)
logger.info(f'获取dict_id为{dict_id}的信息成功')
return ResponseUtil.success(data=dict_type_detail_result)
except Exception as e:
@@ -119,11 +119,11 @@ async def query_detail_system_dict_type(request: Request, dict_id: int, query_db
@dictController.post("/type/export", dependencies=[Depends(CheckUserInterfaceAuth('system:dict:export'))])
@log_decorator(title='字典管理', business_type=5)
-async def export_system_dict_type_list(request: Request, dict_type_page_query: DictTypePageQueryModel = Depends(DictTypePageQueryModel.as_form), query_db: Session = Depends(get_db)):
+async def export_system_dict_type_list(request: Request, dict_type_page_query: DictTypePageQueryModel = Depends(DictTypePageQueryModel.as_form), query_db: AsyncSession = Depends(get_db)):
try:
# 获取全量数据
- dict_type_query_result = DictTypeService.get_dict_type_list_services(query_db, dict_type_page_query, is_page=False)
- dict_type_export_result = DictTypeService.export_dict_type_list_services(dict_type_query_result)
+ dict_type_query_result = await DictTypeService.get_dict_type_list_services(query_db, dict_type_page_query, is_page=False)
+ dict_type_export_result = await DictTypeService.export_dict_type_list_services(dict_type_query_result)
logger.info('导出成功')
return ResponseUtil.streaming(data=bytes2file_response(dict_type_export_result))
except Exception as e:
@@ -132,7 +132,7 @@ async def export_system_dict_type_list(request: Request, dict_type_page_query: D
@dictController.get("/data/type/{dict_type}")
-async def query_system_dict_type_data(request: Request, dict_type: str, query_db: Session = Depends(get_db)):
+async def query_system_dict_type_data(request: Request, dict_type: str, query_db: AsyncSession = Depends(get_db)):
try:
# 获取全量数据
dict_data_query_result = await DictDataService.query_dict_data_list_from_cache_services(request.app.state.redis, dict_type)
@@ -144,10 +144,10 @@ async def query_system_dict_type_data(request: Request, dict_type: str, query_db
@dictController.get("/data/list", response_model=PageResponseModel, dependencies=[Depends(CheckUserInterfaceAuth('system:dict:list'))])
-async def get_system_dict_data_list(request: Request, dict_data_page_query: DictDataPageQueryModel = Depends(DictDataPageQueryModel.as_query), query_db: Session = Depends(get_db)):
+async def get_system_dict_data_list(request: Request, dict_data_page_query: DictDataPageQueryModel = Depends(DictDataPageQueryModel.as_query), query_db: AsyncSession = Depends(get_db)):
try:
# 获取分页数据
- dict_data_page_query_result = DictDataService.get_dict_data_list_services(query_db, dict_data_page_query, is_page=True)
+ dict_data_page_query_result = await DictDataService.get_dict_data_list_services(query_db, dict_data_page_query, is_page=True)
logger.info('获取成功')
return ResponseUtil.success(model_content=dict_data_page_query_result)
except Exception as e:
@@ -157,7 +157,7 @@ async def get_system_dict_data_list(request: Request, dict_data_page_query: Dict
@dictController.post("/data", dependencies=[Depends(CheckUserInterfaceAuth('system:dict:add'))])
@log_decorator(title='字典管理', business_type=1)
-async def add_system_dict_data(request: Request, add_dict_data: DictDataModel, query_db: Session = Depends(get_db), current_user: CurrentUserModel = Depends(LoginService.get_current_user)):
+async def add_system_dict_data(request: Request, add_dict_data: DictDataModel, query_db: AsyncSession = Depends(get_db), current_user: CurrentUserModel = Depends(LoginService.get_current_user)):
try:
add_dict_data.create_by = current_user.user.user_name
add_dict_data.update_by = current_user.user.user_name
@@ -175,7 +175,7 @@ async def add_system_dict_data(request: Request, add_dict_data: DictDataModel, q
@dictController.put("/data", dependencies=[Depends(CheckUserInterfaceAuth('system:dict:edit'))])
@log_decorator(title='字典管理', business_type=2)
-async def edit_system_dict_data(request: Request, edit_dict_data: DictDataModel, query_db: Session = Depends(get_db), current_user: CurrentUserModel = Depends(LoginService.get_current_user)):
+async def edit_system_dict_data(request: Request, edit_dict_data: DictDataModel, query_db: AsyncSession = Depends(get_db), current_user: CurrentUserModel = Depends(LoginService.get_current_user)):
try:
edit_dict_data.update_by = current_user.user.user_name
edit_dict_data.update_time = datetime.now()
@@ -193,7 +193,7 @@ async def edit_system_dict_data(request: Request, edit_dict_data: DictDataModel,
@dictController.delete("/data/{dict_codes}", dependencies=[Depends(CheckUserInterfaceAuth('system:dict:remove'))])
@log_decorator(title='字典管理', business_type=3)
-async def delete_system_dict_data(request: Request, dict_codes: str, query_db: Session = Depends(get_db)):
+async def delete_system_dict_data(request: Request, dict_codes: str, query_db: AsyncSession = Depends(get_db)):
try:
delete_dict_data = DeleteDictDataModel(dictCodes=dict_codes)
delete_dict_data_result = await DictDataService.delete_dict_data_services(request, query_db, delete_dict_data)
@@ -209,9 +209,9 @@ async def delete_system_dict_data(request: Request, dict_codes: str, query_db: S
@dictController.get("/data/{dict_code}", response_model=DictDataModel, dependencies=[Depends(CheckUserInterfaceAuth('system:dict:query'))])
-async def query_detail_system_dict_data(request: Request, dict_code: int, query_db: Session = Depends(get_db)):
+async def query_detail_system_dict_data(request: Request, dict_code: int, query_db: AsyncSession = Depends(get_db)):
try:
- detail_dict_data_result = DictDataService.dict_data_detail_services(query_db, dict_code)
+ detail_dict_data_result = await DictDataService.dict_data_detail_services(query_db, dict_code)
logger.info(f'获取dict_code为{dict_code}的信息成功')
return ResponseUtil.success(data=detail_dict_data_result)
except Exception as e:
@@ -221,11 +221,11 @@ async def query_detail_system_dict_data(request: Request, dict_code: int, query_
@dictController.post("/data/export", dependencies=[Depends(CheckUserInterfaceAuth('system:dict:export'))])
@log_decorator(title='字典管理', business_type=5)
-async def export_system_dict_data_list(request: Request, dict_data_page_query: DictDataPageQueryModel = Depends(DictDataPageQueryModel.as_form), query_db: Session = Depends(get_db)):
+async def export_system_dict_data_list(request: Request, dict_data_page_query: DictDataPageQueryModel = Depends(DictDataPageQueryModel.as_form), query_db: AsyncSession = Depends(get_db)):
try:
# 获取全量数据
- dict_data_query_result = DictDataService.get_dict_data_list_services(query_db, dict_data_page_query, is_page=False)
- dict_data_export_result = DictDataService.export_dict_data_list_services(dict_data_query_result)
+ dict_data_query_result = await DictDataService.get_dict_data_list_services(query_db, dict_data_page_query, is_page=False)
+ dict_data_export_result = await DictDataService.export_dict_data_list_services(dict_data_query_result)
logger.info('导出成功')
return ResponseUtil.streaming(data=bytes2file_response(dict_data_export_result))
except Exception as e:
diff --git a/ruoyi-fastapi-backend/module_admin/controller/job_controller.py b/ruoyi-fastapi-backend/module_admin/controller/job_controller.py
index 8b340ee59be13f7048c066d5c990204d5201be21..220472223914a7486a38847fb20a4f75371b9dd7 100644
--- a/ruoyi-fastapi-backend/module_admin/controller/job_controller.py
+++ b/ruoyi-fastapi-backend/module_admin/controller/job_controller.py
@@ -16,10 +16,10 @@ jobController = APIRouter(prefix='/monitor', dependencies=[Depends(LoginService.
@jobController.get("/job/list", response_model=PageResponseModel, dependencies=[Depends(CheckUserInterfaceAuth('monitor:job:list'))])
-async def get_system_job_list(request: Request, job_page_query: JobPageQueryModel = Depends(JobPageQueryModel.as_query), query_db: Session = Depends(get_db)):
+async def get_system_job_list(request: Request, job_page_query: JobPageQueryModel = Depends(JobPageQueryModel.as_query), query_db: AsyncSession = Depends(get_db)):
try:
# 获取分页数据
- notice_page_query_result = JobService.get_job_list_services(query_db, job_page_query, is_page=True)
+ notice_page_query_result = await JobService.get_job_list_services(query_db, job_page_query, is_page=True)
logger.info('获取成功')
return ResponseUtil.success(model_content=notice_page_query_result)
except Exception as e:
@@ -29,11 +29,11 @@ async def get_system_job_list(request: Request, job_page_query: JobPageQueryMode
@jobController.post("/job", dependencies=[Depends(CheckUserInterfaceAuth('monitor:job:add'))])
@log_decorator(title='定时任务管理', business_type=1)
-async def add_system_job(request: Request, add_job: JobModel, query_db: Session = Depends(get_db), current_user: CurrentUserModel = Depends(LoginService.get_current_user)):
+async def add_system_job(request: Request, add_job: JobModel, query_db: AsyncSession = Depends(get_db), current_user: CurrentUserModel = Depends(LoginService.get_current_user)):
try:
add_job.create_by = current_user.user.user_name
add_job.update_by = current_user.user.user_name
- add_job_result = JobService.add_job_services(query_db, add_job)
+ add_job_result = await JobService.add_job_services(query_db, add_job)
if add_job_result.is_success:
logger.info(add_job_result.message)
return ResponseUtil.success(msg=add_job_result.message)
@@ -47,11 +47,11 @@ async def add_system_job(request: Request, add_job: JobModel, query_db: Session
@jobController.put("/job", dependencies=[Depends(CheckUserInterfaceAuth('monitor:job:edit'))])
@log_decorator(title='定时任务管理', business_type=2)
-async def edit_system_job(request: Request, edit_job: EditJobModel, query_db: Session = Depends(get_db), current_user: CurrentUserModel = Depends(LoginService.get_current_user)):
+async def edit_system_job(request: Request, edit_job: EditJobModel, query_db: AsyncSession = Depends(get_db), current_user: CurrentUserModel = Depends(LoginService.get_current_user)):
try:
edit_job.update_by = current_user.user.user_name
edit_job.update_time = datetime.now()
- edit_job_result = JobService.edit_job_services(query_db, edit_job)
+ edit_job_result = await JobService.edit_job_services(query_db, edit_job)
if edit_job_result.is_success:
logger.info(edit_job_result.message)
return ResponseUtil.success(msg=edit_job_result.message)
@@ -65,12 +65,12 @@ async def edit_system_job(request: Request, edit_job: EditJobModel, query_db: Se
@jobController.put("/job/changeStatus", dependencies=[Depends(CheckUserInterfaceAuth('monitor:job:changeStatus'))])
@log_decorator(title='定时任务管理', business_type=2)
-async def edit_system_job(request: Request, edit_job: EditJobModel, query_db: Session = Depends(get_db), current_user: CurrentUserModel = Depends(LoginService.get_current_user)):
+async def edit_system_job(request: Request, edit_job: EditJobModel, query_db: AsyncSession = Depends(get_db), current_user: CurrentUserModel = Depends(LoginService.get_current_user)):
try:
edit_job.update_by = current_user.user.user_name
edit_job.update_time = datetime.now()
edit_job.type = 'status'
- edit_job_result = JobService.edit_job_services(query_db, edit_job)
+ edit_job_result = await JobService.edit_job_services(query_db, edit_job)
if edit_job_result.is_success:
logger.info(edit_job_result.message)
return ResponseUtil.success(msg=edit_job_result.message)
@@ -84,9 +84,9 @@ async def edit_system_job(request: Request, edit_job: EditJobModel, query_db: Se
@jobController.put("/job/run", dependencies=[Depends(CheckUserInterfaceAuth('monitor:job:changeStatus'))])
@log_decorator(title='定时任务管理', business_type=2)
-async def execute_system_job(request: Request, execute_job: JobModel, query_db: Session = Depends(get_db)):
+async def execute_system_job(request: Request, execute_job: JobModel, query_db: AsyncSession = Depends(get_db)):
try:
- execute_job_result = JobService.execute_job_once_services(query_db, execute_job)
+ execute_job_result = await JobService.execute_job_once_services(query_db, execute_job)
if execute_job_result.is_success:
logger.info(execute_job_result.message)
return ResponseUtil.success(msg=execute_job_result.message)
@@ -100,10 +100,10 @@ async def execute_system_job(request: Request, execute_job: JobModel, query_db:
@jobController.delete("/job/{job_ids}", dependencies=[Depends(CheckUserInterfaceAuth('monitor:job:remove'))])
@log_decorator(title='定时任务管理', business_type=3)
-async def delete_system_job(request: Request, job_ids: str, query_db: Session = Depends(get_db)):
+async def delete_system_job(request: Request, job_ids: str, query_db: AsyncSession = Depends(get_db)):
try:
delete_job = DeleteJobModel(jobIds=job_ids)
- delete_job_result = JobService.delete_job_services(query_db, delete_job)
+ delete_job_result = await JobService.delete_job_services(query_db, delete_job)
if delete_job_result.is_success:
logger.info(delete_job_result.message)
return ResponseUtil.success(msg=delete_job_result.message)
@@ -116,9 +116,9 @@ async def delete_system_job(request: Request, job_ids: str, query_db: Session =
@jobController.get("/job/{job_id}", response_model=JobModel, dependencies=[Depends(CheckUserInterfaceAuth('monitor:job:query'))])
-async def query_detail_system_job(request: Request, job_id: int, query_db: Session = Depends(get_db)):
+async def query_detail_system_job(request: Request, job_id: int, query_db: AsyncSession = Depends(get_db)):
try:
- job_detail_result = JobService.job_detail_services(query_db, job_id)
+ job_detail_result = await JobService.job_detail_services(query_db, job_id)
logger.info(f'获取job_id为{job_id}的信息成功')
return ResponseUtil.success(data=job_detail_result)
except Exception as e:
@@ -128,10 +128,10 @@ async def query_detail_system_job(request: Request, job_id: int, query_db: Sessi
@jobController.post("/job/export", dependencies=[Depends(CheckUserInterfaceAuth('monitor:job:export'))])
@log_decorator(title='定时任务管理', business_type=5)
-async def export_system_job_list(request: Request, job_page_query: JobPageQueryModel = Depends(JobPageQueryModel.as_form), query_db: Session = Depends(get_db)):
+async def export_system_job_list(request: Request, job_page_query: JobPageQueryModel = Depends(JobPageQueryModel.as_form), query_db: AsyncSession = Depends(get_db)):
try:
# 获取全量数据
- job_query_result = JobService.get_job_list_services(query_db, job_page_query, is_page=False)
+ job_query_result = await JobService.get_job_list_services(query_db, job_page_query, is_page=False)
job_export_result = await JobService.export_job_list_services(request, job_query_result)
logger.info('导出成功')
return ResponseUtil.streaming(data=bytes2file_response(job_export_result))
@@ -141,10 +141,10 @@ async def export_system_job_list(request: Request, job_page_query: JobPageQueryM
@jobController.get("/jobLog/list", response_model=PageResponseModel, dependencies=[Depends(CheckUserInterfaceAuth('monitor:job:list'))])
-async def get_system_job_log_list(request: Request, job_log_page_query: JobLogPageQueryModel = Depends(JobLogPageQueryModel.as_query), query_db: Session = Depends(get_db)):
+async def get_system_job_log_list(request: Request, job_log_page_query: JobLogPageQueryModel = Depends(JobLogPageQueryModel.as_query), query_db: AsyncSession = Depends(get_db)):
try:
# 获取分页数据
- job_log_page_query_result = JobLogService.get_job_log_list_services(query_db, job_log_page_query, is_page=True)
+ job_log_page_query_result = await JobLogService.get_job_log_list_services(query_db, job_log_page_query, is_page=True)
logger.info('获取成功')
return ResponseUtil.success(model_content=job_log_page_query_result)
except Exception as e:
@@ -152,12 +152,28 @@ async def get_system_job_log_list(request: Request, job_log_page_query: JobLogPa
return ResponseUtil.error(msg=str(e))
+@jobController.delete("/jobLog/clean", dependencies=[Depends(CheckUserInterfaceAuth('monitor:job:remove'))])
+@log_decorator(title='定时任务日志管理', business_type=9)
+async def clear_system_job_log(request: Request, query_db: AsyncSession = Depends(get_db)):
+ try:
+ 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)
+ else:
+ logger.warning(clear_job_log_result.message)
+ return ResponseUtil.failure(msg=clear_job_log_result.message)
+ except Exception as e:
+ logger.exception(e)
+ 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: Session = Depends(get_db)):
+async def delete_system_job_log(request: Request, job_log_ids: str, query_db: AsyncSession = Depends(get_db)):
try:
delete_job_log = DeleteJobLogModel(jobLogIds=job_log_ids)
- delete_job_log_result = JobLogService.delete_job_log_services(query_db, delete_job_log)
+ delete_job_log_result = await JobLogService.delete_job_log_services(query_db, delete_job_log)
if delete_job_log_result.is_success:
logger.info(delete_job_log_result.message)
return ResponseUtil.success(msg=delete_job_log_result.message)
@@ -169,28 +185,12 @@ async def delete_system_job_log(request: Request, job_log_ids: str, query_db: Se
return ResponseUtil.error(msg=str(e))
-@jobController.post("/jobLog/clean", dependencies=[Depends(CheckUserInterfaceAuth('monitor:job:remove'))])
-@log_decorator(title='定时任务日志管理', business_type=9)
-async def clear_system_job_log(request: Request, query_db: Session = Depends(get_db)):
- try:
- clear_job_log_result = 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)
- else:
- logger.warning(clear_job_log_result.message)
- return ResponseUtil.failure(msg=clear_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))
diff --git a/ruoyi-fastapi-backend/module_admin/controller/log_controller.py b/ruoyi-fastapi-backend/module_admin/controller/log_controller.py
index 6b2135816c593ea2b43e3592c702739ec18071f8..a0a18c5567bbb3bfcd9ec02310bad312d85d48ce 100644
--- a/ruoyi-fastapi-backend/module_admin/controller/log_controller.py
+++ b/ruoyi-fastapi-backend/module_admin/controller/log_controller.py
@@ -15,10 +15,10 @@ logController = APIRouter(prefix='/monitor', dependencies=[Depends(LoginService.
@logController.get("/operlog/list", response_model=PageResponseModel, dependencies=[Depends(CheckUserInterfaceAuth('monitor:operlog:list'))])
-async def get_system_operation_log_list(request: Request, operation_log_page_query: OperLogPageQueryModel = Depends(OperLogPageQueryModel.as_query), query_db: Session = Depends(get_db)):
+async def get_system_operation_log_list(request: Request, operation_log_page_query: OperLogPageQueryModel = Depends(OperLogPageQueryModel.as_query), query_db: AsyncSession = Depends(get_db)):
try:
# 获取分页数据
- operation_log_page_query_result = OperationLogService.get_operation_log_list_services(query_db, operation_log_page_query, is_page=True)
+ operation_log_page_query_result = await OperationLogService.get_operation_log_list_services(query_db, operation_log_page_query, is_page=True)
logger.info('获取成功')
return ResponseUtil.success(model_content=operation_log_page_query_result)
except Exception as e:
@@ -28,9 +28,9 @@ async def get_system_operation_log_list(request: Request, operation_log_page_que
@logController.delete("/operlog/clean", dependencies=[Depends(CheckUserInterfaceAuth('monitor:operlog:remove'))])
@log_decorator(title='操作日志管理', business_type=9)
-async def clear_system_operation_log(request: Request, query_db: Session = Depends(get_db)):
+async def clear_system_operation_log(request: Request, query_db: AsyncSession = Depends(get_db)):
try:
- clear_operation_log_result = OperationLogService.clear_operation_log_services(query_db)
+ clear_operation_log_result = await OperationLogService.clear_operation_log_services(query_db)
if clear_operation_log_result.is_success:
logger.info(clear_operation_log_result.message)
return ResponseUtil.success(msg=clear_operation_log_result.message)
@@ -44,10 +44,10 @@ async def clear_system_operation_log(request: Request, query_db: Session = Depen
@logController.delete("/operlog/{oper_ids}", dependencies=[Depends(CheckUserInterfaceAuth('monitor:operlog:remove'))])
@log_decorator(title='操作日志管理', business_type=3)
-async def delete_system_operation_log(request: Request, oper_ids: str, query_db: Session = Depends(get_db)):
+async def delete_system_operation_log(request: Request, oper_ids: str, query_db: AsyncSession = Depends(get_db)):
try:
delete_operation_log = DeleteOperLogModel(operIds=oper_ids)
- delete_operation_log_result = OperationLogService.delete_operation_log_services(query_db, delete_operation_log)
+ delete_operation_log_result = await OperationLogService.delete_operation_log_services(query_db, delete_operation_log)
if delete_operation_log_result.is_success:
logger.info(delete_operation_log_result.message)
return ResponseUtil.success(msg=delete_operation_log_result.message)
@@ -61,10 +61,10 @@ async def delete_system_operation_log(request: Request, oper_ids: str, query_db:
@logController.post("/operlog/export", dependencies=[Depends(CheckUserInterfaceAuth('monitor:operlog:export'))])
@log_decorator(title='操作日志管理', business_type=5)
-async def export_system_operation_log_list(request: Request, operation_log_page_query: OperLogPageQueryModel = Depends(OperLogPageQueryModel.as_form), query_db: Session = Depends(get_db)):
+async def export_system_operation_log_list(request: Request, operation_log_page_query: OperLogPageQueryModel = Depends(OperLogPageQueryModel.as_form), query_db: AsyncSession = Depends(get_db)):
try:
# 获取全量数据
- operation_log_query_result = OperationLogService.get_operation_log_list_services(query_db, operation_log_page_query, is_page=False)
+ operation_log_query_result = await OperationLogService.get_operation_log_list_services(query_db, operation_log_page_query, is_page=False)
operation_log_export_result = await OperationLogService.export_operation_log_list_services(request, operation_log_query_result)
logger.info('导出成功')
return ResponseUtil.streaming(data=bytes2file_response(operation_log_export_result))
@@ -74,10 +74,10 @@ async def export_system_operation_log_list(request: Request, operation_log_page_
@logController.get("/logininfor/list", response_model=PageResponseModel, dependencies=[Depends(CheckUserInterfaceAuth('monitor:logininfor:list'))])
-async def get_system_login_log_list(request: Request, login_log_page_query: LoginLogPageQueryModel = Depends(LoginLogPageQueryModel.as_query), query_db: Session = Depends(get_db)):
+async def get_system_login_log_list(request: Request, login_log_page_query: LoginLogPageQueryModel = Depends(LoginLogPageQueryModel.as_query), query_db: AsyncSession = Depends(get_db)):
try:
# 获取分页数据
- login_log_page_query_result = LoginLogService.get_login_log_list_services(query_db, login_log_page_query, is_page=True)
+ login_log_page_query_result = await LoginLogService.get_login_log_list_services(query_db, login_log_page_query, is_page=True)
logger.info('获取成功')
return ResponseUtil.success(model_content=login_log_page_query_result)
except Exception as e:
@@ -87,9 +87,9 @@ async def get_system_login_log_list(request: Request, login_log_page_query: Logi
@logController.delete("/logininfor/clean", dependencies=[Depends(CheckUserInterfaceAuth('monitor:logininfor:remove'))])
@log_decorator(title='登录日志管理', business_type=9)
-async def clear_system_login_log(request: Request, query_db: Session = Depends(get_db)):
+async def clear_system_login_log(request: Request, query_db: AsyncSession = Depends(get_db)):
try:
- clear_login_log_result = LoginLogService.clear_login_log_services(query_db)
+ clear_login_log_result = await LoginLogService.clear_login_log_services(query_db)
if clear_login_log_result.is_success:
logger.info(clear_login_log_result.message)
return ResponseUtil.success(msg=clear_login_log_result.message)
@@ -103,10 +103,10 @@ async def clear_system_login_log(request: Request, query_db: Session = Depends(g
@logController.delete("/logininfor/{info_ids}", dependencies=[Depends(CheckUserInterfaceAuth('monitor:logininfor:remove'))])
@log_decorator(title='登录日志管理', business_type=3)
-async def delete_system_login_log(request: Request, info_ids: str, query_db: Session = Depends(get_db)):
+async def delete_system_login_log(request: Request, info_ids: str, query_db: AsyncSession = Depends(get_db)):
try:
delete_login_log = DeleteLoginLogModel(infoIds=info_ids)
- delete_login_log_result = LoginLogService.delete_login_log_services(query_db, delete_login_log)
+ delete_login_log_result = await LoginLogService.delete_login_log_services(query_db, delete_login_log)
if delete_login_log_result.is_success:
logger.info(delete_login_log_result.message)
return ResponseUtil.success(msg=delete_login_log_result.message)
@@ -120,7 +120,7 @@ async def delete_system_login_log(request: Request, info_ids: str, query_db: Ses
@logController.get("/logininfor/unlock/{user_name}", dependencies=[Depends(CheckUserInterfaceAuth('monitor:logininfor:unlock'))])
@log_decorator(title='登录日志管理', business_type=0)
-async def clear_system_login_log(request: Request, user_name: str, query_db: Session = Depends(get_db)):
+async def clear_system_login_log(request: Request, user_name: str, query_db: AsyncSession = Depends(get_db)):
try:
unlock_user = UnlockUser(userName=user_name)
unlock_user_result = await LoginLogService.unlock_user_services(request, unlock_user)
@@ -137,11 +137,11 @@ async def clear_system_login_log(request: Request, user_name: str, query_db: Ses
@logController.post("/logininfor/export", dependencies=[Depends(CheckUserInterfaceAuth('monitor:logininfor:export'))])
@log_decorator(title='登录日志管理', business_type=5)
-async def export_system_login_log_list(request: Request, login_log_page_query: LoginLogPageQueryModel = Depends(LoginLogPageQueryModel.as_form), query_db: Session = Depends(get_db)):
+async def export_system_login_log_list(request: Request, login_log_page_query: LoginLogPageQueryModel = Depends(LoginLogPageQueryModel.as_form), query_db: AsyncSession = Depends(get_db)):
try:
# 获取全量数据
- login_log_query_result = LoginLogService.get_login_log_list_services(query_db, login_log_page_query, is_page=False)
- login_log_export_result = LoginLogService.export_login_log_list_services(login_log_query_result)
+ login_log_query_result = await LoginLogService.get_login_log_list_services(query_db, login_log_page_query, is_page=False)
+ login_log_export_result = await LoginLogService.export_login_log_list_services(login_log_query_result)
logger.info('导出成功')
return ResponseUtil.streaming(data=bytes2file_response(login_log_export_result))
except Exception as e:
diff --git a/ruoyi-fastapi-backend/module_admin/controller/login_controller.py b/ruoyi-fastapi-backend/module_admin/controller/login_controller.py
index 2b8b271179f8c0664423aaf329bec32cf1783fb1..74b495ce310cbb2af1aea2840b56421a009fea4e 100644
--- a/ruoyi-fastapi-backend/module_admin/controller/login_controller.py
+++ b/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:
diff --git a/ruoyi-fastapi-backend/module_admin/controller/menu_controller.py b/ruoyi-fastapi-backend/module_admin/controller/menu_controller.py
index 53a534aa52f0803526766efacd9ae7868432962d..49d1db045334156cf186be88c2769e23dcc19e76 100644
--- a/ruoyi-fastapi-backend/module_admin/controller/menu_controller.py
+++ b/ruoyi-fastapi-backend/module_admin/controller/menu_controller.py
@@ -13,9 +13,9 @@ menuController = APIRouter(prefix='/system/menu', dependencies=[Depends(LoginSer
@menuController.get("/treeselect")
-async def get_system_menu_tree(request: Request, query_db: Session = Depends(get_db), current_user: CurrentUserModel = Depends(LoginService.get_current_user)):
+async def get_system_menu_tree(request: Request, query_db: AsyncSession = Depends(get_db), current_user: CurrentUserModel = Depends(LoginService.get_current_user)):
try:
- menu_query_result = MenuService.get_menu_tree_services(query_db, current_user)
+ menu_query_result = await MenuService.get_menu_tree_services(query_db, current_user)
logger.info('获取成功')
return ResponseUtil.success(data=menu_query_result)
except Exception as e:
@@ -24,9 +24,9 @@ async def get_system_menu_tree(request: Request, query_db: Session = Depends(get
@menuController.get("/roleMenuTreeselect/{role_id}")
-async def get_system_role_menu_tree(request: Request, role_id: int, query_db: Session = Depends(get_db), current_user: CurrentUserModel = Depends(LoginService.get_current_user)):
+async def get_system_role_menu_tree(request: Request, role_id: int, query_db: AsyncSession = Depends(get_db), current_user: CurrentUserModel = Depends(LoginService.get_current_user)):
try:
- role_menu_query_result = MenuService.get_role_menu_tree_services(query_db, role_id, current_user)
+ role_menu_query_result = await MenuService.get_role_menu_tree_services(query_db, role_id, current_user)
logger.info('获取成功')
return ResponseUtil.success(model_content=role_menu_query_result)
except Exception as e:
@@ -35,9 +35,9 @@ async def get_system_role_menu_tree(request: Request, role_id: int, query_db: Se
@menuController.get("/list", response_model=List[MenuModel], dependencies=[Depends(CheckUserInterfaceAuth('system:menu:list'))])
-async def get_system_menu_list(request: Request, menu_query: MenuQueryModel = Depends(MenuQueryModel.as_query), query_db: Session = Depends(get_db), current_user: CurrentUserModel = Depends(LoginService.get_current_user)):
+async def get_system_menu_list(request: Request, menu_query: MenuQueryModel = Depends(MenuQueryModel.as_query), query_db: AsyncSession = Depends(get_db), current_user: CurrentUserModel = Depends(LoginService.get_current_user)):
try:
- menu_query_result = MenuService.get_menu_list_services(query_db, menu_query, current_user)
+ menu_query_result = await MenuService.get_menu_list_services(query_db, menu_query, current_user)
logger.info('获取成功')
return ResponseUtil.success(data=menu_query_result)
except Exception as e:
@@ -47,11 +47,11 @@ async def get_system_menu_list(request: Request, menu_query: MenuQueryModel = De
@menuController.post("", dependencies=[Depends(CheckUserInterfaceAuth('system:menu:add'))])
@log_decorator(title='菜单管理', business_type=1)
-async def add_system_menu(request: Request, add_menu: MenuModel, query_db: Session = Depends(get_db), current_user: CurrentUserModel = Depends(LoginService.get_current_user)):
+async def add_system_menu(request: Request, add_menu: MenuModel, query_db: AsyncSession = Depends(get_db), current_user: CurrentUserModel = Depends(LoginService.get_current_user)):
try:
add_menu.create_by = current_user.user.user_name
add_menu.update_by = current_user.user.user_name
- add_menu_result = MenuService.add_menu_services(query_db, add_menu)
+ add_menu_result = await MenuService.add_menu_services(query_db, add_menu)
if add_menu_result.is_success:
logger.info(add_menu_result.message)
return ResponseUtil.success(msg=add_menu_result.message)
@@ -65,11 +65,11 @@ async def add_system_menu(request: Request, add_menu: MenuModel, query_db: Sessi
@menuController.put("", dependencies=[Depends(CheckUserInterfaceAuth('system:menu:edit'))])
@log_decorator(title='菜单管理', business_type=2)
-async def edit_system_menu(request: Request, edit_menu: MenuModel, query_db: Session = Depends(get_db), current_user: CurrentUserModel = Depends(LoginService.get_current_user)):
+async def edit_system_menu(request: Request, edit_menu: MenuModel, query_db: AsyncSession = Depends(get_db), current_user: CurrentUserModel = Depends(LoginService.get_current_user)):
try:
edit_menu.update_by = current_user.user.user_name
edit_menu.update_time = datetime.now()
- edit_menu_result = MenuService.edit_menu_services(query_db, edit_menu)
+ edit_menu_result = await MenuService.edit_menu_services(query_db, edit_menu)
if edit_menu_result.is_success:
logger.info(edit_menu_result.message)
return ResponseUtil.success(msg=edit_menu_result.message)
@@ -83,10 +83,10 @@ async def edit_system_menu(request: Request, edit_menu: MenuModel, query_db: Ses
@menuController.delete("/{menu_ids}", dependencies=[Depends(CheckUserInterfaceAuth('system:menu:remove'))])
@log_decorator(title='菜单管理', business_type=3)
-async def delete_system_menu(request: Request, menu_ids: str, query_db: Session = Depends(get_db)):
+async def delete_system_menu(request: Request, menu_ids: str, query_db: AsyncSession = Depends(get_db)):
try:
delete_menu = DeleteMenuModel(menuIds=menu_ids)
- delete_menu_result = MenuService.delete_menu_services(query_db, delete_menu)
+ delete_menu_result = await MenuService.delete_menu_services(query_db, delete_menu)
if delete_menu_result.is_success:
logger.info(delete_menu_result.message)
return ResponseUtil.success(msg=delete_menu_result.message)
@@ -99,9 +99,9 @@ async def delete_system_menu(request: Request, menu_ids: str, query_db: Session
@menuController.get("/{menu_id}", response_model=MenuModel, dependencies=[Depends(CheckUserInterfaceAuth('system:menu:query'))])
-async def query_detail_system_menu(request: Request, menu_id: int, query_db: Session = Depends(get_db)):
+async def query_detail_system_menu(request: Request, menu_id: int, query_db: AsyncSession = Depends(get_db)):
try:
- menu_detail_result = MenuService.menu_detail_services(query_db, menu_id)
+ menu_detail_result = await MenuService.menu_detail_services(query_db, menu_id)
logger.info(f'获取menu_id为{menu_id}的信息成功')
return ResponseUtil.success(data=menu_detail_result)
except Exception as e:
diff --git a/ruoyi-fastapi-backend/module_admin/controller/notice_controller.py b/ruoyi-fastapi-backend/module_admin/controller/notice_controller.py
index 4caaa7a680a4cacc1e4246ee46a0c648c2c93ae2..1525727e0fb7684d090d601592e87ba34b3cb62f 100644
--- a/ruoyi-fastapi-backend/module_admin/controller/notice_controller.py
+++ b/ruoyi-fastapi-backend/module_admin/controller/notice_controller.py
@@ -14,10 +14,10 @@ noticeController = APIRouter(prefix='/system/notice', dependencies=[Depends(Logi
@noticeController.get("/list", response_model=PageResponseModel, dependencies=[Depends(CheckUserInterfaceAuth('system:notice:list'))])
-async def get_system_notice_list(request: Request, notice_page_query: NoticePageQueryModel = Depends(NoticePageQueryModel.as_query), query_db: Session = Depends(get_db)):
+async def get_system_notice_list(request: Request, notice_page_query: NoticePageQueryModel = Depends(NoticePageQueryModel.as_query), query_db: AsyncSession = Depends(get_db)):
try:
# 获取分页数据
- notice_page_query_result = NoticeService.get_notice_list_services(query_db, notice_page_query, is_page=True)
+ notice_page_query_result = await NoticeService.get_notice_list_services(query_db, notice_page_query, is_page=True)
logger.info('获取成功')
return ResponseUtil.success(model_content=notice_page_query_result)
except Exception as e:
@@ -27,11 +27,11 @@ async def get_system_notice_list(request: Request, notice_page_query: NoticePage
@noticeController.post("", dependencies=[Depends(CheckUserInterfaceAuth('system:notice:add'))])
@log_decorator(title='通知公告管理', business_type=1)
-async def add_system_notice(request: Request, add_notice: NoticeModel, query_db: Session = Depends(get_db), current_user: CurrentUserModel = Depends(LoginService.get_current_user)):
+async def add_system_notice(request: Request, add_notice: NoticeModel, query_db: AsyncSession = Depends(get_db), current_user: CurrentUserModel = Depends(LoginService.get_current_user)):
try:
add_notice.create_by = current_user.user.user_name
add_notice.update_by = current_user.user.user_name
- add_notice_result = NoticeService.add_notice_services(query_db, add_notice)
+ add_notice_result = await NoticeService.add_notice_services(query_db, add_notice)
if add_notice_result.is_success:
logger.info(add_notice_result.message)
return ResponseUtil.success(msg=add_notice_result.message)
@@ -45,11 +45,11 @@ async def add_system_notice(request: Request, add_notice: NoticeModel, query_db:
@noticeController.put("", dependencies=[Depends(CheckUserInterfaceAuth('system:notice:edit'))])
@log_decorator(title='通知公告管理', business_type=2)
-async def edit_system_notice(request: Request, edit_notice: NoticeModel, query_db: Session = Depends(get_db), current_user: CurrentUserModel = Depends(LoginService.get_current_user)):
+async def edit_system_notice(request: Request, edit_notice: NoticeModel, query_db: AsyncSession = Depends(get_db), current_user: CurrentUserModel = Depends(LoginService.get_current_user)):
try:
edit_notice.update_by = current_user.user.user_name
edit_notice.update_time = datetime.now()
- edit_notice_result = NoticeService.edit_notice_services(query_db, edit_notice)
+ edit_notice_result = await NoticeService.edit_notice_services(query_db, edit_notice)
if edit_notice_result.is_success:
logger.info(edit_notice_result.message)
return ResponseUtil.success(msg=edit_notice_result.message)
@@ -63,10 +63,10 @@ async def edit_system_notice(request: Request, edit_notice: NoticeModel, query_d
@noticeController.delete("/{notice_ids}", dependencies=[Depends(CheckUserInterfaceAuth('system:notice:remove'))])
@log_decorator(title='通知公告管理', business_type=3)
-async def delete_system_notice(request: Request, notice_ids: str, query_db: Session = Depends(get_db)):
+async def delete_system_notice(request: Request, notice_ids: str, query_db: AsyncSession = Depends(get_db)):
try:
delete_notice = DeleteNoticeModel(noticeIds=notice_ids)
- delete_notice_result = NoticeService.delete_notice_services(query_db, delete_notice)
+ delete_notice_result = await NoticeService.delete_notice_services(query_db, delete_notice)
if delete_notice_result.is_success:
logger.info(delete_notice_result.message)
return ResponseUtil.success(msg=delete_notice_result.message)
@@ -79,9 +79,9 @@ async def delete_system_notice(request: Request, notice_ids: str, query_db: Sess
@noticeController.get("/{notice_id}", response_model=NoticeModel, dependencies=[Depends(CheckUserInterfaceAuth('system:notice:query'))])
-async def query_detail_system_post(request: Request, notice_id: int, query_db: Session = Depends(get_db)):
+async def query_detail_system_post(request: Request, notice_id: int, query_db: AsyncSession = Depends(get_db)):
try:
- notice_detail_result = NoticeService.notice_detail_services(query_db, notice_id)
+ notice_detail_result = await NoticeService.notice_detail_services(query_db, notice_id)
logger.info(f'获取notice_id为{notice_id}的信息成功')
return ResponseUtil.success(data=notice_detail_result)
except Exception as e:
diff --git a/ruoyi-fastapi-backend/module_admin/controller/online_controller.py b/ruoyi-fastapi-backend/module_admin/controller/online_controller.py
index cecee5f358bfa554fb9ac8eacca292ed24faf427..747cc13c7eb3fb50dbe1e2e5fd511aca0dafdb91 100644
--- a/ruoyi-fastapi-backend/module_admin/controller/online_controller.py
+++ b/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)
diff --git a/ruoyi-fastapi-backend/module_admin/controller/post_controler.py b/ruoyi-fastapi-backend/module_admin/controller/post_controler.py
index ebf41ea78e393355c7b57bb7c3aa7b65fe60a4c5..046ec635f3eb6b0f23263a761d64398b326315ce 100644
--- a/ruoyi-fastapi-backend/module_admin/controller/post_controler.py
+++ b/ruoyi-fastapi-backend/module_admin/controller/post_controler.py
@@ -16,10 +16,10 @@ postController = APIRouter(prefix='/system/post', dependencies=[Depends(LoginSer
@postController.get("/list", response_model=PageResponseModel, dependencies=[Depends(CheckUserInterfaceAuth('system:post:list'))])
-async def get_system_post_list(request: Request, post_page_query: PostPageQueryModel = Depends(PostPageQueryModel.as_query), query_db: Session = Depends(get_db)):
+async def get_system_post_list(request: Request, post_page_query: PostPageQueryModel = Depends(PostPageQueryModel.as_query), query_db: AsyncSession = Depends(get_db)):
try:
# 获取分页数据
- post_page_query_result = PostService.get_post_list_services(query_db, post_page_query, is_page=True)
+ post_page_query_result = await PostService.get_post_list_services(query_db, post_page_query, is_page=True)
logger.info('获取成功')
return ResponseUtil.success(model_content=post_page_query_result)
except Exception as e:
@@ -29,11 +29,11 @@ async def get_system_post_list(request: Request, post_page_query: PostPageQueryM
@postController.post("", dependencies=[Depends(CheckUserInterfaceAuth('system:post:add'))])
@log_decorator(title='岗位管理', business_type=1)
-async def add_system_post(request: Request, add_post: PostModel, query_db: Session = Depends(get_db), current_user: CurrentUserModel = Depends(LoginService.get_current_user)):
+async def add_system_post(request: Request, add_post: PostModel, query_db: AsyncSession = Depends(get_db), current_user: CurrentUserModel = Depends(LoginService.get_current_user)):
try:
add_post.create_by = current_user.user.user_name
add_post.update_by = current_user.user.user_name
- add_post_result = PostService.add_post_services(query_db, add_post)
+ add_post_result = await PostService.add_post_services(query_db, add_post)
if add_post_result.is_success:
logger.info(add_post_result.message)
return ResponseUtil.success(msg=add_post_result.message)
@@ -47,11 +47,11 @@ async def add_system_post(request: Request, add_post: PostModel, query_db: Sessi
@postController.put("", dependencies=[Depends(CheckUserInterfaceAuth('system:post:edit'))])
@log_decorator(title='岗位管理', business_type=2)
-async def edit_system_post(request: Request, edit_post: PostModel, query_db: Session = Depends(get_db), current_user: CurrentUserModel = Depends(LoginService.get_current_user)):
+async def edit_system_post(request: Request, edit_post: PostModel, query_db: AsyncSession = Depends(get_db), current_user: CurrentUserModel = Depends(LoginService.get_current_user)):
try:
edit_post.update_by = current_user.user.user_name
edit_post.update_time = datetime.now()
- edit_post_result = PostService.edit_post_services(query_db, edit_post)
+ edit_post_result = await PostService.edit_post_services(query_db, edit_post)
if edit_post_result.is_success:
logger.info(edit_post_result.message)
return ResponseUtil.success(msg=edit_post_result.message)
@@ -65,10 +65,10 @@ async def edit_system_post(request: Request, edit_post: PostModel, query_db: Ses
@postController.delete("/{post_ids}", dependencies=[Depends(CheckUserInterfaceAuth('system:post:remove'))])
@log_decorator(title='岗位管理', business_type=3)
-async def delete_system_post(request: Request, post_ids: str, query_db: Session = Depends(get_db)):
+async def delete_system_post(request: Request, post_ids: str, query_db: AsyncSession = Depends(get_db)):
try:
delete_post = DeletePostModel(postIds=post_ids)
- delete_post_result = PostService.delete_post_services(query_db, delete_post)
+ delete_post_result = await PostService.delete_post_services(query_db, delete_post)
if delete_post_result.is_success:
logger.info(delete_post_result.message)
return ResponseUtil.success(msg=delete_post_result.message)
@@ -81,9 +81,9 @@ async def delete_system_post(request: Request, post_ids: str, query_db: Session
@postController.get("/{post_id}", response_model=PostModel, dependencies=[Depends(CheckUserInterfaceAuth('system:post:query'))])
-async def query_detail_system_post(request: Request, post_id: int, query_db: Session = Depends(get_db)):
+async def query_detail_system_post(request: Request, post_id: int, query_db: AsyncSession = Depends(get_db)):
try:
- post_detail_result = PostService.post_detail_services(query_db, post_id)
+ post_detail_result = await PostService.post_detail_services(query_db, post_id)
logger.info(f'获取post_id为{post_id}的信息成功')
return ResponseUtil.success(data=post_detail_result)
except Exception as e:
@@ -93,11 +93,11 @@ async def query_detail_system_post(request: Request, post_id: int, query_db: Ses
@postController.post("/export", dependencies=[Depends(CheckUserInterfaceAuth('system:post:export'))])
@log_decorator(title='岗位管理', business_type=5)
-async def export_system_post_list(request: Request, post_page_query: PostPageQueryModel = Depends(PostPageQueryModel.as_form), query_db: Session = Depends(get_db)):
+async def export_system_post_list(request: Request, post_page_query: PostPageQueryModel = Depends(PostPageQueryModel.as_form), query_db: AsyncSession = Depends(get_db)):
try:
# 获取全量数据
- post_query_result = PostService.get_post_list_services(query_db, post_page_query, is_page=False)
- post_export_result = PostService.export_post_list_services(post_query_result)
+ post_query_result = await PostService.get_post_list_services(query_db, post_page_query, is_page=False)
+ post_export_result = await PostService.export_post_list_services(post_query_result)
logger.info('导出成功')
return ResponseUtil.streaming(data=bytes2file_response(post_export_result))
except Exception as e:
diff --git a/ruoyi-fastapi-backend/module_admin/controller/role_controller.py b/ruoyi-fastapi-backend/module_admin/controller/role_controller.py
index 81381615caf6cac54928d87742033be7ca529fcc..6b848c9636eb3c6bcad07a3ce54ba9377573b619 100644
--- a/ruoyi-fastapi-backend/module_admin/controller/role_controller.py
+++ b/ruoyi-fastapi-backend/module_admin/controller/role_controller.py
@@ -18,10 +18,10 @@ roleController = APIRouter(prefix='/system/role', dependencies=[Depends(LoginSer
@roleController.get("/deptTree/{role_id}", dependencies=[Depends(CheckUserInterfaceAuth('system:role:query'))])
-async def get_system_role_dept_tree(request: Request, role_id: int, query_db: Session = Depends(get_db), data_scope_sql: str = Depends(GetDataScope('SysDept'))):
+async def get_system_role_dept_tree(request: Request, role_id: int, query_db: AsyncSession = Depends(get_db), data_scope_sql: str = Depends(GetDataScope('SysDept'))):
try:
- dept_query_result = DeptService.get_dept_tree_services(query_db, DeptModel(**{}), data_scope_sql)
- role_dept_query_result = RoleService.get_role_dept_tree_services(query_db, role_id)
+ dept_query_result = await DeptService.get_dept_tree_services(query_db, DeptModel(**{}), data_scope_sql)
+ role_dept_query_result = await RoleService.get_role_dept_tree_services(query_db, role_id)
role_dept_query_result.depts = dept_query_result
logger.info('获取成功')
return ResponseUtil.success(model_content=role_dept_query_result)
@@ -31,9 +31,9 @@ async def get_system_role_dept_tree(request: Request, role_id: int, query_db: Se
@roleController.get("/list", response_model=PageResponseModel, dependencies=[Depends(CheckUserInterfaceAuth('system:role:list'))])
-async def get_system_role_list(request: Request, role_page_query: RolePageQueryModel = Depends(RolePageQueryModel.as_query), query_db: Session = Depends(get_db)):
+async def get_system_role_list(request: Request, role_page_query: RolePageQueryModel = Depends(RolePageQueryModel.as_query), query_db: AsyncSession = Depends(get_db)):
try:
- role_page_query_result = RoleService.get_role_list_services(query_db, role_page_query, is_page=True)
+ role_page_query_result = await RoleService.get_role_list_services(query_db, role_page_query, is_page=True)
logger.info('获取成功')
return ResponseUtil.success(model_content=role_page_query_result)
except Exception as e:
@@ -43,11 +43,11 @@ async def get_system_role_list(request: Request, role_page_query: RolePageQueryM
@roleController.post("", dependencies=[Depends(CheckUserInterfaceAuth('system:role:add'))])
@log_decorator(title='角色管理', business_type=1)
-async def add_system_role(request: Request, add_role: AddRoleModel, query_db: Session = Depends(get_db), current_user: CurrentUserModel = Depends(LoginService.get_current_user)):
+async def add_system_role(request: Request, add_role: AddRoleModel, query_db: AsyncSession = Depends(get_db), current_user: CurrentUserModel = Depends(LoginService.get_current_user)):
try:
add_role.create_by = current_user.user.user_name
add_role.update_by = current_user.user.user_name
- add_role_result = RoleService.add_role_services(query_db, add_role)
+ add_role_result = await RoleService.add_role_services(query_db, add_role)
if add_role_result.is_success:
logger.info(add_role_result.message)
return ResponseUtil.success(msg=add_role_result.message)
@@ -61,11 +61,11 @@ async def add_system_role(request: Request, add_role: AddRoleModel, query_db: Se
@roleController.put("", dependencies=[Depends(CheckUserInterfaceAuth('system:role:edit'))])
@log_decorator(title='角色管理', business_type=2)
-async def edit_system_role(request: Request, edit_role: AddRoleModel, query_db: Session = Depends(get_db), current_user: CurrentUserModel = Depends(LoginService.get_current_user)):
+async def edit_system_role(request: Request, edit_role: AddRoleModel, query_db: AsyncSession = Depends(get_db), current_user: CurrentUserModel = Depends(LoginService.get_current_user)):
try:
edit_role.update_by = current_user.user.user_name
edit_role.update_time = datetime.now()
- edit_role_result = RoleService.edit_role_services(query_db, edit_role)
+ edit_role_result = await RoleService.edit_role_services(query_db, edit_role)
if edit_role_result.is_success:
logger.info(edit_role_result.message)
return ResponseUtil.success(msg=edit_role_result.message)
@@ -79,11 +79,11 @@ async def edit_system_role(request: Request, edit_role: AddRoleModel, query_db:
@roleController.put("/dataScope", dependencies=[Depends(CheckUserInterfaceAuth('system:role:edit'))])
@log_decorator(title='角色管理', business_type=4)
-async def edit_system_role_datascope(request: Request, role_data_scope: AddRoleModel, query_db: Session = Depends(get_db), current_user: CurrentUserModel = Depends(LoginService.get_current_user)):
+async def edit_system_role_datascope(request: Request, role_data_scope: AddRoleModel, query_db: AsyncSession = Depends(get_db), current_user: CurrentUserModel = Depends(LoginService.get_current_user)):
try:
role_data_scope.update_by = current_user.user.user_name
role_data_scope.update_time = datetime.now()
- role_data_scope_result = RoleService.role_datascope_services(query_db, role_data_scope)
+ role_data_scope_result = await RoleService.role_datascope_services(query_db, role_data_scope)
if role_data_scope_result.is_success:
logger.info(role_data_scope_result.message)
return ResponseUtil.success(msg=role_data_scope_result.message)
@@ -97,14 +97,14 @@ async def edit_system_role_datascope(request: Request, role_data_scope: AddRoleM
@roleController.delete("/{role_ids}", dependencies=[Depends(CheckUserInterfaceAuth('system:role:remove'))])
@log_decorator(title='角色管理', business_type=3)
-async def delete_system_role(request: Request, role_ids: str, query_db: Session = Depends(get_db), current_user: CurrentUserModel = Depends(LoginService.get_current_user)):
+async def delete_system_role(request: Request, role_ids: str, query_db: AsyncSession = Depends(get_db), current_user: CurrentUserModel = Depends(LoginService.get_current_user)):
try:
delete_role = DeleteRoleModel(
roleIds=role_ids,
updateBy=current_user.user.user_name,
updateTime=datetime.now()
)
- delete_role_result = RoleService.delete_role_services(query_db, delete_role)
+ delete_role_result = await RoleService.delete_role_services(query_db, delete_role)
if delete_role_result.is_success:
logger.info(delete_role_result.message)
return ResponseUtil.success(msg=delete_role_result.message)
@@ -117,9 +117,9 @@ async def delete_system_role(request: Request, role_ids: str, query_db: Session
@roleController.get("/{role_id}", response_model=RoleModel, dependencies=[Depends(CheckUserInterfaceAuth('system:role:query'))])
-async def query_detail_system_role(request: Request, role_id: int, query_db: Session = Depends(get_db)):
+async def query_detail_system_role(request: Request, role_id: int, query_db: AsyncSession = Depends(get_db)):
try:
- role_detail_result = RoleService.role_detail_services(query_db, role_id)
+ role_detail_result = await RoleService.role_detail_services(query_db, role_id)
logger.info(f'获取role_id为{role_id}的信息成功')
return ResponseUtil.success(data=role_detail_result.model_dump(by_alias=True))
except Exception as e:
@@ -129,11 +129,11 @@ async def query_detail_system_role(request: Request, role_id: int, query_db: Ses
@roleController.post("/export", dependencies=[Depends(CheckUserInterfaceAuth('system:role:export'))])
@log_decorator(title='角色管理', business_type=5)
-async def export_system_role_list(request: Request, role_page_query: RolePageQueryModel = Depends(RolePageQueryModel.as_form), query_db: Session = Depends(get_db)):
+async def export_system_role_list(request: Request, role_page_query: RolePageQueryModel = Depends(RolePageQueryModel.as_form), query_db: AsyncSession = Depends(get_db)):
try:
# 获取全量数据
- role_query_result = RoleService.get_role_list_services(query_db, role_page_query, is_page=False)
- role_export_result = RoleService.export_role_list_services(role_query_result)
+ role_query_result = await RoleService.get_role_list_services(query_db, role_page_query, is_page=False)
+ role_export_result = await RoleService.export_role_list_services(role_query_result)
logger.info('导出成功')
return ResponseUtil.streaming(data=bytes2file_response(role_export_result))
except Exception as e:
@@ -143,12 +143,12 @@ async def export_system_role_list(request: Request, role_page_query: RolePageQue
@roleController.put("/changeStatus", dependencies=[Depends(CheckUserInterfaceAuth('system:role:edit'))])
@log_decorator(title='角色管理', business_type=2)
-async def reset_system_role_status(request: Request, edit_role: AddRoleModel, query_db: Session = Depends(get_db), current_user: CurrentUserModel = Depends(LoginService.get_current_user)):
+async def reset_system_role_status(request: Request, edit_role: AddRoleModel, query_db: AsyncSession = Depends(get_db), current_user: CurrentUserModel = Depends(LoginService.get_current_user)):
try:
edit_role.update_by = current_user.user.user_name
edit_role.update_time = datetime.now()
edit_role.type = 'status'
- edit_role_result = RoleService.edit_role_services(query_db, edit_role)
+ edit_role_result = await RoleService.edit_role_services(query_db, edit_role)
if edit_role_result.is_success:
logger.info(edit_role_result.message)
return ResponseUtil.success(msg=edit_role_result.message)
@@ -161,9 +161,9 @@ async def reset_system_role_status(request: Request, edit_role: AddRoleModel, qu
@roleController.get("/authUser/allocatedList", response_model=PageResponseModel, dependencies=[Depends(CheckUserInterfaceAuth('system:role:list'))])
-async def get_system_allocated_user_list(request: Request, user_role: UserRolePageQueryModel = Depends(UserRolePageQueryModel.as_query), query_db: Session = Depends(get_db)):
+async def get_system_allocated_user_list(request: Request, user_role: UserRolePageQueryModel = Depends(UserRolePageQueryModel.as_query), query_db: AsyncSession = Depends(get_db)):
try:
- role_user_allocated_page_query_result = RoleService.get_role_user_allocated_list_services(query_db, user_role, is_page=True)
+ role_user_allocated_page_query_result = await RoleService.get_role_user_allocated_list_services(query_db, user_role, is_page=True)
logger.info('获取成功')
return ResponseUtil.success(model_content=role_user_allocated_page_query_result)
except Exception as e:
@@ -172,9 +172,9 @@ async def get_system_allocated_user_list(request: Request, user_role: UserRolePa
@roleController.get("/authUser/unallocatedList", response_model=PageResponseModel, dependencies=[Depends(CheckUserInterfaceAuth('system:role:list'))])
-async def get_system_unallocated_user_list(request: Request, user_role: UserRolePageQueryModel = Depends(UserRolePageQueryModel.as_query), query_db: Session = Depends(get_db)):
+async def get_system_unallocated_user_list(request: Request, user_role: UserRolePageQueryModel = Depends(UserRolePageQueryModel.as_query), query_db: AsyncSession = Depends(get_db)):
try:
- role_user_unallocated_page_query_result = RoleService.get_role_user_unallocated_list_services(query_db, user_role, is_page=True)
+ role_user_unallocated_page_query_result = await RoleService.get_role_user_unallocated_list_services(query_db, user_role, is_page=True)
logger.info('获取成功')
return ResponseUtil.success(model_content=role_user_unallocated_page_query_result)
except Exception as e:
@@ -184,9 +184,9 @@ async def get_system_unallocated_user_list(request: Request, user_role: UserRole
@roleController.put("/authUser/selectAll", dependencies=[Depends(CheckUserInterfaceAuth('system:role:edit'))])
@log_decorator(title='角色管理', business_type=4)
-async def add_system_role_user(request: Request, add_role_user: CrudUserRoleModel = Depends(CrudUserRoleModel.as_query), query_db: Session = Depends(get_db)):
+async def add_system_role_user(request: Request, add_role_user: CrudUserRoleModel = Depends(CrudUserRoleModel.as_query), query_db: AsyncSession = Depends(get_db)):
try:
- add_role_user_result = UserService.add_user_role_services(query_db, add_role_user)
+ add_role_user_result = await UserService.add_user_role_services(query_db, add_role_user)
if add_role_user_result.is_success:
logger.info(add_role_user_result.message)
return ResponseUtil.success(msg=add_role_user_result.message)
@@ -200,9 +200,9 @@ async def add_system_role_user(request: Request, add_role_user: CrudUserRoleMode
@roleController.put("/authUser/cancel", dependencies=[Depends(CheckUserInterfaceAuth('system:role:edit'))])
@log_decorator(title='角色管理', business_type=4)
-async def cancel_system_role_user(request: Request, cancel_user_role: CrudUserRoleModel, query_db: Session = Depends(get_db)):
+async def cancel_system_role_user(request: Request, cancel_user_role: CrudUserRoleModel, query_db: AsyncSession = Depends(get_db)):
try:
- cancel_user_role_result = UserService.delete_user_role_services(query_db, cancel_user_role)
+ cancel_user_role_result = await UserService.delete_user_role_services(query_db, cancel_user_role)
if cancel_user_role_result.is_success:
logger.info(cancel_user_role_result.message)
return ResponseUtil.success(msg=cancel_user_role_result.message)
@@ -216,9 +216,9 @@ async def cancel_system_role_user(request: Request, cancel_user_role: CrudUserRo
@roleController.put("/authUser/cancelAll", dependencies=[Depends(CheckUserInterfaceAuth('system:role:edit'))])
@log_decorator(title='角色管理', business_type=4)
-async def batch_cancel_system_role_user(request: Request, batch_cancel_user_role: CrudUserRoleModel = Depends(CrudUserRoleModel.as_query), query_db: Session = Depends(get_db)):
+async def batch_cancel_system_role_user(request: Request, batch_cancel_user_role: CrudUserRoleModel = Depends(CrudUserRoleModel.as_query), query_db: AsyncSession = Depends(get_db)):
try:
- batch_cancel_user_role_result = UserService.delete_user_role_services(query_db, batch_cancel_user_role)
+ batch_cancel_user_role_result = await UserService.delete_user_role_services(query_db, batch_cancel_user_role)
if batch_cancel_user_role_result.is_success:
logger.info(batch_cancel_user_role_result.message)
return ResponseUtil.success(msg=batch_cancel_user_role_result.message)
diff --git a/ruoyi-fastapi-backend/module_admin/controller/server_controller.py b/ruoyi-fastapi-backend/module_admin/controller/server_controller.py
index b08991263cdfd6fd59144ae5a9887b382a61504b..8d040ff67014171d10e1acfec1510ea818f9dc94 100644
--- a/ruoyi-fastapi-backend/module_admin/controller/server_controller.py
+++ b/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:
diff --git a/ruoyi-fastapi-backend/module_admin/controller/user_controller.py b/ruoyi-fastapi-backend/module_admin/controller/user_controller.py
index 9385a6d960c9c9d061cadd93f37be220c2d61fdb..fc9f8840097751f9d95faf7860d6067de25aec2c 100644
--- a/ruoyi-fastapi-backend/module_admin/controller/user_controller.py
+++ b/ruoyi-fastapi-backend/module_admin/controller/user_controller.py
@@ -19,9 +19,9 @@ userController = APIRouter(prefix='/system/user', dependencies=[Depends(LoginSer
@userController.get("/deptTree", dependencies=[Depends(CheckUserInterfaceAuth('system:user:list'))])
-async def get_system_dept_tree(request: Request, query_db: Session = Depends(get_db), data_scope_sql: str = Depends(GetDataScope('SysDept'))):
+async def get_system_dept_tree(request: Request, query_db: AsyncSession = Depends(get_db), data_scope_sql: str = Depends(GetDataScope('SysDept'))):
try:
- dept_query_result = DeptService.get_dept_tree_services(query_db, DeptModel(**{}), data_scope_sql)
+ dept_query_result = await DeptService.get_dept_tree_services(query_db, DeptModel(**{}), data_scope_sql)
logger.info('获取成功')
return ResponseUtil.success(data=dept_query_result)
except Exception as e:
@@ -30,10 +30,10 @@ async def get_system_dept_tree(request: Request, query_db: Session = Depends(get
@userController.get("/list", response_model=PageResponseModel, dependencies=[Depends(CheckUserInterfaceAuth('system:user:list'))])
-async def get_system_user_list(request: Request, user_page_query: UserPageQueryModel = Depends(UserPageQueryModel.as_query), query_db: Session = Depends(get_db), data_scope_sql: str = Depends(GetDataScope('SysUser'))):
+async def get_system_user_list(request: Request, user_page_query: UserPageQueryModel = Depends(UserPageQueryModel.as_query), query_db: AsyncSession = Depends(get_db), data_scope_sql: str = Depends(GetDataScope('SysUser'))):
try:
# 获取分页数据
- user_page_query_result = UserService.get_user_list_services(query_db, user_page_query, data_scope_sql, is_page=True)
+ user_page_query_result = await UserService.get_user_list_services(query_db, user_page_query, data_scope_sql, is_page=True)
logger.info('获取成功')
return ResponseUtil.success(model_content=user_page_query_result)
except Exception as e:
@@ -43,12 +43,12 @@ async def get_system_user_list(request: Request, user_page_query: UserPageQueryM
@userController.post("", dependencies=[Depends(CheckUserInterfaceAuth('system:user:add'))])
@log_decorator(title='用户管理', business_type=1)
-async def add_system_user(request: Request, add_user: AddUserModel, query_db: Session = Depends(get_db), current_user: CurrentUserModel = Depends(LoginService.get_current_user)):
+async def add_system_user(request: Request, add_user: AddUserModel, query_db: AsyncSession = Depends(get_db), current_user: CurrentUserModel = Depends(LoginService.get_current_user)):
try:
add_user.password = PwdUtil.get_password_hash(add_user.password)
add_user.create_by = current_user.user.user_name
add_user.update_by = current_user.user.user_name
- add_user_result = UserService.add_user_services(query_db, add_user)
+ add_user_result = await UserService.add_user_services(query_db, add_user)
if add_user_result.is_success:
logger.info(add_user_result.message)
return ResponseUtil.success(msg=add_user_result.message)
@@ -62,11 +62,11 @@ async def add_system_user(request: Request, add_user: AddUserModel, query_db: Se
@userController.put("", dependencies=[Depends(CheckUserInterfaceAuth('system:user:edit'))])
@log_decorator(title='用户管理', business_type=2)
-async def edit_system_user(request: Request, edit_user: EditUserModel, query_db: Session = Depends(get_db), current_user: CurrentUserModel = Depends(LoginService.get_current_user)):
+async def edit_system_user(request: Request, edit_user: EditUserModel, query_db: AsyncSession = Depends(get_db), current_user: CurrentUserModel = Depends(LoginService.get_current_user)):
try:
edit_user.update_by = current_user.user.user_name
edit_user.update_time = datetime.now()
- edit_user_result = UserService.edit_user_services(query_db, edit_user)
+ edit_user_result = await UserService.edit_user_services(query_db, edit_user)
if edit_user_result.is_success:
logger.info(edit_user_result.message)
return ResponseUtil.success(msg=edit_user_result.message)
@@ -80,14 +80,14 @@ async def edit_system_user(request: Request, edit_user: EditUserModel, query_db:
@userController.delete("/{user_ids}", dependencies=[Depends(CheckUserInterfaceAuth('system:user:remove'))])
@log_decorator(title='用户管理', business_type=3)
-async def delete_system_user(request: Request, user_ids: str, query_db: Session = Depends(get_db), current_user: CurrentUserModel = Depends(LoginService.get_current_user)):
+async def delete_system_user(request: Request, user_ids: str, query_db: AsyncSession = Depends(get_db), current_user: CurrentUserModel = Depends(LoginService.get_current_user)):
try:
delete_user = DeleteUserModel(
userIds=user_ids,
updateBy=current_user.user.user_name,
updateTime=datetime.now()
)
- delete_user_result = UserService.delete_user_services(query_db, delete_user)
+ delete_user_result = await UserService.delete_user_services(query_db, delete_user)
if delete_user_result.is_success:
logger.info(delete_user_result.message)
return ResponseUtil.success(msg=delete_user_result.message)
@@ -101,13 +101,13 @@ async def delete_system_user(request: Request, user_ids: str, query_db: Session
@userController.put("/resetPwd", dependencies=[Depends(CheckUserInterfaceAuth('system:user:resetPwd'))])
@log_decorator(title='用户管理', business_type=2)
-async def reset_system_user_pwd(request: Request, edit_user: EditUserModel, query_db: Session = Depends(get_db), current_user: CurrentUserModel = Depends(LoginService.get_current_user)):
+async def reset_system_user_pwd(request: Request, edit_user: EditUserModel, query_db: AsyncSession = Depends(get_db), current_user: CurrentUserModel = Depends(LoginService.get_current_user)):
try:
edit_user.password = PwdUtil.get_password_hash(edit_user.password)
edit_user.update_by = current_user.user.user_name
edit_user.update_time = datetime.now()
edit_user.type = 'pwd'
- edit_user_result = UserService.edit_user_services(query_db, edit_user)
+ edit_user_result = await UserService.edit_user_services(query_db, edit_user)
if edit_user_result.is_success:
logger.info(edit_user_result.message)
return ResponseUtil.success(msg=edit_user_result.message)
@@ -121,12 +121,12 @@ async def reset_system_user_pwd(request: Request, edit_user: EditUserModel, quer
@userController.put("/changeStatus", dependencies=[Depends(CheckUserInterfaceAuth('system:user:edit'))])
@log_decorator(title='用户管理', business_type=2)
-async def change_system_user_status(request: Request, edit_user: EditUserModel, query_db: Session = Depends(get_db), current_user: CurrentUserModel = Depends(LoginService.get_current_user)):
+async def change_system_user_status(request: Request, edit_user: EditUserModel, query_db: AsyncSession = Depends(get_db), current_user: CurrentUserModel = Depends(LoginService.get_current_user)):
try:
edit_user.update_by = current_user.user.user_name
edit_user.update_time = datetime.now()
edit_user.type = 'status'
- edit_user_result = UserService.edit_user_services(query_db, edit_user)
+ edit_user_result = await UserService.edit_user_services(query_db, edit_user)
if edit_user_result.is_success:
logger.info(edit_user_result.message)
return ResponseUtil.success(msg=edit_user_result.message)
@@ -139,9 +139,9 @@ async def change_system_user_status(request: Request, edit_user: EditUserModel,
@userController.get("/profile", response_model=UserProfileModel)
-async def query_detail_system_user(request: Request, query_db: Session = Depends(get_db), current_user: CurrentUserModel = Depends(LoginService.get_current_user)):
+async def query_detail_system_user(request: Request, query_db: AsyncSession = Depends(get_db), current_user: CurrentUserModel = Depends(LoginService.get_current_user)):
try:
- profile_user_result = UserService.user_profile_services(query_db, current_user.user.user_id)
+ profile_user_result = await UserService.user_profile_services(query_db, current_user.user.user_id)
logger.info(f'获取user_id为{current_user.user.user_id}的信息成功')
return ResponseUtil.success(model_content=profile_user_result)
except Exception as e:
@@ -151,9 +151,9 @@ async def query_detail_system_user(request: Request, query_db: Session = Depends
@userController.get("/{user_id}", response_model=UserDetailModel, dependencies=[Depends(CheckUserInterfaceAuth('system:user:query'))])
@userController.get("/", response_model=UserDetailModel, dependencies=[Depends(CheckUserInterfaceAuth('system:user:query'))])
-async def query_detail_system_user(request: Request, user_id: Optional[Union[int, str]] = '', query_db: Session = Depends(get_db), current_user: CurrentUserModel = Depends(LoginService.get_current_user)):
+async def query_detail_system_user(request: Request, user_id: Optional[Union[int, str]] = '', query_db: AsyncSession = Depends(get_db), current_user: CurrentUserModel = Depends(LoginService.get_current_user)):
try:
- detail_user_result = UserService.user_detail_services(query_db, user_id)
+ detail_user_result = await UserService.user_detail_services(query_db, user_id)
logger.info(f'获取user_id为{user_id}的信息成功')
return ResponseUtil.success(model_content=detail_user_result)
except Exception as e:
@@ -163,7 +163,7 @@ async def query_detail_system_user(request: Request, user_id: Optional[Union[int
@userController.post("/profile/avatar")
@log_decorator(title='个人信息', business_type=2)
-async def change_system_user_profile_avatar(request: Request, avatarfile: bytes = File(), query_db: Session = Depends(get_db), current_user: CurrentUserModel = Depends(LoginService.get_current_user)):
+async def change_system_user_profile_avatar(request: Request, avatarfile: bytes = File(), query_db: AsyncSession = Depends(get_db), current_user: CurrentUserModel = Depends(LoginService.get_current_user)):
try:
relative_path = f'avatar/{datetime.now().strftime("%Y")}/{datetime.now().strftime("%m")}/{datetime.now().strftime("%d")}'
dir_path = os.path.join(UploadConfig.UPLOAD_PATH, relative_path)
@@ -182,7 +182,7 @@ async def change_system_user_profile_avatar(request: Request, avatarfile: bytes
updateTime=datetime.now(),
type='avatar'
)
- edit_user_result = UserService.edit_user_services(query_db, edit_user)
+ edit_user_result = await UserService.edit_user_services(query_db, edit_user)
if edit_user_result.is_success:
logger.info(edit_user_result.message)
return ResponseUtil.success(dict_content={'imgUrl': edit_user.avatar}, msg=edit_user_result.message)
@@ -196,7 +196,7 @@ async def change_system_user_profile_avatar(request: Request, avatarfile: bytes
@userController.put("/profile")
@log_decorator(title='个人信息', business_type=2)
-async def change_system_user_profile_info(request: Request, user_info: UserInfoModel, query_db: Session = Depends(get_db), current_user: CurrentUserModel = Depends(LoginService.get_current_user)):
+async def change_system_user_profile_info(request: Request, user_info: UserInfoModel, query_db: AsyncSession = Depends(get_db), current_user: CurrentUserModel = Depends(LoginService.get_current_user)):
try:
edit_user = EditUserModel(
**user_info.model_dump(
@@ -212,7 +212,7 @@ async def change_system_user_profile_info(request: Request, user_info: UserInfoM
postIds=current_user.user.post_ids.split(',') if current_user.user.post_ids else [],
role=current_user.user.role
)
- edit_user_result = UserService.edit_user_services(query_db, edit_user)
+ edit_user_result = await UserService.edit_user_services(query_db, edit_user)
if edit_user_result.is_success:
logger.info(edit_user_result.message)
return ResponseUtil.success(msg=edit_user_result.message)
@@ -226,7 +226,7 @@ async def change_system_user_profile_info(request: Request, user_info: UserInfoM
@userController.put("/profile/updatePwd")
@log_decorator(title='个人信息', business_type=2)
-async def reset_system_user_password(request: Request, reset_password: ResetPasswordModel = Depends(ResetPasswordModel.as_query), query_db: Session = Depends(get_db), current_user: CurrentUserModel = Depends(LoginService.get_current_user)):
+async def reset_system_user_password(request: Request, reset_password: ResetPasswordModel = Depends(ResetPasswordModel.as_query), query_db: AsyncSession = Depends(get_db), current_user: CurrentUserModel = Depends(LoginService.get_current_user)):
try:
reset_user = ResetUserModel(
userId=current_user.user.user_id,
@@ -235,7 +235,7 @@ async def reset_system_user_password(request: Request, reset_password: ResetPass
updateBy=current_user.user.user_name,
updateTime=datetime.now()
)
- reset_user_result = UserService.reset_user_services(query_db, reset_user)
+ reset_user_result = await UserService.reset_user_services(query_db, reset_user)
if reset_user_result.is_success:
logger.info(reset_user_result.message)
return ResponseUtil.success(msg=reset_user_result.message)
@@ -249,7 +249,7 @@ async def reset_system_user_password(request: Request, reset_password: ResetPass
@userController.post("/importData", dependencies=[Depends(CheckUserInterfaceAuth('system:user:import'))])
@log_decorator(title='用户管理', business_type=6)
-async def batch_import_system_user(request: Request, file: UploadFile = File(...), update_support: bool = Query(alias='updateSupport'), query_db: Session = Depends(get_db), current_user: CurrentUserModel = Depends(LoginService.get_current_user)):
+async def batch_import_system_user(request: Request, file: UploadFile = File(...), update_support: bool = Query(alias='updateSupport'), query_db: AsyncSession = Depends(get_db), current_user: CurrentUserModel = Depends(LoginService.get_current_user)):
try:
batch_import_result = await UserService.batch_import_user_services(query_db, file, update_support, current_user)
if batch_import_result.is_success:
@@ -264,9 +264,9 @@ async def batch_import_system_user(request: Request, file: UploadFile = File(...
@userController.post("/importTemplate", dependencies=[Depends(CheckUserInterfaceAuth('system:user:import'))])
-async def export_system_user_template(request: Request, query_db: Session = Depends(get_db)):
+async def export_system_user_template(request: Request, query_db: AsyncSession = Depends(get_db)):
try:
- user_import_template_result = UserService.get_user_import_template_services()
+ user_import_template_result = await UserService.get_user_import_template_services()
logger.info('获取成功')
return ResponseUtil.streaming(data=bytes2file_response(user_import_template_result))
except Exception as e:
@@ -276,11 +276,11 @@ async def export_system_user_template(request: Request, query_db: Session = Depe
@userController.post("/export", dependencies=[Depends(CheckUserInterfaceAuth('system:user:export'))])
@log_decorator(title='用户管理', business_type=5)
-async def export_system_user_list(request: Request, user_page_query: UserPageQueryModel = Depends(UserPageQueryModel.as_form), query_db: Session = Depends(get_db), data_scope_sql: str = Depends(GetDataScope('SysUser'))):
+async def export_system_user_list(request: Request, user_page_query: UserPageQueryModel = Depends(UserPageQueryModel.as_form), query_db: AsyncSession = Depends(get_db), data_scope_sql: str = Depends(GetDataScope('SysUser'))):
try:
# 获取全量数据
- user_query_result = UserService.get_user_list_services(query_db, user_page_query, data_scope_sql, is_page=False)
- user_export_result = UserService.export_user_list_services(user_query_result)
+ user_query_result = await UserService.get_user_list_services(query_db, user_page_query, data_scope_sql, is_page=False)
+ user_export_result = await UserService.export_user_list_services(user_query_result)
logger.info('导出成功')
return ResponseUtil.streaming(data=bytes2file_response(user_export_result))
except Exception as e:
@@ -289,10 +289,10 @@ async def export_system_user_list(request: Request, user_page_query: UserPageQue
@userController.get("/authRole/{user_id}", response_model=UserRoleResponseModel, dependencies=[Depends(CheckUserInterfaceAuth('system:user:query'))])
-async def get_system_allocated_role_list(request: Request, user_id: int, query_db: Session = Depends(get_db)):
+async def get_system_allocated_role_list(request: Request, user_id: int, query_db: AsyncSession = Depends(get_db)):
try:
user_role_query = UserRoleQueryModel(userId=user_id)
- user_role_allocated_query_result = UserService.get_user_role_allocated_list_services(query_db, user_role_query)
+ user_role_allocated_query_result = await UserService.get_user_role_allocated_list_services(query_db, user_role_query)
logger.info('获取成功')
return ResponseUtil.success(model_content=user_role_allocated_query_result)
except Exception as e:
@@ -301,9 +301,9 @@ async def get_system_allocated_role_list(request: Request, user_id: int, query_d
@userController.put("/authRole", response_model=UserRoleResponseModel, dependencies=[Depends(CheckUserInterfaceAuth('system:user:edit'))])
-async def update_system_role_user(request: Request, user_id: int = Query(alias='userId'), role_ids: str = Query(alias='roleIds'), query_db: Session = Depends(get_db)):
+async def update_system_role_user(request: Request, user_id: int = Query(alias='userId'), role_ids: str = Query(alias='roleIds'), query_db: AsyncSession = Depends(get_db)):
try:
- add_user_role_result = UserService.add_user_role_services(query_db, CrudUserRoleModel(userId=user_id, roleIds=role_ids))
+ add_user_role_result = await UserService.add_user_role_services(query_db, CrudUserRoleModel(userId=user_id, roleIds=role_ids))
if add_user_role_result.is_success:
logger.info(add_user_role_result.message)
return ResponseUtil.success(msg=add_user_role_result.message)
diff --git a/ruoyi-fastapi-backend/module_admin/dao/config_dao.py b/ruoyi-fastapi-backend/module_admin/dao/config_dao.py
index 7a13a97a58b9d1ce281659eab9a0bb3799bb14d4..79304c29f357f0cf83ffbc0f17d472fb2028970e 100644
--- a/ruoyi-fastapi-backend/module_admin/dao/config_dao.py
+++ b/ruoyi-fastapi-backend/module_admin/dao/config_dao.py
@@ -1,4 +1,5 @@
-from sqlalchemy.orm import Session
+from sqlalchemy import select, update, delete
+from sqlalchemy.ext.asyncio import AsyncSession
from module_admin.entity.do.config_do import SysConfig
from module_admin.entity.vo.config_vo import *
from utils.page_util import PageUtil
@@ -11,36 +12,38 @@ class ConfigDao:
"""
@classmethod
- def get_config_detail_by_id(cls, db: Session, config_id: int):
+ async def get_config_detail_by_id(cls, db: AsyncSession, config_id: int):
"""
根据参数配置id获取参数配置详细信息
:param db: orm对象
:param config_id: 参数配置id
:return: 参数配置信息对象
"""
- config_info = db.query(SysConfig) \
- .filter(SysConfig.config_id == config_id) \
- .first()
+ config_info = (await db.execute(
+ select(SysConfig)
+ .where(SysConfig.config_id == config_id)
+ )).scalars().first()
return config_info
@classmethod
- def get_config_detail_by_info(cls, db: Session, config: ConfigModel):
+ async def get_config_detail_by_info(cls, db: AsyncSession, config: ConfigModel):
"""
根据参数配置参数获取参数配置信息
:param db: orm对象
:param config: 参数配置参数对象
:return: 参数配置信息对象
"""
- config_info = db.query(SysConfig) \
- .filter(SysConfig.config_key == config.config_key if config.config_key else True,
- SysConfig.config_value == config.config_value if config.config_value else True) \
- .first()
+ config_info = (await db.execute(
+ select(SysConfig)
+ .where(SysConfig.config_key == config.config_key if config.config_key else True,
+ SysConfig.config_value == config.config_value if config.config_value else True)
+ )).scalars().first()
return config_info
@classmethod
- def get_config_list(cls, db: Session, query_object: ConfigPageQueryModel, is_page: bool = False):
+ async def get_config_list(cls, db: AsyncSession, query_object: ConfigPageQueryModel, is_page: bool = False):
"""
根据查询参数获取参数配置列表信息
:param db: orm对象
@@ -48,22 +51,21 @@ class ConfigDao:
:param is_page: 是否开启分页
:return: 参数配置列表信息对象
"""
- query = db.query(SysConfig) \
- .filter(SysConfig.config_name.like(f'%{query_object.config_name}%') if query_object.config_name else True,
- SysConfig.config_key.like(f'%{query_object.config_key}%') if query_object.config_key else True,
- SysConfig.config_type == query_object.config_type if query_object.config_type else True,
- SysConfig.create_time.between(
- datetime.combine(datetime.strptime(query_object.begin_time, '%Y-%m-%d'), time(00, 00, 00)),
- datetime.combine(datetime.strptime(query_object.end_time, '%Y-%m-%d'), time(23, 59, 59)))
- if query_object.begin_time and query_object.end_time else True
- ) \
+ query = select(SysConfig) \
+ .where(SysConfig.config_name.like(f'%{query_object.config_name}%') if query_object.config_name else True,
+ SysConfig.config_key.like(f'%{query_object.config_key}%') if query_object.config_key else True,
+ SysConfig.config_type == query_object.config_type if query_object.config_type else True,
+ SysConfig.create_time.between(
+ datetime.combine(datetime.strptime(query_object.begin_time, '%Y-%m-%d'), time(00, 00, 00)),
+ datetime.combine(datetime.strptime(query_object.end_time, '%Y-%m-%d'), time(23, 59, 59)))
+ if query_object.begin_time and query_object.end_time else True) \
.distinct()
- config_list = PageUtil.paginate(query, query_object.page_num, query_object.page_size, is_page)
+ config_list = await PageUtil.paginate(db, query, query_object.page_num, query_object.page_size, is_page)
return config_list
@classmethod
- def add_config_dao(cls, db: Session, config: ConfigModel):
+ async def add_config_dao(cls, db: AsyncSession, config: ConfigModel):
"""
新增参数配置数据库操作
:param db: orm对象
@@ -72,30 +74,32 @@ class ConfigDao:
"""
db_config = SysConfig(**config.model_dump())
db.add(db_config)
- db.flush()
+ await db.flush()
return db_config
@classmethod
- def edit_config_dao(cls, db: Session, config: dict):
+ async def edit_config_dao(cls, db: AsyncSession, config: dict):
"""
编辑参数配置数据库操作
:param db: orm对象
:param config: 需要更新的参数配置字典
:return:
"""
- db.query(SysConfig) \
- .filter(SysConfig.config_id == config.get('config_id')) \
- .update(config)
+ await db.execute(
+ update(SysConfig),
+ [config]
+ )
@classmethod
- def delete_config_dao(cls, db: Session, config: ConfigModel):
+ async def delete_config_dao(cls, db: AsyncSession, config: ConfigModel):
"""
删除参数配置数据库操作
:param db: orm对象
:param config: 参数配置对象
:return:
"""
- db.query(SysConfig) \
- .filter(SysConfig.config_id == config.config_id) \
- .delete()
+ await db.execute(
+ delete(SysConfig)
+ .where(SysConfig.config_id.in_([config.config_id]))
+ )
diff --git a/ruoyi-fastapi-backend/module_admin/dao/dept_dao.py b/ruoyi-fastapi-backend/module_admin/dao/dept_dao.py
index 05a70d09be59b5d9434af71b977e272d630a2e54..c5169a511cf08e5d53522560dc53db89455f7879 100644
--- a/ruoyi-fastapi-backend/module_admin/dao/dept_dao.py
+++ b/ruoyi-fastapi-backend/module_admin/dao/dept_dao.py
@@ -1,4 +1,5 @@
-from sqlalchemy.orm import Session
+from sqlalchemy import select, update, delete
+from sqlalchemy.ext.asyncio import AsyncSession
from module_admin.entity.do.dept_do import SysDept
from module_admin.entity.do.role_do import SysRoleDept
from module_admin.entity.vo.dept_vo import *
@@ -11,68 +12,72 @@ class DeptDao:
"""
@classmethod
- def get_dept_by_id(cls, db: Session, dept_id: int):
+ async def get_dept_by_id(cls, db: AsyncSession, dept_id: int):
"""
根据部门id获取在用部门信息
:param db: orm对象
:param dept_id: 部门id
:return: 在用部门信息对象
"""
- dept_info = db.query(SysDept) \
- .filter(SysDept.dept_id == dept_id,
- SysDept.status == 0,
- SysDept.del_flag == 0) \
- .first()
+ dept_info = (await db.execute(
+ select(SysDept)
+ .where(SysDept.dept_id == dept_id,
+ SysDept.status == 0,
+ SysDept.del_flag == 0)
+ )).scalars().first()
return dept_info
@classmethod
- def get_dept_by_id_for_list(cls, db: Session, dept_id: int):
+ async def get_dept_by_id_for_list(cls, db: AsyncSession, dept_id: int):
"""
用于获取部门列表的工具方法
:param db: orm对象
:param dept_id: 部门id
:return: 部门id对应的信息对象
"""
- dept_info = db.query(SysDept) \
- .filter(SysDept.dept_id == dept_id,
- SysDept.del_flag == 0) \
- .first()
+ dept_info = (await db.execute(
+ select(SysDept)
+ .where(SysDept.dept_id == dept_id,
+ SysDept.del_flag == 0)
+ )).scalars().first()
return dept_info
@classmethod
- def get_dept_detail_by_id(cls, db: Session, dept_id: int):
+ async def get_dept_detail_by_id(cls, db: AsyncSession, dept_id: int):
"""
根据部门id获取部门详细信息
:param db: orm对象
:param dept_id: 部门id
:return: 部门信息对象
"""
- dept_info = db.query(SysDept) \
- .filter(SysDept.dept_id == dept_id,
- SysDept.del_flag == 0) \
- .first()
+ dept_info = (await db.execute(
+ select(SysDept)
+ .where(SysDept.dept_id == dept_id,
+ SysDept.del_flag == 0)
+ )).scalars().first()
return dept_info
@classmethod
- def get_dept_detail_by_info(cls, db: Session, dept: DeptModel):
+ async def get_dept_detail_by_info(cls, db: AsyncSession, dept: DeptModel):
"""
根据部门参数获取部门信息
:param db: orm对象
:param dept: 部门参数对象
:return: 部门信息对象
"""
- dept_info = db.query(SysDept) \
- .filter(SysDept.parent_id == dept.parent_id if dept.parent_id else True,
- SysDept.dept_name == dept.dept_name if dept.dept_name else True) \
- .first()
+ dept_info = (await db.execute(
+ select(SysDept)
+ .where(SysDept.parent_id == dept.parent_id if dept.parent_id else True,
+ SysDept.dept_name == dept.dept_name if dept.dept_name else True)
+ )).scalars().first()
return dept_info
@classmethod
- def get_dept_info_for_edit_option(cls, db: Session, dept_info: DeptModel, data_scope_sql: str):
+ async def get_dept_info_for_edit_option(cls, db: AsyncSession, dept_info: DeptModel, data_scope_sql: str):
"""
获取部门编辑对应的在用部门列表信息
:param db: orm对象
@@ -80,46 +85,50 @@ class DeptDao:
:param data_scope_sql: 数据权限对应的查询sql语句
:return: 部门列表信息
"""
- dept_result = db.query(SysDept) \
- .filter(SysDept.dept_id != dept_info.dept_id,
- SysDept.parent_id != dept_info.dept_id,
- SysDept.del_flag == 0, SysDept.status == 0,
- eval(data_scope_sql)) \
- .order_by(SysDept.order_num) \
- .distinct().all()
+ dept_result = (await db.execute(
+ select(SysDept)
+ .where(SysDept.dept_id != dept_info.dept_id,
+ SysDept.parent_id != dept_info.dept_id,
+ SysDept.del_flag == 0, SysDept.status == 0,
+ eval(data_scope_sql))
+ .order_by(SysDept.order_num)
+ .distinct()
+ )).scalars().all()
return list_format_datetime(dept_result)
@classmethod
- def get_children_dept(cls, db: Session, dept_id: int):
+ async def get_children_dept(cls, db: AsyncSession, dept_id: int):
"""
根据部门id查询当前部门的子部门列表信息
:param db: orm对象
:param dept_id: 部门id
:return: 子部门信息列表
"""
- dept_result = db.query(SysDept) \
- .filter(SysDept.parent_id == dept_id,
- SysDept.del_flag == 0) \
- .all()
+ dept_result = (await db.execute(
+ select(SysDept)
+ .where(SysDept.parent_id == dept_id,
+ SysDept.del_flag == 0)
+ )).scalars().all()
return list_format_datetime(dept_result)
@classmethod
- def get_dept_all_ancestors(cls, db: Session):
+ async def get_dept_all_ancestors(cls, db: AsyncSession):
"""
获取所有部门的ancestors信息
:param db: orm对象
:return: ancestors信息列表
"""
- ancestors = db.query(SysDept.ancestors)\
- .filter(SysDept.del_flag == 0)\
- .all()
+ ancestors = (await db.execute(
+ select(SysDept.ancestors)
+ .where(SysDept.del_flag == 0)
+ )).scalars().all()
return ancestors
@classmethod
- def get_dept_list_for_tree(cls, db: Session, dept_info: DeptModel, data_scope_sql: str):
+ async def get_dept_list_for_tree(cls, db: AsyncSession, dept_info: DeptModel, data_scope_sql: str):
"""
获取所有在用部门列表信息
:param db: orm对象
@@ -127,18 +136,20 @@ class DeptDao:
:param data_scope_sql: 数据权限对应的查询sql语句
:return: 在用部门列表信息
"""
- dept_result = db.query(SysDept) \
- .filter(SysDept.status == 0,
- SysDept.del_flag == 0,
- SysDept.dept_name.like(f'%{dept_info.dept_name}%') if dept_info.dept_name else True,
- eval(data_scope_sql)) \
- .order_by(SysDept.order_num) \
- .distinct().all()
+ dept_result = (await db.execute(
+ select(SysDept)
+ .where(SysDept.status == 0,
+ SysDept.del_flag == 0,
+ SysDept.dept_name.like(f'%{dept_info.dept_name}%') if dept_info.dept_name else True,
+ eval(data_scope_sql))
+ .order_by(SysDept.order_num)
+ .distinct()
+ )).scalars().all()
return dept_result
@classmethod
- def get_dept_list(cls, db: Session, page_object: DeptModel, data_scope_sql: str):
+ async def get_dept_list(cls, db: AsyncSession, page_object: DeptModel, data_scope_sql: str):
"""
根据查询参数获取部门列表信息
:param db: orm对象
@@ -146,18 +157,20 @@ class DeptDao:
:param data_scope_sql: 数据权限对应的查询sql语句
:return: 部门列表信息对象
"""
- dept_result = db.query(SysDept) \
- .filter(SysDept.del_flag == 0,
- SysDept.status == page_object.status if page_object.status else True,
- SysDept.dept_name.like(f'%{page_object.dept_name}%') if page_object.dept_name else True,
- eval(data_scope_sql)) \
- .order_by(SysDept.order_num) \
- .distinct().all()
+ dept_result = (await db.execute(
+ select(SysDept)
+ .where(SysDept.del_flag == 0,
+ SysDept.status == page_object.status if page_object.status else True,
+ SysDept.dept_name.like(f'%{page_object.dept_name}%') if page_object.dept_name else True,
+ eval(data_scope_sql))
+ .order_by(SysDept.order_num)
+ .distinct()
+ )).scalars().all()
return dept_result
@classmethod
- def add_dept_dao(cls, db: Session, dept: DeptModel):
+ async def add_dept_dao(cls, db: AsyncSession, dept: DeptModel):
"""
新增部门数据库操作
:param db: orm对象
@@ -166,30 +179,33 @@ class DeptDao:
"""
db_dept = SysDept(**dept.model_dump())
db.add(db_dept)
- db.flush()
+ await db.flush()
return db_dept
@classmethod
- def edit_dept_dao(cls, db: Session, dept: dict):
+ async def edit_dept_dao(cls, db: AsyncSession, dept: dict):
"""
编辑部门数据库操作
:param db: orm对象
:param dept: 需要更新的部门字典
:return: 编辑校验结果
"""
- db.query(SysDept) \
- .filter(SysDept.dept_id == dept.get('dept_id')) \
- .update(dept)
+ await db.execute(
+ update(SysDept),
+ [dept]
+ )
@classmethod
- def delete_dept_dao(cls, db: Session, dept: DeptModel):
+ async def delete_dept_dao(cls, db: AsyncSession, dept: DeptModel):
"""
删除部门数据库操作
:param db: orm对象
:param dept: 部门对象
:return:
"""
- db.query(SysDept) \
- .filter(SysDept.dept_id == dept.dept_id) \
- .update({SysDept.del_flag: '2', SysDept.update_by: dept.update_by, SysDept.update_time: dept.update_time})
+ await db.execute(
+ update(SysDept)
+ .where(SysDept.dept_id == dept.dept_id)
+ .values(del_flag='2', update_by=dept.update_by, update_time=dept.update_time)
+ )
diff --git a/ruoyi-fastapi-backend/module_admin/dao/dict_dao.py b/ruoyi-fastapi-backend/module_admin/dao/dict_dao.py
index 3b7d127d8ad534f932dec146920b643ea21e8ba5..fd98c959a6881c84a3f52312408405322adcb19c 100644
--- a/ruoyi-fastapi-backend/module_admin/dao/dict_dao.py
+++ b/ruoyi-fastapi-backend/module_admin/dao/dict_dao.py
@@ -1,5 +1,5 @@
-from sqlalchemy import and_
-from sqlalchemy.orm import Session
+from sqlalchemy import select, update, delete, and_
+from sqlalchemy.ext.asyncio import AsyncSession
from module_admin.entity.do.dict_do import SysDictType, SysDictData
from module_admin.entity.vo.dict_vo import *
from utils.time_format_util import list_format_datetime
@@ -13,47 +13,51 @@ class DictTypeDao:
"""
@classmethod
- def get_dict_type_detail_by_id(cls, db: Session, dict_id: int):
+ async def get_dict_type_detail_by_id(cls, db: AsyncSession, dict_id: int):
"""
根据字典类型id获取字典类型详细信息
:param db: orm对象
:param dict_id: 字典类型id
:return: 字典类型信息对象
"""
- dict_type_info = db.query(SysDictType) \
- .filter(SysDictType.dict_id == dict_id) \
- .first()
+ dict_type_info = (await db.execute(
+ select(SysDictType)
+ .where(SysDictType.dict_id == dict_id)
+ )).scalars().first()
return dict_type_info
@classmethod
- def get_dict_type_detail_by_info(cls, db: Session, dict_type: DictTypeModel):
+ async def get_dict_type_detail_by_info(cls, db: AsyncSession, dict_type: DictTypeModel):
"""
根据字典类型参数获取字典类型信息
:param db: orm对象
:param dict_type: 字典类型参数对象
:return: 字典类型信息对象
"""
- dict_type_info = db.query(SysDictType) \
- .filter(SysDictType.dict_type == dict_type.dict_type if dict_type.dict_type else True,
- SysDictType.dict_name == dict_type.dict_name if dict_type.dict_name else True) \
- .first()
+ dict_type_info = (await db.execute(
+ select(SysDictType)
+ .where(SysDictType.dict_type == dict_type.dict_type if dict_type.dict_type else True,
+ SysDictType.dict_name == dict_type.dict_name if dict_type.dict_name else True)
+ )).scalars().first()
return dict_type_info
@classmethod
- def get_all_dict_type(cls, db: Session):
+ async def get_all_dict_type(cls, db: AsyncSession):
"""
获取所有的字典类型信息
:param db: orm对象
:return: 字典类型信息列表对象
"""
- dict_type_info = db.query(SysDictType).all()
+ dict_type_info = (await db.execute(
+ select(SysDictType)
+ )).scalars().all()
return list_format_datetime(dict_type_info)
@classmethod
- def get_dict_type_list(cls, db: Session, query_object: DictTypePageQueryModel, is_page: bool = False):
+ async def get_dict_type_list(cls, db: AsyncSession, query_object: DictTypePageQueryModel, is_page: bool = False):
"""
根据查询参数获取字典类型列表信息
:param db: orm对象
@@ -61,57 +65,58 @@ class DictTypeDao:
:param is_page: 是否开启分页
:return: 字典类型列表信息对象
"""
- query = db.query(SysDictType) \
- .filter(SysDictType.dict_name.like(f'%{query_object.dict_name}%') if query_object.dict_name else True,
- SysDictType.dict_type.like(f'%{query_object.dict_type}%') if query_object.dict_type else True,
- SysDictType.status == query_object.status if query_object.status else True,
- SysDictType.create_time.between(
- datetime.combine(datetime.strptime(query_object.begin_time, '%Y-%m-%d'), time(00, 00, 00)),
- datetime.combine(datetime.strptime(query_object.end_time, '%Y-%m-%d'), time(23, 59, 59)))
- if query_object.begin_time and query_object.end_time else True
- ) \
+ query = select(SysDictType) \
+ .where(SysDictType.dict_name.like(f'%{query_object.dict_name}%') if query_object.dict_name else True,
+ SysDictType.dict_type.like(f'%{query_object.dict_type}%') if query_object.dict_type else True,
+ SysDictType.status == query_object.status if query_object.status else True,
+ SysDictType.create_time.between(
+ datetime.combine(datetime.strptime(query_object.begin_time, '%Y-%m-%d'), time(00, 00, 00)),
+ datetime.combine(datetime.strptime(query_object.end_time, '%Y-%m-%d'), time(23, 59, 59)))
+ if query_object.begin_time and query_object.end_time else True) \
.distinct()
- dict_type_list = PageUtil.paginate(query, query_object.page_num, query_object.page_size, is_page)
+ dict_type_list = await PageUtil.paginate(db, query, query_object.page_num, query_object.page_size, is_page)
return dict_type_list
@classmethod
- def add_dict_type_dao(cls, db: Session, dict_type: DictTypeModel):
+ async def add_dict_type_dao(cls, db: AsyncSession, dict_type: DictTypeModel):
"""
新增字典类型数据库操作
:param db: orm对象
:param dict_type: 字典类型对象
:return:
"""
- db_dict_type = SysDictType(**dict_type.dict())
+ db_dict_type = SysDictType(**dict_type.model_dump())
db.add(db_dict_type)
- db.flush()
+ await db.flush()
return db_dict_type
@classmethod
- def edit_dict_type_dao(cls, db: Session, dict_type: dict):
+ async def edit_dict_type_dao(cls, db: AsyncSession, dict_type: dict):
"""
编辑字典类型数据库操作
:param db: orm对象
:param dict_type: 需要更新的字典类型字典
:return:
"""
- db.query(SysDictType) \
- .filter(SysDictType.dict_id == dict_type.get('dict_id')) \
- .update(dict_type)
+ await db.execute(
+ update(SysDictType),
+ [dict_type]
+ )
@classmethod
- def delete_dict_type_dao(cls, db: Session, dict_type: DictTypeModel):
+ async def delete_dict_type_dao(cls, db: AsyncSession, dict_type: DictTypeModel):
"""
删除字典类型数据库操作
:param db: orm对象
:param dict_type: 字典类型对象
:return:
"""
- db.query(SysDictType) \
- .filter(SysDictType.dict_id == dict_type.dict_id) \
- .delete()
+ await db.execute(
+ delete(SysDictType)
+ .where(SysDictType.dict_id.in_([dict_type.dict_id]))
+ )
class DictDataDao:
@@ -120,37 +125,39 @@ class DictDataDao:
"""
@classmethod
- def get_dict_data_detail_by_id(cls, db: Session, dict_code: int):
+ async def get_dict_data_detail_by_id(cls, db: AsyncSession, dict_code: int):
"""
根据字典数据id获取字典数据详细信息
:param db: orm对象
:param dict_code: 字典数据id
:return: 字典数据信息对象
"""
- dict_data_info = db.query(SysDictData) \
- .filter(SysDictData.dict_code == dict_code) \
- .first()
+ dict_data_info = (await db.execute(
+ select(SysDictData)
+ .where(SysDictData.dict_code == dict_code)
+ )).scalars().first()
return dict_data_info
@classmethod
- def get_dict_data_detail_by_info(cls, db: Session, dict_data: DictDataModel):
+ async def get_dict_data_detail_by_info(cls, db: AsyncSession, dict_data: DictDataModel):
"""
根据字典数据参数获取字典数据信息
:param db: orm对象
:param dict_data: 字典数据参数对象
:return: 字典数据信息对象
"""
- dict_data_info = db.query(SysDictData) \
- .filter(SysDictData.dict_type == dict_data.dict_type if dict_data.dict_type else True,
- SysDictData.dict_label == dict_data.dict_label if dict_data.dict_label else True,
- SysDictData.dict_value == dict_data.dict_value if dict_data.dict_value else True) \
- .first()
+ dict_data_info = (await db.execute(
+ select(SysDictData)
+ .where(SysDictData.dict_type == dict_data.dict_type if dict_data.dict_type else True,
+ SysDictData.dict_label == dict_data.dict_label if dict_data.dict_label else True,
+ SysDictData.dict_value == dict_data.dict_value if dict_data.dict_value else True)
+ )).scalars().first()
return dict_data_info
@classmethod
- def get_dict_data_list(cls, db: Session, query_object: DictDataPageQueryModel, is_page: bool = False):
+ async def get_dict_data_list(cls, db: AsyncSession, query_object: DictDataPageQueryModel, is_page: bool = False):
"""
根据查询参数获取字典数据列表信息
:param db: orm对象
@@ -158,35 +165,37 @@ class DictDataDao:
:param is_page: 是否开启分页
:return: 字典数据列表信息对象
"""
- query = db.query(SysDictData) \
- .filter(SysDictData.dict_type == query_object.dict_type if query_object.dict_type else True,
- SysDictData.dict_label.like(f'%{query_object.dict_label}%') if query_object.dict_label else True,
- SysDictData.status == query_object.status if query_object.status else True
- ) \
- .order_by(SysDictData.dict_sort) \
+ query = select(SysDictData) \
+ .where(SysDictData.dict_type == query_object.dict_type if query_object.dict_type else True,
+ SysDictData.dict_label.like(f'%{query_object.dict_label}%') if query_object.dict_label else True,
+ SysDictData.status == query_object.status if query_object.status else True)\
+ .order_by(SysDictData.dict_sort)\
.distinct()
- dict_data_list = PageUtil.paginate(query, query_object.page_num, query_object.page_size, is_page)
+ dict_data_list = await PageUtil.paginate(db, query, query_object.page_num, query_object.page_size, is_page)
return dict_data_list
@classmethod
- def query_dict_data_list(cls, db: Session, dict_type: str):
+ async def query_dict_data_list(cls, db: AsyncSession, dict_type: str):
"""
根据查询参数获取字典数据列表信息
:param db: orm对象
:param dict_type: 字典类型
:return: 字典数据列表信息对象
"""
- dict_data_list = db.query(SysDictData).select_from(SysDictType) \
- .filter(SysDictType.dict_type == dict_type if dict_type else True, SysDictType.status == 0) \
- .outerjoin(SysDictData, and_(SysDictType.dict_type == SysDictData.dict_type, SysDictData.status == 0)) \
- .order_by(SysDictData.dict_sort) \
- .distinct().all()
+ dict_data_list = (await db.execute(
+ select(SysDictData)
+ .select_from(SysDictType)
+ .where(SysDictType.dict_type == dict_type if dict_type else True, SysDictType.status == 0)
+ .join(SysDictData, and_(SysDictType.dict_type == SysDictData.dict_type, SysDictData.status == 0), isouter=True)
+ .order_by(SysDictData.dict_sort)
+ .distinct()
+ )).scalars().all()
return dict_data_list
@classmethod
- def add_dict_data_dao(cls, db: Session, dict_data: DictDataModel):
+ async def add_dict_data_dao(cls, db: AsyncSession, dict_data: DictDataModel):
"""
新增字典数据数据库操作
:param db: orm对象
@@ -195,30 +204,32 @@ class DictDataDao:
"""
db_data_type = SysDictData(**dict_data.dict())
db.add(db_data_type)
- db.flush()
+ await db.flush()
return db_data_type
@classmethod
- def edit_dict_data_dao(cls, db: Session, dict_data: dict):
+ async def edit_dict_data_dao(cls, db: AsyncSession, dict_data: dict):
"""
编辑字典数据数据库操作
:param db: orm对象
:param dict_data: 需要更新的字典数据字典
:return:
"""
- db.query(SysDictData) \
- .filter(SysDictData.dict_code == dict_data.get('dict_code')) \
- .update(dict_data)
+ await db.execute(
+ update(SysDictData),
+ [dict_data]
+ )
@classmethod
- def delete_dict_data_dao(cls, db: Session, dict_data: DictDataModel):
+ async def delete_dict_data_dao(cls, db: AsyncSession, dict_data: DictDataModel):
"""
删除字典数据数据库操作
:param db: orm对象
:param dict_data: 字典数据对象
:return:
"""
- db.query(SysDictData) \
- .filter(SysDictData.dict_code == dict_data.dict_code) \
- .delete()
+ await db.execute(
+ delete(SysDictData)
+ .where(SysDictData.dict_code.in_([dict_data.dict_code]))
+ )
diff --git a/ruoyi-fastapi-backend/module_admin/dao/job_dao.py b/ruoyi-fastapi-backend/module_admin/dao/job_dao.py
index 0007b5220225f57d5147fd7c365e05a88430670f..cfd6982f6eaf27ecb6b2049a3c7ccb5ae3b55744 100644
--- a/ruoyi-fastapi-backend/module_admin/dao/job_dao.py
+++ b/ruoyi-fastapi-backend/module_admin/dao/job_dao.py
@@ -1,4 +1,5 @@
-from sqlalchemy.orm import Session
+from sqlalchemy import select, update, delete
+from sqlalchemy.ext.asyncio import AsyncSession
from module_admin.entity.do.job_do import SysJob
from module_admin.entity.vo.job_vo import *
from utils.page_util import PageUtil
@@ -10,38 +11,40 @@ class JobDao:
"""
@classmethod
- def get_job_detail_by_id(cls, db: Session, job_id: int):
+ async def get_job_detail_by_id(cls, db: AsyncSession, job_id: int):
"""
根据定时任务id获取定时任务详细信息
:param db: orm对象
:param job_id: 定时任务id
:return: 定时任务信息对象
"""
- job_info = db.query(SysJob) \
- .filter(SysJob.job_id == job_id) \
- .first()
+ job_info = (await db.execute(
+ select(SysJob)
+ .where(SysJob.job_id == job_id)
+ )).scalars().first()
return job_info
@classmethod
- def get_job_detail_by_info(cls, db: Session, job: JobModel):
+ async def get_job_detail_by_info(cls, db: AsyncSession, job: JobModel):
"""
根据定时任务参数获取定时任务信息
:param db: orm对象
:param job: 定时任务参数对象
:return: 定时任务信息对象
"""
- job_info = db.query(SysJob) \
- .filter(SysJob.job_name == job.job_name if job.job_name else True,
- SysJob.job_group == job.job_group if job.job_group else True,
- SysJob.invoke_target == job.invoke_target if job.invoke_target else True,
- SysJob.cron_expression == job.cron_expression if job.cron_expression else True) \
- .first()
+ job_info = (await db.execute(
+ select(SysJob)
+ .where(SysJob.job_name == job.job_name if job.job_name else True,
+ SysJob.job_group == job.job_group if job.job_group else True,
+ SysJob.invoke_target == job.invoke_target if job.invoke_target else True,
+ SysJob.cron_expression == job.cron_expression if job.cron_expression else True)
+ )).scalars().first()
return job_info
@classmethod
- def get_job_list(cls, db: Session, query_object: JobPageQueryModel, is_page: bool = False):
+ async def get_job_list(cls, db: AsyncSession, query_object: JobPageQueryModel, is_page: bool = False):
"""
根据查询参数获取定时任务列表信息
:param db: orm对象
@@ -49,31 +52,32 @@ class JobDao:
:param is_page: 是否开启分页
:return: 定时任务列表信息对象
"""
- query = db.query(SysJob) \
- .filter(SysJob.job_name.like(f'%{query_object.job_name}%') if query_object.job_name else True,
- SysJob.job_group == query_object.job_group if query_object.job_group else True,
- SysJob.status == query_object.status if query_object.status else True
- ) \
+ query = select(SysJob) \
+ .where(SysJob.job_name.like(f'%{query_object.job_name}%') if query_object.job_name else True,
+ SysJob.job_group == query_object.job_group if query_object.job_group else True,
+ SysJob.status == query_object.status if query_object.status else True) \
.distinct()
- job_list = PageUtil.paginate(query, query_object.page_num, query_object.page_size, is_page)
+ job_list = await PageUtil.paginate(db, query, query_object.page_num, query_object.page_size, is_page)
return job_list
@classmethod
- def get_job_list_for_scheduler(cls, db: Session):
+ async def get_job_list_for_scheduler(cls, db: AsyncSession):
"""
获取定时任务列表信息
:param db: orm对象
:return: 定时任务列表信息对象
"""
- job_list = db.query(SysJob) \
- .filter(SysJob.status == 0) \
- .distinct().all()
+ job_list = (await db.execute(
+ select(SysJob)
+ .where(SysJob.status == 0)
+ .distinct()
+ )).scalars().all()
return job_list
@classmethod
- def add_job_dao(cls, db: Session, job: JobModel):
+ async def add_job_dao(cls, db: AsyncSession, job: JobModel):
"""
新增定时任务数据库操作
:param db: orm对象
@@ -82,30 +86,32 @@ class JobDao:
"""
db_job = SysJob(**job.model_dump())
db.add(db_job)
- db.flush()
+ await db.flush()
return db_job
@classmethod
- def edit_job_dao(cls, db: Session, job: dict):
+ async def edit_job_dao(cls, db: AsyncSession, job: dict):
"""
编辑定时任务数据库操作
:param db: orm对象
:param job: 需要更新的定时任务字典
:return:
"""
- db.query(SysJob) \
- .filter(SysJob.job_id == job.get('job_id')) \
- .update(job)
+ await db.execute(
+ update(SysJob),
+ [job]
+ )
@classmethod
- def delete_job_dao(cls, db: Session, job: JobModel):
+ async def delete_job_dao(cls, db: AsyncSession, job: JobModel):
"""
删除定时任务数据库操作
:param db: orm对象
:param job: 定时任务对象
:return:
"""
- db.query(SysJob) \
- .filter(SysJob.job_id == job.job_id) \
- .delete()
+ await db.execute(
+ delete(SysJob)
+ .where(SysJob.job_id.in_([job.job_id]))
+ )
diff --git a/ruoyi-fastapi-backend/module_admin/dao/job_log_dao.py b/ruoyi-fastapi-backend/module_admin/dao/job_log_dao.py
index 713946594c8067107cbc380a5f7a6973937757c3..7bc8abe3871a32a20f180a073ca79cf0299af4db 100644
--- a/ruoyi-fastapi-backend/module_admin/dao/job_log_dao.py
+++ b/ruoyi-fastapi-backend/module_admin/dao/job_log_dao.py
@@ -1,3 +1,5 @@
+from sqlalchemy import select, delete
+from sqlalchemy.ext.asyncio import AsyncSession
from sqlalchemy.orm import Session
from module_admin.entity.do.job_do import SysJobLog
from module_admin.entity.vo.job_vo import *
@@ -11,7 +13,7 @@ class JobLogDao:
"""
@classmethod
- def get_job_log_list(cls, db: Session, query_object: JobLogPageQueryModel, is_page: bool = False):
+ async def get_job_log_list(cls, db: AsyncSession, query_object: JobLogPageQueryModel, is_page: bool = False):
"""
根据查询参数获取定时任务日志列表信息
:param db: orm对象
@@ -19,17 +21,16 @@ class JobLogDao:
:param is_page: 是否开启分页
:return: 定时任务日志列表信息对象
"""
- query = db.query(SysJobLog) \
- .filter(SysJobLog.job_name.like(f'%{query_object.job_name}%') if query_object.job_name else True,
- SysJobLog.job_group == query_object.job_group if query_object.job_group else True,
- SysJobLog.status == query_object.status if query_object.status else True,
- SysJobLog.create_time.between(
- datetime.combine(datetime.strptime(query_object.begin_time, '%Y-%m-%d'), time(00, 00, 00)),
- datetime.combine(datetime.strptime(query_object.end_time, '%Y-%m-%d'), time(23, 59, 59)))
- if query_object.begin_time and query_object.end_time else True
- ) \
+ query = select(SysJobLog) \
+ .where(SysJobLog.job_name.like(f'%{query_object.job_name}%') if query_object.job_name else True,
+ SysJobLog.job_group == query_object.job_group if query_object.job_group else True,
+ SysJobLog.status == query_object.status if query_object.status else True,
+ SysJobLog.create_time.between(
+ datetime.combine(datetime.strptime(query_object.begin_time, '%Y-%m-%d'), time(00, 00, 00)),
+ datetime.combine(datetime.strptime(query_object.end_time, '%Y-%m-%d'), time(23, 59, 59)))
+ if query_object.begin_time and query_object.end_time else True) \
.distinct()
- job_log_list = PageUtil.paginate(query, query_object.page_num, query_object.page_size, is_page)
+ job_log_list = await PageUtil.paginate(db, query, query_object.page_num, query_object.page_size, is_page)
return job_log_list
@@ -48,23 +49,25 @@ class JobLogDao:
return db_job_log
@classmethod
- def delete_job_log_dao(cls, db: Session, job_log: JobLogModel):
+ async def delete_job_log_dao(cls, db: AsyncSession, job_log: JobLogModel):
"""
删除定时任务日志数据库操作
:param db: orm对象
:param job_log: 定时任务日志对象
:return:
"""
- db.query(SysJobLog) \
- .filter(SysJobLog.job_log_id == job_log.job_log_id) \
- .delete()
+ await db.execute(
+ delete(SysJobLog)
+ .where(SysJobLog.job_log_id.in_([job_log.job_log_id]))
+ )
@classmethod
- def clear_job_log_dao(cls, db: Session):
+ async def clear_job_log_dao(cls, db: AsyncSession):
"""
清除定时任务日志数据库操作
:param db: orm对象
:return:
"""
- db.query(SysJobLog) \
- .delete()
+ await db.execute(
+ delete(SysJobLog)
+ )
diff --git a/ruoyi-fastapi-backend/module_admin/dao/log_dao.py b/ruoyi-fastapi-backend/module_admin/dao/log_dao.py
index b2abd545ab19fccb2df8cd17e9e0d2ff46b0c999..5161bea3eec4b77022522ff32485285db367765d 100644
--- a/ruoyi-fastapi-backend/module_admin/dao/log_dao.py
+++ b/ruoyi-fastapi-backend/module_admin/dao/log_dao.py
@@ -1,9 +1,9 @@
-from sqlalchemy import asc, desc
-from sqlalchemy.orm import Session
+from sqlalchemy import select, update, delete, asc, desc
+from sqlalchemy.ext.asyncio import AsyncSession
from module_admin.entity.do.log_do import SysOperLog, SysLogininfor
from module_admin.entity.vo.log_vo import *
from utils.page_util import PageUtil
-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) \
- .filter(SysOperLog.title.like(f'%{query_object.title}%') if query_object.title else True,
- SysOperLog.oper_name.like(f'%{query_object.oper_name}%') if query_object.oper_name else True,
- SysOperLog.business_type == query_object.business_type if query_object.business_type else True,
- SysOperLog.status == query_object.status if query_object.status else True,
- SysOperLog.oper_time.between(
- datetime.combine(datetime.strptime(query_object.begin_time, '%Y-%m-%d'), time(00, 00, 00)),
- datetime.combine(datetime.strptime(query_object.end_time, '%Y-%m-%d'), time(23, 59, 59)))
- if query_object.begin_time and query_object.end_time else True
- )\
- .distinct().order_by(order_by_column)
- operation_log_list = PageUtil.paginate(query, query_object.page_num, query_object.page_size, is_page)
+ query = select(SysOperLog) \
+ .where(SysOperLog.title.like(f'%{query_object.title}%') if query_object.title else True,
+ SysOperLog.oper_name.like(f'%{query_object.oper_name}%') if query_object.oper_name else True,
+ SysOperLog.business_type == query_object.business_type if query_object.business_type else True,
+ SysOperLog.status == query_object.status if query_object.status else True,
+ SysOperLog.oper_time.between(
+ datetime.combine(datetime.strptime(query_object.begin_time, '%Y-%m-%d'), time(00, 00, 00)),
+ datetime.combine(datetime.strptime(query_object.end_time, '%Y-%m-%d'), time(23, 59, 59)))
+ if query_object.begin_time and query_object.end_time else True) \
+ .distinct() \
+ .order_by(order_by_column)
+ operation_log_list = await PageUtil.paginate(db, query, query_object.page_num, query_object.page_size, is_page)
return operation_log_list
@classmethod
- def add_operation_log_dao(cls, db: Session, operation_log: OperLogModel):
+ async def add_operation_log_dao(cls, db: AsyncSession, operation_log: OperLogModel):
"""
新增操作日志数据库操作
:param db: orm对象
@@ -51,31 +53,33 @@ class OperationLogDao:
"""
db_operation_log = SysOperLog(**operation_log.model_dump())
db.add(db_operation_log)
- db.flush()
+ await db.flush()
return db_operation_log
@classmethod
- def delete_operation_log_dao(cls, db: Session, operation_log: OperLogModel):
+ async def delete_operation_log_dao(cls, db: AsyncSession, operation_log: OperLogModel):
"""
删除操作日志数据库操作
:param db: orm对象
:param operation_log: 操作日志对象
:return:
"""
- db.query(SysOperLog) \
- .filter(SysOperLog.oper_id == operation_log.oper_id) \
- .delete()
+ await db.execute(
+ delete(SysOperLog)
+ .where(SysOperLog.oper_id.in_([operation_log.oper_id]))
+ )
@classmethod
- def clear_operation_log_dao(cls, db: Session):
+ async def clear_operation_log_dao(cls, db: AsyncSession):
"""
清除操作日志数据库操作
:param db: orm对象
:return:
"""
- db.query(SysOperLog) \
- .delete()
+ await db.execute(
+ delete(SysOperLog)
+ )
class LoginLogDao:
@@ -84,7 +88,7 @@ class LoginLogDao:
"""
@classmethod
- def get_login_log_list(cls, db: Session, query_object: LoginLogPageQueryModel, is_page: bool = False):
+ async def get_login_log_list(cls, db: AsyncSession, query_object: LoginLogPageQueryModel, is_page: bool = False):
"""
根据查询参数获取登录日志列表信息
:param db: orm对象
@@ -93,27 +97,29 @@ class LoginLogDao:
:return: 登录日志列表信息对象
"""
if query_object.is_asc == 'ascending':
- order_by_column = asc(getattr(SysLogininfor, CamelCaseUtil.camel_to_snake(query_object.order_by_column), None))
+ order_by_column = asc(
+ getattr(SysLogininfor, 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) \
- .filter(SysLogininfor.ipaddr.like(f'%{query_object.ipaddr}%') if query_object.ipaddr else True,
- SysLogininfor.user_name.like(f'%{query_object.user_name}%') if query_object.user_name else True,
- SysLogininfor.status == query_object.status if query_object.status else True,
- SysLogininfor.login_time.between(
- datetime.combine(datetime.strptime(query_object.begin_time, '%Y-%m-%d'), time(00, 00, 00)),
- datetime.combine(datetime.strptime(query_object.end_time, '%Y-%m-%d'), time(23, 59, 59)))
- if query_object.begin_time and query_object.end_time else True
- )\
- .distinct().order_by(order_by_column)
- login_log_list = PageUtil.paginate(query, query_object.page_num, query_object.page_size, is_page)
+ query = select(SysLogininfor) \
+ .where(SysLogininfor.ipaddr.like(f'%{query_object.ipaddr}%') if query_object.ipaddr else True,
+ SysLogininfor.user_name.like(f'%{query_object.user_name}%') if query_object.user_name else True,
+ SysLogininfor.status == query_object.status if query_object.status else True,
+ SysLogininfor.login_time.between(
+ datetime.combine(datetime.strptime(query_object.begin_time, '%Y-%m-%d'), time(00, 00, 00)),
+ datetime.combine(datetime.strptime(query_object.end_time, '%Y-%m-%d'), time(23, 59, 59)))
+ if query_object.begin_time and query_object.end_time else True) \
+ .distinct() \
+ .order_by(order_by_column)
+ login_log_list = await PageUtil.paginate(db, query, query_object.page_num, query_object.page_size, is_page)
return login_log_list
@classmethod
- def add_login_log_dao(cls, db: Session, login_log: LogininforModel):
+ async def add_login_log_dao(cls, db: AsyncSession, login_log: LogininforModel):
"""
新增登录日志数据库操作
:param db: orm对象
@@ -122,28 +128,30 @@ class LoginLogDao:
"""
db_login_log = SysLogininfor(**login_log.model_dump())
db.add(db_login_log)
- db.flush()
+ await db.flush()
return db_login_log
@classmethod
- def delete_login_log_dao(cls, db: Session, login_log: LogininforModel):
+ async def delete_login_log_dao(cls, db: AsyncSession, login_log: LogininforModel):
"""
删除登录日志数据库操作
:param db: orm对象
:param login_log: 登录日志对象
:return:
"""
- db.query(SysLogininfor) \
- .filter(SysLogininfor.info_id == login_log.info_id) \
- .delete()
+ await db.execute(
+ delete(SysLogininfor)
+ .where(SysLogininfor.info_id.in_([login_log.info_id]))
+ )
@classmethod
- def clear_login_log_dao(cls, db: Session):
+ async def clear_login_log_dao(cls, db: AsyncSession):
"""
清除登录日志数据库操作
:param db: orm对象
:return:
"""
- db.query(SysLogininfor) \
- .delete()
+ await db.execute(
+ delete(SysLogininfor)
+ )
diff --git a/ruoyi-fastapi-backend/module_admin/dao/login_dao.py b/ruoyi-fastapi-backend/module_admin/dao/login_dao.py
index b932bc1793139f0174cd40bf89a29252acf89248..2c80c7fc07503b94a5702ad7c4e029c700c8f9fb 100644
--- a/ruoyi-fastapi-backend/module_admin/dao/login_dao.py
+++ b/ruoyi-fastapi-backend/module_admin/dao/login_dao.py
@@ -1,20 +1,21 @@
-from sqlalchemy.orm import Session
-from sqlalchemy import and_
+from sqlalchemy import select, and_
+from sqlalchemy.ext.asyncio import AsyncSession
from module_admin.entity.do.user_do import SysUser
from module_admin.entity.do.dept_do import SysDept
-def login_by_account(db: Session, user_name: str):
+async def login_by_account(db: AsyncSession, user_name: str):
"""
根据用户名查询用户信息
:param db: orm对象
:param user_name: 用户名
:return: 用户对象
"""
- user = db.query(SysUser, SysDept)\
- .filter(SysUser.user_name == user_name, SysUser.del_flag == '0') \
- .outerjoin(SysDept, and_(SysUser.dept_id == SysDept.dept_id, SysDept.status == 0, SysDept.del_flag == 0)) \
- .distinct() \
- .first()
+ user = (await db.execute(
+ select(SysUser, SysDept)
+ .where(SysUser.user_name == user_name, SysUser.del_flag == '0')
+ .join(SysDept, and_(SysUser.dept_id == SysDept.dept_id, SysDept.status == 0, SysDept.del_flag == 0), isouter=True)
+ .distinct()
+ )).first()
return user
diff --git a/ruoyi-fastapi-backend/module_admin/dao/menu_dao.py b/ruoyi-fastapi-backend/module_admin/dao/menu_dao.py
index 272529be55ed0476f52a7f27e47f3e8149671946..7f8545b64db5be5c53e7ea920b1dc4ca9083fe94 100644
--- a/ruoyi-fastapi-backend/module_admin/dao/menu_dao.py
+++ b/ruoyi-fastapi-backend/module_admin/dao/menu_dao.py
@@ -1,5 +1,5 @@
-from sqlalchemy import and_
-from sqlalchemy.orm import Session
+from sqlalchemy import select, update, delete, and_
+from sqlalchemy.ext.asyncio import AsyncSession
from module_admin.entity.do.menu_do import SysMenu
from module_admin.entity.do.user_do import SysUser, SysUserRole
from module_admin.entity.do.role_do import SysRole, SysRoleMenu
@@ -12,37 +12,39 @@ class MenuDao:
"""
@classmethod
- def get_menu_detail_by_id(cls, db: Session, menu_id: int):
+ async def get_menu_detail_by_id(cls, db: AsyncSession, menu_id: int):
"""
根据菜单id获取菜单详细信息
:param db: orm对象
:param menu_id: 菜单id
:return: 菜单信息对象
"""
- menu_info = db.query(SysMenu) \
- .filter(SysMenu.menu_id == menu_id) \
- .first()
+ menu_info = (await db.execute(
+ select(SysMenu)
+ .where(SysMenu.menu_id == menu_id)
+ )).scalars().first()
return menu_info
@classmethod
- def get_menu_detail_by_info(cls, db: Session, menu: MenuModel):
+ async def get_menu_detail_by_info(cls, db: AsyncSession, menu: MenuModel):
"""
根据菜单参数获取菜单信息
:param db: orm对象
:param menu: 菜单参数对象
:return: 菜单信息对象
"""
- menu_info = db.query(SysMenu) \
- .filter(SysMenu.parent_id == menu.parent_id if menu.parent_id else True,
- SysMenu.menu_name == menu.menu_name if menu.menu_name else True,
- SysMenu.menu_type == menu.menu_type if menu.menu_type else True) \
- .first()
+ menu_info = (await db.execute(
+ select(SysMenu)
+ .where(SysMenu.parent_id == menu.parent_id if menu.parent_id else True,
+ SysMenu.menu_name == menu.menu_name if menu.menu_name else True,
+ SysMenu.menu_type == menu.menu_type if menu.menu_type else True)
+ )).scalars().first()
return menu_info
@classmethod
- def get_menu_list_for_tree(cls, db: Session, user_id: int, role: list):
+ async def get_menu_list_for_tree(cls, db: AsyncSession, user_id: int, role: list):
"""
根据角色信息获取所有在用菜单列表信息
:param db: orm对象
@@ -52,25 +54,31 @@ class MenuDao:
"""
role_id_list = [item.role_id for item in role]
if 1 in role_id_list:
- menu_query_all = db.query(SysMenu) \
- .filter(SysMenu.status == 0) \
- .order_by(SysMenu.order_num) \
- .distinct().all()
+ menu_query_all = (await db.execute(
+ select(SysMenu)
+ .where(SysMenu.status == 0)
+ .order_by(SysMenu.order_num)
+ .distinct()
+ )).scalars().all()
else:
- menu_query_all = db.query(SysMenu).select_from(SysUser) \
- .filter(SysUser.status == 0, SysUser.del_flag == 0, SysUser.user_id == user_id) \
- .outerjoin(SysUserRole, SysUser.user_id == SysUserRole.user_id) \
- .outerjoin(SysRole,
- and_(SysUserRole.role_id == SysRole.role_id, SysRole.status == 0, SysRole.del_flag == 0)) \
- .outerjoin(SysRoleMenu, SysRole.role_id == SysRoleMenu.role_id) \
- .join(SysMenu, and_(SysRoleMenu.menu_id == SysMenu.menu_id, SysMenu.status == 0,)) \
- .order_by(SysMenu.order_num) \
- .distinct().all()
+ menu_query_all = (await db.execute(
+ select(SysMenu)
+ .select_from(SysUser)
+ .where(SysUser.status == 0, SysUser.del_flag == 0, SysUser.user_id == user_id)
+ .join(SysUserRole, SysUser.user_id == SysUserRole.user_id, isouter=True)
+ .join(SysRole,
+ and_(SysUserRole.role_id == SysRole.role_id, SysRole.status == 0, SysRole.del_flag == 0),
+ isouter=True)
+ .join(SysRoleMenu, SysRole.role_id == SysRoleMenu.role_id, isouter=True)
+ .join(SysMenu, and_(SysRoleMenu.menu_id == SysMenu.menu_id, SysMenu.status == 0))
+ .order_by(SysMenu.order_num)
+ .distinct()
+ )).scalars().all()
return menu_query_all
@classmethod
- def get_menu_list(cls, db: Session, page_object: MenuQueryModel, user_id: int, role: list):
+ async def get_menu_list(cls, db: AsyncSession, page_object: MenuQueryModel, user_id: int, role: list):
"""
根据查询参数获取菜单列表信息
:param db: orm对象
@@ -81,30 +89,36 @@ class MenuDao:
"""
role_id_list = [item.role_id for item in role]
if 1 in role_id_list:
- menu_query_all = db.query(SysMenu) \
- .filter(SysMenu.status == page_object.status if page_object.status else True,
- SysMenu.menu_name.like(
- f'%{page_object.menu_name}%') if page_object.menu_name else True) \
- .order_by(SysMenu.order_num) \
- .distinct().all()
+ menu_query_all = (await db.execute(
+ select(SysMenu)
+ .where(SysMenu.status == page_object.status if page_object.status else True,
+ SysMenu.menu_name.like(
+ f'%{page_object.menu_name}%') if page_object.menu_name else True)
+ .order_by(SysMenu.order_num)
+ .distinct()
+ )).scalars().all()
else:
- menu_query_all = db.query(SysMenu).select_from(SysUser) \
- .filter(SysUser.status == 0, SysUser.del_flag == 0, SysUser.user_id == user_id) \
- .outerjoin(SysUserRole, SysUser.user_id == SysUserRole.user_id) \
- .outerjoin(SysRole,
- and_(SysUserRole.role_id == SysRole.role_id, SysRole.status == 0, SysRole.del_flag == 0)) \
- .outerjoin(SysRoleMenu, SysRole.role_id == SysRoleMenu.role_id) \
- .join(SysMenu, and_(SysRoleMenu.menu_id == SysMenu.menu_id,
- SysMenu.status == page_object.status if page_object.status else True,
- SysMenu.menu_name.like(
- f'%{page_object.menu_name}%') if page_object.menu_name else True)) \
- .order_by(SysMenu.order_num) \
- .distinct().all()
+ menu_query_all = (await db.execute(
+ select(SysMenu)
+ .select_from(SysUser)
+ .where(SysUser.status == 0, SysUser.del_flag == 0, SysUser.user_id == user_id)
+ .join(SysUserRole, SysUser.user_id == SysUserRole.user_id, isouter=True)
+ .join(SysRole,
+ and_(SysUserRole.role_id == SysRole.role_id, SysRole.status == 0, SysRole.del_flag == 0),
+ isouter=True)
+ .join(SysRoleMenu, SysRole.role_id == SysRoleMenu.role_id, isouter=True)
+ .join(SysMenu, and_(SysRoleMenu.menu_id == SysMenu.menu_id,
+ SysMenu.status == page_object.status if page_object.status else True,
+ SysMenu.menu_name.like(
+ f'%{page_object.menu_name}%') if page_object.menu_name else True))
+ .order_by(SysMenu.order_num)
+ .distinct()
+ )).scalars().all()
return menu_query_all
@classmethod
- def add_menu_dao(cls, db: Session, menu: MenuModel):
+ async def add_menu_dao(cls, db: AsyncSession, menu: MenuModel):
"""
新增菜单数据库操作
:param db: orm对象
@@ -113,30 +127,32 @@ class MenuDao:
"""
db_menu = SysMenu(**menu.model_dump())
db.add(db_menu)
- db.flush()
+ await db.flush()
return db_menu
@classmethod
- def edit_menu_dao(cls, db: Session, menu: dict):
+ async def edit_menu_dao(cls, db: AsyncSession, menu: dict):
"""
编辑菜单数据库操作
:param db: orm对象
:param menu: 需要更新的菜单字典
:return:
"""
- db.query(SysMenu) \
- .filter(SysMenu.menu_id == menu.get('menu_id')) \
- .update(menu)
+ await db.execute(
+ update(SysMenu),
+ [menu]
+ )
@classmethod
- def delete_menu_dao(cls, db: Session, menu: MenuModel):
+ async def delete_menu_dao(cls, db: AsyncSession, menu: MenuModel):
"""
删除菜单数据库操作
:param db: orm对象
:param menu: 菜单对象
:return:
"""
- db.query(SysMenu) \
- .filter(SysMenu.menu_id == menu.menu_id) \
- .delete()
+ await db.execute(
+ delete(SysMenu)
+ .where(SysMenu.menu_id.in_([menu.menu_id]))
+ )
diff --git a/ruoyi-fastapi-backend/module_admin/dao/notice_dao.py b/ruoyi-fastapi-backend/module_admin/dao/notice_dao.py
index 79f32a3016600551cd00829a01d81958fd7eb014..fd1846f9dc0eeb6d9968a9caa23b72d028ca44e9 100644
--- a/ruoyi-fastapi-backend/module_admin/dao/notice_dao.py
+++ b/ruoyi-fastapi-backend/module_admin/dao/notice_dao.py
@@ -1,4 +1,5 @@
-from sqlalchemy.orm import Session
+from sqlalchemy import select, update, delete
+from sqlalchemy.ext.asyncio import AsyncSession
from module_admin.entity.do.notice_do import SysNotice
from module_admin.entity.vo.notice_vo import *
from utils.page_util import PageUtil
@@ -11,37 +12,39 @@ class NoticeDao:
"""
@classmethod
- def get_notice_detail_by_id(cls, db: Session, notice_id: int):
+ async def get_notice_detail_by_id(cls, db: AsyncSession, notice_id: int):
"""
根据通知公告id获取通知公告详细信息
:param db: orm对象
:param notice_id: 通知公告id
:return: 通知公告信息对象
"""
- notice_info = db.query(SysNotice) \
- .filter(SysNotice.notice_id == notice_id) \
- .first()
+ notice_info = (await db.execute(
+ select(SysNotice)
+ .where(SysNotice.notice_id == notice_id)
+ )).scalars().first()
return notice_info
@classmethod
- def get_notice_detail_by_info(cls, db: Session, notice: NoticeModel):
+ async def get_notice_detail_by_info(cls, db: AsyncSession, notice: NoticeModel):
"""
根据通知公告参数获取通知公告信息
:param db: orm对象
:param notice: 通知公告参数对象
:return: 通知公告信息对象
"""
- notice_info = db.query(SysNotice) \
- .filter(SysNotice.notice_title == notice.notice_title if notice.notice_title else True,
- SysNotice.notice_type == notice.notice_type if notice.notice_type else True,
- SysNotice.notice_content == notice.notice_content if notice.notice_content else True) \
- .first()
+ notice_info = (await db.execute(
+ select(SysNotice)
+ .where(SysNotice.notice_title == notice.notice_title if notice.notice_title else True,
+ SysNotice.notice_type == notice.notice_type if notice.notice_type else True,
+ SysNotice.notice_content == notice.notice_content if notice.notice_content else True)
+ )).scalars().first()
return notice_info
@classmethod
- def get_notice_list(cls, db: Session, query_object: NoticePageQueryModel, is_page: bool = False):
+ async def get_notice_list(cls, db: AsyncSession, query_object: NoticePageQueryModel, is_page: bool = False):
"""
根据查询参数获取通知公告列表信息
:param db: orm对象
@@ -49,22 +52,21 @@ class NoticeDao:
:param is_page: 是否开启分页
:return: 通知公告列表信息对象
"""
- query = db.query(SysNotice) \
- .filter(SysNotice.notice_title.like(f'%{query_object.notice_title}%') if query_object.notice_title else True,
- SysNotice.create_by.like(f'%{query_object.create_by}%') if query_object.create_by else True,
- SysNotice.notice_type == query_object.notice_type if query_object.notice_type else True,
- SysNotice.create_time.between(
- datetime.combine(datetime.strptime(query_object.begin_time, '%Y-%m-%d'), time(00, 00, 00)),
- datetime.combine(datetime.strptime(query_object.end_time, '%Y-%m-%d'), time(23, 59, 59)))
- if query_object.begin_time and query_object.end_time else True
- ) \
+ query = select(SysNotice) \
+ .where(SysNotice.notice_title.like(f'%{query_object.notice_title}%') if query_object.notice_title else True,
+ SysNotice.create_by.like(f'%{query_object.create_by}%') if query_object.create_by else True,
+ SysNotice.notice_type == query_object.notice_type if query_object.notice_type else True,
+ SysNotice.create_time.between(
+ datetime.combine(datetime.strptime(query_object.begin_time, '%Y-%m-%d'), time(00, 00, 00)),
+ datetime.combine(datetime.strptime(query_object.end_time, '%Y-%m-%d'), time(23, 59, 59)))
+ if query_object.begin_time and query_object.end_time else True) \
.distinct()
- notice_list = PageUtil.paginate(query, query_object.page_num, query_object.page_size, is_page)
+ notice_list = await PageUtil.paginate(db, query, query_object.page_num, query_object.page_size, is_page)
return notice_list
@classmethod
- def add_notice_dao(cls, db: Session, notice: NoticeModel):
+ async def add_notice_dao(cls, db: AsyncSession, notice: NoticeModel):
"""
新增通知公告数据库操作
:param db: orm对象
@@ -73,30 +75,32 @@ class NoticeDao:
"""
db_notice = SysNotice(**notice.model_dump())
db.add(db_notice)
- db.flush()
+ await db.flush()
return db_notice
@classmethod
- def edit_notice_dao(cls, db: Session, notice: dict):
+ async def edit_notice_dao(cls, db: AsyncSession, notice: dict):
"""
编辑通知公告数据库操作
:param db: orm对象
:param notice: 需要更新的通知公告字典
:return:
"""
- db.query(SysNotice) \
- .filter(SysNotice.notice_id == notice.get('notice_id')) \
- .update(notice)
+ await db.execute(
+ update(SysNotice),
+ [notice]
+ )
@classmethod
- def delete_notice_dao(cls, db: Session, notice: NoticeModel):
+ async def delete_notice_dao(cls, db: AsyncSession, notice: NoticeModel):
"""
删除通知公告数据库操作
:param db: orm对象
:param notice: 通知公告对象
:return:
"""
- db.query(SysNotice) \
- .filter(SysNotice.notice_id == notice.notice_id) \
- .delete()
+ await db.execute(
+ delete(SysNotice)
+ .where(SysNotice.notice_id.in_([notice.notice_id]))
+ )
diff --git a/ruoyi-fastapi-backend/module_admin/dao/post_dao.py b/ruoyi-fastapi-backend/module_admin/dao/post_dao.py
index 2cb7f89744e972120897d2d291d8fc48c1c00a12..d485d38c2357be10c646a83c782611fd31ff2826 100644
--- a/ruoyi-fastapi-backend/module_admin/dao/post_dao.py
+++ b/ruoyi-fastapi-backend/module_admin/dao/post_dao.py
@@ -1,4 +1,5 @@
-from sqlalchemy.orm import Session
+from sqlalchemy import select, update, delete
+from sqlalchemy.ext.asyncio import AsyncSession
from module_admin.entity.do.post_do import SysPost
from module_admin.entity.vo.post_vo import *
from utils.page_util import PageUtil
@@ -10,52 +11,55 @@ class PostDao:
"""
@classmethod
- def get_post_by_id(cls, db: Session, post_id: int):
+ async def get_post_by_id(cls, db: AsyncSession, post_id: int):
"""
根据岗位id获取在用岗位详细信息
:param db: orm对象
:param post_id: 岗位id
:return: 在用岗位信息对象
"""
- post_info = db.query(SysPost) \
- .filter(SysPost.post_id == post_id,
- SysPost.status == 0) \
- .first()
+ post_info = (await db.execute(
+ select(SysPost)
+ .where(SysPost.post_id == post_id,
+ SysPost.status == 0)
+ )).scalars().first()
return post_info
@classmethod
- def get_post_detail_by_id(cls, db: Session, post_id: int):
+ async def get_post_detail_by_id(cls, db: AsyncSession, post_id: int):
"""
根据岗位id获取岗位详细信息
:param db: orm对象
:param post_id: 岗位id
:return: 岗位信息对象
"""
- post_info = db.query(SysPost) \
- .filter(SysPost.post_id == post_id) \
- .first()
+ post_info = (await db.execute(
+ select(SysPost)
+ .where(SysPost.post_id == post_id)
+ )).scalars().first()
return post_info
@classmethod
- def get_post_detail_by_info(cls, db: Session, post: PostModel):
+ async def get_post_detail_by_info(cls, db: AsyncSession, post: PostModel):
"""
根据岗位参数获取岗位信息
:param db: orm对象
:param post: 岗位参数对象
:return: 岗位信息对象
"""
- post_info = db.query(SysPost) \
- .filter(SysPost.post_name == post.post_name if post.post_name else True,
- SysPost.post_code == post.post_code if post.post_code else True,
- SysPost.post_sort == post.post_sort if post.post_sort else True) \
- .first()
+ post_info = (await db.execute(
+ select(SysPost)
+ .where(SysPost.post_name == post.post_name if post.post_name else True,
+ SysPost.post_code == post.post_code if post.post_code else True,
+ SysPost.post_sort == post.post_sort if post.post_sort else True)
+ )).scalars().first()
return post_info
@classmethod
- def get_post_list(cls, db: Session, query_object: PostPageQueryModel, is_page: bool = False):
+ async def get_post_list(cls, db: AsyncSession, query_object: PostPageQueryModel, is_page: bool = False):
"""
根据查询参数获取岗位列表信息
:param db: orm对象
@@ -63,19 +67,18 @@ class PostDao:
:param is_page: 是否开启分页
:return: 岗位列表信息对象
"""
- query = db.query(SysPost) \
- .filter(SysPost.post_code.like(f'%{query_object.post_code}%') if query_object.post_code else True,
- SysPost.post_name.like(f'%{query_object.post_name}%') if query_object.post_name else True,
- SysPost.status == query_object.status if query_object.status else True
- ) \
+ query = select(SysPost) \
+ .where(SysPost.post_code.like(f'%{query_object.post_code}%') if query_object.post_code else True,
+ SysPost.post_name.like(f'%{query_object.post_name}%') if query_object.post_name else True,
+ SysPost.status == query_object.status if query_object.status else True) \
.order_by(SysPost.post_sort) \
.distinct()
- post_list = PageUtil.paginate(query, query_object.page_num, query_object.page_size, is_page)
+ post_list = await PageUtil.paginate(db, query, query_object.page_num, query_object.page_size, is_page)
return post_list
@classmethod
- def add_post_dao(cls, db: Session, post: PostModel):
+ async def add_post_dao(cls, db: AsyncSession, post: PostModel):
"""
新增岗位数据库操作
:param db: orm对象
@@ -84,30 +87,32 @@ class PostDao:
"""
db_post = SysPost(**post.model_dump())
db.add(db_post)
- db.flush()
+ await db.flush()
return db_post
@classmethod
- def edit_post_dao(cls, db: Session, post: dict):
+ async def edit_post_dao(cls, db: AsyncSession, post: dict):
"""
编辑岗位数据库操作
:param db: orm对象
:param post: 需要更新的岗位字典
:return:
"""
- db.query(SysPost) \
- .filter(SysPost.post_id == post.get('post_id')) \
- .update(post)
+ await db.execute(
+ update(SysPost),
+ [post]
+ )
@classmethod
- def delete_post_dao(cls, db: Session, post: PostModel):
+ async def delete_post_dao(cls, db: AsyncSession, post: PostModel):
"""
删除岗位数据库操作
:param db: orm对象
:param post: 岗位对象
:return:
"""
- db.query(SysPost) \
- .filter(SysPost.post_id == post.post_id) \
- .delete()
+ await db.execute(
+ delete(SysPost)
+ .where(SysPost.post_id.in_([post.post_id]))
+ )
diff --git a/ruoyi-fastapi-backend/module_admin/dao/role_dao.py b/ruoyi-fastapi-backend/module_admin/dao/role_dao.py
index 32267dabab28395fa627b16ed5b561611bce98c8..9c435506719ab9b812c989069d45312381cbe978 100644
--- a/ruoyi-fastapi-backend/module_admin/dao/role_dao.py
+++ b/ruoyi-fastapi-backend/module_admin/dao/role_dao.py
@@ -1,5 +1,5 @@
-from sqlalchemy import desc, func
-from sqlalchemy.orm import Session
+from sqlalchemy import select, update, delete, desc, func
+from sqlalchemy.ext.asyncio import AsyncSession
from module_admin.entity.do.role_do import SysRole, SysRoleMenu, SysRoleDept
from module_admin.entity.do.dept_do import SysDept
from module_admin.entity.vo.role_vo import *
@@ -13,80 +13,90 @@ class RoleDao:
"""
@classmethod
- def get_role_by_name(cls, db: Session, role_name: str):
+ async def get_role_by_name(cls, db: AsyncSession, role_name: str):
"""
根据角色名获取在用角色信息
:param db: orm对象
:param role_name: 角色名
:return: 当前角色名的角色信息对象
"""
- query_role_info = db.query(SysRole) \
- .filter(SysRole.status == 0, SysRole.del_flag == 0, SysRole.role_name == role_name) \
- .order_by(desc(SysRole.create_time)).distinct().first()
+ query_role_info = (await db.execute(
+ select(SysRole)
+ .where(SysRole.status == 0, SysRole.del_flag == 0, SysRole.role_name == role_name)
+ .order_by(desc(SysRole.create_time))
+ .distinct()
+ )).scalars().first()
return query_role_info
@classmethod
- def get_role_by_info(cls, db: Session, role: RoleModel):
+ async def get_role_by_info(cls, db: AsyncSession, role: RoleModel):
"""
根据角色参数获取角色信息
:param db: orm对象
:param role: 角色参数
:return: 当前角色参数的角色信息对象
"""
- query_role_info = db.query(SysRole) \
- .filter(SysRole.del_flag == 0,
- SysRole.role_name == role.role_name if role.role_name else True,
- SysRole.role_key == role.role_key if role.role_key else True) \
- .order_by(desc(SysRole.create_time)).distinct().first()
+ query_role_info = (await db.execute(
+ select(SysRole)
+ .where(SysRole.del_flag == 0,
+ SysRole.role_name == role.role_name if role.role_name else True,
+ SysRole.role_key == role.role_key if role.role_key else True)
+ .order_by(desc(SysRole.create_time))
+ .distinct()
+ )).scalars().first()
return query_role_info
@classmethod
- def get_role_by_id(cls, db: Session, role_id: int):
+ async def get_role_by_id(cls, db: AsyncSession, role_id: int):
"""
根据角色id获取在用角色信息
:param db: orm对象
:param role_id: 角色id
:return: 当前角色id的角色信息对象
"""
- role_info = db.query(SysRole) \
- .filter(SysRole.role_id == role_id,
- SysRole.status == 0,
- SysRole.del_flag == 0) \
- .first()
+ role_info = (await db.execute(
+ select(SysRole)
+ .where(SysRole.role_id == role_id,
+ SysRole.status == 0,
+ SysRole.del_flag == 0)
+ )).scalars().first()
return role_info
@classmethod
- def get_role_detail_by_id(cls, db: Session, role_id: int):
+ async def get_role_detail_by_id(cls, db: AsyncSession, role_id: int):
"""
根据role_id获取角色详细信息
:param db: orm对象
:param role_id: 角色id
:return: 当前role_id的角色信息对象
"""
- query_role_info = db.query(SysRole) \
- .filter(SysRole.del_flag == 0, SysRole.role_id == role_id) \
- .distinct().first()
+ query_role_info = (await db.execute(
+ select(SysRole)
+ .where(SysRole.del_flag == 0, SysRole.role_id == role_id)
+ .distinct()
+ )).scalars().first()
return query_role_info
@classmethod
- def get_role_select_option_dao(cls, db: Session):
+ async def get_role_select_option_dao(cls, db: AsyncSession):
"""
获取编辑页面对应的在用角色列表信息
:param db: orm对象
:return: 角色列表信息
"""
- role_info = db.query(SysRole) \
- .filter(SysRole.role_id != 1, SysRole.status == 0, SysRole.del_flag == 0) \
- .all()
+ role_info = (await db.execute(
+ select(SysRole)
+ .where(SysRole.role_id != 1, SysRole.status == 0, SysRole.del_flag == 0)
+ )).scalars().all()
return role_info
@classmethod
- def get_role_list(cls, db: Session, query_object: RolePageQueryModel, is_page: bool = False):
+ async def get_role_list(cls, db: AsyncSession, query_object: RolePageQueryModel, is_page: bool = False):
"""
根据查询参数获取角色列表信息
:param db: orm对象
@@ -94,24 +104,23 @@ class RoleDao:
:param is_page: 是否开启分页
:return: 角色列表信息对象
"""
- query = db.query(SysRole) \
- .filter(SysRole.del_flag == 0,
- SysRole.role_name.like(f'%{query_object.role_name}%') if query_object.role_name else True,
- SysRole.role_key.like(f'%{query_object.role_key}%') if query_object.role_key else True,
- SysRole.status == query_object.status if query_object.status else True,
- SysRole.create_time.between(
- datetime.combine(datetime.strptime(query_object.begin_time, '%Y-%m-%d'), time(00, 00, 00)),
- datetime.combine(datetime.strptime(query_object.end_time, '%Y-%m-%d'), time(23, 59, 59)))
- if query_object.begin_time and query_object.end_time else True
- ) \
+ query = select(SysRole) \
+ .where(SysRole.del_flag == 0,
+ SysRole.role_name.like(f'%{query_object.role_name}%') if query_object.role_name else True,
+ SysRole.role_key.like(f'%{query_object.role_key}%') if query_object.role_key else True,
+ SysRole.status == query_object.status if query_object.status else True,
+ SysRole.create_time.between(
+ datetime.combine(datetime.strptime(query_object.begin_time, '%Y-%m-%d'), time(00, 00, 00)),
+ datetime.combine(datetime.strptime(query_object.end_time, '%Y-%m-%d'), time(23, 59, 59)))
+ if query_object.begin_time and query_object.end_time else True) \
.order_by(SysRole.role_sort) \
.distinct()
- role_list = PageUtil.paginate(query, query_object.page_num, query_object.page_size, is_page)
+ role_list = await PageUtil.paginate(db, query, query_object.page_num, query_object.page_size, is_page)
return role_list
@classmethod
- def add_role_dao(cls, db: Session, role: RoleModel):
+ async def add_role_dao(cls, db: AsyncSession, role: RoleModel):
"""
新增角色数据库操作
:param db: orm对象
@@ -120,50 +129,55 @@ class RoleDao:
"""
db_role = SysRole(**role.model_dump(exclude={'admin'}))
db.add(db_role)
- db.flush()
+ await db.flush()
return db_role
@classmethod
- def edit_role_dao(cls, db: Session, role: dict):
+ async def edit_role_dao(cls, db: AsyncSession, role: dict):
"""
编辑角色数据库操作
:param db: orm对象
:param role: 需要更新的角色字典
:return:
"""
- db.query(SysRole) \
- .filter(SysRole.role_id == role.get('role_id')) \
- .update(role)
+ await db.execute(
+ update(SysRole),
+ [role]
+ )
@classmethod
- def delete_role_dao(cls, db: Session, role: RoleModel):
+ async def delete_role_dao(cls, db: AsyncSession, role: RoleModel):
"""
删除角色数据库操作
:param db: orm对象
:param role: 角色对象
:return:
"""
- db.query(SysRole) \
- .filter(SysRole.role_id == role.role_id) \
- .update({SysRole.del_flag: '2', SysRole.update_by: role.update_by, SysRole.update_time: role.update_time})
+ await db.execute(
+ update(SysRole)
+ .where(SysRole.role_id == role.role_id)
+ .values(del_flag='2', update_by=role.update_by, update_time=role.update_time)
+ )
@classmethod
- def get_role_menu_dao(cls, db: Session, role_id: int):
+ async def get_role_menu_dao(cls, db: AsyncSession, role_id: int):
"""
根据角色id获取角色菜单关联列表信息
:param db: orm对象
:param role_id: 角色id
:return: 角色菜单关联列表信息
"""
- role_menu_query_all = db.query(SysRoleMenu) \
- .filter(SysRoleMenu.role_id == role_id) \
- .distinct().all()
+ role_menu_query_all = (await db.execute(
+ select(SysRoleMenu)
+ .where(SysRoleMenu.role_id == role_id)
+ .distinct()
+ )).scalars().all()
return role_menu_query_all
@classmethod
- def add_role_menu_dao(cls, db: Session, role_menu: RoleMenuModel):
+ async def add_role_menu_dao(cls, db: AsyncSession, role_menu: RoleMenuModel):
"""
新增角色菜单关联信息数据库操作
:param db: orm对象
@@ -174,35 +188,37 @@ class RoleDao:
db.add(db_role_menu)
@classmethod
- def delete_role_menu_dao(cls, db: Session, role_menu: RoleMenuModel):
+ async def delete_role_menu_dao(cls, db: AsyncSession, role_menu: RoleMenuModel):
"""
删除角色菜单关联信息数据库操作
:param db: orm对象
:param role_menu: 角色菜单关联对象
:return:
"""
- db.query(SysRoleMenu) \
- .filter(SysRoleMenu.role_id == role_menu.role_id) \
- .delete()
+ await db.execute(
+ delete(SysRoleMenu)
+ .where(SysRoleMenu.role_id.in_([role_menu.role_id]))
+ )
@classmethod
- def get_role_dept_dao(cls, db: Session, role_id: int):
+ async def get_role_dept_dao(cls, db: AsyncSession, role_id: int):
"""
根据角色id获取角色部门关联列表信息
:param db: orm对象
:param role_id: 角色id
:return: 角色部门关联列表信息
"""
- role_dept_query_all = db.query(SysRoleDept) \
- .filter(SysRoleDept.role_id == role_id,
- ~db.query(SysDept).filter(func.find_in_set(SysRoleDept.dept_id, SysDept.ancestors)).exists()
- ) \
- .distinct().all()
+ role_dept_query_all = (await db.execute(
+ select(SysRoleDept)
+ .where(SysRoleDept.role_id == role_id,
+ ~select(SysDept).where(func.find_in_set(SysRoleDept.dept_id, SysDept.ancestors)).exists())
+ .distinct()
+ )).scalars().all()
return role_dept_query_all
@classmethod
- def add_role_dept_dao(cls, db: Session, role_dept: RoleDeptModel):
+ async def add_role_dept_dao(cls, db: AsyncSession, role_dept: RoleDeptModel):
"""
新增角色部门关联信息数据库操作
:param db: orm对象
@@ -213,13 +229,14 @@ class RoleDao:
db.add(db_role_dept)
@classmethod
- def delete_role_dept_dao(cls, db: Session, role_dept: RoleDeptModel):
+ async def delete_role_dept_dao(cls, db: AsyncSession, role_dept: RoleDeptModel):
"""
删除角色部门关联信息数据库操作
:param db: orm对象
:param role_dept: 角色部门关联对象
:return:
"""
- db.query(SysRoleDept) \
- .filter(SysRoleDept.role_id == role_dept.role_id) \
- .delete()
+ await db.execute(
+ delete(SysRoleDept)
+ .where(SysRoleDept.role_id.in_([role_dept.role_id]))
+ )
diff --git a/ruoyi-fastapi-backend/module_admin/dao/user_dao.py b/ruoyi-fastapi-backend/module_admin/dao/user_dao.py
index 20e28795104aa164b95dbd0dc1b26809122079a2..d73c6f08fccfac1b2f5154ce63ba653e296f8020 100644
--- a/ruoyi-fastapi-backend/module_admin/dao/user_dao.py
+++ b/ruoyi-fastapi-backend/module_admin/dao/user_dao.py
@@ -1,5 +1,5 @@
-from sqlalchemy import and_, or_, desc, func
-from sqlalchemy.orm import Session
+from sqlalchemy import select, update, delete, and_, or_, desc, func
+from sqlalchemy.ext.asyncio import AsyncSession
from module_admin.entity.do.user_do import SysUser, SysUserRole, SysUserPost
from module_admin.entity.do.role_do import SysRole, SysRoleDept, SysRoleMenu
from module_admin.entity.do.dept_do import SysDept
@@ -16,73 +16,96 @@ class UserDao:
"""
@classmethod
- def get_user_by_name(cls, db: Session, user_name: str):
+ async def get_user_by_name(cls, db: AsyncSession, user_name: str):
"""
根据用户名获取用户信息
:param db: orm对象
:param user_name: 用户名
:return: 当前用户名的用户信息对象
"""
- query_user_info = db.query(SysUser) \
- .filter(SysUser.status == 0, SysUser.del_flag == 0, SysUser.user_name == user_name) \
- .order_by(desc(SysUser.create_time)).distinct().first()
+ query_user_info = (await db.execute(
+ select(SysUser)
+ .where(SysUser.status == 0, SysUser.del_flag == 0, SysUser.user_name == user_name)
+ .order_by(desc(SysUser.create_time))
+ .distinct()
+ )).scalars().first()
return query_user_info
@classmethod
- def get_user_by_info(cls, db: Session, user: UserModel):
+ async def get_user_by_info(cls, db: AsyncSession, user: UserModel):
"""
根据用户参数获取用户信息
:param db: orm对象
:param user: 用户参数
:return: 当前用户参数的用户信息对象
"""
- query_user_info = db.query(SysUser) \
- .filter(SysUser.del_flag == 0,
- SysUser.user_name == user.user_name) \
- .order_by(desc(SysUser.create_time)).distinct().first()
+ query_user_info = (await db.execute(
+ select(SysUser)
+ .where(SysUser.del_flag == 0, SysUser.user_name == user.user_name)
+ .order_by(desc(SysUser.create_time))
+ .distinct()
+ )).scalars().first()
return query_user_info
@classmethod
- def get_user_by_id(cls, db: Session, user_id: int):
+ async def get_user_by_id(cls, db: AsyncSession, user_id: int):
"""
根据user_id获取用户信息
:param db: orm对象
:param user_id: 用户id
:return: 当前user_id的用户信息对象
"""
- query_user_basic_info = db.query(SysUser) \
- .filter(SysUser.status == 0, SysUser.del_flag == 0, SysUser.user_id == user_id) \
- .distinct().first()
- query_user_dept_info = db.query(SysDept).select_from(SysUser) \
- .filter(SysUser.status == 0, SysUser.del_flag == 0, SysUser.user_id == user_id) \
- .join(SysDept, and_(SysUser.dept_id == SysDept.dept_id, SysDept.status == 0, SysDept.del_flag == 0)) \
- .distinct().first()
- query_user_role_info = db.query(SysRole).select_from(SysUser) \
- .filter(SysUser.status == 0, SysUser.del_flag == 0, SysUser.user_id == user_id) \
- .outerjoin(SysUserRole, SysUser.user_id == SysUserRole.user_id) \
- .join(SysRole, and_(SysUserRole.role_id == SysRole.role_id, SysRole.status == 0, SysRole.del_flag == 0)) \
- .distinct().all()
- query_user_post_info = db.query(SysPost).select_from(SysUser) \
- .filter(SysUser.status == 0, SysUser.del_flag == 0, SysUser.user_id == user_id) \
- .outerjoin(SysUserPost, SysUser.user_id == SysUserPost.user_id) \
- .join(SysPost, and_(SysUserPost.post_id == SysPost.post_id, SysPost.status == 0)) \
- .distinct().all()
+ query_user_basic_info = (await db.execute(
+ select(SysUser)
+ .where(SysUser.status == 0, SysUser.del_flag == 0, SysUser.user_id == user_id)
+ .distinct()
+ )).scalars().first()
+ query_user_dept_info = (await db.execute(
+ select(SysDept)
+ .select_from(SysUser)
+ .where(SysUser.status == 0, SysUser.del_flag == 0, SysUser.user_id == user_id)
+ .join(SysDept, and_(SysUser.dept_id == SysDept.dept_id, SysDept.status == 0, SysDept.del_flag == 0))
+ .distinct()
+ )).scalars().first()
+ query_user_role_info = (await db.execute(
+ select(SysRole)
+ .select_from(SysUser)
+ .where(SysUser.status == 0, SysUser.del_flag == 0, SysUser.user_id == user_id)
+ .join(SysUserRole, SysUser.user_id == SysUserRole.user_id, isouter=True)
+ .join(SysRole, and_(SysUserRole.role_id == SysRole.role_id, SysRole.status == 0, SysRole.del_flag == 0))
+ .distinct()
+ )).scalars().all()
+ query_user_post_info = (await db.execute(
+ select(SysPost)
+ .select_from(SysUser)
+ .where(SysUser.status == 0, SysUser.del_flag == 0, SysUser.user_id == user_id)
+ .join(SysUserPost, SysUser.user_id == SysUserPost.user_id, isouter=True)
+ .join(SysPost, and_(SysUserPost.post_id == SysPost.post_id, SysPost.status == 0))
+ .distinct()
+ )).scalars().all()
role_id_list = [item.role_id for item in query_user_role_info]
if 1 in role_id_list:
- query_user_menu_info = db.query(SysMenu) \
- .filter(SysMenu.status == 0) \
- .distinct().all()
+ query_user_menu_info = (await db.execute(
+ select(SysMenu)
+ .where(SysMenu.status == 0)
+ .distinct()
+ )).scalars().all()
else:
- query_user_menu_info = db.query(SysMenu).select_from(SysUser) \
- .filter(SysUser.status == 0, SysUser.del_flag == 0, SysUser.user_id == user_id) \
- .outerjoin(SysUserRole, SysUser.user_id == SysUserRole.user_id) \
- .outerjoin(SysRole, and_(SysUserRole.role_id == SysRole.role_id, SysRole.status == 0, SysRole.del_flag == 0)) \
- .outerjoin(SysRoleMenu, SysRole.role_id == SysRoleMenu.role_id) \
- .join(SysMenu, and_(SysRoleMenu.menu_id == SysMenu.menu_id, SysMenu.status == 0)) \
- .order_by(SysMenu.order_num) \
- .distinct().all()
+ query_user_menu_info = (await db.execute(
+ select(SysMenu)
+ .select_from(SysUser)
+ .where(SysUser.status == 0, SysUser.del_flag == 0, SysUser.user_id == user_id)
+ .join(SysUserRole, SysUser.user_id == SysUserRole.user_id, isouter=True)
+ .join(SysRole,
+ and_(SysUserRole.role_id == SysRole.role_id, SysRole.status == 0, SysRole.del_flag == 0),
+ isouter=True)
+ .join(SysRoleMenu, SysRole.role_id == SysRoleMenu.role_id, isouter=True)
+ .join(SysMenu, and_(SysRoleMenu.menu_id == SysMenu.menu_id, SysMenu.status == 0))
+ .order_by(SysMenu.order_num)
+ .distinct()
+ )).scalars().all()
results = dict(
user_basic_info=query_user_basic_info,
@@ -95,37 +118,52 @@ class UserDao:
return results
@classmethod
- def get_user_detail_by_id(cls, db: Session, user_id: int):
+ async def get_user_detail_by_id(cls, db: AsyncSession, user_id: int):
"""
根据user_id获取用户详细信息
:param db: orm对象
:param user_id: 用户id
:return: 当前user_id的用户信息对象
"""
- query_user_basic_info = db.query(SysUser) \
- .filter(SysUser.del_flag == 0, SysUser.user_id == user_id) \
- .distinct().first()
- query_user_dept_info = db.query(SysDept).select_from(SysUser) \
- .filter(SysUser.del_flag == 0, SysUser.user_id == user_id) \
- .join(SysDept, and_(SysUser.dept_id == SysDept.dept_id, SysDept.status == 0, SysDept.del_flag == 0)) \
- .distinct().first()
- query_user_role_info = db.query(SysRole).select_from(SysUser) \
- .filter(SysUser.del_flag == 0, SysUser.user_id == user_id) \
- .outerjoin(SysUserRole, SysUser.user_id == SysUserRole.user_id) \
- .join(SysRole, and_(SysUserRole.role_id == SysRole.role_id, SysRole.status == 0, SysRole.del_flag == 0)) \
- .distinct().all()
- query_user_post_info = db.query(SysPost).select_from(SysUser) \
- .filter(SysUser.del_flag == 0, SysUser.user_id == user_id) \
- .outerjoin(SysUserPost, SysUser.user_id == SysUserPost.user_id) \
- .join(SysPost, and_(SysUserPost.post_id == SysPost.post_id, SysPost.status == 0)) \
- .distinct().all()
- query_user_menu_info = db.query(SysMenu).select_from(SysUser) \
- .filter(SysUser.del_flag == 0, SysUser.user_id == user_id) \
- .outerjoin(SysUserRole, SysUser.user_id == SysUserRole.user_id) \
- .outerjoin(SysRole, and_(SysUserRole.role_id == SysRole.role_id, SysRole.status == 0, SysRole.del_flag == 0)) \
- .outerjoin(SysRoleMenu, SysRole.role_id == SysRoleMenu.role_id) \
- .join(SysMenu, and_(SysRoleMenu.menu_id == SysMenu.menu_id, SysMenu.status == 0)) \
- .distinct().all()
+ query_user_basic_info = (await db.execute(
+ select(SysUser)
+ .where(SysUser.del_flag == 0, SysUser.user_id == user_id)
+ .distinct()
+ )).scalars().first()
+ query_user_dept_info = (await db.execute(
+ select(SysDept)
+ .select_from(SysUser)
+ .where(SysUser.del_flag == 0, SysUser.user_id == user_id)
+ .join(SysDept, and_(SysUser.dept_id == SysDept.dept_id, SysDept.status == 0, SysDept.del_flag == 0))
+ .distinct()
+ )).scalars().first()
+ query_user_role_info = (await db.execute(
+ select(SysRole)
+ .select_from(SysUser)
+ .where(SysUser.del_flag == 0, SysUser.user_id == user_id)
+ .join(SysUserRole, SysUser.user_id == SysUserRole.user_id, isouter=True)
+ .join(SysRole, and_(SysUserRole.role_id == SysRole.role_id, SysRole.status == 0, SysRole.del_flag == 0))
+ .distinct()
+ )).scalars().all()
+ query_user_post_info = (await db.execute(
+ select(SysPost)
+ .select_from(SysUser)
+ .where(SysUser.del_flag == 0, SysUser.user_id == user_id)
+ .join(SysUserPost, SysUser.user_id == SysUserPost.user_id, isouter=True)
+ .join(SysPost, and_(SysUserPost.post_id == SysPost.post_id, SysPost.status == 0))
+ .distinct()
+ )).scalars().all()
+ query_user_menu_info = (await db.execute(
+ select(SysMenu)
+ .select_from(SysUser)
+ .where(SysUser.del_flag == 0, SysUser.user_id == user_id)
+ .join(SysUserRole, SysUser.user_id == SysUserRole.user_id, isouter=True)
+ .join(SysRole, and_(SysUserRole.role_id == SysRole.role_id, SysRole.status == 0, SysRole.del_flag == 0),
+ isouter=True)
+ .join(SysRoleMenu, SysRole.role_id == SysRoleMenu.role_id, isouter=True)
+ .join(SysMenu, and_(SysRoleMenu.menu_id == SysMenu.menu_id, SysMenu.status == 0))
+ .distinct()
+ )).scalars().all()
results = dict(
user_basic_info=query_user_basic_info,
user_dept_info=query_user_dept_info,
@@ -137,7 +175,8 @@ class UserDao:
return results
@classmethod
- def get_user_list(cls, db: Session, query_object: UserPageQueryModel, data_scope_sql: str, is_page: bool = False):
+ async def get_user_list(cls, db: AsyncSession, query_object: UserPageQueryModel, data_scope_sql: str,
+ is_page: bool = False):
"""
根据查询参数获取用户列表信息
:param db: orm对象
@@ -146,31 +185,32 @@ class UserDao:
:param is_page: 是否开启分页
:return: 用户列表信息对象
"""
- query = db.query(SysUser, SysDept) \
- .filter(SysUser.del_flag == 0,
- or_(SysUser.dept_id == query_object.dept_id, SysUser.dept_id.in_(
- db.query(SysDept.dept_id).filter(func.find_in_set(query_object.dept_id, SysDept.ancestors))
- )) if query_object.dept_id else True,
- SysUser.user_name.like(f'%{query_object.user_name}%') if query_object.user_name else True,
- SysUser.nick_name.like(f'%{query_object.nick_name}%') if query_object.nick_name else True,
- SysUser.email.like(f'%{query_object.email}%') if query_object.email else True,
- SysUser.phonenumber.like(f'%{query_object.phonenumber}%') if query_object.phonenumber else True,
- SysUser.status == query_object.status if query_object.status else True,
- SysUser.sex == query_object.sex if query_object.sex else True,
- SysUser.create_time.between(
- datetime.combine(datetime.strptime(query_object.begin_time, '%Y-%m-%d'), time(00, 00, 00)),
- datetime.combine(datetime.strptime(query_object.end_time, '%Y-%m-%d'), time(23, 59, 59)))
- if query_object.begin_time and query_object.end_time else True,
- eval(data_scope_sql)
- ) \
- .outerjoin(SysDept, and_(SysUser.dept_id == SysDept.dept_id, SysDept.status == 0, SysDept.del_flag == 0)) \
+ query = select(SysUser, SysDept) \
+ .where(SysUser.del_flag == 0,
+ or_(SysUser.dept_id == query_object.dept_id, SysUser.dept_id.in_(
+ select(SysDept.dept_id).where(func.find_in_set(query_object.dept_id, SysDept.ancestors))
+ )) if query_object.dept_id else True,
+ SysUser.user_name.like(f'%{query_object.user_name}%') if query_object.user_name else True,
+ SysUser.nick_name.like(f'%{query_object.nick_name}%') if query_object.nick_name else True,
+ SysUser.email.like(f'%{query_object.email}%') if query_object.email else True,
+ SysUser.phonenumber.like(f'%{query_object.phonenumber}%') if query_object.phonenumber else True,
+ SysUser.status == query_object.status if query_object.status else True,
+ SysUser.sex == query_object.sex if query_object.sex else True,
+ SysUser.create_time.between(
+ datetime.combine(datetime.strptime(query_object.begin_time, '%Y-%m-%d'), time(00, 00, 00)),
+ datetime.combine(datetime.strptime(query_object.end_time, '%Y-%m-%d'), time(23, 59, 59)))
+ if query_object.begin_time and query_object.end_time else True,
+ eval(data_scope_sql)
+ ) \
+ .join(SysDept, and_(SysUser.dept_id == SysDept.dept_id, SysDept.status == 0, SysDept.del_flag == 0),
+ isouter=True) \
.distinct()
- user_list = PageUtil.paginate(query, query_object.page_num, query_object.page_size, is_page)
+ user_list = await PageUtil.paginate(db, query, query_object.page_num, query_object.page_size, is_page)
return user_list
@classmethod
- def add_user_dao(cls, db: Session, user: UserModel):
+ async def add_user_dao(cls, db: AsyncSession, user: UserModel):
"""
新增用户数据库操作
:param db: orm对象
@@ -179,57 +219,62 @@ class UserDao:
"""
db_user = SysUser(**user.model_dump(exclude={'admin'}))
db.add(db_user)
- db.flush()
+ await db.flush()
return db_user
@classmethod
- def edit_user_dao(cls, db: Session, user: dict):
+ async def edit_user_dao(cls, db: AsyncSession, user: dict):
"""
编辑用户数据库操作
:param db: orm对象
:param user: 需要更新的用户字典
:return: 编辑校验结果
"""
- db.query(SysUser) \
- .filter(SysUser.user_id == user.get('user_id')) \
- .update(user)
+ await db.execute(
+ update(SysUser),
+ [user]
+ )
@classmethod
- def delete_user_dao(cls, db: Session, user: UserModel):
+ async def delete_user_dao(cls, db: AsyncSession, user: UserModel):
"""
删除用户数据库操作
:param db: orm对象
:param user: 用户对象
:return:
"""
- db.query(SysUser) \
- .filter(SysUser.user_id == user.user_id) \
- .update({SysUser.del_flag: '2', SysUser.update_by: user.update_by, SysUser.update_time: user.update_time})
+ await db.execute(
+ update(SysUser)
+ .where(SysUser.user_id == user.user_id)
+ .values(del_flag='2', update_by=user.update_by, update_time=user.update_time)
+ )
@classmethod
- def get_user_role_allocated_list_by_user_id(cls, db: Session, query_object: UserRoleQueryModel):
+ async def get_user_role_allocated_list_by_user_id(cls, db: AsyncSession, query_object: UserRoleQueryModel):
"""
根据用户id获取用户已分配的角色列表信息数据库操作
:param db: orm对象
:param query_object: 用户角色查询对象
:return: 用户已分配的角色列表信息
"""
- allocated_role_list = db.query(SysRole) \
- .filter(
- SysRole.del_flag == 0,
- SysRole.role_id != 1,
- SysRole.role_name == query_object.role_name if query_object.role_name else True,
- SysRole.role_key == query_object.role_key if query_object.role_key else True,
- SysRole.role_id.in_(
- db.query(SysUserRole.role_id).filter(SysUserRole.user_id == query_object.user_id)
- )
- ).distinct().all()
+ allocated_role_list = (await db.execute(
+ select(SysRole)
+ .where(SysRole.del_flag == 0,
+ SysRole.role_id != 1,
+ SysRole.role_name == query_object.role_name if query_object.role_name else True,
+ SysRole.role_key == query_object.role_key if query_object.role_key else True,
+ SysRole.role_id.in_(
+ select(SysUserRole.role_id).where(SysUserRole.user_id == query_object.user_id)
+ ))
+ .distinct()
+ )).scalars().all()
return allocated_role_list
@classmethod
- def get_user_role_allocated_list_by_role_id(cls, db: Session, query_object: UserRolePageQueryModel, is_page: bool = False):
+ async def get_user_role_allocated_list_by_role_id(cls, db: AsyncSession, query_object: UserRolePageQueryModel,
+ is_page: bool = False):
"""
根据角色id获取已分配的用户列表信息
:param db: orm对象
@@ -237,22 +282,22 @@ class UserDao:
:param is_page: 是否开启分页
:return: 角色已分配的用户列表信息
"""
- query = db.query(SysUser) \
- .filter(
- SysUser.del_flag == 0,
- SysUser.user_id != 1,
- SysUser.user_name == query_object.user_name if query_object.user_name else True,
- SysUser.phonenumber == query_object.phonenumber if query_object.phonenumber else True,
- SysUser.user_id.in_(
- db.query(SysUserRole.user_id).filter(SysUserRole.role_id == query_object.role_id)
- )
- ).distinct()
- allocated_user_list = PageUtil.paginate(query, query_object.page_num, query_object.page_size, is_page)
+ query = select(SysUser) \
+ .where(SysUser.del_flag == 0,
+ SysUser.user_id != 1,
+ SysUser.user_name == query_object.user_name if query_object.user_name else True,
+ SysUser.phonenumber == query_object.phonenumber if query_object.phonenumber else True,
+ SysUser.user_id.in_(
+ select(SysUserRole.user_id).where(SysUserRole.role_id == query_object.role_id)
+ )) \
+ .distinct()
+ allocated_user_list = await PageUtil.paginate(db, query, query_object.page_num, query_object.page_size, is_page)
return allocated_user_list
@classmethod
- def get_user_role_unallocated_list_by_role_id(cls, db: Session, query_object: UserRolePageQueryModel, is_page: bool = False):
+ async def get_user_role_unallocated_list_by_role_id(cls, db: AsyncSession, query_object: UserRolePageQueryModel,
+ is_page: bool = False):
"""
根据角色id获取未分配的用户列表信息
:param db: orm对象
@@ -260,22 +305,22 @@ class UserDao:
:param is_page: 是否开启分页
:return: 角色未分配的用户列表信息
"""
- query = db.query(SysUser) \
- .filter(
- SysUser.del_flag == 0,
- SysUser.user_id != 1,
- SysUser.user_name == query_object.user_name if query_object.user_name else True,
- SysUser.phonenumber == query_object.phonenumber if query_object.phonenumber else True,
- ~SysUser.user_id.in_(
- db.query(SysUserRole.user_id).filter(SysUserRole.role_id == query_object.role_id)
- )
- ).distinct()
- unallocated_user_list = PageUtil.paginate(query, query_object.page_num, query_object.page_size, is_page)
+ query = select(SysUser) \
+ .where(SysUser.del_flag == 0,
+ SysUser.user_id != 1,
+ SysUser.user_name == query_object.user_name if query_object.user_name else True,
+ SysUser.phonenumber == query_object.phonenumber if query_object.phonenumber else True,
+ ~SysUser.user_id.in_(
+ select(SysUserRole.user_id).where(SysUserRole.role_id == query_object.role_id)
+ )) \
+ .distinct()
+ unallocated_user_list = await PageUtil.paginate(db, query, query_object.page_num, query_object.page_size,
+ is_page)
return unallocated_user_list
@classmethod
- def add_user_role_dao(cls, db: Session, user_role: UserRoleModel):
+ async def add_user_role_dao(cls, db: AsyncSession, user_role: UserRoleModel):
"""
新增用户角色关联信息数据库操作
:param db: orm对象
@@ -286,46 +331,50 @@ class UserDao:
db.add(db_user_role)
@classmethod
- def delete_user_role_dao(cls, db: Session, user_role: UserRoleModel):
+ async def delete_user_role_dao(cls, db: AsyncSession, user_role: UserRoleModel):
"""
删除用户角色关联信息数据库操作
:param db: orm对象
:param user_role: 用户角色关联对象
:return:
"""
- db.query(SysUserRole) \
- .filter(SysUserRole.user_id == user_role.user_id) \
- .delete()
+ await db.execute(
+ delete(SysUserRole)
+ .where(SysUserRole.user_id.in_([user_role.user_id]))
+ )
@classmethod
- def delete_user_role_by_user_and_role_dao(cls, db: Session, user_role: UserRoleModel):
+ async def delete_user_role_by_user_and_role_dao(cls, db: AsyncSession, user_role: UserRoleModel):
"""
根据用户id及角色id删除用户角色关联信息数据库操作
:param db: orm对象
:param user_role: 用户角色关联对象
:return:
"""
- db.query(SysUserRole) \
- .filter(SysUserRole.user_id == user_role.user_id,
- SysUserRole.role_id == user_role.role_id if user_role.role_id else True) \
- .delete()
+ await db.execute(
+ delete(SysUserRole)
+ .where(SysUserRole.user_id.in_([user_role.user_id]),
+ SysUserRole.role_id == user_role.role_id if user_role.role_id else True)
+ )
@classmethod
- def get_user_role_detail(cls, db: Session, user_role: UserRoleModel):
+ async def get_user_role_detail(cls, db: AsyncSession, user_role: UserRoleModel):
"""
根据用户角色关联获取用户角色关联详细信息
:param db: orm对象
:param user_role: 用户角色关联对象
:return: 用户角色关联信息
"""
- user_role_info = db.query(SysUserRole) \
- .filter(SysUserRole.user_id == user_role.user_id, SysUserRole.role_id == user_role.role_id) \
- .distinct().first()
+ user_role_info = (await db.execute(
+ select(SysUserRole)
+ .where(SysUserRole.user_id == user_role.user_id, SysUserRole.role_id == user_role.role_id)
+ .distinct()
+ )).scalars().first()
return user_role_info
@classmethod
- def add_user_post_dao(cls, db: Session, user_post: UserPostModel):
+ async def add_user_post_dao(cls, db: AsyncSession, user_post: UserPostModel):
"""
新增用户岗位关联信息数据库操作
:param db: orm对象
@@ -336,22 +385,24 @@ class UserDao:
db.add(db_user_post)
@classmethod
- def delete_user_post_dao(cls, db: Session, user_post: UserPostModel):
+ async def delete_user_post_dao(cls, db: AsyncSession, user_post: UserPostModel):
"""
删除用户岗位关联信息数据库操作
:param db: orm对象
:param user_post: 用户岗位关联对象
:return:
"""
- db.query(SysUserPost) \
- .filter(SysUserPost.user_id == user_post.user_id) \
- .delete()
+ await db.execute(
+ delete(SysUserPost)
+ .where(SysUserPost.user_id.in_([user_post.user_id]))
+ )
@classmethod
- def get_user_dept_info(cls, db: Session, dept_id: int):
- dept_basic_info = db.query(SysDept) \
- .filter(SysDept.dept_id == dept_id,
- SysDept.status == 0,
- SysDept.del_flag == 0) \
- .first()
+ async def get_user_dept_info(cls, db: AsyncSession, dept_id: int):
+ dept_basic_info = (await db.execute(
+ select(SysDept)
+ .where(SysDept.dept_id == dept_id,
+ SysDept.status == 0,
+ SysDept.del_flag == 0)
+ )).scalars().first()
return dept_basic_info
diff --git a/ruoyi-fastapi-backend/module_admin/service/cache_service.py b/ruoyi-fastapi-backend/module_admin/service/cache_service.py
index d021ef4a8c491619074c3979824686c2dfb119fd..960b9cd498733ecc26d2e30b941b8ac740a1a452 100644
--- a/ruoyi-fastapi-backend/module_admin/service/cache_service.py
+++ b/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: 缓存名称列表信息
diff --git a/ruoyi-fastapi-backend/module_admin/service/captcha_service.py b/ruoyi-fastapi-backend/module_admin/service/captcha_service.py
index b685f0654992d91de41115dc243b8139f386f4aa..85b09123a6fb7c4e622a8f0c36ddf02e14e06929 100644
--- a/ruoyi-fastapi-backend/module_admin/service/captcha_service.py
+++ b/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')
diff --git a/ruoyi-fastapi-backend/module_admin/service/common_service.py b/ruoyi-fastapi-backend/module_admin/service/common_service.py
index 7c8399dbb58e4576f6d6852edb0aa9fb88db4e6b..883f18cf729263256b3449ee1b10f8b536ef39f4 100644
--- a/ruoyi-fastapi-backend/module_admin/service/common_service.py
+++ b/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: 下载的文件名称
diff --git a/ruoyi-fastapi-backend/module_admin/service/config_service.py b/ruoyi-fastapi-backend/module_admin/service/config_service.py
index 1ab439bf9a6682fe251557a0c5da0b9e5ce74b2a..e4700609b23c2d2c61312b9d97910f2a8ce60259 100644
--- a/ruoyi-fastapi-backend/module_admin/service/config_service.py
+++ b/ruoyi-fastapi-backend/module_admin/service/config_service.py
@@ -11,7 +11,7 @@ class ConfigService:
"""
@classmethod
- def get_config_list_services(cls, query_db: Session, query_object: ConfigPageQueryModel, is_page: bool = False):
+ async def get_config_list_services(cls, query_db: AsyncSession, query_object: ConfigPageQueryModel, is_page: bool = False):
"""
获取参数配置列表信息service
:param query_db: orm对象
@@ -19,12 +19,12 @@ class ConfigService:
:param is_page: 是否开启分页
:return: 参数配置列表信息对象
"""
- config_list_result = ConfigDao.get_config_list(query_db, query_object, is_page)
+ config_list_result = await ConfigDao.get_config_list(query_db, query_object, is_page)
return config_list_result
@classmethod
- async def init_cache_sys_config_services(cls, query_db: Session, redis):
+ async def init_cache_sys_config_services(cls, query_db: AsyncSession, redis):
"""
应用初始化：获取所有参数配置对应的键值对信息并缓存service
:param query_db: orm对象
@@ -36,7 +36,7 @@ class ConfigService:
# 删除匹配的键
if keys:
await redis.delete(*keys)
- config_all = ConfigDao.get_config_list(query_db, ConfigPageQueryModel(**dict()), is_page=False)
+ config_all = await ConfigDao.get_config_list(query_db, ConfigPageQueryModel(**dict()), is_page=False)
for config_obj in config_all:
if config_obj.get('configType') == 'Y':
await redis.set(f"{RedisInitKeyConfig.SYS_CONFIG.get('key')}:{config_obj.get('configKey')}", config_obj.get('configValue'))
@@ -54,7 +54,7 @@ class ConfigService:
return result
@classmethod
- async def add_config_services(cls, request: Request, query_db: Session, page_object: ConfigModel):
+ async def add_config_services(cls, request: Request, query_db: AsyncSession, page_object: ConfigModel):
"""
新增参数配置信息service
:param request: Request对象
@@ -62,23 +62,23 @@ class ConfigService:
:param page_object: 新增参数配置对象
:return: 新增参数配置校验结果
"""
- config = ConfigDao.get_config_detail_by_info(query_db, ConfigModel(configKey=page_object.config_key))
+ config = await ConfigDao.get_config_detail_by_info(query_db, ConfigModel(configKey=page_object.config_key))
if config:
result = dict(is_success=False, message='参数键名已存在')
else:
try:
- ConfigDao.add_config_dao(query_db, page_object)
- query_db.commit()
+ await ConfigDao.add_config_dao(query_db, page_object)
+ await query_db.commit()
await cls.init_cache_sys_config_services(query_db, request.app.state.redis)
result = dict(is_success=True, message='新增成功')
except Exception as e:
- query_db.rollback()
+ await query_db.rollback()
raise e
return CrudResponseModel(**result)
@classmethod
- async def edit_config_services(cls, request: Request, query_db: Session, page_object: ConfigModel):
+ async def edit_config_services(cls, request: Request, query_db: AsyncSession, page_object: ConfigModel):
"""
编辑参数配置信息service
:param request: Request对象
@@ -87,20 +87,20 @@ class ConfigService:
:return: 编辑参数配置校验结果
"""
edit_config = page_object.model_dump(exclude_unset=True)
- config_info = cls.config_detail_services(query_db, edit_config.get('config_id'))
+ config_info = await cls.config_detail_services(query_db, edit_config.get('config_id'))
if config_info:
if config_info.config_key != page_object.config_key or config_info.config_value != page_object.config_value:
- config = ConfigDao.get_config_detail_by_info(query_db, page_object)
+ config = await ConfigDao.get_config_detail_by_info(query_db, page_object)
if config:
result = dict(is_success=False, message='参数配置已存在')
return CrudResponseModel(**result)
try:
- ConfigDao.edit_config_dao(query_db, edit_config)
- query_db.commit()
+ await ConfigDao.edit_config_dao(query_db, edit_config)
+ await query_db.commit()
await cls.init_cache_sys_config_services(query_db, request.app.state.redis)
result = dict(is_success=True, message='更新成功')
except Exception as e:
- query_db.rollback()
+ await query_db.rollback()
raise e
else:
result = dict(is_success=False, message='参数配置不存在')
@@ -108,7 +108,7 @@ class ConfigService:
return CrudResponseModel(**result)
@classmethod
- async def delete_config_services(cls, request: Request, query_db: Session, page_object: DeleteConfigModel):
+ async def delete_config_services(cls, request: Request, query_db: AsyncSession, page_object: DeleteConfigModel):
"""
删除参数配置信息service
:param request: Request对象
@@ -120,32 +120,32 @@ class ConfigService:
config_id_list = page_object.config_ids.split(',')
try:
for config_id in config_id_list:
- ConfigDao.delete_config_dao(query_db, ConfigModel(configId=config_id))
- query_db.commit()
+ await ConfigDao.delete_config_dao(query_db, ConfigModel(configId=config_id))
+ await query_db.commit()
await cls.init_cache_sys_config_services(query_db, request.app.state.redis)
result = dict(is_success=True, message='删除成功')
except Exception as e:
- query_db.rollback()
+ await query_db.rollback()
raise e
else:
result = dict(is_success=False, message='传入字典数据id为空')
return CrudResponseModel(**result)
@classmethod
- def config_detail_services(cls, query_db: Session, config_id: int):
+ async def config_detail_services(cls, query_db: AsyncSession, config_id: int):
"""
获取参数配置详细信息service
:param query_db: orm对象
:param config_id: 参数配置id
:return: 参数配置id对应的信息
"""
- config = ConfigDao.get_config_detail_by_id(query_db, config_id=config_id)
+ config = await ConfigDao.get_config_detail_by_id(query_db, config_id=config_id)
result = ConfigModel(**CamelCaseUtil.transform_result(config))
return result
@staticmethod
- def export_config_list_services(config_list: List):
+ async def export_config_list_services(config_list: List):
"""
导出参数配置信息service
:param config_list: 参数配置信息列表
@@ -178,7 +178,7 @@ class ConfigService:
return binary_data
@classmethod
- async def refresh_sys_config_services(cls, request: Request, query_db: Session):
+ async def refresh_sys_config_services(cls, request: Request, query_db: AsyncSession):
"""
刷新字典缓存信息service
:param request: Request对象
diff --git a/ruoyi-fastapi-backend/module_admin/service/dept_service.py b/ruoyi-fastapi-backend/module_admin/service/dept_service.py
index 2c9db676697f9302eef9d60a5268715b9bf40e7f..5d67412c97c38d17fea224000a32359c3ed6da16 100644
--- a/ruoyi-fastapi-backend/module_admin/service/dept_service.py
+++ b/ruoyi-fastapi-backend/module_admin/service/dept_service.py
@@ -9,7 +9,7 @@ class DeptService:
"""
@classmethod
- def get_dept_tree_services(cls, query_db: Session, page_object: DeptModel, data_scope_sql: str):
+ async def get_dept_tree_services(cls, query_db: AsyncSession, page_object: DeptModel, data_scope_sql: str):
"""
获取部门树信息service
:param query_db: orm对象
@@ -17,13 +17,14 @@ class DeptService:
:param data_scope_sql: 数据权限对应的查询sql语句
:return: 部门树信息对象
"""
- dept_list_result = DeptDao.get_dept_list_for_tree(query_db, page_object, data_scope_sql)
+ dept_list_result = await DeptDao.get_dept_list_for_tree(query_db, page_object, data_scope_sql)
dept_tree_result = cls.list_to_tree(dept_list_result)
return dept_tree_result
@classmethod
- def get_dept_for_edit_option_services(cls, query_db: Session, page_object: DeptModel, data_scope_sql: str):
+ async def get_dept_for_edit_option_services(cls, query_db: AsyncSession, page_object: DeptModel,
+ data_scope_sql: str):
"""
获取部门编辑部门树信息service
:param query_db: orm对象
@@ -31,12 +32,12 @@ class DeptService:
:param data_scope_sql: 数据权限对应的查询sql语句
:return: 部门树信息对象
"""
- dept_list_result = DeptDao.get_dept_info_for_edit_option(query_db, page_object, data_scope_sql)
+ dept_list_result = await DeptDao.get_dept_info_for_edit_option(query_db, page_object, data_scope_sql)
return CamelCaseUtil.transform_result(dept_list_result)
@classmethod
- def get_dept_list_services(cls, query_db: Session, page_object: DeptModel, data_scope_sql: str):
+ async def get_dept_list_services(cls, query_db: AsyncSession, page_object: DeptModel, data_scope_sql: str):
"""
获取部门列表信息service
:param query_db: orm对象
@@ -44,72 +45,72 @@ class DeptService:
:param data_scope_sql: 数据权限对应的查询sql语句
:return: 部门列表信息对象
"""
- dept_list_result = DeptDao.get_dept_list(query_db, page_object, data_scope_sql)
+ dept_list_result = await DeptDao.get_dept_list(query_db, page_object, data_scope_sql)
return CamelCaseUtil.transform_result(dept_list_result)
@classmethod
- def add_dept_services(cls, query_db: Session, page_object: DeptModel):
+ async def add_dept_services(cls, query_db: AsyncSession, page_object: DeptModel):
"""
新增部门信息service
:param query_db: orm对象
:param page_object: 新增部门对象
:return: 新增部门校验结果
"""
- parent_info = DeptDao.get_dept_by_id(query_db, page_object.parent_id)
+ parent_info = await DeptDao.get_dept_by_id(query_db, page_object.parent_id)
if parent_info:
page_object.ancestors = f'{parent_info.ancestors},{page_object.parent_id}'
else:
page_object.ancestors = '0'
- dept = DeptDao.get_dept_detail_by_info(query_db, DeptModel(parentId=page_object.parent_id,
- deptName=page_object.dept_name))
+ dept = await DeptDao.get_dept_detail_by_info(query_db, DeptModel(parentId=page_object.parent_id,
+ deptName=page_object.dept_name))
if dept:
result = dict(is_success=False, message='同一部门下不允许存在同名的部门')
else:
try:
- DeptDao.add_dept_dao(query_db, page_object)
- query_db.commit()
+ await DeptDao.add_dept_dao(query_db, page_object)
+ await query_db.commit()
result = dict(is_success=True, message='新增成功')
except Exception as e:
- query_db.rollback()
+ await query_db.rollback()
raise e
return CrudResponseModel(**result)
@classmethod
- def edit_dept_services(cls, query_db: Session, page_object: DeptModel):
+ async def edit_dept_services(cls, query_db: AsyncSession, page_object: DeptModel):
"""
编辑部门信息service
:param query_db: orm对象
:param page_object: 编辑部门对象
:return: 编辑部门校验结果
"""
- parent_info = DeptDao.get_dept_by_id(query_db, page_object.parent_id)
+ parent_info = await DeptDao.get_dept_by_id(query_db, page_object.parent_id)
if parent_info:
page_object.ancestors = f'{parent_info.ancestors},{page_object.parent_id}'
else:
page_object.ancestors = '0'
edit_dept = page_object.model_dump(exclude_unset=True)
- dept_info = cls.dept_detail_services(query_db, edit_dept.get('dept_id'))
+ dept_info = await cls.dept_detail_services(query_db, edit_dept.get('dept_id'))
if dept_info:
if dept_info.parent_id != page_object.parent_id or dept_info.dept_name != page_object.dept_name:
- dept = DeptDao.get_dept_detail_by_info(query_db, DeptModel(parentId=page_object.parent_id,
- deptName=page_object.dept_name))
+ dept = await DeptDao.get_dept_detail_by_info(query_db, DeptModel(parentId=page_object.parent_id,
+ deptName=page_object.dept_name))
if dept:
result = dict(is_success=False, message='同一部门下不允许存在同名的部门')
return CrudResponseModel(**result)
try:
- DeptDao.edit_dept_dao(query_db, edit_dept)
- cls.update_children_info(query_db, DeptModel(deptId=page_object.dept_id,
- ancestors=page_object.ancestors,
- updateBy=page_object.update_by,
- updateTime=page_object.update_time
- )
- )
- query_db.commit()
+ await DeptDao.edit_dept_dao(query_db, edit_dept)
+ await cls.update_children_info(query_db, DeptModel(deptId=page_object.dept_id,
+ ancestors=page_object.ancestors,
+ updateBy=page_object.update_by,
+ updateTime=page_object.update_time
+ )
+ )
+ await query_db.commit()
result = dict(is_success=True, message='更新成功')
except Exception as e:
- query_db.rollback()
+ await query_db.rollback()
raise e
else:
result = dict(is_success=False, message='部门不存在')
@@ -117,7 +118,7 @@ class DeptService:
return CrudResponseModel(**result)
@classmethod
- def delete_dept_services(cls, query_db: Session, page_object: DeleteDeptModel):
+ async def delete_dept_services(cls, query_db: AsyncSession, page_object: DeleteDeptModel):
"""
删除部门信息service
:param query_db: orm对象
@@ -126,7 +127,7 @@ class DeptService:
"""
if page_object.dept_ids.split(','):
dept_id_list = page_object.dept_ids.split(',')
- ancestors = DeptDao.get_dept_all_ancestors(query_db)
+ ancestors = await DeptDao.get_dept_all_ancestors(query_db)
try:
for dept_id in dept_id_list:
for ancestor in ancestors:
@@ -135,25 +136,25 @@ class DeptService:
return CrudResponseModel(**result)
- DeptDao.delete_dept_dao(query_db, DeptModel(deptId=dept_id))
- query_db.commit()
+ await DeptDao.delete_dept_dao(query_db, DeptModel(deptId=dept_id))
+ await query_db.commit()
result = dict(is_success=True, message='删除成功')
except Exception as e:
- query_db.rollback()
+ await query_db.rollback()
raise e
else:
result = dict(is_success=False, message='传入部门id为空')
return CrudResponseModel(**result)
@classmethod
- def dept_detail_services(cls, query_db: Session, dept_id: int):
+ async def dept_detail_services(cls, query_db: AsyncSession, dept_id: int):
"""
获取部门详细信息service
:param query_db: orm对象
:param dept_id: 部门id
:return: 部门id对应的信息
"""
- dept = DeptDao.get_dept_detail_by_id(query_db, dept_id=dept_id)
+ dept = await DeptDao.get_dept_detail_by_id(query_db, dept_id=dept_id)
result = DeptModel(**CamelCaseUtil.transform_result(dept))
return result
@@ -188,26 +189,26 @@ class DeptService:
return container
@classmethod
- def update_children_info(cls, query_db, page_object):
+ async def update_children_info(cls, query_db, page_object):
"""
工具方法：递归更新子部门信息
:param query_db: orm对象
:param page_object: 编辑部门对象
:return:
"""
- children_info = DeptDao.get_children_dept(query_db, page_object.dept_id)
+ children_info = await DeptDao.get_children_dept(query_db, page_object.dept_id)
if children_info:
for child in children_info:
child.ancestors = f'{page_object.ancestors},{page_object.dept_id}'
- DeptDao.edit_dept_dao(query_db,
- dict(dept_id=child.dept_id,
- ancestors=child.ancestors,
- update_by=page_object.update_by,
- update_time=page_object.update_time
- )
- )
- cls.update_children_info(query_db, DeptModel(dept_id=child.dept_id,
- ancestors=child.ancestors,
- update_by=page_object.update_by,
- update_time=page_object.update_time
- ))
+ await DeptDao.edit_dept_dao(query_db,
+ dict(dept_id=child.dept_id,
+ ancestors=child.ancestors,
+ update_by=page_object.update_by,
+ update_time=page_object.update_time
+ )
+ )
+ await cls.update_children_info(query_db, DeptModel(dept_id=child.dept_id,
+ ancestors=child.ancestors,
+ update_by=page_object.update_by,
+ update_time=page_object.update_time
+ ))
diff --git a/ruoyi-fastapi-backend/module_admin/service/dict_service.py b/ruoyi-fastapi-backend/module_admin/service/dict_service.py
index 29dae05ddea257052891c19fe167f3230769ff63..efcd3b7dc42d0459147352704114ecd9017eb8b3 100644
--- a/ruoyi-fastapi-backend/module_admin/service/dict_service.py
+++ b/ruoyi-fastapi-backend/module_admin/service/dict_service.py
@@ -12,7 +12,7 @@ class DictTypeService:
"""
@classmethod
- def get_dict_type_list_services(cls, query_db: Session, query_object: DictTypePageQueryModel, is_page: bool = False):
+ async def get_dict_type_list_services(cls, query_db: AsyncSession, query_object: DictTypePageQueryModel, is_page: bool = False):
"""
获取字典类型列表信息service
:param query_db: orm对象
@@ -20,12 +20,12 @@ class DictTypeService:
:param is_page: 是否开启分页
:return: 字典类型列表信息对象
"""
- dict_type_list_result = DictTypeDao.get_dict_type_list(query_db, query_object, is_page)
+ dict_type_list_result = await DictTypeDao.get_dict_type_list(query_db, query_object, is_page)
return dict_type_list_result
@classmethod
- async def add_dict_type_services(cls, request: Request, query_db: Session, page_object: DictTypeModel):
+ async def add_dict_type_services(cls, request: Request, query_db: AsyncSession, page_object: DictTypeModel):
"""
新增字典类型信息service
:param request: Request对象
@@ -33,23 +33,23 @@ class DictTypeService:
:param page_object: 新增岗位对象
:return: 新增字典类型校验结果
"""
- dict_type = DictTypeDao.get_dict_type_detail_by_info(query_db, DictTypeModel(dictType=page_object.dict_type))
+ dict_type = await DictTypeDao.get_dict_type_detail_by_info(query_db, DictTypeModel(dictType=page_object.dict_type))
if dict_type:
result = dict(is_success=False, message='字典类型已存在')
else:
try:
- DictTypeDao.add_dict_type_dao(query_db, page_object)
- query_db.commit()
+ await DictTypeDao.add_dict_type_dao(query_db, page_object)
+ await query_db.commit()
await DictDataService.init_cache_sys_dict_services(query_db, request.app.state.redis)
result = dict(is_success=True, message='新增成功')
except Exception as e:
- query_db.rollback()
+ await query_db.rollback()
raise e
return CrudResponseModel(**result)
@classmethod
- async def edit_dict_type_services(cls, request: Request, query_db: Session, page_object: DictTypeModel):
+ async def edit_dict_type_services(cls, request: Request, query_db: AsyncSession, page_object: DictTypeModel):
"""
编辑字典类型信息service
:param request: Request对象
@@ -58,26 +58,26 @@ class DictTypeService:
:return: 编辑字典类型校验结果
"""
edit_dict_type = page_object.model_dump(exclude_unset=True)
- dict_type_info = cls.dict_type_detail_services(query_db, edit_dict_type.get('dict_id'))
+ dict_type_info = await cls.dict_type_detail_services(query_db, edit_dict_type.get('dict_id'))
if dict_type_info:
if dict_type_info.dict_type != page_object.dict_type or dict_type_info.dict_name != page_object.dict_name:
- dict_type = DictTypeDao.get_dict_type_detail_by_info(query_db, DictTypeModel(dictType=page_object.dict_type))
+ dict_type = await DictTypeDao.get_dict_type_detail_by_info(query_db, DictTypeModel(dictType=page_object.dict_type))
if dict_type:
result = dict(is_success=False, message='字典类型已存在')
return CrudResponseModel(**result)
try:
if dict_type_info.dict_type != page_object.dict_type:
- query_dict_data = DictDataModel(dictType=dict_type_info.dict_type)
- dict_data_list = DictDataDao.get_dict_data_list(query_db, query_dict_data)
+ query_dict_data = await DictDataModel(dictType=dict_type_info.dict_type)
+ dict_data_list = await DictDataDao.get_dict_data_list(query_db, query_dict_data)
for dict_data in dict_data_list:
edit_dict_data = DictDataModel(dictCode=dict_data.dict_code, dictType=page_object.dict_type, updateBy=page_object.update_by).model_dump(exclude_unset=True)
- DictDataDao.edit_dict_data_dao(query_db, edit_dict_data)
- DictTypeDao.edit_dict_type_dao(query_db, edit_dict_type)
- query_db.commit()
+ await DictDataDao.edit_dict_data_dao(query_db, edit_dict_data)
+ await DictTypeDao.edit_dict_type_dao(query_db, edit_dict_type)
+ await query_db.commit()
await DictDataService.init_cache_sys_dict_services(query_db, request.app.state.redis)
result = dict(is_success=True, message='更新成功')
except Exception as e:
- query_db.rollback()
+ await query_db.rollback()
raise e
else:
result = dict(is_success=False, message='字典类型不存在')
@@ -85,7 +85,7 @@ class DictTypeService:
return CrudResponseModel(**result)
@classmethod
- async def delete_dict_type_services(cls, request: Request, query_db: Session, page_object: DeleteDictTypeModel):
+ async def delete_dict_type_services(cls, request: Request, query_db: AsyncSession, page_object: DeleteDictTypeModel):
"""
删除字典类型信息service
:param request: Request对象
@@ -97,32 +97,32 @@ class DictTypeService:
dict_id_list = page_object.dict_ids.split(',')
try:
for dict_id in dict_id_list:
- DictTypeDao.delete_dict_type_dao(query_db, DictTypeModel(dictId=dict_id))
- query_db.commit()
+ await DictTypeDao.delete_dict_type_dao(query_db, DictTypeModel(dictId=dict_id))
+ await query_db.commit()
await DictDataService.init_cache_sys_dict_services(query_db, request.app.state.redis)
result = dict(is_success=True, message='删除成功')
except Exception as e:
- query_db.rollback()
+ await query_db.rollback()
raise e
else:
result = dict(is_success=False, message='传入字典类型id为空')
return CrudResponseModel(**result)
@classmethod
- def dict_type_detail_services(cls, query_db: Session, dict_id: int):
+ async def dict_type_detail_services(cls, query_db: AsyncSession, dict_id: int):
"""
获取字典类型详细信息service
:param query_db: orm对象
:param dict_id: 字典类型id
:return: 字典类型id对应的信息
"""
- dict_type = DictTypeDao.get_dict_type_detail_by_id(query_db, dict_id=dict_id)
+ dict_type = await DictTypeDao.get_dict_type_detail_by_id(query_db, dict_id=dict_id)
result = DictTypeModel(**CamelCaseUtil.transform_result(dict_type))
return result
@staticmethod
- def export_dict_type_list_services(dict_type_list: List):
+ async def export_dict_type_list_services(dict_type_list: List):
"""
导出字典类型信息service
:param dict_type_list: 字典信息列表
@@ -154,7 +154,7 @@ class DictTypeService:
return binary_data
@classmethod
- async def refresh_sys_dict_services(cls, request: Request, query_db: Session):
+ async def refresh_sys_dict_services(cls, request: Request, query_db: AsyncSession):
"""
刷新字典缓存信息service
:param request: Request对象
@@ -173,7 +173,7 @@ class DictDataService:
"""
@classmethod
- def get_dict_data_list_services(cls, query_db: Session, query_object: DictDataPageQueryModel, is_page: bool = False):
+ async def get_dict_data_list_services(cls, query_db: AsyncSession, query_object: DictDataPageQueryModel, is_page: bool = False):
"""
获取字典数据列表信息service
:param query_db: orm对象
@@ -181,24 +181,24 @@ class DictDataService:
:param is_page: 是否开启分页
:return: 字典数据列表信息对象
"""
- dict_data_list_result = DictDataDao.get_dict_data_list(query_db, query_object, is_page)
+ dict_data_list_result = await DictDataDao.get_dict_data_list(query_db, query_object, is_page)
return dict_data_list_result
@classmethod
- def query_dict_data_list_services(cls, query_db: Session, dict_type: str):
+ async def query_dict_data_list_services(cls, query_db: AsyncSession, dict_type: str):
"""
获取字典数据列表信息service
:param query_db: orm对象
:param dict_type: 字典类型
:return: 字典数据列表信息对象
"""
- dict_data_list_result = DictDataDao.query_dict_data_list(query_db, dict_type)
+ dict_data_list_result = await DictDataDao.query_dict_data_list(query_db, dict_type)
return dict_data_list_result
@classmethod
- async def init_cache_sys_dict_services(cls, query_db: Session, redis):
+ async def init_cache_sys_dict_services(cls, query_db: AsyncSession, redis):
"""
应用初始化：获取所有字典类型对应的字典数据信息并缓存service
:param query_db: orm对象
@@ -210,10 +210,10 @@ class DictDataService:
# 删除匹配的键
if keys:
await redis.delete(*keys)
- dict_type_all = DictTypeDao.get_all_dict_type(query_db)
+ dict_type_all = await DictTypeDao.get_all_dict_type(query_db)
for dict_type_obj in [item for item in dict_type_all if item.status == '0']:
dict_type = dict_type_obj.dict_type
- dict_data_list = DictDataDao.query_dict_data_list(query_db, dict_type)
+ dict_data_list = await DictDataDao.query_dict_data_list(query_db, dict_type)
dict_data = [CamelCaseUtil.transform_result(row) for row in dict_data_list if row]
await redis.set(f"{RedisInitKeyConfig.SYS_DICT.get('key')}:{dict_type}", json.dumps(dict_data, ensure_ascii=False, default=str))
@@ -233,7 +233,7 @@ class DictDataService:
return CamelCaseUtil.transform_result(result)
@classmethod
- async def add_dict_data_services(cls, request: Request, query_db: Session, page_object: DictDataModel):
+ async def add_dict_data_services(cls, request: Request, query_db: AsyncSession, page_object: DictDataModel):
"""
新增字典数据信息service
:param request: Request对象
@@ -241,23 +241,23 @@ class DictDataService:
:param page_object: 新增岗位对象
:return: 新增字典数据校验结果
"""
- dict_data = DictDataDao.get_dict_data_detail_by_info(query_db, page_object)
+ dict_data = await DictDataDao.get_dict_data_detail_by_info(query_db, page_object)
if dict_data:
result = dict(is_success=False, message='字典数据已存在')
else:
try:
- DictDataDao.add_dict_data_dao(query_db, page_object)
- query_db.commit()
+ await DictDataDao.add_dict_data_dao(query_db, page_object)
+ await query_db.commit()
await cls.init_cache_sys_dict_services(query_db, request.app.state.redis)
result = dict(is_success=True, message='新增成功')
except Exception as e:
- query_db.rollback()
+ await query_db.rollback()
raise e
return CrudResponseModel(**result)
@classmethod
- async def edit_dict_data_services(cls, request: Request, query_db: Session, page_object: DictDataModel):
+ async def edit_dict_data_services(cls, request: Request, query_db: AsyncSession, page_object: DictDataModel):
"""
编辑字典数据信息service
:param request: Request对象
@@ -266,20 +266,20 @@ class DictDataService:
:return: 编辑字典数据校验结果
"""
edit_data_type = page_object.model_dump(exclude_unset=True)
- dict_data_info = cls.dict_data_detail_services(query_db, edit_data_type.get('dict_code'))
+ dict_data_info = await cls.dict_data_detail_services(query_db, edit_data_type.get('dict_code'))
if dict_data_info:
if dict_data_info.dict_type != page_object.dict_type or dict_data_info.dict_label != page_object.dict_label or dict_data_info.dict_value != page_object.dict_value:
- dict_data = DictDataDao.get_dict_data_detail_by_info(query_db, page_object)
+ dict_data = await DictDataDao.get_dict_data_detail_by_info(query_db, page_object)
if dict_data:
result = dict(is_success=False, message='字典数据已存在')
return CrudResponseModel(**result)
try:
- DictDataDao.edit_dict_data_dao(query_db, edit_data_type)
- query_db.commit()
+ await DictDataDao.edit_dict_data_dao(query_db, edit_data_type)
+ await query_db.commit()
await cls.init_cache_sys_dict_services(query_db, request.app.state.redis)
result = dict(is_success=True, message='更新成功')
except Exception as e:
- query_db.rollback()
+ await query_db.rollback()
raise e
else:
result = dict(is_success=False, message='字典数据不存在')
@@ -287,7 +287,7 @@ class DictDataService:
return CrudResponseModel(**result)
@classmethod
- async def delete_dict_data_services(cls, request: Request, query_db: Session, page_object: DeleteDictDataModel):
+ async def delete_dict_data_services(cls, request: Request, query_db: AsyncSession, page_object: DeleteDictDataModel):
"""
删除字典数据信息service
:param request: Request对象
@@ -299,32 +299,32 @@ class DictDataService:
dict_code_list = page_object.dict_codes.split(',')
try:
for dict_code in dict_code_list:
- DictDataDao.delete_dict_data_dao(query_db, DictDataModel(dictCode=dict_code))
- query_db.commit()
+ await DictDataDao.delete_dict_data_dao(query_db, DictDataModel(dictCode=dict_code))
+ await query_db.commit()
await cls.init_cache_sys_dict_services(query_db, request.app.state.redis)
result = dict(is_success=True, message='删除成功')
except Exception as e:
- query_db.rollback()
+ await query_db.rollback()
raise e
else:
result = dict(is_success=False, message='传入字典数据id为空')
return CrudResponseModel(**result)
@classmethod
- def dict_data_detail_services(cls, query_db: Session, dict_code: int):
+ async def dict_data_detail_services(cls, query_db: AsyncSession, dict_code: int):
"""
获取字典数据详细信息service
:param query_db: orm对象
:param dict_code: 字典数据id
:return: 字典数据id对应的信息
"""
- dict_data = DictDataDao.get_dict_data_detail_by_id(query_db, dict_code=dict_code)
+ dict_data = await DictDataDao.get_dict_data_detail_by_id(query_db, dict_code=dict_code)
result = DictDataModel(**CamelCaseUtil.transform_result(dict_data))
return result
@staticmethod
- def export_dict_data_list_services(dict_data_list: List):
+ async def export_dict_data_list_services(dict_data_list: List):
"""
导出字典数据信息service
:param dict_data_list: 字典数据信息列表
diff --git a/ruoyi-fastapi-backend/module_admin/service/job_log_service.py b/ruoyi-fastapi-backend/module_admin/service/job_log_service.py
index 7de9d05b55dd4febc91e969f5e3a0395487cf9c9..99d22318f3dc1bb683fbe87574b613a399f6aee1 100644
--- a/ruoyi-fastapi-backend/module_admin/service/job_log_service.py
+++ b/ruoyi-fastapi-backend/module_admin/service/job_log_service.py
@@ -10,7 +10,7 @@ class JobLogService:
"""
@classmethod
- def get_job_log_list_services(cls, query_db: Session, query_object: JobLogPageQueryModel, is_page: bool = False):
+ async def get_job_log_list_services(cls, query_db: AsyncSession, query_object: JobLogPageQueryModel, is_page: bool = False):
"""
获取定时任务日志列表信息service
:param query_db: orm对象
@@ -18,7 +18,7 @@ class JobLogService:
:param is_page: 是否开启分页
:return: 定时任务日志列表信息对象
"""
- job_log_list_result = JobLogDao.get_job_log_list(query_db, query_object, is_page)
+ job_log_list_result = await JobLogDao.get_job_log_list(query_db, query_object, is_page)
return job_log_list_result
@@ -41,7 +41,7 @@ class JobLogService:
return CrudResponseModel(**result)
@classmethod
- def delete_job_log_services(cls, query_db: Session, page_object: DeleteJobLogModel):
+ async def delete_job_log_services(cls, query_db: AsyncSession, page_object: DeleteJobLogModel):
"""
删除定时任务日志信息service
:param query_db: orm对象
@@ -52,29 +52,29 @@ class JobLogService:
job_log_id_list = page_object.job_log_ids.split(',')
try:
for job_log_id in job_log_id_list:
- JobLogDao.delete_job_log_dao(query_db, JobLogModel(jobLogId=job_log_id))
- query_db.commit()
+ await JobLogDao.delete_job_log_dao(query_db, JobLogModel(jobLogId=job_log_id))
+ await query_db.commit()
result = dict(is_success=True, message='删除成功')
except Exception as e:
- query_db.rollback()
+ await query_db.rollback()
raise e
else:
result = dict(is_success=False, message='传入定时任务日志id为空')
return CrudResponseModel(**result)
@classmethod
- def clear_job_log_services(cls, query_db: Session):
+ async def clear_job_log_services(cls, query_db: AsyncSession):
"""
清除定时任务日志信息service
:param query_db: orm对象
:return: 清除定时任务日志校验结果
"""
try:
- JobLogDao.clear_job_log_dao(query_db)
- query_db.commit()
+ await JobLogDao.clear_job_log_dao(query_db)
+ await query_db.commit()
result = dict(is_success=True, message='清除成功')
except Exception as e:
- query_db.rollback()
+ await query_db.rollback()
raise e
return CrudResponseModel(**result)
diff --git a/ruoyi-fastapi-backend/module_admin/service/job_service.py b/ruoyi-fastapi-backend/module_admin/service/job_service.py
index b2e2dccc6884c531cd05fc5f23cf159e59955658..ca3de4d449ca6b9dd8e08eaf0c4b399ce3d396fb 100644
--- a/ruoyi-fastapi-backend/module_admin/service/job_service.py
+++ b/ruoyi-fastapi-backend/module_admin/service/job_service.py
@@ -11,7 +11,7 @@ class JobService:
"""
@classmethod
- def get_job_list_services(cls, query_db: Session, query_object: JobPageQueryModel, is_page: bool = False):
+ async def get_job_list_services(cls, query_db: AsyncSession, query_object: JobPageQueryModel, is_page: bool = False):
"""
获取定时任务列表信息service
:param query_db: orm对象
@@ -19,37 +19,37 @@ class JobService:
:param is_page: 是否开启分页
:return: 定时任务列表信息对象
"""
- job_list_result = JobDao.get_job_list(query_db, query_object, is_page)
+ job_list_result = await JobDao.get_job_list(query_db, query_object, is_page)
return job_list_result
@classmethod
- def add_job_services(cls, query_db: Session, page_object: JobModel):
+ async def add_job_services(cls, query_db: AsyncSession, page_object: JobModel):
"""
新增定时任务信息service
:param query_db: orm对象
:param page_object: 新增定时任务对象
:return: 新增定时任务校验结果
"""
- job = JobDao.get_job_detail_by_info(query_db, page_object)
+ job = await JobDao.get_job_detail_by_info(query_db, page_object)
if job:
result = dict(is_success=False, message='定时任务已存在')
else:
try:
- JobDao.add_job_dao(query_db, page_object)
- job_info = JobDao.get_job_detail_by_info(query_db, page_object)
+ await JobDao.add_job_dao(query_db, page_object)
+ job_info = await JobDao.get_job_detail_by_info(query_db, page_object)
if job_info.status == '0':
SchedulerUtil.add_scheduler_job(job_info=job_info)
- query_db.commit()
+ await query_db.commit()
result = dict(is_success=True, message='新增成功')
except Exception as e:
- query_db.rollback()
+ await query_db.rollback()
raise e
return CrudResponseModel(**result)
@classmethod
- def edit_job_services(cls, query_db: Session, page_object: EditJobModel):
+ async def edit_job_services(cls, query_db: AsyncSession, page_object: EditJobModel):
"""
编辑定时任务信息service
:param query_db: orm对象
@@ -59,25 +59,25 @@ class JobService:
edit_job = page_object.model_dump(exclude_unset=True)
if page_object.type == 'status':
del edit_job['type']
- job_info = cls.job_detail_services(query_db, edit_job.get('job_id'))
+ job_info = await cls.job_detail_services(query_db, edit_job.get('job_id'))
if job_info:
if page_object.type != 'status' and (job_info.job_name != page_object.job_name or job_info.job_group != page_object.job_group or job_info.invoke_target != page_object.invoke_target or job_info.cron_expression != page_object.cron_expression):
- job = JobDao.get_job_detail_by_info(query_db, page_object)
+ job = await JobDao.get_job_detail_by_info(query_db, page_object)
if job:
result = dict(is_success=False, message='定时任务已存在')
return CrudResponseModel(**result)
try:
- JobDao.edit_job_dao(query_db, edit_job)
+ await JobDao.edit_job_dao(query_db, edit_job)
query_job = SchedulerUtil.get_scheduler_job(job_id=edit_job.get('job_id'))
if query_job:
SchedulerUtil.remove_scheduler_job(job_id=edit_job.get('job_id'))
if edit_job.get('status') == '0':
- job_info = cls.job_detail_services(query_db, edit_job.get('job_id'))
+ job_info = await cls.job_detail_services(query_db, edit_job.get('job_id'))
SchedulerUtil.add_scheduler_job(job_info=job_info)
- query_db.commit()
+ await query_db.commit()
result = dict(is_success=True, message='更新成功')
except Exception as e:
- query_db.rollback()
+ await query_db.rollback()
raise e
else:
result = dict(is_success=False, message='定时任务不存在')
@@ -85,7 +85,7 @@ class JobService:
return CrudResponseModel(**result)
@classmethod
- def execute_job_once_services(cls, query_db: Session, page_object: JobModel):
+ async def execute_job_once_services(cls, query_db: AsyncSession, page_object: JobModel):
"""
执行一次定时任务service
:param query_db: orm对象
@@ -95,7 +95,7 @@ class JobService:
query_job = SchedulerUtil.get_scheduler_job(job_id=page_object.job_id)
if query_job:
SchedulerUtil.remove_scheduler_job(job_id=page_object.job_id)
- job_info = cls.job_detail_services(query_db, page_object.job_id)
+ job_info = await cls.job_detail_services(query_db, page_object.job_id)
if job_info:
SchedulerUtil.execute_scheduler_job_once(job_info=job_info)
result = dict(is_success=True, message='执行成功')
@@ -105,7 +105,7 @@ class JobService:
return CrudResponseModel(**result)
@classmethod
- def delete_job_services(cls, query_db: Session, page_object: DeleteJobModel):
+ async def delete_job_services(cls, query_db: AsyncSession, page_object: DeleteJobModel):
"""
删除定时任务信息service
:param query_db: orm对象
@@ -116,25 +116,25 @@ class JobService:
job_id_list = page_object.job_ids.split(',')
try:
for job_id in job_id_list:
- JobDao.delete_job_dao(query_db, JobModel(jobId=job_id))
- query_db.commit()
+ await JobDao.delete_job_dao(query_db, JobModel(jobId=job_id))
+ await query_db.commit()
result = dict(is_success=True, message='删除成功')
except Exception as e:
- query_db.rollback()
+ await query_db.rollback()
raise e
else:
result = dict(is_success=False, message='传入定时任务id为空')
return CrudResponseModel(**result)
@classmethod
- def job_detail_services(cls, query_db: Session, job_id: int):
+ async def job_detail_services(cls, query_db: AsyncSession, job_id: int):
"""
获取定时任务详细信息service
:param query_db: orm对象
:param job_id: 定时任务id
:return: 定时任务id对应的信息
"""
- job = JobDao.get_job_detail_by_id(query_db, job_id=job_id)
+ job = await JobDao.get_job_detail_by_id(query_db, job_id=job_id)
result = JobModel(**CamelCaseUtil.transform_result(job))
return result
diff --git a/ruoyi-fastapi-backend/module_admin/service/log_service.py b/ruoyi-fastapi-backend/module_admin/service/log_service.py
index cbbb94e9314248ae39699561929efeb9d360977d..4e15d2c81435c3c93243cefed8d13d7fec8a1194 100644
--- a/ruoyi-fastapi-backend/module_admin/service/log_service.py
+++ b/ruoyi-fastapi-backend/module_admin/service/log_service.py
@@ -10,7 +10,7 @@ class OperationLogService:
"""
@classmethod
- def get_operation_log_list_services(cls, query_db: Session, query_object: OperLogPageQueryModel, is_page: bool = False):
+ async def get_operation_log_list_services(cls, query_db: AsyncSession, query_object: OperLogPageQueryModel, is_page: bool = False):
"""
获取操作日志列表信息service
:param query_db: orm对象
@@ -18,12 +18,12 @@ class OperationLogService:
:param is_page: 是否开启分页
:return: 操作日志列表信息对象
"""
- operation_log_list_result = OperationLogDao.get_operation_log_list(query_db, query_object, is_page)
+ operation_log_list_result = await OperationLogDao.get_operation_log_list(query_db, query_object, is_page)
return operation_log_list_result
@classmethod
- def add_operation_log_services(cls, query_db: Session, page_object: OperLogModel):
+ async def add_operation_log_services(cls, query_db: AsyncSession, page_object: OperLogModel):
"""
新增操作日志service
:param query_db: orm对象
@@ -31,17 +31,17 @@ class OperationLogService:
:return: 新增操作日志校验结果
"""
try:
- OperationLogDao.add_operation_log_dao(query_db, page_object)
- query_db.commit()
+ await OperationLogDao.add_operation_log_dao(query_db, page_object)
+ await query_db.commit()
result = dict(is_success=True, message='新增成功')
except Exception as e:
- query_db.rollback()
+ await query_db.rollback()
result = dict(is_success=False, message=str(e))
return CrudResponseModel(**result)
@classmethod
- def delete_operation_log_services(cls, query_db: Session, page_object: DeleteOperLogModel):
+ async def delete_operation_log_services(cls, query_db: AsyncSession, page_object: DeleteOperLogModel):
"""
删除操作日志信息service
:param query_db: orm对象
@@ -52,29 +52,29 @@ class OperationLogService:
oper_id_list = page_object.oper_ids.split(',')
try:
for oper_id in oper_id_list:
- OperationLogDao.delete_operation_log_dao(query_db, OperLogModel(operId=oper_id))
- query_db.commit()
+ await OperationLogDao.delete_operation_log_dao(query_db, OperLogModel(operId=oper_id))
+ await query_db.commit()
result = dict(is_success=True, message='删除成功')
except Exception as e:
- query_db.rollback()
+ await query_db.rollback()
raise e
else:
result = dict(is_success=False, message='传入操作日志id为空')
return CrudResponseModel(**result)
@classmethod
- def clear_operation_log_services(cls, query_db: Session):
+ async def clear_operation_log_services(cls, query_db: AsyncSession):
"""
清除操作日志信息service
:param query_db: orm对象
:return: 清除操作日志校验结果
"""
try:
- OperationLogDao.clear_operation_log_dao(query_db)
- query_db.commit()
+ await OperationLogDao.clear_operation_log_dao(query_db)
+ await query_db.commit()
result = dict(is_success=True, message='清除成功')
except Exception as e:
- query_db.rollback()
+ await query_db.rollback()
raise e
return CrudResponseModel(**result)
@@ -132,7 +132,7 @@ class LoginLogService:
"""
@classmethod
- def get_login_log_list_services(cls, query_db: Session, query_object: LoginLogPageQueryModel, is_page: bool = False):
+ async def get_login_log_list_services(cls, query_db: AsyncSession, query_object: LoginLogPageQueryModel, is_page: bool = False):
"""
获取登录日志列表信息service
:param query_db: orm对象
@@ -140,12 +140,12 @@ class LoginLogService:
:param is_page: 是否开启分页
:return: 登录日志列表信息对象
"""
- operation_log_list_result = LoginLogDao.get_login_log_list(query_db, query_object, is_page)
+ operation_log_list_result = await LoginLogDao.get_login_log_list(query_db, query_object, is_page)
return operation_log_list_result
@classmethod
- def add_login_log_services(cls, query_db: Session, page_object: LogininforModel):
+ async def add_login_log_services(cls, query_db: AsyncSession, page_object: LogininforModel):
"""
新增登录日志service
:param query_db: orm对象
@@ -153,17 +153,17 @@ class LoginLogService:
:return: 新增登录日志校验结果
"""
try:
- LoginLogDao.add_login_log_dao(query_db, page_object)
- query_db.commit()
+ await LoginLogDao.add_login_log_dao(query_db, page_object)
+ await query_db.commit()
result = dict(is_success=True, message='新增成功')
except Exception as e:
- query_db.rollback()
+ await query_db.rollback()
result = dict(is_success=False, message=str(e))
return CrudResponseModel(**result)
@classmethod
- def delete_login_log_services(cls, query_db: Session, page_object: DeleteLoginLogModel):
+ async def delete_login_log_services(cls, query_db: AsyncSession, page_object: DeleteLoginLogModel):
"""
删除操作日志信息service
:param query_db: orm对象
@@ -174,29 +174,29 @@ class LoginLogService:
info_id_list = page_object.info_ids.split(',')
try:
for info_id in info_id_list:
- LoginLogDao.delete_login_log_dao(query_db, LogininforModel(infoId=info_id))
- query_db.commit()
+ await LoginLogDao.delete_login_log_dao(query_db, LogininforModel(infoId=info_id))
+ await query_db.commit()
result = dict(is_success=True, message='删除成功')
except Exception as e:
- query_db.rollback()
+ await query_db.rollback()
raise e
else:
result = dict(is_success=False, message='传入登录日志id为空')
return CrudResponseModel(**result)
@classmethod
- def clear_login_log_services(cls, query_db: Session):
+ async def clear_login_log_services(cls, query_db: AsyncSession):
"""
清除操作日志信息service
:param query_db: orm对象
:return: 清除操作日志校验结果
"""
try:
- LoginLogDao.clear_login_log_dao(query_db)
- query_db.commit()
+ await LoginLogDao.clear_login_log_dao(query_db)
+ await query_db.commit()
result = dict(is_success=True, message='清除成功')
except Exception as e:
- query_db.rollback()
+ await query_db.rollback()
raise e
return CrudResponseModel(**result)
@@ -212,7 +212,7 @@ class LoginLogService:
return CrudResponseModel(**result)
@staticmethod
- def export_login_log_list_services(login_log_list: List):
+ async def export_login_log_list_services(login_log_list: List):
"""
导出登录日志信息service
:param login_log_list: 登录日志信息列表
diff --git a/ruoyi-fastapi-backend/module_admin/service/login_service.py b/ruoyi-fastapi-backend/module_admin/service/login_service.py
index 5229c0590ced79a6a6a5bdeacfd69c7c903173a1..5ae6974b1f710df7fbf3baf76e7a44acb8bae2cb 100644
--- a/ruoyi-fastapi-backend/module_admin/service/login_service.py
+++ b/ruoyi-fastapi-backend/module_admin/service/login_service.py
@@ -48,7 +48,7 @@ class LoginService:
登录模块服务层
"""
@classmethod
- async def authenticate_user(cls, request: Request, query_db: Session, login_user: UserLogin):
+ async def authenticate_user(cls, request: Request, query_db: AsyncSession, login_user: UserLogin):
"""
根据用户名密码校验用户登录
:param request: Request对象
@@ -70,7 +70,8 @@ class LoginService:
pass
else:
await cls.__check_login_captcha(request, login_user)
- user = login_by_account(query_db, login_user.user_name)
+ user = await login_by_account(query_db, login_user.user_name)
+ print(user)
if not user:
logger.warning("用户不存在")
raise LoginException(data="", message="用户不存在")
@@ -135,7 +136,7 @@ class LoginService:
return True
@classmethod
- def create_access_token(cls, data: dict, expires_delta: Union[timedelta, None] = None):
+ async def create_access_token(cls, data: dict, expires_delta: Union[timedelta, None] = None):
"""
根据登录信息创建当前用户token
:param data: 登录信息
@@ -153,7 +154,7 @@ class LoginService:
@classmethod
async def get_current_user(cls, request: Request = Request, token: str = Depends(oauth2_scheme),
- query_db: Session = Depends(get_db)):
+ query_db: AsyncSession = Depends(get_db)):
"""
根据token获取当前用户信息
:param request: Request对象
@@ -178,7 +179,7 @@ class LoginService:
except JWTError:
logger.warning("用户token已失效，请重新登录")
raise AuthException(data="", message="用户token已失效，请重新登录")
- query_user = UserDao.get_user_by_id(query_db, user_id=token_data.user_id)
+ query_user = await UserDao.get_user_by_id(query_db, user_id=token_data.user_id)
if query_user.get('user_basic_info') is None:
logger.warning("用户token不合法")
raise AuthException(data="", message="用户token不合法")
@@ -221,14 +222,14 @@ class LoginService:
raise AuthException(data="", message="用户token已失效，请重新登录")
@classmethod
- async def get_current_user_routers(cls, user_id: int, query_db: Session):
+ async def get_current_user_routers(cls, user_id: int, query_db: AsyncSession):
"""
根据用户id获取当前用户路由信息
:param user_id: 用户id
:param query_db: orm对象
:return: 当前用户路由信息对象
"""
- query_user = UserDao.get_user_by_id(query_db, user_id=user_id)
+ query_user = await UserDao.get_user_by_id(query_db, user_id=user_id)
user_router_menu = sorted([row for row in query_user.get('user_menu_info') if row.menu_type in ['M', 'C']], key=lambda x: x.order_num)
user_router = cls.__generate_user_router_menu(0, user_router_menu)
return user_router
@@ -285,7 +286,7 @@ class LoginService:
return router_list
@classmethod
- async def register_user_services(cls, request: Request, query_db: Session, user_register: UserRegister):
+ async def register_user_services(cls, request: Request, query_db: AsyncSession, user_register: UserRegister):
"""
用户注册services
:param request: Request对象
@@ -313,7 +314,7 @@ class LoginService:
nickName=user_register.username,
password=PwdUtil.get_password_hash(user_register.password)
)
- result = UserService.add_user_services(query_db, add_user)
+ result = await UserService.add_user_services(query_db, add_user)
return result
else:
result = dict(is_success=False, message='注册程序已关闭，禁止注册')
@@ -323,7 +324,7 @@ class LoginService:
return CrudResponseModel(**result)
@classmethod
- async def get_sms_code_services(cls, request: Request, query_db: Session, user: ResetUserModel):
+ async def get_sms_code_services(cls, request: Request, query_db: AsyncSession, user: ResetUserModel):
"""
获取短信验证码service
:param request: Request对象
@@ -335,7 +336,7 @@ class LoginService:
f"{RedisInitKeyConfig.SMS_CODE.get('key')}:{user.session_id}")
if redis_sms_result:
return SmsCode(**dict(is_success=False, sms_code='', session_id='', message='短信验证码仍在有效期内'))
- is_user = UserDao.get_user_by_name(query_db, user.user_name)
+ is_user = await UserDao.get_user_by_name(query_db, user.user_name)
if is_user:
sms_code = str(random.randint(100000, 999999))
session_id = str(uuid.uuid4())
@@ -349,7 +350,7 @@ class LoginService:
return SmsCode(**dict(is_success=False, sms_code='', session_id='', message='用户不存在'))
@classmethod
- async def forget_user_services(cls, request: Request, query_db: Session, forget_user: ResetUserModel):
+ async def forget_user_services(cls, request: Request, query_db: AsyncSession, forget_user: ResetUserModel):
"""
用户忘记密码services
:param request: Request对象
@@ -361,8 +362,8 @@ class LoginService:
f"{RedisInitKeyConfig.SMS_CODE.get('key')}:{forget_user.session_id}")
if forget_user.sms_code == redis_sms_result:
forget_user.password = PwdUtil.get_password_hash(forget_user.password)
- forget_user.user_id = UserDao.get_user_by_name(query_db, forget_user.user_name).user_id
- edit_result = UserService.reset_user_services(query_db, forget_user)
+ forget_user.user_id = (await UserDao.get_user_by_name(query_db, forget_user.user_name)).user_id
+ edit_result = await UserService.reset_user_services(query_db, forget_user)
result = edit_result.dict()
elif not redis_sms_result:
result = dict(is_success=False, message='短信验证码已过期')
diff --git a/ruoyi-fastapi-backend/module_admin/service/menu_service.py b/ruoyi-fastapi-backend/module_admin/service/menu_service.py
index 10a295d904c9ae9366550b21588bf2683e878d77..5f89c90ed4ba4f245b06f57e382a5bee2ab6986c 100644
--- a/ruoyi-fastapi-backend/module_admin/service/menu_service.py
+++ b/ruoyi-fastapi-backend/module_admin/service/menu_service.py
@@ -12,20 +12,20 @@ class MenuService:
"""
@classmethod
- def get_menu_tree_services(cls, query_db: Session, current_user: Optional[CurrentUserModel] = None):
+ async def get_menu_tree_services(cls, query_db: AsyncSession, current_user: Optional[CurrentUserModel] = None):
"""
获取菜单树信息service
:param query_db: orm对象
:param current_user: 当前用户对象
:return: 菜单树信息对象
"""
- menu_list_result = MenuDao.get_menu_list_for_tree(query_db, current_user.user.user_id, current_user.user.role)
+ menu_list_result = await MenuDao.get_menu_list_for_tree(query_db, current_user.user.user_id, current_user.user.role)
menu_tree_result = cls.list_to_tree(menu_list_result)
return menu_tree_result
@classmethod
- def get_role_menu_tree_services(cls, query_db: Session, role_id: int, current_user: Optional[CurrentUserModel] = None):
+ async def get_role_menu_tree_services(cls, query_db: AsyncSession, role_id: int, current_user: Optional[CurrentUserModel] = None):
"""
根据角色id获取菜单树信息service
:param query_db: orm对象
@@ -33,9 +33,9 @@ class MenuService:
:param current_user: 当前用户对象
:return: 当前角色id的菜单树信息对象
"""
- menu_list_result = MenuDao.get_menu_list_for_tree(query_db, current_user.user.user_id, current_user.user.role)
+ menu_list_result = await MenuDao.get_menu_list_for_tree(query_db, current_user.user.user_id, current_user.user.role)
menu_tree_result = cls.list_to_tree(menu_list_result)
- role_menu_list = RoleDao.get_role_menu_dao(query_db, role_id)
+ role_menu_list = await RoleDao.get_role_menu_dao(query_db, role_id)
checked_keys = [row.menu_id for row in role_menu_list]
result = RoleMenuQueryModel(
menus=menu_tree_result,
@@ -45,7 +45,7 @@ class MenuService:
return result
@classmethod
- def get_menu_list_services(cls, query_db: Session, page_object: MenuQueryModel, current_user: Optional[CurrentUserModel] = None):
+ async def get_menu_list_services(cls, query_db: AsyncSession, page_object: MenuQueryModel, current_user: Optional[CurrentUserModel] = None):
"""
获取菜单列表信息service
:param query_db: orm对象
@@ -53,34 +53,34 @@ class MenuService:
:param current_user: 当前用户对象
:return: 菜单列表信息对象
"""
- menu_list_result = MenuDao.get_menu_list(query_db, page_object, current_user.user.user_id, current_user.user.role)
+ menu_list_result = await MenuDao.get_menu_list(query_db, page_object, current_user.user.user_id, current_user.user.role)
return CamelCaseUtil.transform_result(menu_list_result)
@classmethod
- def add_menu_services(cls, query_db: Session, page_object: MenuModel):
+ async def add_menu_services(cls, query_db: AsyncSession, page_object: MenuModel):
"""
新增菜单信息service
:param query_db: orm对象
:param page_object: 新增菜单对象
:return: 新增菜单校验结果
"""
- menu = MenuDao.get_menu_detail_by_info(query_db, MenuModel(parentId=page_object.parent_id, menuName=page_object.menu_name, menuType=page_object.menu_type))
+ menu = await MenuDao.get_menu_detail_by_info(query_db, MenuModel(parentId=page_object.parent_id, menuName=page_object.menu_name, menuType=page_object.menu_type))
if menu:
result = dict(is_success=False, message='同一目录下不允许存在同名同类型的菜单')
else:
try:
- MenuDao.add_menu_dao(query_db, page_object)
- query_db.commit()
+ await MenuDao.add_menu_dao(query_db, page_object)
+ await query_db.commit()
result = dict(is_success=True, message='新增成功')
except Exception as e:
- query_db.rollback()
+ await query_db.rollback()
raise e
return CrudResponseModel(**result)
@classmethod
- def edit_menu_services(cls, query_db: Session, page_object: MenuModel):
+ async def edit_menu_services(cls, query_db: AsyncSession, page_object: MenuModel):
"""
编辑菜单信息service
:param query_db: orm对象
@@ -88,19 +88,19 @@ class MenuService:
:return: 编辑菜单校验结果
"""
edit_menu = page_object.model_dump(exclude_unset=True)
- menu_info = cls.menu_detail_services(query_db, edit_menu.get('menu_id'))
+ menu_info = await cls.menu_detail_services(query_db, edit_menu.get('menu_id'))
if menu_info:
if menu_info.parent_id != page_object.parent_id or menu_info.menu_name != page_object.menu_name or menu_info.menu_type != page_object.menu_type:
- menu = MenuDao.get_menu_detail_by_info(query_db, MenuModel(parentId=page_object.parent_id, menuName=page_object.menu_name, menuType=page_object.menu_type))
+ menu = await MenuDao.get_menu_detail_by_info(query_db, MenuModel(parentId=page_object.parent_id, menuName=page_object.menu_name, menuType=page_object.menu_type))
if menu:
result = dict(is_success=False, message='同一目录下不允许存在同名同类型的菜单')
return CrudResponseModel(**result)
try:
- MenuDao.edit_menu_dao(query_db, edit_menu)
- query_db.commit()
+ await MenuDao.edit_menu_dao(query_db, edit_menu)
+ await query_db.commit()
result = dict(is_success=True, message='更新成功')
except Exception as e:
- query_db.rollback()
+ await query_db.rollback()
raise e
else:
result = dict(is_success=False, message='菜单不存在')
@@ -108,7 +108,7 @@ class MenuService:
return CrudResponseModel(**result)
@classmethod
- def delete_menu_services(cls, query_db: Session, page_object: DeleteMenuModel):
+ async def delete_menu_services(cls, query_db: AsyncSession, page_object: DeleteMenuModel):
"""
删除菜单信息service
:param query_db: orm对象
@@ -119,25 +119,25 @@ class MenuService:
menu_id_list = page_object.menu_ids.split(',')
try:
for menu_id in menu_id_list:
- MenuDao.delete_menu_dao(query_db, MenuModel(menuId=menu_id))
- query_db.commit()
+ await MenuDao.delete_menu_dao(query_db, MenuModel(menuId=menu_id))
+ await query_db.commit()
result = dict(is_success=True, message='删除成功')
except Exception as e:
- query_db.rollback()
+ await query_db.rollback()
raise e
else:
result = dict(is_success=False, message='传入菜单id为空')
return CrudResponseModel(**result)
@classmethod
- def menu_detail_services(cls, query_db: Session, menu_id: int):
+ async def menu_detail_services(cls, query_db: AsyncSession, menu_id: int):
"""
获取菜单详细信息service
:param query_db: orm对象
:param menu_id: 菜单id
:return: 菜单id对应的信息
"""
- menu = MenuDao.get_menu_detail_by_id(query_db, menu_id=menu_id)
+ menu = await MenuDao.get_menu_detail_by_id(query_db, menu_id=menu_id)
result = MenuModel(**CamelCaseUtil.transform_result(menu))
return result
diff --git a/ruoyi-fastapi-backend/module_admin/service/notice_service.py b/ruoyi-fastapi-backend/module_admin/service/notice_service.py
index 1ca63a801d9e2570090338d0acd3b3dabca42df7..573fc39fd7ba97944f2f35d18710b1ffba8b45c9 100644
--- a/ruoyi-fastapi-backend/module_admin/service/notice_service.py
+++ b/ruoyi-fastapi-backend/module_admin/service/notice_service.py
@@ -9,7 +9,7 @@ class NoticeService:
"""
@classmethod
- def get_notice_list_services(cls, query_db: Session, query_object: NoticePageQueryModel, is_page: bool = True):
+ async def get_notice_list_services(cls, query_db: AsyncSession, query_object: NoticePageQueryModel, is_page: bool = True):
"""
获取通知公告列表信息service
:param query_db: orm对象
@@ -17,34 +17,34 @@ class NoticeService:
:param is_page: 是否开启分页
:return: 通知公告列表信息对象
"""
- notice_list_result = NoticeDao.get_notice_list(query_db, query_object, is_page)
+ notice_list_result = await NoticeDao.get_notice_list(query_db, query_object, is_page)
return notice_list_result
@classmethod
- def add_notice_services(cls, query_db: Session, page_object: NoticeModel):
+ async def add_notice_services(cls, query_db: AsyncSession, page_object: NoticeModel):
"""
新增通知公告信息service
:param query_db: orm对象
:param page_object: 新增通知公告对象
:return: 新增通知公告校验结果
"""
- notice = NoticeDao.get_notice_detail_by_info(query_db, page_object)
+ notice = await NoticeDao.get_notice_detail_by_info(query_db, page_object)
if notice:
result = dict(is_success=False, message='通知公告已存在')
else:
try:
- NoticeDao.add_notice_dao(query_db, page_object)
- query_db.commit()
+ await NoticeDao.add_notice_dao(query_db, page_object)
+ await query_db.commit()
result = dict(is_success=True, message='新增成功')
except Exception as e:
- query_db.rollback()
+ await query_db.rollback()
raise e
return CrudResponseModel(**result)
@classmethod
- def edit_notice_services(cls, query_db: Session, page_object: NoticeModel):
+ async def edit_notice_services(cls, query_db: AsyncSession, page_object: NoticeModel):
"""
编辑通知公告信息service
:param query_db: orm对象
@@ -52,19 +52,19 @@ class NoticeService:
:return: 编辑通知公告校验结果
"""
edit_notice = page_object.model_dump(exclude_unset=True)
- notice_info = cls.notice_detail_services(query_db, edit_notice.get('notice_id'))
+ notice_info = await cls.notice_detail_services(query_db, edit_notice.get('notice_id'))
if notice_info:
if notice_info.notice_title != page_object.notice_title or notice_info.notice_type != page_object.notice_type or notice_info.notice_content != page_object.notice_content:
- notice = NoticeDao.get_notice_detail_by_info(query_db, page_object)
+ notice = await NoticeDao.get_notice_detail_by_info(query_db, page_object)
if notice:
result = dict(is_success=False, message='通知公告已存在')
return CrudResponseModel(**result)
try:
- NoticeDao.edit_notice_dao(query_db, edit_notice)
- query_db.commit()
+ await NoticeDao.edit_notice_dao(query_db, edit_notice)
+ await query_db.commit()
result = dict(is_success=True, message='更新成功')
except Exception as e:
- query_db.rollback()
+ await query_db.rollback()
raise e
else:
result = dict(is_success=False, message='通知公告不存在')
@@ -72,7 +72,7 @@ class NoticeService:
return CrudResponseModel(**result)
@classmethod
- def delete_notice_services(cls, query_db: Session, page_object: DeleteNoticeModel):
+ async def delete_notice_services(cls, query_db: AsyncSession, page_object: DeleteNoticeModel):
"""
删除通知公告信息service
:param query_db: orm对象
@@ -83,25 +83,25 @@ class NoticeService:
notice_id_list = page_object.notice_ids.split(',')
try:
for notice_id in notice_id_list:
- NoticeDao.delete_notice_dao(query_db, NoticeModel(noticeId=notice_id))
- query_db.commit()
+ await NoticeDao.delete_notice_dao(query_db, NoticeModel(noticeId=notice_id))
+ await query_db.commit()
result = dict(is_success=True, message='删除成功')
except Exception as e:
- query_db.rollback()
+ await query_db.rollback()
raise e
else:
result = dict(is_success=False, message='传入通知公告id为空')
return CrudResponseModel(**result)
@classmethod
- def notice_detail_services(cls, query_db: Session, notice_id: int):
+ async def notice_detail_services(cls, query_db: AsyncSession, notice_id: int):
"""
获取通知公告详细信息service
:param query_db: orm对象
:param notice_id: 通知公告id
:return: 通知公告id对应的信息
"""
- notice = NoticeDao.get_notice_detail_by_id(query_db, notice_id=notice_id)
+ notice = await NoticeDao.get_notice_detail_by_id(query_db, notice_id=notice_id)
result = NoticeModel(**CamelCaseUtil.transform_result(notice))
return result
diff --git a/ruoyi-fastapi-backend/module_admin/service/post_service.py b/ruoyi-fastapi-backend/module_admin/service/post_service.py
index d6b097fef55872f53af574a57f616faac545de62..13882abb906a6a34f82f32ede089af762118e85e 100644
--- a/ruoyi-fastapi-backend/module_admin/service/post_service.py
+++ b/ruoyi-fastapi-backend/module_admin/service/post_service.py
@@ -8,7 +8,7 @@ class PostService:
岗位管理模块服务层
"""
@classmethod
- def get_post_list_services(cls, query_db: Session, query_object: PostPageQueryModel, is_page: bool = False):
+ async def get_post_list_services(cls, query_db: AsyncSession, query_object: PostPageQueryModel, is_page: bool = False):
"""
获取岗位列表信息service
:param query_db: orm对象
@@ -16,34 +16,34 @@ class PostService:
:param is_page: 是否开启分页
:return: 岗位列表信息对象
"""
- post_list_result = PostDao.get_post_list(query_db, query_object, is_page)
+ post_list_result = await PostDao.get_post_list(query_db, query_object, is_page)
return post_list_result
@classmethod
- def add_post_services(cls, query_db: Session, page_object: PostModel):
+ async def add_post_services(cls, query_db: AsyncSession, page_object: PostModel):
"""
新增岗位信息service
:param query_db: orm对象
:param page_object: 新增岗位对象
:return: 新增岗位校验结果
"""
- post = PostDao.get_post_detail_by_info(query_db, PostModel(postName=page_object.post_name))
+ post = await PostDao.get_post_detail_by_info(query_db, PostModel(postName=page_object.post_name))
if post:
result = dict(is_success=False, message='岗位名称已存在')
else:
try:
- PostDao.add_post_dao(query_db, page_object)
- query_db.commit()
+ await PostDao.add_post_dao(query_db, page_object)
+ await query_db.commit()
result = dict(is_success=True, message='新增成功')
except Exception as e:
- query_db.rollback()
+ await query_db.rollback()
raise e
return CrudResponseModel(**result)
@classmethod
- def edit_post_services(cls, query_db: Session, page_object: PostModel):
+ async def edit_post_services(cls, query_db: AsyncSession, page_object: PostModel):
"""
编辑岗位信息service
:param query_db: orm对象
@@ -51,19 +51,19 @@ class PostService:
:return: 编辑岗位校验结果
"""
edit_post = page_object.model_dump(exclude_unset=True)
- post_info = cls.post_detail_services(query_db, edit_post.get('post_id'))
+ post_info = await cls.post_detail_services(query_db, edit_post.get('post_id'))
if post_info:
if post_info.post_name != page_object.post_name:
- post = PostDao.get_post_detail_by_info(query_db, PostModel(postName=page_object.post_name))
+ post = await PostDao.get_post_detail_by_info(query_db, PostModel(postName=page_object.post_name))
if post:
result = dict(is_success=False, message='岗位名称已存在')
return CrudResponseModel(**result)
try:
- PostDao.edit_post_dao(query_db, edit_post)
- query_db.commit()
+ await PostDao.edit_post_dao(query_db, edit_post)
+ await query_db.commit()
result = dict(is_success=True, message='更新成功')
except Exception as e:
- query_db.rollback()
+ await query_db.rollback()
raise e
else:
result = dict(is_success=False, message='岗位不存在')
@@ -71,7 +71,7 @@ class PostService:
return CrudResponseModel(**result)
@classmethod
- def delete_post_services(cls, query_db: Session, page_object: DeletePostModel):
+ async def delete_post_services(cls, query_db: AsyncSession, page_object: DeletePostModel):
"""
删除岗位信息service
:param query_db: orm对象
@@ -82,31 +82,31 @@ class PostService:
post_id_list = page_object.post_ids.split(',')
try:
for post_id in post_id_list:
- PostDao.delete_post_dao(query_db, PostModel(postId=post_id))
- query_db.commit()
+ await PostDao.delete_post_dao(query_db, PostModel(postId=post_id))
+ await query_db.commit()
result = dict(is_success=True, message='删除成功')
except Exception as e:
- query_db.rollback()
+ await query_db.rollback()
raise e
else:
result = dict(is_success=False, message='传入岗位id为空')
return CrudResponseModel(**result)
@classmethod
- def post_detail_services(cls, query_db: Session, post_id: int):
+ async def post_detail_services(cls, query_db: AsyncSession, post_id: int):
"""
获取岗位详细信息service
:param query_db: orm对象
:param post_id: 岗位id
:return: 岗位id对应的信息
"""
- post = PostDao.get_post_detail_by_id(query_db, post_id=post_id)
+ post = await PostDao.get_post_detail_by_id(query_db, post_id=post_id)
result = PostModel(**CamelCaseUtil.transform_result(post))
return result
@staticmethod
- def export_post_list_services(post_list: List):
+ async def export_post_list_services(post_list: List):
"""
导出岗位信息service
:param post_list: 岗位信息列表
diff --git a/ruoyi-fastapi-backend/module_admin/service/role_service.py b/ruoyi-fastapi-backend/module_admin/service/role_service.py
index c09c11f56969655fa54dae50a06a935ca240f180..745d3dbd3248add51b85b2194c3c0d979702dffe 100644
--- a/ruoyi-fastapi-backend/module_admin/service/role_service.py
+++ b/ruoyi-fastapi-backend/module_admin/service/role_service.py
@@ -12,25 +12,25 @@ class RoleService:
"""
@classmethod
- def get_role_select_option_services(cls, query_db: Session):
+ async def get_role_select_option_services(cls, query_db: AsyncSession):
"""
获取角色列表不分页信息service
:param query_db: orm对象
:return: 角色列表不分页信息对象
"""
- role_list_result = RoleDao.get_role_select_option_dao(query_db)
+ role_list_result = await RoleDao.get_role_select_option_dao(query_db)
return CamelCaseUtil.transform_result(role_list_result)
@classmethod
- def get_role_dept_tree_services(cls, query_db: Session, role_id: int):
+ async def get_role_dept_tree_services(cls, query_db: AsyncSession, role_id: int):
"""
根据角色id获取部门树信息service
:param query_db: orm对象
:param role_id: 角色id
:return: 当前角色id的部门树信息对象
"""
- role_dept_list = RoleDao.get_role_dept_dao(query_db, role_id)
+ role_dept_list = await RoleDao.get_role_dept_dao(query_db, role_id)
checked_keys = [row.dept_id for row in role_dept_list]
result = RoleDeptQueryModel(
checkedKeys=checked_keys
@@ -39,7 +39,7 @@ class RoleService:
return result
@classmethod
- def get_role_list_services(cls, query_db: Session, query_object: RolePageQueryModel, is_page: bool = False):
+ async def get_role_list_services(cls, query_db: AsyncSession, query_object: RolePageQueryModel, is_page: bool = False):
"""
获取角色列表信息service
:param query_db: orm对象
@@ -47,12 +47,12 @@ class RoleService:
:param is_page: 是否开启分页
:return: 角色列表信息对象
"""
- role_list_result = RoleDao.get_role_list(query_db, query_object, is_page)
+ role_list_result = await RoleDao.get_role_list(query_db, query_object, is_page)
return role_list_result
@classmethod
- def add_role_services(cls, query_db: Session, page_object: AddRoleModel):
+ async def add_role_services(cls, query_db: AsyncSession, page_object: AddRoleModel):
"""
新增角色信息service
:param query_db: orm对象
@@ -60,29 +60,29 @@ class RoleService:
:return: 新增角色校验结果
"""
add_role = RoleModel(**page_object.model_dump(by_alias=True))
- role_name = RoleDao.get_role_by_info(query_db, RoleModel(roleName=page_object.role_name))
- role_key = RoleDao.get_role_by_info(query_db, RoleModel(roleKey=page_object.role_key))
+ role_name = await RoleDao.get_role_by_info(query_db, RoleModel(roleName=page_object.role_name))
+ role_key = await RoleDao.get_role_by_info(query_db, RoleModel(roleKey=page_object.role_key))
if role_name:
result = dict(is_success=False, message='角色名称已存在')
elif role_key:
result = dict(is_success=False, message='权限字符已存在')
else:
try:
- add_result = RoleDao.add_role_dao(query_db, add_role)
+ add_result = await RoleDao.add_role_dao(query_db, add_role)
role_id = add_result.role_id
if page_object.menu_ids:
for menu in page_object.menu_ids:
- RoleDao.add_role_menu_dao(query_db, RoleMenuModel(roleId=role_id, menuId=menu))
- query_db.commit()
+ await RoleDao.add_role_menu_dao(query_db, RoleMenuModel(roleId=role_id, menuId=menu))
+ await query_db.commit()
result = dict(is_success=True, message='新增成功')
except Exception as e:
- query_db.rollback()
+ await query_db.rollback()
raise e
return CrudResponseModel(**result)
@classmethod
- def edit_role_services(cls, query_db: Session, page_object: AddRoleModel):
+ async def edit_role_services(cls, query_db: AsyncSession, page_object: AddRoleModel):
"""
编辑角色信息service
:param query_db: orm对象
@@ -94,29 +94,29 @@ class RoleService:
del edit_role['menu_ids']
if page_object.type == 'status':
del edit_role['type']
- role_info = cls.role_detail_services(query_db, edit_role.get('role_id'))
+ role_info = await cls.role_detail_services(query_db, edit_role.get('role_id'))
if role_info:
if page_object.type != 'status' and role_info.role_name != page_object.role_name:
- role_name = RoleDao.get_role_by_info(query_db, RoleModel(roleName=page_object.role_name))
+ role_name = await RoleDao.get_role_by_info(query_db, RoleModel(roleName=page_object.role_name))
if role_name:
result = dict(is_success=False, message='角色名称已存在')
return CrudResponseModel(**result)
elif page_object.type != 'status' and role_info.role_key != page_object.role_key:
- role_key = RoleDao.get_role_by_info(query_db, RoleModel(roleKey=page_object.role_key))
+ role_key = await RoleDao.get_role_by_info(query_db, RoleModel(roleKey=page_object.role_key))
if role_key:
result = dict(is_success=False, message='权限字符已存在')
return CrudResponseModel(**result)
try:
- RoleDao.edit_role_dao(query_db, edit_role)
+ await RoleDao.edit_role_dao(query_db, edit_role)
if page_object.type != 'status':
- RoleDao.delete_role_menu_dao(query_db, RoleMenuModel(roleId=page_object.role_id))
+ await RoleDao.delete_role_menu_dao(query_db, RoleMenuModel(roleId=page_object.role_id))
if page_object.menu_ids:
for menu in page_object.menu_ids:
- RoleDao.add_role_menu_dao(query_db, RoleMenuModel(roleId=page_object.role_id, menuId=menu))
- query_db.commit()
+ await RoleDao.add_role_menu_dao(query_db, RoleMenuModel(roleId=page_object.role_id, menuId=menu))
+ await query_db.commit()
result = dict(is_success=True, message='更新成功')
except Exception as e:
- query_db.rollback()
+ await query_db.rollback()
raise e
else:
result = dict(is_success=False, message='角色不存在')
@@ -124,7 +124,7 @@ class RoleService:
return CrudResponseModel(**result)
@classmethod
- def role_datascope_services(cls, query_db: Session, page_object: AddRoleModel):
+ async def role_datascope_services(cls, query_db: AsyncSession, page_object: AddRoleModel):
"""
分配角色数据权限service
:param query_db: orm对象
@@ -133,28 +133,28 @@ class RoleService:
"""
edit_role = page_object.model_dump(exclude_unset=True, exclude={'admin'})
del edit_role['dept_ids']
- role_info = cls.role_detail_services(query_db, edit_role.get('role_id'))
+ role_info = await cls.role_detail_services(query_db, edit_role.get('role_id'))
if role_info:
if role_info.role_name != page_object.role_name:
- role_name = RoleDao.get_role_by_info(query_db, RoleModel(roleName=page_object.role_name))
+ role_name = await RoleDao.get_role_by_info(query_db, RoleModel(roleName=page_object.role_name))
if role_name:
result = dict(is_success=False, message='角色名称已存在')
return CrudResponseModel(**result)
elif role_info.role_key != page_object.role_key:
- role_key = RoleDao.get_role_by_info(query_db, RoleModel(roleKey=page_object.role_key))
+ role_key = await RoleDao.get_role_by_info(query_db, RoleModel(roleKey=page_object.role_key))
if role_key:
result = dict(is_success=False, message='权限字符已存在')
return CrudResponseModel(**result)
try:
- RoleDao.edit_role_dao(query_db, edit_role)
- RoleDao.delete_role_dept_dao(query_db, RoleDeptModel(roleId=page_object.role_id))
+ await RoleDao.edit_role_dao(query_db, edit_role)
+ await RoleDao.delete_role_dept_dao(query_db, RoleDeptModel(roleId=page_object.role_id))
if page_object.dept_ids and page_object.data_scope == '2':
for dept in page_object.dept_ids:
- RoleDao.add_role_dept_dao(query_db, RoleDeptModel(roleId=page_object.role_id, deptId=dept))
- query_db.commit()
+ await RoleDao.add_role_dept_dao(query_db, RoleDeptModel(roleId=page_object.role_id, deptId=dept))
+ await query_db.commit()
result = dict(is_success=True, message='分配成功')
except Exception as e:
- query_db.rollback()
+ await query_db.rollback()
raise e
else:
result = dict(is_success=False, message='角色不存在')
@@ -162,7 +162,7 @@ class RoleService:
return CrudResponseModel(**result)
@classmethod
- def delete_role_services(cls, query_db: Session, page_object: DeleteRoleModel):
+ async def delete_role_services(cls, query_db: AsyncSession, page_object: DeleteRoleModel):
"""
删除角色信息service
:param query_db: orm对象
@@ -174,32 +174,32 @@ class RoleService:
try:
for role_id in role_id_list:
role_id_dict = dict(roleId=role_id, updateBy=page_object.update_by, updateTime=page_object.update_time)
- RoleDao.delete_role_menu_dao(query_db, RoleMenuModel(**role_id_dict))
- RoleDao.delete_role_dao(query_db, RoleModel(**role_id_dict))
- query_db.commit()
+ await RoleDao.delete_role_menu_dao(query_db, RoleMenuModel(**role_id_dict))
+ await RoleDao.delete_role_dao(query_db, RoleModel(**role_id_dict))
+ await query_db.commit()
result = dict(is_success=True, message='删除成功')
except Exception as e:
- query_db.rollback()
+ await query_db.rollback()
raise e
else:
result = dict(is_success=False, message='传入角色id为空')
return CrudResponseModel(**result)
@classmethod
- def role_detail_services(cls, query_db: Session, role_id: int):
+ async def role_detail_services(cls, query_db: AsyncSession, role_id: int):
"""
获取角色详细信息service
:param query_db: orm对象
:param role_id: 角色id
:return: 角色id对应的信息
"""
- role = RoleDao.get_role_detail_by_id(query_db, role_id=role_id)
+ role = await RoleDao.get_role_detail_by_id(query_db, role_id=role_id)
result = RoleModel(**CamelCaseUtil.transform_result(role))
return result
@staticmethod
- def export_role_list_services(role_list: List):
+ async def export_role_list_services(role_list: List):
"""
导出角色列表信息service
:param role_list: 角色信息列表
@@ -232,7 +232,7 @@ class RoleService:
return binary_data
@classmethod
- def get_role_user_allocated_list_services(cls, query_db: Session, page_object: UserRolePageQueryModel, is_page: bool = False):
+ async def get_role_user_allocated_list_services(cls, query_db: AsyncSession, page_object: UserRolePageQueryModel, is_page: bool = False):
"""
根据角色id获取已分配用户列表
:param query_db: orm对象
@@ -240,7 +240,7 @@ class RoleService:
:param is_page: 是否开启分页
:return: 已分配用户列表
"""
- query_user_list = UserDao.get_user_role_allocated_list_by_role_id(query_db, page_object, is_page)
+ query_user_list = await UserDao.get_user_role_allocated_list_by_role_id(query_db, page_object, is_page)
allocated_list = PageResponseModel(
**{
**query_user_list.model_dump(by_alias=True),
@@ -251,7 +251,7 @@ class RoleService:
return allocated_list
@classmethod
- def get_role_user_unallocated_list_services(cls, query_db: Session, page_object: UserRolePageQueryModel, is_page: bool = False):
+ async def get_role_user_unallocated_list_services(cls, query_db: AsyncSession, page_object: UserRolePageQueryModel, is_page: bool = False):
"""
根据角色id获取未分配用户列表
:param query_db: orm对象
@@ -259,7 +259,7 @@ class RoleService:
:param is_page: 是否开启分页
:return: 未分配用户列表
"""
- query_user_list = UserDao.get_user_role_unallocated_list_by_role_id(query_db, page_object, is_page)
+ query_user_list = await UserDao.get_user_role_unallocated_list_by_role_id(query_db, page_object, is_page)
unallocated_list = PageResponseModel(
**{
**query_user_list.model_dump(by_alias=True),
diff --git a/ruoyi-fastapi-backend/module_admin/service/server_service.py b/ruoyi-fastapi-backend/module_admin/service/server_service.py
index 760823bdd9df991f7a40a3ffec460215141dcd21..da6e2a2ff70e00ebcd53661f8fa010b7e72f4a93 100644
--- a/ruoyi-fastapi-backend/module_admin/service/server_service.py
+++ b/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)
diff --git a/ruoyi-fastapi-backend/module_admin/service/user_service.py b/ruoyi-fastapi-backend/module_admin/service/user_service.py
index 9f8f1e3bf6cb36a1c56ccd9f732b350acdac1dc3..40ff53129fabfcebf76625f3010d0ebdb677391f 100644
--- a/ruoyi-fastapi-backend/module_admin/service/user_service.py
+++ b/ruoyi-fastapi-backend/module_admin/service/user_service.py
@@ -14,7 +14,7 @@ class UserService:
"""
@classmethod
- def get_user_list_services(cls, query_db: Session, query_object: UserPageQueryModel, data_scope_sql: str, is_page: bool = False):
+ async def get_user_list_services(cls, query_db: AsyncSession, query_object: UserPageQueryModel, data_scope_sql: str, is_page: bool = False):
"""
获取用户列表信息service
:param query_db: orm对象
@@ -23,7 +23,7 @@ class UserService:
:param is_page: 是否开启分页
:return: 用户列表信息对象
"""
- query_result = UserDao.get_user_list(query_db, query_object, data_scope_sql, is_page)
+ query_result = await UserDao.get_user_list(query_db, query_object, data_scope_sql, is_page)
if is_page:
user_list_result = PageResponseModel(
**{
@@ -39,7 +39,7 @@ class UserService:
return user_list_result
@classmethod
- def add_user_services(cls, query_db: Session, page_object: AddUserModel):
+ async def add_user_services(cls, query_db: AsyncSession, page_object: AddUserModel):
"""
新增用户信息service
:param query_db: orm对象
@@ -47,29 +47,29 @@ class UserService:
:return: 新增用户校验结果
"""
add_user = UserModel(**page_object.model_dump(by_alias=True))
- user = UserDao.get_user_by_info(query_db, UserModel(userName=page_object.user_name))
+ user = await UserDao.get_user_by_info(query_db, UserModel(userName=page_object.user_name))
if user:
result = dict(is_success=False, message='用户名已存在')
else:
try:
- add_result = UserDao.add_user_dao(query_db, add_user)
+ add_result = await UserDao.add_user_dao(query_db, add_user)
user_id = add_result.user_id
if page_object.role_ids:
for role in page_object.role_ids:
- UserDao.add_user_role_dao(query_db, UserRoleModel(userId=user_id, roleId=role))
+ await UserDao.add_user_role_dao(query_db, UserRoleModel(userId=user_id, roleId=role))
if page_object.post_ids:
for post in page_object.post_ids:
- UserDao.add_user_post_dao(query_db, UserPostModel(userId=user_id, postId=post))
- query_db.commit()
+ await UserDao.add_user_post_dao(query_db, UserPostModel(userId=user_id, postId=post))
+ await query_db.commit()
result = dict(is_success=True, message='新增成功')
except Exception as e:
- query_db.rollback()
+ await query_db.rollback()
raise e
return CrudResponseModel(**result)
@classmethod
- def edit_user_services(cls, query_db: Session, page_object: EditUserModel):
+ async def edit_user_services(cls, query_db: AsyncSession, page_object: EditUserModel):
"""
编辑用户信息service
:param query_db: orm对象
@@ -83,28 +83,28 @@ class UserService:
del edit_user['role']
if page_object.type == 'status' or page_object.type == 'avatar' or page_object.type == 'pwd':
del edit_user['type']
- user_info = cls.user_detail_services(query_db, edit_user.get('user_id'))
+ user_info = await cls.user_detail_services(query_db, edit_user.get('user_id'))
if user_info:
if page_object.type != 'status' and page_object.type != 'avatar' and page_object.type == 'pwd' and user_info.data.user_name != page_object.user_name:
- user = UserDao.get_user_by_info(query_db, UserModel(userName=page_object.user_name))
+ user = await UserDao.get_user_by_info(query_db, UserModel(userName=page_object.user_name))
if user:
result = dict(is_success=False, message='用户名已存在')
return CrudResponseModel(**result)
try:
- UserDao.edit_user_dao(query_db, edit_user)
- if page_object.type != 'status' and page_object.type != 'avatar':
- UserDao.delete_user_role_dao(query_db, UserRoleModel(userId=page_object.user_id))
- UserDao.delete_user_post_dao(query_db, UserPostModel(userId=page_object.user_id))
+ await UserDao.edit_user_dao(query_db, edit_user)
+ if page_object.type != 'status' and page_object.type != 'avatar' and page_object.type != 'pwd':
+ await UserDao.delete_user_role_dao(query_db, UserRoleModel(userId=page_object.user_id))
+ await UserDao.delete_user_post_dao(query_db, UserPostModel(userId=page_object.user_id))
if page_object.role_ids:
for role in page_object.role_ids:
- UserDao.add_user_role_dao(query_db, UserRoleModel(userId=page_object.user_id, roleId=role))
+ await UserDao.add_user_role_dao(query_db, UserRoleModel(userId=page_object.user_id, roleId=role))
if page_object.post_ids:
for post in page_object.post_ids:
- UserDao.add_user_post_dao(query_db, UserPostModel(userId=page_object.user_id, postId=post))
- query_db.commit()
+ await UserDao.add_user_post_dao(query_db, UserPostModel(userId=page_object.user_id, postId=post))
+ await query_db.commit()
result = dict(is_success=True, message='更新成功')
except Exception as e:
- query_db.rollback()
+ await query_db.rollback()
raise e
else:
result = dict(is_success=False, message='用户不存在')
@@ -112,7 +112,7 @@ class UserService:
return CrudResponseModel(**result)
@classmethod
- def delete_user_services(cls, query_db: Session, page_object: DeleteUserModel):
+ async def delete_user_services(cls, query_db: AsyncSession, page_object: DeleteUserModel):
"""
删除用户信息service
:param query_db: orm对象
@@ -124,30 +124,30 @@ class UserService:
try:
for user_id in user_id_list:
user_id_dict = dict(userId=user_id, updateBy=page_object.update_by, updateTime=page_object.update_time)
- UserDao.delete_user_role_dao(query_db, UserRoleModel(**user_id_dict))
- UserDao.delete_user_post_dao(query_db, UserPostModel(**user_id_dict))
- UserDao.delete_user_dao(query_db, UserModel(**user_id_dict))
- query_db.commit()
+ await UserDao.delete_user_role_dao(query_db, UserRoleModel(**user_id_dict))
+ await UserDao.delete_user_post_dao(query_db, UserPostModel(**user_id_dict))
+ await UserDao.delete_user_dao(query_db, UserModel(**user_id_dict))
+ await query_db.commit()
result = dict(is_success=True, message='删除成功')
except Exception as e:
- query_db.rollback()
+ await query_db.rollback()
raise e
else:
result = dict(is_success=False, message='传入用户id为空')
return CrudResponseModel(**result)
@classmethod
- def user_detail_services(cls, query_db: Session, user_id: Union[int, str]):
+ async def user_detail_services(cls, query_db: AsyncSession, user_id: Union[int, str]):
"""
获取用户详细信息service
:param query_db: orm对象
:param user_id: 用户id
:return: 用户id对应的信息
"""
- posts = PostService.get_post_list_services(query_db, PostPageQueryModel(**{}), is_page=False)
- roles = RoleService.get_role_select_option_services(query_db)
+ posts = await PostService.get_post_list_services(query_db, PostPageQueryModel(**{}), is_page=False)
+ roles = await RoleService.get_role_select_option_services(query_db)
if user_id != '':
- query_user = UserDao.get_user_detail_by_id(query_db, user_id=user_id)
+ query_user = await UserDao.get_user_detail_by_id(query_db, user_id=user_id)
post_ids = ','.join([str(row.post_id) for row in query_user.get('user_post_info')])
post_ids_list = [row.post_id for row in query_user.get('user_post_info')]
role_ids = ','.join([str(row.role_id) for row in query_user.get('user_role_info')])
@@ -173,14 +173,14 @@ class UserService:
)
@classmethod
- def user_profile_services(cls, query_db: Session, user_id: int):
+ async def user_profile_services(cls, query_db: AsyncSession, user_id: int):
"""
获取用户详细信息service
:param query_db: orm对象
:param user_id: 用户id
:return: 用户id对应的信息
"""
- query_user = UserDao.get_user_detail_by_id(query_db, user_id=user_id)
+ query_user = await UserDao.get_user_detail_by_id(query_db, user_id=user_id)
post_ids = ','.join([str(row.post_id) for row in query_user.get('user_post_info')])
post_group = ','.join([row.post_name for row in query_user.get('user_post_info')])
role_ids = ','.join([str(row.role_id) for row in query_user.get('user_role_info')])
@@ -199,7 +199,7 @@ class UserService:
)
@classmethod
- def reset_user_services(cls, query_db: Session, page_object: ResetUserModel):
+ async def reset_user_services(cls, query_db: AsyncSession, page_object: ResetUserModel):
"""
重置用户密码service
:param query_db: orm对象
@@ -208,7 +208,7 @@ class UserService:
"""
reset_user = page_object.model_dump(exclude_unset=True, exclude={'admin'})
if page_object.old_password:
- user = UserDao.get_user_detail_by_id(query_db, user_id=page_object.user_id).get('user_basic_info')
+ user = (await UserDao.get_user_detail_by_id(query_db, user_id=page_object.user_id)).get('user_basic_info')
if not PwdUtil.verify_password(page_object.old_password, user.password):
result = dict(is_success=False, message='旧密码不正确')
return CrudResponseModel(**result)
@@ -218,17 +218,17 @@ class UserService:
del reset_user['sms_code']
del reset_user['session_id']
try:
- UserDao.edit_user_dao(query_db, reset_user)
- query_db.commit()
+ await UserDao.edit_user_dao(query_db, reset_user)
+ await query_db.commit()
result = dict(is_success=True, message='重置成功')
except Exception as e:
- query_db.rollback()
+ await query_db.rollback()
raise e
return CrudResponseModel(**result)
@classmethod
- async def batch_import_user_services(cls, query_db: Session, file: UploadFile, update_support: bool, current_user: CurrentUserModel):
+ async def batch_import_user_services(cls, query_db: AsyncSession, file: UploadFile, update_support: bool, current_user: CurrentUserModel):
"""
批量导入用户service
:param query_db: orm对象
@@ -277,7 +277,7 @@ class UserService:
createBy=current_user.user.user_name,
updateBy=current_user.user.user_name
)
- user_info = UserDao.get_user_by_info(query_db, UserModel(userName=row['user_name']))
+ user_info = await UserDao.get_user_by_info(query_db, UserModel(userName=row['user_name']))
if user_info:
if update_support:
edit_user = UserModel(
@@ -291,21 +291,21 @@ class UserService:
status=row['status'],
updateBy=current_user.user.user_name
).model_dump(exclude_unset=True)
- UserDao.edit_user_dao(query_db, edit_user)
+ await UserDao.edit_user_dao(query_db, edit_user)
else:
add_error_result.append(f"{count}.用户账号{row['user_name']}已存在")
else:
- UserDao.add_user_dao(query_db, add_user)
- query_db.commit()
+ await UserDao.add_user_dao(query_db, add_user)
+ await query_db.commit()
result = dict(is_success=True, message='\n'.join(add_error_result))
except Exception as e:
- query_db.rollback()
+ await query_db.rollback()
raise e
return CrudResponseModel(**result)
@staticmethod
- def get_user_import_template_services():
+ async def get_user_import_template_services():
"""
获取用户导入模板service
:return: 用户导入模板excel的二进制数据
@@ -318,7 +318,7 @@ class UserService:
return binary_data
@staticmethod
- def export_user_list_services(user_list: List):
+ async def export_user_list_services(user_list: List):
"""
导出用户信息service
:param user_list: 用户信息列表
@@ -360,14 +360,14 @@ class UserService:
return binary_data
@classmethod
- def get_user_role_allocated_list_services(cls, query_db: Session, page_object: UserRoleQueryModel):
+ async def get_user_role_allocated_list_services(cls, query_db: AsyncSession, page_object: UserRoleQueryModel):
"""
根据用户id获取已分配角色列表
:param query_db: orm对象
:param page_object: 用户关联角色对象
:return: 已分配角色列表
"""
- query_user = UserDao.get_user_detail_by_id(query_db, page_object.user_id)
+ query_user = await UserDao.get_user_detail_by_id(query_db, page_object.user_id)
post_ids = ','.join([str(row.post_id) for row in query_user.get('user_post_info')])
role_ids = ','.join([str(row.role_id) for row in query_user.get('user_role_info')])
user = UserInfoModel(
@@ -377,7 +377,7 @@ class UserService:
dept=CamelCaseUtil.transform_result(query_user.get('user_dept_info')),
role=CamelCaseUtil.transform_result(query_user.get('user_role_info'))
)
- query_role_list = [SelectedRoleModel(**row) for row in RoleService.get_role_select_option_services(query_db)]
+ query_role_list = [SelectedRoleModel(**row) for row in await RoleService.get_role_select_option_services(query_db)]
for model_a in query_role_list:
for model_b in user.role:
if model_a.role_id == model_b.role_id:
@@ -390,7 +390,7 @@ class UserService:
return result
@classmethod
- def add_user_role_services(cls, query_db: Session, page_object: CrudUserRoleModel):
+ async def add_user_role_services(cls, query_db: AsyncSession, page_object: CrudUserRoleModel):
"""
新增用户关联角色信息service
:param query_db: orm对象
@@ -401,37 +401,37 @@ class UserService:
role_id_list = page_object.role_ids.split(',')
try:
for role_id in role_id_list:
- user_role = cls.detail_user_role_services(query_db, UserRoleModel(userId=page_object.user_id, roleId=role_id))
+ user_role = await cls.detail_user_role_services(query_db, UserRoleModel(userId=page_object.user_id, roleId=role_id))
if user_role:
continue
else:
- UserDao.add_user_role_dao(query_db, UserRoleModel(userId=page_object.user_id, roleId=role_id))
- query_db.commit()
+ await UserDao.add_user_role_dao(query_db, UserRoleModel(userId=page_object.user_id, roleId=role_id))
+ await query_db.commit()
result = dict(is_success=True, message='分配成功')
except Exception as e:
- query_db.rollback()
+ await query_db.rollback()
raise e
elif page_object.user_id and not page_object.role_ids:
try:
- UserDao.delete_user_role_by_user_and_role_dao(query_db, UserRoleModel(userId=page_object.user_id))
- query_db.commit()
+ await UserDao.delete_user_role_by_user_and_role_dao(query_db, UserRoleModel(userId=page_object.user_id))
+ await query_db.commit()
result = dict(is_success=True, message='分配成功')
except Exception as e:
- query_db.rollback()
+ await query_db.rollback()
raise e
elif page_object.user_ids and page_object.role_id:
user_id_list = page_object.user_ids.split(',')
try:
for user_id in user_id_list:
- user_role = cls.detail_user_role_services(query_db, UserRoleModel(userId=user_id, roleId=page_object.role_id))
+ user_role = await cls.detail_user_role_services(query_db, UserRoleModel(userId=user_id, roleId=page_object.role_id))
if user_role:
continue
else:
- UserDao.add_user_role_dao(query_db, UserRoleModel(userId=user_id, roleId=page_object.role_id))
- query_db.commit()
+ await UserDao.add_user_role_dao(query_db, UserRoleModel(userId=user_id, roleId=page_object.role_id))
+ await query_db.commit()
result = dict(is_success=True, message='新增成功')
except Exception as e:
- query_db.rollback()
+ await query_db.rollback()
raise e
else:
result = dict(is_success=False, message='不满足新增条件')
@@ -439,7 +439,7 @@ class UserService:
return CrudResponseModel(**result)
@classmethod
- def delete_user_role_services(cls, query_db: Session, page_object: CrudUserRoleModel):
+ async def delete_user_role_services(cls, query_db: AsyncSession, page_object: CrudUserRoleModel):
"""
删除用户关联角色信息service
:param query_db: orm对象
@@ -449,21 +449,21 @@ class UserService:
if (page_object.user_id and page_object.role_id) or (page_object.user_ids and page_object.role_id):
if page_object.user_id and page_object.role_id:
try:
- UserDao.delete_user_role_by_user_and_role_dao(query_db, UserRoleModel(userId=page_object.user_id, roleId=page_object.role_id))
- query_db.commit()
+ await UserDao.delete_user_role_by_user_and_role_dao(query_db, UserRoleModel(userId=page_object.user_id, roleId=page_object.role_id))
+ await query_db.commit()
result = dict(is_success=True, message='删除成功')
except Exception as e:
- query_db.rollback()
+ await query_db.rollback()
raise e
elif page_object.user_ids and page_object.role_id:
user_id_list = page_object.user_ids.split(',')
try:
for user_id in user_id_list:
- UserDao.delete_user_role_by_user_and_role_dao(query_db, UserRoleModel(userId=user_id, roleId=page_object.role_id))
- query_db.commit()
+ await UserDao.delete_user_role_by_user_and_role_dao(query_db, UserRoleModel(userId=user_id, roleId=page_object.role_id))
+ await query_db.commit()
result = dict(is_success=True, message='删除成功')
except Exception as e:
- query_db.rollback()
+ await query_db.rollback()
raise e
else:
result = dict(is_success=False, message='不满足删除条件')
@@ -473,13 +473,13 @@ class UserService:
return CrudResponseModel(**result)
@classmethod
- def detail_user_role_services(cls, query_db: Session, page_object: UserRoleModel):
+ async def detail_user_role_services(cls, query_db: AsyncSession, page_object: UserRoleModel):
"""
获取用户关联角色详细信息service
:param query_db: orm对象
:param page_object: 用户关联角色对象
:return: 用户关联角色详细信息
"""
- user_role = UserDao.get_user_role_detail(query_db, page_object)
+ user_role = await UserDao.get_user_role_detail(query_db, page_object)
return user_role
diff --git a/ruoyi-fastapi-backend/requirements.txt b/ruoyi-fastapi-backend/requirements.txt
index 0e606a853cd8ad5d7913b20b04f5afee1274da0d..a0ee800e2cf4b23ce79adcb5456661a7e12468cb 100644
--- a/ruoyi-fastapi-backend/requirements.txt
+++ b/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
diff --git a/ruoyi-fastapi-backend/utils/common_util.py b/ruoyi-fastapi-backend/utils/common_util.py
index df9a6a54b6549fab1fb1e524313f17b634b6a851..1dd8c9370ab05d8ea7c97dc666a9b2f59c746a75 100644
--- a/ruoyi-fastapi-backend/utils/common_util.py
+++ b/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
diff --git a/ruoyi-fastapi-backend/utils/page_util.py b/ruoyi-fastapi-backend/utils/page_util.py
index cf2da9b0d224e163abaad82329cd3dccf172ddb8..d46d26042a7e1787ed520d86b55e71876f6a9c45 100644
--- a/ruoyi-fastapi-backend/utils/page_util.py
+++ b/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()
- paginated_data = query.offset((page_num - 1) * page_size).limit(page_size).all()
+ total = (await db.execute(select(func.count('*')).select_from(query.subquery()))).scalar()
+ 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
diff --git a/ruoyi-fastapi-frontend/package.json b/ruoyi-fastapi-frontend/package.json
index 437e611e0ab1965ac443e6dbea2fae4503cf501a..1268dee90ce6f63e25001567c63dad04ef60d2f4 100644
--- a/ruoyi-fastapi-frontend/package.json
+++ b/ruoyi-fastapi-frontend/package.json
@@ -1,6 +1,6 @@
{
"name": "vfadmin",
- "version": "1.1.3",
+ "version": "1.2.0",
"description": "vfadmin管理系统",
"author": "insistence",
"license": "MIT",