PAS/src/main/java/cn/cslg/pas/service/business/ImportTaskService.java

package cn.cslg.pas.service.business;

import cn.cslg.pas.common.dto.ExportTaskDTO;
import cn.cslg.pas.common.dto.ImportTaskDTO;
import cn.cslg.pas.common.dto.PatentStarListDTO;
import cn.cslg.pas.common.model.cronModel.Personnel;
import cn.cslg.pas.common.model.cronModel.PersonnelVO;
import cn.cslg.pas.common.model.cronModel.Records;
import cn.cslg.pas.common.model.cronModel.SystemFile;
import cn.cslg.pas.common.model.request.GroupRequest;
import cn.cslg.pas.common.model.request.QueryRequest;
import cn.cslg.pas.common.utils.*;
import cn.cslg.pas.common.vo.ImportTaskAMVO;
import cn.cslg.pas.common.vo.business.ImportTaskVO;
import cn.cslg.pas.domain.business.*;
import cn.cslg.pas.exception.UnLoginException;
import cn.cslg.pas.exception.XiaoShiException;
import cn.cslg.pas.factorys.businessFactory.Business;
import cn.cslg.pas.mapper.ImportTaskMapper;
import cn.cslg.pas.service.common.FileManagerService;
import cn.cslg.pas.service.common.PatentStarApiService;
import cn.cslg.pas.service.importPatent.SchedulingTaskService;
import cn.cslg.pas.service.permissions.PermissionService;
import cn.cslg.pas.service.query.FormatQueryService;
import com.alibaba.fastjson.JSONArray;
import com.alibaba.fastjson.JSONObject;
import com.baomidou.mybatisplus.core.conditions.query.LambdaQueryWrapper;
import com.baomidou.mybatisplus.extension.service.impl.ServiceImpl;
import lombok.RequiredArgsConstructor;
import org.apache.commons.compress.utils.IOUtils;
import org.apache.poi.ss.usermodel.Sheet;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.context.annotation.Lazy;
import org.springframework.stereotype.Service;
import org.springframework.transaction.annotation.Transactional;
import org.springframework.web.multipart.MultipartFile;

import java.io.*;
import java.util.ArrayList;
import java.util.Arrays;
import java.util.List;
import java.util.Map;

/**
 * 导入任务表业务层
 *
 * @author chenyu
 * @date 2023/10/20
 */
@Service
@RequiredArgsConstructor
public class ImportTaskService extends ServiceImpl<ImportTaskMapper, ImportTask> implements Business {
    @Autowired
    private FormatQueryService formatQueryService;

    @Autowired
    private ImportTaskMapper importTaskMapper;

    @Autowired
    private FileManagerService fileManagerService;
    @Autowired
    private PatentStarApiService patentStarApiService;
    @Autowired
    private PermissionService permissionService;
    @Autowired
    @Lazy
    private SchedulingTaskService schedulingTaskService;

    @Autowired
    private CacheUtils cacheUtils;
    @Autowired
    private LoginUtils loginUtils;
    @Autowired
    private SystemDictService systemDictService;
    @Autowired
    private ProductService productService;
    @Autowired
    private ProjectService projectService;
    @Autowired
    private ImportTaskConditionService importTaskConditionService;

    @Override
    public Object queryMessage(QueryRequest queryRequest) throws Exception {
        List<String> sqls = formatQueryService.reSqls(queryRequest, "importTask");
        //根据sql查询事件信息
        List<ImportTaskVO> importTaskVOS = importTaskMapper.getImportTask(sqls.get(0), sqls.get(1), sqls.get(2));
        //查询总数
        Long total = importTaskMapper.getImportTaskCount(sqls.get(0));

        //装载事件信息
        this.loadImportTask(importTaskVOS);
        Records records = new Records();
        records.setCurrent(queryRequest.getCurrent());
        records.setSize(queryRequest.getSize());
        records.setData(importTaskVOS);
        records.setTotal(total);
        return records;
    }

