QMS/src/main/java/com/example/demo/service/QrTaskService.java

package com.example.demo.service;

import com.baomidou.mybatisplus.core.conditions.query.LambdaQueryWrapper;
import com.baomidou.mybatisplus.core.conditions.query.QueryWrapper;
import com.baomidou.mybatisplus.core.metadata.IPage;
import com.baomidou.mybatisplus.extension.plugins.pagination.Page;
import com.baomidou.mybatisplus.extension.service.impl.ServiceImpl;
import com.example.demo.domain.dto.QrtzTaskAddNewDTO;
import com.example.demo.domain.dto.QrtzTaskUpdateDTO;
import com.example.demo.domain.dto.QueryPageDTO;
import com.example.demo.domain.dto.QueryTaskDetailsDTO;
import com.example.demo.domain.entity.QrtzTask;
import com.example.demo.domain.entity.QrtzTaskDetail;
import com.example.demo.domain.entity.WebLoginConfig;
import com.example.demo.mapper.QrtzTaskMapper;
import com.example.demo.model.vo.PersonnelVO;
import com.example.demo.util.LoginUtils;
import com.example.demo.util.Response;
import lombok.RequiredArgsConstructor;
import lombok.extern.slf4j.Slf4j;
import org.quartz.SchedulerException;
import org.springframework.beans.BeanUtils;
import org.springframework.context.annotation.Lazy;
import org.springframework.stereotype.Service;

import java.util.ArrayList;
import java.util.Arrays;
import java.util.List;
import java.util.Stack;
import java.util.regex.Matcher;
import java.util.regex.Pattern;

/**
 * @author admin
 * @description 针对表【qrtz_task(定时任务表)】的数据库操作Service实现
 * @createDate 2023-03-15 13:40:32
 */
@Slf4j
@Service
@RequiredArgsConstructor(onConstructor_ = {@Lazy})
public class QrTaskService extends ServiceImpl<QrtzTaskMapper, QrtzTask> {
    private final JobService jobService;
    private final QrTaskDetailService qrTaskDetailService;
    private final LoginUtils loginUtils;
    private final WebLoginConfigService webLoginConfigService;
    /**
     * 新增任务
     *
     * @param qrtzTaskAddNewDTO 新增条件任务DTO对象
     */
    public QrtzTask addQuartzTask(QrtzTaskAddNewDTO qrtzTaskAddNewDTO) {
        log.info("开始处理【新增任务条件】的业务，参数为：{}", qrtzTaskAddNewDTO);
         Integer webId =   qrtzTaskAddNewDTO.getConfigId();
         //根据网站id获得配置
       WebLoginConfig webLoginConfig = webLoginConfigService.getLoginConfig(webId);
       if(webLoginConfig==null){
           return  null;
       }
        //DTO数据赋值给任务条件实体类
        QrtzTask qrtzTask = new QrtzTask();
        BeanUtils.copyProperties(qrtzTaskAddNewDTO, qrtzTask);
        qrtzTask.setCreatePersonId(loginUtils.getId());
        List<String> cells = qrtzTaskAddNewDTO.getConfigCells();
        if (cells == null) {
            qrtzTask.setConfigCells("");
        } else {
            qrtzTask.setConfigCells(String.join(",", cells));
        }
        qrtzTask.setTaskState(0);

        log.info("数据入任务条件表");
        qrtzTask.insert();

        //若是普通任务则新增一条任务执行情况
        if (qrtzTask.getTaskType() != 1) {
            QrtzTaskDetail qrtzTaskDetail = new QrtzTaskDetail()
                    .setTaskId(qrtzTask.getId())
                    .setTaskDetailState(0);
            log.info("新增一条普通任务入任务执行情况表");
            qrtzTaskDetail.insert();
        }
        return qrtzTask;
    }

    public QrtzTask updateQuartzTask(QrtzTaskUpdateDTO qrtzTaskUpdateDTO) {
        log.info("开始处理【更新任务条件】的业务，参数为：{}", qrtzTaskUpdateDTO);

        //DTO数据赋值给实体类
        QrtzTask qrtzTask = new QrtzTask();
        BeanUtils.copyProperties(qrtzTaskUpdateDTO, qrtzTask);
        List<String> cells = qrtzTaskUpdateDTO.getConfigCells();
        if (cells == null) {
            qrtzTask.setConfigCells("");
        } else {
            qrtzTask.setConfigCells(String.join(",", cells));
        }
        //更新任务条件数据
        log.info("更新任务条件数据");
        qrtzTask.updateById();
        return qrtzTask;
    }

    public QrtzTask updateState(Integer taskId, Integer state) {
        QrtzTask qrtzTask = this.getById(taskId);
        qrtzTask.setTaskState(state);
        qrtzTask.updateById();
        return qrtzTask;
    }

