# FdJobChecker.java

    package cloud.wconnect.workperformance.scheduler.fdprocedure;

    import cloud.wconnect.commonlib.cons.FunctionIdConstant;
    import cloud.wconnect.commonlib.cons.MoudleIdConstant;
    import cloud.wconnect.commonlib.cons.SchedulerCons;
    import cloud.wconnect.commonlib.pojo.dto.PropertyDTO;
    import cloud.wconnect.commonlib.pojo.dto.scheduler.JobBodyDTO;
    import cloud.wconnect.commonlib.service.PropertyInternalService;
    import cloud.wconnect.commonlib.service.SchedulerInternalService;
    import cloud.wconnect.commonlib.util.CronRuleUtil;
    import cloud.wconnect.workperformance.entity.fdprocedurecheck.FdProcedureCheckScheduler;
    import cloud.wconnect.workperformance.service.fdprocedurecheck.IFdProcedureCheckSchedulerService;
    import com.baomidou.mybatisplus.core.conditions.query.LambdaQueryWrapper;
    import com.fasterxml.jackson.databind.ObjectMapper;
    import lombok.extern.slf4j.Slf4j;
    import org.springframework.beans.factory.annotation.Value;
    import org.springframework.scheduling.annotation.Scheduled;
    import org.springframework.stereotype.Component;

    import java.util.ArrayList;
    import java.util.HashMap;
    import java.util.List;
    import java.util.Map;
    import java.util.stream.Collectors;

    /**
     * FD procedure check 功能job检查器
     */
    @Slf4j
    @Component
    public class FdJobChecker {

        private final IFdProcedureCheckSchedulerService schedulerService;
        private final SchedulerInternalService schedulerInternalService;
        private final PropertyInternalService propertyInternalService;
        private final ObjectMapper objectMapper;
        private final String defaultTimezone;
        private final static Integer MODULE_ID = MoudleIdConstant.WORK_PERFORMANCE;
        private final static Integer FUNCTION_ID = FunctionIdConstant.FD_PROCEDURE_CHECK;

        public FdJobChecker(IFdProcedureCheckSchedulerService schedulerService, SchedulerInternalService schedulerInternalService,
                            PropertyInternalService propertyInternalService, ObjectMapper objectMapper,
                            @Value("${default.timezone}") String defaultTimezone) {
            this.schedulerService = schedulerService;
            this.schedulerInternalService = schedulerInternalService;
            this.propertyInternalService = propertyInternalService;
            this.objectMapper = objectMapper;
            this.defaultTimezone = defaultTimezone;
        }

        /**
         * 每小时检查一下 处于未同步状态的调度任务， 并将其同步到调度中心
         *
         * @author zc
         * @date 2024/3/13
         */
        @Scheduled(cron = "${schedule.cron.sync-scheduler-job}", zone = "${default.timezone}")
        public void checkSchedulerJob() {
            // 查询未同步的定时任务
            List<FdProcedureCheckScheduler> unSyncJobs = schedulerService.list(new LambdaQueryWrapper<FdProcedureCheckScheduler>()
                    .eq(FdProcedureCheckScheduler::getSyncState, false));
            if (unSyncJobs.isEmpty()) {
                return;
            }

            List<Integer> propertyIds = unSyncJobs.stream().map(FdProcedureCheckScheduler::getPropertyId).distinct().toList();
            Map<Integer, String> propertyIdToTimezoneMapping = propertyInternalService.getProperty(propertyIds)
                    .stream().collect(Collectors.toMap(PropertyDTO::getId, PropertyDTO::getTimezone));

            List<String> updateJobIds = new ArrayList<>();
            List<String> deleteJobIds = new ArrayList<>();
            unSyncJobs.forEach(job -> {
                if (job.getStatus() == SchedulerCons.STATUS_START) { // 开启
                    try {
                        JobBodyDTO jobBodyDTO = new JobBodyDTO()
                                .setJobId(job.getId())
                                .setModuleId(MODULE_ID)
                                .setFunctionId(FUNCTION_ID)
                                .setStartDate(job.getStartDate())
                                .setCronRule(CronRuleUtil.generateCronRuleForScheduler(objectMapper.readValue(job.getScheduler(), HashMap.class),
                                        job.getStartDate(), propertyIdToTimezoneMapping.get(job.getPropertyId()), defaultTimezone));
                        schedulerInternalService.launchJob(jobBodyDTO);
                        updateJobIds.add(job.getId());
                    } catch (Exception e) {
                        log.error("Launch FdProcedureCheck scheduler job[" + job.getId() + "] failed", e);
                    }
                } else { // 关闭 or 删除中
                    try {
                        JobBodyDTO jobBodyDTO = new JobBodyDTO()
                                .setJobId(job.getId())
                                .setModuleId(MODULE_ID)
                                .setFunctionId(FUNCTION_ID);
                        schedulerInternalService.deleteJob(jobBodyDTO);
                        if (job.getStatus() == SchedulerCons.STATUS_STOP) {
                            updateJobIds.add(job.getId());
                        } else {
                            deleteJobIds.add(job.getId());
                        }
                    } catch (Exception e) {
                        log.error("Delete FdProcedureCheck scheduler job[" + job.getId() + "] failed", e);
                    }
                }
            });

            if (!updateJobIds.isEmpty()) {
                schedulerService.refreshSyncStateByIds(updateJobIds);
            }

            if (!deleteJobIds.isEmpty()) {
                schedulerService.removeByIds(deleteJobIds);
            }
        }
    }