PAS/src/main/java/cn/cslg/pas/service/importPatent/SchedulingTaskService.java

package cn.cslg.pas.service.importPatent;

import cn.cslg.pas.common.core.base.Constants;
import cn.cslg.pas.common.vo.ImportTaskAMVO;
import cn.cslg.pas.common.vo.ProgressVO;
import cn.cslg.pas.domain.business.ImportTask;
import cn.cslg.pas.domain.business.ImportTaskCondition;
import cn.cslg.pas.service.business.ImportTaskConditionService;
import cn.cslg.pas.service.business.ImportTaskService;
import com.baomidou.mybatisplus.core.conditions.query.LambdaQueryWrapper;
import org.springframework.beans.BeanUtils;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.context.ApplicationContext;
import org.springframework.stereotype.Service;

import java.util.ArrayList;
import java.util.Arrays;
import java.util.List;
import java.util.concurrent.Executors;
import java.util.concurrent.ThreadPoolExecutor;
import java.util.stream.Collectors;

@Service
public class SchedulingTaskService {
    @Autowired
    private ImportTaskService importTaskService;

    @Autowired
    private ApplicationContext applicationContext;
    private ThreadPoolExecutor executor = (ThreadPoolExecutor) Executors.newFixedThreadPool(Constants.MAX_IMPORT_TASK_COUNT);

    @Autowired
    private ImportTaskConditionService importTaskConditionService;

    private    List<ImportTaskAMVO> importTaskAMVOS;
    public void startTask() {
        Integer freeCount = Constants.MAX_IMPORT_TASK_COUNT - executor.getActiveCount();

        // 当正在活跃的线程数小于最大线程数时
        if (freeCount > 0) {
            //查找任务
            LambdaQueryWrapper<ImportTask> queryWrapper = new LambdaQueryWrapper<>();
            queryWrapper.in(ImportTask::getState, new ArrayList<>(Arrays.asList(0, 1)))
                    .orderByDesc(ImportTask::getState);
            List<ImportTask> importTaskList = importTaskService.list(queryWrapper);
            if (importTaskList.size() > 0) {
                // 装载任务信息
              importTaskAMVOS = this.loadTaskAMVOS(importTaskList);

                importTaskAMVOS.forEach(item -> {
                    item.setState(1);
                    TaskThread taskThread = new TaskThread(item,applicationContext);
                    executor.execute(taskThread);
                });
            }

        }
    }


    public List<ImportTaskAMVO> loadTaskAMVOS(List<ImportTask> importTaskList) {
        List<ImportTaskAMVO> importTaskAMVOS = new ArrayList<>();
        List<Integer> taskConditionIds = new ArrayList<>();
        List<ImportTaskCondition> importTaskConditions = new ArrayList<>();
        taskConditionIds =importTaskList.stream().map(ImportTask::getImportTaskConditionId).collect(Collectors.toList());
        //根据taskid查询taskCondition
        if (taskConditionIds.size() != 0) {
            LambdaQueryWrapper<ImportTaskCondition> queryWrapper = new LambdaQueryWrapper<>();
            queryWrapper.in(ImportTaskCondition::getId, taskConditionIds);
            importTaskConditions = importTaskConditionService.list(queryWrapper);

        }
        for (ImportTask importTask : importTaskList) {
            ImportTaskCondition importTaskCondition = importTaskConditions.stream().filter(item -> item.getId().equals(importTask.getImportTaskConditionId())).findFirst().orElse(null);
            ImportTaskAMVO importTaskAMVO = new ImportTaskAMVO();
            BeanUtils.copyProperties(importTask, importTaskAMVO);
            if(importTaskCondition!=null) {
                importTaskAMVO.setFileGuid(importTaskCondition.getFileGuid());
                importTaskAMVO.setSourceId(importTaskCondition.getSourceId());
                importTaskAMVO.setProjectId(importTaskCondition.getProjectId());
                importTaskAMVO.setProductId(importTaskCondition.getProductId());
                importTaskAMVO.setImportContent(importTaskCondition.getImportContent());
                importTaskAMVO.setDbType(importTaskCondition.getDbType());
                importTaskAMVO.setOrderBy(importTaskCondition.getOrderBy());
                importTaskAMVO.setOrderByType(importTaskCondition.getOrderByType());
            }
            ProgressVO progressVO =new ProgressVO();
            progressVO.setState(0);
            importTaskAMVO.setProgressVO(progressVO);
            importTaskAMVOS.add(importTaskAMVO);


        }
        return importTaskAMVOS;

    }

    public void pauseTask(Integer taskId){
//根据id获得
        ImportTaskAMVO  importTaskAMVO  =  importTaskAMVOS.stream().filter(item->item.getId().equals(taskId)).findFirst().orElse(null);
        importTaskAMVO.getProgressVO().setState(1);
    }
}