perf: 优化日志管理模块service层及异常处理

ruoyi-fastapi-backend/module_admin/controller/log_controller.py

@@ -17,134 +17,87 @@ 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: AsyncSession = Depends(get_db)):
-    try:
     # 获取分页数据
     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:
-        logger.exception(e)
-        return ResponseUtil.error(msg=str(e))
 
 
 @logController.delete("/operlog/clean", dependencies=[Depends(CheckUserInterfaceAuth('monitor:operlog:remove'))])
 @log_decorator(title='操作日志管理', business_type=BusinessType.CLEAN)
 async def clear_system_operation_log(request: Request, query_db: AsyncSession = Depends(get_db)):
-    try:
     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)
-        else:
-            logger.warning(clear_operation_log_result.message)
-            return ResponseUtil.failure(msg=clear_operation_log_result.message)
-    except Exception as e:
-        logger.exception(e)
-        return ResponseUtil.error(msg=str(e))
 
 
 @logController.delete("/operlog/{oper_ids}", dependencies=[Depends(CheckUserInterfaceAuth('monitor:operlog:remove'))])
 @log_decorator(title='操作日志管理', business_type=BusinessType.DELETE)
 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 = 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)
-        else:
-            logger.warning(delete_operation_log_result.message)
-            return ResponseUtil.failure(msg=delete_operation_log_result.message)
-    except Exception as e:
-        logger.exception(e)
-        return ResponseUtil.error(msg=str(e))
 
 
 @logController.post("/operlog/export", dependencies=[Depends(CheckUserInterfaceAuth('monitor:operlog:export'))])
 @log_decorator(title='操作日志管理', business_type=BusinessType.EXPORT)
 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 = 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))
-    except Exception as e:
-        logger.exception(e)
-        return ResponseUtil.error(msg=str(e))
 
 
 @logController.get("/logininfor/list", response_model=PageResponseModel, dependencies=[Depends(CheckUserInterfaceAuth('monitor:logininfor:list'))])
 async def get_system_login_log_list(request: Request, login_log_page_query: LoginLogPageQueryModel = Depends(LoginLogPageQueryModel.as_query), query_db: AsyncSession = Depends(get_db)):
-    try:
     # 获取分页数据
     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:
-        logger.exception(e)
-        return ResponseUtil.error(msg=str(e))
 
 
 @logController.delete("/logininfor/clean", dependencies=[Depends(CheckUserInterfaceAuth('monitor:logininfor:remove'))])
 @log_decorator(title='登录日志管理', business_type=BusinessType.CLEAN)
 async def clear_system_login_log(request: Request, query_db: AsyncSession = Depends(get_db)):
-    try:
     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)
-        else:
-            logger.warning(clear_login_log_result.message)
-            return ResponseUtil.failure(msg=clear_login_log_result.message)
-    except Exception as e:
-        logger.exception(e)
-        return ResponseUtil.error(msg=str(e))
 
 
 @logController.delete("/logininfor/{info_ids}", dependencies=[Depends(CheckUserInterfaceAuth('monitor:logininfor:remove'))])
 @log_decorator(title='登录日志管理', business_type=BusinessType.DELETE)
 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 = 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)
-        else:
-            logger.warning(delete_login_log_result.message)
-            return ResponseUtil.failure(msg=delete_login_log_result.message)
-    except Exception as e:
-        logger.exception(e)
-        return ResponseUtil.error(msg=str(e))
 
 
 @logController.get("/logininfor/unlock/{user_name}", dependencies=[Depends(CheckUserInterfaceAuth('monitor:logininfor:unlock'))])
 @log_decorator(title='登录日志管理', business_type=BusinessType.OTHER)
 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)
-        if unlock_user_result.is_success:
     logger.info(unlock_user_result.message)
+
     return ResponseUtil.success(msg=unlock_user_result.message)
-        else:
-            logger.warning(unlock_user_result.message)
-            return ResponseUtil.failure(msg=unlock_user_result.message)
-    except Exception as e:
-        logger.exception(e)
-        return ResponseUtil.error(msg=str(e))
 
 
 @logController.post("/logininfor/export", dependencies=[Depends(CheckUserInterfaceAuth('monitor:logininfor:export'))])
 @log_decorator(title='登录日志管理', business_type=BusinessType.EXPORT)
 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 = 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:
-        logger.exception(e)
-        return ResponseUtil.error(msg=str(e))

ruoyi-fastapi-backend/module_admin/service/log_service.py