    @Override
    public Object addMessage(Object object, List<MultipartFile> files) {
        return null;
    }

    @Override
    public Object deleteMessage(List<Integer> ids) throws IOException {
        return null;
    }

    @Override
    public Object updateMessage(Object object, List<MultipartFile> files) {
        return null;
    }

    @Override
    public Object getGroup(GroupRequest groupRequest, String tableName) throws Exception {
        return null;
    }

    @Override
    @Transactional(rollbackFor = Exception.class)
    public Object addMessage(Object object) {
        if (object == null) {
            throw new XiaoShiException("参数不能为空");
        }
        //TODO 校验参数
        ImportTaskDTO importTaskDTO = (ImportTaskDTO) object;

        PersonnelVO personnelVO = new PersonnelVO();
        try {
            personnelVO = cacheUtils.getLoginUser(loginUtils.getId());
        } catch (Exception e) {
            throw new UnLoginException("未登录");
        }

        if (importTaskDTO.getType() == null) {
            importTaskDTO.setType(4);
        }
 List<String> addPatentNos =importTaskDTO.getPatentNos();
        ImportTaskCondition importTaskCondition = new ImportTaskCondition();
        if (importTaskDTO.getImportToId() != null) {
            if (importTaskDTO.getImportToType().equals(0)) {
                importTaskCondition.setProjectType(0);
                importTaskCondition.setProjectId(importTaskDTO.getImportToId());
            } else if (importTaskDTO.getImportToType().equals(1)) {
                importTaskCondition.setProjectType(1);
                importTaskCondition.setProjectId(importTaskDTO.getImportToId());
            } else if (importTaskDTO.getImportToType().equals(2)) {
                importTaskCondition.setProductId(importTaskDTO.getImportToId());
            }
        }
        if (!importTaskDTO.getType().equals(1)) {
            importTaskDTO.setImportContent(MathUtils.BinaryToDecimal(importTaskDTO.getImportContent()));
        }
        importTaskCondition.setImportContent(importTaskDTO.getImportContent());
        importTaskCondition.setCrons(importTaskDTO.getCrons());
        importTaskCondition.setIfUpdate(importTaskDTO.getIfUpdate());
        importTaskCondition.setSearchCondition(importTaskDTO.getSearchCondition());
        importTaskCondition.setType(importTaskDTO.getType());
        importTaskCondition.setFileGuid(importTaskDTO.getFileGuid());
        importTaskCondition.setSourceId(importTaskDTO.getSourceId());
        importTaskCondition.setDbType(importTaskDTO.getDBType());
        importTaskCondition.setOrderBy(importTaskDTO.getOrderBy());
        importTaskCondition.setOrderByType(importTaskDTO.getOrderByType());
        importTaskCondition.setCreateId(personnelVO.getId());

        if (importTaskDTO.getPatentNos() != null && importTaskDTO.getPatentNos().size() > 0) {
            String jsons = JSONObject.toJSON(importTaskDTO.getPatentNos()).toString();
            importTaskCondition.setPatentNos(jsons);
        }
        String fieldJson = JsonUtils.objectToJson(importTaskCondition);
        importTaskCondition.setCustomFields(fieldJson);
        importTaskCondition.insert();

        //装载任务
        ImportTask importTask = new ImportTask();
        importTask.setImportTaskConditionId(importTaskCondition.getId());
        importTask.setType(importTaskDTO.getType());
        importTask.setSearchCondition(importTaskDTO.getSearchCondition());
        importTask.setCreateId(personnelVO.getId());
        if (importTaskCondition.getType().equals(1)) {
            try {
                String res = fileManagerService.getSystemFileFromFMS(Arrays.asList(importTaskCondition.getFileGuid()));
                List<SystemFile> systemFiles = JSONArray.parseArray(res, SystemFile.class);
                SystemFile systemFile = systemFiles.get(0);
                String suffix = systemFile.getFileName().substring(systemFile.getFileName().lastIndexOf("."));
                //调用文件系统取出文件接口，获得文件流
                byte[] bytes = fileManagerService.downloadSystemFileFromFMS(importTaskCondition.getFileGuid());
                //创建临时文件tempFile，并将文件读取到tempFile
                File tempFile = File.createTempFile(systemFile.getFileName() + "temp", suffix);
                try (
                        InputStream inputStream = new ByteArrayInputStream(bytes);
                        FileOutputStream outputStream = new FileOutputStream(tempFile)
                ) {
                    IOUtils.copy(inputStream, outputStream); // 将输入流复制到临时文件
                }
                Integer totalNum = ReadExcelUtils.textExcel(tempFile, importTaskCondition.getSourceId().toString());
                importTask.setAllNum(totalNum);
                //删除临时文件tempFile
                new File(tempFile.getPath()).delete();
            } catch (Exception e) {
                throw new XiaoShiException("文件错误");
            }
        } else if (importTaskCondition.getType().equals(4)) {
            try {if(addPatentNos==null||addPatentNos.size()==0) {
                PatentStarListDTO patentStarListDto = new PatentStarListDTO()
                        .setCurrentQuery(importTaskCondition.getSearchCondition())
                        .setOrderBy(importTaskCondition.getOrderBy())
                        .setOrderByType(importTaskCondition.getOrderByType())
                        .setPageNum(1)
                        .setRowCount(50)
                        .setDBType(importTaskCondition.getDbType());

                //调用一般接口返回一批专利著录相关数据
                Map<String, Object> resultMap = patentStarApiService.patentStarSearchApi(patentStarListDto);
                if (resultMap == null || (Integer) resultMap.get("total") == 0) {
                    ThrowException.throwXiaoShiException("未检索到相关专利");
                } else {
                    importTask.setAllNum((Integer) resultMap.get("total"));
                }
            }
            else {
                importTask.setAllNum(addPatentNos.size());
            }
            } catch (Exception e) {
                throw new XiaoShiException("文件错误");
            }
        } else if (importTaskCondition.getType().equals(2) || importTaskCondition.getType().equals(3)) {
            List<String> patentNos = new ArrayList<>();
            if (importTaskCondition.getType().equals(2)) {
                patentNos = Arrays.asList(importTaskCondition.getSearchCondition().split("[,|，]"));
            } else if (importTaskCondition.getType().equals(3)) {
                try {
                    String res = fileManagerService.getSystemFileFromFMS(Arrays.asList(importTaskCondition.getFileGuid()));
                    List<SystemFile> systemFiles = JSONArray.parseArray(res, SystemFile.class);
                    SystemFile systemFile = systemFiles.get(0);
                    String suffix = systemFile.getFileName().substring(systemFile.getFileName().lastIndexOf("."));
                    //调用文件系统取出文件接口，获得文件流
                    byte[] bytes = fileManagerService.downloadSystemFileFromFMS(importTaskCondition.getFileGuid());
                    //创建临时文件tempFile，并将文件读取到tempFile
                    File tempFile = File.createTempFile(systemFile.getFileName() + "temp", suffix);
                    try (
                            InputStream inputStream = new ByteArrayInputStream(bytes);
                            FileOutputStream outputStream = new FileOutputStream(tempFile)
                    ) {
                        IOUtils.copy(inputStream, outputStream); // 将输入流复制到临时文件
                    }
                    Sheet sheet = ReadExcelUtils.readExcel(tempFile);
                    patentNos = ReadExcelUtils.getPatentNoFromExcel(sheet);

                } catch (Exception e) {
                }

            }
            importTask.setAllNum(patentNos.size());
        }
        importTask.setProgress(0.0);
        String taskName = this.setImportTaskName(importTaskCondition, personnelVO.getName());
        importTask.setName(taskName);
        importTask.insert();

        schedulingTaskService.startTask();
        return importTask.getId();

    }

