perf: controller层全部使用新依赖项

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)

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')

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)],
+    query_db: Annotated[AsyncSession, DBSessionDependency()],
-    current_user: Annotated[CurrentUserModel, Depends(LoginService.get_current_user)],
+    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)],
+    query_db: Annotated[AsyncSession, DBSessionDependency()],
-    current_user: Annotated[CurrentUserModel, Depends(LoginService.get_current_user)],
+    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)

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.data_scope import DataScopeDependency
-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.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)],
+    query_db: Annotated[AsyncSession, DBSessionDependency()],
-    data_scope_sql: Annotated[str, Depends(GetDataScope('SysDept'))],
+    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)],
+    query_db: Annotated[AsyncSession, DBSessionDependency()],
-    data_scope_sql: Annotated[str, Depends(GetDataScope('SysDept'))],
+    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)],
+    query_db: Annotated[AsyncSession, DBSessionDependency()],
-    current_user: Annotated[CurrentUserModel, Depends(LoginService.get_current_user)],
+    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)],
+    query_db: Annotated[AsyncSession, DBSessionDependency()],
-    current_user: Annotated[CurrentUserModel, Depends(LoginService.get_current_user)],
+    current_user: Annotated[CurrentUserModel, CurrentUserDependency()],
-    data_scope_sql: Annotated[str, Depends(GetDataScope('SysDept'))],
+    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)],
+    query_db: Annotated[AsyncSession, DBSessionDependency()],
-    current_user: Annotated[CurrentUserModel, Depends(LoginService.get_current_user)],
+    current_user: Annotated[CurrentUserModel, CurrentUserDependency()],
-    data_scope_sql: Annotated[str, Depends(GetDataScope('SysDept'))],
+    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)],
+    query_db: Annotated[AsyncSession, DBSessionDependency()],
-    current_user: Annotated[CurrentUserModel, Depends(LoginService.get_current_user)],
+    current_user: Annotated[CurrentUserModel, CurrentUserDependency()],
-    data_scope_sql: Annotated[str, Depends(GetDataScope('SysDept'))],
+    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)

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)],
+    query_db: Annotated[AsyncSession, DBSessionDependency()],
-    current_user: Annotated[CurrentUserModel, Depends(LoginService.get_current_user)],
+    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)],
+    query_db: Annotated[AsyncSession, DBSessionDependency()],
-    current_user: Annotated[CurrentUserModel, Depends(LoginService.get_current_user)],
+    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)],
+    query_db: Annotated[AsyncSession, DBSessionDependency()],
-    current_user: Annotated[CurrentUserModel, Depends(LoginService.get_current_user)],
+    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)],
+    query_db: Annotated[AsyncSession, DBSessionDependency()],
-    current_user: Annotated[CurrentUserModel, Depends(LoginService.get_current_user)],
+    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(

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)],
+    query_db: Annotated[AsyncSession, DBSessionDependency()],
-    current_user: Annotated[CurrentUserModel, Depends(LoginService.get_current_user)],
+    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)],
+    query_db: Annotated[AsyncSession, DBSessionDependency()],
-    current_user: Annotated[CurrentUserModel, Depends(LoginService.get_current_user)],
+    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)],
+    query_db: Annotated[AsyncSession, DBSessionDependency()],
-    current_user: Annotated[CurrentUserModel, Depends(LoginService.get_current_user)],
+    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)

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(

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)],
+    current_user: Annotated[CurrentUserModel, CurrentUserDependency()],
-    query_db: Annotated[AsyncSession, Depends(get_db)],
+    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:

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)],
+    query_db: Annotated[AsyncSession, DBSessionDependency()],
-    current_user: Annotated[CurrentUserModel, Depends(LoginService.get_current_user)],
+    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)],
+    query_db: Annotated[AsyncSession, DBSessionDependency()],
-    current_user: Annotated[CurrentUserModel, Depends(LoginService.get_current_user)],
+    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)],
+    query_db: Annotated[AsyncSession, DBSessionDependency()],
-    current_user: Annotated[CurrentUserModel, Depends(LoginService.get_current_user)],
+    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)],
+    query_db: Annotated[AsyncSession, DBSessionDependency()],
-    current_user: Annotated[CurrentUserModel, Depends(LoginService.get_current_user)],
+    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)],
+    query_db: Annotated[AsyncSession, DBSessionDependency()],
-    current_user: Annotated[CurrentUserModel, Depends(LoginService.get_current_user)],
+    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}的信息成功')

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)],
+    query_db: Annotated[AsyncSession, DBSessionDependency()],
-    current_user: Annotated[CurrentUserModel, Depends(LoginService.get_current_user)],
+    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)],
+    query_db: Annotated[AsyncSession, DBSessionDependency()],
-    current_user: Annotated[CurrentUserModel, Depends(LoginService.get_current_user)],
+    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}的信息成功')

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)

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)],
+    query_db: Annotated[AsyncSession, DBSessionDependency()],
-    current_user: Annotated[CurrentUserModel, Depends(LoginService.get_current_user)],
+    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)],
+    query_db: Annotated[AsyncSession, DBSessionDependency()],
-    current_user: Annotated[CurrentUserModel, Depends(LoginService.get_current_user)],
+    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)

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.data_scope import DataScopeDependency
-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.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)],
+    query_db: Annotated[AsyncSession, DBSessionDependency()],
-    data_scope_sql: Annotated[str, Depends(GetDataScope('SysDept'))],
+    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)],
+    query_db: Annotated[AsyncSession, DBSessionDependency()],
-    data_scope_sql: Annotated[str, Depends(GetDataScope('SysDept'))],
+    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)],
+    query_db: Annotated[AsyncSession, DBSessionDependency()],
-    current_user: Annotated[CurrentUserModel, Depends(LoginService.get_current_user)],
+    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)],
+    query_db: Annotated[AsyncSession, DBSessionDependency()],
-    current_user: Annotated[CurrentUserModel, Depends(LoginService.get_current_user)],
+    current_user: Annotated[CurrentUserModel, CurrentUserDependency()],
-    data_scope_sql: Annotated[str, Depends(GetDataScope('SysDept'))],
+    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)],
+    query_db: Annotated[AsyncSession, DBSessionDependency()],
-    current_user: Annotated[CurrentUserModel, Depends(LoginService.get_current_user)],
+    current_user: Annotated[CurrentUserModel, CurrentUserDependency()],
-    data_scope_sql: Annotated[str, Depends(GetDataScope('SysDept'))],
+    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)],
+    query_db: Annotated[AsyncSession, DBSessionDependency()],
-    current_user: Annotated[CurrentUserModel, Depends(LoginService.get_current_user)],
+    current_user: Annotated[CurrentUserModel, CurrentUserDependency()],
-    data_scope_sql: Annotated[str, Depends(GetDataScope('SysDept'))],
+    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)],
+    query_db: Annotated[AsyncSession, DBSessionDependency()],
-    current_user: Annotated[CurrentUserModel, Depends(LoginService.get_current_user)],
+    current_user: Annotated[CurrentUserModel, CurrentUserDependency()],
-    data_scope_sql: Annotated[str, Depends(GetDataScope('SysDept'))],
+    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)],
+    query_db: Annotated[AsyncSession, DBSessionDependency()],
-    data_scope_sql: Annotated[str, Depends(GetDataScope('SysDept'))],
+    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)],
+    query_db: Annotated[AsyncSession, DBSessionDependency()],
-    current_user: Annotated[CurrentUserModel, Depends(LoginService.get_current_user)],
+    current_user: Annotated[CurrentUserModel, CurrentUserDependency()],
-    data_scope_sql: Annotated[str, Depends(GetDataScope('SysDept'))],
+    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)],
+    query_db: Annotated[AsyncSession, DBSessionDependency()],
-    data_scope_sql: Annotated[str, Depends(GetDataScope('SysUser'))],
+    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)],
+    query_db: Annotated[AsyncSession, DBSessionDependency()],
-    data_scope_sql: Annotated[str, Depends(GetDataScope('SysUser'))],
+    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)],
+    query_db: Annotated[AsyncSession, DBSessionDependency()],
-    current_user: Annotated[CurrentUserModel, Depends(LoginService.get_current_user)],
+    current_user: Annotated[CurrentUserModel, CurrentUserDependency()],
-    data_scope_sql: Annotated[str, Depends(GetDataScope('SysDept'))],
+    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)

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:
     # 获取全量数据

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.data_scope import DataScopeDependency
-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.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)],
+    query_db: Annotated[AsyncSession, DBSessionDependency()],
-    data_scope_sql: Annotated[str, Depends(GetDataScope('SysDept'))],
+    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)],
+    query_db: Annotated[AsyncSession, DBSessionDependency()],
-    data_scope_sql: Annotated[str, Depends(GetDataScope('SysUser'))],
+    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)],
+    query_db: Annotated[AsyncSession, DBSessionDependency()],
-    current_user: Annotated[CurrentUserModel, Depends(LoginService.get_current_user)],
+    current_user: Annotated[CurrentUserModel, CurrentUserDependency()],
-    dept_data_scope_sql: Annotated[str, Depends(GetDataScope('SysDept'))],
+    dept_data_scope_sql: Annotated[str, DataScopeDependency('SysDept')],
-    role_data_scope_sql: Annotated[str, Depends(GetDataScope('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)],
+    query_db: Annotated[AsyncSession, DBSessionDependency()],
-    current_user: Annotated[CurrentUserModel, Depends(LoginService.get_current_user)],
+    current_user: Annotated[CurrentUserModel, CurrentUserDependency()],
-    user_data_scope_sql: Annotated[str, Depends(GetDataScope('SysUser'))],
+    user_data_scope_sql: Annotated[str, DataScopeDependency('SysUser')],
-    dept_data_scope_sql: Annotated[str, Depends(GetDataScope('SysDept'))],
+    dept_data_scope_sql: Annotated[str, DataScopeDependency('SysDept')],
-    role_data_scope_sql: Annotated[str, Depends(GetDataScope('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)],
+    query_db: Annotated[AsyncSession, DBSessionDependency()],
-    current_user: Annotated[CurrentUserModel, Depends(LoginService.get_current_user)],
+    current_user: Annotated[CurrentUserModel, CurrentUserDependency()],
-    data_scope_sql: Annotated[str, Depends(GetDataScope('SysUser'))],
+    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)],
+    query_db: Annotated[AsyncSession, DBSessionDependency()],
-    current_user: Annotated[CurrentUserModel, Depends(LoginService.get_current_user)],
+    current_user: Annotated[CurrentUserModel, CurrentUserDependency()],
-    data_scope_sql: Annotated[str, Depends(GetDataScope('SysUser'))],
+    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)],
+    query_db: Annotated[AsyncSession, DBSessionDependency()],
-    current_user: Annotated[CurrentUserModel, Depends(LoginService.get_current_user)],
+    current_user: Annotated[CurrentUserModel, CurrentUserDependency()],
-    data_scope_sql: Annotated[str, Depends(GetDataScope('SysUser'))],
+    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)],
+    query_db: Annotated[AsyncSession, DBSessionDependency()],
-    current_user: Annotated[CurrentUserModel, Depends(LoginService.get_current_user)],
+    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)],
+    query_db: Annotated[AsyncSession, DBSessionDependency()],
-    current_user: Annotated[CurrentUserModel, Depends(LoginService.get_current_user)],
+    current_user: Annotated[CurrentUserModel, CurrentUserDependency()],
-    data_scope_sql: Annotated[str, Depends(GetDataScope('SysUser'))],
+    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)],
+    query_db: Annotated[AsyncSession, DBSessionDependency()],
-    current_user: Annotated[CurrentUserModel, Depends(LoginService.get_current_user)],
+    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)],
+    query_db: Annotated[AsyncSession, DBSessionDependency()],
-    current_user: Annotated[CurrentUserModel, Depends(LoginService.get_current_user)],
+    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)],
+    query_db: Annotated[AsyncSession, DBSessionDependency()],
-    current_user: Annotated[CurrentUserModel, Depends(LoginService.get_current_user)],
+    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)],
+    query_db: Annotated[AsyncSession, DBSessionDependency()],
-    current_user: Annotated[CurrentUserModel, Depends(LoginService.get_current_user)],
+    current_user: Annotated[CurrentUserModel, CurrentUserDependency()],
-    user_data_scope_sql: Annotated[str, Depends(GetDataScope('SysUser'))],
+    user_data_scope_sql: Annotated[str, DataScopeDependency('SysUser')],
-    dept_data_scope_sql: Annotated[str, Depends(GetDataScope('SysDept'))],
+    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'))])
+@user_controller.post(
-async def export_system_user_template(request: Request, query_db: Annotated[AsyncSession, Depends(get_db)]) -> Response:
+    '/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)],
+    query_db: Annotated[AsyncSession, DBSessionDependency()],
-    data_scope_sql: Annotated[str, Depends(GetDataScope('SysUser'))],
+    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)],
+    query_db: Annotated[AsyncSession, DBSessionDependency()],
-    current_user: Annotated[CurrentUserModel, Depends(LoginService.get_current_user)],
+    current_user: Annotated[CurrentUserModel, CurrentUserDependency()],
-    user_data_scope_sql: Annotated[str, Depends(GetDataScope('SysUser'))],
+    user_data_scope_sql: Annotated[str, DataScopeDependency('SysUser')],
-    role_data_scope_sql: Annotated[str, Depends(GetDataScope('SysDept'))],
+    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)

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)],
+    query_db: Annotated[AsyncSession, DBSessionDependency()],
-    current_user: Annotated[CurrentUserModel, Depends(LoginService.get_current_user)],
+    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)],
+    query_db: Annotated[AsyncSession, DBSessionDependency()],
-    current_user: Annotated[CurrentUserModel, Depends(LoginService.get_current_user)],
+    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)],
+    query_db: Annotated[AsyncSession, DBSessionDependency()],
-    current_user: Annotated[CurrentUserModel, Depends(LoginService.get_current_user)],
+    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)

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)],
+    query_db: Annotated[AsyncSession, DBSessionDependency()],
-    current_user: Annotated[CurrentUserModel, Depends(LoginService.get_current_user)],
+    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)],
+    query_db: Annotated[AsyncSession, DBSessionDependency()],
-    current_user: Annotated[CurrentUserModel, Depends(LoginService.get_current_user)],
+    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)