perf: 优化定时任务模块service层及异常处理

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

@@ -35,14 +35,11 @@ async def get_system_job_list(
     job_page_query: JobPageQueryModel = Depends(JobPageQueryModel.as_query),
     query_db: AsyncSession = Depends(get_db),
 ):
-    try:
-        # 获取分页数据
-        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:
-        logger.exception(e)
-        return ResponseUtil.error(msg=str(e))
+    # 获取分页数据
+    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)
 
 
 @jobController.post('/job', dependencies=[Depends(CheckUserInterfaceAuth('monitor:job:add'))])
@@ -54,21 +51,14 @@ async def add_system_job(
     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.create_time = datetime.now()
-        add_job.update_by = current_user.user.user_name
-        add_job.update_time = datetime.now()
-        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)
-        else:
-            logger.warning(add_job_result.message)
-            return ResponseUtil.failure(msg=add_job_result.message)
-    except Exception as e:
-        logger.exception(e)
-        return ResponseUtil.error(msg=str(e))
+    add_job.create_by = current_user.user.user_name
+    add_job.create_time = datetime.now()
+    add_job.update_by = current_user.user.user_name
+    add_job.update_time = datetime.now()
+    add_job_result = await JobService.add_job_services(query_db, add_job)
+    logger.info(add_job_result.message)
+
+    return ResponseUtil.success(msg=add_job_result.message)
 
 
 @jobController.put('/job', dependencies=[Depends(CheckUserInterfaceAuth('monitor:job:edit'))])
@@ -80,89 +70,62 @@ async def edit_system_job(
     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 = 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)
-        else:
-            logger.warning(edit_job_result.message)
-            return ResponseUtil.failure(msg=edit_job_result.message)
-    except Exception as e:
-        logger.exception(e)
-        return ResponseUtil.error(msg=str(e))
+    edit_job.update_by = current_user.user.user_name
+    edit_job.update_time = datetime.now()
+    edit_job_result = await JobService.edit_job_services(query_db, edit_job)
+    logger.info(edit_job_result.message)
+
+    return ResponseUtil.success(msg=edit_job_result.message)
 
 
 @jobController.put('/job/changeStatus', dependencies=[Depends(CheckUserInterfaceAuth('monitor:job:changeStatus'))])
 @log_decorator(title='定时任务管理', business_type=BusinessType.UPDATE)
 async def change_system_job_status(
     request: Request,
-    edit_job: EditJobModel,
+    change_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 = 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)
-        else:
-            logger.warning(edit_job_result.message)
-            return ResponseUtil.failure(msg=edit_job_result.message)
-    except Exception as e:
-        logger.exception(e)
-        return ResponseUtil.error(msg=str(e))
+    edit_job = EditJobModel(
+        jobId=change_job.job_id,
+        status=change_job.status,
+        updateBy=current_user.user.user_name,
+        updateTime=datetime.now(),
+        type='status',
+    )
+    edit_job_result = await JobService.edit_job_services(query_db, edit_job)
+    logger.info(edit_job_result.message)
+
+    return ResponseUtil.success(msg=edit_job_result.message)
 
 
 @jobController.put('/job/run', dependencies=[Depends(CheckUserInterfaceAuth('monitor:job:changeStatus'))])
 @log_decorator(title='定时任务管理', business_type=BusinessType.UPDATE)
 async def execute_system_job(request: Request, execute_job: JobModel, query_db: AsyncSession = Depends(get_db)):
-    try:
-        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)
-        else:
-            logger.warning(execute_job_result.message)
-            return ResponseUtil.failure(msg=execute_job_result.message)
-    except Exception as e:
-        logger.exception(e)
-        return ResponseUtil.error(msg=str(e))
+    execute_job_result = await JobService.execute_job_once_services(query_db, execute_job)
+    logger.info(execute_job_result.message)
+
+    return ResponseUtil.success(msg=execute_job_result.message)
 
 
 @jobController.delete('/job/{job_ids}', dependencies=[Depends(CheckUserInterfaceAuth('monitor:job:remove'))])
 @log_decorator(title='定时任务管理', business_type=BusinessType.DELETE)
 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 = 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)