    @Override
    public Object updateMessage(Object object) {
        return null;
    }

    private void loadImportTask(List<ImportTaskVO> importTaskVOS) throws IOException {
        List<ImportTaskAMVO> importTaskAMVOS = schedulingTaskService.getImportTaskAMVOs();
        if (importTaskAMVOS == null) {
            importTaskAMVOS = new ArrayList<>();
        }
        List<String> createIds = new ArrayList<>();
        importTaskVOS.forEach(item -> {
            if (item.getCreateId() != null) {
                createIds.add(item.getCreateId());
            }
        });
        List<Personnel> personnels = new ArrayList<>();
        List<Product> products = new ArrayList<>();
        List<Project> projects = new ArrayList<>();
        //查询创建人名称
        if (createIds.size() != 0) {
            String res = permissionService.getPersonnelByIdsFromPCS(createIds);
            JSONObject jsonObject = JSONObject.parseObject(res);
            personnels = JSONObject.parseArray(jsonObject.getString("data"), Personnel.class);
        }


        LambdaQueryWrapper<SystemDict> lambdaQueryWrapper = new LambdaQueryWrapper<>();
        lambdaQueryWrapper.eq(SystemDict::getGroupType, "IMPORT_TASK");
        List<SystemDict> systemDictList = systemDictService.list(lambdaQueryWrapper);
        for (ImportTaskVO importTaskVO : importTaskVOS) {
            //装载创建人
            Personnel personnel = personnels.stream().filter(item -> item.getId().equals(importTaskVO.getCreateId())).findFirst().orElse(null);
            if (personnel != null) {
                importTaskVO.setCreateName(personnel.getPersonnelName());
            }

            //装载状态
            SystemDict systemDict1 = systemDictList.stream()
                    .filter(item -> item.getType().equals("IMPORT_TASK_TYPE") && item.getType()
                            .equals(importTaskVO.getType().toString())).findFirst().orElse(null);

            SystemDict systemDict2 = systemDictList.stream()
                    .filter(item -> item.getType().equals("IMPORT_TASk_STATE") && item.getType()
                            .equals(importTaskVO.getState().toString())).findFirst().orElse(null);
            if (systemDict1 != null) {
                importTaskVO.setTypeStr(systemDict1.getLabel());
            }
            if (systemDict2 != null) {
                importTaskVO.setStateStr(systemDict2.getLabel());
            }

            //装载正在进行中任务的完成条数
            ImportTaskAMVO importTaskAMVO = importTaskAMVOS.stream().filter(item -> item.getId().equals(importTaskVO.getId())).findFirst().orElse(null);
            if (importTaskAMVO != null) {
                importTaskVO.setDoneNum(importTaskAMVO.getDoneNum());
                importTaskAMVO.setAllNum(importTaskAMVO.getAllNum());
            }
            long percentage = (long) Math.floor((importTaskVO.getDoneNum() + 0D) / importTaskVO.getAllNum() * 100D);
            importTaskVO.setPercentage(percentage);
        }

    }


