refactor(backend): 重构控制器和信息服务方法命名

- 更新了多个控制器文件中的函数命名，增加了 _controller 后缀
- 更新了多个服务文件中的函数命名，增加了 _service 后缀
- 统一了命名格式，提高了代码的可读性和可维护性

backend/app/api/v1/controllers/monitor/cache_controller.py

@@ -20,9 +20,9 @@ router = APIRouter(route_class=OperationLogRoute)
     summary="获取缓存监控信息",
     description="获取缓存监控信息"
 )
-async def get_monitor_cache_info(request: Request) -> JSONResponse:
+async def get_monitor_cache_info_controller(request: Request) -> JSONResponse:
     """获取缓存监控统计信息"""
-    result = await CacheService.get_cache_monitor_statistical_info_services(request)
+    result = await CacheService.get_cache_monitor_statistical_info_service(request)
     logger.info('获取缓存监控信息成功')
     return SuccessResponse(data=result, msg='获取缓存监控信息成功')
 
@@ -33,9 +33,9 @@ async def get_monitor_cache_info(request: Request) -> JSONResponse:
     summary="获取缓存名称列表",
     description="获取缓存名称列表"
 )
-async def get_monitor_cache_name() -> JSONResponse:
+async def get_monitor_cache_name_controller() -> JSONResponse:
     """获取缓存名称列表"""
-    result = await CacheService.get_cache_monitor_cache_name_services()
+    result = await CacheService.get_cache_monitor_cache_name_service()
     logger.info('获取缓存名称列表成功')
     return SuccessResponse(data=result, msg='获取缓存名称列表成功')
 
@@ -46,9 +46,9 @@ async def get_monitor_cache_name() -> JSONResponse:
     summary="获取缓存键名列表",
     description="获取缓存键名列表"
 )
-async def get_monitor_cache_key(request: Request, cache_name: str) -> JSONResponse:
+async def get_monitor_cache_key_controller(request: Request, cache_name: str) -> JSONResponse:
     """获取指定缓存名称下的键名列表"""
-    result = await CacheService.get_cache_monitor_cache_key_services(request, cache_name)
+    result = await CacheService.get_cache_monitor_cache_key_service(request, cache_name)
     logger.info(f'获取缓存{cache_name}的键名列表成功')
     return SuccessResponse(data=result, msg=f'获取缓存{cache_name}的键名列表成功')
 
@@ -59,9 +59,9 @@ async def get_monitor_cache_key(request: Request, cache_name: str) -> JSONRespon
     summary="获取缓存值",
     description="获取缓存值"
 )
-async def get_monitor_cache_value(request: Request, cache_name: str, cache_key: str) -> JSONResponse:
+async def get_monitor_cache_value_controller(request: Request, cache_name: str, cache_key: str) -> JSONResponse:
     """获取指定缓存键的值"""
-    result = await CacheService.get_cache_monitor_cache_value_services(request, cache_name, cache_key)
+    result = await CacheService.get_cache_monitor_cache_value_service(request, cache_name, cache_key)
     logger.info(f'获取缓存{cache_name}:{cache_key}的值成功')
     return SuccessResponse(data=result, msg=f'获取缓存{cache_name}:{cache_key}的值成功')
 
@@ -72,9 +72,9 @@ async def get_monitor_cache_value(request: Request, cache_name: str, cache_key:
     summary="清除指定缓存名称的所有缓存",
     description="清除指定缓存名称的所有缓存"
 )
-async def clear_monitor_cache_name(request: Request, cache_name: str) -> JSONResponse:
+async def clear_monitor_cache_name_controller(request: Request, cache_name: str) -> JSONResponse:
     """清除指定缓存名称下的所有缓存"""
-    result = await CacheService.clear_cache_monitor_cache_name_services(request, cache_name)
+    result = await CacheService.clear_cache_monitor_cache_name_service(request, cache_name)
     if not result:
         raise CustomException(message='清除缓存失败', data=result)
     logger.info(f'清除缓存{cache_name}成功')
@@ -87,9 +87,9 @@ async def clear_monitor_cache_name(request: Request, cache_name: str) -> JSONRes
     summary="清除指定缓存键",
     description="清除指定缓存键"
 )
-async def clear_monitor_cache_key(request: Request, cache_key: str) -> JSONResponse:
+async def clear_monitor_cache_key_controller(request: Request, cache_key: str) -> JSONResponse:
     """清除指定缓存键"""
-    result = await CacheService.clear_cache_monitor_cache_key_services(request, cache_key)
+    result = await CacheService.clear_cache_monitor_cache_key_service(request, cache_key)
     if not result:
         raise CustomException(message='清除缓存失败', data=result)
     logger.info(f'清除缓存键{cache_key}成功')
@@ -102,9 +102,9 @@ async def clear_monitor_cache_key(request: Request, cache_key: str) -> JSONRespo
     summary="清除所有缓存",
     description="清除所有缓存"
 )
-async def clear_monitor_cache_all(request: Request) -> JSONResponse:
+async def clear_monitor_cache_all_controller(request: Request) -> JSONResponse:
     """清除所有缓存"""
-    result = await CacheService.clear_cache_monitor_all_services(request)
+    result = await CacheService.clear_cache_monitor_all_service(request)
     if not result:
         raise CustomException(message='清除缓存失败', data=result)
     logger.info('清除所有缓存成功')

backend/app/api/v1/controllers/monitor/online_controller.py

@@ -22,13 +22,13 @@ router = APIRouter(route_class=OperationLogRoute)
     summary="获取在线用户列表",
     description="获取在线用户列表"
 )