-        else:
-            logger.warning(delete_job_result.message)
-            return ResponseUtil.failure(msg=delete_job_result.message)
-    except Exception as e:
-        logger.exception(e)
-        return ResponseUtil.error(msg=str(e))
+    delete_job = DeleteJobModel(jobIds=job_ids)
+    delete_job_result = await JobService.delete_job_services(query_db, delete_job)
+    logger.info(delete_job_result.message)
+
+    return ResponseUtil.success(msg=delete_job_result.message)
 
 
 @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: AsyncSession = Depends(get_db)):
-    try:
-        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:
-        logger.exception(e)
-        return ResponseUtil.error(msg=str(e))
+    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)
 
 
 @jobController.post('/job/export', dependencies=[Depends(CheckUserInterfaceAuth('monitor:job:export'))])
@@ -172,15 +135,12 @@ async def export_system_job_list(
     job_page_query: JobPageQueryModel = Depends(JobPageQueryModel.as_form),
     query_db: AsyncSession = Depends(get_db),
 ):
-    try:
-        # 获取全量数据
-        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))
-    except Exception as e:
-        logger.exception(e)
-        return ResponseUtil.error(msg=str(e))
+    # 获取全量数据
+    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))
 
 
 @jobController.get(
@@ -191,49 +151,32 @@ async def get_system_job_log_list(
     job_log_page_query: JobLogPageQueryModel = Depends(JobLogPageQueryModel.as_query),
     query_db: AsyncSession = Depends(get_db),
 ):
-    try:
-        # 获取分页数据
-        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:
-        logger.exception(e)
-        return ResponseUtil.error(msg=str(e))
+    # 获取分页数据
+    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)
 
 
 @jobController.delete('/jobLog/clean', dependencies=[Depends(CheckUserInterfaceAuth('monitor:job:remove'))])
 @log_decorator(title='定时任务日志管理', business_type=BusinessType.CLEAN)
 async def clear_system_job_log(request: Request, query_db: AsyncSession = Depends(get_db)):
-    try:
-        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)
-        else:
-            logger.warning(clear_job_log_result.message)
-            return ResponseUtil.failure(msg=clear_job_log_result.message)
-    except Exception as e:
-        logger.exception(e)
-        return ResponseUtil.error(msg=str(e))
+    clear_job_log_result = await JobLogService.clear_job_log_services(query_db)
+    logger.info(clear_job_log_result.message)
+
+    return ResponseUtil.success(msg=clear_job_log_result.message)
 
 
 @jobController.delete('/jobLog/{job_log_ids}', dependencies=[Depends(CheckUserInterfaceAuth('monitor:job:remove'))])
 @log_decorator(title='定时任务日志管理', business_type=BusinessType.DELETE)
 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 = 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)
-        else:
-            logger.warning(delete_job_log_result.message)
-            return ResponseUtil.failure(msg=delete_job_log_result.message)
-    except Exception as e:
-        logger.exception(e)
-        return ResponseUtil.error(msg=str(e))
+    delete_job_log = DeleteJobLogModel(jobLogIds=job_log_ids)
+    delete_job_log_result = await JobLogService.delete_job_log_services(query_db, delete_job_log)
+    logger.info(delete_job_log_result.message)
+
+    return ResponseUtil.success(msg=delete_job_log_result.message)
 
 
 @jobController.post('/jobLog/export', dependencies=[Depends(CheckUserInterfaceAuth('monitor:job:export'))])
@@ -243,14 +186,9 @@ async def export_system_job_log_list(
     job_log_page_query: JobLogPageQueryModel = Depends(JobLogPageQueryModel.as_form),
     query_db: AsyncSession = Depends(get_db),
 ):
-    try:
-        # 获取全量数据
-        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))
-    except Exception as e:
-        logger.exception(e)
-        return ResponseUtil.error(msg=str(e))
+    # 获取全量数据
+    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))

ruoyi-fastapi-backend/module_admin/dao/job_dao.py

@@ -36,10 +36,13 @@ class JobDao:
             (
                 await db.execute(
                     select(SysJob).where(
-                        SysJob.job_name == job.job_name if job.job_name else True,
-                        SysJob.job_group == job.job_group if job.job_group else True,
-                        SysJob.invoke_target == job.invoke_target if job.invoke_target else True,
-                        SysJob.cron_expression == job.cron_expression if job.cron_expression else True,
+                        SysJob.job_name == job.job_name,
+                        SysJob.job_group == job.job_group,
+                        SysJob.job_executor == job.job_executor,
+                        SysJob.invoke_target == job.invoke_target,
+                        SysJob.job_args == job.job_args,
+                        SysJob.job_kwargs == job.job_kwargs,
+                        SysJob.cron_expression == job.cron_expression,
                     )
                 )
             )

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