    private String setImportTaskName(ImportTaskCondition importTaskCondition, String name) {
        //装载名称
        String type = "";
        String toName = "";
        String to = "";
        String taskName = "";
        if (importTaskCondition.getType().equals(2)) {
            type = "【专利号】";
        } else if (importTaskCondition.getType().equals(3) || importTaskCondition.getType().equals(4)) {
            type = "【检索式】";
        } else if (importTaskCondition.getType().equals(1)) {
            type = "【Excel】";
        }
        if (importTaskCondition.getProjectId() != null && importTaskCondition.getProjectType().equals(0)) {
            to = "专题库";
            LambdaQueryWrapper<Project> queryWrapper = new LambdaQueryWrapper<>();
            queryWrapper.in(Project::getId, importTaskCondition.getProjectId());
            List<Project> projects = projectService.list(queryWrapper);
            if (projects.size() != 0) {
                toName = projects.get(0).getName();
            }
        } else if (importTaskCondition.getProjectId() != null && importTaskCondition.getProjectType().equals(1)) {
            to = "报告";
            LambdaQueryWrapper<Project> queryWrapper = new LambdaQueryWrapper<>();
            queryWrapper.in(Project::getId, importTaskCondition.getProjectId());
            List<Project> projects = projectService.list(queryWrapper);
            if (projects.size() != 0) {
                toName = projects.get(0).getName();
            }
        } else if (importTaskCondition.getProductId() != null) {
            to = "产品";
            LambdaQueryWrapper<Product> queryWrapper = new LambdaQueryWrapper<>();
            queryWrapper.in(Product::getId, importTaskCondition.getProductId());
            List<Product> products = productService.list(queryWrapper);
            if (products.size() != 0) {
                toName = products.get(0).getName();
            }
        }
        //导入任务
        taskName = type + "导入到" + to + "【" + toName + "】 - " + name;


        return taskName;
    }

