From 184982eb08a13558ecd82750fadc2f45d7728d3d Mon Sep 17 00:00:00 2001 From: insistence <3055204202@qq.com> Date: Thu, 11 Dec 2025 16:59:18 +0800 Subject: [PATCH] =?UTF-8?q?perf:=20controller=E5=B1=82=E5=85=A8=E9=83=A8?= =?UTF-8?q?=E4=BD=BF=E7=94=A8=E6=96=B0=E4=BE=9D=E8=B5=96=E9=A1=B9?= MIME-Version: 1.0 Content-Type: text/plain; charset=UTF-8 Content-Transfer-Encoding: 8bit --- .../controller/cache_controller.py | 29 +-- .../controller/common_controller.py | 6 +- .../controller/config_controller.py | 61 ++++--- .../controller/dept_controller.py | 67 ++++--- .../controller/dict_controller.py | 107 ++++++++---- .../module_admin/controller/job_controller.py | 97 ++++++---- .../module_admin/controller/log_controller.py | 67 ++++--- .../controller/login_controller.py | 17 +- .../controller/menu_controller.py | 57 +++--- .../controller/notice_controller.py | 47 +++-- .../controller/online_controller.py | 21 ++- .../controller/post_controller.py | 54 ++++-- .../controller/role_controller.py | 138 +++++++++------ .../controller/server_controller.py | 12 +- .../controller/user_controller.py | 165 +++++++++++------- .../controller/gen_controller.py | 91 ++++++---- .../templates/python/controller.py.jinja2 | 50 ++++-- 17 files changed, 687 insertions(+), 399 deletions(-) diff --git a/ruoyi-fastapi-backend/module_admin/controller/cache_controller.py b/ruoyi-fastapi-backend/module_admin/controller/cache_controller.py index a5ff8ca..40b2684 100644 --- a/ruoyi-fastapi-backend/module_admin/controller/cache_controller.py +++ b/ruoyi-fastapi-backend/module_admin/controller/cache_controller.py @@ -1,19 +1,21 @@ from typing import Annotated -from fastapi import APIRouter, Depends, Path, Request, Response +from fastapi import APIRouter, Path, Request, Response -from common.aspect.interface_auth import CheckUserInterfaceAuth +from common.aspect.interface_auth import UserInterfaceAuthDependency +from common.aspect.pre_auth import PreAuthDependency from module_admin.entity.vo.cache_vo import CacheInfoModel, CacheMonitorModel from module_admin.service.cache_service import CacheService -from module_admin.service.login_service import LoginService from utils.log_util import logger from utils.response_util import ResponseUtil -cache_controller = APIRouter(prefix='/monitor/cache', dependencies=[Depends(LoginService.get_current_user)]) +cache_controller = APIRouter(prefix='/monitor/cache', dependencies=[PreAuthDependency()]) @cache_controller.get( - '', response_model=CacheMonitorModel, dependencies=[Depends(CheckUserInterfaceAuth('monitor:cache:list'))] + '', + response_model=CacheMonitorModel, + dependencies=[UserInterfaceAuthDependency('monitor:cache:list')], ) async def get_monitor_cache_info(request: Request) -> Response: # 获取全量数据 @@ -26,7 +28,7 @@ async def get_monitor_cache_info(request: Request) -> Response: @cache_controller.get( '/getNames', response_model=list[CacheInfoModel], - dependencies=[Depends(CheckUserInterfaceAuth('monitor:cache:list'))], + dependencies=[UserInterfaceAuthDependency('monitor:cache:list')], ) async def get_monitor_cache_name(request: Request) -> Response: # 获取全量数据 @@ -39,7 +41,7 @@ async def get_monitor_cache_name(request: Request) -> Response: @cache_controller.get( '/getKeys/{cache_name}', response_model=list[str], - dependencies=[Depends(CheckUserInterfaceAuth('monitor:cache:list'))], + dependencies=[UserInterfaceAuthDependency('monitor:cache:list')], ) async def get_monitor_cache_key(request: Request, cache_name: Annotated[str, Path(description='缓存名称')]) -> Response: # 获取全量数据 @@ -52,7 +54,7 @@ async def get_monitor_cache_key(request: Request, cache_name: Annotated[str, Pat @cache_controller.get( '/getValue/{cache_name}/{cache_key}', response_model=CacheInfoModel, - dependencies=[Depends(CheckUserInterfaceAuth('monitor:cache:list'))], + dependencies=[UserInterfaceAuthDependency('monitor:cache:list')], ) async def get_monitor_cache_value( request: Request, @@ -67,7 +69,8 @@ async def get_monitor_cache_value( @cache_controller.delete( - '/clearCacheName/{cache_name}', dependencies=[Depends(CheckUserInterfaceAuth('monitor:cache:list'))] + '/clearCacheName/{cache_name}', + dependencies=[UserInterfaceAuthDependency('monitor:cache:list')], ) async def clear_monitor_cache_name( request: Request, cache_name: Annotated[str, Path(description='缓存名称')] @@ -79,7 +82,8 @@ async def clear_monitor_cache_name( @cache_controller.delete( - '/clearCacheKey/{cache_key}', dependencies=[Depends(CheckUserInterfaceAuth('monitor:cache:list'))] + '/clearCacheKey/{cache_key}', + dependencies=[UserInterfaceAuthDependency('monitor:cache:list')], ) async def clear_monitor_cache_key(request: Request, cache_key: Annotated[str, Path(description='缓存键')]) -> Response: clear_cache_key_result = await CacheService.clear_cache_monitor_cache_key_services(request, cache_key) @@ -88,7 +92,10 @@ async def clear_monitor_cache_key(request: Request, cache_key: Annotated[str, Pa return ResponseUtil.success(msg=clear_cache_key_result.message) -@cache_controller.delete('/clearCacheAll', dependencies=[Depends(CheckUserInterfaceAuth('monitor:cache:list'))]) +@cache_controller.delete( + '/clearCacheAll', + dependencies=[UserInterfaceAuthDependency('monitor:cache:list')], +) async def clear_monitor_cache_all(request: Request) -> Response: clear_cache_all_result = await CacheService.clear_cache_monitor_all_services(request) logger.info(clear_cache_all_result.message) diff --git a/ruoyi-fastapi-backend/module_admin/controller/common_controller.py b/ruoyi-fastapi-backend/module_admin/controller/common_controller.py index 714ecbd..9d37c8f 100644 --- a/ruoyi-fastapi-backend/module_admin/controller/common_controller.py +++ b/ruoyi-fastapi-backend/module_admin/controller/common_controller.py @@ -1,13 +1,13 @@ from typing import Annotated -from fastapi import APIRouter, BackgroundTasks, Depends, File, Query, Request, Response, UploadFile +from fastapi import APIRouter, BackgroundTasks, File, Query, Request, Response, UploadFile +from common.aspect.pre_auth import PreAuthDependency from module_admin.service.common_service import CommonService -from module_admin.service.login_service import LoginService from utils.log_util import logger from utils.response_util import ResponseUtil -common_controller = APIRouter(prefix='/common', dependencies=[Depends(LoginService.get_current_user)]) +common_controller = APIRouter(prefix='/common', dependencies=[PreAuthDependency()]) @common_controller.post('/upload') diff --git a/ruoyi-fastapi-backend/module_admin/controller/config_controller.py b/ruoyi-fastapi-backend/module_admin/controller/config_controller.py index ac8c811..e216269 100644 --- a/ruoyi-fastapi-backend/module_admin/controller/config_controller.py +++ b/ruoyi-fastapi-backend/module_admin/controller/config_controller.py @@ -1,33 +1,35 @@ from datetime import datetime from typing import Annotated -from fastapi import APIRouter, Depends, Form, Path, Query, Request, Response +from fastapi import APIRouter, Form, Path, Query, Request, Response from pydantic_validation_decorator import ValidateFields from sqlalchemy.ext.asyncio import AsyncSession from common.annotation.log_annotation import Log -from common.aspect.interface_auth import CheckUserInterfaceAuth +from common.aspect.db_seesion import DBSessionDependency +from common.aspect.interface_auth import UserInterfaceAuthDependency +from common.aspect.pre_auth import CurrentUserDependency, PreAuthDependency from common.enums import BusinessType -from config.get_db import get_db from module_admin.entity.vo.config_vo import ConfigModel, ConfigPageQueryModel, DeleteConfigModel from module_admin.entity.vo.user_vo import CurrentUserModel from module_admin.service.config_service import ConfigService -from module_admin.service.login_service import LoginService from utils.common_util import bytes2file_response from utils.log_util import logger from utils.page_util import PageResponseModel from utils.response_util import ResponseUtil -config_controller = APIRouter(prefix='/system/config', dependencies=[Depends(LoginService.get_current_user)]) +config_controller = APIRouter(prefix='/system/config', dependencies=[PreAuthDependency()]) @config_controller.get( - '/list', response_model=PageResponseModel, dependencies=[Depends(CheckUserInterfaceAuth('system:config:list'))] + '/list', + response_model=PageResponseModel, + dependencies=[UserInterfaceAuthDependency('system:config:list')], ) async def get_system_config_list( request: Request, config_page_query: Annotated[ConfigPageQueryModel, Query()], - query_db: Annotated[AsyncSession, Depends(get_db)], + query_db: Annotated[AsyncSession, DBSessionDependency()], ) -> Response: # 获取分页数据 config_page_query_result = await ConfigService.get_config_list_services(query_db, config_page_query, is_page=True) @@ -36,14 +38,17 @@ async def get_system_config_list( return ResponseUtil.success(model_content=config_page_query_result) -@config_controller.post('', dependencies=[Depends(CheckUserInterfaceAuth('system:config:add'))]) +@config_controller.post( + '', + dependencies=[UserInterfaceAuthDependency('system:config:add')], +) @ValidateFields(validate_model='add_config') @Log(title='参数管理', business_type=BusinessType.INSERT) async def add_system_config( request: Request, add_config: ConfigModel, - query_db: Annotated[AsyncSession, Depends(get_db)], - current_user: Annotated[CurrentUserModel, Depends(LoginService.get_current_user)], + query_db: Annotated[AsyncSession, DBSessionDependency()], + current_user: Annotated[CurrentUserModel, CurrentUserDependency()], ) -> Response: add_config.create_by = current_user.user.user_name add_config.create_time = datetime.now() @@ -55,14 +60,17 @@ async def add_system_config( return ResponseUtil.success(msg=add_config_result.message) -@config_controller.put('', dependencies=[Depends(CheckUserInterfaceAuth('system:config:edit'))]) +@config_controller.put( + '', + dependencies=[UserInterfaceAuthDependency('system:config:edit')], +) @ValidateFields(validate_model='edit_config') @Log(title='参数管理', business_type=BusinessType.UPDATE) async def edit_system_config( request: Request, edit_config: ConfigModel, - query_db: Annotated[AsyncSession, Depends(get_db)], - current_user: Annotated[CurrentUserModel, Depends(LoginService.get_current_user)], + query_db: Annotated[AsyncSession, DBSessionDependency()], + current_user: Annotated[CurrentUserModel, CurrentUserDependency()], ) -> Response: edit_config.update_by = current_user.user.user_name edit_config.update_time = datetime.now() @@ -72,11 +80,14 @@ async def edit_system_config( return ResponseUtil.success(msg=edit_config_result.message) -@config_controller.delete('/refreshCache', dependencies=[Depends(CheckUserInterfaceAuth('system:config:remove'))]) +@config_controller.delete( + '/refreshCache', + dependencies=[UserInterfaceAuthDependency('system:config:remove')], +) @Log(title='参数管理', business_type=BusinessType.UPDATE) async def refresh_system_config( request: Request, - query_db: Annotated[AsyncSession, Depends(get_db)], + query_db: Annotated[AsyncSession, DBSessionDependency()], ) -> Response: refresh_config_result = await ConfigService.refresh_sys_config_services(request, query_db) logger.info(refresh_config_result.message) @@ -84,12 +95,15 @@ async def refresh_system_config( return ResponseUtil.success(msg=refresh_config_result.message) -@config_controller.delete('/{config_ids}', dependencies=[Depends(CheckUserInterfaceAuth('system:config:remove'))]) +@config_controller.delete( + '/{config_ids}', + dependencies=[UserInterfaceAuthDependency('system:config:remove')], +) @Log(title='参数管理', business_type=BusinessType.DELETE) async def delete_system_config( request: Request, config_ids: Annotated[str, Path(description='需要删除的参数主键')], - query_db: Annotated[AsyncSession, Depends(get_db)], + query_db: Annotated[AsyncSession, DBSessionDependency()], ) -> Response: delete_config = DeleteConfigModel(configIds=config_ids) delete_config_result = await ConfigService.delete_config_services(request, query_db, delete_config) @@ -99,12 +113,14 @@ async def delete_system_config( @config_controller.get( - '/{config_id}', response_model=ConfigModel, dependencies=[Depends(CheckUserInterfaceAuth('system:config:query'))] + '/{config_id}', + response_model=ConfigModel, + dependencies=[UserInterfaceAuthDependency('system:config:query')], ) async def query_detail_system_config( request: Request, config_id: Annotated[int, Path(description='参数主键')], - query_db: Annotated[AsyncSession, Depends(get_db)], + query_db: Annotated[AsyncSession, DBSessionDependency()], ) -> Response: config_detail_result = await ConfigService.config_detail_services(query_db, config_id) logger.info(f'获取config_id为{config_id}的信息成功') @@ -121,12 +137,15 @@ async def query_system_config(request: Request, config_key: str) -> Response: return ResponseUtil.success(msg=config_query_result) -@config_controller.post('/export', dependencies=[Depends(CheckUserInterfaceAuth('system:config:export'))]) +@config_controller.post( + '/export', + dependencies=[UserInterfaceAuthDependency('system:config:export')], +) @Log(title='参数管理', business_type=BusinessType.EXPORT) async def export_system_config_list( request: Request, config_page_query: Annotated[ConfigPageQueryModel, Form()], - query_db: Annotated[AsyncSession, Depends(get_db)], + query_db: Annotated[AsyncSession, DBSessionDependency()], ) -> Response: # 获取全量数据 config_query_result = await ConfigService.get_config_list_services(query_db, config_page_query, is_page=False) diff --git a/ruoyi-fastapi-backend/module_admin/controller/dept_controller.py b/ruoyi-fastapi-backend/module_admin/controller/dept_controller.py index a3a98e6..542e869 100644 --- a/ruoyi-fastapi-backend/module_admin/controller/dept_controller.py +++ b/ruoyi-fastapi-backend/module_admin/controller/dept_controller.py @@ -1,35 +1,35 @@ from datetime import datetime from typing import Annotated -from fastapi import APIRouter, Depends, Path, Query, Request, Response +from fastapi import APIRouter, Path, Query, Request, Response from pydantic_validation_decorator import ValidateFields from sqlalchemy.ext.asyncio import AsyncSession from common.annotation.log_annotation import Log -from common.aspect.data_scope import GetDataScope -from common.aspect.interface_auth import CheckUserInterfaceAuth +from common.aspect.data_scope import DataScopeDependency +from common.aspect.db_seesion import DBSessionDependency +from common.aspect.interface_auth import UserInterfaceAuthDependency +from common.aspect.pre_auth import CurrentUserDependency, PreAuthDependency from common.enums import BusinessType -from config.get_db import get_db from module_admin.entity.vo.dept_vo import DeleteDeptModel, DeptModel, DeptQueryModel from module_admin.entity.vo.user_vo import CurrentUserModel from module_admin.service.dept_service import DeptService -from module_admin.service.login_service import LoginService from utils.log_util import logger from utils.response_util import ResponseUtil -dept_controller = APIRouter(prefix='/system/dept', dependencies=[Depends(LoginService.get_current_user)]) +dept_controller = APIRouter(prefix='/system/dept', dependencies=[PreAuthDependency()]) @dept_controller.get( '/list/exclude/{dept_id}', response_model=list[DeptModel], - dependencies=[Depends(CheckUserInterfaceAuth('system:dept:list'))], + dependencies=[UserInterfaceAuthDependency('system:dept:list')], ) async def get_system_dept_tree_for_edit_option( request: Request, dept_id: Annotated[int, Path(description='部门id')], - query_db: Annotated[AsyncSession, Depends(get_db)], - data_scope_sql: Annotated[str, Depends(GetDataScope('SysDept'))], + query_db: Annotated[AsyncSession, DBSessionDependency()], + data_scope_sql: Annotated[str, DataScopeDependency('SysDept')], ) -> Response: dept_query = DeptModel(deptId=dept_id) dept_query_result = await DeptService.get_dept_for_edit_option_services(query_db, dept_query, data_scope_sql) @@ -39,13 +39,15 @@ async def get_system_dept_tree_for_edit_option( @dept_controller.get( - '/list', response_model=list[DeptModel], dependencies=[Depends(CheckUserInterfaceAuth('system:dept:list'))] + '/list', + response_model=list[DeptModel], + dependencies=[UserInterfaceAuthDependency('system:dept:list')], ) async def get_system_dept_list( request: Request, dept_query: Annotated[DeptQueryModel, Query()], - query_db: Annotated[AsyncSession, Depends(get_db)], - data_scope_sql: Annotated[str, Depends(GetDataScope('SysDept'))], + query_db: Annotated[AsyncSession, DBSessionDependency()], + data_scope_sql: Annotated[str, DataScopeDependency('SysDept')], ) -> Response: dept_query_result = await DeptService.get_dept_list_services(query_db, dept_query, data_scope_sql) logger.info('获取成功') @@ -53,14 +55,17 @@ async def get_system_dept_list( return ResponseUtil.success(data=dept_query_result) -@dept_controller.post('', dependencies=[Depends(CheckUserInterfaceAuth('system:dept:add'))]) +@dept_controller.post( + '', + dependencies=[UserInterfaceAuthDependency('system:dept:add')], +) @ValidateFields(validate_model='add_dept') @Log(title='部门管理', business_type=BusinessType.INSERT) async def add_system_dept( request: Request, add_dept: DeptModel, - query_db: Annotated[AsyncSession, Depends(get_db)], - current_user: Annotated[CurrentUserModel, Depends(LoginService.get_current_user)], + query_db: Annotated[AsyncSession, DBSessionDependency()], + current_user: Annotated[CurrentUserModel, CurrentUserDependency()], ) -> Response: add_dept.create_by = current_user.user.user_name add_dept.create_time = datetime.now() @@ -72,15 +77,18 @@ async def add_system_dept( return ResponseUtil.success(data=add_dept_result) -@dept_controller.put('', dependencies=[Depends(CheckUserInterfaceAuth('system:dept:edit'))]) +@dept_controller.put( + '', + dependencies=[UserInterfaceAuthDependency('system:dept:edit')], +) @ValidateFields(validate_model='edit_dept') @Log(title='部门管理', business_type=BusinessType.UPDATE) async def edit_system_dept( request: Request, edit_dept: DeptModel, - query_db: Annotated[AsyncSession, Depends(get_db)], - current_user: Annotated[CurrentUserModel, Depends(LoginService.get_current_user)], - data_scope_sql: Annotated[str, Depends(GetDataScope('SysDept'))], + query_db: Annotated[AsyncSession, DBSessionDependency()], + current_user: Annotated[CurrentUserModel, CurrentUserDependency()], + data_scope_sql: Annotated[str, DataScopeDependency('SysDept')], ) -> Response: if not current_user.user.admin: await DeptService.check_dept_data_scope_services(query_db, edit_dept.dept_id, data_scope_sql) @@ -92,14 +100,17 @@ async def edit_system_dept( return ResponseUtil.success(msg=edit_dept_result.message) -@dept_controller.delete('/{dept_ids}', dependencies=[Depends(CheckUserInterfaceAuth('system:dept:remove'))]) +@dept_controller.delete( + '/{dept_ids}', + dependencies=[UserInterfaceAuthDependency('system:dept:remove')], +) @Log(title='部门管理', business_type=BusinessType.DELETE) async def delete_system_dept( request: Request, dept_ids: Annotated[str, Path(description='需要删除的部门id')], - query_db: Annotated[AsyncSession, Depends(get_db)], - current_user: Annotated[CurrentUserModel, Depends(LoginService.get_current_user)], - data_scope_sql: Annotated[str, Depends(GetDataScope('SysDept'))], + query_db: Annotated[AsyncSession, DBSessionDependency()], + current_user: Annotated[CurrentUserModel, CurrentUserDependency()], + data_scope_sql: Annotated[str, DataScopeDependency('SysDept')], ) -> Response: dept_id_list = dept_ids.split(',') if dept_ids else [] if dept_id_list: @@ -116,14 +127,16 @@ async def delete_system_dept( @dept_controller.get( - '/{dept_id}', response_model=DeptModel, dependencies=[Depends(CheckUserInterfaceAuth('system:dept:query'))] + '/{dept_id}', + response_model=DeptModel, + dependencies=[UserInterfaceAuthDependency('system:dept:query')], ) async def query_detail_system_dept( request: Request, dept_id: Annotated[int, Path(description='部门id')], - query_db: Annotated[AsyncSession, Depends(get_db)], - current_user: Annotated[CurrentUserModel, Depends(LoginService.get_current_user)], - data_scope_sql: Annotated[str, Depends(GetDataScope('SysDept'))], + query_db: Annotated[AsyncSession, DBSessionDependency()], + current_user: Annotated[CurrentUserModel, CurrentUserDependency()], + data_scope_sql: Annotated[str, DataScopeDependency('SysDept')], ) -> Response: if not current_user.user.admin: await DeptService.check_dept_data_scope_services(query_db, dept_id, data_scope_sql) diff --git a/ruoyi-fastapi-backend/module_admin/controller/dict_controller.py b/ruoyi-fastapi-backend/module_admin/controller/dict_controller.py index 9a719ae..dd319d4 100644 --- a/ruoyi-fastapi-backend/module_admin/controller/dict_controller.py +++ b/ruoyi-fastapi-backend/module_admin/controller/dict_controller.py @@ -1,14 +1,15 @@ from datetime import datetime from typing import Annotated -from fastapi import APIRouter, Depends, Form, Path, Query, Request, Response +from fastapi import APIRouter, Form, Path, Query, Request, Response from pydantic_validation_decorator import ValidateFields from sqlalchemy.ext.asyncio import AsyncSession from common.annotation.log_annotation import Log -from common.aspect.interface_auth import CheckUserInterfaceAuth +from common.aspect.db_seesion import DBSessionDependency +from common.aspect.interface_auth import UserInterfaceAuthDependency +from common.aspect.pre_auth import CurrentUserDependency, PreAuthDependency from common.enums import BusinessType -from config.get_db import get_db from module_admin.entity.vo.dict_vo import ( DeleteDictDataModel, DeleteDictTypeModel, @@ -19,22 +20,23 @@ from module_admin.entity.vo.dict_vo import ( ) from module_admin.entity.vo.user_vo import CurrentUserModel from module_admin.service.dict_service import DictDataService, DictTypeService -from module_admin.service.login_service import LoginService from utils.common_util import bytes2file_response from utils.log_util import logger from utils.page_util import PageResponseModel from utils.response_util import ResponseUtil -dict_controller = APIRouter(prefix='/system/dict', dependencies=[Depends(LoginService.get_current_user)]) +dict_controller = APIRouter(prefix='/system/dict', dependencies=[PreAuthDependency()]) @dict_controller.get( - '/type/list', response_model=PageResponseModel, dependencies=[Depends(CheckUserInterfaceAuth('system:dict:list'))] + '/type/list', + response_model=PageResponseModel, + dependencies=[UserInterfaceAuthDependency('system:dict:list')], ) async def get_system_dict_type_list( request: Request, dict_type_page_query: Annotated[DictTypePageQueryModel, Query()], - query_db: Annotated[AsyncSession, Depends(get_db)], + query_db: Annotated[AsyncSession, DBSessionDependency()], ) -> Response: # 获取分页数据 dict_type_page_query_result = await DictTypeService.get_dict_type_list_services( @@ -45,14 +47,17 @@ async def get_system_dict_type_list( return ResponseUtil.success(model_content=dict_type_page_query_result) -@dict_controller.post('/type', dependencies=[Depends(CheckUserInterfaceAuth('system:dict:add'))]) +@dict_controller.post( + '/type', + dependencies=[UserInterfaceAuthDependency('system:dict:add')], +) @ValidateFields(validate_model='add_dict_type') @Log(title='字典类型', business_type=BusinessType.INSERT) async def add_system_dict_type( request: Request, add_dict_type: DictTypeModel, - query_db: Annotated[AsyncSession, Depends(get_db)], - current_user: Annotated[CurrentUserModel, Depends(LoginService.get_current_user)], + query_db: Annotated[AsyncSession, DBSessionDependency()], + current_user: Annotated[CurrentUserModel, CurrentUserDependency()], ) -> Response: add_dict_type.create_by = current_user.user.user_name add_dict_type.create_time = datetime.now() @@ -64,14 +69,17 @@ async def add_system_dict_type( return ResponseUtil.success(msg=add_dict_type_result.message) -@dict_controller.put('/type', dependencies=[Depends(CheckUserInterfaceAuth('system:dict:edit'))]) +@dict_controller.put( + '/type', + dependencies=[UserInterfaceAuthDependency('system:dict:edit')], +) @ValidateFields(validate_model='edit_dict_type') @Log(title='字典类型', business_type=BusinessType.UPDATE) async def edit_system_dict_type( request: Request, edit_dict_type: DictTypeModel, - query_db: Annotated[AsyncSession, Depends(get_db)], - current_user: Annotated[CurrentUserModel, Depends(LoginService.get_current_user)], + query_db: Annotated[AsyncSession, DBSessionDependency()], + current_user: Annotated[CurrentUserModel, CurrentUserDependency()], ) -> Response: edit_dict_type.update_by = current_user.user.user_name edit_dict_type.update_time = datetime.now() @@ -81,21 +89,27 @@ async def edit_system_dict_type( return ResponseUtil.success(msg=edit_dict_type_result.message) -@dict_controller.delete('/type/refreshCache', dependencies=[Depends(CheckUserInterfaceAuth('system:dict:remove'))]) +@dict_controller.delete( + '/type/refreshCache', + dependencies=[UserInterfaceAuthDependency('system:dict:remove')], +) @Log(title='字典类型', business_type=BusinessType.UPDATE) -async def refresh_system_dict(request: Request, query_db: Annotated[AsyncSession, Depends(get_db)]) -> Response: +async def refresh_system_dict(request: Request, query_db: Annotated[AsyncSession, DBSessionDependency()]) -> Response: refresh_dict_result = await DictTypeService.refresh_sys_dict_services(request, query_db) logger.info(refresh_dict_result.message) return ResponseUtil.success(msg=refresh_dict_result.message) -@dict_controller.delete('/type/{dict_ids}', dependencies=[Depends(CheckUserInterfaceAuth('system:dict:remove'))]) +@dict_controller.delete( + '/type/{dict_ids}', + dependencies=[UserInterfaceAuthDependency('system:dict:remove')], +) @Log(title='字典类型', business_type=BusinessType.DELETE) async def delete_system_dict_type( request: Request, dict_ids: Annotated[str, Path(description='需要删除的字典主键')], - query_db: Annotated[AsyncSession, Depends(get_db)], + query_db: Annotated[AsyncSession, DBSessionDependency()], ) -> Response: delete_dict_type = DeleteDictTypeModel(dictIds=dict_ids) delete_dict_type_result = await DictTypeService.delete_dict_type_services(request, query_db, delete_dict_type) @@ -106,7 +120,7 @@ async def delete_system_dict_type( @dict_controller.get('/type/optionselect', response_model=list[DictTypeModel]) async def query_system_dict_type_options( - request: Request, query_db: Annotated[AsyncSession, Depends(get_db)] + request: Request, query_db: Annotated[AsyncSession, DBSessionDependency()] ) -> Response: dict_type_query_result = await DictTypeService.get_dict_type_list_services( query_db, DictTypePageQueryModel(), is_page=False @@ -117,12 +131,14 @@ async def query_system_dict_type_options( @dict_controller.get( - '/type/{dict_id}', response_model=DictTypeModel, dependencies=[Depends(CheckUserInterfaceAuth('system:dict:query'))] + '/type/{dict_id}', + response_model=DictTypeModel, + dependencies=[UserInterfaceAuthDependency('system:dict:query')], ) async def query_detail_system_dict_type( request: Request, dict_id: Annotated[int, Path(description='字典主键')], - query_db: Annotated[AsyncSession, Depends(get_db)], + query_db: Annotated[AsyncSession, DBSessionDependency()], ) -> Response: dict_type_detail_result = await DictTypeService.dict_type_detail_services(query_db, dict_id) logger.info(f'获取dict_id为{dict_id}的信息成功') @@ -130,12 +146,15 @@ async def query_detail_system_dict_type( return ResponseUtil.success(data=dict_type_detail_result) -@dict_controller.post('/type/export', dependencies=[Depends(CheckUserInterfaceAuth('system:dict:export'))]) +@dict_controller.post( + '/type/export', + dependencies=[UserInterfaceAuthDependency('system:dict:export')], +) @Log(title='字典类型', business_type=BusinessType.EXPORT) async def export_system_dict_type_list( request: Request, dict_type_page_query: Annotated[DictTypePageQueryModel, Form()], - query_db: Annotated[AsyncSession, Depends(get_db)], + query_db: Annotated[AsyncSession, DBSessionDependency()], ) -> Response: # 获取全量数据 dict_type_query_result = await DictTypeService.get_dict_type_list_services( @@ -151,7 +170,7 @@ async def export_system_dict_type_list( async def query_system_dict_type_data( request: Request, dict_type: Annotated[str, Path(description='字典类型')], - query_db: Annotated[AsyncSession, Depends(get_db)], + query_db: Annotated[AsyncSession, DBSessionDependency()], ) -> Response: # 获取全量数据 dict_data_query_result = await DictDataService.query_dict_data_list_from_cache_services( @@ -163,12 +182,14 @@ async def query_system_dict_type_data( @dict_controller.get( - '/data/list', response_model=PageResponseModel, dependencies=[Depends(CheckUserInterfaceAuth('system:dict:list'))] + '/data/list', + response_model=PageResponseModel, + dependencies=[UserInterfaceAuthDependency('system:dict:list')], ) async def get_system_dict_data_list( request: Request, dict_data_page_query: Annotated[DictDataPageQueryModel, Query()], - query_db: Annotated[AsyncSession, Depends(get_db)], + query_db: Annotated[AsyncSession, DBSessionDependency()], ) -> Response: # 获取分页数据 dict_data_page_query_result = await DictDataService.get_dict_data_list_services( @@ -179,14 +200,17 @@ async def get_system_dict_data_list( return ResponseUtil.success(model_content=dict_data_page_query_result) -@dict_controller.post('/data', dependencies=[Depends(CheckUserInterfaceAuth('system:dict:add'))]) +@dict_controller.post( + '/data', + dependencies=[UserInterfaceAuthDependency('system:dict:add')], +) @ValidateFields(validate_model='add_dict_data') @Log(title='字典数据', business_type=BusinessType.INSERT) async def add_system_dict_data( request: Request, add_dict_data: DictDataModel, - query_db: Annotated[AsyncSession, Depends(get_db)], - current_user: Annotated[CurrentUserModel, Depends(LoginService.get_current_user)], + query_db: Annotated[AsyncSession, DBSessionDependency()], + current_user: Annotated[CurrentUserModel, CurrentUserDependency()], ) -> Response: add_dict_data.create_by = current_user.user.user_name add_dict_data.create_time = datetime.now() @@ -198,14 +222,17 @@ async def add_system_dict_data( return ResponseUtil.success(msg=add_dict_data_result.message) -@dict_controller.put('/data', dependencies=[Depends(CheckUserInterfaceAuth('system:dict:edit'))]) +@dict_controller.put( + '/data', + dependencies=[UserInterfaceAuthDependency('system:dict:edit')], +) @ValidateFields(validate_model='edit_dict_data') @Log(title='字典数据', business_type=BusinessType.UPDATE) async def edit_system_dict_data( request: Request, edit_dict_data: DictDataModel, - query_db: Annotated[AsyncSession, Depends(get_db)], - current_user: Annotated[CurrentUserModel, Depends(LoginService.get_current_user)], + query_db: Annotated[AsyncSession, DBSessionDependency()], + current_user: Annotated[CurrentUserModel, CurrentUserDependency()], ) -> Response: edit_dict_data.update_by = current_user.user.user_name edit_dict_data.update_time = datetime.now() @@ -215,12 +242,15 @@ async def edit_system_dict_data( return ResponseUtil.success(msg=edit_dict_data_result.message) -@dict_controller.delete('/data/{dict_codes}', dependencies=[Depends(CheckUserInterfaceAuth('system:dict:remove'))]) +@dict_controller.delete( + '/data/{dict_codes}', + dependencies=[UserInterfaceAuthDependency('system:dict:remove')], +) @Log(title='字典数据', business_type=BusinessType.DELETE) async def delete_system_dict_data( request: Request, dict_codes: Annotated[str, Path(description='需要删除的字典编码')], - query_db: Annotated[AsyncSession, Depends(get_db)], + query_db: Annotated[AsyncSession, DBSessionDependency()], ) -> Response: delete_dict_data = DeleteDictDataModel(dictCodes=dict_codes) delete_dict_data_result = await DictDataService.delete_dict_data_services(request, query_db, delete_dict_data) @@ -232,12 +262,12 @@ async def delete_system_dict_data( @dict_controller.get( '/data/{dict_code}', response_model=DictDataModel, - dependencies=[Depends(CheckUserInterfaceAuth('system:dict:query'))], + dependencies=[UserInterfaceAuthDependency('system:dict:query')], ) async def query_detail_system_dict_data( request: Request, dict_code: Annotated[int, Path(description='字典编码')], - query_db: Annotated[AsyncSession, Depends(get_db)], + query_db: Annotated[AsyncSession, DBSessionDependency()], ) -> Response: detail_dict_data_result = await DictDataService.dict_data_detail_services(query_db, dict_code) logger.info(f'获取dict_code为{dict_code}的信息成功') @@ -245,12 +275,15 @@ async def query_detail_system_dict_data( return ResponseUtil.success(data=detail_dict_data_result) -@dict_controller.post('/data/export', dependencies=[Depends(CheckUserInterfaceAuth('system:dict:export'))]) +@dict_controller.post( + '/data/export', + dependencies=[UserInterfaceAuthDependency('system:dict:export')], +) @Log(title='字典数据', business_type=BusinessType.EXPORT) async def export_system_dict_data_list( request: Request, dict_data_page_query: Annotated[DictDataPageQueryModel, Form()], - query_db: Annotated[AsyncSession, Depends(get_db)], + query_db: Annotated[AsyncSession, DBSessionDependency()], ) -> Response: # 获取全量数据 dict_data_query_result = await DictDataService.get_dict_data_list_services( diff --git a/ruoyi-fastapi-backend/module_admin/controller/job_controller.py b/ruoyi-fastapi-backend/module_admin/controller/job_controller.py index efe9021..5d656be 100644 --- a/ruoyi-fastapi-backend/module_admin/controller/job_controller.py +++ b/ruoyi-fastapi-backend/module_admin/controller/job_controller.py @@ -1,14 +1,15 @@ from datetime import datetime from typing import Annotated -from fastapi import APIRouter, Depends, Form, Path, Query, Request, Response +from fastapi import APIRouter, Form, Path, Query, Request, Response from pydantic_validation_decorator import ValidateFields from sqlalchemy.ext.asyncio import AsyncSession from common.annotation.log_annotation import Log -from common.aspect.interface_auth import CheckUserInterfaceAuth +from common.aspect.db_seesion import DBSessionDependency +from common.aspect.interface_auth import UserInterfaceAuthDependency +from common.aspect.pre_auth import CurrentUserDependency, PreAuthDependency from common.enums import BusinessType -from config.get_db import get_db from module_admin.entity.vo.job_vo import ( DeleteJobLogModel, DeleteJobModel, @@ -20,22 +21,23 @@ from module_admin.entity.vo.job_vo import ( from module_admin.entity.vo.user_vo import CurrentUserModel from module_admin.service.job_log_service import JobLogService from module_admin.service.job_service import JobService -from module_admin.service.login_service import LoginService from utils.common_util import bytes2file_response from utils.log_util import logger from utils.page_util import PageResponseModel from utils.response_util import ResponseUtil -job_controller = APIRouter(prefix='/monitor', dependencies=[Depends(LoginService.get_current_user)]) +job_controller = APIRouter(prefix='/monitor', dependencies=[PreAuthDependency()]) @job_controller.get( - '/job/list', response_model=PageResponseModel, dependencies=[Depends(CheckUserInterfaceAuth('monitor:job:list'))] + '/job/list', + response_model=PageResponseModel, + dependencies=[UserInterfaceAuthDependency('monitor:job:list')], ) async def get_system_job_list( request: Request, job_page_query: Annotated[JobPageQueryModel, Query()], - query_db: Annotated[AsyncSession, Depends(get_db)], + query_db: Annotated[AsyncSession, DBSessionDependency()], ) -> Response: # 获取分页数据 notice_page_query_result = await JobService.get_job_list_services(query_db, job_page_query, is_page=True) @@ -44,14 +46,17 @@ async def get_system_job_list( return ResponseUtil.success(model_content=notice_page_query_result) -@job_controller.post('/job', dependencies=[Depends(CheckUserInterfaceAuth('monitor:job:add'))]) +@job_controller.post( + '/job', + dependencies=[UserInterfaceAuthDependency('monitor:job:add')], +) @ValidateFields(validate_model='add_job') @Log(title='定时任务', business_type=BusinessType.INSERT) async def add_system_job( request: Request, add_job: JobModel, - query_db: Annotated[AsyncSession, Depends(get_db)], - current_user: Annotated[CurrentUserModel, Depends(LoginService.get_current_user)], + query_db: Annotated[AsyncSession, DBSessionDependency()], + current_user: Annotated[CurrentUserModel, CurrentUserDependency()], ) -> Response: add_job.create_by = current_user.user.user_name add_job.create_time = datetime.now() @@ -63,14 +68,17 @@ async def add_system_job( return ResponseUtil.success(msg=add_job_result.message) -@job_controller.put('/job', dependencies=[Depends(CheckUserInterfaceAuth('monitor:job:edit'))]) +@job_controller.put( + '/job', + dependencies=[UserInterfaceAuthDependency('monitor:job:edit')], +) @ValidateFields(validate_model='edit_job') @Log(title='定时任务', business_type=BusinessType.UPDATE) async def edit_system_job( request: Request, edit_job: EditJobModel, - query_db: Annotated[AsyncSession, Depends(get_db)], - current_user: Annotated[CurrentUserModel, Depends(LoginService.get_current_user)], + query_db: Annotated[AsyncSession, DBSessionDependency()], + current_user: Annotated[CurrentUserModel, CurrentUserDependency()], ) -> Response: edit_job.update_by = current_user.user.user_name edit_job.update_time = datetime.now() @@ -80,13 +88,16 @@ async def edit_system_job( return ResponseUtil.success(msg=edit_job_result.message) -@job_controller.put('/job/changeStatus', dependencies=[Depends(CheckUserInterfaceAuth('monitor:job:changeStatus'))]) +@job_controller.put( + '/job/changeStatus', + dependencies=[UserInterfaceAuthDependency('monitor:job:changeStatus')], +) @Log(title='定时任务', business_type=BusinessType.UPDATE) async def change_system_job_status( request: Request, change_job: EditJobModel, - query_db: Annotated[AsyncSession, Depends(get_db)], - current_user: Annotated[CurrentUserModel, Depends(LoginService.get_current_user)], + query_db: Annotated[AsyncSession, DBSessionDependency()], + current_user: Annotated[CurrentUserModel, CurrentUserDependency()], ) -> Response: edit_job = EditJobModel( jobId=change_job.job_id, @@ -101,12 +112,15 @@ async def change_system_job_status( return ResponseUtil.success(msg=edit_job_result.message) -@job_controller.put('/job/run', dependencies=[Depends(CheckUserInterfaceAuth('monitor:job:changeStatus'))]) +@job_controller.put( + '/job/run', + dependencies=[UserInterfaceAuthDependency('monitor:job:changeStatus')], +) @Log(title='定时任务', business_type=BusinessType.UPDATE) async def execute_system_job( request: Request, execute_job: JobModel, - query_db: Annotated[AsyncSession, Depends(get_db)], + query_db: Annotated[AsyncSession, DBSessionDependency()], ) -> Response: execute_job_result = await JobService.execute_job_once_services(query_db, execute_job) logger.info(execute_job_result.message) @@ -114,12 +128,15 @@ async def execute_system_job( return ResponseUtil.success(msg=execute_job_result.message) -@job_controller.delete('/job/{job_ids}', dependencies=[Depends(CheckUserInterfaceAuth('monitor:job:remove'))]) +@job_controller.delete( + '/job/{job_ids}', + dependencies=[UserInterfaceAuthDependency('monitor:job:remove')], +) @Log(title='定时任务', business_type=BusinessType.DELETE) async def delete_system_job( request: Request, job_ids: Annotated[str, Path(description='需要删除的定时任务ID')], - query_db: Annotated[AsyncSession, Depends(get_db)], + query_db: Annotated[AsyncSession, DBSessionDependency()], ) -> Response: delete_job = DeleteJobModel(jobIds=job_ids) delete_job_result = await JobService.delete_job_services(query_db, delete_job) @@ -129,12 +146,14 @@ async def delete_system_job( @job_controller.get( - '/job/{job_id}', response_model=JobModel, dependencies=[Depends(CheckUserInterfaceAuth('monitor:job:query'))] + '/job/{job_id}', + response_model=JobModel, + dependencies=[UserInterfaceAuthDependency('monitor:job:query')], ) async def query_detail_system_job( request: Request, job_id: Annotated[int, Path(description='任务ID')], - query_db: Annotated[AsyncSession, Depends(get_db)], + query_db: Annotated[AsyncSession, DBSessionDependency()], ) -> Response: job_detail_result = await JobService.job_detail_services(query_db, job_id) logger.info(f'获取job_id为{job_id}的信息成功') @@ -142,12 +161,15 @@ async def query_detail_system_job( return ResponseUtil.success(data=job_detail_result) -@job_controller.post('/job/export', dependencies=[Depends(CheckUserInterfaceAuth('monitor:job:export'))]) +@job_controller.post( + '/job/export', + dependencies=[UserInterfaceAuthDependency('monitor:job:export')], +) @Log(title='定时任务', business_type=BusinessType.EXPORT) async def export_system_job_list( request: Request, job_page_query: Annotated[JobPageQueryModel, Form()], - query_db: Annotated[AsyncSession, Depends(get_db)], + query_db: Annotated[AsyncSession, DBSessionDependency()], ) -> Response: # 获取全量数据 job_query_result = await JobService.get_job_list_services(query_db, job_page_query, is_page=False) @@ -158,12 +180,14 @@ async def export_system_job_list( @job_controller.get( - '/jobLog/list', response_model=PageResponseModel, dependencies=[Depends(CheckUserInterfaceAuth('monitor:job:list'))] + '/jobLog/list', + response_model=PageResponseModel, + dependencies=[UserInterfaceAuthDependency('monitor:job:list')], ) async def get_system_job_log_list( request: Request, job_log_page_query: Annotated[JobLogPageQueryModel, Query()], - query_db: Annotated[AsyncSession, Depends(get_db)], + query_db: Annotated[AsyncSession, DBSessionDependency()], ) -> Response: # 获取分页数据 job_log_page_query_result = await JobLogService.get_job_log_list_services( @@ -174,11 +198,14 @@ async def get_system_job_log_list( return ResponseUtil.success(model_content=job_log_page_query_result) -@job_controller.delete('/jobLog/clean', dependencies=[Depends(CheckUserInterfaceAuth('monitor:job:remove'))]) +@job_controller.delete( + '/jobLog/clean', + dependencies=[UserInterfaceAuthDependency('monitor:job:remove')], +) @Log(title='定时任务调度日志', business_type=BusinessType.CLEAN) async def clear_system_job_log( request: Request, - query_db: Annotated[AsyncSession, Depends(get_db)], + query_db: Annotated[AsyncSession, DBSessionDependency()], ) -> Response: clear_job_log_result = await JobLogService.clear_job_log_services(query_db) logger.info(clear_job_log_result.message) @@ -186,12 +213,15 @@ async def clear_system_job_log( return ResponseUtil.success(msg=clear_job_log_result.message) -@job_controller.delete('/jobLog/{job_log_ids}', dependencies=[Depends(CheckUserInterfaceAuth('monitor:job:remove'))]) +@job_controller.delete( + '/jobLog/{job_log_ids}', + dependencies=[UserInterfaceAuthDependency('monitor:job:remove')], +) @Log(title='定时任务调度日志', business_type=BusinessType.DELETE) async def delete_system_job_log( request: Request, job_log_ids: Annotated[str, Path(description='需要删除的定时任务日志ID')], - query_db: Annotated[AsyncSession, Depends(get_db)], + query_db: Annotated[AsyncSession, DBSessionDependency()], ) -> Response: delete_job_log = DeleteJobLogModel(jobLogIds=job_log_ids) delete_job_log_result = await JobLogService.delete_job_log_services(query_db, delete_job_log) @@ -200,12 +230,15 @@ async def delete_system_job_log( return ResponseUtil.success(msg=delete_job_log_result.message) -@job_controller.post('/jobLog/export', dependencies=[Depends(CheckUserInterfaceAuth('monitor:job:export'))]) +@job_controller.post( + '/jobLog/export', + dependencies=[UserInterfaceAuthDependency('monitor:job:export')], +) @Log(title='定时任务调度日志', business_type=BusinessType.EXPORT) async def export_system_job_log_list( request: Request, job_log_page_query: Annotated[JobLogPageQueryModel, Form()], - query_db: Annotated[AsyncSession, Depends(get_db)], + query_db: Annotated[AsyncSession, DBSessionDependency()], ) -> Response: # 获取全量数据 job_log_query_result = await JobLogService.get_job_log_list_services(query_db, job_log_page_query, is_page=False) diff --git a/ruoyi-fastapi-backend/module_admin/controller/log_controller.py b/ruoyi-fastapi-backend/module_admin/controller/log_controller.py index c64943e..c9238a2 100644 --- a/ruoyi-fastapi-backend/module_admin/controller/log_controller.py +++ b/ruoyi-fastapi-backend/module_admin/controller/log_controller.py @@ -1,12 +1,13 @@ from typing import Annotated -from fastapi import APIRouter, Depends, Form, Path, Query, Request, Response +from fastapi import APIRouter, Form, Path, Query, Request, Response from sqlalchemy.ext.asyncio import AsyncSession from common.annotation.log_annotation import Log -from common.aspect.interface_auth import CheckUserInterfaceAuth +from common.aspect.db_seesion import DBSessionDependency +from common.aspect.interface_auth import UserInterfaceAuthDependency +from common.aspect.pre_auth import PreAuthDependency from common.enums import BusinessType -from config.get_db import get_db from module_admin.entity.vo.log_vo import ( DeleteLoginLogModel, DeleteOperLogModel, @@ -15,24 +16,23 @@ from module_admin.entity.vo.log_vo import ( UnlockUser, ) from module_admin.service.log_service import LoginLogService, OperationLogService -from module_admin.service.login_service import LoginService from utils.common_util import bytes2file_response from utils.log_util import logger from utils.page_util import PageResponseModel from utils.response_util import ResponseUtil -log_controller = APIRouter(prefix='/monitor', dependencies=[Depends(LoginService.get_current_user)]) +log_controller = APIRouter(prefix='/monitor', dependencies=[PreAuthDependency()]) @log_controller.get( '/operlog/list', response_model=PageResponseModel, - dependencies=[Depends(CheckUserInterfaceAuth('monitor:operlog:list'))], + dependencies=[UserInterfaceAuthDependency('monitor:operlog:list')], ) async def get_system_operation_log_list( request: Request, operation_log_page_query: Annotated[OperLogPageQueryModel, Query()], - query_db: Annotated[AsyncSession, Depends(get_db)], + query_db: Annotated[AsyncSession, DBSessionDependency()], ) -> Response: # 获取分页数据 operation_log_page_query_result = await OperationLogService.get_operation_log_list_services( @@ -43,21 +43,29 @@ async def get_system_operation_log_list( return ResponseUtil.success(model_content=operation_log_page_query_result) -@log_controller.delete('/operlog/clean', dependencies=[Depends(CheckUserInterfaceAuth('monitor:operlog:remove'))]) +@log_controller.delete( + '/operlog/clean', + dependencies=[UserInterfaceAuthDependency('monitor:operlog:remove')], +) @Log(title='操作日志', business_type=BusinessType.CLEAN) -async def clear_system_operation_log(request: Request, query_db: Annotated[AsyncSession, Depends(get_db)]) -> Response: +async def clear_system_operation_log( + request: Request, query_db: Annotated[AsyncSession, DBSessionDependency()] +) -> Response: clear_operation_log_result = await OperationLogService.clear_operation_log_services(query_db) logger.info(clear_operation_log_result.message) return ResponseUtil.success(msg=clear_operation_log_result.message) -@log_controller.delete('/operlog/{oper_ids}', dependencies=[Depends(CheckUserInterfaceAuth('monitor:operlog:remove'))]) +@log_controller.delete( + '/operlog/{oper_ids}', + dependencies=[UserInterfaceAuthDependency('monitor:operlog:remove')], +) @Log(title='操作日志', business_type=BusinessType.DELETE) async def delete_system_operation_log( request: Request, oper_ids: Annotated[str, Path(description='需要删除的日志主键')], - query_db: Annotated[AsyncSession, Depends(get_db)], + query_db: Annotated[AsyncSession, DBSessionDependency()], ) -> Response: delete_operation_log = DeleteOperLogModel(operIds=oper_ids) delete_operation_log_result = await OperationLogService.delete_operation_log_services( @@ -68,12 +76,15 @@ async def delete_system_operation_log( return ResponseUtil.success(msg=delete_operation_log_result.message) -@log_controller.post('/operlog/export', dependencies=[Depends(CheckUserInterfaceAuth('monitor:operlog:export'))]) +@log_controller.post( + '/operlog/export', + dependencies=[UserInterfaceAuthDependency('monitor:operlog:export')], +) @Log(title='操作日志', business_type=BusinessType.EXPORT) async def export_system_operation_log_list( request: Request, operation_log_page_query: Annotated[OperLogPageQueryModel, Form()], - query_db: Annotated[AsyncSession, Depends(get_db)], + query_db: Annotated[AsyncSession, DBSessionDependency()], ) -> Response: # 获取全量数据 operation_log_query_result = await OperationLogService.get_operation_log_list_services( @@ -90,12 +101,12 @@ async def export_system_operation_log_list( @log_controller.get( '/logininfor/list', response_model=PageResponseModel, - dependencies=[Depends(CheckUserInterfaceAuth('monitor:logininfor:list'))], + dependencies=[UserInterfaceAuthDependency('monitor:logininfor:list')], ) async def get_system_login_log_list( request: Request, login_log_page_query: Annotated[LoginLogPageQueryModel, Query()], - query_db: Annotated[AsyncSession, Depends(get_db)], + query_db: Annotated[AsyncSession, DBSessionDependency()], ) -> Response: # 获取分页数据 login_log_page_query_result = await LoginLogService.get_login_log_list_services( @@ -106,9 +117,14 @@ async def get_system_login_log_list( return ResponseUtil.success(model_content=login_log_page_query_result) -@log_controller.delete('/logininfor/clean', dependencies=[Depends(CheckUserInterfaceAuth('monitor:logininfor:remove'))]) +@log_controller.delete( + '/logininfor/clean', + dependencies=[UserInterfaceAuthDependency('monitor:logininfor:remove')], +) @Log(title='登录日志', business_type=BusinessType.CLEAN) -async def clear_system_login_log(request: Request, query_db: Annotated[AsyncSession, Depends(get_db)]) -> Response: +async def clear_system_login_log( + request: Request, query_db: Annotated[AsyncSession, DBSessionDependency()] +) -> Response: clear_login_log_result = await LoginLogService.clear_login_log_services(query_db) logger.info(clear_login_log_result.message) @@ -116,13 +132,14 @@ async def clear_system_login_log(request: Request, query_db: Annotated[AsyncSess @log_controller.delete( - '/logininfor/{info_ids}', dependencies=[Depends(CheckUserInterfaceAuth('monitor:logininfor:remove'))] + '/logininfor/{info_ids}', + dependencies=[UserInterfaceAuthDependency('monitor:logininfor:remove')], ) @Log(title='登录日志', business_type=BusinessType.DELETE) async def delete_system_login_log( request: Request, info_ids: Annotated[str, Path(description='需要删除的访问ID')], - query_db: Annotated[AsyncSession, Depends(get_db)], + query_db: Annotated[AsyncSession, DBSessionDependency()], ) -> Response: delete_login_log = DeleteLoginLogModel(infoIds=info_ids) delete_login_log_result = await LoginLogService.delete_login_log_services(query_db, delete_login_log) @@ -132,13 +149,14 @@ async def delete_system_login_log( @log_controller.get( - '/logininfor/unlock/{user_name}', dependencies=[Depends(CheckUserInterfaceAuth('monitor:logininfor:unlock'))] + '/logininfor/unlock/{user_name}', + dependencies=[UserInterfaceAuthDependency('monitor:logininfor:unlock')], ) @Log(title='账户解锁', business_type=BusinessType.OTHER) async def unlock_system_user( request: Request, user_name: Annotated[str, Path(description='用户名称')], - query_db: Annotated[AsyncSession, Depends(get_db)], + query_db: Annotated[AsyncSession, DBSessionDependency()], ) -> Response: unlock_user = UnlockUser(userName=user_name) unlock_user_result = await LoginLogService.unlock_user_services(request, unlock_user) @@ -147,12 +165,15 @@ async def unlock_system_user( return ResponseUtil.success(msg=unlock_user_result.message) -@log_controller.post('/logininfor/export', dependencies=[Depends(CheckUserInterfaceAuth('monitor:logininfor:export'))]) +@log_controller.post( + '/logininfor/export', + dependencies=[UserInterfaceAuthDependency('monitor:logininfor:export')], +) @Log(title='登录日志', business_type=BusinessType.EXPORT) async def export_system_login_log_list( request: Request, login_log_page_query: Annotated[LoginLogPageQueryModel, Form()], - query_db: Annotated[AsyncSession, Depends(get_db)], + query_db: Annotated[AsyncSession, DBSessionDependency()], ) -> Response: # 获取全量数据 login_log_query_result = await LoginLogService.get_login_log_list_services( diff --git a/ruoyi-fastapi-backend/module_admin/controller/login_controller.py b/ruoyi-fastapi-backend/module_admin/controller/login_controller.py index 6df7872..b00b3e1 100644 --- a/ruoyi-fastapi-backend/module_admin/controller/login_controller.py +++ b/ruoyi-fastapi-backend/module_admin/controller/login_controller.py @@ -7,9 +7,10 @@ from fastapi import APIRouter, Depends, Request, Response from sqlalchemy.ext.asyncio import AsyncSession from common.annotation.log_annotation import Log +from common.aspect.db_seesion import DBSessionDependency +from common.aspect.pre_auth import CurrentUserDependency from common.enums import BusinessType, RedisInitKeyConfig from config.env import AppConfig, JwtConfig -from config.get_db import get_db from module_admin.entity.vo.common_vo import CrudResponseModel from module_admin.entity.vo.login_vo import Token, UserLogin, UserRegister from module_admin.entity.vo.user_vo import CurrentUserModel, EditUserModel @@ -26,7 +27,7 @@ login_controller = APIRouter() async def login( request: Request, form_data: Annotated[CustomOAuth2PasswordRequestForm, Depends()], - query_db: Annotated[AsyncSession, Depends(get_db)], + query_db: Annotated[AsyncSession, DBSessionDependency()], ) -> Response: captcha_enabled = ( await request.app.state.redis.get(f'{RedisInitKeyConfig.SYS_CONFIG.key}:sys.account.captchaEnabled') == 'true' @@ -79,7 +80,7 @@ async def login( @login_controller.get('/getInfo', response_model=CurrentUserModel) async def get_login_user_info( - request: Request, current_user: Annotated[CurrentUserModel, Depends(LoginService.get_current_user)] + request: Request, current_user: Annotated[CurrentUserModel, CurrentUserDependency()] ) -> Response: logger.info('获取成功') @@ -89,8 +90,8 @@ async def get_login_user_info( @login_controller.get('/getRouters') async def get_login_user_routers( request: Request, - current_user: Annotated[CurrentUserModel, Depends(LoginService.get_current_user)], - query_db: Annotated[AsyncSession, Depends(get_db)], + current_user: Annotated[CurrentUserModel, CurrentUserDependency()], + query_db: Annotated[AsyncSession, DBSessionDependency()], ) -> Response: logger.info('获取成功') user_routers = await LoginService.get_current_user_routers(current_user.user.user_id, query_db) @@ -102,7 +103,7 @@ async def get_login_user_routers( async def register_user( request: Request, user_register: UserRegister, - query_db: Annotated[AsyncSession, Depends(get_db)], + query_db: Annotated[AsyncSession, DBSessionDependency()], ) -> Response: user_register_result = await LoginService.register_user_services(request, query_db, user_register) logger.info(user_register_result.message) @@ -111,7 +112,7 @@ async def register_user( # @login_controller.post("/getSmsCode", response_model=SmsCode) -# async def get_sms_code(request: Request, user: ResetUserModel, query_db: AsyncSession = Depends(get_db)): +# async def get_sms_code(request: Request, user: ResetUserModel, query_db: AsyncSession = DBSessionDependency()): # try: # sms_result = await LoginService.get_sms_code_services(request, query_db, user) # if sms_result.is_success: @@ -126,7 +127,7 @@ async def register_user( # # # @login_controller.post("/forgetPwd", response_model=CrudResponseModel) -# async def forget_user_pwd(request: Request, forget_user: ResetUserModel, query_db: AsyncSession = Depends(get_db)): +# async def forget_user_pwd(request: Request, forget_user: ResetUserModel, query_db: AsyncSession = DBSessionDependency()): # 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 0359ab0..fd157d1 100644 --- a/ruoyi-fastapi-backend/module_admin/controller/menu_controller.py +++ b/ruoyi-fastapi-backend/module_admin/controller/menu_controller.py @@ -1,29 +1,29 @@ from datetime import datetime from typing import Annotated -from fastapi import APIRouter, Depends, Path, Query, Request, Response +from fastapi import APIRouter, Path, Query, Request, Response from pydantic_validation_decorator import ValidateFields from sqlalchemy.ext.asyncio import AsyncSession from common.annotation.log_annotation import Log -from common.aspect.interface_auth import CheckUserInterfaceAuth +from common.aspect.db_seesion import DBSessionDependency +from common.aspect.interface_auth import UserInterfaceAuthDependency +from common.aspect.pre_auth import CurrentUserDependency, PreAuthDependency from common.enums import BusinessType -from config.get_db import get_db from module_admin.entity.vo.menu_vo import DeleteMenuModel, MenuModel, MenuQueryModel from module_admin.entity.vo.user_vo import CurrentUserModel -from module_admin.service.login_service import LoginService from module_admin.service.menu_service import MenuService from utils.log_util import logger from utils.response_util import ResponseUtil -menu_controller = APIRouter(prefix='/system/menu', dependencies=[Depends(LoginService.get_current_user)]) +menu_controller = APIRouter(prefix='/system/menu', dependencies=[PreAuthDependency()]) @menu_controller.get('/treeselect') async def get_system_menu_tree( request: Request, - query_db: Annotated[AsyncSession, Depends(get_db)], - current_user: Annotated[CurrentUserModel, Depends(LoginService.get_current_user)], + query_db: Annotated[AsyncSession, DBSessionDependency()], + current_user: Annotated[CurrentUserModel, CurrentUserDependency()], ) -> Response: menu_query_result = await MenuService.get_menu_tree_services(query_db, current_user) logger.info('获取成功') @@ -35,8 +35,8 @@ async def get_system_menu_tree( async def get_system_role_menu_tree( request: Request, role_id: Annotated[int, Path(description='角色ID')], - query_db: Annotated[AsyncSession, Depends(get_db)], - current_user: Annotated[CurrentUserModel, Depends(LoginService.get_current_user)], + query_db: Annotated[AsyncSession, DBSessionDependency()], + current_user: Annotated[CurrentUserModel, CurrentUserDependency()], ) -> Response: role_menu_query_result = await MenuService.get_role_menu_tree_services(query_db, role_id, current_user) logger.info('获取成功') @@ -45,13 +45,15 @@ async def get_system_role_menu_tree( @menu_controller.get( - '/list', response_model=list[MenuModel], dependencies=[Depends(CheckUserInterfaceAuth('system:menu:list'))] + '/list', + response_model=list[MenuModel], + dependencies=[UserInterfaceAuthDependency('system:menu:list')], ) async def get_system_menu_list( request: Request, menu_query: Annotated[MenuQueryModel, Query()], - query_db: Annotated[AsyncSession, Depends(get_db)], - current_user: Annotated[CurrentUserModel, Depends(LoginService.get_current_user)], + query_db: Annotated[AsyncSession, DBSessionDependency()], + current_user: Annotated[CurrentUserModel, CurrentUserDependency()], ) -> Response: menu_query_result = await MenuService.get_menu_list_services(query_db, menu_query, current_user) logger.info('获取成功') @@ -59,14 +61,17 @@ async def get_system_menu_list( return ResponseUtil.success(data=menu_query_result) -@menu_controller.post('', dependencies=[Depends(CheckUserInterfaceAuth('system:menu:add'))]) +@menu_controller.post( + '', + dependencies=[UserInterfaceAuthDependency('system:menu:add')], +) @ValidateFields(validate_model='add_menu') @Log(title='菜单管理', business_type=BusinessType.INSERT) async def add_system_menu( request: Request, add_menu: MenuModel, - query_db: Annotated[AsyncSession, Depends(get_db)], - current_user: Annotated[CurrentUserModel, Depends(LoginService.get_current_user)], + query_db: Annotated[AsyncSession, DBSessionDependency()], + current_user: Annotated[CurrentUserModel, CurrentUserDependency()], ) -> Response: add_menu.create_by = current_user.user.user_name add_menu.create_time = datetime.now() @@ -78,14 +83,17 @@ async def add_system_menu( return ResponseUtil.success(msg=add_menu_result.message) -@menu_controller.put('', dependencies=[Depends(CheckUserInterfaceAuth('system:menu:edit'))]) +@menu_controller.put( + '', + dependencies=[UserInterfaceAuthDependency('system:menu:edit')], +) @ValidateFields(validate_model='edit_menu') @Log(title='菜单管理', business_type=BusinessType.UPDATE) async def edit_system_menu( request: Request, edit_menu: MenuModel, - query_db: Annotated[AsyncSession, Depends(get_db)], - current_user: Annotated[CurrentUserModel, Depends(LoginService.get_current_user)], + query_db: Annotated[AsyncSession, DBSessionDependency()], + current_user: Annotated[CurrentUserModel, CurrentUserDependency()], ) -> Response: edit_menu.update_by = current_user.user.user_name edit_menu.update_time = datetime.now() @@ -95,12 +103,15 @@ async def edit_system_menu( return ResponseUtil.success(msg=edit_menu_result.message) -@menu_controller.delete('/{menu_ids}', dependencies=[Depends(CheckUserInterfaceAuth('system:menu:remove'))]) +@menu_controller.delete( + '/{menu_ids}', + dependencies=[UserInterfaceAuthDependency('system:menu:remove')], +) @Log(title='菜单管理', business_type=BusinessType.DELETE) async def delete_system_menu( request: Request, menu_ids: Annotated[str, Path(description='需要删除的菜单ID')], - query_db: Annotated[AsyncSession, Depends(get_db)], + query_db: Annotated[AsyncSession, DBSessionDependency()], ) -> Response: delete_menu = DeleteMenuModel(menuIds=menu_ids) delete_menu_result = await MenuService.delete_menu_services(query_db, delete_menu) @@ -110,12 +121,14 @@ async def delete_system_menu( @menu_controller.get( - '/{menu_id}', response_model=MenuModel, dependencies=[Depends(CheckUserInterfaceAuth('system:menu:query'))] + '/{menu_id}', + response_model=MenuModel, + dependencies=[UserInterfaceAuthDependency('system:menu:query')], ) async def query_detail_system_menu( request: Request, menu_id: Annotated[int, Path(description='菜单ID')], - query_db: Annotated[AsyncSession, Depends(get_db)], + query_db: Annotated[AsyncSession, DBSessionDependency()], ) -> Response: menu_detail_result = await MenuService.menu_detail_services(query_db, menu_id) logger.info(f'获取menu_id为{menu_id}的信息成功') diff --git a/ruoyi-fastapi-backend/module_admin/controller/notice_controller.py b/ruoyi-fastapi-backend/module_admin/controller/notice_controller.py index 8dcb2cf..e4987d2 100644 --- a/ruoyi-fastapi-backend/module_admin/controller/notice_controller.py +++ b/ruoyi-fastapi-backend/module_admin/controller/notice_controller.py @@ -1,32 +1,34 @@ from datetime import datetime from typing import Annotated -from fastapi import APIRouter, Depends, Path, Query, Request, Response +from fastapi import APIRouter, Path, Query, Request, Response from pydantic_validation_decorator import ValidateFields from sqlalchemy.ext.asyncio import AsyncSession from common.annotation.log_annotation import Log -from common.aspect.interface_auth import CheckUserInterfaceAuth +from common.aspect.db_seesion import DBSessionDependency +from common.aspect.interface_auth import UserInterfaceAuthDependency +from common.aspect.pre_auth import CurrentUserDependency, PreAuthDependency from common.enums import BusinessType -from config.get_db import get_db from module_admin.entity.vo.notice_vo import DeleteNoticeModel, NoticeModel, NoticePageQueryModel from module_admin.entity.vo.user_vo import CurrentUserModel -from module_admin.service.login_service import LoginService from module_admin.service.notice_service import NoticeService from utils.log_util import logger from utils.page_util import PageResponseModel from utils.response_util import ResponseUtil -notice_controller = APIRouter(prefix='/system/notice', dependencies=[Depends(LoginService.get_current_user)]) +notice_controller = APIRouter(prefix='/system/notice', dependencies=[PreAuthDependency()]) @notice_controller.get( - '/list', response_model=PageResponseModel, dependencies=[Depends(CheckUserInterfaceAuth('system:notice:list'))] + '/list', + response_model=PageResponseModel, + dependencies=[UserInterfaceAuthDependency('system:notice:list')], ) async def get_system_notice_list( request: Request, notice_page_query: Annotated[NoticePageQueryModel, Query()], - query_db: Annotated[AsyncSession, Depends(get_db)], + query_db: Annotated[AsyncSession, DBSessionDependency()], ) -> Response: # 获取分页数据 notice_page_query_result = await NoticeService.get_notice_list_services(query_db, notice_page_query, is_page=True) @@ -35,14 +37,17 @@ async def get_system_notice_list( return ResponseUtil.success(model_content=notice_page_query_result) -@notice_controller.post('', dependencies=[Depends(CheckUserInterfaceAuth('system:notice:add'))]) +@notice_controller.post( + '', + dependencies=[UserInterfaceAuthDependency('system:notice:add')], +) @ValidateFields(validate_model='add_notice') @Log(title='通知公告', business_type=BusinessType.INSERT) async def add_system_notice( request: Request, add_notice: NoticeModel, - query_db: Annotated[AsyncSession, Depends(get_db)], - current_user: Annotated[CurrentUserModel, Depends(LoginService.get_current_user)], + query_db: Annotated[AsyncSession, DBSessionDependency()], + current_user: Annotated[CurrentUserModel, CurrentUserDependency()], ) -> Response: add_notice.create_by = current_user.user.user_name add_notice.create_time = datetime.now() @@ -54,14 +59,17 @@ async def add_system_notice( return ResponseUtil.success(msg=add_notice_result.message) -@notice_controller.put('', dependencies=[Depends(CheckUserInterfaceAuth('system:notice:edit'))]) +@notice_controller.put( + '', + dependencies=[UserInterfaceAuthDependency('system:notice:edit')], +) @ValidateFields(validate_model='edit_notice') @Log(title='通知公告', business_type=BusinessType.UPDATE) async def edit_system_notice( request: Request, edit_notice: NoticeModel, - query_db: Annotated[AsyncSession, Depends(get_db)], - current_user: Annotated[CurrentUserModel, Depends(LoginService.get_current_user)], + query_db: Annotated[AsyncSession, DBSessionDependency()], + current_user: Annotated[CurrentUserModel, CurrentUserDependency()], ) -> Response: edit_notice.update_by = current_user.user.user_name edit_notice.update_time = datetime.now() @@ -71,12 +79,15 @@ async def edit_system_notice( return ResponseUtil.success(msg=edit_notice_result.message) -@notice_controller.delete('/{notice_ids}', dependencies=[Depends(CheckUserInterfaceAuth('system:notice:remove'))]) +@notice_controller.delete( + '/{notice_ids}', + dependencies=[UserInterfaceAuthDependency('system:notice:remove')], +) @Log(title='通知公告', business_type=BusinessType.DELETE) async def delete_system_notice( request: Request, notice_ids: Annotated[str, Path(description='需要删除的公告ID')], - query_db: Annotated[AsyncSession, Depends(get_db)], + query_db: Annotated[AsyncSession, DBSessionDependency()], ) -> Response: delete_notice = DeleteNoticeModel(noticeIds=notice_ids) delete_notice_result = await NoticeService.delete_notice_services(query_db, delete_notice) @@ -86,12 +97,14 @@ async def delete_system_notice( @notice_controller.get( - '/{notice_id}', response_model=NoticeModel, dependencies=[Depends(CheckUserInterfaceAuth('system:notice:query'))] + '/{notice_id}', + response_model=NoticeModel, + dependencies=[UserInterfaceAuthDependency('system:notice:query')], ) async def query_detail_system_post( request: Request, notice_id: Annotated[int, Path(description='公告ID')], - query_db: Annotated[AsyncSession, Depends(get_db)], + query_db: Annotated[AsyncSession, DBSessionDependency()], ) -> Response: notice_detail_result = await NoticeService.notice_detail_services(query_db, notice_id) logger.info(f'获取notice_id为{notice_id}的信息成功') diff --git a/ruoyi-fastapi-backend/module_admin/controller/online_controller.py b/ruoyi-fastapi-backend/module_admin/controller/online_controller.py index 4fde252..b84f1bf 100644 --- a/ruoyi-fastapi-backend/module_admin/controller/online_controller.py +++ b/ruoyi-fastapi-backend/module_admin/controller/online_controller.py @@ -1,24 +1,26 @@ from typing import Annotated -from fastapi import APIRouter, Depends, Path, Query, Request, Response +from fastapi import APIRouter, Path, Query, Request, Response from sqlalchemy.ext.asyncio import AsyncSession from common.annotation.log_annotation import Log -from common.aspect.interface_auth import CheckUserInterfaceAuth +from common.aspect.db_seesion import DBSessionDependency +from common.aspect.interface_auth import UserInterfaceAuthDependency +from common.aspect.pre_auth import PreAuthDependency from common.enums import BusinessType -from config.get_db import get_db from module_admin.entity.vo.online_vo import DeleteOnlineModel, OnlineQueryModel -from module_admin.service.login_service import LoginService from module_admin.service.online_service import OnlineService from utils.log_util import logger from utils.page_util import PageResponseModel from utils.response_util import ResponseUtil -online_controller = APIRouter(prefix='/monitor/online', dependencies=[Depends(LoginService.get_current_user)]) +online_controller = APIRouter(prefix='/monitor/online', dependencies=[PreAuthDependency()]) @online_controller.get( - '/list', response_model=PageResponseModel, dependencies=[Depends(CheckUserInterfaceAuth('monitor:online:list'))] + '/list', + response_model=PageResponseModel, + dependencies=[UserInterfaceAuthDependency('monitor:online:list')], ) async def get_monitor_online_list( request: Request, @@ -33,12 +35,15 @@ async def get_monitor_online_list( ) -@online_controller.delete('/{token_ids}', dependencies=[Depends(CheckUserInterfaceAuth('monitor:online:forceLogout'))]) +@online_controller.delete( + '/{token_ids}', + dependencies=[UserInterfaceAuthDependency('monitor:online:forceLogout')], +) @Log(title='在线用户', business_type=BusinessType.FORCE) async def delete_monitor_online( request: Request, token_ids: Annotated[str, Path(description='需要强退的会话编号')], - query_db: Annotated[AsyncSession, Depends(get_db)], + query_db: Annotated[AsyncSession, DBSessionDependency()], ) -> Response: 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_controller.py b/ruoyi-fastapi-backend/module_admin/controller/post_controller.py index 64368ae..c03f40b 100644 --- a/ruoyi-fastapi-backend/module_admin/controller/post_controller.py +++ b/ruoyi-fastapi-backend/module_admin/controller/post_controller.py @@ -1,33 +1,35 @@ from datetime import datetime from typing import Annotated -from fastapi import APIRouter, Depends, Form, Path, Query, Request, Response +from fastapi import APIRouter, Form, Path, Query, Request, Response from pydantic_validation_decorator import ValidateFields from sqlalchemy.ext.asyncio import AsyncSession from common.annotation.log_annotation import Log -from common.aspect.interface_auth import CheckUserInterfaceAuth +from common.aspect.db_seesion import DBSessionDependency +from common.aspect.interface_auth import UserInterfaceAuthDependency +from common.aspect.pre_auth import CurrentUserDependency, PreAuthDependency from common.enums import BusinessType -from config.get_db import get_db from module_admin.entity.vo.post_vo import DeletePostModel, PostModel, PostPageQueryModel from module_admin.entity.vo.user_vo import CurrentUserModel -from module_admin.service.login_service import LoginService from module_admin.service.post_service import PostService from utils.common_util import bytes2file_response from utils.log_util import logger from utils.page_util import PageResponseModel from utils.response_util import ResponseUtil -post_controller = APIRouter(prefix='/system/post', dependencies=[Depends(LoginService.get_current_user)]) +post_controller = APIRouter(prefix='/system/post', dependencies=[PreAuthDependency()]) @post_controller.get( - '/list', response_model=PageResponseModel, dependencies=[Depends(CheckUserInterfaceAuth('system:post:list'))] + '/list', + response_model=PageResponseModel, + dependencies=[UserInterfaceAuthDependency('system:post:list')], ) async def get_system_post_list( request: Request, post_page_query: Annotated[PostPageQueryModel, Query()], - query_db: Annotated[AsyncSession, Depends(get_db)], + query_db: Annotated[AsyncSession, DBSessionDependency()], ) -> Response: # 获取分页数据 post_page_query_result = await PostService.get_post_list_services(query_db, post_page_query, is_page=True) @@ -36,14 +38,17 @@ async def get_system_post_list( return ResponseUtil.success(model_content=post_page_query_result) -@post_controller.post('', dependencies=[Depends(CheckUserInterfaceAuth('system:post:add'))]) +@post_controller.post( + '', + dependencies=[UserInterfaceAuthDependency('system:post:add')], +) @ValidateFields(validate_model='add_post') @Log(title='岗位管理', business_type=BusinessType.INSERT) async def add_system_post( request: Request, add_post: PostModel, - query_db: Annotated[AsyncSession, Depends(get_db)], - current_user: Annotated[CurrentUserModel, Depends(LoginService.get_current_user)], + query_db: Annotated[AsyncSession, DBSessionDependency()], + current_user: Annotated[CurrentUserModel, CurrentUserDependency()], ) -> Response: add_post.create_by = current_user.user.user_name add_post.create_time = datetime.now() @@ -55,14 +60,17 @@ async def add_system_post( return ResponseUtil.success(msg=add_post_result.message) -@post_controller.put('', dependencies=[Depends(CheckUserInterfaceAuth('system:post:edit'))]) +@post_controller.put( + '', + dependencies=[UserInterfaceAuthDependency('system:post:edit')], +) @ValidateFields(validate_model='edit_post') @Log(title='岗位管理', business_type=BusinessType.UPDATE) async def edit_system_post( request: Request, edit_post: PostModel, - query_db: Annotated[AsyncSession, Depends(get_db)], - current_user: Annotated[CurrentUserModel, Depends(LoginService.get_current_user)], + query_db: Annotated[AsyncSession, DBSessionDependency()], + current_user: Annotated[CurrentUserModel, CurrentUserDependency()], ) -> Response: edit_post.update_by = current_user.user.user_name edit_post.update_time = datetime.now() @@ -72,12 +80,15 @@ async def edit_system_post( return ResponseUtil.success(msg=edit_post_result.message) -@post_controller.delete('/{post_ids}', dependencies=[Depends(CheckUserInterfaceAuth('system:post:remove'))]) +@post_controller.delete( + '/{post_ids}', + dependencies=[UserInterfaceAuthDependency('system:post:remove')], +) @Log(title='岗位管理', business_type=BusinessType.DELETE) async def delete_system_post( request: Request, post_ids: Annotated[str, Path(description='需要删除的岗位ID')], - query_db: Annotated[AsyncSession, Depends(get_db)], + query_db: Annotated[AsyncSession, DBSessionDependency()], ) -> Response: delete_post = DeletePostModel(postIds=post_ids) delete_post_result = await PostService.delete_post_services(query_db, delete_post) @@ -87,12 +98,14 @@ async def delete_system_post( @post_controller.get( - '/{post_id}', response_model=PostModel, dependencies=[Depends(CheckUserInterfaceAuth('system:post:query'))] + '/{post_id}', + response_model=PostModel, + dependencies=[UserInterfaceAuthDependency('system:post:query')], ) async def query_detail_system_post( request: Request, post_id: Annotated[int, Path(description='岗位ID')], - query_db: Annotated[AsyncSession, Depends(get_db)], + query_db: Annotated[AsyncSession, DBSessionDependency()], ) -> Response: post_detail_result = await PostService.post_detail_services(query_db, post_id) logger.info(f'获取post_id为{post_id}的信息成功') @@ -100,12 +113,15 @@ async def query_detail_system_post( return ResponseUtil.success(data=post_detail_result) -@post_controller.post('/export', dependencies=[Depends(CheckUserInterfaceAuth('system:post:export'))]) +@post_controller.post( + '/export', + dependencies=[UserInterfaceAuthDependency('system:post:export')], +) @Log(title='岗位管理', business_type=BusinessType.EXPORT) async def export_system_post_list( request: Request, post_page_query: Annotated[PostPageQueryModel, Form()], - query_db: Annotated[AsyncSession, Depends(get_db)], + query_db: Annotated[AsyncSession, DBSessionDependency()], ) -> Response: # 获取全量数据 post_query_result = await PostService.get_post_list_services(query_db, post_page_query, is_page=False) diff --git a/ruoyi-fastapi-backend/module_admin/controller/role_controller.py b/ruoyi-fastapi-backend/module_admin/controller/role_controller.py index c13bf55..e5fe7a2 100644 --- a/ruoyi-fastapi-backend/module_admin/controller/role_controller.py +++ b/ruoyi-fastapi-backend/module_admin/controller/role_controller.py @@ -1,20 +1,20 @@ from datetime import datetime from typing import Annotated -from fastapi import APIRouter, Depends, Form, Path, Query, Request, Response +from fastapi import APIRouter, Form, Path, Query, Request, Response from pydantic_validation_decorator import ValidateFields from sqlalchemy.ext.asyncio import AsyncSession from common.annotation.log_annotation import Log -from common.aspect.data_scope import GetDataScope -from common.aspect.interface_auth import CheckUserInterfaceAuth +from common.aspect.data_scope import DataScopeDependency +from common.aspect.db_seesion import DBSessionDependency +from common.aspect.interface_auth import UserInterfaceAuthDependency +from common.aspect.pre_auth import CurrentUserDependency, PreAuthDependency from common.enums import BusinessType -from config.get_db import get_db from module_admin.entity.vo.dept_vo import DeptModel from module_admin.entity.vo.role_vo import AddRoleModel, DeleteRoleModel, RoleModel, RolePageQueryModel from module_admin.entity.vo.user_vo import CrudUserRoleModel, CurrentUserModel, UserRolePageQueryModel from module_admin.service.dept_service import DeptService -from module_admin.service.login_service import LoginService from module_admin.service.role_service import RoleService from module_admin.service.user_service import UserService from utils.common_util import bytes2file_response @@ -22,15 +22,18 @@ from utils.log_util import logger from utils.page_util import PageResponseModel from utils.response_util import ResponseUtil -role_controller = APIRouter(prefix='/system/role', dependencies=[Depends(LoginService.get_current_user)]) +role_controller = APIRouter(prefix='/system/role', dependencies=[PreAuthDependency()]) -@role_controller.get('/deptTree/{role_id}', dependencies=[Depends(CheckUserInterfaceAuth('system:role:query'))]) +@role_controller.get( + '/deptTree/{role_id}', + dependencies=[UserInterfaceAuthDependency('system:role:query')], +) async def get_system_role_dept_tree( request: Request, role_id: Annotated[int, Path(description='角色ID')], - query_db: Annotated[AsyncSession, Depends(get_db)], - data_scope_sql: Annotated[str, Depends(GetDataScope('SysDept'))], + query_db: Annotated[AsyncSession, DBSessionDependency()], + data_scope_sql: Annotated[str, DataScopeDependency('SysDept')], ) -> Response: 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) @@ -41,13 +44,15 @@ async def get_system_role_dept_tree( @role_controller.get( - '/list', response_model=PageResponseModel, dependencies=[Depends(CheckUserInterfaceAuth('system:role:list'))] + '/list', + response_model=PageResponseModel, + dependencies=[UserInterfaceAuthDependency('system:role:list')], ) async def get_system_role_list( request: Request, role_page_query: Annotated[RolePageQueryModel, Query()], - query_db: Annotated[AsyncSession, Depends(get_db)], - data_scope_sql: Annotated[str, Depends(GetDataScope('SysDept'))], + query_db: Annotated[AsyncSession, DBSessionDependency()], + data_scope_sql: Annotated[str, DataScopeDependency('SysDept')], ) -> Response: role_page_query_result = await RoleService.get_role_list_services( query_db, role_page_query, data_scope_sql, is_page=True @@ -57,14 +62,17 @@ async def get_system_role_list( return ResponseUtil.success(model_content=role_page_query_result) -@role_controller.post('', dependencies=[Depends(CheckUserInterfaceAuth('system:role:add'))]) +@role_controller.post( + '', + dependencies=[UserInterfaceAuthDependency('system:role:add')], +) @ValidateFields(validate_model='add_role') @Log(title='角色管理', business_type=BusinessType.INSERT) async def add_system_role( request: Request, add_role: AddRoleModel, - query_db: Annotated[AsyncSession, Depends(get_db)], - current_user: Annotated[CurrentUserModel, Depends(LoginService.get_current_user)], + query_db: Annotated[AsyncSession, DBSessionDependency()], + current_user: Annotated[CurrentUserModel, CurrentUserDependency()], ) -> Response: add_role.create_by = current_user.user.user_name add_role.create_time = datetime.now() @@ -76,15 +84,18 @@ async def add_system_role( return ResponseUtil.success(msg=add_role_result.message) -@role_controller.put('', dependencies=[Depends(CheckUserInterfaceAuth('system:role:edit'))]) +@role_controller.put( + '', + dependencies=[UserInterfaceAuthDependency('system:role:edit')], +) @ValidateFields(validate_model='edit_role') @Log(title='角色管理', business_type=BusinessType.UPDATE) async def edit_system_role( request: Request, edit_role: AddRoleModel, - query_db: Annotated[AsyncSession, Depends(get_db)], - current_user: Annotated[CurrentUserModel, Depends(LoginService.get_current_user)], - data_scope_sql: Annotated[str, Depends(GetDataScope('SysDept'))], + query_db: Annotated[AsyncSession, DBSessionDependency()], + current_user: Annotated[CurrentUserModel, CurrentUserDependency()], + data_scope_sql: Annotated[str, DataScopeDependency('SysDept')], ) -> Response: await RoleService.check_role_allowed_services(edit_role) if not current_user.user.admin: @@ -97,14 +108,17 @@ async def edit_system_role( return ResponseUtil.success(msg=edit_role_result.message) -@role_controller.put('/dataScope', dependencies=[Depends(CheckUserInterfaceAuth('system:role:edit'))]) +@role_controller.put( + '/dataScope', + dependencies=[UserInterfaceAuthDependency('system:role:edit')], +) @Log(title='角色管理', business_type=BusinessType.GRANT) async def edit_system_role_datascope( request: Request, role_data_scope: AddRoleModel, - query_db: Annotated[AsyncSession, Depends(get_db)], - current_user: Annotated[CurrentUserModel, Depends(LoginService.get_current_user)], - data_scope_sql: Annotated[str, Depends(GetDataScope('SysDept'))], + query_db: Annotated[AsyncSession, DBSessionDependency()], + current_user: Annotated[CurrentUserModel, CurrentUserDependency()], + data_scope_sql: Annotated[str, DataScopeDependency('SysDept')], ) -> Response: await RoleService.check_role_allowed_services(role_data_scope) if not current_user.user.admin: @@ -123,14 +137,17 @@ async def edit_system_role_datascope( return ResponseUtil.success(msg=role_data_scope_result.message) -@role_controller.delete('/{role_ids}', dependencies=[Depends(CheckUserInterfaceAuth('system:role:remove'))]) +@role_controller.delete( + '/{role_ids}', + dependencies=[UserInterfaceAuthDependency('system:role:remove')], +) @Log(title='角色管理', business_type=BusinessType.DELETE) async def delete_system_role( request: Request, role_ids: Annotated[str, Path(description='需要删除的角色ID')], - query_db: Annotated[AsyncSession, Depends(get_db)], - current_user: Annotated[CurrentUserModel, Depends(LoginService.get_current_user)], - data_scope_sql: Annotated[str, Depends(GetDataScope('SysDept'))], + query_db: Annotated[AsyncSession, DBSessionDependency()], + current_user: Annotated[CurrentUserModel, CurrentUserDependency()], + data_scope_sql: Annotated[str, DataScopeDependency('SysDept')], ) -> Response: role_id_list = role_ids.split(',') if role_ids else [] if role_id_list: @@ -146,14 +163,16 @@ async def delete_system_role( @role_controller.get( - '/{role_id}', response_model=RoleModel, dependencies=[Depends(CheckUserInterfaceAuth('system:role:query'))] + '/{role_id}', + response_model=RoleModel, + dependencies=[UserInterfaceAuthDependency('system:role:query')], ) async def query_detail_system_role( request: Request, role_id: Annotated[int, Path(description='角色ID')], - query_db: Annotated[AsyncSession, Depends(get_db)], - current_user: Annotated[CurrentUserModel, Depends(LoginService.get_current_user)], - data_scope_sql: Annotated[str, Depends(GetDataScope('SysDept'))], + query_db: Annotated[AsyncSession, DBSessionDependency()], + current_user: Annotated[CurrentUserModel, CurrentUserDependency()], + data_scope_sql: Annotated[str, DataScopeDependency('SysDept')], ) -> Response: if not current_user.user.admin: await RoleService.check_role_data_scope_services(query_db, str(role_id), data_scope_sql) @@ -163,13 +182,16 @@ async def query_detail_system_role( return ResponseUtil.success(data=role_detail_result.model_dump(by_alias=True)) -@role_controller.post('/export', dependencies=[Depends(CheckUserInterfaceAuth('system:role:export'))]) +@role_controller.post( + '/export', + dependencies=[UserInterfaceAuthDependency('system:role:export')], +) @Log(title='角色管理', business_type=BusinessType.EXPORT) async def export_system_role_list( request: Request, role_page_query: Annotated[RolePageQueryModel, Form()], - query_db: Annotated[AsyncSession, Depends(get_db)], - data_scope_sql: Annotated[str, Depends(GetDataScope('SysDept'))], + query_db: Annotated[AsyncSession, DBSessionDependency()], + data_scope_sql: Annotated[str, DataScopeDependency('SysDept')], ) -> Response: # 获取全量数据 role_query_result = await RoleService.get_role_list_services( @@ -181,14 +203,17 @@ async def export_system_role_list( return ResponseUtil.streaming(data=bytes2file_response(role_export_result)) -@role_controller.put('/changeStatus', dependencies=[Depends(CheckUserInterfaceAuth('system:role:edit'))]) +@role_controller.put( + '/changeStatus', + dependencies=[UserInterfaceAuthDependency('system:role:edit')], +) @Log(title='角色管理', business_type=BusinessType.UPDATE) async def reset_system_role_status( request: Request, change_role: AddRoleModel, - query_db: Annotated[AsyncSession, Depends(get_db)], - current_user: Annotated[CurrentUserModel, Depends(LoginService.get_current_user)], - data_scope_sql: Annotated[str, Depends(GetDataScope('SysDept'))], + query_db: Annotated[AsyncSession, DBSessionDependency()], + current_user: Annotated[CurrentUserModel, CurrentUserDependency()], + data_scope_sql: Annotated[str, DataScopeDependency('SysDept')], ) -> Response: await RoleService.check_role_allowed_services(change_role) if not current_user.user.admin: @@ -209,13 +234,13 @@ async def reset_system_role_status( @role_controller.get( '/authUser/allocatedList', response_model=PageResponseModel, - dependencies=[Depends(CheckUserInterfaceAuth('system:role:list'))], + dependencies=[UserInterfaceAuthDependency('system:role:list')], ) async def get_system_allocated_user_list( request: Request, user_role: Annotated[UserRolePageQueryModel, Query()], - query_db: Annotated[AsyncSession, Depends(get_db)], - data_scope_sql: Annotated[str, Depends(GetDataScope('SysUser'))], + query_db: Annotated[AsyncSession, DBSessionDependency()], + data_scope_sql: Annotated[str, DataScopeDependency('SysUser')], ) -> Response: role_user_allocated_page_query_result = await RoleService.get_role_user_allocated_list_services( query_db, user_role, data_scope_sql, is_page=True @@ -228,13 +253,13 @@ async def get_system_allocated_user_list( @role_controller.get( '/authUser/unallocatedList', response_model=PageResponseModel, - dependencies=[Depends(CheckUserInterfaceAuth('system:role:list'))], + dependencies=[UserInterfaceAuthDependency('system:role:list')], ) async def get_system_unallocated_user_list( request: Request, user_role: Annotated[UserRolePageQueryModel, Query()], - query_db: Annotated[AsyncSession, Depends(get_db)], - data_scope_sql: Annotated[str, Depends(GetDataScope('SysUser'))], + query_db: Annotated[AsyncSession, DBSessionDependency()], + data_scope_sql: Annotated[str, DataScopeDependency('SysUser')], ) -> Response: role_user_unallocated_page_query_result = await RoleService.get_role_user_unallocated_list_services( query_db, user_role, data_scope_sql, is_page=True @@ -244,14 +269,17 @@ async def get_system_unallocated_user_list( return ResponseUtil.success(model_content=role_user_unallocated_page_query_result) -@role_controller.put('/authUser/selectAll', dependencies=[Depends(CheckUserInterfaceAuth('system:role:edit'))]) +@role_controller.put( + '/authUser/selectAll', + dependencies=[UserInterfaceAuthDependency('system:role:edit')], +) @Log(title='角色管理', business_type=BusinessType.GRANT) async def add_system_role_user( request: Request, add_role_user: Annotated[CrudUserRoleModel, Query()], - query_db: Annotated[AsyncSession, Depends(get_db)], - current_user: Annotated[CurrentUserModel, Depends(LoginService.get_current_user)], - data_scope_sql: Annotated[str, Depends(GetDataScope('SysDept'))], + query_db: Annotated[AsyncSession, DBSessionDependency()], + current_user: Annotated[CurrentUserModel, CurrentUserDependency()], + data_scope_sql: Annotated[str, DataScopeDependency('SysDept')], ) -> Response: if not current_user.user.admin: await RoleService.check_role_data_scope_services(query_db, str(add_role_user.role_id), data_scope_sql) @@ -261,12 +289,15 @@ async def add_system_role_user( return ResponseUtil.success(msg=add_role_user_result.message) -@role_controller.put('/authUser/cancel', dependencies=[Depends(CheckUserInterfaceAuth('system:role:edit'))]) +@role_controller.put( + '/authUser/cancel', + dependencies=[UserInterfaceAuthDependency('system:role:edit')], +) @Log(title='角色管理', business_type=BusinessType.GRANT) async def cancel_system_role_user( request: Request, cancel_user_role: CrudUserRoleModel, - query_db: Annotated[AsyncSession, Depends(get_db)], + query_db: Annotated[AsyncSession, DBSessionDependency()], ) -> Response: cancel_user_role_result = await UserService.delete_user_role_services(query_db, cancel_user_role) logger.info(cancel_user_role_result.message) @@ -274,12 +305,15 @@ async def cancel_system_role_user( return ResponseUtil.success(msg=cancel_user_role_result.message) -@role_controller.put('/authUser/cancelAll', dependencies=[Depends(CheckUserInterfaceAuth('system:role:edit'))]) +@role_controller.put( + '/authUser/cancelAll', + dependencies=[UserInterfaceAuthDependency('system:role:edit')], +) @Log(title='角色管理', business_type=BusinessType.GRANT) async def batch_cancel_system_role_user( request: Request, batch_cancel_user_role: Annotated[CrudUserRoleModel, Query()], - query_db: Annotated[AsyncSession, Depends(get_db)], + query_db: Annotated[AsyncSession, DBSessionDependency()], ) -> Response: batch_cancel_user_role_result = await UserService.delete_user_role_services(query_db, batch_cancel_user_role) logger.info(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 ed1bffb..acbcdf1 100644 --- a/ruoyi-fastapi-backend/module_admin/controller/server_controller.py +++ b/ruoyi-fastapi-backend/module_admin/controller/server_controller.py @@ -1,17 +1,19 @@ -from fastapi import APIRouter, Depends, Request, Response +from fastapi import APIRouter, Request, Response -from common.aspect.interface_auth import CheckUserInterfaceAuth +from common.aspect.interface_auth import UserInterfaceAuthDependency +from common.aspect.pre_auth import PreAuthDependency from module_admin.entity.vo.server_vo import ServerMonitorModel -from module_admin.service.login_service import LoginService from module_admin.service.server_service import ServerService from utils.log_util import logger from utils.response_util import ResponseUtil -server_controller = APIRouter(prefix='/monitor/server', dependencies=[Depends(LoginService.get_current_user)]) +server_controller = APIRouter(prefix='/monitor/server', dependencies=[PreAuthDependency()]) @server_controller.get( - '', response_model=ServerMonitorModel, dependencies=[Depends(CheckUserInterfaceAuth('monitor:server:list'))] + '', + response_model=ServerMonitorModel, + dependencies=[UserInterfaceAuthDependency('monitor:server:list')], ) async def get_monitor_server_info(request: Request) -> Response: # 获取全量数据 diff --git a/ruoyi-fastapi-backend/module_admin/controller/user_controller.py b/ruoyi-fastapi-backend/module_admin/controller/user_controller.py index b8cdc5a..f568799 100644 --- a/ruoyi-fastapi-backend/module_admin/controller/user_controller.py +++ b/ruoyi-fastapi-backend/module_admin/controller/user_controller.py @@ -3,16 +3,17 @@ from datetime import datetime from typing import Annotated, Literal, Optional, Union import aiofiles -from fastapi import APIRouter, Depends, File, Form, Path, Query, Request, Response, UploadFile +from fastapi import APIRouter, File, Form, Path, Query, Request, Response, UploadFile from pydantic_validation_decorator import ValidateFields from sqlalchemy.ext.asyncio import AsyncSession from common.annotation.log_annotation import Log -from common.aspect.data_scope import GetDataScope -from common.aspect.interface_auth import CheckUserInterfaceAuth +from common.aspect.data_scope import DataScopeDependency +from common.aspect.db_seesion import DBSessionDependency +from common.aspect.interface_auth import UserInterfaceAuthDependency +from common.aspect.pre_auth import CurrentUserDependency, PreAuthDependency from common.enums import BusinessType from config.env import UploadConfig -from config.get_db import get_db from module_admin.entity.vo.dept_vo import DeptModel from module_admin.entity.vo.user_vo import ( AddUserModel, @@ -31,7 +32,6 @@ from module_admin.entity.vo.user_vo import ( UserRoleResponseModel, ) from module_admin.service.dept_service import DeptService -from module_admin.service.login_service import LoginService from module_admin.service.role_service import RoleService from module_admin.service.user_service import UserService from utils.common_util import bytes2file_response @@ -41,14 +41,17 @@ from utils.pwd_util import PwdUtil from utils.response_util import ResponseUtil from utils.upload_util import UploadUtil -user_controller = APIRouter(prefix='/system/user', dependencies=[Depends(LoginService.get_current_user)]) +user_controller = APIRouter(prefix='/system/user', dependencies=[PreAuthDependency()]) -@user_controller.get('/deptTree', dependencies=[Depends(CheckUserInterfaceAuth('system:user:list'))]) +@user_controller.get( + '/deptTree', + dependencies=[UserInterfaceAuthDependency('system:user:list')], +) async def get_system_dept_tree( request: Request, - query_db: Annotated[AsyncSession, Depends(get_db)], - data_scope_sql: Annotated[str, Depends(GetDataScope('SysDept'))], + query_db: Annotated[AsyncSession, DBSessionDependency()], + data_scope_sql: Annotated[str, DataScopeDependency('SysDept')], ) -> Response: dept_query_result = await DeptService.get_dept_tree_services(query_db, DeptModel(), data_scope_sql) logger.info('获取成功') @@ -57,13 +60,15 @@ async def get_system_dept_tree( @user_controller.get( - '/list', response_model=PageResponseModel, dependencies=[Depends(CheckUserInterfaceAuth('system:user:list'))] + '/list', + response_model=PageResponseModel, + dependencies=[UserInterfaceAuthDependency('system:user:list')], ) async def get_system_user_list( request: Request, user_page_query: Annotated[UserPageQueryModel, Query()], - query_db: Annotated[AsyncSession, Depends(get_db)], - data_scope_sql: Annotated[str, Depends(GetDataScope('SysUser'))], + query_db: Annotated[AsyncSession, DBSessionDependency()], + data_scope_sql: Annotated[str, DataScopeDependency('SysUser')], ) -> Response: # 获取分页数据 user_page_query_result = await UserService.get_user_list_services( @@ -74,16 +79,19 @@ async def get_system_user_list( return ResponseUtil.success(model_content=user_page_query_result) -@user_controller.post('', dependencies=[Depends(CheckUserInterfaceAuth('system:user:add'))]) +@user_controller.post( + '', + dependencies=[UserInterfaceAuthDependency('system:user:add')], +) @ValidateFields(validate_model='add_user') @Log(title='用户管理', business_type=BusinessType.INSERT) async def add_system_user( request: Request, add_user: AddUserModel, - query_db: Annotated[AsyncSession, Depends(get_db)], - current_user: Annotated[CurrentUserModel, Depends(LoginService.get_current_user)], - dept_data_scope_sql: Annotated[str, Depends(GetDataScope('SysDept'))], - role_data_scope_sql: Annotated[str, Depends(GetDataScope('SysDept'))], + query_db: Annotated[AsyncSession, DBSessionDependency()], + current_user: Annotated[CurrentUserModel, CurrentUserDependency()], + dept_data_scope_sql: Annotated[str, DataScopeDependency('SysDept')], + role_data_scope_sql: Annotated[str, DataScopeDependency('SysDept')], ) -> Response: if not current_user.user.admin: await DeptService.check_dept_data_scope_services(query_db, add_user.dept_id, dept_data_scope_sql) @@ -101,17 +109,20 @@ async def add_system_user( return ResponseUtil.success(msg=add_user_result.message) -@user_controller.put('', dependencies=[Depends(CheckUserInterfaceAuth('system:user:edit'))]) +@user_controller.put( + '', + dependencies=[UserInterfaceAuthDependency('system:user:edit')], +) @ValidateFields(validate_model='edit_user') @Log(title='用户管理', business_type=BusinessType.UPDATE) async def edit_system_user( request: Request, edit_user: EditUserModel, - query_db: Annotated[AsyncSession, Depends(get_db)], - current_user: Annotated[CurrentUserModel, Depends(LoginService.get_current_user)], - user_data_scope_sql: Annotated[str, Depends(GetDataScope('SysUser'))], - dept_data_scope_sql: Annotated[str, Depends(GetDataScope('SysDept'))], - role_data_scope_sql: Annotated[str, Depends(GetDataScope('SysDept'))], + query_db: Annotated[AsyncSession, DBSessionDependency()], + current_user: Annotated[CurrentUserModel, CurrentUserDependency()], + user_data_scope_sql: Annotated[str, DataScopeDependency('SysUser')], + dept_data_scope_sql: Annotated[str, DataScopeDependency('SysDept')], + role_data_scope_sql: Annotated[str, DataScopeDependency('SysDept')], ) -> Response: await UserService.check_user_allowed_services(edit_user) if not current_user.user.admin: @@ -128,14 +139,17 @@ async def edit_system_user( return ResponseUtil.success(msg=edit_user_result.message) -@user_controller.delete('/{user_ids}', dependencies=[Depends(CheckUserInterfaceAuth('system:user:remove'))]) +@user_controller.delete( + '/{user_ids}', + dependencies=[UserInterfaceAuthDependency('system:user:remove')], +) @Log(title='用户管理', business_type=BusinessType.DELETE) async def delete_system_user( request: Request, user_ids: Annotated[str, Path(description='需要删除的用户ID')], - query_db: Annotated[AsyncSession, Depends(get_db)], - current_user: Annotated[CurrentUserModel, Depends(LoginService.get_current_user)], - data_scope_sql: Annotated[str, Depends(GetDataScope('SysUser'))], + query_db: Annotated[AsyncSession, DBSessionDependency()], + current_user: Annotated[CurrentUserModel, CurrentUserDependency()], + data_scope_sql: Annotated[str, DataScopeDependency('SysUser')], ) -> Response: user_id_list = user_ids.split(',') if user_ids else [] if user_id_list: @@ -154,14 +168,17 @@ async def delete_system_user( return ResponseUtil.success(msg=delete_user_result.message) -@user_controller.put('/resetPwd', dependencies=[Depends(CheckUserInterfaceAuth('system:user:resetPwd'))]) +@user_controller.put( + '/resetPwd', + dependencies=[UserInterfaceAuthDependency('system:user:resetPwd')], +) @Log(title='用户管理', business_type=BusinessType.UPDATE) async def reset_system_user_pwd( request: Request, reset_user: EditUserModel, - query_db: Annotated[AsyncSession, Depends(get_db)], - current_user: Annotated[CurrentUserModel, Depends(LoginService.get_current_user)], - data_scope_sql: Annotated[str, Depends(GetDataScope('SysUser'))], + query_db: Annotated[AsyncSession, DBSessionDependency()], + current_user: Annotated[CurrentUserModel, CurrentUserDependency()], + data_scope_sql: Annotated[str, DataScopeDependency('SysUser')], ) -> Response: await UserService.check_user_allowed_services(reset_user) if not current_user.user.admin: @@ -180,14 +197,17 @@ async def reset_system_user_pwd( return ResponseUtil.success(msg=edit_user_result.message) -@user_controller.put('/changeStatus', dependencies=[Depends(CheckUserInterfaceAuth('system:user:edit'))]) +@user_controller.put( + '/changeStatus', + dependencies=[UserInterfaceAuthDependency('system:user:edit')], +) @Log(title='用户管理', business_type=BusinessType.UPDATE) async def change_system_user_status( request: Request, change_user: EditUserModel, - query_db: Annotated[AsyncSession, Depends(get_db)], - current_user: Annotated[CurrentUserModel, Depends(LoginService.get_current_user)], - data_scope_sql: Annotated[str, Depends(GetDataScope('SysUser'))], + query_db: Annotated[AsyncSession, DBSessionDependency()], + current_user: Annotated[CurrentUserModel, CurrentUserDependency()], + data_scope_sql: Annotated[str, DataScopeDependency('SysUser')], ) -> Response: await UserService.check_user_allowed_services(change_user) if not current_user.user.admin: @@ -208,8 +228,8 @@ async def change_system_user_status( @user_controller.get('/profile', response_model=UserProfileModel) async def query_detail_system_user_profile( request: Request, - query_db: Annotated[AsyncSession, Depends(get_db)], - current_user: Annotated[CurrentUserModel, Depends(LoginService.get_current_user)], + query_db: Annotated[AsyncSession, DBSessionDependency()], + current_user: Annotated[CurrentUserModel, CurrentUserDependency()], ) -> Response: 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}的信息成功') @@ -218,16 +238,20 @@ async def query_detail_system_user_profile( @user_controller.get( - '/{user_id}', response_model=UserDetailModel, dependencies=[Depends(CheckUserInterfaceAuth('system:user:query'))] + '/{user_id}', + response_model=UserDetailModel, + dependencies=[UserInterfaceAuthDependency('system:user:query')], ) @user_controller.get( - '/', response_model=UserDetailModel, dependencies=[Depends(CheckUserInterfaceAuth('system:user:query'))] + '/', + response_model=UserDetailModel, + dependencies=[UserInterfaceAuthDependency('system:user:query')], ) async def query_detail_system_user( request: Request, - query_db: Annotated[AsyncSession, Depends(get_db)], - current_user: Annotated[CurrentUserModel, Depends(LoginService.get_current_user)], - data_scope_sql: Annotated[str, Depends(GetDataScope('SysUser'))], + query_db: Annotated[AsyncSession, DBSessionDependency()], + current_user: Annotated[CurrentUserModel, CurrentUserDependency()], + data_scope_sql: Annotated[str, DataScopeDependency('SysUser')], user_id: Optional[Union[int, Literal['']]] = '', ) -> Response: if user_id and not current_user.user.admin: @@ -243,8 +267,8 @@ async def query_detail_system_user( async def change_system_user_profile_avatar( request: Request, avatarfile: Annotated[bytes, File()], - query_db: Annotated[AsyncSession, Depends(get_db)], - current_user: Annotated[CurrentUserModel, Depends(LoginService.get_current_user)], + query_db: Annotated[AsyncSession, DBSessionDependency()], + current_user: Annotated[CurrentUserModel, CurrentUserDependency()], ) -> Response: if avatarfile: relative_path = ( @@ -278,8 +302,8 @@ async def change_system_user_profile_avatar( async def change_system_user_profile_info( request: Request, user_info: UserInfoModel, - query_db: Annotated[AsyncSession, Depends(get_db)], - current_user: Annotated[CurrentUserModel, Depends(LoginService.get_current_user)], + query_db: Annotated[AsyncSession, DBSessionDependency()], + current_user: Annotated[CurrentUserModel, CurrentUserDependency()], ) -> Response: edit_user = EditUserModel( **user_info.model_dump(exclude_unset=True, by_alias=True, exclude={'role_ids', 'post_ids'}), @@ -302,8 +326,8 @@ async def change_system_user_profile_info( async def reset_system_user_password( request: Request, reset_password: ResetPasswordModel, - query_db: Annotated[AsyncSession, Depends(get_db)], - current_user: Annotated[CurrentUserModel, Depends(LoginService.get_current_user)], + query_db: Annotated[AsyncSession, DBSessionDependency()], + current_user: Annotated[CurrentUserModel, CurrentUserDependency()], ) -> Response: reset_user = ResetUserModel( userId=current_user.user.user_id, @@ -319,16 +343,19 @@ async def reset_system_user_password( return ResponseUtil.success(msg=reset_user_result.message) -@user_controller.post('/importData', dependencies=[Depends(CheckUserInterfaceAuth('system:user:import'))]) +@user_controller.post( + '/importData', + dependencies=[UserInterfaceAuthDependency('system:user:import')], +) @Log(title='用户管理', business_type=BusinessType.IMPORT) async def batch_import_system_user( request: Request, file: Annotated[UploadFile, File(...)], update_support: Annotated[bool, Query(alias='updateSupport')], - query_db: Annotated[AsyncSession, Depends(get_db)], - current_user: Annotated[CurrentUserModel, Depends(LoginService.get_current_user)], - user_data_scope_sql: Annotated[str, Depends(GetDataScope('SysUser'))], - dept_data_scope_sql: Annotated[str, Depends(GetDataScope('SysDept'))], + query_db: Annotated[AsyncSession, DBSessionDependency()], + current_user: Annotated[CurrentUserModel, CurrentUserDependency()], + user_data_scope_sql: Annotated[str, DataScopeDependency('SysUser')], + dept_data_scope_sql: Annotated[str, DataScopeDependency('SysDept')], ) -> Response: batch_import_result = await UserService.batch_import_user_services( request, query_db, file, update_support, current_user, user_data_scope_sql, dept_data_scope_sql @@ -338,21 +365,29 @@ async def batch_import_system_user( return ResponseUtil.success(msg=batch_import_result.message) -@user_controller.post('/importTemplate', dependencies=[Depends(CheckUserInterfaceAuth('system:user:import'))]) -async def export_system_user_template(request: Request, query_db: Annotated[AsyncSession, Depends(get_db)]) -> Response: +@user_controller.post( + '/importTemplate', + dependencies=[UserInterfaceAuthDependency('system:user:import')], +) +async def export_system_user_template( + request: Request, query_db: Annotated[AsyncSession, DBSessionDependency()] +) -> Response: user_import_template_result = await UserService.get_user_import_template_services() logger.info('获取成功') return ResponseUtil.streaming(data=bytes2file_response(user_import_template_result)) -@user_controller.post('/export', dependencies=[Depends(CheckUserInterfaceAuth('system:user:export'))]) +@user_controller.post( + '/export', + dependencies=[UserInterfaceAuthDependency('system:user:export')], +) @Log(title='用户管理', business_type=BusinessType.EXPORT) async def export_system_user_list( request: Request, user_page_query: Annotated[UserPageQueryModel, Form()], - query_db: Annotated[AsyncSession, Depends(get_db)], - data_scope_sql: Annotated[str, Depends(GetDataScope('SysUser'))], + query_db: Annotated[AsyncSession, DBSessionDependency()], + data_scope_sql: Annotated[str, DataScopeDependency('SysUser')], ) -> Response: # 获取全量数据 user_query_result = await UserService.get_user_list_services( @@ -367,12 +402,12 @@ async def export_system_user_list( @user_controller.get( '/authRole/{user_id}', response_model=UserRoleResponseModel, - dependencies=[Depends(CheckUserInterfaceAuth('system:user:query'))], + dependencies=[UserInterfaceAuthDependency('system:user:query')], ) async def get_system_allocated_role_list( request: Request, user_id: Annotated[int, Path(description='用户ID')], - query_db: Annotated[AsyncSession, Depends(get_db)], + query_db: Annotated[AsyncSession, DBSessionDependency()], ) -> Response: user_role_query = UserRoleQueryModel(userId=user_id) user_role_allocated_query_result = await UserService.get_user_role_allocated_list_services( @@ -386,17 +421,17 @@ async def get_system_allocated_role_list( @user_controller.put( '/authRole', response_model=UserRoleResponseModel, - dependencies=[Depends(CheckUserInterfaceAuth('system:user:edit'))], + dependencies=[UserInterfaceAuthDependency('system:user:edit')], ) @Log(title='用户管理', business_type=BusinessType.GRANT) async def update_system_role_user( request: Request, user_id: Annotated[int, Query(alias='userId')], role_ids: Annotated[str, Query(alias='roleIds')], - query_db: Annotated[AsyncSession, Depends(get_db)], - current_user: Annotated[CurrentUserModel, Depends(LoginService.get_current_user)], - user_data_scope_sql: Annotated[str, Depends(GetDataScope('SysUser'))], - role_data_scope_sql: Annotated[str, Depends(GetDataScope('SysDept'))], + query_db: Annotated[AsyncSession, DBSessionDependency()], + current_user: Annotated[CurrentUserModel, CurrentUserDependency()], + user_data_scope_sql: Annotated[str, DataScopeDependency('SysUser')], + role_data_scope_sql: Annotated[str, DataScopeDependency('SysDept')], ) -> Response: if not current_user.user.admin: await UserService.check_user_data_scope_services(query_db, user_id, user_data_scope_sql) diff --git a/ruoyi-fastapi-backend/module_generator/controller/gen_controller.py b/ruoyi-fastapi-backend/module_generator/controller/gen_controller.py index 6f5d4c5..d41fc7f 100644 --- a/ruoyi-fastapi-backend/module_generator/controller/gen_controller.py +++ b/ruoyi-fastapi-backend/module_generator/controller/gen_controller.py @@ -1,17 +1,17 @@ from datetime import datetime from typing import Annotated -from fastapi import APIRouter, Depends, Path, Query, Request, Response +from fastapi import APIRouter, Path, Query, Request, Response from pydantic_validation_decorator import ValidateFields from sqlalchemy.ext.asyncio import AsyncSession from common.annotation.log_annotation import Log -from common.aspect.interface_auth import CheckRoleInterfaceAuth, CheckUserInterfaceAuth +from common.aspect.db_seesion import DBSessionDependency +from common.aspect.interface_auth import RoleInterfaceAuthDependency, UserInterfaceAuthDependency +from common.aspect.pre_auth import CurrentUserDependency, PreAuthDependency from common.enums import BusinessType from config.env import GenConfig -from config.get_db import get_db from module_admin.entity.vo.user_vo import CurrentUserModel -from module_admin.service.login_service import LoginService from module_generator.entity.vo.gen_vo import DeleteGenTableModel, EditGenTableModel, GenTablePageQueryModel from module_generator.service.gen_service import GenTableColumnService, GenTableService from utils.common_util import bytes2file_response @@ -19,16 +19,18 @@ from utils.log_util import logger from utils.page_util import PageResponseModel from utils.response_util import ResponseUtil -gen_controller = APIRouter(prefix='/tool/gen', dependencies=[Depends(LoginService.get_current_user)]) +gen_controller = APIRouter(prefix='/tool/gen', dependencies=[PreAuthDependency()]) @gen_controller.get( - '/list', response_model=PageResponseModel, dependencies=[Depends(CheckUserInterfaceAuth('tool:gen:list'))] + '/list', + response_model=PageResponseModel, + dependencies=[UserInterfaceAuthDependency('tool:gen:list')], ) async def get_gen_table_list( request: Request, gen_page_query: Annotated[GenTablePageQueryModel, Query()], - query_db: Annotated[AsyncSession, Depends(get_db)], + query_db: Annotated[AsyncSession, DBSessionDependency()], ) -> Response: # 获取分页数据 gen_page_query_result = await GenTableService.get_gen_table_list_services(query_db, gen_page_query, is_page=True) @@ -38,12 +40,14 @@ async def get_gen_table_list( @gen_controller.get( - '/db/list', response_model=PageResponseModel, dependencies=[Depends(CheckUserInterfaceAuth('tool:gen:list'))] + '/db/list', + response_model=PageResponseModel, + dependencies=[UserInterfaceAuthDependency('tool:gen:list')], ) async def get_gen_db_table_list( request: Request, gen_page_query: Annotated[GenTablePageQueryModel, Query()], - query_db: Annotated[AsyncSession, Depends(get_db)], + query_db: Annotated[AsyncSession, DBSessionDependency()], ) -> Response: # 获取分页数据 gen_page_query_result = await GenTableService.get_gen_db_table_list_services(query_db, gen_page_query, is_page=True) @@ -52,13 +56,16 @@ async def get_gen_db_table_list( return ResponseUtil.success(model_content=gen_page_query_result) -@gen_controller.post('/importTable', dependencies=[Depends(CheckUserInterfaceAuth('tool:gen:import'))]) +@gen_controller.post( + '/importTable', + dependencies=[UserInterfaceAuthDependency('tool:gen:import')], +) @Log(title='代码生成', business_type=BusinessType.IMPORT) async def import_gen_table( request: Request, tables: Annotated[str, Query()], - query_db: Annotated[AsyncSession, Depends(get_db)], - current_user: Annotated[CurrentUserModel, Depends(LoginService.get_current_user)], + query_db: Annotated[AsyncSession, DBSessionDependency()], + current_user: Annotated[CurrentUserModel, CurrentUserDependency()], ) -> Response: table_names = tables.split(',') if tables else [] add_gen_table_list = await GenTableService.get_gen_db_table_list_by_name_services(query_db, table_names) @@ -68,14 +75,17 @@ async def import_gen_table( return ResponseUtil.success(msg=add_gen_table_result.message) -@gen_controller.put('', dependencies=[Depends(CheckUserInterfaceAuth('tool:gen:edit'))]) +@gen_controller.put( + '', + dependencies=[UserInterfaceAuthDependency('tool:gen:edit')], +) @ValidateFields(validate_model='edit_gen_table') @Log(title='代码生成', business_type=BusinessType.UPDATE) async def edit_gen_table( request: Request, edit_gen_table: EditGenTableModel, - query_db: Annotated[AsyncSession, Depends(get_db)], - current_user: Annotated[CurrentUserModel, Depends(LoginService.get_current_user)], + query_db: Annotated[AsyncSession, DBSessionDependency()], + current_user: Annotated[CurrentUserModel, CurrentUserDependency()], ) -> Response: edit_gen_table.update_by = current_user.user.user_name edit_gen_table.update_time = datetime.now() @@ -86,12 +96,15 @@ async def edit_gen_table( return ResponseUtil.success(msg=edit_gen_result.message) -@gen_controller.delete('/{table_ids}', dependencies=[Depends(CheckUserInterfaceAuth('tool:gen:remove'))]) +@gen_controller.delete( + '/{table_ids}', + dependencies=[UserInterfaceAuthDependency('tool:gen:remove')], +) @Log(title='代码生成', business_type=BusinessType.DELETE) async def delete_gen_table( request: Request, table_ids: Annotated[str, Path(description='需要删除的代码生成业务表ID')], - query_db: Annotated[AsyncSession, Depends(get_db)], + query_db: Annotated[AsyncSession, DBSessionDependency()], ) -> Response: delete_gen_table = DeleteGenTableModel(tableIds=table_ids) delete_gen_table_result = await GenTableService.delete_gen_table_services(query_db, delete_gen_table) @@ -100,13 +113,16 @@ async def delete_gen_table( return ResponseUtil.success(msg=delete_gen_table_result.message) -@gen_controller.post('/createTable', dependencies=[Depends(CheckRoleInterfaceAuth('admin'))]) +@gen_controller.post( + '/createTable', + dependencies=[RoleInterfaceAuthDependency('admin')], +) @Log(title='创建表', business_type=BusinessType.OTHER) async def create_table( request: Request, sql: Annotated[str, Query()], - query_db: Annotated[AsyncSession, Depends(get_db)], - current_user: Annotated[CurrentUserModel, Depends(LoginService.get_current_user)], + query_db: Annotated[AsyncSession, DBSessionDependency()], + current_user: Annotated[CurrentUserModel, CurrentUserDependency()], ) -> Response: create_table_result = await GenTableService.create_table_services(query_db, sql, current_user) logger.info(create_table_result.message) @@ -114,12 +130,15 @@ async def create_table( return ResponseUtil.success(msg=create_table_result.message) -@gen_controller.get('/batchGenCode', dependencies=[Depends(CheckUserInterfaceAuth('tool:gen:code'))]) +@gen_controller.get( + '/batchGenCode', + dependencies=[UserInterfaceAuthDependency('tool:gen:code')], +) @Log(title='代码生成', business_type=BusinessType.GENCODE) async def batch_gen_code( request: Request, tables: Annotated[str, Query()], - query_db: Annotated[AsyncSession, Depends(get_db)], + query_db: Annotated[AsyncSession, DBSessionDependency()], ) -> Response: table_names = tables.split(',') if tables else [] batch_gen_code_result = await GenTableService.batch_gen_code_services(query_db, table_names) @@ -128,12 +147,15 @@ async def batch_gen_code( return ResponseUtil.streaming(data=bytes2file_response(batch_gen_code_result)) -@gen_controller.get('/genCode/{table_name}', dependencies=[Depends(CheckUserInterfaceAuth('tool:gen:code'))]) +@gen_controller.get( + '/genCode/{table_name}', + dependencies=[UserInterfaceAuthDependency('tool:gen:code')], +) @Log(title='代码生成', business_type=BusinessType.GENCODE) async def gen_code_local( request: Request, table_name: Annotated[str, Path(description='表名称')], - query_db: Annotated[AsyncSession, Depends(get_db)], + query_db: Annotated[AsyncSession, DBSessionDependency()], ) -> Response: if not GenConfig.allow_overwrite: logger.error('【系统预设】不允许生成文件覆盖到本地') @@ -144,11 +166,14 @@ async def gen_code_local( return ResponseUtil.success(msg=gen_code_local_result.message) -@gen_controller.get('/{table_id}', dependencies=[Depends(CheckUserInterfaceAuth('tool:gen:query'))]) +@gen_controller.get( + '/{table_id}', + dependencies=[UserInterfaceAuthDependency('tool:gen:query')], +) async def query_detail_gen_table( request: Request, table_id: Annotated[int, Path(description='表编号')], - query_db: Annotated[AsyncSession, Depends(get_db)], + query_db: Annotated[AsyncSession, DBSessionDependency()], ) -> Response: gen_table = await GenTableService.get_gen_table_by_id_services(query_db, table_id) gen_tables = await GenTableService.get_gen_table_all_services(query_db) @@ -159,11 +184,14 @@ async def query_detail_gen_table( return ResponseUtil.success(data=gen_table_detail_result) -@gen_controller.get('/preview/{table_id}', dependencies=[Depends(CheckUserInterfaceAuth('tool:gen:preview'))]) +@gen_controller.get( + '/preview/{table_id}', + dependencies=[UserInterfaceAuthDependency('tool:gen:preview')], +) async def preview_code( request: Request, table_id: Annotated[int, Path(description='表编号')], - query_db: Annotated[AsyncSession, Depends(get_db)], + query_db: Annotated[AsyncSession, DBSessionDependency()], ) -> Response: preview_code_result = await GenTableService.preview_code_services(query_db, table_id) logger.info('获取预览代码成功') @@ -171,12 +199,15 @@ async def preview_code( return ResponseUtil.success(data=preview_code_result) -@gen_controller.get('/synchDb/{table_name}', dependencies=[Depends(CheckUserInterfaceAuth('tool:gen:edit'))]) +@gen_controller.get( + '/synchDb/{table_name}', + dependencies=[UserInterfaceAuthDependency('tool:gen:edit')], +) @Log(title='代码生成', business_type=BusinessType.UPDATE) async def sync_db( request: Request, table_name: Annotated[str, Path(description='表名称')], - query_db: Annotated[AsyncSession, Depends(get_db)], + query_db: Annotated[AsyncSession, DBSessionDependency()], ) -> Response: sync_db_result = await GenTableService.sync_db_services(query_db, table_name) logger.info(sync_db_result.message) diff --git a/ruoyi-fastapi-backend/module_generator/templates/python/controller.py.jinja2 b/ruoyi-fastapi-backend/module_generator/templates/python/controller.py.jinja2 index 4c33ca9..f574cf2 100644 --- a/ruoyi-fastapi-backend/module_generator/templates/python/controller.py.jinja2 +++ b/ruoyi-fastapi-backend/module_generator/templates/python/controller.py.jinja2 @@ -13,16 +13,16 @@ from datetime import datetime {% endif %} from typing import Annotated -from fastapi import APIRouter, Depends, Form, Path, Query, Request, Response +from fastapi import APIRouter, Form, Path, Query, Request, Response from pydantic_validation_decorator import ValidateFields from sqlalchemy.ext.asyncio import AsyncSession from common.annotation.log_annotation import Log -from common.aspect.interface_auth import CheckUserInterfaceAuth +from common.aspect.db_seesion import DBSessionDependency +from common.aspect.interface_auth import UserInterfaceAuthDependency +from common.aspect.pre_auth import CurrentUserDependency, PreAuthDependency from common.enums import BusinessType -from config.get_db import get_db from module_admin.entity.vo.user_vo import CurrentUserModel -from module_admin.service.login_service import LoginService from {{ packageName }}.service.{{ businessName }}_service import {{ BusinessName }}Service from {{ packageName }}.entity.vo.{{ businessName }}_vo import Delete{{ BusinessName }}Model, {{ BusinessName }}Model, {{ BusinessName }}PageQueryModel from utils.common_util import bytes2file_response @@ -31,16 +31,18 @@ from utils.page_util import PageResponseModel from utils.response_util import ResponseUtil -{{ businessName }}_controller = APIRouter(prefix='/{{ moduleName }}/{{ businessName }}', dependencies=[Depends(LoginService.get_current_user)]) +{{ businessName }}_controller = APIRouter(prefix='/{{ moduleName }}/{{ businessName }}', dependencies=[PreAuthDependency()]) @{{ businessName }}_controller.get( - '/list', response_model=PageResponseModel, dependencies=[Depends(CheckUserInterfaceAuth('{{ permissionPrefix }}:list'))] + '/list', + response_model=PageResponseModel, + dependencies=[UserInterfaceAuthDependency('{{ permissionPrefix }}:list')], ) async def get_{{ moduleName }}_{{ businessName }}_list( request: Request, {% if table.crud or table.sub %}{{ businessName }}_page_query{% elif table.tree %}{{ businessName }}_query{% endif %}: Annotated[{{ BusinessName }}PageQueryModel, Query()], - query_db: Annotated[AsyncSession, Depends(get_db)], + query_db: Annotated[AsyncSession, DBSessionDependency()], ) -> Response: {% if table.crud or table.sub %} # 获取分页数据 @@ -56,14 +58,16 @@ async def get_{{ moduleName }}_{{ businessName }}_list( {% endif %} -@{{ businessName }}_controller.post('', dependencies=[Depends(CheckUserInterfaceAuth('{{ permissionPrefix }}:add'))]) +@{{ businessName }}_controller.post( + '', + dependencies=[UserInterfaceAuthDependency('{{ permissionPrefix }}:add')]), @ValidateFields(validate_model='add_{{ businessName }}') @Log(title='{{ functionName }}', business_type=BusinessType.INSERT) async def add_{{ moduleName }}_{{ businessName }}( request: Request, add_{{ businessName }}: {{ BusinessName }}Model, - query_db: Annotated[AsyncSession, Depends(get_db)], - current_user: Annotated[CurrentUserModel, Depends(LoginService.get_current_user)], + query_db: Annotated[AsyncSession, DBSessionDependency()], + current_user: Annotated[CurrentUserModel, CurrentUserDependency()], ) -> Response: {% for column in columns %} {% if column.python_field == "createBy" %} @@ -82,14 +86,16 @@ async def add_{{ moduleName }}_{{ businessName }}( return ResponseUtil.success(msg=add_{{ businessName }}_result.message) -@{{ businessName }}_controller.put('', dependencies=[Depends(CheckUserInterfaceAuth('{{ permissionPrefix }}:edit'))]) +@{{ businessName }}_controller.put( + '', + dependencies=[UserInterfaceAuthDependency('{{ permissionPrefix }}:edit')]), @ValidateFields(validate_model='edit_{{ businessName }}') @Log(title='{{ functionName }}', business_type=BusinessType.UPDATE) async def edit_{{ moduleName }}_{{ businessName }}( request: Request, edit_{{ businessName }}: {{ BusinessName }}Model, - query_db: Annotated[AsyncSession, Depends(get_db)], - current_user: Annotated[CurrentUserModel, Depends(LoginService.get_current_user)], + query_db: Annotated[AsyncSession, DBSessionDependency()], + current_user: Annotated[CurrentUserModel, CurrentUserDependency()], ) -> Response: {% for column in columns %} {% if column.python_field == "updateBy" %} @@ -104,12 +110,14 @@ async def edit_{{ moduleName }}_{{ businessName }}( return ResponseUtil.success(msg=edit_{{ businessName }}_result.message) -@{{ businessName }}_controller.delete('/{% raw %}{{% endraw %}{{ pk_field }}s{% raw %}}{% endraw %}', dependencies=[Depends(CheckUserInterfaceAuth('{{ permissionPrefix }}:remove'))]) +@{{ businessName }}_controller.delete( + '/{% raw %}{{% endraw %}{{ pk_field }}s{% raw %}}{% endraw %}', + dependencies=[UserInterfaceAuthDependency('{{ permissionPrefix }}:remove')]), @Log(title='{{ functionName }}', business_type=BusinessType.DELETE) async def delete_{{ moduleName }}_{{ businessName }}( request: Request, {{ pk_field }}s: Annotated[str, Path(description='需要删除的{{ pk_field_comment }}')], - Annotated[AsyncSession, Depends(get_db)], + Annotated[AsyncSession, DBSessionDependency()], ) -> Response: delete_{{ businessName }} = Delete{{ BusinessName }}Model({{ pkField }}s={{ pk_field }}s) delete_{{ businessName }}_result = await {{ BusinessName }}Service.delete_{{ businessName }}_services(query_db, delete_{{ businessName }}) @@ -119,12 +127,14 @@ async def delete_{{ moduleName }}_{{ businessName }}( @{{ businessName }}_controller.get( - '/{% raw %}{{% endraw %}{{ pk_field }}{% raw %}}{% endraw %}', response_model={{ BusinessName }}Model, dependencies=[Depends(CheckUserInterfaceAuth('{{ permissionPrefix }}:query'))] + '/{% raw %}{{% endraw %}{{ pk_field }}{% raw %}}{% endraw %}', + response_model={{ BusinessName }}Model, + dependencies=[UserInterfaceAuthDependency('{{ permissionPrefix }}:query')] ) async def query_detail_{{ moduleName }}_{{ businessName }}( request: Request, {{ pk_field }}: Annotated[{{ pkColumn.python_type }}, Path(description='{{ pk_field_comment }}')], - query_db: Annotated[AsyncSession, Depends(get_db)], + query_db: Annotated[AsyncSession, DBSessionDependency()], ) -> Response: {{ businessName }}_detail_result = await {{ BusinessName }}Service.{{ businessName }}_detail_services(query_db, {{ pk_field }}) logger.info(f'获取{{ pk_field }}为{% raw %}{{% endraw %}{{ pk_field }}{% raw %}}{% endraw %}的信息成功') @@ -132,12 +142,14 @@ async def query_detail_{{ moduleName }}_{{ businessName }}( return ResponseUtil.success(data={{ businessName }}_detail_result) -@{{ businessName }}_controller.post('/export', dependencies=[Depends(CheckUserInterfaceAuth('{{ permissionPrefix }}:export'))]) +@{{ businessName }}_controller.post( + '/export', + dependencies=[UserInterfaceAuthDependency('{{ permissionPrefix }}:export')]) @Log(title='{{ functionName }}', business_type=BusinessType.EXPORT) async def export_{{ moduleName }}_{{ businessName }}_list( request: Request, {{ businessName }}_page_query: Annotated[{{ BusinessName }}PageQueryModel, Form()], - query_db: Annotated[AsyncSession, Depends(get_db)], + query_db: Annotated[AsyncSession, DBSessionDependency()], ) -> Response: # 获取全量数据 {{ businessName }}_query_result = await {{ BusinessName }}Service.get_{{ businessName }}_list_services(query_db, {{ businessName }}_page_query, is_page=False)