PAS/src/main/java/cn/cslg/pas/service/quartzService/SysImportPatentJobService.java

package cn.cslg.pas.service.quartzService;

import cn.cslg.pas.common.core.base.Cycle;
import cn.cslg.pas.common.utils.DateUtils2;
import cn.cslg.pas.common.utils.utilVO.NowDateFirstMessVO;
import cn.cslg.pas.domain.business.ImportTaskCondition;
import cn.cslg.pas.domain.business.PatentProject;
import cn.cslg.pas.service.MailSendService;
import cn.cslg.pas.service.business.ImportTaskConditionService;
import cn.cslg.pas.service.business.ImportTaskService;
import cn.cslg.pas.service.business.PatentProjectService;
import com.baomidou.mybatisplus.core.conditions.query.LambdaQueryWrapper;
import lombok.RequiredArgsConstructor;
import org.quartz.DisallowConcurrentExecution;
import org.quartz.JobDataMap;
import org.quartz.JobExecutionContext;
import org.quartz.JobExecutionException;
import org.springframework.scheduling.quartz.QuartzJobBean;

import java.time.LocalDate;
import java.util.ArrayList;
import java.util.List;
import java.util.stream.Collectors;


@DisallowConcurrentExecution
@RequiredArgsConstructor
public class SysImportPatentJobService extends QuartzJobBean {
    private final ImportTaskConditionService importTaskConditionService;
    private final ImportTaskService importTaskService;
    private final PatentProjectService patentProjectService;
    private final MailSendService mailSendService;

    @Override
    public void executeInternal(JobExecutionContext context) throws JobExecutionException {
        mailSendService.sendSysCycleStartEmail();
        NowDateFirstMessVO messVO = DateUtils2.getNowDateFirstMessage(null);
        Boolean isFirstDayOfWeek = messVO.getIsFirstDayOfWeek();
        Boolean isFirstDayOfMonth = messVO.getIsFirstDayOfMonth();
        Boolean isFirstDayOfQuarter = messVO.getIsFirstDayOfQuarter();
        Boolean isFirstDayOfYear = messVO.getIsFirstDayOfYear();
        List<String> cycles = new ArrayList<>();
        if (isFirstDayOfWeek != null && isFirstDayOfWeek) {
            cycles.add(Cycle.WEEK);
        }
        if (isFirstDayOfMonth != null && isFirstDayOfMonth) {
            cycles.add(Cycle.MONTH);
        }
        if (isFirstDayOfQuarter != null && isFirstDayOfQuarter) {
            cycles.add(Cycle.QUARTER);
        }
        if (isFirstDayOfYear != null && isFirstDayOfYear) {
            cycles.add(Cycle.YEAR);
        }

        if (cycles.size() <= 0) {
            return;
        }
        LambdaQueryWrapper<PatentProject> queryWrapper = new LambdaQueryWrapper<>();
        queryWrapper.eq(PatentProject::getIfUpdate, true)
                .in(PatentProject::getUpdateCycle, cycles);
        List<PatentProject> patentProjects = patentProjectService.list(queryWrapper);
        if (patentProjects != null && patentProjects.size() != 0) {
            List<Integer> projectId = patentProjects.stream().map(PatentProject::getProjectId).collect(Collectors.toList());
            //根据id查询检索条件
            LambdaQueryWrapper<ImportTaskCondition> queryWrapper1 = new LambdaQueryWrapper<>();
            queryWrapper1.in(ImportTaskCondition::getProjectId, projectId);
            queryWrapper1.eq(ImportTaskCondition::getIfCycle, true)
                    .eq(ImportTaskCondition::getIfUpdate, true);
            List<ImportTaskCondition> importTaskConditions = importTaskConditionService.list(queryWrapper1);

            importTaskConditions.forEach(item -> {
                importTaskService.addImportTaskByCondition(item);
            });
        }


    }

    private void addProjectCycleTask(Integer projectId) {
        LambdaQueryWrapper<PatentProject> queryWrapper = new LambdaQueryWrapper<>();
        queryWrapper.eq(PatentProject::getIfUpdate, true)
                .eq(PatentProject::getUpdateCycle, "");
        //根据id查询检索条件
        LambdaQueryWrapper<ImportTaskCondition> queryWrapper2 = new LambdaQueryWrapper<>();
        queryWrapper2.eq(ImportTaskCondition::getProjectId, projectId);
        queryWrapper2.eq(ImportTaskCondition::getIfCycle, true)
                .eq(ImportTaskCondition::getIfUpdate, true);
        List<ImportTaskCondition> importTaskConditions = importTaskConditionService.list(queryWrapper2);
        importTaskConditions.forEach(item -> {
            importTaskService.addImportTaskByCondition(item);
        });


    }
}