feat: 初始化项目架构
This commit is contained in:
insistence
@@ -0,0 +1,94 @@
|
||||
from fastapi import APIRouter
|
||||
from fastapi import Depends
|
||||
from module_admin.service.login_service import LoginService
|
||||
from module_admin.service.cache_service import *
|
||||
from utils.response_util import *
|
||||
from utils.log_util import *
|
||||
from module_admin.aspect.interface_auth import CheckUserInterfaceAuth
|
||||
|
||||
|
||||
cacheController = APIRouter(prefix='/monitor/cache', dependencies=[Depends(LoginService.get_current_user)])
|
||||
|
||||
|
||||
@cacheController.get("", response_model=CacheMonitorModel, dependencies=[Depends(CheckUserInterfaceAuth('monitor:cache:list'))])
|
||||
async def get_monitor_cache_info(request: Request):
|
||||
try:
|
||||
# 获取全量数据
|
||||
cache_info_query_result = await CacheService.get_cache_monitor_statistical_info_services(request)
|
||||
logger.info('获取成功')
|
||||
return ResponseUtil.success(data=cache_info_query_result)
|
||||
except Exception as e:
|
||||
logger.exception(e)
|
||||
return ResponseUtil.error(msg=str(e))
|
||||
|
||||
|
||||
@cacheController.get("/getNames", response_model=List[CacheInfoModel], dependencies=[Depends(CheckUserInterfaceAuth('monitor:cache:list'))])
|
||||
async def get_monitor_cache_name(request: Request):
|
||||
try:
|
||||
# 获取全量数据
|
||||
cache_name_list_result = CacheService.get_cache_monitor_cache_name_services()
|
||||
logger.info('获取成功')
|
||||
return ResponseUtil.success(data=cache_name_list_result)
|
||||
except Exception as e:
|
||||
logger.exception(e)
|
||||
return ResponseUtil.error(msg=str(e))
|
||||
|
||||
|
||||
@cacheController.get("/getKeys/{cache_name}", response_model=List[str], dependencies=[Depends(CheckUserInterfaceAuth('monitor:cache:list'))])
|
||||
async def get_monitor_cache_key(request: Request, cache_name: str):
|
||||
try:
|
||||
# 获取全量数据
|
||||
cache_key_list_result = await CacheService.get_cache_monitor_cache_key_services(request, cache_name)
|
||||
logger.info('获取成功')
|
||||
return ResponseUtil.success(data=cache_key_list_result)
|
||||
except Exception as e:
|
||||
logger.exception(e)
|
||||
return ResponseUtil.error(msg=str(e))
|
||||
|
||||
|
||||
@cacheController.get("/getValue/{cache_name}/{cache_key}", response_model=CacheInfoModel, dependencies=[Depends(CheckUserInterfaceAuth('monitor:cache:list'))])
|
||||
async def get_monitor_cache_value(request: Request, cache_name: str, cache_key: str):
|
||||
try:
|
||||
# 获取全量数据
|
||||
cache_value_list_result = await CacheService.get_cache_monitor_cache_value_services(request, cache_name, cache_key)
|
||||
logger.info('获取成功')
|
||||
return ResponseUtil.success(data=cache_value_list_result)
|
||||
except Exception as e:
|
||||
logger.exception(e)
|
||||
return ResponseUtil.error(msg=str(e))
|
||||
|
||||
|
||||
@cacheController.delete("/clearCacheName/{cache_name}", dependencies=[Depends(CheckUserInterfaceAuth('monitor:cache:list'))])
|
||||
async def clear_monitor_cache_name(request: Request, cache_name: str):
|
||||
try:
|
||||
clear_cache_name_result = await CacheService.clear_cache_monitor_cache_name_services(request, cache_name)
|
||||
if clear_cache_name_result.is_success:
|
||||
logger.info(clear_cache_name_result.message)
|
||||
return ResponseUtil.success(msg=clear_cache_name_result.message)
|
||||
except Exception as e:
|
||||
logger.exception(e)
|
||||
return ResponseUtil.error(msg=str(e))
|
||||
|
||||
|
||||
@cacheController.delete("/clearCacheKey/{cache_key}", dependencies=[Depends(CheckUserInterfaceAuth('monitor:cache:list'))])
|
||||
async def clear_monitor_cache_key(request: Request, cache_key: str):
|
||||
try:
|
||||
clear_cache_key_result = await CacheService.clear_cache_monitor_cache_key_services(request, cache_key)
|
||||
if clear_cache_key_result.is_success:
|
||||
logger.info(clear_cache_key_result.message)
|
||||
return ResponseUtil.success(msg=clear_cache_key_result.message)
|
||||
except Exception as e:
|
||||
logger.exception(e)
|
||||
return ResponseUtil.error(msg=str(e))
|
||||
|
||||
|
||||
@cacheController.delete("/clearCacheAll", dependencies=[Depends(CheckUserInterfaceAuth('monitor:cache:list'))])
|
||||
async def clear_monitor_cache_all(request: Request):
|
||||
try:
|
||||
clear_cache_all_result = await CacheService.clear_cache_monitor_all_services(request)
|
||||
if clear_cache_all_result.is_success:
|
||||
logger.info(clear_cache_all_result.message)
|
||||
return ResponseUtil.success(msg=clear_cache_all_result.message)
|
||||
except Exception as e:
|
||||
logger.exception(e)
|
||||
return ResponseUtil.error(msg=str(e))
|
||||
@@ -0,0 +1,29 @@
|
||||
import uuid
|
||||
from fastapi import APIRouter, Request
|
||||
from config.env import RedisInitKeyConfig
|
||||
from module_admin.service.captcha_service import *
|
||||
from module_admin.entity.vo.login_vo import CaptchaCode
|
||||
from utils.response_util import *
|
||||
from utils.log_util import *
|
||||
from datetime import timedelta
|
||||
|
||||
|
||||
captchaController = APIRouter()
|
||||
|
||||
|
||||
@captchaController.get("/captchaImage")
|
||||
async def get_captcha_image(request: Request):
|
||||
try:
|
||||
captcha_enabled = True if await request.app.state.redis.get(f"{RedisInitKeyConfig.SYS_CONFIG.get('key')}:sys.account.captchaEnabled") == 'true' else False
|
||||
session_id = str(uuid.uuid4())
|
||||
captcha_result = CaptchaService.create_captcha_image_service()
|
||||
image = captcha_result[0]
|
||||
computed_result = captcha_result[1]
|
||||
await request.app.state.redis.set(f"{RedisInitKeyConfig.CAPTCHA_CODES.get('key')}:{session_id}", computed_result, ex=timedelta(minutes=2))
|
||||
logger.info(f'编号为{session_id}的会话获取图片验证码成功')
|
||||
return ResponseUtil.success(
|
||||
model_content=CaptchaCode(captchaEnabled=captcha_enabled, img=image, uuid=session_id)
|
||||
)
|
||||
except Exception as e:
|
||||
logger.exception(e)
|
||||
return ResponseUtil.error(msg=str(e))
|
||||
@@ -0,0 +1,87 @@
|
||||
from fastapi import APIRouter, Request
|
||||
from fastapi import Depends, File, Form, Query
|
||||
from sqlalchemy.orm import Session
|
||||
from config.env import CachePathConfig
|
||||
from config.get_db import get_db
|
||||
from module_admin.service.login_service import LoginService
|
||||
from module_admin.service.common_service import *
|
||||
from module_admin.service.config_service import ConfigService
|
||||
from utils.response_util import *
|
||||
from utils.log_util import *
|
||||
from module_admin.aspect.interface_auth import CheckUserInterfaceAuth
|
||||
from typing import Optional
|
||||
|
||||
|
||||
commonController = APIRouter(prefix='/common')
|
||||
|
||||
|
||||
@commonController.post("/upload", dependencies=[Depends(LoginService.get_current_user), Depends(CheckUserInterfaceAuth('common'))])
|
||||
async def common_upload(request: Request, taskPath: str = Form(), uploadId: str = Form(), file: UploadFile = File(...)):
|
||||
try:
|
||||
try:
|
||||
os.makedirs(os.path.join(CachePathConfig.PATH, taskPath, uploadId))
|
||||
except FileExistsError:
|
||||
pass
|
||||
CommonService.upload_service(CachePathConfig.PATH, taskPath, uploadId, file)
|
||||
logger.info('上传成功')
|
||||
return response_200(data={'filename': file.filename, 'path': f'/common/{CachePathConfig.PATHSTR}?taskPath={taskPath}&taskId={uploadId}&filename={file.filename}'}, message="上传成功")
|
||||
except Exception as e:
|
||||
logger.exception(e)
|
||||
return response_500(data="", message=str(e))
|
||||
|
||||
|
||||
@commonController.post("/uploadForEditor", dependencies=[Depends(LoginService.get_current_user), Depends(CheckUserInterfaceAuth('common'))])
|
||||
async def editor_upload(request: Request, baseUrl: str = Form(), uploadId: str = Form(), taskPath: str = Form(), file: UploadFile = File(...)):
|
||||
try:
|
||||
try:
|
||||
os.makedirs(os.path.join(CachePathConfig.PATH, taskPath, uploadId))
|
||||
except FileExistsError:
|
||||
pass
|
||||
CommonService.upload_service(CachePathConfig.PATH, taskPath, uploadId, file)
|
||||
logger.info('上传成功')
|
||||
return JSONResponse(
|
||||
status_code=status.HTTP_200_OK,
|
||||
content=jsonable_encoder(
|
||||
{
|
||||
'errno': 0,
|
||||
'data': {
|
||||
'url': f'{baseUrl}/common/{CachePathConfig.PATHSTR}?taskPath={taskPath}&taskId={uploadId}&filename={file.filename}'
|
||||
},
|
||||
}
|
||||
)
|
||||
)
|
||||
except Exception as e:
|
||||
logger.exception(e)
|
||||
return JSONResponse(
|
||||
status_code=status.HTTP_500_INTERNAL_SERVER_ERROR,
|
||||
content=jsonable_encoder(
|
||||
{
|
||||
'errno': 1,
|
||||
'message': str(e),
|
||||
}
|
||||
)
|
||||
)
|
||||
|
||||
|
||||
@commonController.get(f"/{CachePathConfig.PATHSTR}")
|
||||
async def common_download(request: Request, task_path: str = Query(alias='taskPath'), task_id: str = Query(alias='taskId'), filename: str = Query()):
|
||||
try:
|
||||
def generate_file():
|
||||
with open(os.path.join(CachePathConfig.PATH, task_path, task_id, filename), 'rb') as response_file:
|
||||
yield from response_file
|
||||
return streaming_response_200(data=generate_file())
|
||||
except Exception as e:
|
||||
logger.exception(e)
|
||||
return response_500(data="", message=str(e))
|
||||
|
||||
|
||||
@commonController.get("/config/query/{config_key}")
|
||||
async def query_system_config(request: Request, config_key: str):
|
||||
try:
|
||||
# 获取全量数据
|
||||
config_query_result = await ConfigService.query_config_list_from_cache_services(request.app.state.redis, config_key)
|
||||
logger.info('获取成功')
|
||||
return response_200(data=config_query_result, message="获取成功")
|
||||
except Exception as e:
|
||||
logger.exception(e)
|
||||
return response_500(data="", message=str(e))
|
||||
@@ -0,0 +1,136 @@
|
||||
from fastapi import APIRouter
|
||||
from fastapi import Depends
|
||||
from config.get_db import get_db
|
||||
from module_admin.service.login_service import LoginService, CurrentUserModel
|
||||
from module_admin.service.config_service import *
|
||||
from utils.response_util import *
|
||||
from utils.log_util import *
|
||||
from utils.page_util import *
|
||||
from utils.common_util import bytes2file_response
|
||||
from module_admin.aspect.interface_auth import CheckUserInterfaceAuth
|
||||
from module_admin.annotation.log_annotation import log_decorator
|
||||
|
||||
|
||||
configController = APIRouter(prefix='/system/config', dependencies=[Depends(LoginService.get_current_user)])
|
||||
|
||||
|
||||
@configController.get("/list", response_model=PageResponseModel, dependencies=[Depends(CheckUserInterfaceAuth('system:config:list'))])
|
||||
async def get_system_config_list(request: Request, config_page_query: ConfigPageQueryModel = Depends(ConfigPageQueryModel.as_query), query_db: Session = Depends(get_db)):
|
||||
try:
|
||||
config_query = ConfigQueryModel(**config_page_query.model_dump(by_alias=True))
|
||||
# 获取全量数据
|
||||
config_query_result = ConfigService.get_config_list_services(query_db, config_query)
|
||||
# 分页操作
|
||||
config_page_query_result = get_page_obj(config_query_result, config_page_query.page_num, config_page_query.page_size)
|
||||
logger.info('获取成功')
|
||||
return ResponseUtil.success(model_content=config_page_query_result)
|
||||
except Exception as e:
|
||||
logger.exception(e)
|
||||
return ResponseUtil.error(msg=str(e))
|
||||
|
||||
|
||||
@configController.post("", dependencies=[Depends(CheckUserInterfaceAuth('system:config:add'))])
|
||||
@log_decorator(title='参数管理', business_type=1)
|
||||
async def add_system_config(request: Request, add_config: ConfigModel, query_db: Session = Depends(get_db), current_user: CurrentUserModel = Depends(LoginService.get_current_user)):
|
||||
try:
|
||||
add_config.create_by = current_user.user.user_name
|
||||
add_config.update_by = current_user.user.user_name
|
||||
add_config_result = await ConfigService.add_config_services(request, query_db, add_config)
|
||||
if add_config_result.is_success:
|
||||
logger.info(add_config_result.message)
|
||||
return ResponseUtil.success(msg=add_config_result.message)
|
||||
else:
|
||||
logger.warning(add_config_result.message)
|
||||
return ResponseUtil.failure(msg=add_config_result.message)
|
||||
except Exception as e:
|
||||
logger.exception(e)
|
||||
return ResponseUtil.error(msg=str(e))
|
||||
|
||||
|
||||
@configController.put("", dependencies=[Depends(CheckUserInterfaceAuth('system:config:edit'))])
|
||||
@log_decorator(title='参数管理', business_type=2)
|
||||
async def edit_system_config(request: Request, edit_config: ConfigModel, query_db: Session = Depends(get_db), current_user: CurrentUserModel = Depends(LoginService.get_current_user)):
|
||||
try:
|
||||
edit_config.update_by = current_user.user.user_name
|
||||
edit_config.update_time = datetime.now()
|
||||
edit_config_result = await ConfigService.edit_config_services(request, query_db, edit_config)
|
||||
if edit_config_result.is_success:
|
||||
logger.info(edit_config_result.message)
|
||||
return ResponseUtil.success(msg=edit_config_result.message)
|
||||
else:
|
||||
logger.warning(edit_config_result.message)
|
||||
return ResponseUtil.failure(msg=edit_config_result.message)
|
||||
except Exception as e:
|
||||
logger.exception(e)
|
||||
return ResponseUtil.error(msg=str(e))
|
||||
|
||||
|
||||
@configController.delete("/refreshCache", dependencies=[Depends(CheckUserInterfaceAuth('system:config:edit'))])
|
||||
@log_decorator(title='参数管理', business_type=2)
|
||||
async def refresh_system_config(request: Request, query_db: Session = Depends(get_db)):
|
||||
try:
|
||||
refresh_config_result = await ConfigService.refresh_sys_config_services(request, query_db)
|
||||
if refresh_config_result.is_success:
|
||||
logger.info(refresh_config_result.message)
|
||||
return ResponseUtil.success(msg=refresh_config_result.message)
|
||||
else:
|
||||
logger.warning(refresh_config_result.message)
|
||||
return ResponseUtil.failure(msg=refresh_config_result.message)
|
||||
except Exception as e:
|
||||
logger.exception(e)
|
||||
return ResponseUtil.error(msg=str(e))
|
||||
|
||||
|
||||
@configController.delete("/{config_ids}", dependencies=[Depends(CheckUserInterfaceAuth('system:config:remove'))])
|
||||
@log_decorator(title='参数管理', business_type=3)
|
||||
async def delete_system_config(request: Request, config_ids: str, query_db: Session = Depends(get_db)):
|
||||
try:
|
||||
delete_config = DeleteConfigModel(configIds=config_ids)
|
||||
delete_config_result = await ConfigService.delete_config_services(request, query_db, delete_config)
|
||||
if delete_config_result.is_success:
|
||||
logger.info(delete_config_result.message)
|
||||
return ResponseUtil.success(msg=delete_config_result.message)
|
||||
else:
|
||||
logger.warning(delete_config_result.message)
|
||||
return ResponseUtil.failure(msg=delete_config_result.message)
|
||||
except Exception as e:
|
||||
logger.exception(e)
|
||||
return ResponseUtil.error(msg=str(e))
|
||||
|
||||
|
||||
@configController.get("/{config_id}", response_model=ConfigModel, dependencies=[Depends(CheckUserInterfaceAuth('system:config:query'))])
|
||||
async def query_detail_system_config(request: Request, config_id: int, query_db: Session = Depends(get_db)):
|
||||
try:
|
||||
config_detail_result = ConfigService.config_detail_services(query_db, config_id)
|
||||
logger.info(f'获取config_id为{config_id}的信息成功')
|
||||
return ResponseUtil.success(data=config_detail_result)
|
||||
except Exception as e:
|
||||
logger.exception(e)
|
||||
return ResponseUtil.error(msg=str(e))
|
||||
|
||||
|
||||
@configController.get("/configKey/{config_key}")
|
||||
async def query_system_config(request: Request, config_key: str):
|
||||
try:
|
||||
# 获取全量数据
|
||||
config_query_result = await ConfigService.query_config_list_from_cache_services(request.app.state.redis, config_key)
|
||||
logger.info('获取成功')
|
||||
return ResponseUtil.success(msg=config_query_result)
|
||||
except Exception as e:
|
||||
logger.exception(e)
|
||||
return ResponseUtil.error(msg=str(e))
|
||||
|
||||
|
||||
@configController.post("/export", dependencies=[Depends(CheckUserInterfaceAuth('system:config:export'))])
|
||||
@log_decorator(title='参数管理', business_type=5)
|
||||
async def export_system_config_list(request: Request, config_page_query: ConfigPageQueryModel = Depends(ConfigPageQueryModel.as_form), query_db: Session = Depends(get_db)):
|
||||
try:
|
||||
config_query = ConfigQueryModel(**config_page_query.model_dump(by_alias=True))
|
||||
# 获取全量数据
|
||||
config_query_result = ConfigService.get_config_list_services(query_db, config_query)
|
||||
config_export_result = ConfigService.export_config_list_services(config_query_result)
|
||||
logger.info('导出成功')
|
||||
return ResponseUtil.streaming(data=bytes2file_response(config_export_result))
|
||||
except Exception as e:
|
||||
logger.exception(e)
|
||||
return ResponseUtil.error(msg=str(e))
|
||||
102
ruoyi-fastapi-backend/module_admin/controller/dept_controller.py
Normal file
102
ruoyi-fastapi-backend/module_admin/controller/dept_controller.py
Normal file
@@ -0,0 +1,102 @@
|
||||
from fastapi import APIRouter, Request
|
||||
from fastapi import Depends
|
||||
from config.get_db import get_db
|
||||
from module_admin.service.login_service import LoginService, CurrentUserModel
|
||||
from module_admin.service.dept_service import *
|
||||
from utils.response_util import *
|
||||
from utils.log_util import *
|
||||
from module_admin.aspect.interface_auth import CheckUserInterfaceAuth
|
||||
from module_admin.aspect.data_scope import GetDataScope
|
||||
from module_admin.annotation.log_annotation import log_decorator
|
||||
|
||||
|
||||
deptController = APIRouter(prefix='/system/dept', dependencies=[Depends(LoginService.get_current_user)])
|
||||
|
||||
|
||||
@deptController.get("/list/exclude/{dept_id}", response_model=List[DeptModel], dependencies=[Depends(CheckUserInterfaceAuth('common'))])
|
||||
async def get_system_dept_tree_for_edit_option(request: Request, dept_id: int, query_db: Session = Depends(get_db), data_scope_sql: str = Depends(GetDataScope('SysDept'))):
|
||||
try:
|
||||
dept_query = DeptModel(deptId=dept_id)
|
||||
dept_query_result = DeptService.get_dept_for_edit_option_services(query_db, dept_query, data_scope_sql)
|
||||
logger.info('获取成功')
|
||||
return ResponseUtil.success(data=dept_query_result)
|
||||
except Exception as e:
|
||||
logger.exception(e)
|
||||
return ResponseUtil.error(msg=str(e))
|
||||
|
||||
|
||||
@deptController.get("/list", response_model=List[DeptModel], dependencies=[Depends(CheckUserInterfaceAuth('system:dept:list'))])
|
||||
async def get_system_dept_list(request: Request, dept_query: DeptQueryModel = Depends(DeptQueryModel.as_query), query_db: Session = Depends(get_db), data_scope_sql: str = Depends(GetDataScope('SysDept'))):
|
||||
try:
|
||||
dept_query_result = DeptService.get_dept_list_services(query_db, dept_query, data_scope_sql)
|
||||
logger.info('获取成功')
|
||||
return ResponseUtil.success(data=dept_query_result)
|
||||
except Exception as e:
|
||||
logger.exception(e)
|
||||
return ResponseUtil.error(msg=str(e))
|
||||
|
||||
|
||||
@deptController.post("", dependencies=[Depends(CheckUserInterfaceAuth('system:dept:add'))])
|
||||
@log_decorator(title='部门管理', business_type=1)
|
||||
async def add_system_dept(request: Request, add_dept: DeptModel, query_db: Session = Depends(get_db), current_user: CurrentUserModel = Depends(LoginService.get_current_user)):
|
||||
try:
|
||||
add_dept.create_by = current_user.user.user_name
|
||||
add_dept.update_by = current_user.user.user_name
|
||||
add_dept_result = DeptService.add_dept_services(query_db, add_dept)
|
||||
if add_dept_result.is_success:
|
||||
logger.info(add_dept_result.message)
|
||||
return ResponseUtil.success(data=add_dept_result)
|
||||
else:
|
||||
logger.warning(add_dept_result.message)
|
||||
return ResponseUtil.failure(msg=add_dept_result.message)
|
||||
except Exception as e:
|
||||
logger.exception(e)
|
||||
return ResponseUtil.error(msg=str(e))
|
||||
|
||||
|
||||
@deptController.put("", dependencies=[Depends(CheckUserInterfaceAuth('system:dept:edit'))])
|
||||
@log_decorator(title='部门管理', business_type=2)
|
||||
async def edit_system_dept(request: Request, edit_dept: DeptModel, query_db: Session = Depends(get_db), current_user: CurrentUserModel = Depends(LoginService.get_current_user)):
|
||||
try:
|
||||
edit_dept.update_by = current_user.user.user_name
|
||||
edit_dept.update_time = datetime.now()
|
||||
edit_dept_result = DeptService.edit_dept_services(query_db, edit_dept)
|
||||
if edit_dept_result.is_success:
|
||||
logger.info(edit_dept_result.message)
|
||||
return ResponseUtil.success(msg=edit_dept_result.message)
|
||||
else:
|
||||
logger.warning(edit_dept_result.message)
|
||||
return ResponseUtil.failure(msg=edit_dept_result.message)
|
||||
except Exception as e:
|
||||
logger.exception(e)
|
||||
return ResponseUtil.error(msg=str(e))
|
||||
|
||||
|
||||
@deptController.delete("/{dept_ids}", dependencies=[Depends(CheckUserInterfaceAuth('system:dept:remove'))])
|
||||
@log_decorator(title='部门管理', business_type=3)
|
||||
async def delete_system_dept(request: Request, dept_ids: str, query_db: Session = Depends(get_db), current_user: CurrentUserModel = Depends(LoginService.get_current_user)):
|
||||
try:
|
||||
delete_dept = DeleteDeptModel(deptIds=dept_ids)
|
||||
delete_dept.update_by = current_user.user.user_name
|
||||
delete_dept.update_time = datetime.now()
|
||||
delete_dept_result = DeptService.delete_dept_services(query_db, delete_dept)
|
||||
if delete_dept_result.is_success:
|
||||
logger.info(delete_dept_result.message)
|
||||
return ResponseUtil.success(msg=delete_dept_result.message)
|
||||
else:
|
||||
logger.warning(delete_dept_result.message)
|
||||
return ResponseUtil.failure(msg=delete_dept_result.message)
|
||||
except Exception as e:
|
||||
logger.exception(e)
|
||||
return ResponseUtil.error(msg=str(e))
|
||||
|
||||
|
||||
@deptController.get("/{dept_id}", response_model=DeptModel, dependencies=[Depends(CheckUserInterfaceAuth('system:dept:query'))])
|
||||
async def query_detail_system_dept(request: Request, dept_id: int, query_db: Session = Depends(get_db)):
|
||||
try:
|
||||
detail_dept_result = DeptService.dept_detail_services(query_db, dept_id)
|
||||
logger.info(f'获取dept_id为{dept_id}的信息成功')
|
||||
return ResponseUtil.success(data=detail_dept_result)
|
||||
except Exception as e:
|
||||
logger.exception(e)
|
||||
return ResponseUtil.error(msg=str(e))
|
||||
241
ruoyi-fastapi-backend/module_admin/controller/dict_controller.py
Normal file
241
ruoyi-fastapi-backend/module_admin/controller/dict_controller.py
Normal file
@@ -0,0 +1,241 @@
|
||||
from fastapi import APIRouter
|
||||
from fastapi import Depends
|
||||
from config.get_db import get_db
|
||||
from module_admin.service.login_service import LoginService, CurrentUserModel
|
||||
from module_admin.service.dict_service import *
|
||||
from utils.response_util import *
|
||||
from utils.log_util import *
|
||||
from utils.page_util import *
|
||||
from utils.common_util import bytes2file_response
|
||||
from module_admin.aspect.interface_auth import CheckUserInterfaceAuth
|
||||
from module_admin.annotation.log_annotation import log_decorator
|
||||
|
||||
|
||||
dictController = APIRouter(prefix='/system/dict', dependencies=[Depends(LoginService.get_current_user)])
|
||||
|
||||
|
||||
@dictController.get("/type/list", response_model=PageResponseModel, dependencies=[Depends(CheckUserInterfaceAuth('system:dict:list'))])
|
||||
async def get_system_dict_type_list(request: Request, dict_type_page_query: DictTypePageQueryModel = Depends(DictTypePageQueryModel.as_query), query_db: Session = Depends(get_db)):
|
||||
try:
|
||||
dict_type_query = DictTypeQueryModel(**dict_type_page_query.model_dump(by_alias=True))
|
||||
# 获取全量数据
|
||||
dict_type_query_result = DictTypeService.get_dict_type_list_services(query_db, dict_type_query)
|
||||
# 分页操作
|
||||
dict_type_page_query_result = get_page_obj(dict_type_query_result, dict_type_page_query.page_num, dict_type_page_query.page_size)
|
||||
logger.info('获取成功')
|
||||
return ResponseUtil.success(model_content=dict_type_page_query_result)
|
||||
except Exception as e:
|
||||
logger.exception(e)
|
||||
return ResponseUtil.error(msg=str(e))
|
||||
|
||||
|
||||
@dictController.post("/type", dependencies=[Depends(CheckUserInterfaceAuth('system:dict:add'))])
|
||||
@log_decorator(title='字典管理', business_type=1)
|
||||
async def add_system_dict_type(request: Request, add_dict_type: DictTypeModel, query_db: Session = Depends(get_db), current_user: CurrentUserModel = Depends(LoginService.get_current_user)):
|
||||
try:
|
||||
add_dict_type.create_by = current_user.user.user_name
|
||||
add_dict_type.update_by = current_user.user.user_name
|
||||
add_dict_type_result = await DictTypeService.add_dict_type_services(request, query_db, add_dict_type)
|
||||
if add_dict_type_result.is_success:
|
||||
logger.info(add_dict_type_result.message)
|
||||
return ResponseUtil.success(msg=add_dict_type_result.message)
|
||||
else:
|
||||
logger.warning(add_dict_type_result.message)
|
||||
return ResponseUtil.failure(msg=add_dict_type_result.message)
|
||||
except Exception as e:
|
||||
logger.exception(e)
|
||||
return ResponseUtil.error(msg=str(e))
|
||||
|
||||
|
||||
@dictController.put("/type", dependencies=[Depends(CheckUserInterfaceAuth('system:dict:edit'))])
|
||||
@log_decorator(title='字典管理', business_type=2)
|
||||
async def edit_system_dict_type(request: Request, edit_dict_type: DictTypeModel, query_db: Session = Depends(get_db), current_user: CurrentUserModel = Depends(LoginService.get_current_user)):
|
||||
try:
|
||||
edit_dict_type.update_by = current_user.user.user_name
|
||||
edit_dict_type.update_time = datetime.now()
|
||||
edit_dict_type_result = await DictTypeService.edit_dict_type_services(request, query_db, edit_dict_type)
|
||||
if edit_dict_type_result.is_success:
|
||||
logger.info(edit_dict_type_result.message)
|
||||
return ResponseUtil.success(msg=edit_dict_type_result.message)
|
||||
else:
|
||||
logger.warning(edit_dict_type_result.message)
|
||||
return ResponseUtil.failure(msg=edit_dict_type_result.message)
|
||||
except Exception as e:
|
||||
logger.exception(e)
|
||||
return ResponseUtil.error(msg=str(e))
|
||||
|
||||
|
||||
@dictController.delete("/type/refreshCache", dependencies=[Depends(CheckUserInterfaceAuth('system:dict:edit'))])
|
||||
@log_decorator(title='字典管理', business_type=2)
|
||||
async def refresh_system_dict(request: Request, query_db: Session = Depends(get_db)):
|
||||
try:
|
||||
refresh_dict_result = await DictTypeService.refresh_sys_dict_services(request, query_db)
|
||||
if refresh_dict_result.is_success:
|
||||
logger.info(refresh_dict_result.message)
|
||||
return ResponseUtil.success(msg=refresh_dict_result.message)
|
||||
else:
|
||||
logger.warning(refresh_dict_result.message)
|
||||
return ResponseUtil.failure(msg=refresh_dict_result.message)
|
||||
except Exception as e:
|
||||
logger.exception(e)
|
||||
return ResponseUtil.error(msg=str(e))
|
||||
|
||||
|
||||
@dictController.delete("/type/{dict_ids}", dependencies=[Depends(CheckUserInterfaceAuth('system:dict:remove'))])
|
||||
@log_decorator(title='字典管理', business_type=3)
|
||||
async def delete_system_dict_type(request: Request, dict_ids: str, query_db: Session = Depends(get_db)):
|
||||
try:
|
||||
delete_dict_type = DeleteDictTypeModel(dictIds=dict_ids)
|
||||
delete_dict_type_result = await DictTypeService.delete_dict_type_services(request, query_db, delete_dict_type)
|
||||
if delete_dict_type_result.is_success:
|
||||
logger.info(delete_dict_type_result.message)
|
||||
return ResponseUtil.success(msg=delete_dict_type_result.message)
|
||||
else:
|
||||
logger.warning(delete_dict_type_result.message)
|
||||
return ResponseUtil.failure(msg=delete_dict_type_result.message)
|
||||
except Exception as e:
|
||||
logger.exception(e)
|
||||
return ResponseUtil.error(msg=str(e))
|
||||
|
||||
|
||||
@dictController.get("/type/optionselect", response_model=List[DictTypeModel], dependencies=[Depends(CheckUserInterfaceAuth('system:dict:query'))])
|
||||
async def query_system_dict_type_options(request: Request, query_db: Session = Depends(get_db)):
|
||||
try:
|
||||
dict_type_query_result = DictTypeService.get_dict_type_list_services(query_db, DictTypeQueryModel(**dict()))
|
||||
logger.info(f'获取成功')
|
||||
return ResponseUtil.success(data=dict_type_query_result)
|
||||
except Exception as e:
|
||||
logger.exception(e)
|
||||
return ResponseUtil.error(msg=str(e))
|
||||
|
||||
|
||||
@dictController.get("/type/{dict_id}", response_model=DictTypeModel, dependencies=[Depends(CheckUserInterfaceAuth('system:dict:query'))])
|
||||
async def query_detail_system_dict_type(request: Request, dict_id: int, query_db: Session = Depends(get_db)):
|
||||
try:
|
||||
dict_type_detail_result = DictTypeService.dict_type_detail_services(query_db, dict_id)
|
||||
logger.info(f'获取dict_id为{dict_id}的信息成功')
|
||||
return ResponseUtil.success(data=dict_type_detail_result)
|
||||
except Exception as e:
|
||||
logger.exception(e)
|
||||
return ResponseUtil.error(msg=str(e))
|
||||
|
||||
|
||||
@dictController.post("/type/export", dependencies=[Depends(CheckUserInterfaceAuth('system:dict:export'))])
|
||||
@log_decorator(title='字典管理', business_type=5)
|
||||
async def export_system_dict_type_list(request: Request, dict_type_page_query: DictTypePageQueryModel = Depends(DictTypePageQueryModel.as_form), query_db: Session = Depends(get_db)):
|
||||
try:
|
||||
dict_type_query = DictTypeQueryModel(**dict_type_page_query.model_dump(by_alias=True))
|
||||
# 获取全量数据
|
||||
dict_type_query_result = DictTypeService.get_dict_type_list_services(query_db, dict_type_query)
|
||||
dict_type_export_result = DictTypeService.export_dict_type_list_services(dict_type_query_result)
|
||||
logger.info('导出成功')
|
||||
return ResponseUtil.streaming(data=bytes2file_response(dict_type_export_result))
|
||||
except Exception as e:
|
||||
logger.exception(e)
|
||||
return ResponseUtil.error(msg=str(e))
|
||||
|
||||
|
||||
@dictController.get("/data/type/{dict_type}", dependencies=[Depends(CheckUserInterfaceAuth('system:dict:list'))])
|
||||
async def query_system_dict_type_data(request: Request, dict_type: str, query_db: Session = Depends(get_db)):
|
||||
try:
|
||||
# 获取全量数据
|
||||
dict_data_query_result = await DictDataService.query_dict_data_list_from_cache_services(request.app.state.redis, dict_type)
|
||||
logger.info('获取成功')
|
||||
return ResponseUtil.success(data=dict_data_query_result)
|
||||
except Exception as e:
|
||||
logger.exception(e)
|
||||
return ResponseUtil.error(msg=str(e))
|
||||
|
||||
|
||||
@dictController.get("/data/list", response_model=PageResponseModel, dependencies=[Depends(CheckUserInterfaceAuth('system:dict:list'))])
|
||||
async def get_system_dict_data_list(request: Request, dict_data_page_query: DictDataPageQueryModel = Depends(DictDataPageQueryModel.as_query), query_db: Session = Depends(get_db)):
|
||||
try:
|
||||
dict_data_query = DictDataModel(**dict_data_page_query.model_dump(by_alias=True))
|
||||
# 获取全量数据
|
||||
dict_data_query_result = DictDataService.get_dict_data_list_services(query_db, dict_data_query)
|
||||
# 分页操作
|
||||
dict_data_page_query_result = get_page_obj(dict_data_query_result, dict_data_page_query.page_num, dict_data_page_query.page_size)
|
||||
logger.info('获取成功')
|
||||
return ResponseUtil.success(model_content=dict_data_page_query_result)
|
||||
except Exception as e:
|
||||
logger.exception(e)
|
||||
return ResponseUtil.error(msg=str(e))
|
||||
|
||||
|
||||
@dictController.post("/data", dependencies=[Depends(CheckUserInterfaceAuth('system:dict:add'))])
|
||||
@log_decorator(title='字典管理', business_type=1)
|
||||
async def add_system_dict_data(request: Request, add_dict_data: DictDataModel, query_db: Session = Depends(get_db), current_user: CurrentUserModel = Depends(LoginService.get_current_user)):
|
||||
try:
|
||||
add_dict_data.create_by = current_user.user.user_name
|
||||
add_dict_data.update_by = current_user.user.user_name
|
||||
add_dict_data_result = await DictDataService.add_dict_data_services(request, query_db, add_dict_data)
|
||||
if add_dict_data_result.is_success:
|
||||
logger.info(add_dict_data_result.message)
|
||||
return ResponseUtil.success(msg=add_dict_data_result.message)
|
||||
else:
|
||||
logger.warning(add_dict_data_result.message)
|
||||
return ResponseUtil.failure(msg=add_dict_data_result.message)
|
||||
except Exception as e:
|
||||
logger.exception(e)
|
||||
return ResponseUtil.error(msg=str(e))
|
||||
|
||||
|
||||
@dictController.put("/data", dependencies=[Depends(CheckUserInterfaceAuth('system:dict:edit'))])
|
||||
@log_decorator(title='字典管理', business_type=2)
|
||||
async def edit_system_dict_data(request: Request, edit_dict_data: DictDataModel, query_db: Session = Depends(get_db), current_user: CurrentUserModel = Depends(LoginService.get_current_user)):
|
||||
try:
|
||||
edit_dict_data.update_by = current_user.user.user_name
|
||||
edit_dict_data.update_time = datetime.now()
|
||||
edit_dict_data_result = await DictDataService.edit_dict_data_services(request, query_db, edit_dict_data)
|
||||
if edit_dict_data_result.is_success:
|
||||
logger.info(edit_dict_data_result.message)
|
||||
return ResponseUtil.success(msg=edit_dict_data_result.message)
|
||||
else:
|
||||
logger.warning(edit_dict_data_result.message)
|
||||
return ResponseUtil.failure(msg=edit_dict_data_result.message)
|
||||
except Exception as e:
|
||||
logger.exception(e)
|
||||
return ResponseUtil.error(msg=str(e))
|
||||
|
||||
|
||||
@dictController.delete("/data/{dict_codes}", dependencies=[Depends(CheckUserInterfaceAuth('system:dict:remove'))])
|
||||
@log_decorator(title='字典管理', business_type=3)
|
||||
async def delete_system_dict_data(request: Request, dict_codes: str, query_db: Session = Depends(get_db)):
|
||||
try:
|
||||
delete_dict_data = DeleteDictDataModel(dictCodes=dict_codes)
|
||||
delete_dict_data_result = await DictDataService.delete_dict_data_services(request, query_db, delete_dict_data)
|
||||
if delete_dict_data_result.is_success:
|
||||
logger.info(delete_dict_data_result.message)
|
||||
return ResponseUtil.success(msg=delete_dict_data_result.message)
|
||||
else:
|
||||
logger.warning(delete_dict_data_result.message)
|
||||
return ResponseUtil.failure(msg=delete_dict_data_result.message)
|
||||
except Exception as e:
|
||||
logger.exception(e)
|
||||
return ResponseUtil.error(msg=str(e))
|
||||
|
||||
|
||||
@dictController.get("/data/{dict_code}", response_model=DictDataModel, dependencies=[Depends(CheckUserInterfaceAuth('system:dict:query'))])
|
||||
async def query_detail_system_dict_data(request: Request, dict_code: int, query_db: Session = Depends(get_db)):
|
||||
try:
|
||||
detail_dict_data_result = DictDataService.dict_data_detail_services(query_db, dict_code)
|
||||
logger.info(f'获取dict_code为{dict_code}的信息成功')
|
||||
return ResponseUtil.success(data=detail_dict_data_result)
|
||||
except Exception as e:
|
||||
logger.exception(e)
|
||||
return ResponseUtil.error(msg=str(e))
|
||||
|
||||
|
||||
@dictController.post("/data/export", dependencies=[Depends(CheckUserInterfaceAuth('system:dict:export'))])
|
||||
@log_decorator(title='字典管理', business_type=5)
|
||||
async def export_system_dict_data_list(request: Request, dict_data_page_query: DictDataPageQueryModel = Depends(DictDataPageQueryModel.as_form), query_db: Session = Depends(get_db)):
|
||||
try:
|
||||
dict_data_query = DictDataModel(**dict_data_page_query.model_dump(by_alias=True))
|
||||
# 获取全量数据
|
||||
dict_data_query_result = DictDataService.get_dict_data_list_services(query_db, dict_data_query)
|
||||
dict_data_export_result = DictDataService.export_dict_data_list_services(dict_data_query_result)
|
||||
logger.info('导出成功')
|
||||
return ResponseUtil.streaming(data=bytes2file_response(dict_data_export_result))
|
||||
except Exception as e:
|
||||
logger.exception(e)
|
||||
return ResponseUtil.error(msg=str(e))
|
||||
207
ruoyi-fastapi-backend/module_admin/controller/job_controller.py
Normal file
207
ruoyi-fastapi-backend/module_admin/controller/job_controller.py
Normal file
@@ -0,0 +1,207 @@
|
||||
from fastapi import APIRouter
|
||||
from fastapi import Depends
|
||||
from config.get_db import get_db
|
||||
from module_admin.service.login_service import LoginService, CurrentUserModel
|
||||
from module_admin.service.job_service import *
|
||||
from module_admin.service.job_log_service import *
|
||||
from utils.response_util import *
|
||||
from utils.log_util import *
|
||||
from utils.page_util import *
|
||||
from utils.common_util import bytes2file_response
|
||||
from module_admin.aspect.interface_auth import CheckUserInterfaceAuth
|
||||
from module_admin.annotation.log_annotation import log_decorator
|
||||
|
||||
|
||||
jobController = APIRouter(prefix='/monitor', dependencies=[Depends(LoginService.get_current_user)])
|
||||
|
||||
|
||||
@jobController.get("/job/list", response_model=PageResponseModel, dependencies=[Depends(CheckUserInterfaceAuth('monitor:job:list'))])
|
||||
async def get_system_job_list(request: Request, job_page_query: JobPageQueryModel = Depends(JobPageQueryModel.as_query), query_db: Session = Depends(get_db)):
|
||||
try:
|
||||
job_query = JobModel(**job_page_query.model_dump(by_alias=True))
|
||||
# 获取全量数据
|
||||
job_query_result = JobService.get_job_list_services(query_db, job_query)
|
||||
# 分页操作
|
||||
notice_page_query_result = get_page_obj(job_query_result, job_page_query.page_num, job_page_query.page_size)
|
||||
logger.info('获取成功')
|
||||
return ResponseUtil.success(model_content=notice_page_query_result)
|
||||
except Exception as e:
|
||||
logger.exception(e)
|
||||
return ResponseUtil.error(msg=str(e))
|
||||
|
||||
|
||||
@jobController.post("/job", dependencies=[Depends(CheckUserInterfaceAuth('monitor:job:add'))])
|
||||
@log_decorator(title='定时任务管理', business_type=1)
|
||||
async def add_system_job(request: Request, add_job: JobModel, query_db: Session = Depends(get_db), current_user: CurrentUserModel = Depends(LoginService.get_current_user)):
|
||||
try:
|
||||
add_job.create_by = current_user.user.user_name
|
||||
add_job.update_by = current_user.user.user_name
|
||||
add_job_result = JobService.add_job_services(query_db, add_job)
|
||||
if add_job_result.is_success:
|
||||
logger.info(add_job_result.message)
|
||||
return ResponseUtil.success(msg=add_job_result.message)
|
||||
else:
|
||||
logger.warning(add_job_result.message)
|
||||
return ResponseUtil.failure(msg=add_job_result.message)
|
||||
except Exception as e:
|
||||
logger.exception(e)
|
||||
return ResponseUtil.error(msg=str(e))
|
||||
|
||||
|
||||
@jobController.put("/job", dependencies=[Depends(CheckUserInterfaceAuth('monitor:job:edit'))])
|
||||
@log_decorator(title='定时任务管理', business_type=2)
|
||||
async def edit_system_job(request: Request, edit_job: EditJobModel, query_db: Session = Depends(get_db), current_user: CurrentUserModel = Depends(LoginService.get_current_user)):
|
||||
try:
|
||||
edit_job.update_by = current_user.user.user_name
|
||||
edit_job.update_time = datetime.now()
|
||||
edit_job_result = JobService.edit_job_services(query_db, edit_job)
|
||||
if edit_job_result.is_success:
|
||||
logger.info(edit_job_result.message)
|
||||
return ResponseUtil.success(msg=edit_job_result.message)
|
||||
else:
|
||||
logger.warning(edit_job_result.message)
|
||||
return ResponseUtil.failure(msg=edit_job_result.message)
|
||||
except Exception as e:
|
||||
logger.exception(e)
|
||||
return ResponseUtil.error(msg=str(e))
|
||||
|
||||
|
||||
@jobController.put("/job/changeStatus", dependencies=[Depends(CheckUserInterfaceAuth('monitor:job:edit'))])
|
||||
@log_decorator(title='定时任务管理', business_type=2)
|
||||
async def edit_system_job(request: Request, edit_job: EditJobModel, query_db: Session = Depends(get_db), current_user: CurrentUserModel = Depends(LoginService.get_current_user)):
|
||||
try:
|
||||
edit_job.update_by = current_user.user.user_name
|
||||
edit_job.update_time = datetime.now()
|
||||
edit_job.type = 'status'
|
||||
edit_job_result = JobService.edit_job_services(query_db, edit_job)
|
||||
if edit_job_result.is_success:
|
||||
logger.info(edit_job_result.message)
|
||||
return ResponseUtil.success(msg=edit_job_result.message)
|
||||
else:
|
||||
logger.warning(edit_job_result.message)
|
||||
return ResponseUtil.failure(msg=edit_job_result.message)
|
||||
except Exception as e:
|
||||
logger.exception(e)
|
||||
return ResponseUtil.error(msg=str(e))
|
||||
|
||||
|
||||
@jobController.put("/job/run", dependencies=[Depends(CheckUserInterfaceAuth('monitor:job:changeStatus'))])
|
||||
@log_decorator(title='定时任务管理', business_type=2)
|
||||
async def execute_system_job(request: Request, execute_job: JobModel, query_db: Session = Depends(get_db)):
|
||||
try:
|
||||
execute_job_result = JobService.execute_job_once_services(query_db, execute_job)
|
||||
if execute_job_result.is_success:
|
||||
logger.info(execute_job_result.message)
|
||||
return ResponseUtil.success(msg=execute_job_result.message)
|
||||
else:
|
||||
logger.warning(execute_job_result.message)
|
||||
return ResponseUtil.failure(msg=execute_job_result.message)
|
||||
except Exception as e:
|
||||
logger.exception(e)
|
||||
return ResponseUtil.error(msg=str(e))
|
||||
|
||||
|
||||
@jobController.delete("/job/{job_ids}", dependencies=[Depends(CheckUserInterfaceAuth('monitor:job:remove'))])
|
||||
@log_decorator(title='定时任务管理', business_type=3)
|
||||
async def delete_system_job(request: Request, job_ids: str, query_db: Session = Depends(get_db)):
|
||||
try:
|
||||
delete_job = DeleteJobModel(jobIds=job_ids)
|
||||
delete_job_result = JobService.delete_job_services(query_db, delete_job)
|
||||
if delete_job_result.is_success:
|
||||
logger.info(delete_job_result.message)
|
||||
return ResponseUtil.success(msg=delete_job_result.message)
|
||||
else:
|
||||
logger.warning(delete_job_result.message)
|
||||
return ResponseUtil.failure(msg=delete_job_result.message)
|
||||
except Exception as e:
|
||||
logger.exception(e)
|
||||
return ResponseUtil.error(msg=str(e))
|
||||
|
||||
|
||||
@jobController.get("/job/{job_id}", response_model=JobModel, dependencies=[Depends(CheckUserInterfaceAuth('monitor:job:query'))])
|
||||
async def query_detail_system_job(request: Request, job_id: int, query_db: Session = Depends(get_db)):
|
||||
try:
|
||||
job_detail_result = JobService.job_detail_services(query_db, job_id)
|
||||
logger.info(f'获取job_id为{job_id}的信息成功')
|
||||
return ResponseUtil.success(data=job_detail_result)
|
||||
except Exception as e:
|
||||
logger.exception(e)
|
||||
return ResponseUtil.error(msg=str(e))
|
||||
|
||||
|
||||
@jobController.post("/job/export", dependencies=[Depends(CheckUserInterfaceAuth('monitor:job:export'))])
|
||||
@log_decorator(title='定时任务管理', business_type=5)
|
||||
async def export_system_job_list(request: Request, job_page_query: JobPageQueryModel = Depends(JobPageQueryModel.as_form), query_db: Session = Depends(get_db)):
|
||||
try:
|
||||
job_query = JobModel(**job_page_query.model_dump(by_alias=True))
|
||||
# 获取全量数据
|
||||
job_query_result = JobService.get_job_list_services(query_db, job_query)
|
||||
job_export_result = await JobService.export_job_list_services(request, job_query_result)
|
||||
logger.info('导出成功')
|
||||
return ResponseUtil.streaming(data=bytes2file_response(job_export_result))
|
||||
except Exception as e:
|
||||
logger.exception(e)
|
||||
return ResponseUtil.error(msg=str(e))
|
||||
|
||||
|
||||
@jobController.get("/jobLog/list", response_model=PageResponseModel, dependencies=[Depends(CheckUserInterfaceAuth('monitor:job:list'))])
|
||||
async def get_system_job_log_list(request: Request, job_log_page_query: JobLogPageQueryModel = Depends(JobLogPageQueryModel.as_query), query_db: Session = Depends(get_db)):
|
||||
try:
|
||||
job_log_query = JobLogQueryModel(**job_log_page_query.model_dump(by_alias=True))
|
||||
# 获取全量数据
|
||||
job_log_query_result = JobLogService.get_job_log_list_services(query_db, job_log_query)
|
||||
# 分页操作
|
||||
notice_page_query_result = get_page_obj(job_log_query_result, job_log_page_query.page_num, job_log_page_query.page_size)
|
||||
logger.info('获取成功')
|
||||
return ResponseUtil.success(model_content=notice_page_query_result)
|
||||
except Exception as e:
|
||||
logger.exception(e)
|
||||
return ResponseUtil.error(msg=str(e))
|
||||
|
||||
|
||||
@jobController.delete("/jobLog/{job_log_ids}", dependencies=[Depends(CheckUserInterfaceAuth('monitor:job:remove'))])
|
||||
@log_decorator(title='定时任务日志管理', business_type=3)
|
||||
async def delete_system_job_log(request: Request, job_log_ids: str, query_db: Session = Depends(get_db)):
|
||||
try:
|
||||
delete_job_log = DeleteJobLogModel(jobLogIds=job_log_ids)
|
||||
delete_job_log_result = JobLogService.delete_job_log_services(query_db, delete_job_log)
|
||||
if delete_job_log_result.is_success:
|
||||
logger.info(delete_job_log_result.message)
|
||||
return ResponseUtil.success(msg=delete_job_log_result.message)
|
||||
else:
|
||||
logger.warning(delete_job_log_result.message)
|
||||
return ResponseUtil.failure(msg=delete_job_log_result.message)
|
||||
except Exception as e:
|
||||
logger.exception(e)
|
||||
return ResponseUtil.error(msg=str(e))
|
||||
|
||||
|
||||
@jobController.post("/jobLog/clean", dependencies=[Depends(CheckUserInterfaceAuth('monitor:job:remove'))])
|
||||
@log_decorator(title='定时任务日志管理', business_type=9)
|
||||
async def clear_system_job_log(request: Request, query_db: Session = Depends(get_db)):
|
||||
try:
|
||||
clear_job_log_result = JobLogService.clear_job_log_services(query_db)
|
||||
if clear_job_log_result.is_success:
|
||||
logger.info(clear_job_log_result.message)
|
||||
return ResponseUtil.success(msg=clear_job_log_result.message)
|
||||
else:
|
||||
logger.warning(clear_job_log_result.message)
|
||||
return ResponseUtil.failure(msg=clear_job_log_result.message)
|
||||
except Exception as e:
|
||||
logger.exception(e)
|
||||
return ResponseUtil.error(msg=str(e))
|
||||
|
||||
|
||||
@jobController.post("/jobLog/export", dependencies=[Depends(CheckUserInterfaceAuth('monitor:job:export'))])
|
||||
@log_decorator(title='定时任务日志管理', business_type=5)
|
||||
async def export_system_job_log_list(request: Request, job_log_page_query: JobLogPageQueryModel = Depends(JobLogPageQueryModel.as_form), query_db: Session = Depends(get_db)):
|
||||
try:
|
||||
job_log_query = JobLogQueryModel(**job_log_page_query.model_dump(by_alias=True))
|
||||
# 获取全量数据
|
||||
job_log_query_result = JobLogService.get_job_log_list_services(query_db, job_log_query)
|
||||
job_log_export_result = JobLogService.export_job_log_list_services(query_db, job_log_query_result)
|
||||
logger.info('导出成功')
|
||||
return ResponseUtil.streaming(data=bytes2file_response(job_log_export_result))
|
||||
except Exception as e:
|
||||
logger.exception(e)
|
||||
return ResponseUtil.error(msg=str(e))
|
||||
157
ruoyi-fastapi-backend/module_admin/controller/log_controller.py
Normal file
157
ruoyi-fastapi-backend/module_admin/controller/log_controller.py
Normal file
@@ -0,0 +1,157 @@
|
||||
from fastapi import APIRouter
|
||||
from fastapi import Depends
|
||||
from config.get_db import get_db
|
||||
from module_admin.service.login_service import LoginService
|
||||
from module_admin.service.log_service import *
|
||||
from utils.response_util import *
|
||||
from utils.log_util import *
|
||||
from utils.page_util import *
|
||||
from utils.common_util import bytes2file_response
|
||||
from module_admin.aspect.interface_auth import CheckUserInterfaceAuth
|
||||
from module_admin.annotation.log_annotation import log_decorator
|
||||
|
||||
|
||||
logController = APIRouter(prefix='/monitor', dependencies=[Depends(LoginService.get_current_user)])
|
||||
|
||||
|
||||
@logController.get("/operlog/list", response_model=PageResponseModel, dependencies=[Depends(CheckUserInterfaceAuth('monitor:operlog:list'))])
|
||||
async def get_system_operation_log_list(request: Request, operation_log_page_query: OperLogPageQueryModel = Depends(OperLogPageQueryModel.as_query), query_db: Session = Depends(get_db)):
|
||||
try:
|
||||
operation_log_query = OperLogQueryModel(**operation_log_page_query.model_dump(by_alias=True))
|
||||
# 获取全量数据
|
||||
operation_log_query_result = OperationLogService.get_operation_log_list_services(query_db, operation_log_query)
|
||||
# 分页操作
|
||||
operation_log_page_query_result = get_page_obj(operation_log_query_result, operation_log_page_query.page_num, operation_log_page_query.page_size)
|
||||
logger.info('获取成功')
|
||||
return ResponseUtil.success(model_content=operation_log_page_query_result)
|
||||
except Exception as e:
|
||||
logger.exception(e)
|
||||
return ResponseUtil.error(msg=str(e))
|
||||
|
||||
|
||||
@logController.delete("/operlog/clean", dependencies=[Depends(CheckUserInterfaceAuth('monitor:operlog:remove'))])
|
||||
@log_decorator(title='操作日志管理', business_type=9)
|
||||
async def clear_system_operation_log(request: Request, query_db: Session = Depends(get_db)):
|
||||
try:
|
||||
clear_operation_log_result = OperationLogService.clear_operation_log_services(query_db)
|
||||
if clear_operation_log_result.is_success:
|
||||
logger.info(clear_operation_log_result.message)
|
||||
return ResponseUtil.success(msg=clear_operation_log_result.message)
|
||||
else:
|
||||
logger.warning(clear_operation_log_result.message)
|
||||
return ResponseUtil.failure(msg=clear_operation_log_result.message)
|
||||
except Exception as e:
|
||||
logger.exception(e)
|
||||
return ResponseUtil.error(msg=str(e))
|
||||
|
||||
|
||||
@logController.delete("/operlog/{oper_ids}", dependencies=[Depends(CheckUserInterfaceAuth('monitor:operlog:remove'))])
|
||||
@log_decorator(title='操作日志管理', business_type=3)
|
||||
async def delete_system_operation_log(request: Request, oper_ids: str, query_db: Session = Depends(get_db)):
|
||||
try:
|
||||
delete_operation_log = DeleteOperLogModel(operIds=oper_ids)
|
||||
delete_operation_log_result = OperationLogService.delete_operation_log_services(query_db, delete_operation_log)
|
||||
if delete_operation_log_result.is_success:
|
||||
logger.info(delete_operation_log_result.message)
|
||||
return ResponseUtil.success(msg=delete_operation_log_result.message)
|
||||
else:
|
||||
logger.warning(delete_operation_log_result.message)
|
||||
return ResponseUtil.failure(msg=delete_operation_log_result.message)
|
||||
except Exception as e:
|
||||
logger.exception(e)
|
||||
return ResponseUtil.error(msg=str(e))
|
||||
|
||||
|
||||
@logController.post("/operlog/export", dependencies=[Depends(CheckUserInterfaceAuth('monitor:operlog:export'))])
|
||||
@log_decorator(title='操作日志管理', business_type=5)
|
||||
async def export_system_operation_log_list(request: Request, operation_log_page_query: OperLogPageQueryModel = Depends(OperLogPageQueryModel.as_form), query_db: Session = Depends(get_db)):
|
||||
try:
|
||||
operation_log_query = OperLogQueryModel(**operation_log_page_query.model_dump(by_alias=True))
|
||||
# 获取全量数据
|
||||
operation_log_query_result = OperationLogService.get_operation_log_list_services(query_db, operation_log_query)
|
||||
operation_log_export_result = await OperationLogService.export_operation_log_list_services(request, operation_log_query_result)
|
||||
logger.info('导出成功')
|
||||
return ResponseUtil.streaming(data=bytes2file_response(operation_log_export_result))
|
||||
except Exception as e:
|
||||
logger.exception(e)
|
||||
return response_500(data="", message=str(e))
|
||||
|
||||
|
||||
@logController.get("/logininfor/list", response_model=PageResponseModel, dependencies=[Depends(CheckUserInterfaceAuth('monitor:logininfor:list'))])
|
||||
async def get_system_login_log_list(request: Request, login_log_page_query: LoginLogPageQueryModel = Depends(LoginLogPageQueryModel.as_query), query_db: Session = Depends(get_db)):
|
||||
try:
|
||||
login_log_query = LoginLogQueryModel(**login_log_page_query.model_dump(by_alias=True))
|
||||
# 获取全量数据
|
||||
login_log_query_result = LoginLogService.get_login_log_list_services(query_db, login_log_query)
|
||||
# 分页操作
|
||||
login_log_page_query_result = get_page_obj(login_log_query_result, login_log_page_query.page_num, login_log_page_query.page_size)
|
||||
logger.info('获取成功')
|
||||
return ResponseUtil.success(model_content=login_log_page_query_result)
|
||||
except Exception as e:
|
||||
logger.exception(e)
|
||||
return ResponseUtil.error(msg=str(e))
|
||||
|
||||
|
||||
@logController.delete("/logininfor/clean", dependencies=[Depends(CheckUserInterfaceAuth('monitor:logininfor:remove'))])
|
||||
@log_decorator(title='登录日志管理', business_type=9)
|
||||
async def clear_system_login_log(request: Request, query_db: Session = Depends(get_db)):
|
||||
try:
|
||||
clear_login_log_result = LoginLogService.clear_login_log_services(query_db)
|
||||
if clear_login_log_result.is_success:
|
||||
logger.info(clear_login_log_result.message)
|
||||
return ResponseUtil.success(msg=clear_login_log_result.message)
|
||||
else:
|
||||
logger.warning(clear_login_log_result.message)
|
||||
return ResponseUtil.failure(msg=clear_login_log_result.message)
|
||||
except Exception as e:
|
||||
logger.exception(e)
|
||||
return ResponseUtil.error(msg=str(e))
|
||||
|
||||
|
||||
@logController.delete("/logininfor/{info_ids}", dependencies=[Depends(CheckUserInterfaceAuth('monitor:logininfor:remove'))])
|
||||
@log_decorator(title='登录日志管理', business_type=3)
|
||||
async def delete_system_login_log(request: Request, info_ids: str, query_db: Session = Depends(get_db)):
|
||||
try:
|
||||
delete_login_log = DeleteLoginLogModel(infoIds=info_ids)
|
||||
delete_login_log_result = LoginLogService.delete_login_log_services(query_db, delete_login_log)
|
||||
if delete_login_log_result.is_success:
|
||||
logger.info(delete_login_log_result.message)
|
||||
return ResponseUtil.success(msg=delete_login_log_result.message)
|
||||
else:
|
||||
logger.warning(delete_login_log_result.message)
|
||||
return ResponseUtil.failure(msg=delete_login_log_result.message)
|
||||
except Exception as e:
|
||||
logger.exception(e)
|
||||
return ResponseUtil.error(msg=str(e))
|
||||
|
||||
|
||||
@logController.get("/logininfor/unlock/{user_name}", dependencies=[Depends(CheckUserInterfaceAuth('monitor:logininfor:unlock'))])
|
||||
@log_decorator(title='登录日志管理', business_type=0)
|
||||
async def clear_system_login_log(request: Request, user_name: str, query_db: Session = Depends(get_db)):
|
||||
try:
|
||||
unlock_user = UnlockUser(userName=user_name)
|
||||
unlock_user_result = await LoginLogService.unlock_user_services(request, unlock_user)
|
||||
if unlock_user_result.is_success:
|
||||
logger.info(unlock_user_result.message)
|
||||
return ResponseUtil.success(msg=unlock_user_result.message)
|
||||
else:
|
||||
logger.warning(unlock_user_result.message)
|
||||
return ResponseUtil.failure(msg=unlock_user_result.message)
|
||||
except Exception as e:
|
||||
logger.exception(e)
|
||||
return ResponseUtil.error(msg=str(e))
|
||||
|
||||
|
||||
@logController.post("/logininfor/export", dependencies=[Depends(CheckUserInterfaceAuth('monitor:logininfor:export'))])
|
||||
@log_decorator(title='登录日志管理', business_type=5)
|
||||
async def export_system_login_log_list(request: Request, login_log_page_query: LoginLogPageQueryModel = Depends(LoginLogPageQueryModel.as_form), query_db: Session = Depends(get_db)):
|
||||
try:
|
||||
login_log_query = LoginLogQueryModel(**login_log_page_query.model_dump(by_alias=True))
|
||||
# 获取全量数据
|
||||
login_log_query_result = LoginLogService.get_login_log_list_services(query_db, login_log_query)
|
||||
login_log_export_result = LoginLogService.export_login_log_list_services(login_log_query_result)
|
||||
logger.info('导出成功')
|
||||
return ResponseUtil.streaming(data=bytes2file_response(login_log_export_result))
|
||||
except Exception as e:
|
||||
logger.exception(e)
|
||||
return ResponseUtil.error(msg=str(e))
|
||||
@@ -0,0 +1,125 @@
|
||||
from fastapi import APIRouter
|
||||
from module_admin.service.login_service import *
|
||||
from module_admin.entity.vo.login_vo import *
|
||||
from module_admin.dao.login_dao import *
|
||||
from config.env import JwtConfig, RedisInitKeyConfig
|
||||
from utils.response_util import *
|
||||
from utils.log_util import *
|
||||
from module_admin.annotation.log_annotation import log_decorator
|
||||
from datetime import timedelta
|
||||
|
||||
|
||||
loginController = APIRouter()
|
||||
|
||||
|
||||
@loginController.post("/login", response_model=Token)
|
||||
@log_decorator(title='用户登录', business_type=0, log_type='login')
|
||||
async def login(request: Request, form_data: CustomOAuth2PasswordRequestForm = Depends(), query_db: Session = Depends(get_db)):
|
||||
captcha_enabled = True if await request.app.state.redis.get(f"{RedisInitKeyConfig.SYS_CONFIG.get('key')}:sys.account.captchaEnabled") == 'true' else False
|
||||
user = UserLogin(
|
||||
userName=form_data.username,
|
||||
password=form_data.password,
|
||||
code=form_data.code,
|
||||
uuid=form_data.uuid,
|
||||
loginInfo=form_data.login_info,
|
||||
captchaEnabled=captcha_enabled
|
||||
)
|
||||
try:
|
||||
result = await LoginService.authenticate_user(request, query_db, user)
|
||||
except LoginException as e:
|
||||
return ResponseUtil.failure(msg=e.message)
|
||||
try:
|
||||
access_token_expires = timedelta(minutes=JwtConfig.ACCESS_TOKEN_EXPIRE_MINUTES)
|
||||
session_id = str(uuid.uuid4())
|
||||
access_token = LoginService.create_access_token(
|
||||
data={
|
||||
"user_id": str(result[0].user_id),
|
||||
"user_name": result[0].user_name,
|
||||
"dept_name": result[1].dept_name if result[1] else None,
|
||||
"session_id": session_id,
|
||||
"login_info": user.login_info
|
||||
},
|
||||
expires_delta=access_token_expires
|
||||
)
|
||||
await request.app.state.redis.set(f"{RedisInitKeyConfig.ACCESS_TOKEN.get('key')}:{session_id}", access_token,
|
||||
ex=timedelta(minutes=JwtConfig.REDIS_TOKEN_EXPIRE_MINUTES))
|
||||
# 此方法可实现同一账号同一时间只能登录一次
|
||||
# await request.app.state.redis.set(f"{RedisInitKeyConfig.ACCESS_TOKEN.get('key')}:{result[0].user_id}", access_token,
|
||||
# ex=timedelta(minutes=JwtConfig.REDIS_TOKEN_EXPIRE_MINUTES))
|
||||
logger.info('登录成功')
|
||||
# 判断请求是否来自于api文档，如果是返回指定格式的结果，用于修复api文档认证成功后token显示undefined的bug
|
||||
request_from_swagger = request.headers.get('referer').endswith('docs') if request.headers.get('referer') else False
|
||||
request_from_redoc = request.headers.get('referer').endswith('redoc') if request.headers.get('referer') else False
|
||||
if request_from_swagger or request_from_redoc:
|
||||
return {'access_token': access_token, 'token_type': 'Bearer'}
|
||||
return ResponseUtil.success(
|
||||
msg='登录成功',
|
||||
dict_content={'token': access_token}
|
||||
)
|
||||
except Exception as e:
|
||||
logger.exception(e)
|
||||
return ResponseUtil.error(msg=str(e))
|
||||
|
||||
|
||||
@loginController.get("/getInfo", response_model=CurrentUserModel)
|
||||
async def get_login_user_info(request: Request, current_user: CurrentUserModel = Depends(LoginService.get_current_user)):
|
||||
try:
|
||||
logger.info('获取成功')
|
||||
return ResponseUtil.success(model_content=current_user)
|
||||
except Exception as e:
|
||||
logger.exception(e)
|
||||
return ResponseUtil.error(msg=str(e))
|
||||
|
||||
|
||||
@loginController.get("/getRouters")
|
||||
async def get_login_user_routers(request: Request, current_user: CurrentUserModel = Depends(LoginService.get_current_user), query_db: Session = Depends(get_db)):
|
||||
try:
|
||||
logger.info('获取成功')
|
||||
user_routers = await LoginService.get_current_user_routers(current_user.user.user_id, query_db)
|
||||
return ResponseUtil.success(data=user_routers)
|
||||
except Exception as e:
|
||||
logger.exception(e)
|
||||
return ResponseUtil.error(msg=str(e))
|
||||
|
||||
|
||||
@loginController.post("/getSmsCode", response_model=SmsCode)
|
||||
async def get_sms_code(request: Request, user: ResetUserModel, query_db: Session = Depends(get_db)):
|
||||
try:
|
||||
sms_result = await get_sms_code_services(request, query_db, user)
|
||||
if sms_result.is_success:
|
||||
logger.info('获取成功')
|
||||
return response_200(data=sms_result, message='获取成功')
|
||||
else:
|
||||
logger.warning(sms_result.message)
|
||||
return response_400(data='', message=sms_result.message)
|
||||
except Exception as e:
|
||||
logger.exception(e)
|
||||
return response_500(data="", message=str(e))
|
||||
|
||||
|
||||
@loginController.post("/forgetPwd", response_model=CrudResponseModel)
|
||||
async def forget_user_pwd(request: Request, forget_user: ResetUserModel, query_db: Session = Depends(get_db)):
|
||||
try:
|
||||
forget_user_result = await forget_user_services(request, query_db, forget_user)
|
||||
if forget_user_result.is_success:
|
||||
logger.info(forget_user_result.message)
|
||||
return response_200(data=forget_user_result, message=forget_user_result.message)
|
||||
else:
|
||||
logger.warning(forget_user_result.message)
|
||||
return response_400(data="", message=forget_user_result.message)
|
||||
except Exception as e:
|
||||
logger.exception(e)
|
||||
return response_500(data="", message=str(e))
|
||||
|
||||
|
||||
@loginController.post("/logout")
|
||||
async def logout(request: Request, token: Optional[str] = Depends(oauth2_scheme)):
|
||||
try:
|
||||
payload = jwt.decode(token, JwtConfig.SECRET_KEY, algorithms=[JwtConfig.ALGORITHM])
|
||||
session_id: str = payload.get("session_id")
|
||||
await logout_services(request, session_id)
|
||||
logger.info('退出成功')
|
||||
return ResponseUtil.success(msg="退出成功")
|
||||
except Exception as e:
|
||||
logger.exception(e)
|
||||
return ResponseUtil.error(msg=str(e))
|
||||
109
ruoyi-fastapi-backend/module_admin/controller/menu_controller.py
Normal file
109
ruoyi-fastapi-backend/module_admin/controller/menu_controller.py
Normal file
@@ -0,0 +1,109 @@
|
||||
from fastapi import APIRouter, Request
|
||||
from fastapi import Depends
|
||||
from config.get_db import get_db
|
||||
from module_admin.service.login_service import LoginService
|
||||
from module_admin.service.menu_service import *
|
||||
from utils.response_util import *
|
||||
from utils.log_util import *
|
||||
from module_admin.aspect.interface_auth import CheckUserInterfaceAuth
|
||||
from module_admin.annotation.log_annotation import log_decorator
|
||||
|
||||
|
||||
menuController = APIRouter(prefix='/system/menu', dependencies=[Depends(LoginService.get_current_user)])
|
||||
|
||||
|
||||
@menuController.get("/treeselect", dependencies=[Depends(CheckUserInterfaceAuth('common'))])
|
||||
async def get_system_menu_tree(request: Request, query_db: Session = Depends(get_db), current_user: CurrentUserModel = Depends(LoginService.get_current_user)):
|
||||
try:
|
||||
menu_query_result = MenuService.get_menu_tree_services(query_db, current_user)
|
||||
logger.info('获取成功')
|
||||
return ResponseUtil.success(data=menu_query_result)
|
||||
except Exception as e:
|
||||
logger.exception(e)
|
||||
return ResponseUtil.error(msg=str(e))
|
||||
|
||||
|
||||
@menuController.get("/roleMenuTreeselect/{role_id}", dependencies=[Depends(CheckUserInterfaceAuth('common'))])
|
||||
async def get_system_role_menu_tree(request: Request, role_id: int, query_db: Session = Depends(get_db), current_user: CurrentUserModel = Depends(LoginService.get_current_user)):
|
||||
try:
|
||||
role_menu_query_result = MenuService.get_role_menu_tree_services(query_db, role_id, current_user)
|
||||
logger.info('获取成功')
|
||||
return ResponseUtil.success(model_content=role_menu_query_result)
|
||||
except Exception as e:
|
||||
logger.exception(e)
|
||||
return ResponseUtil.error(msg=str(e))
|
||||
|
||||
|
||||
@menuController.get("/list", response_model=List[MenuModel], dependencies=[Depends(CheckUserInterfaceAuth('system:menu:list'))])
|
||||
async def get_system_menu_list(request: Request, menu_query: MenuQueryModel = Depends(MenuQueryModel.as_query), query_db: Session = Depends(get_db), current_user: CurrentUserModel = Depends(LoginService.get_current_user)):
|
||||
try:
|
||||
menu_query_result = MenuService.get_menu_list_services(query_db, menu_query, current_user)
|
||||
logger.info('获取成功')
|
||||
return ResponseUtil.success(data=menu_query_result)
|
||||
except Exception as e:
|
||||
logger.exception(e)
|
||||
return ResponseUtil.error(msg=str(e))
|
||||
|
||||
|
||||
@menuController.post("", dependencies=[Depends(CheckUserInterfaceAuth('system:menu:add'))])
|
||||
@log_decorator(title='菜单管理', business_type=1)
|
||||
async def add_system_menu(request: Request, add_menu: MenuModel, query_db: Session = Depends(get_db), current_user: CurrentUserModel = Depends(LoginService.get_current_user)):
|
||||
try:
|
||||
add_menu.create_by = current_user.user.user_name
|
||||
add_menu.update_by = current_user.user.user_name
|
||||
add_menu_result = MenuService.add_menu_services(query_db, add_menu)
|
||||
if add_menu_result.is_success:
|
||||
logger.info(add_menu_result.message)
|
||||
return ResponseUtil.success(msg=add_menu_result.message)
|
||||
else:
|
||||
logger.warning(add_menu_result.message)
|
||||
return ResponseUtil.failure(msg=add_menu_result.message)
|
||||
except Exception as e:
|
||||
logger.exception(e)
|
||||
return ResponseUtil.error(msg=str(e))
|
||||
|
||||
|
||||
@menuController.put("", dependencies=[Depends(CheckUserInterfaceAuth('system:menu:edit'))])
|
||||
@log_decorator(title='菜单管理', business_type=2)
|
||||
async def edit_system_menu(request: Request, edit_menu: MenuModel, query_db: Session = Depends(get_db), current_user: CurrentUserModel = Depends(LoginService.get_current_user)):
|
||||
try:
|
||||
edit_menu.update_by = current_user.user.user_name
|
||||
edit_menu.update_time = datetime.now()
|
||||
edit_menu_result = MenuService.edit_menu_services(query_db, edit_menu)
|
||||
if edit_menu_result.is_success:
|
||||
logger.info(edit_menu_result.message)
|
||||
return ResponseUtil.success(msg=edit_menu_result.message)
|
||||
else:
|
||||
logger.warning(edit_menu_result.message)
|
||||
return ResponseUtil.failure(msg=edit_menu_result.message)
|
||||
except Exception as e:
|
||||
logger.exception(e)
|
||||
return ResponseUtil.error(msg=str(e))
|
||||
|
||||
|
||||
@menuController.delete("/{menu_ids}", dependencies=[Depends(CheckUserInterfaceAuth('system:menu:remove'))])
|
||||
@log_decorator(title='菜单管理', business_type=3)
|
||||
async def delete_system_menu(request: Request, menu_ids: str, query_db: Session = Depends(get_db)):
|
||||
try:
|
||||
delete_menu = DeleteMenuModel(menuIds=menu_ids)
|
||||
delete_menu_result = MenuService.delete_menu_services(query_db, delete_menu)
|
||||
if delete_menu_result.is_success:
|
||||
logger.info(delete_menu_result.message)
|
||||
return ResponseUtil.success(msg=delete_menu_result.message)
|
||||
else:
|
||||
logger.warning(delete_menu_result.message)
|
||||
return ResponseUtil.failure(msg=delete_menu_result.message)
|
||||
except Exception as e:
|
||||
logger.exception(e)
|
||||
return ResponseUtil.error(msg=str(e))
|
||||
|
||||
|
||||
@menuController.get("/{menu_id}", response_model=MenuModel, dependencies=[Depends(CheckUserInterfaceAuth('system:menu:query'))])
|
||||
async def query_detail_system_menu(request: Request, menu_id: int, query_db: Session = Depends(get_db)):
|
||||
try:
|
||||
menu_detail_result = MenuService.menu_detail_services(query_db, menu_id)
|
||||
logger.info(f'获取menu_id为{menu_id}的信息成功')
|
||||
return ResponseUtil.success(data=menu_detail_result)
|
||||
except Exception as e:
|
||||
logger.exception(e)
|
||||
return ResponseUtil.error(msg=str(e))
|
||||
@@ -0,0 +1,92 @@
|
||||
from fastapi import APIRouter, Request
|
||||
from fastapi import Depends
|
||||
from config.get_db import get_db
|
||||
from module_admin.service.login_service import LoginService, CurrentUserModel
|
||||
from module_admin.service.notice_service import *
|
||||
from utils.response_util import *
|
||||
from utils.log_util import *
|
||||
from utils.page_util import *
|
||||
from module_admin.aspect.interface_auth import CheckUserInterfaceAuth
|
||||
from module_admin.annotation.log_annotation import log_decorator
|
||||
|
||||
|
||||
noticeController = APIRouter(prefix='/system/notice', dependencies=[Depends(LoginService.get_current_user)])
|
||||
|
||||
|
||||
@noticeController.get("/list", response_model=PageResponseModel, dependencies=[Depends(CheckUserInterfaceAuth('system:notice:list'))])
|
||||
async def get_system_notice_list(request: Request, notice_page_query: NoticePageQueryModel = Depends(NoticePageQueryModel.as_query), query_db: Session = Depends(get_db)):
|
||||
try:
|
||||
notice_query = NoticeQueryModel(**notice_page_query.model_dump(by_alias=True))
|
||||
# 获取全量数据
|
||||
notice_query_result = NoticeService.get_notice_list_services(query_db, notice_query)
|
||||
# 分页操作
|
||||
notice_page_query_result = get_page_obj(notice_query_result, notice_page_query.page_num, notice_page_query.page_size)
|
||||
logger.info('获取成功')
|
||||
return ResponseUtil.success(model_content=notice_page_query_result)
|
||||
except Exception as e:
|
||||
logger.exception(e)
|
||||
return ResponseUtil.error(msg=str(e))
|
||||
|
||||
|
||||
@noticeController.post("", dependencies=[Depends(CheckUserInterfaceAuth('system:notice:add'))])
|
||||
@log_decorator(title='通知公告管理', business_type=1)
|
||||
async def add_system_notice(request: Request, add_notice: NoticeModel, query_db: Session = Depends(get_db), current_user: CurrentUserModel = Depends(LoginService.get_current_user)):
|
||||
try:
|
||||
add_notice.create_by = current_user.user.user_name
|
||||
add_notice.update_by = current_user.user.user_name
|
||||
add_notice_result = NoticeService.add_notice_services(query_db, add_notice)
|
||||
if add_notice_result.is_success:
|
||||
logger.info(add_notice_result.message)
|
||||
return ResponseUtil.success(msg=add_notice_result.message)
|
||||
else:
|
||||
logger.warning(add_notice_result.message)
|
||||
return ResponseUtil.failure(msg=add_notice_result.message)
|
||||
except Exception as e:
|
||||
logger.exception(e)
|
||||
return ResponseUtil.error(msg=str(e))
|
||||
|
||||
|
||||
@noticeController.put("", dependencies=[Depends(CheckUserInterfaceAuth('system:notice:edit'))])
|
||||
@log_decorator(title='通知公告管理', business_type=2)
|
||||
async def edit_system_notice(request: Request, edit_notice: NoticeModel, query_db: Session = Depends(get_db), current_user: CurrentUserModel = Depends(LoginService.get_current_user)):
|
||||
try:
|
||||
edit_notice.update_by = current_user.user.user_name
|
||||
edit_notice.update_time = datetime.now()
|
||||
edit_notice_result = NoticeService.edit_notice_services(query_db, edit_notice)
|
||||
if edit_notice_result.is_success:
|
||||
logger.info(edit_notice_result.message)
|
||||
return ResponseUtil.success(msg=edit_notice_result.message)
|
||||
else:
|
||||
logger.warning(edit_notice_result.message)
|
||||
return ResponseUtil.failure(msg=edit_notice_result.message)
|
||||
except Exception as e:
|
||||
logger.exception(e)
|
||||
return ResponseUtil.error(msg=str(e))
|
||||
|
||||
|
||||
@noticeController.delete("/{notice_ids}", dependencies=[Depends(CheckUserInterfaceAuth('system:notice:remove'))])
|
||||
@log_decorator(title='通知公告管理', business_type=3)
|
||||
async def delete_system_notice(request: Request, notice_ids: str, query_db: Session = Depends(get_db)):
|
||||
try:
|
||||
delete_notice = DeleteNoticeModel(noticeIds=notice_ids)
|
||||
delete_notice_result = NoticeService.delete_notice_services(query_db, delete_notice)
|
||||
if delete_notice_result.is_success:
|
||||
logger.info(delete_notice_result.message)
|
||||
return ResponseUtil.success(msg=delete_notice_result.message)
|
||||
else:
|
||||
logger.warning(delete_notice_result.message)
|
||||
return ResponseUtil.failure(msg=delete_notice_result.message)
|
||||
except Exception as e:
|
||||
logger.exception(e)
|
||||
return ResponseUtil.error(msg=str(e))
|
||||
|
||||
|
||||
@noticeController.get("/{notice_id}", response_model=NoticeModel, dependencies=[Depends(CheckUserInterfaceAuth('system:notice:query'))])
|
||||
async def query_detail_system_post(request: Request, notice_id: int, query_db: Session = Depends(get_db)):
|
||||
try:
|
||||
notice_detail_result = NoticeService.notice_detail_services(query_db, notice_id)
|
||||
logger.info(f'获取notice_id为{notice_id}的信息成功')
|
||||
return ResponseUtil.success(data=notice_detail_result)
|
||||
except Exception as e:
|
||||
logger.exception(e)
|
||||
return ResponseUtil.error(msg=str(e))
|
||||
@@ -0,0 +1,42 @@
|
||||
from fastapi import APIRouter
|
||||
from fastapi import Depends
|
||||
from config.get_db import get_db
|
||||
from module_admin.service.login_service import LoginService, Session
|
||||
from module_admin.service.online_service import *
|
||||
from utils.response_util import *
|
||||
from utils.log_util import *
|
||||
from utils.page_util import *
|
||||
from module_admin.aspect.interface_auth import CheckUserInterfaceAuth
|
||||
from module_admin.annotation.log_annotation import log_decorator
|
||||
|
||||
|
||||
onlineController = APIRouter(prefix='/monitor/online', dependencies=[Depends(LoginService.get_current_user)])
|
||||
|
||||
|
||||
@onlineController.get("/list", response_model=PageResponseModel, dependencies=[Depends(CheckUserInterfaceAuth('monitor:online:list'))])
|
||||
async def get_monitor_online_list(request: Request, online_page_query: OnlineQueryModel = Depends(OnlineQueryModel.as_query)):
|
||||
try:
|
||||
# 获取全量数据
|
||||
online_query_result = await OnlineService.get_online_list_services(request, online_page_query)
|
||||
logger.info('获取成功')
|
||||
return ResponseUtil.success(model_content=PageResponseModel(rows=online_query_result, total=len(online_query_result)))
|
||||
except Exception as e:
|
||||
logger.exception(e)
|
||||
return ResponseUtil.error(msg=str(e))
|
||||
|
||||
|
||||
@onlineController.delete("/{token_ids}", dependencies=[Depends(CheckUserInterfaceAuth('monitor:online:forceLogout'))])
|
||||
@log_decorator(title='在线用户', business_type=7)
|
||||
async def delete_monitor_online(request: Request, token_ids: str, query_db: Session = Depends(get_db)):
|
||||
try:
|
||||
delete_online = DeleteOnlineModel(tokenIds=token_ids)
|
||||
delete_online_result = await OnlineService.delete_online_services(request, delete_online)
|
||||
if delete_online_result.is_success:
|
||||
logger.info(delete_online_result.message)
|
||||
return ResponseUtil.success(msg=delete_online_result.message)
|
||||
else:
|
||||
logger.warning(delete_online_result.message)
|
||||
return ResponseUtil.failure(msg=delete_online_result.message)
|
||||
except Exception as e:
|
||||
logger.exception(e)
|
||||
return ResponseUtil.error(msg=str(e))
|
||||
109
ruoyi-fastapi-backend/module_admin/controller/post_controler.py
Normal file
109
ruoyi-fastapi-backend/module_admin/controller/post_controler.py
Normal file
@@ -0,0 +1,109 @@
|
||||
from fastapi import APIRouter, Request
|
||||
from fastapi import Depends
|
||||
from config.get_db import get_db
|
||||
from module_admin.service.login_service import LoginService, CurrentUserModel
|
||||
from module_admin.service.post_service import *
|
||||
from module_admin.entity.vo.post_vo import *
|
||||
from utils.response_util import *
|
||||
from utils.log_util import *
|
||||
from utils.page_util import *
|
||||
from utils.common_util import bytes2file_response
|
||||
from module_admin.aspect.interface_auth import CheckUserInterfaceAuth
|
||||
from module_admin.annotation.log_annotation import log_decorator
|
||||
|
||||
|
||||
postController = APIRouter(prefix='/system/post', dependencies=[Depends(LoginService.get_current_user)])
|
||||
|
||||
|
||||
@postController.get("/list", response_model=PageResponseModel, dependencies=[Depends(CheckUserInterfaceAuth('system:post:list'))])
|
||||
async def get_system_post_list(request: Request, post_page_query: PostPageQueryModel = Depends(PostPageQueryModel.as_query), query_db: Session = Depends(get_db)):
|
||||
try:
|
||||
post_query = PostModel(**post_page_query.model_dump(by_alias=True))
|
||||
# 获取全量数据
|
||||
post_query_result = PostService.get_post_list_services(query_db, post_query)
|
||||
# 分页操作
|
||||
post_page_query_result = get_page_obj(post_query_result, post_page_query.page_num, post_page_query.page_size)
|
||||
logger.info('获取成功')
|
||||
return ResponseUtil.success(model_content=post_page_query_result)
|
||||
except Exception as e:
|
||||
logger.exception(e)
|
||||
return ResponseUtil.error(msg=str(e))
|
||||
|
||||
|
||||
@postController.post("", dependencies=[Depends(CheckUserInterfaceAuth('system:post:add'))])
|
||||
@log_decorator(title='岗位管理', business_type=1)
|
||||
async def add_system_post(request: Request, add_post: PostModel, query_db: Session = Depends(get_db), current_user: CurrentUserModel = Depends(LoginService.get_current_user)):
|
||||
try:
|
||||
add_post.create_by = current_user.user.user_name
|
||||
add_post.update_by = current_user.user.user_name
|
||||
add_post_result = PostService.add_post_services(query_db, add_post)
|
||||
if add_post_result.is_success:
|
||||
logger.info(add_post_result.message)
|
||||
return ResponseUtil.success(msg=add_post_result.message)
|
||||
else:
|
||||
logger.warning(add_post_result.message)
|
||||
return ResponseUtil.failure(msg=add_post_result.message)
|
||||
except Exception as e:
|
||||
logger.exception(e)
|
||||
return ResponseUtil.error(msg=str(e))
|
||||
|
||||
|
||||
@postController.put("", dependencies=[Depends(CheckUserInterfaceAuth('system:post:edit'))])
|
||||
@log_decorator(title='岗位管理', business_type=2)
|
||||
async def edit_system_post(request: Request, edit_post: PostModel, query_db: Session = Depends(get_db), current_user: CurrentUserModel = Depends(LoginService.get_current_user)):
|
||||
try:
|
||||
edit_post.update_by = current_user.user.user_name
|
||||
edit_post.update_time = datetime.now()
|
||||
edit_post_result = PostService.edit_post_services(query_db, edit_post)
|
||||
if edit_post_result.is_success:
|
||||
logger.info(edit_post_result.message)
|
||||
return ResponseUtil.success(msg=edit_post_result.message)
|
||||
else:
|
||||
logger.warning(edit_post_result.message)
|
||||
return ResponseUtil.failure(msg=edit_post_result.message)
|
||||
except Exception as e:
|
||||
logger.exception(e)
|
||||
return ResponseUtil.error(msg=str(e))
|
||||
|
||||
|
||||
@postController.delete("/{post_ids}", dependencies=[Depends(CheckUserInterfaceAuth('system:post:remove'))])
|
||||
@log_decorator(title='岗位管理', business_type=3)
|
||||
async def delete_system_post(request: Request, post_ids: str, query_db: Session = Depends(get_db)):
|
||||
try:
|
||||
delete_post = DeletePostModel(postIds=post_ids)
|
||||
delete_post_result = PostService.delete_post_services(query_db, delete_post)
|
||||
if delete_post_result.is_success:
|
||||
logger.info(delete_post_result.message)
|
||||
return ResponseUtil.success(msg=delete_post_result.message)
|
||||
else:
|
||||
logger.warning(delete_post_result.message)
|
||||
return ResponseUtil.failure(msg=delete_post_result.message)
|
||||
except Exception as e:
|
||||
logger.exception(e)
|
||||
return ResponseUtil.error(msg=str(e))
|
||||
|
||||
|
||||
@postController.get("/{post_id}", response_model=PostModel, dependencies=[Depends(CheckUserInterfaceAuth('system:post:query'))])
|
||||
async def query_detail_system_post(request: Request, post_id: int, query_db: Session = Depends(get_db)):
|
||||
try:
|
||||
post_detail_result = PostService.post_detail_services(query_db, post_id)
|
||||
logger.info(f'获取post_id为{post_id}的信息成功')
|
||||
return ResponseUtil.success(data=post_detail_result)
|
||||
except Exception as e:
|
||||
logger.exception(e)
|
||||
return ResponseUtil.error(msg=str(e))
|
||||
|
||||
|
||||
@postController.post("/export", dependencies=[Depends(CheckUserInterfaceAuth('system:post:export'))])
|
||||
@log_decorator(title='岗位管理', business_type=5)
|
||||
async def export_system_post_list(request: Request, post_page_query: PostPageQueryModel = Depends(PostPageQueryModel.as_form), query_db: Session = Depends(get_db)):
|
||||
try:
|
||||
post_query = PostModel(**post_page_query.model_dump(by_alias=True))
|
||||
# 获取全量数据
|
||||
post_query_result = PostService.get_post_list_services(query_db, post_query)
|
||||
post_export_result = PostService.export_post_list_services(post_query_result)
|
||||
logger.info('导出成功')
|
||||
return ResponseUtil.streaming(data=bytes2file_response(post_export_result))
|
||||
except Exception as e:
|
||||
logger.exception(e)
|
||||
return ResponseUtil.error(msg=str(e))
|
||||
240
ruoyi-fastapi-backend/module_admin/controller/role_controller.py
Normal file
240
ruoyi-fastapi-backend/module_admin/controller/role_controller.py
Normal file
@@ -0,0 +1,240 @@
|
||||
from fastapi import APIRouter, Request
|
||||
from fastapi import Depends
|
||||
from config.get_db import get_db
|
||||
from module_admin.service.login_service import LoginService, CurrentUserModel
|
||||
from module_admin.service.role_service import *
|
||||
from module_admin.service.dept_service import DeptService, DeptModel
|
||||
from module_admin.service.user_service import UserService, UserRoleQueryModel, UserRolePageQueryModel, CrudUserRoleModel
|
||||
from utils.response_util import *
|
||||
from utils.log_util import *
|
||||
from utils.page_util import *
|
||||
from utils.common_util import bytes2file_response
|
||||
from module_admin.aspect.interface_auth import CheckUserInterfaceAuth
|
||||
from module_admin.aspect.data_scope import GetDataScope
|
||||
from module_admin.annotation.log_annotation import log_decorator
|
||||
|
||||
|
||||
roleController = APIRouter(prefix='/system/role', dependencies=[Depends(LoginService.get_current_user)])
|
||||
|
||||
|
||||
@roleController.get("/deptTree/{role_id}", dependencies=[Depends(CheckUserInterfaceAuth('common'))])
|
||||
async def get_system_role_dept_tree(request: Request, role_id: int, query_db: Session = Depends(get_db), data_scope_sql: str = Depends(GetDataScope('SysDept'))):
|
||||
try:
|
||||
dept_query_result = DeptService.get_dept_tree_services(query_db, DeptModel(**{}), data_scope_sql)
|
||||
role_dept_query_result = RoleService.get_role_dept_tree_services(query_db, role_id)
|
||||
role_dept_query_result.depts = dept_query_result
|
||||
logger.info('获取成功')
|
||||
return ResponseUtil.success(model_content=role_dept_query_result)
|
||||
except Exception as e:
|
||||
logger.exception(e)
|
||||
return ResponseUtil.error(msg=str(e))
|
||||
|
||||
|
||||
@roleController.get("/list", response_model=PageResponseModel, dependencies=[Depends(CheckUserInterfaceAuth('system:role:list'))])
|
||||
async def get_system_role_list(request: Request, role_page_query: RolePageQueryModel = Depends(RolePageQueryModel.as_query), query_db: Session = Depends(get_db)):
|
||||
try:
|
||||
role_query = RoleQueryModel(**role_page_query.model_dump(by_alias=True))
|
||||
role_query_result = RoleService.get_role_list_services(query_db, role_query)
|
||||
# 分页操作
|
||||
role_page_query_result = get_page_obj(role_query_result, role_page_query.page_num, role_page_query.page_size)
|
||||
logger.info('获取成功')
|
||||
return ResponseUtil.success(model_content=role_page_query_result)
|
||||
except Exception as e:
|
||||
logger.exception(e)
|
||||
return ResponseUtil.error(msg=str(e))
|
||||
|
||||
|
||||
@roleController.post("", dependencies=[Depends(CheckUserInterfaceAuth('system:role:add'))])
|
||||
@log_decorator(title='角色管理', business_type=1)
|
||||
async def add_system_role(request: Request, add_role: AddRoleModel, query_db: Session = Depends(get_db), current_user: CurrentUserModel = Depends(LoginService.get_current_user)):
|
||||
try:
|
||||
add_role.create_by = current_user.user.user_name
|
||||
add_role.update_by = current_user.user.user_name
|
||||
add_role_result = RoleService.add_role_services(query_db, add_role)
|
||||
if add_role_result.is_success:
|
||||
logger.info(add_role_result.message)
|
||||
return ResponseUtil.success(msg=add_role_result.message)
|
||||
else:
|
||||
logger.warning(add_role_result.message)
|
||||
return ResponseUtil.failure(msg=add_role_result.message)
|
||||
except Exception as e:
|
||||
logger.exception(e)
|
||||
return ResponseUtil.error(msg=str(e))
|
||||
|
||||
|
||||
@roleController.put("", dependencies=[Depends(CheckUserInterfaceAuth('system:role:edit'))])
|
||||
@log_decorator(title='角色管理', business_type=2)
|
||||
async def edit_system_role(request: Request, edit_role: AddRoleModel, query_db: Session = Depends(get_db), current_user: CurrentUserModel = Depends(LoginService.get_current_user)):
|
||||
try:
|
||||
edit_role.update_by = current_user.user.user_name
|
||||
edit_role.update_time = datetime.now()
|
||||
edit_role_result = RoleService.edit_role_services(query_db, edit_role)
|
||||
if edit_role_result.is_success:
|
||||
logger.info(edit_role_result.message)
|
||||
return ResponseUtil.success(msg=edit_role_result.message)
|
||||
else:
|
||||
logger.warning(edit_role_result.message)
|
||||
return ResponseUtil.failure(msg=edit_role_result.message)
|
||||
except Exception as e:
|
||||
logger.exception(e)
|
||||
return ResponseUtil.error(msg=str(e))
|
||||
|
||||
|
||||
@roleController.put("/dataScope", dependencies=[Depends(CheckUserInterfaceAuth('system:role:edit'))])
|
||||
@log_decorator(title='角色管理', business_type=4)
|
||||
async def edit_system_role_datascope(request: Request, role_data_scope: AddRoleModel, query_db: Session = Depends(get_db), current_user: CurrentUserModel = Depends(LoginService.get_current_user)):
|
||||
try:
|
||||
role_data_scope.update_by = current_user.user.user_name
|
||||
role_data_scope.update_time = datetime.now()
|
||||
role_data_scope_result = RoleService.role_datascope_services(query_db, role_data_scope)
|
||||
if role_data_scope_result.is_success:
|
||||
logger.info(role_data_scope_result.message)
|
||||
return ResponseUtil.success(msg=role_data_scope_result.message)
|
||||
else:
|
||||
logger.warning(role_data_scope_result.message)
|
||||
return ResponseUtil.failure(msg=role_data_scope_result.message)
|
||||
except Exception as e:
|
||||
logger.exception(e)
|
||||
return ResponseUtil.error(msg=str(e))
|
||||
|
||||
|
||||
@roleController.delete("/{role_ids}", dependencies=[Depends(CheckUserInterfaceAuth('system:role:remove'))])
|
||||
@log_decorator(title='角色管理', business_type=3)
|
||||
async def delete_system_role(request: Request, role_ids: str, query_db: Session = Depends(get_db), current_user: CurrentUserModel = Depends(LoginService.get_current_user)):
|
||||
try:
|
||||
delete_role = DeleteRoleModel(
|
||||
roleIds=role_ids,
|
||||
updateBy=current_user.user.user_name,
|
||||
updateTime=datetime.now()
|
||||
)
|
||||
delete_role_result = RoleService.delete_role_services(query_db, delete_role)
|
||||
if delete_role_result.is_success:
|
||||
logger.info(delete_role_result.message)
|
||||
return ResponseUtil.success(msg=delete_role_result.message)
|
||||
else:
|
||||
logger.warning(delete_role_result.message)
|
||||
return ResponseUtil.failure(msg=delete_role_result.message)
|
||||
except Exception as e:
|
||||
logger.exception(e)
|
||||
return ResponseUtil.error(msg=str(e))
|
||||
|
||||
|
||||
@roleController.get("/{role_id}", response_model=RoleModel, dependencies=[Depends(CheckUserInterfaceAuth('system:role:query'))])
|
||||
async def query_detail_system_role(request: Request, role_id: int, query_db: Session = Depends(get_db)):
|
||||
try:
|
||||
role_detail_result = RoleService.role_detail_services(query_db, role_id)
|
||||
logger.info(f'获取role_id为{role_id}的信息成功')
|
||||
return ResponseUtil.success(data=role_detail_result.model_dump(by_alias=True))
|
||||
except Exception as e:
|
||||
logger.exception(e)
|
||||
return ResponseUtil.error(msg=str(e))
|
||||
|
||||
|
||||
@roleController.post("/export", dependencies=[Depends(CheckUserInterfaceAuth('system:role:export'))])
|
||||
@log_decorator(title='角色管理', business_type=5)
|
||||
async def export_system_role_list(request: Request, role_page_query: RolePageQueryModel = Depends(RolePageQueryModel.as_form), query_db: Session = Depends(get_db)):
|
||||
try:
|
||||
role_query = RoleQueryModel(**role_page_query.model_dump(by_alias=True))
|
||||
# 获取全量数据
|
||||
role_query_result = RoleService.get_role_list_services(query_db, role_query)
|
||||
role_export_result = RoleService.export_role_list_services(role_query_result)
|
||||
logger.info('导出成功')
|
||||
return ResponseUtil.streaming(data=bytes2file_response(role_export_result))
|
||||
except Exception as e:
|
||||
logger.exception(e)
|
||||
return ResponseUtil.error(msg=str(e))
|
||||
|
||||
|
||||
@roleController.put("/changeStatus", dependencies=[Depends(CheckUserInterfaceAuth('system:role:edit'))])
|
||||
@log_decorator(title='角色管理', business_type=2)
|
||||
async def reset_system_role_status(request: Request, edit_role: AddRoleModel, query_db: Session = Depends(get_db), current_user: CurrentUserModel = Depends(LoginService.get_current_user)):
|
||||
try:
|
||||
edit_role.update_by = current_user.user.user_name
|
||||
edit_role.update_time = datetime.now()
|
||||
edit_role.type = 'status'
|
||||
edit_role_result = RoleService.edit_role_services(query_db, edit_role)
|
||||
if edit_role_result.is_success:
|
||||
logger.info(edit_role_result.message)
|
||||
return ResponseUtil.success(msg=edit_role_result.message)
|
||||
else:
|
||||
logger.warning(edit_role_result.message)
|
||||
return ResponseUtil.failure(msg=edit_role_result.message)
|
||||
except Exception as e:
|
||||
logger.exception(e)
|
||||
return ResponseUtil.error(msg=str(e))
|
||||
|
||||
|
||||
@roleController.get("/authUser/allocatedList", response_model=PageResponseModel, dependencies=[Depends(CheckUserInterfaceAuth('common'))])
|
||||
async def get_system_allocated_user_list(request: Request, user_role: UserRolePageQueryModel = Depends(UserRolePageQueryModel.as_query), query_db: Session = Depends(get_db)):
|
||||
try:
|
||||
role_user_query = UserRoleQueryModel(**user_role.model_dump(by_alias=True))
|
||||
role_user_allocated_query_result = RoleService.get_role_user_allocated_list_services(query_db, role_user_query)
|
||||
# 分页操作
|
||||
role_user_allocated_page_query_result = get_page_obj(role_user_allocated_query_result, user_role.page_num, user_role.page_size)
|
||||
logger.info('获取成功')
|
||||
return ResponseUtil.success(model_content=role_user_allocated_page_query_result)
|
||||
except Exception as e:
|
||||
logger.exception(e)
|
||||
return ResponseUtil.error(msg=str(e))
|
||||
|
||||
|
||||
@roleController.get("/authUser/unallocatedList", response_model=PageResponseModel, dependencies=[Depends(CheckUserInterfaceAuth('common'))])
|
||||
async def get_system_unallocated_user_list(request: Request, user_role: UserRolePageQueryModel = Depends(UserRolePageQueryModel.as_query), query_db: Session = Depends(get_db)):
|
||||
try:
|
||||
role_user_query = UserRoleQueryModel(**user_role.model_dump(by_alias=True))
|
||||
role_user_unallocated_query_result = RoleService.get_role_user_unallocated_list_services(query_db, role_user_query)
|
||||
# 分页操作
|
||||
role_user_unallocated_page_query_result = get_page_obj(role_user_unallocated_query_result, user_role.page_num, user_role.page_size)
|
||||
logger.info('获取成功')
|
||||
return ResponseUtil.success(model_content=role_user_unallocated_page_query_result)
|
||||
except Exception as e:
|
||||
logger.exception(e)
|
||||
return ResponseUtil.error(msg=str(e))
|
||||
|
||||
|
||||
@roleController.put("/authUser/selectAll", dependencies=[Depends(CheckUserInterfaceAuth('system:role:edit'))])
|
||||
@log_decorator(title='角色管理', business_type=4)
|
||||
async def add_system_role_user(request: Request, add_role_user: CrudUserRoleModel = Depends(CrudUserRoleModel.as_query), query_db: Session = Depends(get_db)):
|
||||
try:
|
||||
add_role_user_result = UserService.add_user_role_services(query_db, add_role_user)
|
||||
if add_role_user_result.is_success:
|
||||
logger.info(add_role_user_result.message)
|
||||
return ResponseUtil.success(msg=add_role_user_result.message)
|
||||
else:
|
||||
logger.warning(add_role_user_result.message)
|
||||
return ResponseUtil.failure(msg=add_role_user_result.message)
|
||||
except Exception as e:
|
||||
logger.exception(e)
|
||||
return ResponseUtil.error(msg=str(e))
|
||||
|
||||
|
||||
@roleController.put("/authUser/cancel", dependencies=[Depends(CheckUserInterfaceAuth('system:role:edit'))])
|
||||
@log_decorator(title='角色管理', business_type=4)
|
||||
async def cancel_system_role_user(request: Request, cancel_user_role: CrudUserRoleModel, query_db: Session = Depends(get_db)):
|
||||
try:
|
||||
cancel_user_role_result = UserService.delete_user_role_services(query_db, cancel_user_role)
|
||||
if cancel_user_role_result.is_success:
|
||||
logger.info(cancel_user_role_result.message)
|
||||
return ResponseUtil.success(msg=cancel_user_role_result.message)
|
||||
else:
|
||||
logger.warning(cancel_user_role_result.message)
|
||||
return ResponseUtil.failure(msg=cancel_user_role_result.message)
|
||||
except Exception as e:
|
||||
logger.exception(e)
|
||||
return ResponseUtil.error(msg=str(e))
|
||||
|
||||
|
||||
@roleController.put("/authUser/cancelAll", dependencies=[Depends(CheckUserInterfaceAuth('system:role:edit'))])
|
||||
@log_decorator(title='角色管理', business_type=4)
|
||||
async def batch_cancel_system_role_user(request: Request, batch_cancel_user_role: CrudUserRoleModel = Depends(CrudUserRoleModel.as_query), query_db: Session = Depends(get_db)):
|
||||
try:
|
||||
batch_cancel_user_role_result = UserService.delete_user_role_services(query_db, batch_cancel_user_role)
|
||||
if batch_cancel_user_role_result.is_success:
|
||||
logger.info(batch_cancel_user_role_result.message)
|
||||
return ResponseUtil.success(msg=batch_cancel_user_role_result.message)
|
||||
else:
|
||||
logger.warning(batch_cancel_user_role_result.message)
|
||||
return ResponseUtil.failure(msg=batch_cancel_user_role_result.message)
|
||||
except Exception as e:
|
||||
logger.exception(e)
|
||||
return ResponseUtil.error(msg=str(e))
|
||||
@@ -0,0 +1,22 @@
|
||||
from fastapi import APIRouter, Request
|
||||
from fastapi import Depends
|
||||
from module_admin.service.login_service import LoginService
|
||||
from module_admin.service.server_service import *
|
||||
from utils.response_util import *
|
||||
from utils.log_util import *
|
||||
from module_admin.aspect.interface_auth import CheckUserInterfaceAuth
|
||||
|
||||
|
||||
serverController = APIRouter(prefix='/monitor/server', dependencies=[Depends(LoginService.get_current_user)])
|
||||
|
||||
|
||||
@serverController.get("", response_model=ServerMonitorModel, dependencies=[Depends(CheckUserInterfaceAuth('monitor:server:list'))])
|
||||
async def get_monitor_server_info(request: Request):
|
||||
try:
|
||||
# 获取全量数据
|
||||
server_info_query_result = ServerService.get_server_monitor_info()
|
||||
logger.info('获取成功')
|
||||
return ResponseUtil.success(data=server_info_query_result)
|
||||
except Exception as e:
|
||||
logger.exception(e)
|
||||
return ResponseUtil.error(msg=str(e))
|
||||
307
ruoyi-fastapi-backend/module_admin/controller/user_controller.py
Normal file
307
ruoyi-fastapi-backend/module_admin/controller/user_controller.py
Normal file
@@ -0,0 +1,307 @@
|
||||
from fastapi import APIRouter, Request
|
||||
from fastapi import Depends, File, Query
|
||||
from config.get_db import get_db
|
||||
from module_admin.service.login_service import LoginService
|
||||
from module_admin.service.user_service import *
|
||||
from module_admin.service.dept_service import DeptService
|
||||
from utils.page_util import *
|
||||
from utils.response_util import *
|
||||
from utils.log_util import *
|
||||
from utils.common_util import bytes2file_response
|
||||
from module_admin.aspect.interface_auth import CheckUserInterfaceAuth
|
||||
from module_admin.aspect.data_scope import GetDataScope
|
||||
from module_admin.annotation.log_annotation import log_decorator
|
||||
|
||||
|
||||
userController = APIRouter(prefix='/system/user', dependencies=[Depends(LoginService.get_current_user)])
|
||||
|
||||
|
||||
@userController.get("/deptTree", dependencies=[Depends(CheckUserInterfaceAuth('system:user:list'))])
|
||||
async def get_system_dept_tree(request: Request, query_db: Session = Depends(get_db), data_scope_sql: str = Depends(GetDataScope('SysDept'))):
|
||||
try:
|
||||
dept_query_result = DeptService.get_dept_tree_services(query_db, DeptModel(**{}), data_scope_sql)
|
||||
logger.info('获取成功')
|
||||
return ResponseUtil.success(data=dept_query_result)
|
||||
except Exception as e:
|
||||
logger.exception(e)
|
||||
return ResponseUtil.error(msg=str(e))
|
||||
|
||||
|
||||
@userController.get("/list", response_model=PageResponseModel, dependencies=[Depends(CheckUserInterfaceAuth('system:user:list'))])
|
||||
async def get_system_user_list(request: Request, user_page_query: UserPageQueryModel = Depends(UserPageQueryModel.as_query), query_db: Session = Depends(get_db), data_scope_sql: str = Depends(GetDataScope('SysUser'))):
|
||||
try:
|
||||
user_query = UserQueryModel(**user_page_query.model_dump(by_alias=True))
|
||||
# 获取全量数据
|
||||
user_query_result = UserService.get_user_list_services(query_db, user_query, data_scope_sql)
|
||||
# 分页操作
|
||||
user_page_query_result = get_page_obj(user_query_result, user_page_query.page_num, user_page_query.page_size)
|
||||
logger.info('获取成功')
|
||||
return ResponseUtil.success(model_content=user_page_query_result)
|
||||
except Exception as e:
|
||||
logger.exception(e)
|
||||
return ResponseUtil.error(msg=str(e))
|
||||
|
||||
|
||||
@userController.post("", dependencies=[Depends(CheckUserInterfaceAuth('system:user:add'))])
|
||||
@log_decorator(title='用户管理', business_type=1)
|
||||
async def add_system_user(request: Request, add_user: AddUserModel, query_db: Session = Depends(get_db), current_user: CurrentUserModel = Depends(LoginService.get_current_user)):
|
||||
try:
|
||||
add_user.password = PwdUtil.get_password_hash(add_user.password)
|
||||
add_user.create_by = current_user.user.user_name
|
||||
add_user.update_by = current_user.user.user_name
|
||||
add_user_result = UserService.add_user_services(query_db, add_user)
|
||||
if add_user_result.is_success:
|
||||
logger.info(add_user_result.message)
|
||||
return ResponseUtil.success(msg=add_user_result.message)
|
||||
else:
|
||||
logger.warning(add_user_result.message)
|
||||
return ResponseUtil.failure(msg=add_user_result.message)
|
||||
except Exception as e:
|
||||
logger.exception(e)
|
||||
return ResponseUtil.error(msg=str(e))
|
||||
|
||||
|
||||
@userController.put("", dependencies=[Depends(CheckUserInterfaceAuth('system:user:edit'))])
|
||||
@log_decorator(title='用户管理', business_type=2)
|
||||
async def edit_system_user(request: Request, edit_user: EditUserModel, query_db: Session = Depends(get_db), current_user: CurrentUserModel = Depends(LoginService.get_current_user)):
|
||||
try:
|
||||
edit_user.update_by = current_user.user.user_name
|
||||
edit_user.update_time = datetime.now()
|
||||
edit_user_result = UserService.edit_user_services(query_db, edit_user)
|
||||
if edit_user_result.is_success:
|
||||
logger.info(edit_user_result.message)
|
||||
return ResponseUtil.success(msg=edit_user_result.message)
|
||||
else:
|
||||
logger.warning(edit_user_result.message)
|
||||
return ResponseUtil.failure(msg=edit_user_result.message)
|
||||
except Exception as e:
|
||||
logger.exception(e)
|
||||
return ResponseUtil.error(msg=str(e))
|
||||
|
||||
|
||||
@userController.delete("/{user_ids}", dependencies=[Depends(CheckUserInterfaceAuth('system:user:remove'))])
|
||||
@log_decorator(title='用户管理', business_type=3)
|
||||
async def delete_system_user(request: Request, user_ids: str, query_db: Session = Depends(get_db), current_user: CurrentUserModel = Depends(LoginService.get_current_user)):
|
||||
try:
|
||||
delete_user = DeleteUserModel(
|
||||
userIds=user_ids,
|
||||
updateBy=current_user.user.user_name,
|
||||
updateTime=datetime.now()
|
||||
)
|
||||
delete_user_result = UserService.delete_user_services(query_db, delete_user)
|
||||
if delete_user_result.is_success:
|
||||
logger.info(delete_user_result.message)
|
||||
return ResponseUtil.success(msg=delete_user_result.message)
|
||||
else:
|
||||
logger.warning(delete_user_result.message)
|
||||
return ResponseUtil.failure(msg=delete_user_result.message)
|
||||
except Exception as e:
|
||||
logger.exception(e)
|
||||
return ResponseUtil.error(msg=str(e))
|
||||
|
||||
|
||||
@userController.put("/resetPwd", dependencies=[Depends(CheckUserInterfaceAuth('system:user:resetPwd'))])
|
||||
@log_decorator(title='用户管理', business_type=2)
|
||||
async def reset_system_user_pwd(request: Request, edit_user: EditUserModel, query_db: Session = Depends(get_db), current_user: CurrentUserModel = Depends(LoginService.get_current_user)):
|
||||
try:
|
||||
edit_user.password = PwdUtil.get_password_hash(edit_user.password)
|
||||
edit_user.update_by = current_user.user.user_name
|
||||
edit_user.update_time = datetime.now()
|
||||
edit_user.type = 'pwd'
|
||||
edit_user_result = UserService.edit_user_services(query_db, edit_user)
|
||||
if edit_user_result.is_success:
|
||||
logger.info(edit_user_result.message)
|
||||
return ResponseUtil.success(msg=edit_user_result.message)
|
||||
else:
|
||||
logger.warning(edit_user_result.message)
|
||||
return ResponseUtil.failure(msg=edit_user_result.message)
|
||||
except Exception as e:
|
||||
logger.exception(e)
|
||||
return ResponseUtil.error(msg=str(e))
|
||||
|
||||
|
||||
@userController.put("/changeStatus", dependencies=[Depends(CheckUserInterfaceAuth('system:user:edit'))])
|
||||
@log_decorator(title='用户管理', business_type=2)
|
||||
async def change_system_user_status(request: Request, edit_user: EditUserModel, query_db: Session = Depends(get_db), current_user: CurrentUserModel = Depends(LoginService.get_current_user)):
|
||||
try:
|
||||
edit_user.update_by = current_user.user.user_name
|
||||
edit_user.update_time = datetime.now()
|
||||
edit_user.type = 'status'
|
||||
edit_user_result = UserService.edit_user_services(query_db, edit_user)
|
||||
if edit_user_result.is_success:
|
||||
logger.info(edit_user_result.message)
|
||||
return ResponseUtil.success(msg=edit_user_result.message)
|
||||
else:
|
||||
logger.warning(edit_user_result.message)
|
||||
return ResponseUtil.failure(msg=edit_user_result.message)
|
||||
except Exception as e:
|
||||
logger.exception(e)
|
||||
return ResponseUtil.error(msg=str(e))
|
||||
|
||||
|
||||
@userController.get("/profile", response_model=UserProfileModel)
|
||||
async def query_detail_system_user(request: Request, query_db: Session = Depends(get_db), current_user: CurrentUserModel = Depends(LoginService.get_current_user)):
|
||||
try:
|
||||
profile_user_result = UserService.user_profile_services(query_db, current_user.user.user_id)
|
||||
logger.info(f'获取user_id为{current_user.user.user_id}的信息成功')
|
||||
return ResponseUtil.success(model_content=profile_user_result)
|
||||
except Exception as e:
|
||||
logger.exception(e)
|
||||
return ResponseUtil.error(msg=str(e))
|
||||
|
||||
|
||||
@userController.get("/{user_id}", response_model=UserDetailModel, dependencies=[Depends(CheckUserInterfaceAuth('system:user:query'))])
|
||||
@userController.get("/", response_model=UserDetailModel, dependencies=[Depends(CheckUserInterfaceAuth('system:user:query'))])
|
||||
async def query_detail_system_user(request: Request, user_id: Optional[Union[int, str]] = '', query_db: Session = Depends(get_db), current_user: CurrentUserModel = Depends(LoginService.get_current_user)):
|
||||
try:
|
||||
detail_user_result = UserService.user_detail_services(query_db, user_id)
|
||||
logger.info(f'获取user_id为{user_id}的信息成功')
|
||||
return ResponseUtil.success(model_content=detail_user_result)
|
||||
except Exception as e:
|
||||
logger.exception(e)
|
||||
return ResponseUtil.error(msg=str(e))
|
||||
|
||||
|
||||
@userController.post("/profile/avatar")
|
||||
@log_decorator(title='个人信息', business_type=2)
|
||||
async def change_system_user_profile_avatar(request: Request, avatarfile: bytes = File(), query_db: Session = Depends(get_db), current_user: CurrentUserModel = Depends(LoginService.get_current_user)):
|
||||
try:
|
||||
dir_path = os.path.join(CachePathConfig.PATH, 'profile', 'avatar')
|
||||
try:
|
||||
os.makedirs(dir_path)
|
||||
except FileExistsError:
|
||||
pass
|
||||
avatar_name = f'blob_{datetime.now().strftime("%Y%m%d%H%M%S")}.jpeg'
|
||||
avatar_path = os.path.join(dir_path, avatar_name)
|
||||
with open(avatar_path, 'wb') as f:
|
||||
f.write(avatarfile)
|
||||
edit_user = EditUserModel(
|
||||
userId=current_user.user.user_id,
|
||||
avatar=f'/common/{CachePathConfig.PATHSTR}?taskPath=profile&taskId=avatar&filename={avatar_name}',
|
||||
updateBy=current_user.user.user_name,
|
||||
updateTime=datetime.now(),
|
||||
type='avatar'
|
||||
)
|
||||
edit_user_result = UserService.edit_user_services(query_db, edit_user)
|
||||
if edit_user_result.is_success:
|
||||
logger.info(edit_user_result.message)
|
||||
return ResponseUtil.success(dict_content={'imgUrl': edit_user.avatar}, msg=edit_user_result.message)
|
||||
else:
|
||||
logger.warning(edit_user_result.message)
|
||||
return ResponseUtil.failure(msg=edit_user_result.message)
|
||||
except Exception as e:
|
||||
logger.exception(e)
|
||||
return ResponseUtil.error(msg=str(e))
|
||||
|
||||
|
||||
@userController.put("/profile")
|
||||
@log_decorator(title='个人信息', business_type=2)
|
||||
async def change_system_user_profile_info(request: Request, user_info: UserInfoModel, query_db: Session = Depends(get_db), current_user: CurrentUserModel = Depends(LoginService.get_current_user)):
|
||||
try:
|
||||
edit_user = EditUserModel(**user_info.model_dump(by_alias=True, exclude={'role_ids', 'post_ids'}), roleIds=user_info.role_ids.split(','), postIds=user_info.post_ids.split(','))
|
||||
edit_user.user_id = current_user.user.user_id
|
||||
edit_user.update_by = current_user.user.user_name
|
||||
edit_user.update_time = datetime.now()
|
||||
print(edit_user.model_dump())
|
||||
edit_user_result = UserService.edit_user_services(query_db, edit_user)
|
||||
if edit_user_result.is_success:
|
||||
logger.info(edit_user_result.message)
|
||||
return ResponseUtil.success(msg=edit_user_result.message)
|
||||
else:
|
||||
logger.warning(edit_user_result.message)
|
||||
return ResponseUtil.failure(msg=edit_user_result.message)
|
||||
except Exception as e:
|
||||
logger.exception(e)
|
||||
return ResponseUtil.error(msg=str(e))
|
||||
|
||||
|
||||
@userController.put("/profile/updatePwd")
|
||||
@log_decorator(title='个人信息', business_type=2)
|
||||
async def reset_system_user_password(request: Request, old_password: str = Query(alias='oldPassword'), new_password: str = Query(alias='newPassword'), query_db: Session = Depends(get_db), current_user: CurrentUserModel = Depends(LoginService.get_current_user)):
|
||||
try:
|
||||
reset_user = ResetUserModel(
|
||||
userId=current_user.user.user_id,
|
||||
oldPassword=old_password,
|
||||
password=PwdUtil.get_password_hash(new_password),
|
||||
updateBy=current_user.user.user_name,
|
||||
updateTime=datetime.now()
|
||||
)
|
||||
reset_user_result = UserService.reset_user_services(query_db, reset_user)
|
||||
if reset_user_result.is_success:
|
||||
logger.info(reset_user_result.message)
|
||||
return ResponseUtil.success(msg=reset_user_result.message)
|
||||
else:
|
||||
logger.warning(reset_user_result.message)
|
||||
return ResponseUtil.failure(msg=reset_user_result.message)
|
||||
except Exception as e:
|
||||
logger.exception(e)
|
||||
return ResponseUtil.error(msg=str(e))
|
||||
|
||||
|
||||
@userController.post("/importData", dependencies=[Depends(CheckUserInterfaceAuth('system:user:import'))])
|
||||
@log_decorator(title='用户管理', business_type=6)
|
||||
async def batch_import_system_user(request: Request, file: UploadFile = File(...), update_support: bool = Query(alias='updateSupport'), query_db: Session = Depends(get_db), current_user: CurrentUserModel = Depends(LoginService.get_current_user)):
|
||||
try:
|
||||
batch_import_result = await UserService.batch_import_user_services(query_db, file, update_support, current_user)
|
||||
if batch_import_result.is_success:
|
||||
logger.info(batch_import_result.message)
|
||||
return ResponseUtil.success(msg=batch_import_result.message)
|
||||
else:
|
||||
logger.warning(batch_import_result.message)
|
||||
return ResponseUtil.failure(msg=batch_import_result.message)
|
||||
except Exception as e:
|
||||
logger.exception(e)
|
||||
return ResponseUtil.error(msg=str(e))
|
||||
|
||||
|
||||
@userController.post("/importTemplate", dependencies=[Depends(CheckUserInterfaceAuth('system:user:import'))])
|
||||
async def export_system_user_template(request: Request, query_db: Session = Depends(get_db)):
|
||||
try:
|
||||
user_import_template_result = UserService.get_user_import_template_services()
|
||||
logger.info('获取成功')
|
||||
return ResponseUtil.streaming(data=bytes2file_response(user_import_template_result))
|
||||
except Exception as e:
|
||||
logger.exception(e)
|
||||
return ResponseUtil.error(msg=str(e))
|
||||
|
||||
|
||||
@userController.post("/export", dependencies=[Depends(CheckUserInterfaceAuth('system:user:export'))])
|
||||
@log_decorator(title='用户管理', business_type=5)
|
||||
async def export_system_user_list(request: Request, user_page_query: UserPageQueryModel = Depends(UserPageQueryModel.as_form), query_db: Session = Depends(get_db), data_scope_sql: str = Depends(GetDataScope('SysUser'))):
|
||||
try:
|
||||
user_query = UserQueryModel(**user_page_query.model_dump(by_alias=True))
|
||||
# 获取全量数据
|
||||
user_query_result = UserService.get_user_list_services(query_db, user_query, data_scope_sql)
|
||||
user_export_result = UserService.export_user_list_services(user_query_result)
|
||||
logger.info('导出成功')
|
||||
return ResponseUtil.streaming(data=bytes2file_response(user_export_result))
|
||||
except Exception as e:
|
||||
logger.exception(e)
|
||||
return ResponseUtil.error(msg=str(e))
|
||||
|
||||
|
||||
@userController.get("/authRole/{user_id}", response_model=UserRoleResponseModel, dependencies=[Depends(CheckUserInterfaceAuth('system:user:query'))])
|
||||
async def get_system_allocated_role_list(request: Request, user_id: int, query_db: Session = Depends(get_db)):
|
||||
try:
|
||||
user_role_query = UserRoleQueryModel(userId=user_id)
|
||||
user_role_allocated_query_result = UserService.get_user_role_allocated_list_services(query_db, user_role_query)
|
||||
logger.info('获取成功')
|
||||
return ResponseUtil.success(model_content=user_role_allocated_query_result)
|
||||
except Exception as e:
|
||||
logger.exception(e)
|
||||
return ResponseUtil.error(msg=str(e))
|
||||
|
||||
|
||||
@userController.put("/authRole", response_model=UserRoleResponseModel, dependencies=[Depends(CheckUserInterfaceAuth('system:user:edit'))])
|
||||
async def update_system_role_user(request: Request, user_id: int = Query(alias='userId'), role_ids: str = Query(alias='roleIds'), query_db: Session = Depends(get_db)):
|
||||
try:
|
||||
add_user_role_result = UserService.add_user_role_services(query_db, CrudUserRoleModel(userId=user_id, roleIds=role_ids))
|
||||
if add_user_role_result.is_success:
|
||||
logger.info(add_user_role_result.message)
|
||||
return ResponseUtil.success(msg=add_user_role_result.message)
|
||||
else:
|
||||
logger.warning(add_user_role_result.message)
|
||||
return ResponseUtil.failure(msg=add_user_role_result.message)
|
||||
except Exception as e:
|
||||
logger.exception(e)
|
||||
return ResponseUtil.error(msg=str(e))
|
||||
Reference in New Issue
Block a user