PowLu/RuoYi-Vue3-FastAPI
1
0
Fork 0
Code Issues Pull Requests Actions Packages Projects Releases Wiki Activity

refactor: 重构数据库orm为异步 #I9MRQS

Browse Source
This commit is contained in:
insistence
2024-05-17 15:04:30 +08:00
parent 18103e3d38
commit 1972f1cb6d
52 changed files with 1414 additions and 1246 deletions
Download Patch File Download Diff File Expand all files Collapse all files

2
ruoyi-fastapi-backend/module_admin/controller/cache_controller.py
View File

@@ -26,7 +26,7 @@ async def get_monitor_cache_info(request: Request):
async def get_monitor_cache_name(request: Request):
try:
# 获取全量数据
cache_name_list_result = CacheService.get_cache_monitor_cache_name_services()
cache_name_list_result = await CacheService.get_cache_monitor_cache_name_services()
logger.info('获取成功')
return ResponseUtil.success(data=cache_name_list_result)
except Exception as e:

2
ruoyi-fastapi-backend/module_admin/controller/captcha_controller.py
View File

@@ -18,7 +18,7 @@ async def get_captcha_image(request: Request):
register_enabled = True if await request.app.state.redis.get(
f"{RedisInitKeyConfig.SYS_CONFIG.get('key')}:sys.account.registerUser") == 'true' else False
session_id = str(uuid.uuid4())
captcha_result = CaptchaService.create_captcha_image_service()
captcha_result = await CaptchaService.create_captcha_image_service()
image = captcha_result[0]
computed_result = captcha_result[1]
await request.app.state.redis.set(f"{RedisInitKeyConfig.CAPTCHA_CODES.get('key')}:{session_id}", computed_result, ex=timedelta(minutes=2))

6
ruoyi-fastapi-backend/module_admin/controller/common_controller.py
View File