    /**
     * 删除任务
     *
     * @param taskIds
     */
    public List<Integer> deleteQuartzTask(List<Integer> taskIds) throws SchedulerException {
        List<Integer> reIds = new ArrayList<>();
        LambdaQueryWrapper<QrtzTask> wrapper = new LambdaQueryWrapper<>();
        wrapper.in(QrtzTask::getId, taskIds);
        List<QrtzTask> qrtzTaskList = this.list(wrapper);
        for (QrtzTask qrtzTask : qrtzTaskList) {
            //根据任务条件id查找是否有正在进行的任务
            LambdaQueryWrapper<QrtzTaskDetail> queryWrapper =new LambdaQueryWrapper<>();
            queryWrapper.eq(QrtzTaskDetail::getTaskId,qrtzTask.getId())
                    .in(QrtzTaskDetail::getTaskDetailState, Arrays.asList(1,7,8));
            List<QrtzTaskDetail> qrtzTaskDetails =qrTaskDetailService.list(queryWrapper);
            if(qrtzTaskDetails.size()==0){
                Boolean flag = this.removeById(qrtzTask.getId());
                LambdaQueryWrapper<QrtzTaskDetail> deleteWrapper =new LambdaQueryWrapper<>();
                queryWrapper.eq(QrtzTaskDetail::getTaskId,qrtzTask.getId());
                qrTaskDetailService.removeById(deleteWrapper);
                if (!flag) {
                    reIds.add(qrtzTask.getId());
                }
                if (qrtzTask.getTaskType().equals(1)) {
                    jobService.deleteJob(qrtzTask.getId());
                }
            }
            else {
                reIds.add(qrtzTask.getId());
            }

        }
        return reIds;
    }

    public Page<QrtzTask> getTasks(QueryPageDTO queryPageDTO) {
        log.info("开始处理【查询任务条件列表】的业务，参数为：{}", queryPageDTO);

        String orderBy = queryPageDTO.getOrderBy();
        String orderType = queryPageDTO.getOrderType();
        QueryWrapper<QrtzTask> queryWrapper = new QueryWrapper<>();
        if (orderBy != null && !orderBy.equals("")) {
            String regex = "[A-Z]+";
            Pattern pattern = Pattern.compile(regex);
            Matcher matcher = pattern.matcher(orderBy);
            while (matcher.find()) {
                orderBy = orderBy.replaceFirst(matcher.group(), "_" + matcher.group().toLowerCase());
            }
            if (orderType.equals("asc")) {
                queryWrapper.orderByAsc(orderBy);
            } else {
                queryWrapper.orderByDesc(orderBy);
            }
        } else {
            queryWrapper.orderByDesc("modified_time");
        }
        Page<QrtzTask> page = this.page(new Page<>(queryPageDTO.getCurrent(), queryPageDTO.getSize()), queryWrapper.orderByDesc("modified_time"));
        return page;
    }

    public Page<QrtzTaskDetail> getTaskDetails(QueryTaskDetailsDTO queryTaskDetailsDTO) {
        log.info("开始处理【查询任务执行情况列表】的业务，参数为：{}", queryTaskDetailsDTO);
        LambdaQueryWrapper<QrtzTaskDetail> queryWrapper = new LambdaQueryWrapper<>();

        //根据所属任务条件id查询列表
        if (queryTaskDetailsDTO.getTaskId() != null) {
            queryWrapper.eq(QrtzTaskDetail::getTaskId, queryTaskDetailsDTO.getTaskId());
        }
        //根据任务状态查询列表
        if (queryTaskDetailsDTO.getTaskDetailStates() != null && queryTaskDetailsDTO.getTaskDetailStates().size() != 0) {
            queryWrapper.in(QrtzTaskDetail::getTaskDetailState, queryTaskDetailsDTO.getTaskDetailStates());
        }
        if(queryTaskDetailsDTO.getOrderBy()!=null){
            queryTaskDetailsDTO.setOrderBy(this.formatOrder(queryTaskDetailsDTO.getOrderBy()));
            if(queryTaskDetailsDTO.getOrderBy().equals("state")){
                queryWrapper.last(" order by  FIELD(task_detail_state,1,7,8,0,2,3,4,5,6)");
            }
            else {
                queryWrapper.last(" order by " + queryTaskDetailsDTO.getOrderBy());
                if(queryTaskDetailsDTO.getOrderType()!=null){
                    queryWrapper.last(" order by " + queryTaskDetailsDTO.getOrderBy()+" "+queryTaskDetailsDTO.getOrderType());
                }
            }
        }

        Page<QrtzTaskDetail> page = qrTaskDetailService.page(new Page<>(queryTaskDetailsDTO.getCurrent(), queryTaskDetailsDTO.getSize()), queryWrapper);
        return page;
    }

public  String formatOrder(String order){
        switch (order)
        { case "createTime":
            order ="create_time";
            break;

        }
        return order;
}
}