public/RuoYi-Vue3-FastAPI
1
0
Fork 0
mirror of https://github.com/insistence/RuoYi-Vue3-FastAPI.git synced 2026-09-21 12:52:27 +00:00
Code Issues Packages Projects Releases Wiki Activity

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

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