@@ -11,7 +11,7 @@ commonController = APIRouter(prefix='/common', dependencies=[Depends(LoginServic
@commonController.post("/upload")
async def common_upload(request: Request, file: UploadFile = File(...)):
try:
upload_result = CommonService.upload_service(request, file)
upload_result = await CommonService.upload_service(request, file)
if upload_result.is_success:
logger.info('上传成功')
return ResponseUtil.success(model_content=upload_result.result)
@@ -26,7 +26,7 @@ async def common_upload(request: Request, file: UploadFile = File(...)):
@commonController.get("/download")
async def common_download(request: Request, background_tasks: BackgroundTasks, file_name: str = Query(alias='fileName'), delete: bool = Query()):
try:
download_result = CommonService.download_services(background_tasks, file_name, delete)
download_result = await CommonService.download_services(background_tasks, file_name, delete)
if download_result.is_success:
logger.info(download_result.message)
return ResponseUtil.streaming(data=download_result.result)
@@ -41,7 +41,7 @@ async def common_download(request: Request, background_tasks: BackgroundTasks, f
@commonController.get("/download/resource")
async def common_download(request: Request, resource: str = Query()):
try:
download_resource_result = CommonService.download_resource_services(resource)
download_resource_result = await CommonService.download_resource_services(resource)
if download_resource_result.is_success:
logger.info(download_resource_result.message)
return ResponseUtil.streaming(data=download_resource_result.result)

22
ruoyi-fastapi-backend/module_admin/controller/config_controller.py
View File

@@ -15,10 +15,10 @@ configController = APIRouter(prefix='/system/config', dependencies=[Depends(Logi
@configController.get("/list", response_model=PageResponseModel, dependencies=[Depends(CheckUserInterfaceAuth('system:config:list'))])
async def get_system_config_list(request: Request, config_page_query: ConfigPageQueryModel = Depends(ConfigPageQueryModel.as_query), query_db: Session = Depends(get_db)):
async def get_system_config_list(request: Request, config_page_query: ConfigPageQueryModel = Depends(ConfigPageQueryModel.as_query), query_db: AsyncSession = Depends(get_db)):
try:
# 获取分页数据
config_page_query_result = ConfigService.get_config_list_services(query_db, config_page_query, is_page=True)
config_page_query_result = await ConfigService.get_config_list_services(query_db, config_page_query, is_page=True)
logger.info('获取成功')
return ResponseUtil.success(model_content=config_page_query_result)
except Exception as e:
@@ -28,7 +28,7 @@ async def get_system_config_list(request: Request, config_page_query: ConfigPage
@configController.post("", dependencies=[Depends(CheckUserInterfaceAuth('system:config:add'))])
@log_decorator(title='参数管理', business_type=1)
async def add_system_config(request: Request, add_config: ConfigModel, query_db: Session = Depends(get_db), current_user: CurrentUserModel = Depends(LoginService.get_current_user)):
async def add_system_config(request: Request, add_config: ConfigModel, query_db: AsyncSession = Depends(get_db), current_user: CurrentUserModel = Depends(LoginService.get_current_user)):
try:
add_config.create_by = current_user.user.user_name
add_config.update_by = current_user.user.user_name
@@ -46,7 +46,7 @@ async def add_system_config(request: Request, add_config: ConfigModel, query_db:
@configController.put("", dependencies=[Depends(CheckUserInterfaceAuth('system:config:edit'))])
@log_decorator(title='参数管理', business_type=2)
async def edit_system_config(request: Request, edit_config: ConfigModel, query_db: Session = Depends(get_db), current_user: CurrentUserModel = Depends(LoginService.get_current_user)):
async def edit_system_config(request: Request, edit_config: ConfigModel, query_db: AsyncSession = Depends(get_db), current_user: CurrentUserModel = Depends(LoginService.get_current_user)):
try:
edit_config.update_by = current_user.user.user_name
edit_config.update_time = datetime.now()
@@ -64,7 +64,7 @@ async def edit_system_config(request: Request, edit_config: ConfigModel, query_d
@configController.delete("/refreshCache", dependencies=[Depends(CheckUserInterfaceAuth('system:config:remove'))])
@log_decorator(title='参数管理', business_type=2)
async def refresh_system_config(request: Request, query_db: Session = Depends(get_db)):
async def refresh_system_config(request: Request, query_db: AsyncSession = Depends(get_db)):
try:
refresh_config_result = await ConfigService.refresh_sys_config_services(request, query_db)
if refresh_config_result.is_success:
@@ -80,7 +80,7 @@ async def refresh_system_config(request: Request, query_db: Session = Depends(ge
@configController.delete("/{config_ids}", dependencies=[Depends(CheckUserInterfaceAuth('system:config:remove'))])
@log_decorator(title='参数管理', business_type=3)
async def delete_system_config(request: Request, config_ids: str, query_db: Session = Depends(get_db)):
async def delete_system_config(request: Request, config_ids: str, query_db: AsyncSession = Depends(get_db)):
try:
delete_config = DeleteConfigModel(configIds=config_ids)
delete_config_result = await ConfigService.delete_config_services(request, query_db, delete_config)
@@ -96,9 +96,9 @@ async def delete_system_config(request: Request, config_ids: str, query_db: Sess
@configController.get("/{config_id}", response_model=ConfigModel, dependencies=[Depends(CheckUserInterfaceAuth('system:config:query'))])
async def query_detail_system_config(request: Request, config_id: int, query_db: Session = Depends(get_db)):
async def query_detail_system_config(request: Request, config_id: int, query_db: AsyncSession = Depends(get_db)):
try:
config_detail_result = ConfigService.config_detail_services(query_db, config_id)
config_detail_result = await ConfigService.config_detail_services(query_db, config_id)
logger.info(f'获取config_id为{config_id}的信息成功')
return ResponseUtil.success(data=config_detail_result)
except Exception as e:
@@ -120,11 +120,11 @@ async def query_system_config(request: Request, config_key: str):
@configController.post("/export", dependencies=[Depends(CheckUserInterfaceAuth('system:config:export'))])
@log_decorator(title='参数管理', business_type=5)
async def export_system_config_list(request: Request, config_page_query: ConfigPageQueryModel = Depends(ConfigPageQueryModel.as_form), query_db: Session = Depends(get_db)):
async def export_system_config_list(request: Request, config_page_query: ConfigPageQueryModel = Depends(ConfigPageQueryModel.as_form), query_db: AsyncSession = Depends(get_db)):
try:
# 获取全量数据
config_query_result = ConfigService.get_config_list_services(query_db, config_page_query, is_page=False)
config_export_result = ConfigService.export_config_list_services(config_query_result)
config_query_result = await ConfigService.get_config_list_services(query_db, config_page_query, is_page=False)
config_export_result = await ConfigService.export_config_list_services(config_query_result)
logger.info('导出成功')
return ResponseUtil.streaming(data=bytes2file_response(config_export_result))
except Exception as e:

24
ruoyi-fastapi-backend/module_admin/controller/dept_controller.py
View File

@@ -14,10 +14,10 @@ deptController = APIRouter(prefix='/system/dept', dependencies=[Depends(LoginSer
@deptController.get("/list/exclude/{dept_id}", response_model=List[DeptModel], dependencies=[Depends(CheckUserInterfaceAuth('system:dept:list'))])
async def get_system_dept_tree_for_edit_option(request: Request, dept_id: int, query_db: Session = Depends(get_db), data_scope_sql: str = Depends(GetDataScope('SysDept'))):
async def get_system_dept_tree_for_edit_option(request: Request, dept_id: int, query_db: AsyncSession = Depends(get_db), data_scope_sql: str = Depends(GetDataScope('SysDept'))):
try:
dept_query = DeptModel(deptId=dept_id)
dept_query_result = DeptService.get_dept_for_edit_option_services(query_db, dept_query, data_scope_sql)
dept_query_result = await DeptService.get_dept_for_edit_option_services(query_db, dept_query, data_scope_sql)
logger.info('获取成功')
return ResponseUtil.success(data=dept_query_result)
except Exception as e:
@@ -26,9 +26,9 @@ async def get_system_dept_tree_for_edit_option(request: Request, dept_id: int, q
@deptController.get("/list", response_model=List[DeptModel], dependencies=[Depends(CheckUserInterfaceAuth('system:dept:list'))])
async def get_system_dept_list(request: Request, dept_query: DeptQueryModel = Depends(DeptQueryModel.as_query), query_db: Session = Depends(get_db), data_scope_sql: str = Depends(GetDataScope('SysDept'))):
async def get_system_dept_list(request: Request, dept_query: DeptQueryModel = Depends(DeptQueryModel.as_query), query_db: AsyncSession = Depends(get_db), data_scope_sql: str = Depends(GetDataScope('SysDept'))):
try:
dept_query_result = DeptService.get_dept_list_services(query_db, dept_query, data_scope_sql)
dept_query_result = await DeptService.get_dept_list_services(query_db, dept_query, data_scope_sql)
logger.info('获取成功')
return ResponseUtil.success(data=dept_query_result)
except Exception as e:
@@ -38,11 +38,11 @@ async def get_system_dept_list(request: Request, dept_query: DeptQueryModel = De
@deptController.post("", dependencies=[Depends(CheckUserInterfaceAuth('system:dept:add'))])
@log_decorator(title='部门管理', business_type=1)
async def add_system_dept(request: Request, add_dept: DeptModel, query_db: Session = Depends(get_db), current_user: CurrentUserModel = Depends(LoginService.get_current_user)):
async def add_system_dept(request: Request, add_dept: DeptModel, query_db: AsyncSession = Depends(get_db), current_user: CurrentUserModel = Depends(LoginService.get_current_user)):
try:
add_dept.create_by = current_user.user.user_name
add_dept.update_by = current_user.user.user_name
add_dept_result = DeptService.add_dept_services(query_db, add_dept)
add_dept_result = await DeptService.add_dept_services(query_db, add_dept)
if add_dept_result.is_success:
logger.info(add_dept_result.message)
return ResponseUtil.success(data=add_dept_result)
@@ -56,11 +56,11 @@ async def add_system_dept(request: Request, add_dept: DeptModel, query_db: Sessi
@deptController.put("", dependencies=[Depends(CheckUserInterfaceAuth('system:dept:edit'))])
@log_decorator(title='部门管理', business_type=2)
async def edit_system_dept(request: Request, edit_dept: DeptModel, query_db: Session = Depends(get_db), current_user: CurrentUserModel = Depends(LoginService.get_current_user)):
async def edit_system_dept(request: Request, edit_dept: DeptModel, query_db: AsyncSession = Depends(get_db), current_user: CurrentUserModel = Depends(LoginService.get_current_user)):
try:
edit_dept.update_by = current_user.user.user_name
edit_dept.update_time = datetime.now()
edit_dept_result = DeptService.edit_dept_services(query_db, edit_dept)
edit_dept_result = await DeptService.edit_dept_services(query_db, edit_dept)
if edit_dept_result.is_success:
logger.info(edit_dept_result.message)
return ResponseUtil.success(msg=edit_dept_result.message)
@@ -74,12 +74,12 @@ async def edit_system_dept(request: Request, edit_dept: DeptModel, query_db: Ses
@deptController.delete("/{dept_ids}", dependencies=[Depends(CheckUserInterfaceAuth('system:dept:remove'))])
@log_decorator(title='部门管理', business_type=3)
async def delete_system_dept(request: Request, dept_ids: str, query_db: Session = Depends(get_db), current_user: CurrentUserModel = Depends(LoginService.get_current_user)):
async def delete_system_dept(request: Request, dept_ids: str, query_db: AsyncSession = Depends(get_db), current_user: CurrentUserModel = Depends(LoginService.get_current_user)):
try:
delete_dept = DeleteDeptModel(deptIds=dept_ids)
delete_dept.update_by = current_user.user.user_name
delete_dept.update_time = datetime.now()
delete_dept_result = DeptService.delete_dept_services(query_db, delete_dept)
delete_dept_result = await DeptService.delete_dept_services(query_db, delete_dept)
if delete_dept_result.is_success:
logger.info(delete_dept_result.message)
return ResponseUtil.success(msg=delete_dept_result.message)
@@ -92,9 +92,9 @@ async def delete_system_dept(request: Request, dept_ids: str, query_db: Session
@deptController.get("/{dept_id}", response_model=DeptModel, dependencies=[Depends(CheckUserInterfaceAuth('system:dept:query'))])
async def query_detail_system_dept(request: Request, dept_id: int, query_db: Session = Depends(get_db)):
async def query_detail_system_dept(request: Request, dept_id: int, query_db: AsyncSession = Depends(get_db)):
try:
detail_dept_result = DeptService.dept_detail_services(query_db, dept_id)
detail_dept_result = await DeptService.dept_detail_services(query_db, dept_id)
logger.info(f'获取dept_id为{dept_id}的信息成功')
return ResponseUtil.success(data=detail_dept_result)
except Exception as e:

48
ruoyi-fastapi-backend/module_admin/controller/dict_controller.py
View File

@@ -15,10 +15,10 @@ dictController = APIRouter(prefix='/system/dict', dependencies=[Depends(LoginSer
@dictController.get("/type/list", response_model=PageResponseModel, dependencies=[Depends(CheckUserInterfaceAuth('system:dict:list'))])
async def get_system_dict_type_list(request: Request, dict_type_page_query: DictTypePageQueryModel = Depends(DictTypePageQueryModel.as_query), query_db: Session = Depends(get_db)):
async def get_system_dict_type_list(request: Request, dict_type_page_query: DictTypePageQueryModel = Depends(DictTypePageQueryModel.as_query), query_db: AsyncSession = Depends(get_db)):
try:
# 获取分页数据
dict_type_page_query_result = DictTypeService.get_dict_type_list_services(query_db, dict_type_page_query, is_page=True)
dict_type_page_query_result = await DictTypeService.get_dict_type_list_services(query_db, dict_type_page_query, is_page=True)
logger.info('获取成功')
return ResponseUtil.success(model_content=dict_type_page_query_result)
except Exception as e:
@@ -28,7 +28,7 @@ async def get_system_dict_type_list(request: Request, dict_type_page_query: Dict
@dictController.post("/type", dependencies=[Depends(CheckUserInterfaceAuth('system:dict:add'))])
@log_decorator(title='字典管理', business_type=1)
async def add_system_dict_type(request: Request, add_dict_type: DictTypeModel, query_db: Session = Depends(get_db), current_user: CurrentUserModel = Depends(LoginService.get_current_user)):
async def add_system_dict_type(request: Request, add_dict_type: DictTypeModel, query_db: AsyncSession = Depends(get_db), current_user: CurrentUserModel = Depends(LoginService.get_current_user)):
try:
add_dict_type.create_by = current_user.user.user_name
add_dict_type.update_by = current_user.user.user_name
@@ -46,7 +46,7 @@ async def add_system_dict_type(request: Request, add_dict_type: DictTypeModel, q
@dictController.put("/type", dependencies=[Depends(CheckUserInterfaceAuth('system:dict:edit'))])
@log_decorator(title='字典管理', business_type=2)
async def edit_system_dict_type(request: Request, edit_dict_type: DictTypeModel, query_db: Session = Depends(get_db), current_user: CurrentUserModel = Depends(LoginService.get_current_user)):
async def edit_system_dict_type(request: Request, edit_dict_type: DictTypeModel, query_db: AsyncSession = Depends(get_db), current_user: CurrentUserModel = Depends(LoginService.get_current_user)):
try:
edit_dict_type.update_by = current_user.user.user_name
edit_dict_type.update_time = datetime.now()
@@ -64,7 +64,7 @@ async def edit_system_dict_type(request: Request, edit_dict_type: DictTypeModel,
@dictController.delete("/type/refreshCache", dependencies=[Depends(CheckUserInterfaceAuth('system:dict:remove'))])
@log_decorator(title='字典管理', business_type=2)
async def refresh_system_dict(request: Request, query_db: Session = Depends(get_db)):
async def refresh_system_dict(request: Request, query_db: AsyncSession = Depends(get_db)):
try:
refresh_dict_result = await DictTypeService.refresh_sys_dict_services(request, query_db)
if refresh_dict_result.is_success:
@@ -80,7 +80,7 @@ async def refresh_system_dict(request: Request, query_db: Session = Depends(get_
@dictController.delete("/type/{dict_ids}", dependencies=[Depends(CheckUserInterfaceAuth('system:dict:remove'))])
@log_decorator(title='字典管理', business_type=3)
async def delete_system_dict_type(request: Request, dict_ids: str, query_db: Session = Depends(get_db)):
async def delete_system_dict_type(request: Request, dict_ids: str, query_db: AsyncSession = Depends(get_db)):
try:
delete_dict_type = DeleteDictTypeModel(dictIds=dict_ids)
delete_dict_type_result = await DictTypeService.delete_dict_type_services(request, query_db, delete_dict_type)
@@ -96,9 +96,9 @@ async def delete_system_dict_type(request: Request, dict_ids: str, query_db: Ses
@dictController.get("/type/optionselect", response_model=List[DictTypeModel])
async def query_system_dict_type_options(request: Request, query_db: Session = Depends(get_db)):
async def query_system_dict_type_options(request: Request, query_db: AsyncSession = Depends(get_db)):
try:
dict_type_query_result = DictTypeService.get_dict_type_list_services(query_db, DictTypePageQueryModel(**dict()), is_page=False)
dict_type_query_result = await DictTypeService.get_dict_type_list_services(query_db, DictTypePageQueryModel(**dict()), is_page=False)
logger.info(f'获取成功')
return ResponseUtil.success(data=dict_type_query_result)
except Exception as e:
@@ -107,9 +107,9 @@ async def query_system_dict_type_options(request: Request, query_db: Session = D
@dictController.get("/type/{dict_id}", response_model=DictTypeModel, dependencies=[Depends(CheckUserInterfaceAuth('system:dict:query'))])
async def query_detail_system_dict_type(request: Request, dict_id: int, query_db: Session = Depends(get_db)):
async def query_detail_system_dict_type(request: Request, dict_id: int, query_db: AsyncSession = Depends(get_db)):
try:
dict_type_detail_result = DictTypeService.dict_type_detail_services(query_db, dict_id)
dict_type_detail_result = await DictTypeService.dict_type_detail_services(query_db, dict_id)
logger.info(f'获取dict_id为{dict_id}的信息成功')
return ResponseUtil.success(data=dict_type_detail_result)
except Exception as e:
@@ -119,11 +119,11 @@ async def query_detail_system_dict_type(request: Request, dict_id: int, query_db
@dictController.post("/type/export", dependencies=[Depends(CheckUserInterfaceAuth('system:dict:export'))])
@log_decorator(title='字典管理', business_type=5)
async def export_system_dict_type_list(request: Request, dict_type_page_query: DictTypePageQueryModel = Depends(DictTypePageQueryModel.as_form), query_db: Session = Depends(get_db)):
async def export_system_dict_type_list(request: Request, dict_type_page_query: DictTypePageQueryModel = Depends(DictTypePageQueryModel.as_form), query_db: AsyncSession = Depends(get_db)):
try:
# 获取全量数据
dict_type_query_result = DictTypeService.get_dict_type_list_services(query_db, dict_type_page_query, is_page=False)
dict_type_export_result = DictTypeService.export_dict_type_list_services(dict_type_query_result)
dict_type_query_result = await DictTypeService.get_dict_type_list_services(query_db, dict_type_page_query, is_page=False)
dict_type_export_result = await DictTypeService.export_dict_type_list_services(dict_type_query_result)
logger.info('导出成功')
return ResponseUtil.streaming(data=bytes2file_response(dict_type_export_result))
except Exception as e:
@@ -132,7 +132,7 @@ async def export_system_dict_type_list(request: Request, dict_type_page_query: D
@dictController.get("/data/type/{dict_type}")
async def query_system_dict_type_data(request: Request, dict_type: str, query_db: Session = Depends(get_db)):
async def query_system_dict_type_data(request: Request, dict_type: str, query_db: AsyncSession = Depends(get_db)):
try:
# 获取全量数据
dict_data_query_result = await DictDataService.query_dict_data_list_from_cache_services(request.app.state.redis, dict_type)
@@ -144,10 +144,10 @@ async def query_system_dict_type_data(request: Request, dict_type: str, query_db
@dictController.get("/data/list", response_model=PageResponseModel, dependencies=[Depends(CheckUserInterfaceAuth('system:dict:list'))])
async def get_system_dict_data_list(request: Request, dict_data_page_query: DictDataPageQueryModel = Depends(DictDataPageQueryModel.as_query), query_db: Session = Depends(get_db)):
async def get_system_dict_data_list(request: Request, dict_data_page_query: DictDataPageQueryModel = Depends(DictDataPageQueryModel.as_query), query_db: AsyncSession = Depends(get_db)):
try:
# 获取分页数据
dict_data_page_query_result = DictDataService.get_dict_data_list_services(query_db, dict_data_page_query, is_page=True)
dict_data_page_query_result = await DictDataService.get_dict_data_list_services(query_db, dict_data_page_query, is_page=True)
logger.info('获取成功')
return ResponseUtil.success(model_content=dict_data_page_query_result)
except Exception as e:
@@ -157,7 +157,7 @@ async def get_system_dict_data_list(request: Request, dict_data_page_query: Dict
@dictController.post("/data", dependencies=[Depends(CheckUserInterfaceAuth('system:dict:add'))])
@log_decorator(title='字典管理', business_type=1)
async def add_system_dict_data(request: Request, add_dict_data: DictDataModel, query_db: Session = Depends(get_db), current_user: CurrentUserModel = Depends(LoginService.get_current_user)):
async def add_system_dict_data(request: Request, add_dict_data: DictDataModel, query_db: AsyncSession = Depends(get_db), current_user: CurrentUserModel = Depends(LoginService.get_current_user)):
try:
add_dict_data.create_by = current_user.user.user_name
add_dict_data.update_by = current_user.user.user_name
@@ -175,7 +175,7 @@ async def add_system_dict_data(request: Request, add_dict_data: DictDataModel, q
@dictController.put("/data", dependencies=[Depends(CheckUserInterfaceAuth('system:dict:edit'))])
@log_decorator(title='字典管理', business_type=2)
async def edit_system_dict_data(request: Request, edit_dict_data: DictDataModel, query_db: Session = Depends(get_db), current_user: CurrentUserModel = Depends(LoginService.get_current_user)):
async def edit_system_dict_data(request: Request, edit_dict_data: DictDataModel, query_db: AsyncSession = Depends(get_db), current_user: CurrentUserModel = Depends(LoginService.get_current_user)):
try:
edit_dict_data.update_by = current_user.user.user_name
edit_dict_data.update_time = datetime.now()
@@ -193,7 +193,7 @@ async def edit_system_dict_data(request: Request, edit_dict_data: DictDataModel,
@dictController.delete("/data/{dict_codes}", dependencies=[Depends(CheckUserInterfaceAuth('system:dict:remove'))])
@log_decorator(title='字典管理', business_type=3)
async def delete_system_dict_data(request: Request, dict_codes: str, query_db: Session = Depends(get_db)):
async def delete_system_dict_data(request: Request, dict_codes: str, query_db: AsyncSession = Depends(get_db)):
try:
delete_dict_data = DeleteDictDataModel(dictCodes=dict_codes)
delete_dict_data_result = await DictDataService.delete_dict_data_services(request, query_db, delete_dict_data)
@@ -209,9 +209,9 @@ async def delete_system_dict_data(request: Request, dict_codes: str, query_db: S
@dictController.get("/data/{dict_code}", response_model=DictDataModel, dependencies=[Depends(CheckUserInterfaceAuth('system:dict:query'))])
async def query_detail_system_dict_data(request: Request, dict_code: int, query_db: Session = Depends(get_db)):
async def query_detail_system_dict_data(request: Request, dict_code: int, query_db: AsyncSession = Depends(get_db)):
try:
detail_dict_data_result = DictDataService.dict_data_detail_services(query_db, dict_code)
detail_dict_data_result = await DictDataService.dict_data_detail_services(query_db, dict_code)
logger.info(f'获取dict_code为{dict_code}的信息成功')
return ResponseUtil.success(data=detail_dict_data_result)
except Exception as e:
@@ -221,11 +221,11 @@ async def query_detail_system_dict_data(request: Request, dict_code: int, query_
@dictController.post("/data/export", dependencies=[Depends(CheckUserInterfaceAuth('system:dict:export'))])
@log_decorator(title='字典管理', business_type=5)
async def export_system_dict_data_list(request: Request, dict_data_page_query: DictDataPageQueryModel = Depends(DictDataPageQueryModel.as_form), query_db: Session = Depends(get_db)):
async def export_system_dict_data_list(request: Request, dict_data_page_query: DictDataPageQueryModel = Depends(DictDataPageQueryModel.as_form), query_db: AsyncSession = Depends(get_db)):
try:
# 获取全量数据
dict_data_query_result = DictDataService.get_dict_data_list_services(query_db, dict_data_page_query, is_page=False)
dict_data_export_result = DictDataService.export_dict_data_list_services(dict_data_query_result)
dict_data_query_result = await DictDataService.get_dict_data_list_services(query_db, dict_data_page_query, is_page=False)
dict_data_export_result = await DictDataService.export_dict_data_list_services(dict_data_query_result)
logger.info('导出成功')
return ResponseUtil.streaming(data=bytes2file_response(dict_data_export_result))
except Exception as e:

50
ruoyi-fastapi-backend/module_admin/controller/job_controller.py
View File

@@ -16,10 +16,10 @@ jobController = APIRouter(prefix='/monitor', dependencies=[Depends(LoginService.
@jobController.get("/job/list", response_model=PageResponseModel, dependencies=[Depends(CheckUserInterfaceAuth('monitor:job:list'))])
async def get_system_job_list(request: Request, job_page_query: JobPageQueryModel = Depends(JobPageQueryModel.as_query), query_db: Session = Depends(get_db)):
async def get_system_job_list(request: Request, job_page_query: JobPageQueryModel = Depends(JobPageQueryModel.as_query), query_db: AsyncSession = Depends(get_db)):
try:
# 获取分页数据
notice_page_query_result = JobService.get_job_list_services(query_db, job_page_query, is_page=True)
notice_page_query_result = await JobService.get_job_list_services(query_db, job_page_query, is_page=True)
logger.info('获取成功')
return ResponseUtil.success(model_content=notice_page_query_result)
except Exception as e:
@@ -29,11 +29,11 @@ async def get_system_job_list(request: Request, job_page_query: JobPageQueryMode
@jobController.post("/job", dependencies=[Depends(CheckUserInterfaceAuth('monitor:job:add'))])
@log_decorator(title='定时任务管理', business_type=1)
async def add_system_job(request: Request, add_job: JobModel, query_db: Session = Depends(get_db), current_user: CurrentUserModel = Depends(LoginService.get_current_user)):
async def add_system_job(request: Request, add_job: JobModel, query_db: AsyncSession = Depends(get_db), current_user: CurrentUserModel = Depends(LoginService.get_current_user)):
try:
add_job.create_by = current_user.user.user_name
add_job.update_by = current_user.user.user_name
add_job_result = JobService.add_job_services(query_db, add_job)
add_job_result = await JobService.add_job_services(query_db, add_job)
if add_job_result.is_success:
logger.info(add_job_result.message)
return ResponseUtil.success(msg=add_job_result.message)
@@ -47,11 +47,11 @@ async def add_system_job(request: Request, add_job: JobModel, query_db: Session
@jobController.put("/job", dependencies=[Depends(CheckUserInterfaceAuth('monitor:job:edit'))])
@log_decorator(title='定时任务管理', business_type=2)
async def edit_system_job(request: Request, edit_job: EditJobModel, query_db: Session = Depends(get_db), current_user: CurrentUserModel = Depends(LoginService.get_current_user)):
async def edit_system_job(request: Request, edit_job: EditJobModel, query_db: AsyncSession = Depends(get_db), current_user: CurrentUserModel = Depends(LoginService.get_current_user)):
try:
edit_job.update_by = current_user.user.user_name
edit_job.update_time = datetime.now()
edit_job_result = JobService.edit_job_services(query_db, edit_job)
edit_job_result = await JobService.edit_job_services(query_db, edit_job)
if edit_job_result.is_success:
logger.info(edit_job_result.message)
return ResponseUtil.success(msg=edit_job_result.message)
@@ -65,12 +65,12 @@ async def edit_system_job(request: Request, edit_job: EditJobModel, query_db: Se
@jobController.put("/job/changeStatus", dependencies=[Depends(CheckUserInterfaceAuth('monitor:job:changeStatus'))])
@log_decorator(title='定时任务管理', business_type=2)
async def edit_system_job(request: Request, edit_job: EditJobModel, query_db: Session = Depends(get_db), current_user: CurrentUserModel = Depends(LoginService.get_current_user)):
async def edit_system_job(request: Request, edit_job: EditJobModel, query_db: AsyncSession = Depends(get_db), current_user: CurrentUserModel = Depends(LoginService.get_current_user)):
try:
edit_job.update_by = current_user.user.user_name
edit_job.update_time = datetime.now()
edit_job.type = 'status'
edit_job_result = JobService.edit_job_services(query_db, edit_job)
edit_job_result = await JobService.edit_job_services(query_db, edit_job)
if edit_job_result.is_success:
logger.info(edit_job_result.message)
return ResponseUtil.success(msg=edit_job_result.message)
@@ -84,9 +84,9 @@ async def edit_system_job(request: Request, edit_job: EditJobModel, query_db: Se
@jobController.put("/job/run", dependencies=[Depends(CheckUserInterfaceAuth('monitor:job:changeStatus'))])
@log_decorator(title='定时任务管理', business_type=2)
async def execute_system_job(request: Request, execute_job: JobModel, query_db: Session = Depends(get_db)):
async def execute_system_job(request: Request, execute_job: JobModel, query_db: AsyncSession = Depends(get_db)):
try:
execute_job_result = JobService.execute_job_once_services(query_db, execute_job)
execute_job_result = await JobService.execute_job_once_services(query_db, execute_job)
if execute_job_result.is_success:
logger.info(execute_job_result.message)
return ResponseUtil.success(msg=execute_job_result.message)
@@ -100,10 +100,10 @@ async def execute_system_job(request: Request, execute_job: JobModel, query_db:
@jobController.delete("/job/{job_ids}", dependencies=[Depends(CheckUserInterfaceAuth('monitor:job:remove'))])
@log_decorator(title='定时任务管理', business_type=3)
async def delete_system_job(request: Request, job_ids: str, query_db: Session = Depends(get_db)):
async def delete_system_job(request: Request, job_ids: str, query_db: AsyncSession = Depends(get_db)):
try:
delete_job = DeleteJobModel(jobIds=job_ids)
delete_job_result = JobService.delete_job_services(query_db, delete_job)
delete_job_result = await JobService.delete_job_services(query_db, delete_job)
if delete_job_result.is_success:
logger.info(delete_job_result.message)
return ResponseUtil.success(msg=delete_job_result.message)
@@ -116,9 +116,9 @@ async def delete_system_job(request: Request, job_ids: str, query_db: Session =
@jobController.get("/job/{job_id}", response_model=JobModel, dependencies=[Depends(CheckUserInterfaceAuth('monitor:job:query'))])
async def query_detail_system_job(request: Request, job_id: int, query_db: Session = Depends(get_db)):
async def query_detail_system_job(request: Request, job_id: int, query_db: AsyncSession = Depends(get_db)):
try:
job_detail_result = JobService.job_detail_services(query_db, job_id)
job_detail_result = await JobService.job_detail_services(query_db, job_id)
logger.info(f'获取job_id为{job_id}的信息成功')
return ResponseUtil.success(data=job_detail_result)
except Exception as e:
@@ -128,10 +128,10 @@ async def query_detail_system_job(request: Request, job_id: int, query_db: Sessi
@jobController.post("/job/export", dependencies=[Depends(CheckUserInterfaceAuth('monitor:job:export'))])
@log_decorator(title='定时任务管理', business_type=5)
async def export_system_job_list(request: Request, job_page_query: JobPageQueryModel = Depends(JobPageQueryModel.as_form), query_db: Session = Depends(get_db)):
async def export_system_job_list(request: Request, job_page_query: JobPageQueryModel = Depends(JobPageQueryModel.as_form), query_db: AsyncSession = Depends(get_db)):
try:
# 获取全量数据
job_query_result = JobService.get_job_list_services(query_db, job_page_query, is_page=False)
job_query_result = await JobService.get_job_list_services(query_db, job_page_query, is_page=False)
job_export_result = await JobService.export_job_list_services(request, job_query_result)
logger.info('导出成功')
return ResponseUtil.streaming(data=bytes2file_response(job_export_result))
@@ -141,10 +141,10 @@ async def export_system_job_list(request: Request, job_page_query: JobPageQueryM
@jobController.get("/jobLog/list", response_model=PageResponseModel, dependencies=[Depends(CheckUserInterfaceAuth('monitor:job:list'))])
async def get_system_job_log_list(request: Request, job_log_page_query: JobLogPageQueryModel = Depends(JobLogPageQueryModel.as_query), query_db: Session = Depends(get_db)):
async def get_system_job_log_list(request: Request, job_log_page_query: JobLogPageQueryModel = Depends(JobLogPageQueryModel.as_query), query_db: AsyncSession = Depends(get_db)):
try:
# 获取分页数据
job_log_page_query_result = JobLogService.get_job_log_list_services(query_db, job_log_page_query, is_page=True)
job_log_page_query_result = await JobLogService.get_job_log_list_services(query_db, job_log_page_query, is_page=True)
logger.info('获取成功')
return ResponseUtil.success(model_content=job_log_page_query_result)
except Exception as e:
@@ -154,10 +154,10 @@ async def get_system_job_log_list(request: Request, job_log_page_query: JobLogPa
@jobController.delete("/jobLog/{job_log_ids}", dependencies=[Depends(CheckUserInterfaceAuth('monitor:job:remove'))])
@log_decorator(title='定时任务日志管理', business_type=3)
async def delete_system_job_log(request: Request, job_log_ids: str, query_db: Session = Depends(get_db)):
async def delete_system_job_log(request: Request, job_log_ids: str, query_db: AsyncSession = Depends(get_db)):
try:
delete_job_log = DeleteJobLogModel(jobLogIds=job_log_ids)
delete_job_log_result = JobLogService.delete_job_log_services(query_db, delete_job_log)
delete_job_log_result = await JobLogService.delete_job_log_services(query_db, delete_job_log)
if delete_job_log_result.is_success:
logger.info(delete_job_log_result.message)
return ResponseUtil.success(msg=delete_job_log_result.message)
@@ -169,11 +169,11 @@ async def delete_system_job_log(request: Request, job_log_ids: str, query_db: Se
return ResponseUtil.error(msg=str(e))
@jobController.post("/jobLog/clean", dependencies=[Depends(CheckUserInterfaceAuth('monitor:job:remove'))])
@jobController.delete("/jobLog/clean", dependencies=[Depends(CheckUserInterfaceAuth('monitor:job:remove'))])
@log_decorator(title='定时任务日志管理', business_type=9)
async def clear_system_job_log(request: Request, query_db: Session = Depends(get_db)):
async def clear_system_job_log(request: Request, query_db: AsyncSession = Depends(get_db)):
try:
clear_job_log_result = JobLogService.clear_job_log_services(query_db)
clear_job_log_result = await JobLogService.clear_job_log_services(query_db)
if clear_job_log_result.is_success:
logger.info(clear_job_log_result.message)
return ResponseUtil.success(msg=clear_job_log_result.message)
@@ -187,10 +187,10 @@ async def clear_system_job_log(request: Request, query_db: Session = Depends(get
@jobController.post("/jobLog/export", dependencies=[Depends(CheckUserInterfaceAuth('monitor:job:export'))])
@log_decorator(title='定时任务日志管理', business_type=5)
async def export_system_job_log_list(request: Request, job_log_page_query: JobLogPageQueryModel = Depends(JobLogPageQueryModel.as_form), query_db: Session = Depends(get_db)):
async def export_system_job_log_list(request: Request, job_log_page_query: JobLogPageQueryModel = Depends(JobLogPageQueryModel.as_form), query_db: AsyncSession = Depends(get_db)):
try:
# 获取全量数据
job_log_query_result = JobLogService.get_job_log_list_services(query_db, job_log_page_query, is_page=False)
job_log_query_result = await JobLogService.get_job_log_list_services(query_db, job_log_page_query, is_page=False)
job_log_export_result = await JobLogService.export_job_log_list_services(request, job_log_query_result)
logger.info('导出成功')
return ResponseUtil.streaming(data=bytes2file_response(job_log_export_result))

36
ruoyi-fastapi-backend/module_admin/controller/log_controller.py
View File

@@ -15,10 +15,10 @@ logController = APIRouter(prefix='/monitor', dependencies=[Depends(LoginService.
@logController.get("/operlog/list", response_model=PageResponseModel, dependencies=[Depends(CheckUserInterfaceAuth('monitor:operlog:list'))])
async def get_system_operation_log_list(request: Request, operation_log_page_query: OperLogPageQueryModel = Depends(OperLogPageQueryModel.as_query), query_db: Session = Depends(get_db)):
async def get_system_operation_log_list(request: Request, operation_log_page_query: OperLogPageQueryModel = Depends(OperLogPageQueryModel.as_query), query_db: AsyncSession = Depends(get_db)):
try:
# 获取分页数据
operation_log_page_query_result = OperationLogService.get_operation_log_list_services(query_db, operation_log_page_query, is_page=True)
operation_log_page_query_result = await OperationLogService.get_operation_log_list_services(query_db, operation_log_page_query, is_page=True)
logger.info('获取成功')
return ResponseUtil.success(model_content=operation_log_page_query_result)
except Exception as e:
@@ -28,9 +28,9 @@ async def get_system_operation_log_list(request: Request, operation_log_page_que
@logController.delete("/operlog/clean", dependencies=[Depends(CheckUserInterfaceAuth('monitor:operlog:remove'))])
@log_decorator(title='操作日志管理', business_type=9)
async def clear_system_operation_log(request: Request, query_db: Session = Depends(get_db)):
async def clear_system_operation_log(request: Request, query_db: AsyncSession = Depends(get_db)):
try:
clear_operation_log_result = OperationLogService.clear_operation_log_services(query_db)
clear_operation_log_result = await OperationLogService.clear_operation_log_services(query_db)
if clear_operation_log_result.is_success:
logger.info(clear_operation_log_result.message)
return ResponseUtil.success(msg=clear_operation_log_result.message)
@@ -44,10 +44,10 @@ async def clear_system_operation_log(request: Request, query_db: Session = Depen
@logController.delete("/operlog/{oper_ids}", dependencies=[Depends(CheckUserInterfaceAuth('monitor:operlog:remove'))])
@log_decorator(title='操作日志管理', business_type=3)
async def delete_system_operation_log(request: Request, oper_ids: str, query_db: Session = Depends(get_db)):
async def delete_system_operation_log(request: Request, oper_ids: str, query_db: AsyncSession = Depends(get_db)):
try:
delete_operation_log = DeleteOperLogModel(operIds=oper_ids)
delete_operation_log_result = OperationLogService.delete_operation_log_services(query_db, delete_operation_log)
delete_operation_log_result = await OperationLogService.delete_operation_log_services(query_db, delete_operation_log)
if delete_operation_log_result.is_success:
logger.info(delete_operation_log_result.message)
return ResponseUtil.success(msg=delete_operation_log_result.message)
@@ -61,10 +61,10 @@ async def delete_system_operation_log(request: Request, oper_ids: str, query_db:
@logController.post("/operlog/export", dependencies=[Depends(CheckUserInterfaceAuth('monitor:operlog:export'))])
@log_decorator(title='操作日志管理', business_type=5)
async def export_system_operation_log_list(request: Request, operation_log_page_query: OperLogPageQueryModel = Depends(OperLogPageQueryModel.as_form), query_db: Session = Depends(get_db)):
async def export_system_operation_log_list(request: Request, operation_log_page_query: OperLogPageQueryModel = Depends(OperLogPageQueryModel.as_form), query_db: AsyncSession = Depends(get_db)):
try:
# 获取全量数据
operation_log_query_result = OperationLogService.get_operation_log_list_services(query_db, operation_log_page_query, is_page=False)
operation_log_query_result = await OperationLogService.get_operation_log_list_services(query_db, operation_log_page_query, is_page=False)
operation_log_export_result = await OperationLogService.export_operation_log_list_services(request, operation_log_query_result)
logger.info('导出成功')
return ResponseUtil.streaming(data=bytes2file_response(operation_log_export_result))
@@ -74,10 +74,10 @@ async def export_system_operation_log_list(request: Request, operation_log_page_
@logController.get("/logininfor/list", response_model=PageResponseModel, dependencies=[Depends(CheckUserInterfaceAuth('monitor:logininfor:list'))])
async def get_system_login_log_list(request: Request, login_log_page_query: LoginLogPageQueryModel = Depends(LoginLogPageQueryModel.as_query), query_db: Session = Depends(get_db)):
async def get_system_login_log_list(request: Request, login_log_page_query: LoginLogPageQueryModel = Depends(LoginLogPageQueryModel.as_query), query_db: AsyncSession = Depends(get_db)):
try:
# 获取分页数据
login_log_page_query_result = LoginLogService.get_login_log_list_services(query_db, login_log_page_query, is_page=True)
login_log_page_query_result = await LoginLogService.get_login_log_list_services(query_db, login_log_page_query, is_page=True)
logger.info('获取成功')
return ResponseUtil.success(model_content=login_log_page_query_result)
except Exception as e:
@@ -87,9 +87,9 @@ async def get_system_login_log_list(request: Request, login_log_page_query: Logi
@logController.delete("/logininfor/clean", dependencies=[Depends(CheckUserInterfaceAuth('monitor:logininfor:remove'))])
@log_decorator(title='登录日志管理', business_type=9)
async def clear_system_login_log(request: Request, query_db: Session = Depends(get_db)):
async def clear_system_login_log(request: Request, query_db: AsyncSession = Depends(get_db)):
try:
clear_login_log_result = LoginLogService.clear_login_log_services(query_db)
clear_login_log_result = await LoginLogService.clear_login_log_services(query_db)
if clear_login_log_result.is_success:
logger.info(clear_login_log_result.message)
return ResponseUtil.success(msg=clear_login_log_result.message)
@@ -103,10 +103,10 @@ async def clear_system_login_log(request: Request, query_db: Session = Depends(g
@logController.delete("/logininfor/{info_ids}", dependencies=[Depends(CheckUserInterfaceAuth('monitor:logininfor:remove'))])
@log_decorator(title='登录日志管理', business_type=3)
async def delete_system_login_log(request: Request, info_ids: str, query_db: Session = Depends(get_db)):
async def delete_system_login_log(request: Request, info_ids: str, query_db: AsyncSession = Depends(get_db)):
try:
delete_login_log = DeleteLoginLogModel(infoIds=info_ids)
delete_login_log_result = LoginLogService.delete_login_log_services(query_db, delete_login_log)
delete_login_log_result = await LoginLogService.delete_login_log_services(query_db, delete_login_log)
if delete_login_log_result.is_success:
logger.info(delete_login_log_result.message)
return ResponseUtil.success(msg=delete_login_log_result.message)
@@ -120,7 +120,7 @@ async def delete_system_login_log(request: Request, info_ids: str, query_db: Ses
@logController.get("/logininfor/unlock/{user_name}", dependencies=[Depends(CheckUserInterfaceAuth('monitor:logininfor:unlock'))])
@log_decorator(title='登录日志管理', business_type=0)
async def clear_system_login_log(request: Request, user_name: str, query_db: Session = Depends(get_db)):
async def clear_system_login_log(request: Request, user_name: str, query_db: AsyncSession = Depends(get_db)):
try:
unlock_user = UnlockUser(userName=user_name)
unlock_user_result = await LoginLogService.unlock_user_services(request, unlock_user)
@@ -137,11 +137,11 @@ async def clear_system_login_log(request: Request, user_name: str, query_db: Ses
@logController.post("/logininfor/export", dependencies=[Depends(CheckUserInterfaceAuth('monitor:logininfor:export'))])
@log_decorator(title='登录日志管理', business_type=5)
async def export_system_login_log_list(request: Request, login_log_page_query: LoginLogPageQueryModel = Depends(LoginLogPageQueryModel.as_form), query_db: Session = Depends(get_db)):
async def export_system_login_log_list(request: Request, login_log_page_query: LoginLogPageQueryModel = Depends(LoginLogPageQueryModel.as_form), query_db: AsyncSession = Depends(get_db)):
try:
# 获取全量数据
login_log_query_result = LoginLogService.get_login_log_list_services(query_db, login_log_page_query, is_page=False)
login_log_export_result = LoginLogService.export_login_log_list_services(login_log_query_result)
login_log_query_result = await LoginLogService.get_login_log_list_services(query_db, login_log_page_query, is_page=False)
login_log_export_result = await LoginLogService.export_login_log_list_services(login_log_query_result)
logger.info('导出成功')
return ResponseUtil.streaming(data=bytes2file_response(login_log_export_result))
except Exception as e:

14
ruoyi-fastapi-backend/module_admin/controller/login_controller.py
View File

@@ -14,7 +14,7 @@ loginController = APIRouter()
@loginController.post("/login", response_model=Token)
@log_decorator(title='用户登录', business_type=0, log_type='login')
async def login(request: Request, form_data: CustomOAuth2PasswordRequestForm = Depends(), query_db: Session = Depends(get_db)):
async def login(request: Request, form_data: CustomOAuth2PasswordRequestForm = Depends(), query_db: AsyncSession = Depends(get_db)):
captcha_enabled = True if await request.app.state.redis.get(f"{RedisInitKeyConfig.SYS_CONFIG.get('key')}:sys.account.captchaEnabled") == 'true' else False
user = UserLogin(
userName=form_data.username,
@@ -31,7 +31,7 @@ async def login(request: Request, form_data: CustomOAuth2PasswordRequestForm = D
try:
access_token_expires = timedelta(minutes=JwtConfig.jwt_expire_minutes)
session_id = str(uuid.uuid4())
access_token = LoginService.create_access_token(
access_token = await LoginService.create_access_token(
data={
"user_id": str(result[0].user_id),
"user_name": result[0].user_name,
@@ -48,7 +48,7 @@ async def login(request: Request, form_data: CustomOAuth2PasswordRequestForm = D
# 此方法可实现同一账号同一时间只能登录一次
await request.app.state.redis.set(f"{RedisInitKeyConfig.ACCESS_TOKEN.get('key')}:{result[0].user_id}", access_token,
ex=timedelta(minutes=JwtConfig.jwt_redis_expire_minutes))
UserService.edit_user_services(query_db, EditUserModel(userId=result[0].user_id, loginDate=datetime.now(), type='status'))
await UserService.edit_user_services(query_db, EditUserModel(userId=result[0].user_id, loginDate=datetime.now(), type='status'))
logger.info('登录成功')
# 判断请求是否来自于api文档，如果是返回指定格式的结果，用于修复api文档认证成功后token显示undefined的bug
request_from_swagger = request.headers.get('referer').endswith('docs') if request.headers.get('referer') else False
@@ -75,7 +75,7 @@ async def get_login_user_info(request: Request, current_user: CurrentUserModel =
@loginController.get("/getRouters")
async def get_login_user_routers(request: Request, current_user: CurrentUserModel = Depends(LoginService.get_current_user), query_db: Session = Depends(get_db)):
async def get_login_user_routers(request: Request, current_user: CurrentUserModel = Depends(LoginService.get_current_user), query_db: AsyncSession = Depends(get_db)):
try:
logger.info('获取成功')
user_routers = await LoginService.get_current_user_routers(current_user.user.user_id, query_db)
@@ -86,7 +86,7 @@ async def get_login_user_routers(request: Request, current_user: CurrentUserMode
@loginController.post("/register", response_model=CrudResponseModel)
async def register_user(request: Request, user_register: UserRegister, query_db: Session = Depends(get_db)):
async def register_user(request: Request, user_register: UserRegister, query_db: AsyncSession = Depends(get_db)):
try:
user_register_result = await LoginService.register_user_services(request, query_db, user_register)
if user_register_result.is_success:
@@ -101,7 +101,7 @@ async def register_user(request: Request, user_register: UserRegister, query_db:
# @loginController.post("/getSmsCode", response_model=SmsCode)
# async def get_sms_code(request: Request, user: ResetUserModel, query_db: Session = Depends(get_db)):
# async def get_sms_code(request: Request, user: ResetUserModel, query_db: AsyncSession = Depends(get_db)):
# try:
# sms_result = await LoginService.get_sms_code_services(request, query_db, user)
# if sms_result.is_success:
@@ -116,7 +116,7 @@ async def register_user(request: Request, user_register: UserRegister, query_db:
#
#
# @loginController.post("/forgetPwd", response_model=CrudResponseModel)
# async def forget_user_pwd(request: Request, forget_user: ResetUserModel, query_db: Session = Depends(get_db)):
# async def forget_user_pwd(request: Request, forget_user: ResetUserModel, query_db: AsyncSession = Depends(get_db)):
# try:
# forget_user_result = await LoginService.forget_user_services(request, query_db, forget_user)
# if forget_user_result.is_success:

28
ruoyi-fastapi-backend/module_admin/controller/menu_controller.py
View File

@@ -13,9 +13,9 @@ menuController = APIRouter(prefix='/system/menu', dependencies=[Depends(LoginSer
@menuController.get("/treeselect")
async def get_system_menu_tree(request: Request, query_db: Session = Depends(get_db), current_user: CurrentUserModel = Depends(LoginService.get_current_user)):
async def get_system_menu_tree(request: Request, query_db: AsyncSession = Depends(get_db), current_user: CurrentUserModel = Depends(LoginService.get_current_user)):
try:
menu_query_result = MenuService.get_menu_tree_services(query_db, current_user)
menu_query_result = await MenuService.get_menu_tree_services(query_db, current_user)
logger.info('获取成功')
return ResponseUtil.success(data=menu_query_result)
except Exception as e:
@@ -24,9 +24,9 @@ async def get_system_menu_tree(request: Request, query_db: Session = Depends(get
@menuController.get("/roleMenuTreeselect/{role_id}")
async def get_system_role_menu_tree(request: Request, role_id: int, query_db: Session = Depends(get_db), current_user: CurrentUserModel = Depends(LoginService.get_current_user)):
async def get_system_role_menu_tree(request: Request, role_id: int, query_db: AsyncSession = Depends(get_db), current_user: CurrentUserModel = Depends(LoginService.get_current_user)):
try:
role_menu_query_result = MenuService.get_role_menu_tree_services(query_db, role_id, current_user)
role_menu_query_result = await MenuService.get_role_menu_tree_services(query_db, role_id, current_user)
logger.info('获取成功')
return ResponseUtil.success(model_content=role_menu_query_result)
except Exception as e:
@@ -35,9 +35,9 @@ async def get_system_role_menu_tree(request: Request, role_id: int, query_db: Se
@menuController.get("/list", response_model=List[MenuModel], dependencies=[Depends(CheckUserInterfaceAuth('system:menu:list'))])
async def get_system_menu_list(request: Request, menu_query: MenuQueryModel = Depends(MenuQueryModel.as_query), query_db: Session = Depends(get_db), current_user: CurrentUserModel = Depends(LoginService.get_current_user)):
async def get_system_menu_list(request: Request, menu_query: MenuQueryModel = Depends(MenuQueryModel.as_query), query_db: AsyncSession = Depends(get_db), current_user: CurrentUserModel = Depends(LoginService.get_current_user)):
try:
menu_query_result = MenuService.get_menu_list_services(query_db, menu_query, current_user)
menu_query_result = await MenuService.get_menu_list_services(query_db, menu_query, current_user)
logger.info('获取成功')
return ResponseUtil.success(data=menu_query_result)
except Exception as e:
@@ -47,11 +47,11 @@ async def get_system_menu_list(request: Request, menu_query: MenuQueryModel = De
@menuController.post("", dependencies=[Depends(CheckUserInterfaceAuth('system:menu:add'))])
@log_decorator(title='菜单管理', business_type=1)
async def add_system_menu(request: Request, add_menu: MenuModel, query_db: Session = Depends(get_db), current_user: CurrentUserModel = Depends(LoginService.get_current_user)):
async def add_system_menu(request: Request, add_menu: MenuModel, query_db: AsyncSession = Depends(get_db), current_user: CurrentUserModel = Depends(LoginService.get_current_user)):
try:
add_menu.create_by = current_user.user.user_name
add_menu.update_by = current_user.user.user_name
add_menu_result = MenuService.add_menu_services(query_db, add_menu)
add_menu_result = await MenuService.add_menu_services(query_db, add_menu)
if add_menu_result.is_success:
logger.info(add_menu_result.message)
return ResponseUtil.success(msg=add_menu_result.message)
@@ -65,11 +65,11 @@ async def add_system_menu(request: Request, add_menu: MenuModel, query_db: Sessi
@menuController.put("", dependencies=[Depends(CheckUserInterfaceAuth('system:menu:edit'))])
@log_decorator(title='菜单管理', business_type=2)
async def edit_system_menu(request: Request, edit_menu: MenuModel, query_db: Session = Depends(get_db), current_user: CurrentUserModel = Depends(LoginService.get_current_user)):
async def edit_system_menu(request: Request, edit_menu: MenuModel, query_db: AsyncSession = Depends(get_db), current_user: CurrentUserModel = Depends(LoginService.get_current_user)):
try:
edit_menu.update_by = current_user.user.user_name
edit_menu.update_time = datetime.now()
edit_menu_result = MenuService.edit_menu_services(query_db, edit_menu)
edit_menu_result = await MenuService.edit_menu_services(query_db, edit_menu)
if edit_menu_result.is_success:
logger.info(edit_menu_result.message)
return ResponseUtil.success(msg=edit_menu_result.message)
@@ -83,10 +83,10 @@ async def edit_system_menu(request: Request, edit_menu: MenuModel, query_db: Ses
@menuController.delete("/{menu_ids}", dependencies=[Depends(CheckUserInterfaceAuth('system:menu:remove'))])
@log_decorator(title='菜单管理', business_type=3)
async def delete_system_menu(request: Request, menu_ids: str, query_db: Session = Depends(get_db)):
async def delete_system_menu(request: Request, menu_ids: str, query_db: AsyncSession = Depends(get_db)):
try:
delete_menu = DeleteMenuModel(menuIds=menu_ids)
delete_menu_result = MenuService.delete_menu_services(query_db, delete_menu)
delete_menu_result = await MenuService.delete_menu_services(query_db, delete_menu)
if delete_menu_result.is_success:
logger.info(delete_menu_result.message)
return ResponseUtil.success(msg=delete_menu_result.message)
@@ -99,9 +99,9 @@ async def delete_system_menu(request: Request, menu_ids: str, query_db: Session
@menuController.get("/{menu_id}", response_model=MenuModel, dependencies=[Depends(CheckUserInterfaceAuth('system:menu:query'))])
async def query_detail_system_menu(request: Request, menu_id: int, query_db: Session = Depends(get_db)):
async def query_detail_system_menu(request: Request, menu_id: int, query_db: AsyncSession = Depends(get_db)):
try:
menu_detail_result = MenuService.menu_detail_services(query_db, menu_id)
menu_detail_result = await MenuService.menu_detail_services(query_db, menu_id)
logger.info(f'获取menu_id为{menu_id}的信息成功')
return ResponseUtil.success(data=menu_detail_result)
except Exception as e:

20
ruoyi-fastapi-backend/module_admin/controller/notice_controller.py
View File

@@ -14,10 +14,10 @@ noticeController = APIRouter(prefix='/system/notice', dependencies=[Depends(Logi
@noticeController.get("/list", response_model=PageResponseModel, dependencies=[Depends(CheckUserInterfaceAuth('system:notice:list'))])
async def get_system_notice_list(request: Request, notice_page_query: NoticePageQueryModel = Depends(NoticePageQueryModel.as_query), query_db: Session = Depends(get_db)):
async def get_system_notice_list(request: Request, notice_page_query: NoticePageQueryModel = Depends(NoticePageQueryModel.as_query), query_db: AsyncSession = Depends(get_db)):
try:
# 获取分页数据
notice_page_query_result = NoticeService.get_notice_list_services(query_db, notice_page_query, is_page=True)
notice_page_query_result = await NoticeService.get_notice_list_services(query_db, notice_page_query, is_page=True)
logger.info('获取成功')
return ResponseUtil.success(model_content=notice_page_query_result)
except Exception as e:
@@ -27,11 +27,11 @@ async def get_system_notice_list(request: Request, notice_page_query: NoticePage
@noticeController.post("", dependencies=[Depends(CheckUserInterfaceAuth('system:notice:add'))])
@log_decorator(title='通知公告管理', business_type=1)
async def add_system_notice(request: Request, add_notice: NoticeModel, query_db: Session = Depends(get_db), current_user: CurrentUserModel = Depends(LoginService.get_current_user)):
async def add_system_notice(request: Request, add_notice: NoticeModel, query_db: AsyncSession = Depends(get_db), current_user: CurrentUserModel = Depends(LoginService.get_current_user)):
try:
add_notice.create_by = current_user.user.user_name
add_notice.update_by = current_user.user.user_name
add_notice_result = NoticeService.add_notice_services(query_db, add_notice)
add_notice_result = await NoticeService.add_notice_services(query_db, add_notice)
if add_notice_result.is_success:
logger.info(add_notice_result.message)
return ResponseUtil.success(msg=add_notice_result.message)
@@ -45,11 +45,11 @@ async def add_system_notice(request: Request, add_notice: NoticeModel, query_db:
@noticeController.put("", dependencies=[Depends(CheckUserInterfaceAuth('system:notice:edit'))])
@log_decorator(title='通知公告管理', business_type=2)
async def edit_system_notice(request: Request, edit_notice: NoticeModel, query_db: Session = Depends(get_db), current_user: CurrentUserModel = Depends(LoginService.get_current_user)):
async def edit_system_notice(request: Request, edit_notice: NoticeModel, query_db: AsyncSession = Depends(get_db), current_user: CurrentUserModel = Depends(LoginService.get_current_user)):
try:
edit_notice.update_by = current_user.user.user_name
edit_notice.update_time = datetime.now()
edit_notice_result = NoticeService.edit_notice_services(query_db, edit_notice)
edit_notice_result = await NoticeService.edit_notice_services(query_db, edit_notice)
if edit_notice_result.is_success:
logger.info(edit_notice_result.message)
return ResponseUtil.success(msg=edit_notice_result.message)
@@ -63,10 +63,10 @@ async def edit_system_notice(request: Request, edit_notice: NoticeModel, query_d
@noticeController.delete("/{notice_ids}", dependencies=[Depends(CheckUserInterfaceAuth('system:notice:remove'))])
@log_decorator(title='通知公告管理', business_type=3)
async def delete_system_notice(request: Request, notice_ids: str, query_db: Session = Depends(get_db)):
async def delete_system_notice(request: Request, notice_ids: str, query_db: AsyncSession = Depends(get_db)):
try:
delete_notice = DeleteNoticeModel(noticeIds=notice_ids)
delete_notice_result = NoticeService.delete_notice_services(query_db, delete_notice)
delete_notice_result = await NoticeService.delete_notice_services(query_db, delete_notice)
if delete_notice_result.is_success:
logger.info(delete_notice_result.message)
return ResponseUtil.success(msg=delete_notice_result.message)
@@ -79,9 +79,9 @@ async def delete_system_notice(request: Request, notice_ids: str, query_db: Sess
@noticeController.get("/{notice_id}", response_model=NoticeModel, dependencies=[Depends(CheckUserInterfaceAuth('system:notice:query'))])
async def query_detail_system_post(request: Request, notice_id: int, query_db: Session = Depends(get_db)):
async def query_detail_system_post(request: Request, notice_id: int, query_db: AsyncSession = Depends(get_db)):
try:
notice_detail_result = NoticeService.notice_detail_services(query_db, notice_id)
notice_detail_result = await NoticeService.notice_detail_services(query_db, notice_id)
logger.info(f'获取notice_id为{notice_id}的信息成功')
return ResponseUtil.success(data=notice_detail_result)
except Exception as e:

4
ruoyi-fastapi-backend/module_admin/controller/online_controller.py
View File

@@ -1,7 +1,7 @@
from fastapi import APIRouter
from fastapi import Depends
from config.get_db import get_db
from module_admin.service.login_service import LoginService, Session
from module_admin.service.login_service import LoginService, AsyncSession
from module_admin.service.online_service import *
from utils.response_util import *
from utils.log_util import *
@@ -27,7 +27,7 @@ async def get_monitor_online_list(request: Request, online_page_query: OnlineQue
@onlineController.delete("/{token_ids}", dependencies=[Depends(CheckUserInterfaceAuth('monitor:online:forceLogout'))])
@log_decorator(title='在线用户', business_type=7)
async def delete_monitor_online(request: Request, token_ids: str, query_db: Session = Depends(get_db)):
async def delete_monitor_online(request: Request, token_ids: str, query_db: AsyncSession = Depends(get_db)):
try:
delete_online = DeleteOnlineModel(tokenIds=token_ids)
delete_online_result = await OnlineService.delete_online_services(request, delete_online)

26
ruoyi-fastapi-backend/module_admin/controller/post_controler.py
View File

@@ -16,10 +16,10 @@ postController = APIRouter(prefix='/system/post', dependencies=[Depends(LoginSer
@postController.get("/list", response_model=PageResponseModel, dependencies=[Depends(CheckUserInterfaceAuth('system:post:list'))])
async def get_system_post_list(request: Request, post_page_query: PostPageQueryModel = Depends(PostPageQueryModel.as_query), query_db: Session = Depends(get_db)):
async def get_system_post_list(request: Request, post_page_query: PostPageQueryModel = Depends(PostPageQueryModel.as_query), query_db: AsyncSession = Depends(get_db)):
try:
# 获取分页数据
post_page_query_result = PostService.get_post_list_services(query_db, post_page_query, is_page=True)
post_page_query_result = await PostService.get_post_list_services(query_db, post_page_query, is_page=True)
logger.info('获取成功')
return ResponseUtil.success(model_content=post_page_query_result)
except Exception as e:
@@ -29,11 +29,11 @@ async def get_system_post_list(request: Request, post_page_query: PostPageQueryM
@postController.post("", dependencies=[Depends(CheckUserInterfaceAuth('system:post:add'))])
@log_decorator(title='岗位管理', business_type=1)
async def add_system_post(request: Request, add_post: PostModel, query_db: Session = Depends(get_db), current_user: CurrentUserModel = Depends(LoginService.get_current_user)):
async def add_system_post(request: Request, add_post: PostModel, query_db: AsyncSession = Depends(get_db), current_user: CurrentUserModel = Depends(LoginService.get_current_user)):
try:
add_post.create_by = current_user.user.user_name
add_post.update_by = current_user.user.user_name
add_post_result = PostService.add_post_services(query_db, add_post)
add_post_result = await PostService.add_post_services(query_db, add_post)
if add_post_result.is_success:
logger.info(add_post_result.message)
return ResponseUtil.success(msg=add_post_result.message)
@@ -47,11 +47,11 @@ async def add_system_post(request: Request, add_post: PostModel, query_db: Sessi
@postController.put("", dependencies=[Depends(CheckUserInterfaceAuth('system:post:edit'))])
@log_decorator(title='岗位管理', business_type=2)
async def edit_system_post(request: Request, edit_post: PostModel, query_db: Session = Depends(get_db), current_user: CurrentUserModel = Depends(LoginService.get_current_user)):
async def edit_system_post(request: Request, edit_post: PostModel, query_db: AsyncSession = Depends(get_db), current_user: CurrentUserModel = Depends(LoginService.get_current_user)):
try:
edit_post.update_by = current_user.user.user_name
edit_post.update_time = datetime.now()
edit_post_result = PostService.edit_post_services(query_db, edit_post)
edit_post_result = await PostService.edit_post_services(query_db, edit_post)
if edit_post_result.is_success:
logger.info(edit_post_result.message)
return ResponseUtil.success(msg=edit_post_result.message)
@@ -65,10 +65,10 @@ async def edit_system_post(request: Request, edit_post: PostModel, query_db: Ses
@postController.delete("/{post_ids}", dependencies=[Depends(CheckUserInterfaceAuth('system:post:remove'))])
@log_decorator(title='岗位管理', business_type=3)
async def delete_system_post(request: Request, post_ids: str, query_db: Session = Depends(get_db)):
async def delete_system_post(request: Request, post_ids: str, query_db: AsyncSession = Depends(get_db)):
try:
delete_post = DeletePostModel(postIds=post_ids)
delete_post_result = PostService.delete_post_services(query_db, delete_post)
delete_post_result = await PostService.delete_post_services(query_db, delete_post)
if delete_post_result.is_success:
logger.info(delete_post_result.message)
return ResponseUtil.success(msg=delete_post_result.message)
@@ -81,9 +81,9 @@ async def delete_system_post(request: Request, post_ids: str, query_db: Session
@postController.get("/{post_id}", response_model=PostModel, dependencies=[Depends(CheckUserInterfaceAuth('system:post:query'))])
async def query_detail_system_post(request: Request, post_id: int, query_db: Session = Depends(get_db)):
async def query_detail_system_post(request: Request, post_id: int, query_db: AsyncSession = Depends(get_db)):
try:
post_detail_result = PostService.post_detail_services(query_db, post_id)
post_detail_result = await PostService.post_detail_services(query_db, post_id)
logger.info(f'获取post_id为{post_id}的信息成功')
return ResponseUtil.success(data=post_detail_result)
except Exception as e:
@@ -93,11 +93,11 @@ async def query_detail_system_post(request: Request, post_id: int, query_db: Ses
@postController.post("/export", dependencies=[Depends(CheckUserInterfaceAuth('system:post:export'))])
@log_decorator(title='岗位管理', business_type=5)
async def export_system_post_list(request: Request, post_page_query: PostPageQueryModel = Depends(PostPageQueryModel.as_form), query_db: Session = Depends(get_db)):
async def export_system_post_list(request: Request, post_page_query: PostPageQueryModel = Depends(PostPageQueryModel.as_form), query_db: AsyncSession = Depends(get_db)):
try:
# 获取全量数据
post_query_result = PostService.get_post_list_services(query_db, post_page_query, is_page=False)
post_export_result = PostService.export_post_list_services(post_query_result)
post_query_result = await PostService.get_post_list_services(query_db, post_page_query, is_page=False)
post_export_result = await PostService.export_post_list_services(post_query_result)
logger.info('导出成功')
return ResponseUtil.streaming(data=bytes2file_response(post_export_result))
except Exception as e:

60
ruoyi-fastapi-backend/module_admin/controller/role_controller.py
View File

@@ -18,10 +18,10 @@ roleController = APIRouter(prefix='/system/role', dependencies=[Depends(LoginSer
@roleController.get("/deptTree/{role_id}", dependencies=[Depends(CheckUserInterfaceAuth('system:role:query'))])
async def get_system_role_dept_tree(request: Request, role_id: int, query_db: Session = Depends(get_db), data_scope_sql: str = Depends(GetDataScope('SysDept'))):
async def get_system_role_dept_tree(request: Request, role_id: int, query_db: AsyncSession = Depends(get_db), data_scope_sql: str = Depends(GetDataScope('SysDept'))):
try:
dept_query_result = DeptService.get_dept_tree_services(query_db, DeptModel(**{}), data_scope_sql)
role_dept_query_result = RoleService.get_role_dept_tree_services(query_db, role_id)
dept_query_result = await DeptService.get_dept_tree_services(query_db, DeptModel(**{}), data_scope_sql)
role_dept_query_result = await RoleService.get_role_dept_tree_services(query_db, role_id)
role_dept_query_result.depts = dept_query_result
logger.info('获取成功')
return ResponseUtil.success(model_content=role_dept_query_result)
@@ -31,9 +31,9 @@ async def get_system_role_dept_tree(request: Request, role_id: int, query_db: Se
@roleController.get("/list", response_model=PageResponseModel, dependencies=[Depends(CheckUserInterfaceAuth('system:role:list'))])
async def get_system_role_list(request: Request, role_page_query: RolePageQueryModel = Depends(RolePageQueryModel.as_query), query_db: Session = Depends(get_db)):
async def get_system_role_list(request: Request, role_page_query: RolePageQueryModel = Depends(RolePageQueryModel.as_query), query_db: AsyncSession = Depends(get_db)):
try:
role_page_query_result = RoleService.get_role_list_services(query_db, role_page_query, is_page=True)
role_page_query_result = await RoleService.get_role_list_services(query_db, role_page_query, is_page=True)
logger.info('获取成功')
return ResponseUtil.success(model_content=role_page_query_result)
except Exception as e:
@@ -43,11 +43,11 @@ async def get_system_role_list(request: Request, role_page_query: RolePageQueryM
@roleController.post("", dependencies=[Depends(CheckUserInterfaceAuth('system:role:add'))])
@log_decorator(title='角色管理', business_type=1)
async def add_system_role(request: Request, add_role: AddRoleModel, query_db: Session = Depends(get_db), current_user: CurrentUserModel = Depends(LoginService.get_current_user)):
async def add_system_role(request: Request, add_role: AddRoleModel, query_db: AsyncSession = Depends(get_db), current_user: CurrentUserModel = Depends(LoginService.get_current_user)):
try:
add_role.create_by = current_user.user.user_name
add_role.update_by = current_user.user.user_name
add_role_result = RoleService.add_role_services(query_db, add_role)
add_role_result = await RoleService.add_role_services(query_db, add_role)
if add_role_result.is_success:
logger.info(add_role_result.message)
return ResponseUtil.success(msg=add_role_result.message)
@@ -61,11 +61,11 @@ async def add_system_role(request: Request, add_role: AddRoleModel, query_db: Se
@roleController.put("", dependencies=[Depends(CheckUserInterfaceAuth('system:role:edit'))])
@log_decorator(title='角色管理', business_type=2)
async def edit_system_role(request: Request, edit_role: AddRoleModel, query_db: Session = Depends(get_db), current_user: CurrentUserModel = Depends(LoginService.get_current_user)):
async def edit_system_role(request: Request, edit_role: AddRoleModel, query_db: AsyncSession = Depends(get_db), current_user: CurrentUserModel = Depends(LoginService.get_current_user)):
try:
edit_role.update_by = current_user.user.user_name
edit_role.update_time = datetime.now()
edit_role_result = RoleService.edit_role_services(query_db, edit_role)
edit_role_result = await RoleService.edit_role_services(query_db, edit_role)
if edit_role_result.is_success:
logger.info(edit_role_result.message)
return ResponseUtil.success(msg=edit_role_result.message)
@@ -79,11 +79,11 @@ async def edit_system_role(request: Request, edit_role: AddRoleModel, query_db:
@roleController.put("/dataScope", dependencies=[Depends(CheckUserInterfaceAuth('system:role:edit'))])
@log_decorator(title='角色管理', business_type=4)
async def edit_system_role_datascope(request: Request, role_data_scope: AddRoleModel, query_db: Session = Depends(get_db), current_user: CurrentUserModel = Depends(LoginService.get_current_user)):
async def edit_system_role_datascope(request: Request, role_data_scope: AddRoleModel, query_db: AsyncSession = Depends(get_db), current_user: CurrentUserModel = Depends(LoginService.get_current_user)):
try:
role_data_scope.update_by = current_user.user.user_name
role_data_scope.update_time = datetime.now()
role_data_scope_result = RoleService.role_datascope_services(query_db, role_data_scope)
role_data_scope_result = await RoleService.role_datascope_services(query_db, role_data_scope)
if role_data_scope_result.is_success:
logger.info(role_data_scope_result.message)
return ResponseUtil.success(msg=role_data_scope_result.message)
@@ -97,14 +97,14 @@ async def edit_system_role_datascope(request: Request, role_data_scope: AddRoleM
@roleController.delete("/{role_ids}", dependencies=[Depends(CheckUserInterfaceAuth('system:role:remove'))])
@log_decorator(title='角色管理', business_type=3)
async def delete_system_role(request: Request, role_ids: str, query_db: Session = Depends(get_db), current_user: CurrentUserModel = Depends(LoginService.get_current_user)):
async def delete_system_role(request: Request, role_ids: str, query_db: AsyncSession = Depends(get_db), current_user: CurrentUserModel = Depends(LoginService.get_current_user)):
try:
delete_role = DeleteRoleModel(
roleIds=role_ids,
updateBy=current_user.user.user_name,
updateTime=datetime.now()
)
delete_role_result = RoleService.delete_role_services(query_db, delete_role)
delete_role_result = await RoleService.delete_role_services(query_db, delete_role)
if delete_role_result.is_success:
logger.info(delete_role_result.message)
return ResponseUtil.success(msg=delete_role_result.message)
@@ -117,9 +117,9 @@ async def delete_system_role(request: Request, role_ids: str, query_db: Session
@roleController.get("/{role_id}", response_model=RoleModel, dependencies=[Depends(CheckUserInterfaceAuth('system:role:query'))])
async def query_detail_system_role(request: Request, role_id: int, query_db: Session = Depends(get_db)):
async def query_detail_system_role(request: Request, role_id: int, query_db: AsyncSession = Depends(get_db)):
try:
role_detail_result = RoleService.role_detail_services(query_db, role_id)
role_detail_result = await RoleService.role_detail_services(query_db, role_id)
logger.info(f'获取role_id为{role_id}的信息成功')
return ResponseUtil.success(data=role_detail_result.model_dump(by_alias=True))
except Exception as e:
@@ -129,11 +129,11 @@ async def query_detail_system_role(request: Request, role_id: int, query_db: Ses
@roleController.post("/export", dependencies=[Depends(CheckUserInterfaceAuth('system:role:export'))])
@log_decorator(title='角色管理', business_type=5)
async def export_system_role_list(request: Request, role_page_query: RolePageQueryModel = Depends(RolePageQueryModel.as_form), query_db: Session = Depends(get_db)):
async def export_system_role_list(request: Request, role_page_query: RolePageQueryModel = Depends(RolePageQueryModel.as_form), query_db: AsyncSession = Depends(get_db)):
try:
# 获取全量数据
role_query_result = RoleService.get_role_list_services(query_db, role_page_query, is_page=False)
role_export_result = RoleService.export_role_list_services(role_query_result)
role_query_result = await RoleService.get_role_list_services(query_db, role_page_query, is_page=False)
role_export_result = await RoleService.export_role_list_services(role_query_result)
logger.info('导出成功')
return ResponseUtil.streaming(data=bytes2file_response(role_export_result))
except Exception as e:
@@ -143,12 +143,12 @@ async def export_system_role_list(request: Request, role_page_query: RolePageQue
@roleController.put("/changeStatus", dependencies=[Depends(CheckUserInterfaceAuth('system:role:edit'))])
@log_decorator(title='角色管理', business_type=2)
async def reset_system_role_status(request: Request, edit_role: AddRoleModel, query_db: Session = Depends(get_db), current_user: CurrentUserModel = Depends(LoginService.get_current_user)):
async def reset_system_role_status(request: Request, edit_role: AddRoleModel, query_db: AsyncSession = Depends(get_db), current_user: CurrentUserModel = Depends(LoginService.get_current_user)):
try:
edit_role.update_by = current_user.user.user_name
edit_role.update_time = datetime.now()
edit_role.type = 'status'
edit_role_result = RoleService.edit_role_services(query_db, edit_role)
edit_role_result = await RoleService.edit_role_services(query_db, edit_role)
if edit_role_result.is_success:
logger.info(edit_role_result.message)
return ResponseUtil.success(msg=edit_role_result.message)
@@ -161,9 +161,9 @@ async def reset_system_role_status(request: Request, edit_role: AddRoleModel, qu
@roleController.get("/authUser/allocatedList", response_model=PageResponseModel, dependencies=[Depends(CheckUserInterfaceAuth('system:role:list'))])
async def get_system_allocated_user_list(request: Request, user_role: UserRolePageQueryModel = Depends(UserRolePageQueryModel.as_query), query_db: Session = Depends(get_db)):
async def get_system_allocated_user_list(request: Request, user_role: UserRolePageQueryModel = Depends(UserRolePageQueryModel.as_query), query_db: AsyncSession = Depends(get_db)):
try:
role_user_allocated_page_query_result = RoleService.get_role_user_allocated_list_services(query_db, user_role, is_page=True)
role_user_allocated_page_query_result = await RoleService.get_role_user_allocated_list_services(query_db, user_role, is_page=True)
logger.info('获取成功')
return ResponseUtil.success(model_content=role_user_allocated_page_query_result)
except Exception as e:
@@ -172,9 +172,9 @@ async def get_system_allocated_user_list(request: Request, user_role: UserRolePa
@roleController.get("/authUser/unallocatedList", response_model=PageResponseModel, dependencies=[Depends(CheckUserInterfaceAuth('system:role:list'))])
async def get_system_unallocated_user_list(request: Request, user_role: UserRolePageQueryModel = Depends(UserRolePageQueryModel.as_query), query_db: Session = Depends(get_db)):
async def get_system_unallocated_user_list(request: Request, user_role: UserRolePageQueryModel = Depends(UserRolePageQueryModel.as_query), query_db: AsyncSession = Depends(get_db)):
try:
role_user_unallocated_page_query_result = RoleService.get_role_user_unallocated_list_services(query_db, user_role, is_page=True)
role_user_unallocated_page_query_result = await RoleService.get_role_user_unallocated_list_services(query_db, user_role, is_page=True)
logger.info('获取成功')
return ResponseUtil.success(model_content=role_user_unallocated_page_query_result)
except Exception as e:
@@ -184,9 +184,9 @@ async def get_system_unallocated_user_list(request: Request, user_role: UserRole
@roleController.put("/authUser/selectAll", dependencies=[Depends(CheckUserInterfaceAuth('system:role:edit'))])
@log_decorator(title='角色管理', business_type=4)
async def add_system_role_user(request: Request, add_role_user: CrudUserRoleModel = Depends(CrudUserRoleModel.as_query), query_db: Session = Depends(get_db)):
async def add_system_role_user(request: Request, add_role_user: CrudUserRoleModel = Depends(CrudUserRoleModel.as_query), query_db: AsyncSession = Depends(get_db)):
try:
add_role_user_result = UserService.add_user_role_services(query_db, add_role_user)
add_role_user_result = await UserService.add_user_role_services(query_db, add_role_user)
if add_role_user_result.is_success:
logger.info(add_role_user_result.message)
return ResponseUtil.success(msg=add_role_user_result.message)
@@ -200,9 +200,9 @@ async def add_system_role_user(request: Request, add_role_user: CrudUserRoleMode
@roleController.put("/authUser/cancel", dependencies=[Depends(CheckUserInterfaceAuth('system:role:edit'))])
@log_decorator(title='角色管理', business_type=4)
async def cancel_system_role_user(request: Request, cancel_user_role: CrudUserRoleModel, query_db: Session = Depends(get_db)):
async def cancel_system_role_user(request: Request, cancel_user_role: CrudUserRoleModel, query_db: AsyncSession = Depends(get_db)):
try:
cancel_user_role_result = UserService.delete_user_role_services(query_db, cancel_user_role)
cancel_user_role_result = await UserService.delete_user_role_services(query_db, cancel_user_role)
if cancel_user_role_result.is_success:
logger.info(cancel_user_role_result.message)
return ResponseUtil.success(msg=cancel_user_role_result.message)
@@ -216,9 +216,9 @@ async def cancel_system_role_user(request: Request, cancel_user_role: CrudUserRo
@roleController.put("/authUser/cancelAll", dependencies=[Depends(CheckUserInterfaceAuth('system:role:edit'))])
@log_decorator(title='角色管理', business_type=4)
async def batch_cancel_system_role_user(request: Request, batch_cancel_user_role: CrudUserRoleModel = Depends(CrudUserRoleModel.as_query), query_db: Session = Depends(get_db)):
async def batch_cancel_system_role_user(request: Request, batch_cancel_user_role: CrudUserRoleModel = Depends(CrudUserRoleModel.as_query), query_db: AsyncSession = Depends(get_db)):
try:
batch_cancel_user_role_result = UserService.delete_user_role_services(query_db, batch_cancel_user_role)
batch_cancel_user_role_result = await UserService.delete_user_role_services(query_db, batch_cancel_user_role)
if batch_cancel_user_role_result.is_success:
logger.info(batch_cancel_user_role_result.message)
return ResponseUtil.success(msg=batch_cancel_user_role_result.message)

2
ruoyi-fastapi-backend/module_admin/controller/server_controller.py
View File

@@ -14,7 +14,7 @@ serverController = APIRouter(prefix='/monitor/server', dependencies=[Depends(Log
async def get_monitor_server_info(request: Request):
try:
# 获取全量数据
server_info_query_result = ServerService.get_server_monitor_info()
server_info_query_result = await ServerService.get_server_monitor_info()
logger.info('获取成功')
return ResponseUtil.success(data=server_info_query_result)
except Exception as e:

68
ruoyi-fastapi-backend/module_admin/controller/user_controller.py
View File

@@ -19,9 +19,9 @@ userController = APIRouter(prefix='/system/user', dependencies=[Depends(LoginSer
@userController.get("/deptTree", dependencies=[Depends(CheckUserInterfaceAuth('system:user:list'))])
async def get_system_dept_tree(request: Request, query_db: Session = Depends(get_db), data_scope_sql: str = Depends(GetDataScope('SysDept'))):
async def get_system_dept_tree(request: Request, query_db: AsyncSession = Depends(get_db), data_scope_sql: str = Depends(GetDataScope('SysDept'))):
try:
dept_query_result = DeptService.get_dept_tree_services(query_db, DeptModel(**{}), data_scope_sql)
dept_query_result = await DeptService.get_dept_tree_services(query_db, DeptModel(**{}), data_scope_sql)
logger.info('获取成功')
return ResponseUtil.success(data=dept_query_result)
except Exception as e:
@@ -30,10 +30,10 @@ async def get_system_dept_tree(request: Request, query_db: Session = Depends(get
@userController.get("/list", response_model=PageResponseModel, dependencies=[Depends(CheckUserInterfaceAuth('system:user:list'))])
async def get_system_user_list(request: Request, user_page_query: UserPageQueryModel = Depends(UserPageQueryModel.as_query), query_db: Session = Depends(get_db), data_scope_sql: str = Depends(GetDataScope('SysUser'))):
async def get_system_user_list(request: Request, user_page_query: UserPageQueryModel = Depends(UserPageQueryModel.as_query), query_db: AsyncSession = Depends(get_db), data_scope_sql: str = Depends(GetDataScope('SysUser'))):
try:
# 获取分页数据
user_page_query_result = UserService.get_user_list_services(query_db, user_page_query, data_scope_sql, is_page=True)
user_page_query_result = await UserService.get_user_list_services(query_db, user_page_query, data_scope_sql, is_page=True)
logger.info('获取成功')
return ResponseUtil.success(model_content=user_page_query_result)
except Exception as e:
@@ -43,12 +43,12 @@ async def get_system_user_list(request: Request, user_page_query: UserPageQueryM
@userController.post("", dependencies=[Depends(CheckUserInterfaceAuth('system:user:add'))])
@log_decorator(title='用户管理', business_type=1)
async def add_system_user(request: Request, add_user: AddUserModel, query_db: Session = Depends(get_db), current_user: CurrentUserModel = Depends(LoginService.get_current_user)):
async def add_system_user(request: Request, add_user: AddUserModel, query_db: AsyncSession = Depends(get_db), current_user: CurrentUserModel = Depends(LoginService.get_current_user)):
try:
add_user.password = PwdUtil.get_password_hash(add_user.password)
add_user.create_by = current_user.user.user_name
add_user.update_by = current_user.user.user_name
add_user_result = UserService.add_user_services(query_db, add_user)
add_user_result = await UserService.add_user_services(query_db, add_user)
if add_user_result.is_success:
logger.info(add_user_result.message)
return ResponseUtil.success(msg=add_user_result.message)
@@ -62,11 +62,11 @@ async def add_system_user(request: Request, add_user: AddUserModel, query_db: Se
@userController.put("", dependencies=[Depends(CheckUserInterfaceAuth('system:user:edit'))])
@log_decorator(title='用户管理', business_type=2)
async def edit_system_user(request: Request, edit_user: EditUserModel, query_db: Session = Depends(get_db), current_user: CurrentUserModel = Depends(LoginService.get_current_user)):
async def edit_system_user(request: Request, edit_user: EditUserModel, query_db: AsyncSession = Depends(get_db), current_user: CurrentUserModel = Depends(LoginService.get_current_user)):
try:
edit_user.update_by = current_user.user.user_name
edit_user.update_time = datetime.now()
edit_user_result = UserService.edit_user_services(query_db, edit_user)
edit_user_result = await UserService.edit_user_services(query_db, edit_user)
if edit_user_result.is_success:
logger.info(edit_user_result.message)
return ResponseUtil.success(msg=edit_user_result.message)
@@ -80,14 +80,14 @@ async def edit_system_user(request: Request, edit_user: EditUserModel, query_db:
@userController.delete("/{user_ids}", dependencies=[Depends(CheckUserInterfaceAuth('system:user:remove'))])
@log_decorator(title='用户管理', business_type=3)
async def delete_system_user(request: Request, user_ids: str, query_db: Session = Depends(get_db), current_user: CurrentUserModel = Depends(LoginService.get_current_user)):
async def delete_system_user(request: Request, user_ids: str, query_db: AsyncSession = Depends(get_db), current_user: CurrentUserModel = Depends(LoginService.get_current_user)):
try:
delete_user = DeleteUserModel(
userIds=user_ids,
updateBy=current_user.user.user_name,
updateTime=datetime.now()
)
delete_user_result = UserService.delete_user_services(query_db, delete_user)
delete_user_result = await UserService.delete_user_services(query_db, delete_user)
if delete_user_result.is_success:
logger.info(delete_user_result.message)
return ResponseUtil.success(msg=delete_user_result.message)
@@ -101,13 +101,13 @@ async def delete_system_user(request: Request, user_ids: str, query_db: Session
@userController.put("/resetPwd", dependencies=[Depends(CheckUserInterfaceAuth('system:user:resetPwd'))])
@log_decorator(title='用户管理', business_type=2)
async def reset_system_user_pwd(request: Request, edit_user: EditUserModel, query_db: Session = Depends(get_db), current_user: CurrentUserModel = Depends(LoginService.get_current_user)):
async def reset_system_user_pwd(request: Request, edit_user: EditUserModel, query_db: AsyncSession = Depends(get_db), current_user: CurrentUserModel = Depends(LoginService.get_current_user)):
try:
edit_user.password = PwdUtil.get_password_hash(edit_user.password)
edit_user.update_by = current_user.user.user_name
edit_user.update_time = datetime.now()
edit_user.type = 'pwd'
edit_user_result = UserService.edit_user_services(query_db, edit_user)
edit_user_result = await UserService.edit_user_services(query_db, edit_user)
if edit_user_result.is_success:
logger.info(edit_user_result.message)
return ResponseUtil.success(msg=edit_user_result.message)
@@ -121,12 +121,12 @@ async def reset_system_user_pwd(request: Request, edit_user: EditUserModel, quer
@userController.put("/changeStatus", dependencies=[Depends(CheckUserInterfaceAuth('system:user:edit'))])
@log_decorator(title='用户管理', business_type=2)
async def change_system_user_status(request: Request, edit_user: EditUserModel, query_db: Session = Depends(get_db), current_user: CurrentUserModel = Depends(LoginService.get_current_user)):
async def change_system_user_status(request: Request, edit_user: EditUserModel, query_db: AsyncSession = Depends(get_db), current_user: CurrentUserModel = Depends(LoginService.get_current_user)):
try:
edit_user.update_by = current_user.user.user_name
edit_user.update_time = datetime.now()
edit_user.type = 'status'
edit_user_result = UserService.edit_user_services(query_db, edit_user)
edit_user_result = await UserService.edit_user_services(query_db, edit_user)
if edit_user_result.is_success:
logger.info(edit_user_result.message)
return ResponseUtil.success(msg=edit_user_result.message)
@@ -139,9 +139,9 @@ async def change_system_user_status(request: Request, edit_user: EditUserModel,
@userController.get("/profile", response_model=UserProfileModel)
async def query_detail_system_user(request: Request, query_db: Session = Depends(get_db), current_user: CurrentUserModel = Depends(LoginService.get_current_user)):
async def query_detail_system_user(request: Request, query_db: AsyncSession = Depends(get_db), current_user: CurrentUserModel = Depends(LoginService.get_current_user)):
try:
profile_user_result = UserService.user_profile_services(query_db, current_user.user.user_id)
profile_user_result = await UserService.user_profile_services(query_db, current_user.user.user_id)
logger.info(f'获取user_id为{current_user.user.user_id}的信息成功')
return ResponseUtil.success(model_content=profile_user_result)
except Exception as e:
@@ -151,9 +151,9 @@ async def query_detail_system_user(request: Request, query_db: Session = Depends
@userController.get("/{user_id}", response_model=UserDetailModel, dependencies=[Depends(CheckUserInterfaceAuth('system:user:query'))])
@userController.get("/", response_model=UserDetailModel, dependencies=[Depends(CheckUserInterfaceAuth('system:user:query'))])
async def query_detail_system_user(request: Request, user_id: Optional[Union[int, str]] = '', query_db: Session = Depends(get_db), current_user: CurrentUserModel = Depends(LoginService.get_current_user)):
async def query_detail_system_user(request: Request, user_id: Optional[Union[int, str]] = '', query_db: AsyncSession = Depends(get_db), current_user: CurrentUserModel = Depends(LoginService.get_current_user)):
try:
detail_user_result = UserService.user_detail_services(query_db, user_id)
detail_user_result = await UserService.user_detail_services(query_db, user_id)
logger.info(f'获取user_id为{user_id}的信息成功')
return ResponseUtil.success(model_content=detail_user_result)
except Exception as e:
@@ -163,7 +163,7 @@ async def query_detail_system_user(request: Request, user_id: Optional[Union[int
@userController.post("/profile/avatar")
@log_decorator(title='个人信息', business_type=2)
async def change_system_user_profile_avatar(request: Request, avatarfile: bytes = File(), query_db: Session = Depends(get_db), current_user: CurrentUserModel = Depends(LoginService.get_current_user)):
async def change_system_user_profile_avatar(request: Request, avatarfile: bytes = File(), query_db: AsyncSession = Depends(get_db), current_user: CurrentUserModel = Depends(LoginService.get_current_user)):
try:
relative_path = f'avatar/{datetime.now().strftime("%Y")}/{datetime.now().strftime("%m")}/{datetime.now().strftime("%d")}'
dir_path = os.path.join(UploadConfig.UPLOAD_PATH, relative_path)
@@ -182,7 +182,7 @@ async def change_system_user_profile_avatar(request: Request, avatarfile: bytes
updateTime=datetime.now(),
type='avatar'
)
edit_user_result = UserService.edit_user_services(query_db, edit_user)
edit_user_result = await UserService.edit_user_services(query_db, edit_user)
if edit_user_result.is_success:
logger.info(edit_user_result.message)
return ResponseUtil.success(dict_content={'imgUrl': edit_user.avatar}, msg=edit_user_result.message)
@@ -196,7 +196,7 @@ async def change_system_user_profile_avatar(request: Request, avatarfile: bytes
@userController.put("/profile")
@log_decorator(title='个人信息', business_type=2)
async def change_system_user_profile_info(request: Request, user_info: UserInfoModel, query_db: Session = Depends(get_db), current_user: CurrentUserModel = Depends(LoginService.get_current_user)):
async def change_system_user_profile_info(request: Request, user_info: UserInfoModel, query_db: AsyncSession = Depends(get_db), current_user: CurrentUserModel = Depends(LoginService.get_current_user)):
try:
edit_user = EditUserModel(
**user_info.model_dump(
@@ -212,7 +212,7 @@ async def change_system_user_profile_info(request: Request, user_info: UserInfoM
postIds=current_user.user.post_ids.split(',') if current_user.user.post_ids else [],
role=current_user.user.role
)
edit_user_result = UserService.edit_user_services(query_db, edit_user)
edit_user_result = await UserService.edit_user_services(query_db, edit_user)
if edit_user_result.is_success:
logger.info(edit_user_result.message)
return ResponseUtil.success(msg=edit_user_result.message)
@@ -226,7 +226,7 @@ async def change_system_user_profile_info(request: Request, user_info: UserInfoM
@userController.put("/profile/updatePwd")
@log_decorator(title='个人信息', business_type=2)
async def reset_system_user_password(request: Request, reset_password: ResetPasswordModel = Depends(ResetPasswordModel.as_query), query_db: Session = Depends(get_db), current_user: CurrentUserModel = Depends(LoginService.get_current_user)):
async def reset_system_user_password(request: Request, reset_password: ResetPasswordModel = Depends(ResetPasswordModel.as_query), query_db: AsyncSession = Depends(get_db), current_user: CurrentUserModel = Depends(LoginService.get_current_user)):
try:
reset_user = ResetUserModel(
userId=current_user.user.user_id,
@@ -235,7 +235,7 @@ async def reset_system_user_password(request: Request, reset_password: ResetPass
updateBy=current_user.user.user_name,
updateTime=datetime.now()
)
reset_user_result = UserService.reset_user_services(query_db, reset_user)
reset_user_result = await UserService.reset_user_services(query_db, reset_user)
if reset_user_result.is_success:
logger.info(reset_user_result.message)
return ResponseUtil.success(msg=reset_user_result.message)
@@ -249,7 +249,7 @@ async def reset_system_user_password(request: Request, reset_password: ResetPass
@userController.post("/importData", dependencies=[Depends(CheckUserInterfaceAuth('system:user:import'))])
@log_decorator(title='用户管理', business_type=6)
async def batch_import_system_user(request: Request, file: UploadFile = File(...), update_support: bool = Query(alias='updateSupport'), query_db: Session = Depends(get_db), current_user: CurrentUserModel = Depends(LoginService.get_current_user)):
async def batch_import_system_user(request: Request, file: UploadFile = File(...), update_support: bool = Query(alias='updateSupport'), query_db: AsyncSession = Depends(get_db), current_user: CurrentUserModel = Depends(LoginService.get_current_user)):
try:
batch_import_result = await UserService.batch_import_user_services(query_db, file, update_support, current_user)
if batch_import_result.is_success:
@@ -264,9 +264,9 @@ async def batch_import_system_user(request: Request, file: UploadFile = File(...
@userController.post("/importTemplate", dependencies=[Depends(CheckUserInterfaceAuth('system:user:import'))])
async def export_system_user_template(request: Request, query_db: Session = Depends(get_db)):
async def export_system_user_template(request: Request, query_db: AsyncSession = Depends(get_db)):
try:
user_import_template_result = UserService.get_user_import_template_services()
user_import_template_result = await UserService.get_user_import_template_services()
logger.info('获取成功')
return ResponseUtil.streaming(data=bytes2file_response(user_import_template_result))
except Exception as e:
@@ -276,11 +276,11 @@ async def export_system_user_template(request: Request, query_db: Session = Depe
@userController.post("/export", dependencies=[Depends(CheckUserInterfaceAuth('system:user:export'))])
@log_decorator(title='用户管理', business_type=5)
async def export_system_user_list(request: Request, user_page_query: UserPageQueryModel = Depends(UserPageQueryModel.as_form), query_db: Session = Depends(get_db), data_scope_sql: str = Depends(GetDataScope('SysUser'))):
async def export_system_user_list(request: Request, user_page_query: UserPageQueryModel = Depends(UserPageQueryModel.as_form), query_db: AsyncSession = Depends(get_db), data_scope_sql: str = Depends(GetDataScope('SysUser'))):
try:
# 获取全量数据
user_query_result = UserService.get_user_list_services(query_db, user_page_query, data_scope_sql, is_page=False)
user_export_result = UserService.export_user_list_services(user_query_result)
user_query_result = await UserService.get_user_list_services(query_db, user_page_query, data_scope_sql, is_page=False)
user_export_result = await UserService.export_user_list_services(user_query_result)
logger.info('导出成功')
return ResponseUtil.streaming(data=bytes2file_response(user_export_result))
except Exception as e:
@@ -289,10 +289,10 @@ async def export_system_user_list(request: Request, user_page_query: UserPageQue
@userController.get("/authRole/{user_id}", response_model=UserRoleResponseModel, dependencies=[Depends(CheckUserInterfaceAuth('system:user:query'))])
async def get_system_allocated_role_list(request: Request, user_id: int, query_db: Session = Depends(get_db)):
async def get_system_allocated_role_list(request: Request, user_id: int, query_db: AsyncSession = Depends(get_db)):
try:
user_role_query = UserRoleQueryModel(userId=user_id)
user_role_allocated_query_result = UserService.get_user_role_allocated_list_services(query_db, user_role_query)
user_role_allocated_query_result = await UserService.get_user_role_allocated_list_services(query_db, user_role_query)
logger.info('获取成功')
return ResponseUtil.success(model_content=user_role_allocated_query_result)
except Exception as e:
@@ -301,9 +301,9 @@ async def get_system_allocated_role_list(request: Request, user_id: int, query_d
@userController.put("/authRole", response_model=UserRoleResponseModel, dependencies=[Depends(CheckUserInterfaceAuth('system:user:edit'))])
async def update_system_role_user(request: Request, user_id: int = Query(alias='userId'), role_ids: str = Query(alias='roleIds'), query_db: Session = Depends(get_db)):
async def update_system_role_user(request: Request, user_id: int = Query(alias='userId'), role_ids: str = Query(alias='roleIds'), query_db: AsyncSession = Depends(get_db)):
try:
add_user_role_result = UserService.add_user_role_services(query_db, CrudUserRoleModel(userId=user_id, roleIds=role_ids))
add_user_role_result = await UserService.add_user_role_services(query_db, CrudUserRoleModel(userId=user_id, roleIds=role_ids))
if add_user_role_result.is_success:
logger.info(add_user_role_result.message)
return ResponseUtil.success(msg=add_user_role_result.message)