    public void updateImportTaskState(Integer taskId, Integer state) {
        ImportTask importTask = this.getById(taskId);
        importTask.setState(state);
        importTask.updateById();
        if (state.equals(4)) {
            schedulingTaskService.pauseTask(taskId, state);
        }
        if (state.equals(0)) {
            schedulingTaskService.startTask();
        }

    }

    public Integer addExportTask(ExportTaskDTO exportTaskDTO){
        if (exportTaskDTO == null) {
            throw new XiaoShiException("入参不能为空");
        }
        ImportTaskCondition importTaskCondition = new ImportTaskCondition();
        if (exportTaskDTO.getProjectId() != null) {
            importTaskCondition.setProjectId(exportTaskDTO.getProjectId());
        }
        importTaskCondition.setIfUpdate(false);
        importTaskCondition.setType(exportTaskDTO.getType());
        importTaskCondition.setCreateId(exportTaskDTO.getCreateId());
        importTaskCondition.insert();

        Integer importTaskConditionId = importTaskCondition.getId();
        if (importTaskConditionId != null) {
            ImportTask importTask = new ImportTask();
            importTask.setImportTaskConditionId(importTaskConditionId);
            importTask.setType(exportTaskDTO.getType());
            importTask.setAllNum(exportTaskDTO.getAllNum());
            importTask.setFinishTime(exportTaskDTO.getFinishTime());
            importTask.setState(0);
            importTask.setCreateId(exportTaskDTO.getCreateId());
            String name = "";
            if (exportTaskDTO.getType().equals(6)) {
                name = "【专利】";
            } else if (exportTaskDTO.getType().equals(7)){
                name = "【PDF首页】";
            }
            String importTaskName = "导出" + name + "-" + exportTaskDTO.getCreateName();
            importTask.setName(importTaskName);
            importTask.insert();
            return importTask.getId();
        } else {
            throw new XiaoShiException("导出任务记录失败");
        }
    }


    public Integer updateExportTask(ExportTaskDTO exportTaskDTO){
        if (exportTaskDTO == null) {
            throw new XiaoShiException("入参不能为空");
        }
        ImportTask importTask = this.getById(exportTaskDTO.getTaskId());
        if (importTask != null) {
            Integer importTaskConditionId = importTask.getImportTaskConditionId();

            ImportTaskCondition importTaskCondition = importTaskConditionService.getById(importTaskConditionId);
            importTaskCondition.setFileGuid(exportTaskDTO.getFileGuid());
            importTaskCondition.updateById();

            importTask.setState(exportTaskDTO.getState());
            importTask.setAllNum(exportTaskDTO.getAllNum());
            importTask.setDoneNum(exportTaskDTO.getDoneNum());
            importTask.setDefaultNum(exportTaskDTO.getDefaultNum());
            importTask.setFinishTime(exportTaskDTO.getFinishTime());
            importTask.updateById();
        }
        return importTask.getId();
    }
}