-async def get_online_list(
+async def get_online_list_controller(
     request: Request, 
     paging_query: PaginationQueryParams = Depends(),
     search: OnlineQueryParams = Depends()
 )->JSONResponse:
     # 获取全量数据
-    result_dict_list = await OnlineService.get_online_list(request=request, search=search)
+    result_dict_list = await OnlineService.get_online_list_service(request=request, search=search)
     result_dict = await PaginationService.get_page_obj(data_list= result_dict_list, page_no= paging_query.page_no, page_size = paging_query.page_size)
     logger.info('获取成功')
 
@@ -41,11 +41,11 @@ async def get_online_list(
     summary="强制下线",
     description="强制下线"
 )
-async def delete__online(
+async def delete__online_controller(
     request: Request, 
     username: str = Body(..., description="用户"),
 )->JSONResponse:
-    delete_online_result = await OnlineService.delete_online(request=request, username=username)
+    delete_online_result = await OnlineService.delete_online_service(request=request, username=username)
     if delete_online_result:
         logger.info("强制下线成功")
         return SuccessResponse(msg="强制下线成功")

backend/app/api/v1/controllers/monitor/server_controller.py

@@ -20,9 +20,9 @@ router = APIRouter(route_class=OperationLogRoute)
     description="查询服务器监控信息",
     dependencies=[Depends(AuthPermission(permissions=["monitor:server:query"]))]
 )
-async def get_monitor_server_info() -> JSONResponse:
+async def get_monitor_server_info_controller() -> JSONResponse:
     # 获取全量数据
-    result_dict = await ServerService.get_server_monitor_info()
+    result_dict = await ServerService.get_server_monitor_info_service()
     logger.info('获取服务器监控信息成功')
 
     return SuccessResponse(data=result_dict, msg='获取服务器监控信息成功')

backend/app/api/v1/controllers/system/auth_controller.py

@@ -30,16 +30,16 @@ from app.core.logger import logger
 router = APIRouter(route_class=OperationLogRoute)
 
 
-@router.post("/login", summary="登录", description="登录",response_model=JWTOutSchema)
-async def login_for_access_token(
-        request: Request,
-        login_form: CustomOAuth2PasswordRequestForm = Depends(),
-        db: AsyncSession = Depends(db_getter),
+@router.post("/login", summary="登录", description="登录", response_model=JWTOutSchema)
+async def login_for_access_token_controller(
+    request: Request,
+    login_form: CustomOAuth2PasswordRequestForm = Depends(),
+    db: AsyncSession = Depends(db_getter),
 ) -> Union[JSONResponse, Dict]:
-    user = await LoginService.authenticate_user(request=request, login_form=login_form, db=db)
-    login_token = await LoginService.create_token(request=request, username=user.username)
+    user = await LoginService.authenticate_user_service(request=request, login_form=login_form, db=db)
+    login_token = await LoginService.create_token_service(request=request, username=user.username)
     logger.info(f"用户{user.username}登录成功")
-    
+
     # 如果是文档请求，则不记录日志:http://localhost:8000/api/v1/docs
     if settings.DOCS_URL in request.headers.get("referer", ""):
         return login_token.model_dump()
@@ -47,55 +47,61 @@ async def login_for_access_token(
 
 
 @router.post("/token/refresh", summary="刷新token", description="刷新token", response_model=JWTOutSchema, dependencies=[Depends(get_current_user)])
-async def get_new_token(
-        request: Request,
-        payload: RefreshTokenPayloadSchema
+async def get_new_token_controller(
+    request: Request,
+    payload: RefreshTokenPayloadSchema
 ) -> JSONResponse:
     # 解析当前的访问Token以获取用户名
-    new_token = await LoginService.refresh_token(request=request, refresh_token=payload)
+    new_token = await LoginService.refresh_token_service(request=request, refresh_token=payload)
     token_dict = new_token.model_dump()
     logger.info(f"刷新token成功: {token_dict}")
     return SuccessResponse(data=token_dict, msg="刷新成功")
 
 
 @router.post("/captcha/get", summary="获取验证码", description="获取登录验证码", response_model=CaptchaOutSchema)
-async def get_captcha_for_login(
-        request: Request
+async def get_captcha_for_login_controller(
+    request: Request
 ) -> JSONResponse:
     # 获取验证码
-    captcha = await CaptchaService.get_captcha(request=request)
+    captcha = await CaptchaService.get_captcha_service(request=request)
     logger.info(f"获取验证码成功")
     return SuccessResponse(data=captcha, msg="获取验证码成功")
 
 
 @router.post('/logout', summary="退出登录", description="退出登录", dependencies=[Depends(get_current_user)])
-async def logout(
+async def logout_controller(
     request: Request,
     payload: LogoutPayloadSchema
 ) -> JSONResponse:
-    if await LoginService.logout_services(request=request, token=payload):
+    if await LoginService.logout_services_service(request=request, token=payload):
         logger.info('退出成功')
         return SuccessResponse(msg='退出成功')
-    return ErrorResponse(msg='退出失败')    
+    return ErrorResponse(msg='退出失败')
 
 
 # 以下接口为预留，后期会用
 @router.post("/background_tasks", summary="模拟fastapi自带后台任务-模拟流式响应")
-async def stream_response(background_tasks: BackgroundTasks, message:str):
+async def stream_response__controller(
+    background_tasks: BackgroundTasks,
+    message: str
+):
     def task(message):
         for i in range(5):
             yield f"睡眠 {message} {i}\n"
             time.sleep(1)
     background_tasks.add_task(task, message)
-    
+
     return StreamingResponse(
-        data=task(*args, **kwargs),
+        data=task(message),
         headers={"X-Custom-Header": "Streaming-Response"},
         media_type="text/plain",
     )
 
+
 @router.websocket("/ws", name="websocket")
-async def websocket_endpoint(websocket: WebSocket):
+async def websocket_endpoint_controller(
+    websocket: WebSocket
+):
     # ws://127.0.0.1:8000/ws
     await websocket.accept()
     while True:

backend/app/api/v1/controllers/system/config_controller.py

@@ -16,36 +16,39 @@ router = APIRouter(route_class=OperationLogRoute)
 
 
 @router.get("/info", summary="获取配置", description="获取配置")
-async def get_obj_list(
-        auth: AuthSchema = Depends(AuthPermission(permissions=["system:config:query"])),
+async def get_obj_list_controller(
+    auth: AuthSchema = Depends(AuthPermission(permissions=["system:config:query"]))
 ) -> JSONResponse:
-    result_dict = await ConfigService.get_services(auth=auth, id=1)
+    result_dict = await ConfigService.get_service(auth=auth, id=1)
     logger.info(f"{auth.user.name} 获取配置成功")
     return SuccessResponse(data=result_dict, msg="查询配置列表成功")
 
+
 @router.put("/update", summary="修改配置", description="修改配置")
-async def update_objs(
-        request: Request,
-        data: ConfigUpdateSchema,
-        auth: AuthSchema = Depends(AuthPermission(permissions=["system:config:update"])),
+async def update_objs_controller(
+    request: Request,
+    data: ConfigUpdateSchema,
+    auth: AuthSchema = Depends(AuthPermission(permissions=["system:config:update"]))
 ) -> JSONResponse:
-    result_dict = await ConfigService.update_services(auth=auth, request=request, data=data)
+    result_dict = await ConfigService.update_service(auth=auth, request=request, data=data)
     logger.info(f"{auth.user.name} 更新配置成功 {result_dict}")
     return SuccessResponse(data=result_dict, msg="更新配置成功")
 
+
 @router.post("/upload", summary="上传文件", dependencies=[Depends(AuthPermission(permissions=["system:config:upload"]))])
-async def upload_file(
-        file: UploadFile, 
-        request: Request
+async def upload_file_controller(
+    file: UploadFile,
+    request: Request
 ) -> JSONResponse:
-    result_str = await ConfigService.upload_services(request=request, file=file)
+    result_str = await ConfigService.upload_service(request=request, file=file)
     logger.info(f"上传文件: {result_str}")
     return SuccessResponse(data=result_str, msg='上传文件成功')
 
+
 @router.get("/init", summary="获取初始化配置", description="获取初始化配置")
-async def get_init_config(
-        request: Request,
+async def get_init_config_controller(
+    request: Request
 ) -> JSONResponse:
-    result_dict = await ConfigService.get_init_config(request=request)
+    result_dict = await ConfigService.get_init_config_service(request=request)
     logger.info(f"获取初始化配置成功 {result_dict}")
     return SuccessResponse(data=result_dict, msg="获取初始化配置成功")

backend/app/api/v1/controllers/system/dept_controller.py

@@ -23,63 +23,62 @@ router = APIRouter(route_class=OperationLogRoute)
 
 
 @router.get("/list", summary="查询部门", description="查询部门")
-async def get_obj_list(
-        page: PaginationQueryParams = Depends(),
-        search: DeptQueryParams = Depends(),
-        auth: AuthSchema = Depends(AuthPermission(permissions=["system:dept:query"])),
+async def get_obj_list_controller(
+    page: PaginationQueryParams = Depends(),
+    search: DeptQueryParams = Depends(),
+    auth: AuthSchema = Depends(AuthPermission(permissions=["system:dept:query"]))
 ) -> JSONResponse:
-    result_dict_list = await DeptService.get_dept_list_services(search=search, auth=auth, order_by=page.order_by)
-    result_dict = await PaginationService.get_page_obj(data_list= result_dict_list, page_no= page.page_no, page_size = page.page_size)
+    result_dict_list = await DeptService.get_dept_list_service(search=search, auth=auth, order_by=page.order_by)
+    result_dict = await PaginationService.get_page_obj(data_list=result_dict_list, page_no=page.page_no, page_size=page.page_size)
     logger.info(f"{auth.user.name} 查询部门成功")
     return SuccessResponse(data=result_dict, msg="查询部门成功")
 
 
 @router.get("/detail", summary="查询部门详情", description="查询部门详情")
-async def get_obj_detail(
-        id: int = Query(..., description="部门ID"),
-        auth: AuthSchema = Depends(AuthPermission(permissions=["system:dept:query"])),
+async def get_obj_detail_controller(
+    id: int = Query(..., description="部门ID"),
+    auth: AuthSchema = Depends(AuthPermission(permissions=["system:dept:query"]))
 ) -> JSONResponse:
-    result_dict = await DeptService.get_dept_detail_services(id=id, auth=auth)
+    result_dict = await DeptService.get_dept_detail_service(id=id, auth=auth)
     logger.info(f"{auth.user.name} 查询部门详情成功 {id}")
     return SuccessResponse(data=result_dict, msg="查询部门详情成功")
 
 
 @router.post("/create", summary="创建部门", description="创建部门")
-async def create_obj(
-        data: DeptCreateSchema,
-        auth: AuthSchema = Depends(AuthPermission(permissions=["system:dept:create"])),
+async def create_obj_controller(
+    data: DeptCreateSchema,
+    auth: AuthSchema = Depends(AuthPermission(permissions=["system:dept:create"]))
 ) -> JSONResponse:
-    result_dict = await DeptService.create_dept_services(data=data, auth=auth)
+    result_dict = await DeptService.create_dept_service(data=data, auth=auth)
     logger.info(f"{auth.user.name} 创建部门成功: {result_dict}")
     return SuccessResponse(data=result_dict, msg="创建部门成功")
 
 
 @router.put("/update", summary="修改部门", description="修改部门")
-async def update_obj(
-        data: DeptUpdateSchema,
-        auth: AuthSchema = Depends(AuthPermission(permissions=["system:dept:update"])),
+async def update_obj_controller(
+    data: DeptUpdateSchema,
+    auth: AuthSchema = Depends(AuthPermission(permissions=["system:dept:update"]))
 ) -> JSONResponse:
-    result_dict = await DeptService.update_dept_services(data=data, auth=auth)
+    result_dict = await DeptService.update_dept_service(data=data, auth=auth)
     logger.info(f"{auth.user.name} 修改部门成功: {result_dict}")
     return SuccessResponse(data=result_dict, msg="修改部门成功")
 
 
 @router.delete("/delete", summary="删除部门", description="删除部门")
-async def delete_obj(
-        id: int = Query(..., description="部门ID"),
-        auth: AuthSchema = Depends(AuthPermission(permissions=["system:dept:delete"])),
+async def delete_obj_controller(
+    id: int = Query(..., description="部门ID"),
+    auth: AuthSchema = Depends(AuthPermission(permissions=["system:dept:delete"]))
 ) -> JSONResponse:
-    await DeptService.delete_dept_services(id=id, auth=auth)
+    await DeptService.delete_dept_service(id=id, auth=auth)
     logger.info(f"{auth.user.name} 删除部门成功: {id}")
     return SuccessResponse(msg="删除部门成功")
 
 
 @router.patch("/available/setting", summary="批量修改部门状态", description="批量修改部门状态")
-async def batch_set_available_obj(
-        data: BatchSetAvailable,
-        auth: AuthSchema = Depends(AuthPermission(permissions=["system:dept:patch"])),
+async def batch_set_available_obj_controller(
+    data: BatchSetAvailable,
+    auth: AuthSchema = Depends(AuthPermission(permissions=["system:dept:patch"]))
 ) -> JSONResponse:
-    await DeptService.batch_set_available_services(data=data , auth=auth)
+    await DeptService.batch_set_available_service(data=data, auth=auth)
     logger.info(f"{auth.user.name} 批量修改部门状态成功: {data.ids}")
     return SuccessResponse(msg="批量修改部门状态成功")
-

backend/app/api/v1/controllers/system/dict_controller.py

@@ -26,71 +26,71 @@ from app.api.v1.schemas.system.dict_schema import (
 router = APIRouter(route_class=OperationLogRoute)
 
 @router.get("/type/detail", summary="获取字典类型详情", description="获取字典类型详情")
-async def get_type_detail(
+async def get_type_detail_controller(
     id: int = Query(..., description="字典类型ID"),
-    auth: AuthSchema = Depends(AuthPermission(permissions=["system:dict_type:query"])),
+    auth: AuthSchema = Depends(AuthPermission(permissions=["system:dict_type:query"]))
 ) -> JSONResponse:
-    result_dict = await DictTypeService.get_obj_detail_services(id=id, auth=auth)
+    result_dict = await DictTypeService.get_obj_detail_service(id=id, auth=auth)
     logger.info(f"{auth.user.name} 获取字典类型详情成功 {id}")
     return SuccessResponse(data=result_dict, msg="获取字典类型详情成功")
 
 @router.get("/type/list", summary="查询字典类型", description="查询字典类型")
-async def get_type_list(
+async def get_type_list_controller(
     page: PaginationQueryParams = Depends(),
     search: DictTypeQueryParams = Depends(),
-    auth: AuthSchema = Depends(AuthPermission(permissions=["system:dict_type:query"])),
+    auth: AuthSchema = Depends(AuthPermission(permissions=["system:dict_type:query"]))
 ) -> JSONResponse:
-    result_dict_list = await DictTypeService.get_obj_list_services(auth=auth, search=search, order_by=page.order_by)
+    result_dict_list = await DictTypeService.get_obj_list_service(auth=auth, search=search, order_by=page.order_by)
     result_dict = await PaginationService.get_page_obj(data_list= result_dict_list, page_no= page.page_no, page_size = page.page_size)
     logger.info(f"{auth.user.name} 查询字典类型列表成功")
     return SuccessResponse(data=result_dict, msg="查询字典类型列表成功")
 
 @router.get("/type/optionselect", summary="获取全部字典类型", description="获取全部字典类型")
-async def get_type_list(
-    auth: AuthSchema = Depends(AuthPermission(permissions=["system:dict_type:query"])),
+async def get_type_list_controller(
+    auth: AuthSchema = Depends(AuthPermission(permissions=["system:dict_type:query"]))
 ) -> JSONResponse:
-    result_dict_list = await DictTypeService.get_obj_list_services(auth=auth)
+    result_dict_list = await DictTypeService.get_obj_list_service(auth=auth)
     logger.info(f"{auth.user.name} 获取字典类型列表成功")
     return SuccessResponse(data=result_dict_list, msg="获取字典类型列表成功")
 
 @router.post("/type/create", summary="创建字典类型", description="创建字典类型")
-async def create_type(
+async def create_type_controller(
     request: Request,
     data: DictTypeCreateSchema,
-    auth: AuthSchema = Depends(AuthPermission(permissions=["system:dict_type:create"])),
+    auth: AuthSchema = Depends(AuthPermission(permissions=["system:dict_type:create"]))
 ) -> JSONResponse:
-    result_dict = await DictTypeService.create_obj_services(auth=auth, request=request, data=data)
+    result_dict = await DictTypeService.create_obj_service(auth=auth, request=request, data=data)
     logger.info(f"{auth.user.name} 创建字典类型成功: {result_dict}")
     return SuccessResponse(data=result_dict, msg="创建字典类型成功")
 
 @router.put("/type/update", summary="修改字典类型", description="修改字典类型")
-async def update_type(
+async def update_type_controller(
     request: Request,
     data: DictTypeUpdateSchema,
-    auth: AuthSchema = Depends(AuthPermission(permissions=["system:dict_type:update"])),
+    auth: AuthSchema = Depends(AuthPermission(permissions=["system:dict_type:update"]))
 ) -> JSONResponse:
-    result_dict = await DictTypeService.update_obj_services(auth=auth, request=request, data=data)
+    result_dict = await DictTypeService.update_obj_service(auth=auth, request=request, data=data)
     logger.info(f"{auth.user.name} 修改字典类型成功: {result_dict}")
     return SuccessResponse(data=result_dict, msg="修改字典类型成功")
 
 @router.delete("/type/delete", summary="删除字典类型", description="删除字典类型")
-async def delete_type(
+async def delete_type_controller(
     request: Request,
     id: int = Query(..., description="字典类型ID"),
-    auth: AuthSchema = Depends(AuthPermission(permissions=["system:dict_type:delete"])),
+    auth: AuthSchema = Depends(AuthPermission(permissions=["system:dict_type:delete"]))
 ) -> JSONResponse:
-    await DictTypeService.delete_obj_services(auth=auth, request=request, id=id)
+    await DictTypeService.delete_obj_service(auth=auth, request=request, id=id)
     logger.info(f"{auth.user.name} 删除字典类型成功: {id}")
     return SuccessResponse(msg="删除字典类型成功")
 
 @router.post('/type/export', summary="导出字典类型", description="导出字典类型")
-async def export_type_list(
+async def export_type_list_controller(
     search: DictTypeQueryParams = Depends(),
-    auth: AuthSchema = Depends(AuthPermission(permissions=["system:dict_type:export"])),
+    auth: AuthSchema = Depends(AuthPermission(permissions=["system:dict_type:export"]))
 ) -> StreamingResponse:
     # 获取全量数据
-    result_dict_list = await DictTypeService.get_obj_list_services(search=search, auth=auth)
-    export_result = await DictTypeService.export_obj_services(data_list=result_dict_list)
+    result_dict_list = await DictTypeService.get_obj_list_service(search=search, auth=auth)
+    export_result = await DictTypeService.export_obj_service(data_list=result_dict_list)
     logger.info('导出字典类型成功')
 
     return StreamResponse(
@@ -102,63 +102,63 @@ async def export_type_list(
     )
 
 @router.get("/data/detail", summary="获取字典数据详情", description="获取字典数据详情")
-async def get_data_detail(
+async def get_data_detail_controller(
     id: int = Query(..., description="字典数据ID"),
-    auth: AuthSchema = Depends(AuthPermission(permissions=["system:dict_data:query"])),
+    auth: AuthSchema = Depends(AuthPermission(permissions=["system:dict_data:query"]))
 ) -> JSONResponse:
-    result_dict = await DictDataService.get_obj_detail_services(id=id, auth=auth)
+    result_dict = await DictDataService.get_obj_detail_service(id=id, auth=auth)
     logger.info(f"{auth.user.name} 获取字典数据详情成功 {id}")
     return SuccessResponse(data=result_dict, msg="获取字典数据详情成功")
 
 @router.get("/data/list", summary="查询字典数据", description="查询字典数据")
-async def get_data_list(
+async def get_data_list_controller(
     page: PaginationQueryParams = Depends(),
     search: DictDataQueryParams = Depends(),
-    auth: AuthSchema = Depends(AuthPermission(permissions=["system:dict_data:query"])),
+    auth: AuthSchema = Depends(AuthPermission(permissions=["system:dict_data:query"]))
 ) -> JSONResponse:
-    result_dict_list = await DictDataService.get_obj_list_services(auth=auth, search=search, order_by=page.order_by)
+    result_dict_list = await DictDataService.get_obj_list_service(auth=auth, search=search, order_by=page.order_by)
     result_dict = await PaginationService.get_page_obj(data_list= result_dict_list, page_no= page.page_no, page_size = page.page_size)
     logger.info(f"{auth.user.name} 查询字典数据列表成功")
     return SuccessResponse(data=result_dict, msg="查询字典数据列表成功")
 
 @router.post("/data/create", summary="创建字典数据", description="创建字典数据")
-async def create_data(
+async def create_data_controller(
     request: Request,
     data: DictDataCreateSchema,
-    auth: AuthSchema = Depends(AuthPermission(permissions=["system:dict_data:create"])),
+    auth: AuthSchema = Depends(AuthPermission(permissions=["system:dict_data:create"]))
 ) -> JSONResponse:
-    result_dict = await DictDataService.create_obj_services(auth=auth, request=request, data=data)
+    result_dict = await DictDataService.create_obj_service(auth=auth, request=request, data=data)
     logger.info(f"{auth.user.name} 创建字典数据成功: {result_dict}")
     return SuccessResponse(data=result_dict, msg="创建字典数据成功")
 
 @router.put("/data/update", summary="修改字典数据", description="修改字典数据")
-async def update_data(
+async def update_data_controller(
     request: Request,
     data: DictDataUpdateSchema,
-    auth: AuthSchema = Depends(AuthPermission(permissions=["system:dict_data:update"])),
+    auth: AuthSchema = Depends(AuthPermission(permissions=["system:dict_data:update"]))
 ) -> JSONResponse:
-    result_dict = await DictDataService.update_obj_services(auth=auth, request=request, data=data)
+    result_dict = await DictDataService.update_obj_service(auth=auth, request=request, data=data)
     logger.info(f"{auth.user.name} 修改字典数据成功: {result_dict}")
     return SuccessResponse(data=result_dict, msg="修改字典数据成功")
 
 @router.delete("/data/delete", summary="删除字典数据", description="删除字典数据")
-async def delete_data(
+async def delete_data_controller(
     request: Request,
     id: int = Query(..., description="字典数据ID"),
-    auth: AuthSchema = Depends(AuthPermission(permissions=["system:dict_data:delete"])),
+    auth: AuthSchema = Depends(AuthPermission(permissions=["system:dict_data:delete"]))
 ) -> JSONResponse:
-    await DictDataService.delete_obj_services(auth=auth, request=request, id=id)
+    await DictDataService.delete_obj_service(auth=auth, request=request, id=id)
     logger.info(f"{auth.user.name} 删除字典数据成功: {id}")
     return SuccessResponse(msg="删除字典数据成功")
 
 @router.post('/data/export', summary="导出字典数据", description="导出字典数据")
-async def export_data_list(
+async def export_data_list_controller(
     search: DictDataQueryParams = Depends(),
-    auth: AuthSchema = Depends(AuthPermission(permissions=["system:dict_data:export"])),
+    auth: AuthSchema = Depends(AuthPermission(permissions=["system:dict_data:export"]))
 ) -> StreamingResponse:
     # 获取全量数据
-    result_dict_list = await DictDataService.get_obj_list_services(search=search, auth=auth)
-    export_result = await DictDataService.export_obj_services(data_list=result_dict_list)
+    result_dict_list = await DictDataService.get_obj_list_service(search=search, auth=auth)
+    export_result = await DictDataService.export_obj_service(data_list=result_dict_list)
     logger.info('导出字典数据成功')
 
     return StreamResponse(
@@ -170,15 +170,20 @@ async def export_data_list(
     )
 
 @router.get('/type/data',  summary="获取字典类型", description="获取字典类型", dependencies=[Depends(AuthPermission(permissions=["system:dict_data:query"]))])
-async def query_system_dict_type_options(request: Request):
-    result = await DictDataService.get_init_dict(redis=request.app.state.redis)
+async def query_system_dict_type_options_controller(
+    request: Request
+):
+    result = await DictDataService.get_init_dict_service(redis=request.app.state.redis)
     logger.info(f"获取初始化字典数据成功 {result}")
     return SuccessResponse(data=result, msg="获取初始字典数据成功")
 
 @router.get('/data/type/{dict_type}', summary="根据字典类型获取数据", description="根据字典类型获取数据", dependencies=[Depends(AuthPermission(permissions=["system:dict_data:query"]))])
-async def query_system_dict_type_data(request: Request, dict_type: str):
+async def query_system_dict_type_data_controller(
+    request: Request, 
+    dict_type: str
+):
     # 获取全量数据
-    dict_data_query_result = await DictDataService.query_init_dict(
+    dict_data_query_result = await DictDataService.query_init_dict_service(
         redis=request.app.state.redis, dict_type=dict_type
     )
     logger.info(f"获取字典数据：{dict_data_query_result}")

backend/app/api/v1/controllers/system/job_controller.py

@@ -18,65 +18,66 @@ from app.api.v1.schemas.system.job_schema import (
     JobCreateSchema,
     JobUpdateSchema
 )
+from app.core.ap_scheduler import SchedulerUtil
 
 
 router = APIRouter(route_class=OperationLogRoute)
 
 @router.get("/detail", summary="获取定时任务详情", description="获取定时任务详情")
-async def get_obj_detail(
-        id: int = Query(..., description="定时任务ID"),
-        auth: AuthSchema = Depends(AuthPermission(permissions=["system:job:query"])),
+async def get_obj_detail_controller(
+    id: int = Query(..., description="定时任务ID"),
+    auth: AuthSchema = Depends(AuthPermission(permissions=["system:job:query"]))
 ) -> JSONResponse:
-    result_dict = await JobService.get_job_detail_services(id=id, auth=auth)
+    result_dict = await JobService.get_job_detail_service(id=id, auth=auth)
     logger.info(f"{auth.user.name} 获取定时任务详情成功 {id}")
     return SuccessResponse(data=result_dict, msg="获取定时任务详情成功")
 
 @router.get("/list", summary="查询定时任务", description="查询定时任务")
-async def get_obj_list(
-        page: PaginationQueryParams = Depends(),
-        search: JobQueryParams = Depends(),
-        auth: AuthSchema = Depends(AuthPermission(permissions=["system:job:query"])),
+async def get_obj_list_controller(
+    page: PaginationQueryParams = Depends(),
+    search: JobQueryParams = Depends(),
+    auth: AuthSchema = Depends(AuthPermission(permissions=["system:job:query"]))
 ) -> JSONResponse:
-    result_dict_list = await JobService.get_job_list_services(auth=auth, search=search, order_by=page.order_by)
+    result_dict_list = await JobService.get_job_list_service(auth=auth, search=search, order_by=page.order_by)
     result_dict = await PaginationService.get_page_obj(data_list= result_dict_list, page_no= page.page_no, page_size = page.page_size)
     logger.info(f"{auth.user.name} 查询定时任务列表成功")
     return SuccessResponse(data=result_dict, msg="查询定时任务列表成功")
 
 @router.post("/create", summary="创建定时任务", description="创建定时任务")
-async def create_obj(
-        data: JobCreateSchema,
-        auth: AuthSchema = Depends(AuthPermission(permissions=["system:job:create"])),
+async def create_obj_controller(
+    data: JobCreateSchema,
+    auth: AuthSchema = Depends(AuthPermission(permissions=["system:job:create"]))
 ) -> JSONResponse:
-    result_dict = await JobService.create_job_services(auth=auth, data=data)
+    result_dict = await JobService.create_job_service(auth=auth, data=data)
     logger.info(f"{auth.user.name} 创建定时任务成功: {result_dict}")
     return SuccessResponse(data=result_dict, msg="创建定时任务成功")
 
 @router.put("/update", summary="修改定时任务", description="修改定时任务")
-async def update_obj(
-        data: JobUpdateSchema,
-        auth: AuthSchema = Depends(AuthPermission(permissions=["system:job:update"])),
+async def update_obj_controller(
+    data: JobUpdateSchema,
+    auth: AuthSchema = Depends(AuthPermission(permissions=["system:job:update"]))
 ) -> JSONResponse:
-    result_dict = await JobService.update_job_services(auth=auth, data=data)
+    result_dict = await JobService.update_job_service(auth=auth, data=data)
     logger.info(f"{auth.user.name} 修改定时任务成功: {result_dict}")
     return SuccessResponse(data=result_dict, msg="修改定时任务成功")
 
 @router.delete("/delete", summary="删除定时任务", description="删除定时任务")
-async def delete_obj(
-        id: int = Query(..., description="定时任务ID"),
-        auth: AuthSchema = Depends(AuthPermission(permissions=["system:job:delete"])),
+async def delete_obj_controller(
+    id: int = Query(..., description="定时任务ID"),
+    auth: AuthSchema = Depends(AuthPermission(permissions=["system:job:delete"]))
 ) -> JSONResponse:
-    await JobService.delete_job_services(auth=auth, id=id)
+    await JobService.delete_job_service(auth=auth, id=id)
     logger.info(f"{auth.user.name} 删除定时任务成功: {id}")
     return SuccessResponse(msg="删除定时任务成功")
 
 @router.post('/export', summary="导出定时任务", description="导出定时任务")
-async def export_obj_list(
+async def export_obj_list_controller(
     search: JobQueryParams = Depends(),
-    auth: AuthSchema = Depends(AuthPermission(permissions=["system:job:export"])),
+    auth: AuthSchema = Depends(AuthPermission(permissions=["system:job:export"]))
 ) -> StreamingResponse:
     # 获取全量数据
-    result_dict_list = await JobService.get_job_list_services(search=search, auth=auth)
-    export_result = await JobService.export_job_services(data_list=result_dict_list)
+    result_dict_list = await JobService.get_job_list_service(search=search, auth=auth)
+    export_result = await JobService.export_job_service(data_list=result_dict_list)
     logger.info('导出定时任务成功')
 
     return StreamResponse(
@@ -88,28 +89,25 @@ async def export_obj_list(
     )
 
 @router.delete("/clear", summary="清空定时任务日志", description="清空定时任务日志")
-async def clear_obj_log(
-    auth: AuthSchema = Depends(AuthPermission(permissions=["system:job:delete"])),
+async def clear_obj_log_controller(
+    auth: AuthSchema = Depends(AuthPermission(permissions=["system:job:delete"]))
 ) -> JSONResponse:
-    await JobService.clear_job_services(auth=auth)
+    await JobService.clear_job_service(auth=auth)
     logger.info(f"{auth.user.name} 清空定时任务成功")
     return SuccessResponse(msg="清空定时任务成功")
 
 @router.put("/option", summary="暂停/恢复/重启定时任务", description="暂停/恢复/重启定时任务")
-async def option_obj(
+async def option_obj_controller(
     id: int = Query(..., description="定时任务ID"),
     option: int = Query(..., description="操作类型 1: 暂停 2: 恢复 3: 重启"),
-    auth: AuthSchema = Depends(AuthPermission(permissions=["system:job:update"])),
+    auth: AuthSchema = Depends(AuthPermission(permissions=["system:job:update"]))
 ) -> JSONResponse:
-    await JobService.option_job_services(auth=auth, id=id, option=option)
+    await JobService.option_job_service(auth=auth, id=id, option=option)
     logger.info(f"{auth.user.name} 操作定时任务成功: {id}")
     return SuccessResponse(msg="操作定时任务成功")
 
-@router.get("/log", summary="获取定时任务日志", description="获取定时任务日志")
-async def test_job():
-    from app.core.ap_scheduler import SchedulerUtil
-    logger.info(f"获取定时任务日志: {SchedulerUtil.get_all_jobs()}")
-    logger.info(f"打印定时任务日志: {SchedulerUtil.print_jobs('default')}")
+@router.get("/log", summary="获取定时任务日志", description="获取定时任务日志", dependencies=[Depends(AuthPermission(permissions=["system:job:query"]))])
+async def get_job_log_controller():
     data = [
         {
             "id": i.id,
@@ -124,15 +122,9 @@ async def test_job():
             "coalesce": i.coalesce,
             "max_instances": i.max_instances,
             "next_run_time": i.next_run_time,
-            "state": SchedulerUtil.get_job_status(),
+            "state": SchedulerUtil.get_job_status()
         }
         for i in SchedulerUtil.get_all_jobs()
     ]
 
-    return data
-
-@router.put("/log", summary="暂停任务", description="暂停任务")
-async def pauseJob(job_id):
-    from app.core.ap_scheduler import SchedulerUtil
-    return SchedulerUtil.pause_job(job_id=str(job_id))
-
+    return SuccessResponse(msg="获取定时任务日志成功", data=data)

backend/app/api/v1/controllers/system/menu_controller.py

@@ -22,62 +22,62 @@ router = APIRouter(route_class=OperationLogRoute)
 
 
 @router.get("/list", summary="查询菜单", description="查询菜单")
-async def get_obj_list(
-        page: PaginationQueryParams = Depends(),
-        search: MenuQueryParams = Depends(),
-        auth: AuthSchema = Depends(AuthPermission(permissions=["system:menu:query"])),
+async def get_obj_list_controller(
+    page: PaginationQueryParams = Depends(),
+    search: MenuQueryParams = Depends(),
+    auth: AuthSchema = Depends(AuthPermission(permissions=["system:menu:query"]))
 ) -> JSONResponse:
-    result_dict_list = await MenuService.get_menu_list(search=search, auth=auth)
+    result_dict_list = await MenuService.get_menu_list_service(search=search, auth=auth)
     result_dict = await PaginationService.get_page_obj(data_list= result_dict_list, page_no= page.page_no, page_size = page.page_size)
     logger.info(f"{auth.user.name} 查询菜单成功")
     return SuccessResponse(data=result_dict, msg="查询菜单成功")
 
 
 @router.get("/detail", summary="查询菜单详情", description="查询菜单详情")
-async def get_obj_detail(
-        id: int = Query(..., description="菜单ID"),
-        auth: AuthSchema = Depends(AuthPermission(permissions=["system:menu:query"])),
+async def get_obj_detail_controller(
+    id: int = Query(..., description="菜单ID"),
+    auth: AuthSchema = Depends(AuthPermission(permissions=["system:menu:query"]))
 ) -> JSONResponse:
-    result_dict = await MenuService.get_menu_detail(id=id, auth=auth)
+    result_dict = await MenuService.get_menu_detail_service(id=id, auth=auth)
     logger.info(f"{auth.user.name} 查询菜单情成功 {id}")
     return SuccessResponse(data=result_dict, msg="获取菜单成功")
 
 
 @router.post("/create", summary="创建菜单", description="创建菜单")
-async def create_obj(
-        data: MenuCreateSchema,
-        auth: AuthSchema = Depends(AuthPermission(permissions=["system:menu:create"])),
+async def create_obj_controller(
+    data: MenuCreateSchema,
+    auth: AuthSchema = Depends(AuthPermission(permissions=["system:menu:create"]))
 ) -> JSONResponse:
-    result_dict = await MenuService.create_menu(data=data, auth=auth)
+    result_dict = await MenuService.create_menu_service(data=data, auth=auth)
     logger.info(f"{auth.user.name} 创建菜单成功: {result_dict}")
     return SuccessResponse(data=result_dict, msg="创建菜单成功")
 
 
 @router.put("/update", summary="修改菜单", description="修改菜单")
-async def update_obj(
-        data: MenuUpdateSchema,
-        auth: AuthSchema = Depends(AuthPermission(permissions=["system:menu:update"])),
+async def update_obj_controller(
+    data: MenuUpdateSchema,
+    auth: AuthSchema = Depends(AuthPermission(permissions=["system:menu:update"]))
 ) -> JSONResponse:
-    result_dict = await MenuService.update_menu(data=data, auth=auth)
+    result_dict = await MenuService.update_menu_service(data=data, auth=auth)
     logger.info(f"{auth.user.name} 修改菜单成功: {result_dict}")
     return SuccessResponse(data=result_dict, msg="修改菜单成功")
 
 
 @router.delete("/delete", summary="删除菜单", description="删除菜单")
-async def delete_obj(
-        id: int = Query(..., description="菜单ID"),
-        auth: AuthSchema = Depends(AuthPermission(permissions=["system:menu:delete"])),
+async def delete_obj_controller(
+    id: int = Query(..., description="菜单ID"),
+    auth: AuthSchema = Depends(AuthPermission(permissions=["system:menu:delete"]))
 ) -> JSONResponse:
-    await MenuService.delete_menu(id=id, auth=auth)
+    await MenuService.delete_menu_service(id=id, auth=auth)
     logger.info(f"{auth.user.name} 删除菜单成功: {id}")
     return SuccessResponse(msg="删除菜单成功")
 
 
 @router.patch("/available/setting", summary="批量修改菜单状态", description="批量修改菜单状态")
-async def batch_set_available_obj(
-        data: BatchSetAvailable,
-        auth: AuthSchema = Depends(AuthPermission(permissions=["system:menu:patch"])),
+async def batch_set_available_obj_controller(
+    data: BatchSetAvailable,
+    auth: AuthSchema = Depends(AuthPermission(permissions=["system:menu:patch"]))
 ) -> JSONResponse:
-    await MenuService.set_menu_available(data=data, auth=auth)
+    await MenuService.set_menu_available_service(data=data, auth=auth)
     logger.info(f"{auth.user.name} 批量修改菜单状态成功: {data.ids}")
     return SuccessResponse(msg="批量修改菜单状态成功")

backend/app/api/v1/controllers/system/notice_controller.py

@@ -23,69 +23,69 @@ from app.api.v1.schemas.system.notice_schema import (
 router = APIRouter(route_class=OperationLogRoute)
 
 @router.get("/detail", summary="获取公告详情", description="获取公告详情")
-async def get_obj_detail(
-        id: int = Query(..., description="公告ID"),
-        auth: AuthSchema = Depends(AuthPermission(permissions=["system:notice:query"])),
+async def get_obj_detail_controller(
+    id: int = Query(..., description="公告ID"),
+    auth: AuthSchema = Depends(AuthPermission(permissions=["system:notice:query"]))
 ) -> JSONResponse:
-    result_dict = await NoticeService.get_notice_detail_services(id=id, auth=auth)
+    result_dict = await NoticeService.get_notice_detail_service(id=id, auth=auth)
     logger.info(f"{auth.user.name} 获取公告详情成功 {id}")
     return SuccessResponse(data=result_dict, msg="获取公告详情成功")
 
 @router.get("/list", summary="查询公告", description="查询公告")
-async def get_obj_list(
-        page: PaginationQueryParams = Depends(),
-        search: NoticeQueryParams = Depends(),
-        auth: AuthSchema = Depends(AuthPermission(permissions=["system:notice:query"])),
+async def get_obj_list_controller(
+    page: PaginationQueryParams = Depends(),
+    search: NoticeQueryParams = Depends(),
+    auth: AuthSchema = Depends(AuthPermission(permissions=["system:notice:query"]))
 ) -> JSONResponse:
-    result_dict_list = await NoticeService.get_notice_list_services(auth=auth, search=search, order_by=page.order_by)
+    result_dict_list = await NoticeService.get_notice_list_service(auth=auth, search=search, order_by=page.order_by)
     result_dict = await PaginationService.get_page_obj(data_list= result_dict_list, page_no= page.page_no, page_size = page.page_size)
     logger.info(f"{auth.user.name} 查询公告列表成功")
     return SuccessResponse(data=result_dict, msg="查询公告列表成功")
 
 @router.post("/create", summary="创建公告", description="创建公告")
-async def create_obj(
-        data: NoticeCreateSchema,
-        auth: AuthSchema = Depends(AuthPermission(permissions=["system:notice:create"])),
+async def create_obj_controller(
+    data: NoticeCreateSchema,
+    auth: AuthSchema = Depends(AuthPermission(permissions=["system:notice:create"]))
 ) -> JSONResponse:
-    result_dict = await NoticeService.create_notice_services(auth=auth, data=data)
+    result_dict = await NoticeService.create_notice_service(auth=auth, data=data)
     logger.info(f"{auth.user.name} 创建公告成功: {result_dict}")
     return SuccessResponse(data=result_dict, msg="创建公告成功")
 
 @router.put("/update", summary="修改公告", description="修改公告")
-async def update_obj(
-        data: NoticeUpdateSchema,
-        auth: AuthSchema = Depends(AuthPermission(permissions=["system:notice:update"])),
+async def update_obj_controller(
+    data: NoticeUpdateSchema,
+    auth: AuthSchema = Depends(AuthPermission(permissions=["system:notice:update"]))
 ) -> JSONResponse:
-    result_dict = await NoticeService.update_notice_services(auth=auth, data=data)
+    result_dict = await NoticeService.update_notice_service(auth=auth, data=data)
     logger.info(f"{auth.user.name} 修改公告成功: {result_dict}")
     return SuccessResponse(data=result_dict, msg="修改公告成功")
 
 @router.delete("/delete", summary="删除公告", description="删除公告")
-async def delete_obj(
-        id: int = Query(..., description="公告ID"),
-        auth: AuthSchema = Depends(AuthPermission(permissions=["system:notice:delete"])),
+async def delete_obj_controller(
+    id: int = Query(..., description="公告ID"),
+    auth: AuthSchema = Depends(AuthPermission(permissions=["system:notice:delete"]))
 ) -> JSONResponse:
-    await NoticeService.delete_notice_services(auth=auth, id=id)
+    await NoticeService.delete_notice_service(auth=auth, id=id)
     logger.info(f"{auth.user.name} 删除公告成功: {id}")
     return SuccessResponse(msg="删除公告成功")
 
 @router.patch("/available/setting", summary="批量修改公告状态", description="批量修改公告状态")
-async def batch_set_available_obj(
-        data: BatchSetAvailable,
-        auth: AuthSchema = Depends(AuthPermission(permissions=["system:notice:patch"])),
+async def batch_set_available_obj_controller(
+    data: BatchSetAvailable,
+    auth: AuthSchema = Depends(AuthPermission(permissions=["system:notice:patch"]))
 ) -> JSONResponse:
-    await NoticeService.set_notice_available_services(auth=auth, data=data)
+    await NoticeService.set_notice_available_service(auth=auth, data=data)
     logger.info(f"{auth.user.name} 批量修改公告状态成功: {data.ids}")
     return SuccessResponse(msg="批量修改公告状态成功")
 
 @router.post('/export', summary="导出公告", description="导出公告")
-async def export_obj_list(
+async def export_obj_list_controller(
     search: NoticeQueryParams = Depends(),
-    auth: AuthSchema = Depends(AuthPermission(permissions=["system:notice:export"])),
+    auth: AuthSchema = Depends(AuthPermission(permissions=["system:notice:export"]))
 ) -> StreamingResponse:
     # 获取全量数据
-    result_dict_list = await NoticeService.get_notice_list_services(search=search, auth=auth)
-    export_result = await NoticeService.export_notice_services(notice_list=result_dict_list)
+    result_dict_list = await NoticeService.get_notice_list_service(search=search, auth=auth)
+    export_result = await NoticeService.export_notice_service(notice_list=result_dict_list)
     logger.info('导出公告成功')
 
     return StreamResponse(

backend/app/api/v1/controllers/system/operation_log_controller.py

@@ -18,48 +18,48 @@ router = APIRouter(route_class=OperationLogRoute)
 
 
 @router.get("/list", summary="查询日志", description="查询日志")
-async def get_obj_list(
+async def get_obj_list_controller(
     page: PaginationQueryParams = Depends(),
     search: OperationLogQueryParams = Depends(),
     auth: AuthSchema = Depends(AuthPermission(permissions=["system:log:query"]))
 ) -> JSONResponse:
     """ 查询日志 """
-    result_dict_list = await OperationLogService.get_log_list(search=search, auth=auth, order_by=page.order_by)
+    result_dict_list = await OperationLogService.get_log_list_service(search=search, auth=auth, order_by=page.order_by)
     result_dict = await PaginationService.get_page_obj(data_list= result_dict_list, page_no= page.page_no, page_size = page.page_size)
     logger.info(f"{auth.user.name} 查询日志成功")
     return SuccessResponse(data=result_dict, msg="查询日志成功")
 
 
 @router.get("/detail", summary="日志详情", description="日志详情")
-async def get_obj_detail(
+async def get_obj_detail_controller(
     id: int = Query(..., description="操作日志ID"),
     auth: AuthSchema = Depends(AuthPermission(permissions=["system:log:query"]))
 ) -> JSONResponse:
     """ 详情日志 """
-    result_dict = await OperationLogService.get_log_detail(id=id, auth=auth)
+    result_dict = await OperationLogService.get_log_detail_service(id=id, auth=auth)
     logger.info(f"{auth.user.name} 查询日志成功 {id}")
     return SuccessResponse(data=result_dict, msg="获取日志详情成功")
 
 
 @router.delete("/delete", summary="删除日志", description="删除日志")
-async def delete_obj_log(
+async def delete_obj_log_controller(
     id: int = Query(..., description="操作日志ID"),
     auth: AuthSchema = Depends(AuthPermission(permissions=["system:log:delete"]))
 ) -> JSONResponse:
     """ 删除日志 """
-    await OperationLogService.delete_log(id=id, auth=auth)
+    await OperationLogService.delete_log_service(id=id, auth=auth)
     logger.info(f"{auth.user.name} 删除日志成功 {id}")
     return SuccessResponse(msg="删除日志成功")
 
 
 @router.post("/export", summary="导出日志", description="导出日志")
-async def export_obj_list(
+async def export_obj_list_controller(
     search: OperationLogQueryParams = Depends(),
     auth: AuthSchema = Depends(AuthPermission(permissions=["system:log:export"]))
 ) -> StreamingResponse:
     """ 导出日志 """
-    operation_log_list = await OperationLogService.get_log_list(search=search, auth=auth)
-    operation_log_export_result = await OperationLogService.export_log_list(operation_log_list=operation_log_list)
+    operation_log_list = await OperationLogService.get_log_list_service(search=search, auth=auth)
+    operation_log_export_result = await OperationLogService.export_log_list_service(operation_log_list=operation_log_list)
     logger.info('导出日志成功')
 
     return StreamResponse(

backend/app/api/v1/controllers/system/position_controller.py

@@ -24,75 +24,75 @@ router = APIRouter(route_class=OperationLogRoute)
 
 
 @router.get("/list", summary="查询岗位", description="查询岗位")
-async def get_obj_list(
-        page: PaginationQueryParams = Depends(),
-        search: PositionQueryParams = Depends(),
-        auth: AuthSchema = Depends(AuthPermission(permissions=["system:position:query"])),
+async def get_obj_list_controller(
+    page: PaginationQueryParams = Depends(),
+    search: PositionQueryParams = Depends(),
+    auth: AuthSchema = Depends(AuthPermission(permissions=["system:position:query"])),
 ) -> JSONResponse:
-    result_dict_list = await PositionService.get_position_list(search=search, auth=auth, order_by=page.order_by)
+    result_dict_list = await PositionService.get_position_list_service(search=search, auth=auth, order_by=page.order_by)
     result_dict = await PaginationService.get_page_obj(data_list= result_dict_list, page_no= page.page_no, page_size = page.page_size)
     logger.info(f"{auth.user.name} 查询岗位列表成功")
     return SuccessResponse(data=result_dict, msg="查询岗位列表成功")
 
 
 @router.get("/detail", summary="查询岗位详情", description="查询岗位详情")
-async def get_obj_detail(
-        id: int = Query(..., description="岗位ID"),
-        auth: AuthSchema = Depends(AuthPermission(permissions=["system:position:query"])),
+async def get_obj_detail_controller(
+    id: int = Query(..., description="岗位ID"),
+    auth: AuthSchema = Depends(AuthPermission(permissions=["system:position:query"])),
 ) -> JSONResponse:
-    result_dict = await PositionService.get_position_detail(id=id, auth=auth)
+    result_dict = await PositionService.get_position_detail_service(id=id, auth=auth)
     logger.info(f"{auth.user.name} 查询岗位详情成功 {id}")
     return SuccessResponse(data=result_dict, msg="获取岗位详情成功")
 
 
 @router.post("/create", summary="创建岗位", description="创建岗位")
-async def create_obj(
-        data: PositionCreateSchema,
-        auth: AuthSchema = Depends(AuthPermission(permissions=["system:position:create"])),
+async def create_obj_controller(
+    data: PositionCreateSchema,
+    auth: AuthSchema = Depends(AuthPermission(permissions=["system:position:create"])),
 ) -> JSONResponse:
-    result_dict = await PositionService.create_position(data=data, auth=auth)
+    result_dict = await PositionService.create_position_service(data=data, auth=auth)
     logger.info(f"{auth.user.name} 创建岗位成功: {result_dict}")
     return SuccessResponse(data=result_dict, msg="创建岗位成功")
 
 
 @router.put("/update", summary="修改岗位", description="修改岗位")
-async def update_obj(
-        data: PositionUpdateSchema,
-        auth: AuthSchema = Depends(AuthPermission(permissions=["system:position:update"])),
+async def update_obj_controller(
+    data: PositionUpdateSchema,
+    auth: AuthSchema = Depends(AuthPermission(permissions=["system:position:update"])),
 ) -> JSONResponse:
-    result_dict = await PositionService.update_position(data=data, auth=auth)
+    result_dict = await PositionService.update_position_service(data=data, auth=auth)
     logger.info(f"{auth.user.name} 修改岗位成功: {result_dict}")
     return SuccessResponse(data=result_dict, msg="修改岗位成功")
 
 
 @router.delete("/delete", summary="删除岗位", description="删除岗位")
-async def delete_obj(
-        id: int = Query(..., description="岗位ID"),
-        auth: AuthSchema = Depends(AuthPermission(permissions=["system:position:delete"])),
+async def delete_obj_controller(
+    id: int = Query(..., description="岗位ID"),
+    auth: AuthSchema = Depends(AuthPermission(permissions=["system:position:delete"])),
 ) -> JSONResponse:
-    await PositionService.delete_position(id=id, auth=auth)
+    await PositionService.delete_position_service(id=id, auth=auth)
     logger.info(f"{auth.user.name} 删除岗位成功: {id}")
     return SuccessResponse(msg="删除岗位成功")
 
 
 @router.patch("/available/setting", summary="批量修改岗位状态", description="批量修改岗位状态")
-async def batch_set_available_obj(
-        data: BatchSetAvailable,
-        auth: AuthSchema = Depends(AuthPermission(permissions=["system:position:patch"])),
+async def batch_set_available_obj_controller(
+    data: BatchSetAvailable,
+    auth: AuthSchema = Depends(AuthPermission(permissions=["system:position:patch"])),
 ) -> JSONResponse:
-    await PositionService.set_position_available(data=data, auth=auth)
+    await PositionService.set_position_available_service(data=data, auth=auth)
     logger.info(f"{auth.user.name} 批量修改岗位状态成功: {data.ids}")
     return SuccessResponse(msg="批量修改岗位状态成功")
 
 
 @router.post('/export', summary="导出岗位", description="导出岗位")
-async def export_obj_list(
+async def export_obj_list_controller(
     search: PositionQueryParams = Depends(),
     auth: AuthSchema = Depends(AuthPermission(permissions=["system:position:export"])),
 ) -> StreamingResponse:
     # 获取全量数据
-    position_query_result = await PositionService.get_position_list(search=search, auth=auth)
-    position_export_result = await PositionService.export_post_list(post_list=position_query_result)
+    position_query_result = await PositionService.get_position_list_service(search=search, auth=auth)
+    position_export_result = await PositionService.export_post_list_service(post_list=position_query_result)
     logger.info('导出岗位成功')
 
     return StreamResponse(

backend/app/api/v1/controllers/system/role_controller.py

@@ -25,85 +25,85 @@ router = APIRouter(route_class=OperationLogRoute)
 
 
 @router.get("/list", summary="查询角色", description="查询角色")
-async def get_obj_list(
-        page: PaginationQueryParams = Depends(),
-        search: RoleQueryParams = Depends(),
-        auth: AuthSchema = Depends(AuthPermission(permissions=["system:role:query"])),
+async def get_obj_list_controller(
+    page: PaginationQueryParams = Depends(),
+    search: RoleQueryParams = Depends(),
+    auth: AuthSchema = Depends(AuthPermission(permissions=["system:role:query"])),
 ) -> JSONResponse:
-    result_dict_list = await RoleService.get_role_list(search=search, auth=auth, order_by=page.order_by)
+    result_dict_list = await RoleService.get_role_list_service(search=search, auth=auth, order_by=page.order_by)
     result_dict = await PaginationService.get_page_obj(data_list= result_dict_list, page_no= page.page_no, page_size = page.page_size)
     logger.info(f"{auth.user.name} 查询角色成功")
     return SuccessResponse(data=result_dict, msg="查询角色成功")
 
 
 @router.get("/detail", summary="查询角色详情", description="查询角色详情")
-async def get_obj_detail(
-        id: int = Query(..., description="角色ID"),
-        auth: AuthSchema = Depends(AuthPermission(permissions=["system:role:query"])),
+async def get_obj_detail_controller(
+    id: int = Query(..., description="角色ID"),
+    auth: AuthSchema = Depends(AuthPermission(permissions=["system:role:query"])),
 ) -> JSONResponse:
-    result_dict = await RoleService.get_role_detail(id=id, auth=auth)
+    result_dict = await RoleService.get_role_detail_service(id=id, auth=auth)
     logger.info(f"{auth.user.name} 获取角色详情成功 {id}")
     return SuccessResponse(data=result_dict, msg="获取角色详情成功")
 
 
 @router.post("/create", summary="创建角色", description="创建角色")
-async def create_obj(
-        data: RoleCreateSchema,
-        auth: AuthSchema = Depends(AuthPermission(permissions=["system:role:create"])),
+async def create_obj_controller(
+    data: RoleCreateSchema,
+    auth: AuthSchema = Depends(AuthPermission(permissions=["system:role:create"])),
 ) -> JSONResponse:
-    result_dict = await RoleService.create_role(data=data, auth=auth)
+    result_dict = await RoleService.create_role_service(data=data, auth=auth)
     logger.info(f"{auth.user.name} 创建角色成功: {result_dict}")
     return SuccessResponse(data=result_dict, msg="创建角色成功")
 
 
 @router.put("/update", summary="修改角色", description="修改角色")
-async def update_obj(
-        data: RoleUpdateSchema,
-        auth: AuthSchema = Depends(AuthPermission(permissions=["system:role:update"])),
+async def update_obj_controller(
+    data: RoleUpdateSchema,
+    auth: AuthSchema = Depends(AuthPermission(permissions=["system:role:update"])),
 ) -> JSONResponse:
-    result_dict = await RoleService.update_role(data=data, auth=auth)
+    result_dict = await RoleService.update_role_service(data=data, auth=auth)
     logger.info(f"{auth.user.name} 修改角色成功: {result_dict}")
     return SuccessResponse(data=result_dict, msg="修改角色成功")
 
 
 @router.delete("/delete", summary="删除角色", description="删除角色")
-async def delete_obj(
-        id: int = Query(..., description="角色ID"),
-        auth: AuthSchema = Depends(AuthPermission(permissions=["system:role:delete"])),
+async def delete_obj_controller(
+    id: int = Query(..., description="角色ID"),
+    auth: AuthSchema = Depends(AuthPermission(permissions=["system:role:delete"])),
 ) -> JSONResponse:
-    await RoleService.delete_role(id=id, auth=auth)
+    await RoleService.delete_role_service(id=id, auth=auth)
     logger.info(f"{auth.user.name} 删除角色成功: {id}")
     return SuccessResponse(msg="删除角色成功")
 
 
 @router.patch("/available/setting", summary="批量修改角色状态", description="批量修改角色状态")
-async def batch_set_available_obj(
-        data: BatchSetAvailable,
-        auth: AuthSchema = Depends(AuthPermission(permissions=["system:role:patch"])),
+async def batch_set_available_obj_controller(
+    data: BatchSetAvailable,
+    auth: AuthSchema = Depends(AuthPermission(permissions=["system:role:patch"])),
 ) -> JSONResponse:
-    await RoleService.set_role_available(data=data, auth=auth)
+    await RoleService.set_role_available_service(data=data, auth=auth)
     logger.info(f"{auth.user.name} 批量修改角色状态成功: {data.ids}")
     return SuccessResponse(msg="批量修改角色状态成功")
 
 
 @router.patch("/permission/setting", summary="角色授权", description="角色授权")
-async def set_role_permission(
-        data: RolePermissionSettingSchema,
-        auth: AuthSchema = Depends(AuthPermission(permissions=["system:role:permission"])),
+async def set_role_permission_controller(
+    data: RolePermissionSettingSchema,
+    auth: AuthSchema = Depends(AuthPermission(permissions=["system:role:permission"])),
 ) -> JSONResponse:
-    await RoleService.set_role_permission(data=data, auth=auth)
+    await RoleService.set_role_permission_service(data=data, auth=auth)
     logger.info(f"{auth.user.name} 设置角色权限成功: {data}")
     return SuccessResponse(msg="授权角色成功")
 
 
 @router.post('/export', summary="导出角色", description="导出角色")
-async def export_obj_list(
+async def export_obj_list_controller(
     search: RoleQueryParams = Depends(),
     auth: AuthSchema = Depends(AuthPermission(permissions=["system:role:export"])),
 ) -> StreamingResponse:
     # 获取全量数据
-    role_query_result = await RoleService.get_role_list(search=search, auth=auth)
-    role_export_result = await RoleService.export_role_list(role_list=role_query_result)
+    role_query_result = await RoleService.get_role_list_service(search=search, auth=auth)
+    role_export_result = await RoleService.export_role_list_service(role_list=role_query_result)
     logger.info('导出角色成功')
 
     return StreamResponse(

backend/app/api/v1/controllers/system/user_controller.py

@@ -29,131 +29,131 @@ router = APIRouter(route_class=OperationLogRoute)
 
 
 @router.get("/current/info", summary="查询当前用户信息", description="查询当前用户信息")
-async def get_current_user_info(
-        auth: AuthSchema = Depends(get_current_user)
+async def get_current_user_info_controller(
+    auth: AuthSchema = Depends(get_current_user)
 ) -> JSONResponse:
-    result_dict = await UserService.get_current_user_info(auth=auth)
+    result_dict = await UserService.get_current_user_info_service(auth=auth)
     logger.info(f"{auth.user.name} 获取当前用户信息成功")
     return SuccessResponse(data=result_dict, msg='获取当前用户信息成功')
 
 
 @router.post("/current/avatar/upload", summary="上传当前用户头像", dependencies=[Depends(get_current_user)])
-async def user_avatar_upload(
-        file: UploadFile, 
-        request: Request
+async def user_avatar_upload_controller(
+    file: UploadFile, 
+    request: Request
 ) -> JSONResponse:
-    result_str = await UserService.upload_avatar(request=request, file=file)
+    result_str = await UserService.upload_avatar_service(request=request, file=file)
     logger.info(f"上传头像成功: {result_str}")
     return SuccessResponse(data=result_str, msg='上传头像成功')
 
 
 @router.put("/current/info/update", summary="更新当前用户基本信息", description="更新当前用户基本信息")
-async def update_current_user_info(
-        data: CurrentUserUpdateSchema,
-        auth: AuthSchema = Depends(get_current_user)
+async def update_current_user_info_controller(
+    data: CurrentUserUpdateSchema,
+    auth: AuthSchema = Depends(get_current_user)
 ) -> JSONResponse:
-    result_dict = await UserService.update_current_user_info(data=data, auth=auth)
+    result_dict = await UserService.update_current_user_info_service(data=data, auth=auth)
     logger.info(f"{auth.user.name} 更新当前用户基本信息成功: {result_dict}")
     return SuccessResponse(data=result_dict, msg='更新当前用户基本信息成功')
 
 
 @router.put("/current/password/change", summary="修改当前用户密码", description="修改当前用户密码")
-async def change_current_user_password(
-        data: UserChangePasswordSchema,
-        auth: AuthSchema = Depends(get_current_user)
+async def change_current_user_password_controller(
+    data: UserChangePasswordSchema,
+    auth: AuthSchema = Depends(get_current_user)
 ) -> JSONResponse:
-    result_dict = await UserService.change_user_password(data=data, auth=auth)
+    result_dict = await UserService.change_user_password_service(data=data, auth=auth)
     logger.info(f"{auth.user.name} 修改密码成功: {result_dict}")
     return SuccessResponse(data=result_dict, msg='修改密码成功')
 
 
 @router.post('/register', summary="注册用户", description="注册用户")
-async def register_user(
-        data: UserRegisterSchema, 
-        db: AsyncSession = Depends(db_getter),
+async def register_user_controller(
+    data: UserRegisterSchema, 
+    db: AsyncSession = Depends(db_getter),
 ) -> JSONResponse:
     auth = AuthSchema(db=db)
-    user_register_result = await UserService.register_user(data=data, auth=auth)
+    user_register_result = await UserService.register_user_service(data=data, auth=auth)
     logger.info(f"{data.username} 注册用户成功: {user_register_result}")
     return SuccessResponse(data=user_register_result, msg='注册用户成功')
 
 
 @router.post('/forget/password', summary="忘记密码", description="忘记密码")
-async def forget_password(
-        data: UserForgetPasswordSchema, 
-        db: AsyncSession = Depends(db_getter),
+async def forget_password_controller(
+    data: UserForgetPasswordSchema, 
+    db: AsyncSession = Depends(db_getter),
 ) -> JSONResponse:
     auth = AuthSchema(db=db)
-    user_forget_password_result = await UserService.forget_password(data=data, auth=auth)
+    user_forget_password_result = await UserService.forget_password_service(data=data, auth=auth)
     logger.info(f"{data.username} 忘记密码,重置密码成功: {user_forget_password_result}")
     return SuccessResponse(data=user_forget_password_result, msg='忘记密码,重置密码成功')
 
 
 @router.get("/list", summary="查询用户", description="查询用户")
-async def get_obj_list(
-        page: PaginationQueryParams = Depends(),
-        search: UserQueryParams = Depends(),
-        auth: AuthSchema = Depends(AuthPermission(permissions=["system:user:query"])),
+async def get_obj_list_controller(
+    page: PaginationQueryParams = Depends(),
+    search: UserQueryParams = Depends(),
+    auth: AuthSchema = Depends(AuthPermission(permissions=["system:user:query"])),
 ) -> JSONResponse:
-    result_dict_list = await UserService.get_user_list(search=search, auth=auth, order_by=page.order_by)
+    result_dict_list = await UserService.get_user_list_service(search=search, auth=auth, order_by=page.order_by)
     result_dict = await PaginationService.get_page_obj(data_list= result_dict_list, page_no= page.page_no, page_size = page.page_size)
     logger.info(f"{auth.user.name} 查询用户成功")
     return SuccessResponse(data=result_dict, msg="查询用户成功")
 
 
 @router.get("/detail", summary="查询用户详情", description="查询用户详情")
-async def get_obj_detail(
-        id: int = Query(..., description="用户ID"),
-        auth: AuthSchema = Depends(AuthPermission(permissions=["system:user:query"])),
+async def get_obj_detail_controller(
+    id: int = Query(..., description="用户ID"),
+    auth: AuthSchema = Depends(AuthPermission(permissions=["system:user:query"])),
 ) -> JSONResponse:
-    result_dict = await UserService.get_detail_by_id(id=id, auth=auth)
+    result_dict = await UserService.get_detail_by_id_service(id=id, auth=auth)
     logger.info(f"{auth.user.name} 获取用户详情成功 {id}")
     return SuccessResponse(data=result_dict, msg='获取用户详情成功')
 
 
 @router.post("/create", summary="创建用户", description="创建用户")
-async def create_obj(
-        data: UserCreateSchema,
-        auth: AuthSchema = Depends(AuthPermission(permissions=["system:user:create"])),
+async def create_obj_controller(
+    data: UserCreateSchema,
+    auth: AuthSchema = Depends(AuthPermission(permissions=["system:user:create"])),
 ) -> JSONResponse:
-    result_dict = await UserService.create_user(data=data, auth=auth)
+    result_dict = await UserService.create_user_service(data=data, auth=auth)
     logger.info(f"{auth.user.name} 创建用户成功: {result_dict}")
     return SuccessResponse(data=result_dict, msg="创建用户成功")
 
 
 @router.put("/update", summary="修改用户", description="修改用户")
-async def update_obj(
-        data: UserUpdateSchema,
-        auth: AuthSchema = Depends(AuthPermission(permissions=["system:user:update"])),
+async def update_obj_controller(
+    data: UserUpdateSchema,
+    auth: AuthSchema = Depends(AuthPermission(permissions=["system:user:update"])),
 ) -> JSONResponse:
-    result_dict = await UserService.update_user(data=data, auth=auth)
+    result_dict = await UserService.update_user_service(data=data, auth=auth)
     logger.info(f"{auth.user.name} 修改用户成功: {result_dict}")
     return SuccessResponse(data=result_dict, msg="修改用户成功")
 
 
 @router.delete("/delete", summary="删除用户", description="删除用户")
-async def delete_obj(
-        id: int = Query(..., description="用户ID"),
-        auth: AuthSchema = Depends(AuthPermission(permissions=["system:user:delete"])),
+async def delete_obj_controller(
+    id: int = Query(..., description="用户ID"),
+    auth: AuthSchema = Depends(AuthPermission(permissions=["system:user:delete"])),
 ) -> JSONResponse:
-    await UserService.delete_user(id=id, auth=auth)
+    await UserService.delete_user_service(id=id, auth=auth)
     logger.info(f"{auth.user.name} 删除用户成功: {id}")
     return SuccessResponse(msg="删除用户成功")
 
 
 @router.patch("/available/setting", summary="批量修改用户状态", description="批量修改用户状态")
-async def batch_set_available_obj(
-        data: BatchSetAvailable,
-        auth: AuthSchema = Depends(AuthPermission(permissions=["system:user:patch"])),
+async def batch_set_available_obj_controller(
+    data: BatchSetAvailable,
+    auth: AuthSchema = Depends(AuthPermission(permissions=["system:user:patch"])),
 ) -> JSONResponse:
-    await UserService.set_user_available(data=data, auth=auth)
+    await UserService.set_user_available_service(data=data, auth=auth)
     logger.info(f"{auth.user.name} 批量修改用户状态成功: {data.ids}")
     return SuccessResponse(msg="批量修改用户状态成功")
 
 
 @router.post('/import/template', summary="获取用户导入模板", description="获取用户导入模板", dependencies=[Depends(AuthPermission(permissions=["system:user:import"]))])
-async def export_obj_template()-> StreamingResponse:
-    user_import_template_result = await UserService.get_import_template_user()
+async def export_obj_template_controller()-> StreamingResponse:
+    user_import_template_result = await UserService.get_import_template_user_service()
     logger.info('获取用户导入模板成功')
 
     return StreamResponse(
@@ -167,14 +167,14 @@ async def export_obj_template()-> StreamingResponse:
 
 
 @router.post('/export', summary="导出用户", description="导出用户")
-async def export_obj_list(
+async def export_obj_list_controller(
     page: PaginationQueryParams = Depends(),
     search: UserQueryParams = Depends(),
     auth: AuthSchema = Depends(AuthPermission(permissions=["system:user:export"])),
 ) -> StreamingResponse:
     # 获取全量数据
-    user_list = await UserService.get_user_list(auth=auth, search=search, order_by=page.order_by)
-    user_export_result = await UserService.export_user_list(user_list)
+    user_list = await UserService.get_user_list_service(auth=auth, search=search, order_by=page.order_by)
+    user_export_result = await UserService.export_user_list_service(user_list)
     logger.info('导出用户成功')
 
     return StreamResponse(
@@ -187,10 +187,10 @@ async def export_obj_list(
 
 
 @router.post('/import/data', summary="导入用户", description="导入用户")
-async def import_obj_list(
+async def import_obj_list_controller(
     file: UploadFile,
     auth: AuthSchema = Depends(AuthPermission(permissions=["system:user:import"]))
 ) -> JSONResponse:
-    batch_import_result = await UserService.batch_import_user(file=file, auth=auth, update_support=True)
+    batch_import_result = await UserService.batch_import_user_service(file=file, auth=auth, update_support=True)
     logger.info(f"{auth.user.name} 导入用户成功: {batch_import_result}")
     return SuccessResponse(data=batch_import_result, msg="导入用户成功")