# OooRoomJobChecker.java

    package cloud.wconnect.frontoffice.scheduler.oooroom;

    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.frontoffice.entity.oooroom.OooRoomSchedulerJob;
    import cloud.wconnect.frontoffice.service.oooroom.IOooRoomSchedulerJobService;
    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;

    /**
     * @author: yyt
     * 2024-03-14
     */
    @Slf4j
    @Component
    public class OooRoomJobChecker {

        private final IOooRoomSchedulerJobService oooRoomSchedulerJobService;
        private final SchedulerInternalService schedulerInternalService;
        private final PropertyInternalService propertyInternalService;
        private final ObjectMapper objectMapper;
        private final String defaultTimezone;

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

        /**
         * 每小时检查一次未同步的数据，将未同步的数据同步到调度中心
         *
         * @author yyt
         * @date 2024/3/14
         **/
        @Scheduled(cron = "${schedule.cron.sync-scheduler-job}", zone = "${default.timezone}")
        public void checkSchedulerJob() {
            //查询未同步的定时任务
            List<OooRoomSchedulerJob> unSyncJobs = oooRoomSchedulerJobService.list(new LambdaQueryWrapper<OooRoomSchedulerJob>()
                    .eq(OooRoomSchedulerJob::getSyncState, false));
            if (unSyncJobs.isEmpty()) {
                return;
            }

            List<Integer> propertyIds = unSyncJobs.stream().map(OooRoomSchedulerJob::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 task = new JobBodyDTO()
                                .setJobId(job.getId()).setModuleId(MoudleIdConstant.FRONT_OFFICE).setFunctionId(FunctionIdConstant.OOO_ROOM)
                                .setStartDate(job.getStartDate())
                                .setCronRule(CronRuleUtil.generateCronRuleForScheduler(objectMapper.readValue(job.getScheduler(), HashMap.class),
                                        job.getStartDate(), propertyIdToTimezoneMapping.get(job.getPropertyId()), defaultTimezone));
                        schedulerInternalService.launchJob(task);
                        updateJobIds.add(job.getId());
                    } catch (Exception e) {
                        log.error("Launch ooo room scheduler job[" + job.getId() + "] failed", e);
                    }
                } else {//关闭 or 删除中
                    try {
                        schedulerInternalService.deleteJob(new JobBodyDTO().setJobId(job.getId())
                                .setModuleId(MoudleIdConstant.FRONT_OFFICE).setFunctionId(FunctionIdConstant.OOO_ROOM));
                        if (job.getStatus() == SchedulerCons.STATUS_STOP) {
                            updateJobIds.add(job.getId());
                        } else {
                            deleteJobIds.add(job.getId());
                        }
                    } catch (Exception e) {
                        log.error("Delete ooo room scheduler job[" + job.getId() + "] failed", e);
                    }
                }
            });

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

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

    }