@@ -1,12 +1,15 @@
 from fastapi import Request
 from sqlalchemy.ext.asyncio import AsyncSession
 from typing import List
+from config.constant import CommonConstant, JobConstant
 from config.get_scheduler import SchedulerUtil
+from exceptions.exception import ServiceException
 from module_admin.dao.job_dao import JobDao
 from module_admin.entity.vo.common_vo import CrudResponseModel
 from module_admin.entity.vo.job_vo import DeleteJobModel, EditJobModel, JobModel, JobPageQueryModel
 from module_admin.service.dict_service import DictDataService
 from utils.common_util import CamelCaseUtil, export_list2excel
+from utils.string_util import StringUtil
 
 
 class JobService:
@@ -30,6 +33,21 @@ class JobService:
 
         return job_list_result
 
+    @classmethod
+    async def check_job_unique_services(cls, query_db: AsyncSession, page_object: JobModel):
+        """
+        校验定时任务是否存在service
+
+        :param query_db: orm对象
+        :param page_object: 定时任务对象
+        :return: 校验结果
+        """
+        job_id = -1 if page_object.job_id is None else page_object.job_id
+        job = await JobDao.get_job_detail_by_info(query_db, page_object)
+        if job and job.job_id != job_id:
+            return CommonConstant.NOT_UNIQUE
+        return CommonConstant.UNIQUE
+
     @classmethod
     async def add_job_services(cls, query_db: AsyncSession, page_object: JobModel):
         """
@@ -39,13 +57,28 @@ class JobService:
         :param page_object: 新增定时任务对象
         :return: 新增定时任务校验结果
         """
-        job = await JobDao.get_job_detail_by_info(query_db, page_object)
-        if job:
-            result = dict(is_success=False, message='定时任务已存在')
+        if not SchedulerUtil.validate_cron_expression(page_object.cron_expression):
+            raise ServiceException(message=f'新增定时任务{page_object.job_name}失败，Cron表达式不正确')
+        elif not await cls.check_job_unique_services(query_db, page_object):
+            raise ServiceException(message=f'新增定时任务{page_object.job_name}失败，定时任务已存在')
+        elif StringUtil.contains_ignore_case(page_object.invoke_target, CommonConstant.LOOKUP_RMI):
+            raise ServiceException(message=f'新增定时任务{page_object.job_name}失败，目标字符串不允许rmi调用')
+        elif StringUtil.contains_any_ignore_case(
+            page_object.invoke_target, [CommonConstant.LOOKUP_LDAP, CommonConstant.LOOKUP_LDAPS]
+        ):
+            raise ServiceException(message=f'新增定时任务{page_object.job_name}失败，目标字符串不允许ldap(s)调用')
+        elif StringUtil.contains_any_ignore_case(
+            page_object.invoke_target, [CommonConstant.HTTP, CommonConstant.HTTPS]
+        ):
+            raise ServiceException(message=f'新增定时任务{page_object.job_name}失败，目标字符串不允许http(s)调用')
+        elif StringUtil.startswith_any_case(page_object.invoke_target, JobConstant.JOB_ERROR_LIST):
+            raise ServiceException(message=f'新增定时任务{page_object.job_name}失败，目标字符串存在违规')
+        elif not StringUtil.startswith_any_case(page_object.invoke_target, JobConstant.JOB_WHITE_LIST):
+            raise ServiceException(message=f'新增定时任务{page_object.job_name}失败，目标字符串不在白名单内')
         else:
             try:
-                await JobDao.add_job_dao(query_db, page_object)
-                job_info = await JobDao.get_job_detail_by_info(query_db, page_object)
+                add_job = await JobDao.add_job_dao(query_db, page_object)
+                job_info = await cls.job_detail_services(query_db, add_job.job_id)
                 if job_info.status == '0':
                     SchedulerUtil.add_scheduler_job(job_info=job_info)
                 await query_db.commit()
