From 1972f1cb6dcb501851ea962f6af5d0aa937588ac Mon Sep 17 00:00:00 2001 From: insistence <3055204202@qq.com> Date: Fri, 17 May 2024 15:04:30 +0800 Subject: [PATCH 1/8] =?UTF-8?q?refactor:=20=E9=87=8D=E6=9E=84=E6=95=B0?= =?UTF-8?q?=E6=8D=AE=E5=BA=93orm=E4=B8=BA=E5=BC=82=E6=AD=A5=20#I9MRQS?= MIME-Version: 1.0 Content-Type: text/plain; charset=UTF-8 Content-Transfer-Encoding: 8bit --- ruoyi-fastapi-backend/config/database.py | 20 +- ruoyi-fastapi-backend/config/get_db.py | 13 +- ruoyi-fastapi-backend/config/get_redis.py | 14 +- ruoyi-fastapi-backend/config/get_scheduler.py | 40 +- .../module_admin/annotation/log_annotation.py | 4 +- .../module_admin/aspect/data_scope.py | 4 +- .../controller/cache_controller.py | 2 +- .../controller/captcha_controller.py | 2 +- .../controller/common_controller.py | 6 +- .../controller/config_controller.py | 22 +- .../controller/dept_controller.py | 24 +- .../controller/dict_controller.py | 48 +-- .../module_admin/controller/job_controller.py | 50 +-- .../module_admin/controller/log_controller.py | 36 +- .../controller/login_controller.py | 14 +- .../controller/menu_controller.py | 28 +- .../controller/notice_controller.py | 20 +- .../controller/online_controller.py | 4 +- .../module_admin/controller/post_controler.py | 26 +- .../controller/role_controller.py | 60 +-- .../controller/server_controller.py | 2 +- .../controller/user_controller.py | 68 ++-- .../module_admin/dao/config_dao.py | 66 ++-- .../module_admin/dao/dept_dao.py | 146 +++---- .../module_admin/dao/dict_dao.py | 149 ++++---- .../module_admin/dao/job_dao.py | 72 ++-- .../module_admin/dao/job_log_dao.py | 39 +- .../module_admin/dao/log_dao.py | 104 ++--- .../module_admin/dao/login_dao.py | 17 +- .../module_admin/dao/menu_dao.py | 126 +++--- .../module_admin/dao/notice_dao.py | 68 ++-- .../module_admin/dao/post_dao.py | 71 ++-- .../module_admin/dao/role_dao.py | 153 ++++---- .../module_admin/dao/user_dao.py | 361 ++++++++++-------- .../module_admin/service/cache_service.py | 3 +- .../module_admin/service/captcha_service.py | 2 +- .../module_admin/service/common_service.py | 6 +- .../module_admin/service/config_service.py | 46 +-- .../module_admin/service/dept_service.py | 97 ++--- .../module_admin/service/dict_service.py | 98 ++--- .../module_admin/service/job_log_service.py | 20 +- .../module_admin/service/job_service.py | 46 +-- .../module_admin/service/log_service.py | 58 +-- .../module_admin/service/login_service.py | 29 +- .../module_admin/service/menu_service.py | 48 +-- .../module_admin/service/notice_service.py | 38 +- .../module_admin/service/post_service.py | 40 +- .../module_admin/service/role_service.py | 86 ++--- .../module_admin/service/server_service.py | 2 +- .../module_admin/service/user_service.py | 136 +++---- ruoyi-fastapi-backend/requirements.txt | 2 +- ruoyi-fastapi-backend/utils/page_util.py | 24 +- 52 files changed, 1414 insertions(+), 1246 deletions(-) diff --git a/ruoyi-fastapi-backend/config/database.py b/ruoyi-fastapi-backend/config/database.py index cb871ec..512ae1b 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 6d3a9cf..9c12561 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 4c3ef80..aa78f4c 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 17e5ae5..ae4f932 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 e864391..fa7c1b3 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 3e03918..598170e 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/controller/cache_controller.py b/ruoyi-fastapi-backend/module_admin/controller/cache_controller.py index 7b7da4b..b33a287 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 4fc64b6..9d245cc 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 d298149..5744f70 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 e7a93d4..576d62c 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 efacd0d..741dd7e 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 0ccd472..fcf96eb 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 8b340ee..4186437 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: @@ -154,10 +154,10 @@ async def get_system_job_log_list(request: Request, job_log_page_query: JobLogPa @jobController.delete("/jobLog/{job_log_ids}", dependencies=[Depends(CheckUserInterfaceAuth('monitor:job:remove'))]) @log_decorator(title='定时任务日志管理', business_type=3) -async def delete_system_job_log(request: Request, job_log_ids: str, query_db: Session = Depends(get_db)): +async def delete_system_job_log(request: Request, job_log_ids: str, query_db: AsyncSession = Depends(get_db)): try: delete_job_log = DeleteJobLogModel(jobLogIds=job_log_ids) - delete_job_log_result = JobLogService.delete_job_log_services(query_db, delete_job_log) + delete_job_log_result = await JobLogService.delete_job_log_services(query_db, delete_job_log) if delete_job_log_result.is_success: logger.info(delete_job_log_result.message) return ResponseUtil.success(msg=delete_job_log_result.message) @@ -169,11 +169,11 @@ async def delete_system_job_log(request: Request, job_log_ids: str, query_db: Se return ResponseUtil.error(msg=str(e)) -@jobController.post("/jobLog/clean", dependencies=[Depends(CheckUserInterfaceAuth('monitor:job:remove'))]) +@jobController.delete("/jobLog/clean", dependencies=[Depends(CheckUserInterfaceAuth('monitor:job:remove'))]) @log_decorator(title='定时任务日志管理', business_type=9) -async def clear_system_job_log(request: Request, query_db: Session = Depends(get_db)): +async def clear_system_job_log(request: Request, query_db: AsyncSession = Depends(get_db)): try: - clear_job_log_result = JobLogService.clear_job_log_services(query_db) + clear_job_log_result = await JobLogService.clear_job_log_services(query_db) if clear_job_log_result.is_success: logger.info(clear_job_log_result.message) return ResponseUtil.success(msg=clear_job_log_result.message) @@ -187,10 +187,10 @@ async def clear_system_job_log(request: Request, query_db: Session = Depends(get @jobController.post("/jobLog/export", dependencies=[Depends(CheckUserInterfaceAuth('monitor:job:export'))]) @log_decorator(title='定时任务日志管理', business_type=5) -async def export_system_job_log_list(request: Request, job_log_page_query: JobLogPageQueryModel = Depends(JobLogPageQueryModel.as_form), query_db: Session = Depends(get_db)): +async def export_system_job_log_list(request: Request, job_log_page_query: JobLogPageQueryModel = Depends(JobLogPageQueryModel.as_form), query_db: AsyncSession = Depends(get_db)): try: # 获取全量数据 - job_log_query_result = JobLogService.get_job_log_list_services(query_db, job_log_page_query, is_page=False) + job_log_query_result = await JobLogService.get_job_log_list_services(query_db, job_log_page_query, is_page=False) job_log_export_result = await JobLogService.export_job_log_list_services(request, job_log_query_result) logger.info('导出成功') return ResponseUtil.streaming(data=bytes2file_response(job_log_export_result)) diff --git a/ruoyi-fastapi-backend/module_admin/controller/log_controller.py b/ruoyi-fastapi-backend/module_admin/controller/log_controller.py index 6b21358..a0a18c5 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 2b8b271..74b495c 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 53a534a..49d1db0 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 4caaa7a..1525727 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 cecee5f..747cc13 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 ebf41ea..046ec63 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 8138161..6b848c9 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 b089912..8d040ff 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 9385a6d..fc9f884 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 7a13a97..79304c2 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 05a70d0..c5169a5 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 3b7d127..fd98c95 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 0007b52..cfd6982 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 7139465..7bc8abe 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 b2abd54..7a39922 100644 --- a/ruoyi-fastapi-backend/module_admin/dao/log_dao.py +++ b/ruoyi-fastapi-backend/module_admin/dao/log_dao.py @@ -1,5 +1,5 @@ -from sqlalchemy import asc, desc -from sqlalchemy.orm import Session +from sqlalchemy import select, update, delete, asc, desc +from sqlalchemy.ext.asyncio import AsyncSession from module_admin.entity.do.log_do import SysOperLog, SysLogininfor from module_admin.entity.vo.log_vo import * from utils.page_util import PageUtil @@ -11,8 +11,9 @@ class OperationLogDao: """ 操作日志管理模块数据库操作层 """ + @classmethod - def get_operation_log_list(cls, db: Session, query_object: OperLogPageQueryModel, is_page: bool = False): + async def get_operation_log_list(cls, db: AsyncSession, query_object: OperLogPageQueryModel, is_page: bool = False): """ 根据查询参数获取操作日志列表信息 :param db: orm对象 @@ -23,26 +24,27 @@ class OperationLogDao: if query_object.is_asc == 'ascending': order_by_column = asc(getattr(SysOperLog, CamelCaseUtil.camel_to_snake(query_object.order_by_column), None)) elif query_object.is_asc == 'descending': - order_by_column = desc(getattr(SysOperLog, CamelCaseUtil.camel_to_snake(query_object.order_by_column), None)) + order_by_column = desc( + getattr(SysOperLog, CamelCaseUtil.camel_to_snake(query_object.order_by_column), None)) else: order_by_column = desc(SysOperLog.oper_time) - query = db.query(SysOperLog) \ - .filter(SysOperLog.title.like(f'%{query_object.title}%') if query_object.title else True, - SysOperLog.oper_name.like(f'%{query_object.oper_name}%') if query_object.oper_name else True, - SysOperLog.business_type == query_object.business_type if query_object.business_type else True, - SysOperLog.status == query_object.status if query_object.status else True, - SysOperLog.oper_time.between( - datetime.combine(datetime.strptime(query_object.begin_time, '%Y-%m-%d'), time(00, 00, 00)), - datetime.combine(datetime.strptime(query_object.end_time, '%Y-%m-%d'), time(23, 59, 59))) - if query_object.begin_time and query_object.end_time else True - )\ - .distinct().order_by(order_by_column) - operation_log_list = PageUtil.paginate(query, query_object.page_num, query_object.page_size, is_page) + query = select(SysOperLog) \ + .where(SysOperLog.title.like(f'%{query_object.title}%') if query_object.title else True, + SysOperLog.oper_name.like(f'%{query_object.oper_name}%') if query_object.oper_name else True, + SysOperLog.business_type == query_object.business_type if query_object.business_type else True, + SysOperLog.status == query_object.status if query_object.status else True, + SysOperLog.oper_time.between( + datetime.combine(datetime.strptime(query_object.begin_time, '%Y-%m-%d'), time(00, 00, 00)), + datetime.combine(datetime.strptime(query_object.end_time, '%Y-%m-%d'), time(23, 59, 59))) + if query_object.begin_time and query_object.end_time else True) \ + .distinct() \ + .order_by(order_by_column) + operation_log_list = await PageUtil.paginate(db, query, query_object.page_num, query_object.page_size, is_page) return operation_log_list @classmethod - def add_operation_log_dao(cls, db: Session, operation_log: OperLogModel): + async def add_operation_log_dao(cls, db: AsyncSession, operation_log: OperLogModel): """ 新增操作日志数据库操作 :param db: orm对象 @@ -51,31 +53,33 @@ class OperationLogDao: """ db_operation_log = SysOperLog(**operation_log.model_dump()) db.add(db_operation_log) - db.flush() + await db.flush() return db_operation_log @classmethod - def delete_operation_log_dao(cls, db: Session, operation_log: OperLogModel): + async def delete_operation_log_dao(cls, db: AsyncSession, operation_log: OperLogModel): """ 删除操作日志数据库操作 :param db: orm对象 :param operation_log: 操作日志对象 :return: """ - db.query(SysOperLog) \ - .filter(SysOperLog.oper_id == operation_log.oper_id) \ - .delete() + await db.execute( + delete(SysOperLog) + .where(SysOperLog.oper_id.in_([operation_log.oper_id])) + ) @classmethod - def clear_operation_log_dao(cls, db: Session): + async def clear_operation_log_dao(cls, db: AsyncSession): """ 清除操作日志数据库操作 :param db: orm对象 :return: """ - db.query(SysOperLog) \ - .delete() + await db.execute( + delete(SysOperLog) + ) class LoginLogDao: @@ -84,7 +88,7 @@ class LoginLogDao: """ @classmethod - def get_login_log_list(cls, db: Session, query_object: LoginLogPageQueryModel, is_page: bool = False): + async def get_login_log_list(cls, db: AsyncSession, query_object: LoginLogPageQueryModel, is_page: bool = False): """ 根据查询参数获取登录日志列表信息 :param db: orm对象 @@ -93,27 +97,29 @@ class LoginLogDao: :return: 登录日志列表信息对象 """ if query_object.is_asc == 'ascending': - order_by_column = asc(getattr(SysLogininfor, CamelCaseUtil.camel_to_snake(query_object.order_by_column), None)) + order_by_column = asc( + getattr(SysLogininfor, CamelCaseUtil.camel_to_snake(query_object.order_by_column), None)) elif query_object.is_asc == 'descending': - order_by_column = desc(getattr(SysLogininfor, CamelCaseUtil.camel_to_snake(query_object.order_by_column), None)) + order_by_column = desc( + getattr(SysLogininfor, CamelCaseUtil.camel_to_snake(query_object.order_by_column), None)) else: order_by_column = desc(SysLogininfor.login_time) - query = db.query(SysLogininfor) \ - .filter(SysLogininfor.ipaddr.like(f'%{query_object.ipaddr}%') if query_object.ipaddr else True, - SysLogininfor.user_name.like(f'%{query_object.user_name}%') if query_object.user_name else True, - SysLogininfor.status == query_object.status if query_object.status else True, - SysLogininfor.login_time.between( - datetime.combine(datetime.strptime(query_object.begin_time, '%Y-%m-%d'), time(00, 00, 00)), - datetime.combine(datetime.strptime(query_object.end_time, '%Y-%m-%d'), time(23, 59, 59))) - if query_object.begin_time and query_object.end_time else True - )\ - .distinct().order_by(order_by_column) - login_log_list = PageUtil.paginate(query, query_object.page_num, query_object.page_size, is_page) + query = select(SysLogininfor) \ + .where(SysLogininfor.ipaddr.like(f'%{query_object.ipaddr}%') if query_object.ipaddr else True, + SysLogininfor.user_name.like(f'%{query_object.user_name}%') if query_object.user_name else True, + SysLogininfor.status == query_object.status if query_object.status else True, + SysLogininfor.login_time.between( + datetime.combine(datetime.strptime(query_object.begin_time, '%Y-%m-%d'), time(00, 00, 00)), + datetime.combine(datetime.strptime(query_object.end_time, '%Y-%m-%d'), time(23, 59, 59))) + if query_object.begin_time and query_object.end_time else True) \ + .distinct() \ + .order_by(order_by_column) + login_log_list = await PageUtil.paginate(db, query, query_object.page_num, query_object.page_size, is_page) return login_log_list @classmethod - def add_login_log_dao(cls, db: Session, login_log: LogininforModel): + async def add_login_log_dao(cls, db: AsyncSession, login_log: LogininforModel): """ 新增登录日志数据库操作 :param db: orm对象 @@ -122,28 +128,30 @@ class LoginLogDao: """ db_login_log = SysLogininfor(**login_log.model_dump()) db.add(db_login_log) - db.flush() + await db.flush() return db_login_log @classmethod - def delete_login_log_dao(cls, db: Session, login_log: LogininforModel): + async def delete_login_log_dao(cls, db: AsyncSession, login_log: LogininforModel): """ 删除登录日志数据库操作 :param db: orm对象 :param login_log: 登录日志对象 :return: """ - db.query(SysLogininfor) \ - .filter(SysLogininfor.info_id == login_log.info_id) \ - .delete() + await db.execute( + delete(SysLogininfor) + .where(SysLogininfor.info_id.in_([login_log.info_id])) + ) @classmethod - def clear_login_log_dao(cls, db: Session): + async def clear_login_log_dao(cls, db: AsyncSession): """ 清除登录日志数据库操作 :param db: orm对象 :return: """ - db.query(SysLogininfor) \ - .delete() + await db.execute( + delete(SysLogininfor) + ) diff --git a/ruoyi-fastapi-backend/module_admin/dao/login_dao.py b/ruoyi-fastapi-backend/module_admin/dao/login_dao.py index b932bc1..2c80c7f 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 272529b..7f8545b 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 79f32a3..fd1846f 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 2cb7f89..d485d38 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 32267da..9c43550 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 20e2879..d73c6f0 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 d021ef4..960b9cd 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 b685f06..85b0912 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 7c8399d..883f18c 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 1ab439b..e470060 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 2c9db67..5d67412 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 29dae05..efcd3b7 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 7de9d05..99d2231 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 b2e2dcc..ca3de4d 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 cbbb94e..4e15d2c 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 5229c05..5ae6974 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 10a295d..5f89c90 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 1ca63a8..573fc39 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 d6b097f..13882ab 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 c09c11f..745d3db 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 760823b..da6e2a2 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 9f8f1e3..7852f60 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) + await UserDao.edit_user_dao(query_db, edit_user) if page_object.type != 'status' and page_object.type != 'avatar': - UserDao.delete_user_role_dao(query_db, UserRoleModel(userId=page_object.user_id)) - UserDao.delete_user_post_dao(query_db, UserPostModel(userId=page_object.user_id)) + await UserDao.delete_user_role_dao(query_db, UserRoleModel(userId=page_object.user_id)) + await UserDao.delete_user_post_dao(query_db, UserPostModel(userId=page_object.user_id)) if page_object.role_ids: for role in page_object.role_ids: - UserDao.add_user_role_dao(query_db, UserRoleModel(userId=page_object.user_id, roleId=role)) + await UserDao.add_user_role_dao(query_db, UserRoleModel(userId=page_object.user_id, roleId=role)) if page_object.post_ids: for post in page_object.post_ids: - UserDao.add_user_post_dao(query_db, UserPostModel(userId=page_object.user_id, postId=post)) - query_db.commit() + await UserDao.add_user_post_dao(query_db, UserPostModel(userId=page_object.user_id, postId=post)) + await query_db.commit() result = dict(is_success=True, message='更新成功') except Exception as e: - query_db.rollback() + await query_db.rollback() raise e else: result = dict(is_success=False, message='用户不存在') @@ -112,7 +112,7 @@ class UserService: return CrudResponseModel(**result) @classmethod - def delete_user_services(cls, query_db: Session, page_object: DeleteUserModel): + async def delete_user_services(cls, query_db: AsyncSession, page_object: DeleteUserModel): """ 删除用户信息service :param query_db: orm对象 @@ -124,30 +124,30 @@ class UserService: try: for user_id in user_id_list: user_id_dict = dict(userId=user_id, updateBy=page_object.update_by, updateTime=page_object.update_time) - UserDao.delete_user_role_dao(query_db, UserRoleModel(**user_id_dict)) - UserDao.delete_user_post_dao(query_db, UserPostModel(**user_id_dict)) - UserDao.delete_user_dao(query_db, UserModel(**user_id_dict)) - query_db.commit() + await UserDao.delete_user_role_dao(query_db, UserRoleModel(**user_id_dict)) + await UserDao.delete_user_post_dao(query_db, UserPostModel(**user_id_dict)) + await UserDao.delete_user_dao(query_db, UserModel(**user_id_dict)) + await query_db.commit() result = dict(is_success=True, message='删除成功') except Exception as e: - query_db.rollback() + await query_db.rollback() raise e else: result = dict(is_success=False, message='传入用户id为空') return CrudResponseModel(**result) @classmethod - def user_detail_services(cls, query_db: Session, user_id: Union[int, str]): + async def user_detail_services(cls, query_db: AsyncSession, user_id: Union[int, str]): """ 获取用户详细信息service :param query_db: orm对象 :param user_id: 用户id :return: 用户id对应的信息 """ - posts = PostService.get_post_list_services(query_db, PostPageQueryModel(**{}), is_page=False) - roles = RoleService.get_role_select_option_services(query_db) + posts = await PostService.get_post_list_services(query_db, PostPageQueryModel(**{}), is_page=False) + roles = await RoleService.get_role_select_option_services(query_db) if user_id != '': - query_user = UserDao.get_user_detail_by_id(query_db, user_id=user_id) + query_user = await UserDao.get_user_detail_by_id(query_db, user_id=user_id) post_ids = ','.join([str(row.post_id) for row in query_user.get('user_post_info')]) post_ids_list = [row.post_id for row in query_user.get('user_post_info')] role_ids = ','.join([str(row.role_id) for row in query_user.get('user_role_info')]) @@ -173,14 +173,14 @@ class UserService: ) @classmethod - def user_profile_services(cls, query_db: Session, user_id: int): + async def user_profile_services(cls, query_db: AsyncSession, user_id: int): """ 获取用户详细信息service :param query_db: orm对象 :param user_id: 用户id :return: 用户id对应的信息 """ - query_user = UserDao.get_user_detail_by_id(query_db, user_id=user_id) + query_user = await UserDao.get_user_detail_by_id(query_db, user_id=user_id) post_ids = ','.join([str(row.post_id) for row in query_user.get('user_post_info')]) post_group = ','.join([row.post_name for row in query_user.get('user_post_info')]) role_ids = ','.join([str(row.role_id) for row in query_user.get('user_role_info')]) @@ -199,7 +199,7 @@ class UserService: ) @classmethod - def reset_user_services(cls, query_db: Session, page_object: ResetUserModel): + async def reset_user_services(cls, query_db: AsyncSession, page_object: ResetUserModel): """ 重置用户密码service :param query_db: orm对象 @@ -208,7 +208,7 @@ class UserService: """ reset_user = page_object.model_dump(exclude_unset=True, exclude={'admin'}) if page_object.old_password: - user = UserDao.get_user_detail_by_id(query_db, user_id=page_object.user_id).get('user_basic_info') + user = (await UserDao.get_user_detail_by_id(query_db, user_id=page_object.user_id)).get('user_basic_info') if not PwdUtil.verify_password(page_object.old_password, user.password): result = dict(is_success=False, message='旧密码不正确') return CrudResponseModel(**result) @@ -218,17 +218,17 @@ class UserService: del reset_user['sms_code'] del reset_user['session_id'] try: - UserDao.edit_user_dao(query_db, reset_user) - query_db.commit() + await UserDao.edit_user_dao(query_db, reset_user) + await query_db.commit() result = dict(is_success=True, message='重置成功') except Exception as e: - query_db.rollback() + await query_db.rollback() raise e return CrudResponseModel(**result) @classmethod - async def batch_import_user_services(cls, query_db: Session, file: UploadFile, update_support: bool, current_user: CurrentUserModel): + async def batch_import_user_services(cls, query_db: AsyncSession, file: UploadFile, update_support: bool, current_user: CurrentUserModel): """ 批量导入用户service :param query_db: orm对象 @@ -277,7 +277,7 @@ class UserService: createBy=current_user.user.user_name, updateBy=current_user.user.user_name ) - user_info = UserDao.get_user_by_info(query_db, UserModel(userName=row['user_name'])) + user_info = await UserDao.get_user_by_info(query_db, UserModel(userName=row['user_name'])) if user_info: if update_support: edit_user = UserModel( @@ -291,21 +291,21 @@ class UserService: status=row['status'], updateBy=current_user.user.user_name ).model_dump(exclude_unset=True) - UserDao.edit_user_dao(query_db, edit_user) + await UserDao.edit_user_dao(query_db, edit_user) else: add_error_result.append(f"{count}.用户账号{row['user_name']}已存在") else: - UserDao.add_user_dao(query_db, add_user) - query_db.commit() + await UserDao.add_user_dao(query_db, add_user) + await query_db.commit() result = dict(is_success=True, message='\n'.join(add_error_result)) except Exception as e: - query_db.rollback() + await query_db.rollback() raise e return CrudResponseModel(**result) @staticmethod - def get_user_import_template_services(): + async def get_user_import_template_services(): """ 获取用户导入模板service :return: 用户导入模板excel的二进制数据 @@ -318,7 +318,7 @@ class UserService: return binary_data @staticmethod - def export_user_list_services(user_list: List): + async def export_user_list_services(user_list: List): """ 导出用户信息service :param user_list: 用户信息列表 @@ -360,14 +360,14 @@ class UserService: return binary_data @classmethod - def get_user_role_allocated_list_services(cls, query_db: Session, page_object: UserRoleQueryModel): + async def get_user_role_allocated_list_services(cls, query_db: AsyncSession, page_object: UserRoleQueryModel): """ 根据用户id获取已分配角色列表 :param query_db: orm对象 :param page_object: 用户关联角色对象 :return: 已分配角色列表 """ - query_user = UserDao.get_user_detail_by_id(query_db, page_object.user_id) + query_user = await UserDao.get_user_detail_by_id(query_db, page_object.user_id) post_ids = ','.join([str(row.post_id) for row in query_user.get('user_post_info')]) role_ids = ','.join([str(row.role_id) for row in query_user.get('user_role_info')]) user = UserInfoModel( @@ -377,7 +377,7 @@ class UserService: dept=CamelCaseUtil.transform_result(query_user.get('user_dept_info')), role=CamelCaseUtil.transform_result(query_user.get('user_role_info')) ) - query_role_list = [SelectedRoleModel(**row) for row in RoleService.get_role_select_option_services(query_db)] + query_role_list = [SelectedRoleModel(**row) for row in await RoleService.get_role_select_option_services(query_db)] for model_a in query_role_list: for model_b in user.role: if model_a.role_id == model_b.role_id: @@ -390,7 +390,7 @@ class UserService: return result @classmethod - def add_user_role_services(cls, query_db: Session, page_object: CrudUserRoleModel): + async def add_user_role_services(cls, query_db: AsyncSession, page_object: CrudUserRoleModel): """ 新增用户关联角色信息service :param query_db: orm对象 @@ -401,37 +401,37 @@ class UserService: role_id_list = page_object.role_ids.split(',') try: for role_id in role_id_list: - user_role = cls.detail_user_role_services(query_db, UserRoleModel(userId=page_object.user_id, roleId=role_id)) + user_role = await cls.detail_user_role_services(query_db, UserRoleModel(userId=page_object.user_id, roleId=role_id)) if user_role: continue else: - UserDao.add_user_role_dao(query_db, UserRoleModel(userId=page_object.user_id, roleId=role_id)) - query_db.commit() + await UserDao.add_user_role_dao(query_db, UserRoleModel(userId=page_object.user_id, roleId=role_id)) + await query_db.commit() result = dict(is_success=True, message='分配成功') except Exception as e: - query_db.rollback() + await query_db.rollback() raise e elif page_object.user_id and not page_object.role_ids: try: - UserDao.delete_user_role_by_user_and_role_dao(query_db, UserRoleModel(userId=page_object.user_id)) - query_db.commit() + await UserDao.delete_user_role_by_user_and_role_dao(query_db, UserRoleModel(userId=page_object.user_id)) + await query_db.commit() result = dict(is_success=True, message='分配成功') except Exception as e: - query_db.rollback() + await query_db.rollback() raise e elif page_object.user_ids and page_object.role_id: user_id_list = page_object.user_ids.split(',') try: for user_id in user_id_list: - user_role = cls.detail_user_role_services(query_db, UserRoleModel(userId=user_id, roleId=page_object.role_id)) + user_role = await cls.detail_user_role_services(query_db, UserRoleModel(userId=user_id, roleId=page_object.role_id)) if user_role: continue else: - UserDao.add_user_role_dao(query_db, UserRoleModel(userId=user_id, roleId=page_object.role_id)) - query_db.commit() + await UserDao.add_user_role_dao(query_db, UserRoleModel(userId=user_id, roleId=page_object.role_id)) + await query_db.commit() result = dict(is_success=True, message='新增成功') except Exception as e: - query_db.rollback() + await query_db.rollback() raise e else: result = dict(is_success=False, message='不满足新增条件') @@ -439,7 +439,7 @@ class UserService: return CrudResponseModel(**result) @classmethod - def delete_user_role_services(cls, query_db: Session, page_object: CrudUserRoleModel): + async def delete_user_role_services(cls, query_db: AsyncSession, page_object: CrudUserRoleModel): """ 删除用户关联角色信息service :param query_db: orm对象 @@ -449,21 +449,21 @@ class UserService: if (page_object.user_id and page_object.role_id) or (page_object.user_ids and page_object.role_id): if page_object.user_id and page_object.role_id: try: - UserDao.delete_user_role_by_user_and_role_dao(query_db, UserRoleModel(userId=page_object.user_id, roleId=page_object.role_id)) - query_db.commit() + await UserDao.delete_user_role_by_user_and_role_dao(query_db, UserRoleModel(userId=page_object.user_id, roleId=page_object.role_id)) + await query_db.commit() result = dict(is_success=True, message='删除成功') except Exception as e: - query_db.rollback() + await query_db.rollback() raise e elif page_object.user_ids and page_object.role_id: user_id_list = page_object.user_ids.split(',') try: for user_id in user_id_list: - UserDao.delete_user_role_by_user_and_role_dao(query_db, UserRoleModel(userId=user_id, roleId=page_object.role_id)) - query_db.commit() + await UserDao.delete_user_role_by_user_and_role_dao(query_db, UserRoleModel(userId=user_id, roleId=page_object.role_id)) + await query_db.commit() result = dict(is_success=True, message='删除成功') except Exception as e: - query_db.rollback() + await query_db.rollback() raise e else: result = dict(is_success=False, message='不满足删除条件') @@ -473,13 +473,13 @@ class UserService: return CrudResponseModel(**result) @classmethod - def detail_user_role_services(cls, query_db: Session, page_object: UserRoleModel): + async def detail_user_role_services(cls, query_db: AsyncSession, page_object: UserRoleModel): """ 获取用户关联角色详细信息service :param query_db: orm对象 :param page_object: 用户关联角色对象 :return: 用户关联角色详细信息 """ - user_role = UserDao.get_user_role_detail(query_db, page_object) + user_role = await UserDao.get_user_role_detail(query_db, page_object) return user_role diff --git a/ruoyi-fastapi-backend/requirements.txt b/ruoyi-fastapi-backend/requirements.txt index 0e606a8..7b52357 100644 --- a/ruoyi-fastapi-backend/requirements.txt +++ b/ruoyi-fastapi-backend/requirements.txt @@ -11,5 +11,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/page_util.py b/ruoyi-fastapi-backend/utils/page_util.py index cf2da9b..d46d260 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 -- Gitee From ef39f5aa1ed7d30691cedd93f6db188f4046ed7c Mon Sep 17 00:00:00 2001 From: insistence <3055204202@qq.com> Date: Fri, 17 May 2024 15:05:34 +0800 Subject: [PATCH 2/8] =?UTF-8?q?fix:=20=E4=BF=AE=E5=A4=8D=E7=94=A8=E6=88=B7?= =?UTF-8?q?=E7=AE=A1=E7=90=86=E6=A8=A1=E5=9D=97=E9=87=8D=E7=BD=AE=E7=94=A8?= =?UTF-8?q?=E6=88=B7=E5=AF=86=E7=A0=81=E6=97=B6=E4=BC=9A=E5=BC=82=E5=B8=B8?= =?UTF-8?q?=E9=87=8D=E7=BD=AE=E7=94=A8=E6=88=B7=E5=B2=97=E4=BD=8D=E5=92=8C?= =?UTF-8?q?=E8=A7=92=E8=89=B2=E7=9A=84=E9=97=AE=E9=A2=98?= MIME-Version: 1.0 Content-Type: text/plain; charset=UTF-8 Content-Transfer-Encoding: 8bit --- ruoyi-fastapi-backend/module_admin/service/user_service.py | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/ruoyi-fastapi-backend/module_admin/service/user_service.py b/ruoyi-fastapi-backend/module_admin/service/user_service.py index 7852f60..40ff531 100644 --- a/ruoyi-fastapi-backend/module_admin/service/user_service.py +++ b/ruoyi-fastapi-backend/module_admin/service/user_service.py @@ -92,7 +92,7 @@ class UserService: return CrudResponseModel(**result) try: await UserDao.edit_user_dao(query_db, edit_user) - if page_object.type != 'status' and page_object.type != 'avatar': + if page_object.type != 'status' and page_object.type != 'avatar' and page_object.type != 'pwd': 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: -- Gitee From 3b13237ad614d6422932d35ba33f052c5764cf59 Mon Sep 17 00:00:00 2001 From: insistence <3055204202@qq.com> Date: Fri, 17 May 2024 15:07:17 +0800 Subject: [PATCH 3/8] =?UTF-8?q?fix:=20=E4=BF=AE=E5=A4=8D=E6=B8=85=E7=A9=BA?= =?UTF-8?q?=E5=AE=9A=E6=97=B6=E4=BB=BB=E5=8A=A1=E6=97=A5=E5=BF=97=E5=BC=82?= =?UTF-8?q?=E5=B8=B8=E7=9A=84=E9=97=AE=E9=A2=98?= MIME-Version: 1.0 Content-Type: text/plain; charset=UTF-8 Content-Transfer-Encoding: 8bit --- .../module_admin/controller/job_controller.py | 32 +++++++++---------- 1 file changed, 16 insertions(+), 16 deletions(-) diff --git a/ruoyi-fastapi-backend/module_admin/controller/job_controller.py b/ruoyi-fastapi-backend/module_admin/controller/job_controller.py index 4186437..2204722 100644 --- a/ruoyi-fastapi-backend/module_admin/controller/job_controller.py +++ b/ruoyi-fastapi-backend/module_admin/controller/job_controller.py @@ -152,6 +152,22 @@ 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: AsyncSession = Depends(get_db)): @@ -169,22 +185,6 @@ async def delete_system_job_log(request: Request, job_log_ids: str, query_db: As 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.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: AsyncSession = Depends(get_db)): -- Gitee From 5319327c370635934fb6fd191e4b9fb8b6e49e12 Mon Sep 17 00:00:00 2001 From: insistence <3055204202@qq.com> Date: Fri, 17 May 2024 15:11:14 +0800 Subject: [PATCH 4/8] =?UTF-8?q?chore:=20=E5=A2=9E=E5=8A=A0asyncmy=E4=BE=9D?= =?UTF-8?q?=E8=B5=96=E7=94=A8=E4=BA=8E=E6=94=AF=E6=8C=81orm=E5=BC=82?= =?UTF-8?q?=E6=AD=A5=E6=93=8D=E4=BD=9Cmysql?= MIME-Version: 1.0 Content-Type: text/plain; charset=UTF-8 Content-Transfer-Encoding: 8bit --- ruoyi-fastapi-backend/requirements.txt | 1 + 1 file changed, 1 insertion(+) diff --git a/ruoyi-fastapi-backend/requirements.txt b/ruoyi-fastapi-backend/requirements.txt index 7b52357..a0ee800 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 -- Gitee From 4b13e492fc0283a5309ea37f20dcf12eefc4d2e3 Mon Sep 17 00:00:00 2001 From: insistence <3055204202@qq.com> Date: Fri, 17 May 2024 15:16:59 +0800 Subject: [PATCH 5/8] =?UTF-8?q?style:=20=E4=BF=AE=E5=A4=8D.env.prod?= =?UTF-8?q?=E6=96=87=E4=BB=B6=E4=B9=A6=E5=86=99=E9=94=99=E8=AF=AF?= MIME-Version: 1.0 Content-Type: text/plain; charset=UTF-8 Content-Transfer-Encoding: 8bit --- ruoyi-fastapi-backend/.env.prod | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/ruoyi-fastapi-backend/.env.prod b/ruoyi-fastapi-backend/.env.prod index 193077d..b9132b5 100644 --- a/ruoyi-fastapi-backend/.env.prod +++ b/ruoyi-fastapi-backend/.env.prod @@ -16,7 +16,7 @@ APP_RELOAD = false # 应用是否开启IP归属区域查询 APP_IP_LOCATION_QUERY = true # 应用是否允许账号同时登录 -APP_SAMETIME_LOGIN = true +APP_SAME_TIME_LOGIN = true # -------- Jwt配置 -------- # Jwt秘钥 -- Gitee From 8b3d04ca062ebbdca2d93a49687a51b771a6c94e Mon Sep 17 00:00:00 2001 From: insistence <3055204202@qq.com> Date: Fri, 17 May 2024 15:59:12 +0800 Subject: [PATCH 6/8] =?UTF-8?q?feat:=20=E6=96=B0=E5=A2=9ESnakeCaseUtil?= =?UTF-8?q?=E5=B7=A5=E5=85=B7=E7=B1=BB=EF=BC=8C=E5=B0=86=E5=8E=9FCamelCase?= =?UTF-8?q?Util=E5=B7=A5=E5=85=B7=E7=B1=BB=E7=9A=84camel=5Fto=5Fsnake?= =?UTF-8?q?=E5=87=BD=E6=95=B0=E8=BF=81=E7=A7=BB=E8=87=B3SnakeCaseUtil?= =?UTF-8?q?=E5=B7=A5=E5=85=B7=E7=B1=BB?= MIME-Version: 1.0 Content-Type: text/plain; charset=UTF-8 Content-Transfer-Encoding: 8bit --- .../module_admin/dao/log_dao.py | 10 ++-- ruoyi-fastapi-backend/utils/common_util.py | 51 ++++++++++++++----- 2 files changed, 44 insertions(+), 17 deletions(-) diff --git a/ruoyi-fastapi-backend/module_admin/dao/log_dao.py b/ruoyi-fastapi-backend/module_admin/dao/log_dao.py index 7a39922..5161bea 100644 --- a/ruoyi-fastapi-backend/module_admin/dao/log_dao.py +++ b/ruoyi-fastapi-backend/module_admin/dao/log_dao.py @@ -3,7 +3,7 @@ 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 @@ -22,10 +22,10 @@ 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)) + getattr(SysOperLog, SnakeCaseUtil.camel_to_snake(query_object.order_by_column), None)) else: order_by_column = desc(SysOperLog.oper_time) query = select(SysOperLog) \ @@ -98,10 +98,10 @@ class LoginLogDao: """ if query_object.is_asc == 'ascending': order_by_column = asc( - getattr(SysLogininfor, CamelCaseUtil.camel_to_snake(query_object.order_by_column), None)) + 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)) + getattr(SysLogininfor, SnakeCaseUtil.camel_to_snake(query_object.order_by_column), None)) else: order_by_column = desc(SysLogininfor.login_time) query = select(SysLogininfor) \ diff --git a/ruoyi-fastapi-backend/utils/common_util.py b/ruoyi-fastapi-backend/utils/common_util.py index df9a6a5..1dd8c93 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 -- Gitee From 6064535c22465e736ac6179742d630c19eb3e695 Mon Sep 17 00:00:00 2001 From: insistence <3055204202@qq.com> Date: Fri, 17 May 2024 16:03:40 +0800 Subject: [PATCH 7/8] =?UTF-8?q?chore:=20=E5=8D=87=E7=BA=A7=E7=89=88?= =?UTF-8?q?=E6=9C=AC=E8=87=B31.2.0?= MIME-Version: 1.0 Content-Type: text/plain; charset=UTF-8 Content-Transfer-Encoding: 8bit --- ruoyi-fastapi-backend/.env.dev | 2 +- ruoyi-fastapi-backend/.env.prod | 2 +- ruoyi-fastapi-frontend/package.json | 2 +- 3 files changed, 3 insertions(+), 3 deletions(-) diff --git a/ruoyi-fastapi-backend/.env.dev b/ruoyi-fastapi-backend/.env.dev index e3916a8..f982a6c 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 b9132b5..c651f43 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-frontend/package.json b/ruoyi-fastapi-frontend/package.json index 733e362..d0e0a6a 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", -- Gitee From b1e3fcdc3011f9d17ed1b1a0ad8a88f999ddb421 Mon Sep 17 00:00:00 2001 From: insistence <3055204202@qq.com> Date: Fri, 17 May 2024 16:04:06 +0800 Subject: [PATCH 8/8] =?UTF-8?q?docs:=20=E6=9B=B4=E6=96=B0README=E6=96=87?= =?UTF-8?q?=E6=A1=A3?= MIME-Version: 1.0 Content-Type: text/plain; charset=UTF-8 Content-Transfer-Encoding: 8bit --- README.md | 5 ++--- 1 file changed, 2 insertions(+), 3 deletions(-) diff --git a/README.md b/README.md index 680011f..14975b2 100644 --- a/README.md +++ b/README.md @@ -1,12 +1,12 @@

logo

-

RuoYi-Vue3-FastAPI v1.1.3

+

RuoYi-Vue3-FastAPI v1.2.0

基于RuoYi-Vue3+FastAPI前后端分离的快速开发框架

- + @@ -18,7 +18,6 @@ - ## 平台简介 RuoYi-Vue3-FastAPI是一套全部开源的快速开发平台，毫无保留给个人及企业免费使用。 -- Gitee