@@ -1,6 +1,7 @@
 from module_admin.dao.log_dao import *
 from module_admin.service.dict_service import Request, DictDataService
 from module_admin.entity.vo.common_vo import CrudResponseModel
+from exceptions.exception import ServiceException
 from utils.common_util import export_list2excel, CamelCaseUtil
 
 
@@ -33,12 +34,10 @@ class OperationLogService:
         try:
             await OperationLogDao.add_operation_log_dao(query_db, page_object)
             await query_db.commit()
-            result = dict(is_success=True, message='新增成功')
+            return CrudResponseModel(is_success=True, message='新增成功')
         except Exception as e:
             await query_db.rollback()
-            result = dict(is_success=False, message=str(e))
-
-        return CrudResponseModel(**result)
+            raise e
 
     @classmethod
     async def delete_operation_log_services(cls, query_db: AsyncSession, page_object: DeleteOperLogModel):
@@ -54,13 +53,12 @@ class OperationLogService:
                 for oper_id in oper_id_list:
                     await OperationLogDao.delete_operation_log_dao(query_db, OperLogModel(operId=oper_id))
                 await query_db.commit()
-                result = dict(is_success=True, message='删除成功')
+                return CrudResponseModel(is_success=True, message='删除成功')
             except Exception as e:
                 await query_db.rollback()
                 raise e
         else:
-            result = dict(is_success=False, message='传入操作日志id为空')
-        return CrudResponseModel(**result)
+            raise ServiceException(message='传入操作日志id为空')
 
     @classmethod
     async def clear_operation_log_services(cls, query_db: AsyncSession):
@@ -72,13 +70,11 @@ class OperationLogService:
         try:
             await OperationLogDao.clear_operation_log_dao(query_db)
             await query_db.commit()
-            result = dict(is_success=True, message='清除成功')
+            return CrudResponseModel(is_success=True, message='清除成功')
         except Exception as e:
             await query_db.rollback()
             raise e
 
-        return CrudResponseModel(**result)
-
     @classmethod
     async def export_operation_log_list_services(cls, request: Request, operation_log_list: List):
         """
@@ -155,12 +151,10 @@ class LoginLogService:
         try:
             await LoginLogDao.add_login_log_dao(query_db, page_object)
             await query_db.commit()
-            result = dict(is_success=True, message='新增成功')
+            return CrudResponseModel(is_success=True, message='新增成功')
         except Exception as e:
             await query_db.rollback()
-            result = dict(is_success=False, message=str(e))
-
-        return CrudResponseModel(**result)
+            raise e
 
     @classmethod
     async def delete_login_log_services(cls, query_db: AsyncSession, page_object: DeleteLoginLogModel):
@@ -176,13 +170,12 @@ class LoginLogService:
                 for info_id in info_id_list:
                     await LoginLogDao.delete_login_log_dao(query_db, LogininforModel(infoId=info_id))
                 await query_db.commit()
-                result = dict(is_success=True, message='删除成功')
+                return CrudResponseModel(is_success=True, message='删除成功')
             except Exception as e:
                 await query_db.rollback()
                 raise e
         else:
-            result = dict(is_success=False, message='传入登录日志id为空')
-        return CrudResponseModel(**result)
+            raise ServiceException(message='传入登录日志id为空')
 
     @classmethod
     async def clear_login_log_services(cls, query_db: AsyncSession):
@@ -194,22 +187,19 @@ class LoginLogService:
         try:
             await LoginLogDao.clear_login_log_dao(query_db)
             await query_db.commit()
-            result = dict(is_success=True, message='清除成功')
+            return CrudResponseModel(is_success=True, message='清除成功')
         except Exception as e:
             await query_db.rollback()
             raise e
 
-        return CrudResponseModel(**result)
-
     @classmethod
     async def unlock_user_services(cls, request: Request, unlock_user: UnlockUser):
         locked_user = await request.app.state.redis.get(f"account_lock:{unlock_user.user_name}")
         if locked_user:
             await request.app.state.redis.delete(f"account_lock:{unlock_user.user_name}")
-            result = dict(is_success=True, message='解锁成功')
+            return CrudResponseModel(is_success=True, message='解锁成功')
         else:
-            result = dict(is_success=False, message='该用户未锁定')
-        return CrudResponseModel(**result)
+            raise ServiceException(message='该用户未锁定')
 
     @staticmethod
     async def export_login_log_list_services(login_log_list: List):