@@ -68,18 +101,31 @@ class JobService:
         edit_job = page_object.model_dump(exclude_unset=True)
         if page_object.type == 'status':
             del edit_job['type']
-        job_info = await cls.job_detail_services(query_db, edit_job.get('job_id'))
+        job_info = await cls.job_detail_services(query_db, page_object.job_id)
         if job_info:
-            if page_object.type != 'status' and (
-                job_info.job_name != page_object.job_name
-                or job_info.job_group != page_object.job_group
-                or job_info.invoke_target != page_object.invoke_target
-                or job_info.cron_expression != page_object.cron_expression
-            ):
-                job = await JobDao.get_job_detail_by_info(query_db, page_object)
-                if job:
-                    result = dict(is_success=False, message='定时任务已存在')
-                    return CrudResponseModel(**result)
+            if page_object.type != 'status':
+                if not SchedulerUtil.validate_cron_expression(page_object.cron_expression):
+                    raise ServiceException(message=f'修改定时任务{page_object.job_name}失败，Cron表达式不正确')
+                elif not await cls.check_job_unique_services(query_db, page_object):
+                    raise ServiceException(message=f'修改定时任务{page_object.job_name}失败，定时任务已存在')
+                elif StringUtil.contains_ignore_case(page_object.invoke_target, CommonConstant.LOOKUP_RMI):
+                    raise ServiceException(message=f'修改定时任务{page_object.job_name}失败，目标字符串不允许rmi调用')
+                elif StringUtil.contains_any_ignore_case(
+                    page_object.invoke_target, [CommonConstant.LOOKUP_LDAP, CommonConstant.LOOKUP_LDAPS]
+                ):
+                    raise ServiceException(
+                        message=f'修改定时任务{page_object.job_name}失败，目标字符串不允许ldap(s)调用'
+                    )
+                elif StringUtil.contains_any_ignore_case(
+                    page_object.invoke_target, [CommonConstant.HTTP, CommonConstant.HTTPS]
+                ):
+                    raise ServiceException(
+                        message=f'修改定时任务{page_object.job_name}失败，目标字符串不允许http(s)调用'
+                    )
+                elif StringUtil.startswith_any_case(page_object.invoke_target, JobConstant.JOB_ERROR_LIST):
+                    raise ServiceException(message=f'修改定时任务{page_object.job_name}失败，目标字符串存在违规')
+                elif not StringUtil.startswith_any_case(page_object.invoke_target, JobConstant.JOB_WHITE_LIST):
+                    raise ServiceException(message=f'修改定时任务{page_object.job_name}失败，目标字符串不在白名单内')
             try:
                 await JobDao.edit_job_dao(query_db, edit_job)
                 query_job = SchedulerUtil.get_scheduler_job(job_id=edit_job.get('job_id'))
@@ -89,14 +135,12 @@ class JobService:
                     job_info = await cls.job_detail_services(query_db, edit_job.get('job_id'))
                     SchedulerUtil.add_scheduler_job(job_info=job_info)
                 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='定时任务不存在')
-
-        return CrudResponseModel(**result)
+            raise ServiceException(message='定时任务不存在')
 
     @classmethod
     async def execute_job_once_services(cls, query_db: AsyncSession, page_object: JobModel):
@@ -113,11 +157,9 @@ class JobService:
         job_info = await cls.job_detail_services(query_db, page_object.job_id)
         if job_info:
             SchedulerUtil.execute_scheduler_job_once(job_info=job_info)
-            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='定时任务不存在')
 
     @classmethod
     async def delete_job_services(cls, query_db: AsyncSession, page_object: DeleteJobModel):
@@ -137,13 +179,12 @@ class JobService:
                     if query_job:
                         SchedulerUtil.remove_scheduler_job(job_id=job_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 job_detail_services(cls, query_db: AsyncSession, job_id: int):
@@ -155,7 +196,10 @@ class JobService:
         :return: 定时任务id对应的信息
         """
         job = await JobDao.get_job_detail_by_id(query_db, job_id=job_id)
-        result = JobModel(**CamelCaseUtil.transform_result(job))
+        if job:
+            result = JobModel(**CamelCaseUtil.transform_result(job))
+        else:
+            result = JobModel(**dict())
 
         return result