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

package cn.cslg.pas.service.business;

import cn.cslg.pas.common.dto.business.*;
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.projectTask.*;
import cn.cslg.pas.common.model.request.GroupRequest;
import cn.cslg.pas.common.model.request.QueryRequest;
import cn.cslg.pas.common.model.request.StringRequest;
import cn.cslg.pas.common.utils.CacheUtils;
import cn.cslg.pas.common.utils.FormatUtil;
import cn.cslg.pas.common.utils.LoginUtils;
import cn.cslg.pas.common.vo.PatentWithIdVO;
import cn.cslg.pas.common.vo.business.*;
import cn.cslg.pas.domain.business.*;
import cn.cslg.pas.domain.es.EsProjectTask;
import cn.cslg.pas.domain.es.Patent;
import cn.cslg.pas.domain.es.PatentJoin;
import cn.cslg.pas.exception.UnLoginException;
import cn.cslg.pas.exception.XiaoShiException;
import cn.cslg.pas.factorys.businessFactory.Business;
import cn.cslg.pas.mapper.ProjectTaskMapper;
import cn.cslg.pas.service.AssoTaskFieldService;
import cn.cslg.pas.service.MailSendService;
import cn.cslg.pas.service.business.es.EsPatentService;
import cn.cslg.pas.service.business.es.EsService;
import cn.cslg.pas.service.common.FileManagerService;
import cn.cslg.pas.service.permissions.PermissionService;
import cn.cslg.pas.service.query.FormatQueryService;
import com.alibaba.fastjson.JSONObject;
import com.baomidou.mybatisplus.core.conditions.query.LambdaQueryWrapper;
import com.baomidou.mybatisplus.core.conditions.query.QueryWrapper;
import com.baomidou.mybatisplus.core.conditions.update.LambdaUpdateWrapper;
import com.baomidou.mybatisplus.extension.service.impl.ServiceImpl;
import org.springframework.beans.BeanUtils;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.stereotype.Service;
import org.springframework.transaction.annotation.Propagation;
import org.springframework.transaction.annotation.Transactional;

import org.springframework.web.multipart.MultipartFile;

import java.io.File;
import java.io.IOException;
import java.util.*;
import java.util.stream.Collectors;

/**
 * 任务模块
 *
 * @Author xiexiang
 * @Date 2023/11/21
 */
@Service
public class ProjectTaskService extends ServiceImpl<ProjectTaskMapper, ProjectTask> implements Business {

    @Autowired
    private CacheUtils cacheUtils;

    @Autowired
    private LoginUtils loginUtils;

    @Autowired
    private PatentDigProjectService patentDigProjectService;

    @Autowired
    private PatentDigProjectFilesService patentDigProjectFilesService;

    @Autowired
    private FormatQueryService formatQueryService;

    @Autowired
    private ProjectTaskMapper projectTaskMapper;

    @Autowired
    private PermissionService permissionService;

    @Autowired
    private AssoTaskFileService assoTaskFileService;

    @Autowired
    private TaskHandleResultService taskHandleResultService;

    @Autowired
    private AssoHandleResultFileService assoHandleResultFileService;

    @Autowired
    private FileManagerService fileManagerService;

    @Autowired
    private ProjectService projectService;

    @Autowired
    private AssoTaskPersonService assoTaskPersonService;

    @Autowired
    private TortCompareRecordService tortCompareRecordService;

    @Autowired
    private ReportProjectService reportProjectService;

    @Autowired
    private EsPatentService esPatentService;

    @Autowired
    private CompareLiteratureService compareLiteratureService;

    @Autowired
    private EsService esService;

    @Autowired
    private CustomFieldService customFieldService;

    @Autowired
    private AssoTaskFieldService assoTaskFieldService;

    @Autowired
    private FTOCompareRecordService ftoCompareRecordService;

    @Autowired
    private TaskCodeService taskCodeService;

    @Autowired
    private MailSendService mailSendService;

    @Autowired
    private AssoProjectPersonService assoProjectPersonService;

    /**
     * 挖掘项目开卷审核任务
     *
     * @param patentDigProjectTaskDTO
     * @return
     */
    public Object addProjectOpenAuditTask(PatentDigProjectTaskDTO patentDigProjectTaskDTO) {
        PatentDigProjectDTO patentDigProjectDTO = patentDigProjectTaskDTO.getPatentDigProjectDTO();
        ProjectTaskDTO projectTaskDTO = patentDigProjectTaskDTO.getProjectTaskDTO();
        TaskFormDTO taskFormDTO = toTaskFormDTO(projectTaskDTO);

        //如果专利挖掘项目DTO不为空，则需要先建立专利挖掘项目
        if (patentDigProjectDTO != null) {
            patentDigProjectDTO.setId(null);
            Integer projectId = (Integer) patentDigProjectService.addMessage(patentDigProjectDTO);
            if (projectId != null) {
                projectTaskDTO.setProjectId(projectId);
                projectTaskDTO.setType(1);
                ProjectTask projectTask = this.addTaskByTaskFormDTO(taskFormDTO, projectId);
                Integer projectTaskId = projectTask.getId();
                if (projectTaskId != null) {
                    //将专利挖掘项目状态置为开卷审核
                    LambdaUpdateWrapper<PatentDigProject> queryWrapper = new LambdaUpdateWrapper<>();
                    queryWrapper.eq(PatentDigProject::getProjectId, projectId);
                    queryWrapper.set(PatentDigProject::getState, 0);
                    patentDigProjectService.update(queryWrapper);
                }
                return projectTaskId;
            } else {
                throw new XiaoShiException("专利挖掘项目新增失败");
            }
        } else {
            throw new XiaoShiException("挖掘项目数据不能为空！");
        }
    }

    /**
     * 新建任务
     *
     * @param projectTaskDTO
     * @return
     */
    public Integer addTask(ProjectTaskDTO projectTaskDTO) throws Exception {
        //判断专题库id不为空
        if (projectTaskDTO.getProjectId() == null) {
            throw new XiaoShiException("专题库id不能为空!");
        }
        //判断任务类型不为空
        if (projectTaskDTO.getType() == null) {
            throw new XiaoShiException("任务类型不能为空!");
        }
        //判断任务名称不为空
        projectTaskDTO.setName(projectTaskDTO.getName().trim());
        String name = projectTaskDTO.getName();
        if (name == null || name.equals("")) {
            throw new XiaoShiException("任务名称不能为空!");
        }
        //根据assoTaskId查询processId
        if (projectTaskDTO.getAssoTaskId() != null) {
            LambdaQueryWrapper<ProjectTask> queryWrapper = new LambdaQueryWrapper<>();
            queryWrapper.eq(ProjectTask::getId, projectTaskDTO.getAssoTaskId());
            List<ProjectTask> projectTasks = this.list(queryWrapper);
            if (projectTasks != null && projectTasks.size() != 0) {
                ProjectTask projectTask = projectTasks.get(0);
                projectTaskDTO.setProcessId(projectTask.getProcessId());
            }
        }

        ProjectTask projectTask = new ProjectTask();
        BeanUtils.copyProperties(projectTaskDTO, projectTask);
        projectTask.setLastTaskId(null);
        //任务状态置为处理中
        projectTask.setStatus(2);
        //获取登录人信息
        PersonnelVO personnelVO = new PersonnelVO();

        personnelVO = cacheUtils.getLoginUser(loginUtils.getId());

        //设置任务的发起人
        projectTask.setCreateId(personnelVO.getId());
        projectTask.insert();
        Integer taskId = projectTask.getId();
        //新增任务可能会上传附件，如果附件不为空，则添加任务与附件关联
        if (projectTaskDTO.getFileGuids() != null) {
            AssoTaskFileDTO assoTaskFileDTO = new AssoTaskFileDTO();
            assoTaskFileDTO.setTaskId(projectTask.getId());
            assoTaskFileDTO.setFileGuids(projectTaskDTO.getFileGuids());
            assoTaskFileService.addTaskFile(assoTaskFileDTO);
        }

        if (projectTaskDTO.getLastTaskId() != null) {
            LambdaQueryWrapper<TaskHandleResult> queryWrapper = new LambdaQueryWrapper<>();
            queryWrapper.eq(TaskHandleResult::getTaskId, projectTaskDTO.getLastTaskId());
            TaskHandleResult taskHandleResult = taskHandleResultService.getOne(queryWrapper, false);
            if (taskHandleResult != null) {
                Integer resultId = taskHandleResult.getId();
                LambdaQueryWrapper<AssoHandleResultFile> queryWrapper1 = new LambdaQueryWrapper<>();
                queryWrapper1.eq(AssoHandleResultFile::getTaskHandleResultId, resultId);
                List<AssoHandleResultFile> assoHandleResultFiles = assoHandleResultFileService.list(queryWrapper1);
                List<FileDTO> fileDTOS = new ArrayList<>();
                this.getCopyFileDTOs(assoHandleResultFiles, fileDTOS);
                FileFormDTO fileFormDTO = new FileFormDTO();
                fileFormDTO.setFiles(fileDTOS);
                this.addProjectTaskFileByFormDTO(fileFormDTO, taskId);
            }
        }
        //根据新增的审核任务的lastTaskId，将上一级任务状态改为审核中
        if (projectTask.getLastTaskId() != null && projectTask.getType().equals(5)) {
            LambdaUpdateWrapper<ProjectTask> queryWrapper = new LambdaUpdateWrapper<>();
            queryWrapper.eq(ProjectTask::getId, projectTask.getLastTaskId());
            queryWrapper.set(ProjectTask::getStatus, 1);
            this.update(queryWrapper);
        }
        //项目可见人检验
        //如果是内部人员
        if (projectTask.getHandlerType().equals(0)) {
            this.checkProjectPerson(1, projectTask.getHandler(), projectTask.getProjectId(), projectTask.getId());
        }
        return projectTask.getId();
    }

    /**
     * 查询任务
     *
     * @param queryRequest
     * @return
     * @throws Exception
     */
    @Override
    public Object queryMessage(QueryRequest queryRequest) throws Exception {
        List<String> sqls = formatQueryService.reSqls(queryRequest, "projectTask");
        sqls = this.loadSearchSql(sqls);
        //根据sql查询任务信息
        List<ProjectTaskVO> projectTaskVOS = projectTaskMapper.getProjectTask(sqls.get(0), sqls.get(1), sqls.get(2));
        //查询总数
        Long total = projectTaskMapper.getProjectTaskCount(sqls.get(0));
        //装载事件信息
        this.loadProjectTask(projectTaskVOS);
        Records records = new Records();
        records.setCurrent(queryRequest.getCurrent());
        records.setSize(queryRequest.getSize());
        records.setData(projectTaskVOS);
        records.setTotal(total);
        return records;
    }

    /**
     * 装载任务
     *
     * @param projectTaskVOS
     * @throws IOException
     */
    public void loadProjectTask(List<ProjectTaskVO> projectTaskVOS) throws IOException {
        List<String> createIds = new ArrayList<>();
        List<String> handlerIds = new ArrayList<>();
        List<Integer> projectIds = new ArrayList<>();
        projectTaskVOS.forEach(
                item -> {
                    if (item.getCreateId() != null) {
                        createIds.add(item.getCreateId());
                    }
                    if (item.getHandler() != null && item.getHandlerType() != null && item.getHandlerType().equals(0)) {
                        handlerIds.add(item.getHandler());
                    }
                    if (item.getProjectId() != null) {
                        projectIds.add(item.getProjectId());
                    }
                }
        );
        List<Personnel> personnels = new ArrayList<>();
        List<Personnel> personnels2 = new ArrayList<>();
        //查询发起人名称
        if (createIds.size() != 0) {
            String res = permissionService.getPersonnelByIdsFromPCS(createIds);
            JSONObject jsonObject = JSONObject.parseObject(res);
            personnels = JSONObject.parseArray(jsonObject.getString("data"), Personnel.class);
        }
        //查询负责人名称
        if (handlerIds.size() != 0) {
            String res = permissionService.getPersonnelByIdsFromPCS(handlerIds);
            JSONObject jsonObject = JSONObject.parseObject(res);
            personnels2 = JSONObject.parseArray(jsonObject.getString("data"), Personnel.class);
        }
        //根据报告ids查询项目信息
        List<Project> projects = new ArrayList<>();
        if (!projectIds.isEmpty()) {
            projects = this.getProjectInfo(projectIds);
        }
        //装载信息
        for (ProjectTaskVO projectTaskVO : projectTaskVOS) {
            Integer handlerType = projectTaskVO.getHandlerType();
            //装载人员信息
            Personnel personnel = personnels.stream().filter(item -> item.getId().equals(projectTaskVO.getCreateId())).findFirst().orElse(null);
            if (personnel != null) {
                projectTaskVO.setCreateName(personnel.getPersonnelName());
            }

            if (handlerType != null && handlerType.equals(0)) {
                Personnel personnel2 = personnels2.stream().filter(item -> item.getId().equals(projectTaskVO.getHandler())).findFirst().orElse(null);
                if (personnel2 != null) {
                    projectTaskVO.setHandlerName(personnel2.getPersonnelName());
                }
            } else {
                projectTaskVO.setHandlerName(projectTaskVO.getHandler());
            }


            String name = patentDigProjectFilesService.getProcessName(projectTaskVO.getProcessId());
            projectTaskVO.setProcessName(name);
            Project project = projects.stream().filter(item -> item.getId().equals(projectTaskVO.getProjectId())).findFirst().orElse(null);
            if (project != null) {
                projectTaskVO.setProjectName(project.getName());
                projectTaskVO.setProjectType(project.getType());
                if (project.getType().equals(2)) {//报告
                    LambdaQueryWrapper<ReportProject> queryWrapper = new LambdaQueryWrapper<>();
                    queryWrapper.eq(ReportProject::getProjectId, projectTaskVO.getProjectId());
                    ReportProject reportProject = reportProjectService.getOne(queryWrapper, false);
                    if (reportProject != null) {
                        projectTaskVO.setReportType(reportProject.getReportType());
                    }
                }
            }
        }
    }


    /**
     * 根据任务id查询任务详情以及处理结果以及审核历史
     *
     * @param taskId
     * @return
     */
    public TaskDetailsVO getAuditHistory(Integer taskId) throws IOException {
        //新建返回VO类
        TaskDetailsVO taskDetailsVO = new TaskDetailsVO();
        List<HandleResultFileVO> handleResultFileVOS = new ArrayList<>();
        List<AuditHistoryVO> auditHistoryVOS = new ArrayList<>();
        //根据taskId查询此条任务详情
        ProjectTask currentTask = this.getById(taskId);
        //根据此条任务详情获取assoTaskId
        //使用Optional避免空指针异常：使用Optional来处理可能为空的变量，例如currentTask和assoTask。
        Optional<ProjectTask> currentTaskOptional = Optional.ofNullable(currentTask);
        Integer assoTaskId = currentTaskOptional.map(ProjectTask::getAssoTaskId).orElse(null);
        String taskPath = currentTaskOptional.map(ProjectTask::getTaskPath).orElse(null);
        List<ProjectTask> allProjectTasks = new ArrayList<>();
        if (assoTaskId != null) {
            //根据assoTaskId获取最初任务的详情
            ProjectTaskVO projectTaskVO = new ProjectTaskVO();
            ProjectTask assoTask = this.getById(assoTaskId);
            if (assoTask != null) {
                //装载最初任务详情
                BeanUtils.copyProperties(assoTask, projectTaskVO);
                taskDetailsVO.setProjectTaskVO(projectTaskVO);
                if (assoTask.getType() == 7) {
                    //专利挖掘文件任务
                    LambdaQueryWrapper<PatentDigProjectFiles> queryWrapper = new LambdaQueryWrapper<>();
                    queryWrapper.eq(PatentDigProjectFiles::getTaskId, assoTask.getId());
                    List<PatentDigProjectFiles> patentDigProjectFiles = patentDigProjectFilesService.list(queryWrapper);
                    List<String> fileGuids = new ArrayList<>();
                    List<SystemFile> systemFiles = new ArrayList<>();
                    if (!patentDigProjectFiles.isEmpty()) {
                        fileGuids = patentDigProjectFiles.stream().map(PatentDigProjectFiles::getFileGuid).collect(Collectors.toList());
                    }
                    //调用文件系统查询文件信息接口
                    if (!fileGuids.isEmpty()) {
                        String res = fileManagerService.getSystemFileFromFMS(fileGuids);
                        systemFiles = JSONObject.parseArray(res, SystemFile.class);
                    }
                    if (!systemFiles.isEmpty()) {
                        for (PatentDigProjectFiles patentDigProjectFiles1 : patentDigProjectFiles) {
                            HandleResultFileVO handleResultFileVO = new HandleResultFileVO();
                            //装载文件信息
                            SystemFile systemFile = systemFiles.stream().filter(item -> item.getGuid().equals(patentDigProjectFiles1.getFileGuid())).findFirst().orElse(null);
                            if (systemFile != null) {
                                BeanUtils.copyProperties(patentDigProjectFiles1, handleResultFileVO);
                                handleResultFileVO.setGuid(patentDigProjectFiles1.getFileGuid());
                                handleResultFileVO.setType(systemFile.getType());
                                handleResultFileVO.setSource(1);
                                handleResultFileVO.setOriginalName(systemFile.getOriginalName());
                            }
                            handleResultFileVOS.add(handleResultFileVO);
                        }
                    }
                }
                //根据assoTaskId查询所有任务的id
                List<Integer> ids = new ArrayList<>();
                ids.add(taskId);
                if (taskPath != null) {
                    List<String> a = Arrays.asList(taskPath.split("/"));
                    List<Integer> b = FormatUtil.StringTOIntegerList(a);
                    ids.addAll(b);
                }
                LambdaQueryWrapper<ProjectTask> allTaskWrapper = new LambdaQueryWrapper<>();
                allTaskWrapper.in(ProjectTask::getId, ids);
                allProjectTasks = this.list(allTaskWrapper);
            }
        }


        //审核历史返回VO以及集合
        if (allProjectTasks != null) {
            auditHistoryVOS = allProjectTasks.stream()
                    //过滤筛选掉分配任务的信息
                    .filter(item -> item.getId() != item.getAssoTaskId())
                    .map(item -> {
                        //新建VO
                        AuditHistoryVO auditHistoryVO = new AuditHistoryVO();
                        ProjectTaskVO auditHistoryTaskVO = new ProjectTaskVO();
                        BeanUtils.copyProperties(item, auditHistoryTaskVO);
                        //处理结果VO
                        TaskHandleResultVO taskHandleResultVO = new TaskHandleResultVO();
                        LambdaQueryWrapper<TaskHandleResult> queryWrapper = new LambdaQueryWrapper<>();
                        queryWrapper.eq(TaskHandleResult::getTaskId, item.getId());
                        List<TaskHandleResult> taskHandleResults = taskHandleResultService.list(queryWrapper);
                        if (taskHandleResults.size() != 0) {
                            TaskHandleResult taskHandleResult = taskHandleResults.get(0);
                            if (taskHandleResult != null) {
                                BeanUtils.copyProperties(taskHandleResult, taskHandleResultVO);
                                auditHistoryVO.setProjectTaskVO(auditHistoryTaskVO);
                                auditHistoryVO.setTaskHandleResultVO(taskHandleResultVO);
                                return auditHistoryVO;
                            }
                        }
                        return null;//返回空值不装到列表中
                    })
                    //过滤掉空对象
                    .filter(Objects::nonNull)
                    .sorted(Comparator.comparing(
                            a -> a.getTaskHandleResultVO(),
                            Comparator.nullsLast(Comparator.comparing(TaskHandleResultVO::getCreateTime, Comparator.reverseOrder()))))
                    .collect(Collectors.toList());

            taskDetailsVO.setAuditHistoryVOS(auditHistoryVOS);
        }
        //全部的文件信息(获取所有的任务的id，查出所有的结果id)
        List<Integer> allTaskIds = allProjectTasks.stream().map(ProjectTask::getId).collect(Collectors.toList());
        LambdaQueryWrapper<TaskHandleResult> queryWrapper = new LambdaQueryWrapper<>();
        queryWrapper.in(TaskHandleResult::getTaskId, allTaskIds);
        List<TaskHandleResult> taskHandleResults = taskHandleResultService.list(queryWrapper);

        List<Integer> resultIds = new ArrayList<>();
        if (taskHandleResults != null && !taskHandleResults.isEmpty()) {
            resultIds = taskHandleResults.stream().map(TaskHandleResult::getId).collect(Collectors.toList());
        }
        //根据所有的结果ids查询所有fileGuids
        if (resultIds != null && !resultIds.isEmpty()) {
            LambdaQueryWrapper<AssoHandleResultFile> allGuidsWrapper = new LambdaQueryWrapper<>();
            allGuidsWrapper.in(AssoHandleResultFile::getTaskHandleResultId, resultIds);
            List<AssoHandleResultFile> assoHandleResultFiles = assoHandleResultFileService.list(allGuidsWrapper);
            List<String> fileGuids = new ArrayList<>();
            List<SystemFile> systemFiles = new ArrayList<>();
            if (!assoHandleResultFiles.isEmpty()) {
                fileGuids = assoHandleResultFiles.stream().map(AssoHandleResultFile::getFileGuid).collect(Collectors.toList());
            }
            //调用文件系统查询文件信息接口
            if (!fileGuids.isEmpty()) {
                String res = fileManagerService.getSystemFileFromFMS(fileGuids);
                systemFiles = JSONObject.parseArray(res, SystemFile.class);
            }
            if (!systemFiles.isEmpty()) {
                for (AssoHandleResultFile assoHandleResultFile : assoHandleResultFiles) {
                    HandleResultFileVO handleResultFileVO = new HandleResultFileVO();
                    //装载文件信息
                    SystemFile systemFile = systemFiles.stream().filter(item -> item.getGuid().equals(assoHandleResultFile.getFileGuid())).findFirst().orElse(null);
                    if (systemFile != null) {
                        BeanUtils.copyProperties(assoHandleResultFile, handleResultFileVO);
                        handleResultFileVO.setGuid(assoHandleResultFile.getFileGuid());
                        handleResultFileVO.setSource(2);
                        handleResultFileVO.setType(systemFile.getType());
                        handleResultFileVO.setOriginalName(systemFile.getOriginalName());
                    }
                    handleResultFileVOS.add(handleResultFileVO);
                }
            }
        }
        taskDetailsVO.setSystemFileList(handleResultFileVOS.stream()
                .sorted(Comparator.comparing(HandleResultFileVO::getCreateTime).reversed())
                .collect(Collectors.toList()));
        //装载名称
        this.loadTaskDetails(taskDetailsVO);
        return taskDetailsVO;
    }

    /**
     * 装载任务详情的集合
     *
     * @param taskDetailsVO
     * @throws IOException
     */
    public void loadTaskDetails(TaskDetailsVO taskDetailsVO) throws IOException {
        //装载项目名称
        Integer projectId = null;
        if (taskDetailsVO.getProjectTaskVO() != null) {
            projectId = taskDetailsVO.getProjectTaskVO().getProjectId();
        }
        if (projectId != null) {
            //根据项目id查询项目名称并装载
            LambdaQueryWrapper<PatentDigProject> queryWrapper = new LambdaQueryWrapper<>();
            queryWrapper.eq(PatentDigProject::getProjectId, projectId);
            List<PatentDigProject> patentDigProjects = patentDigProjectService.list(queryWrapper);
            if (patentDigProjects != null && patentDigProjects.size() != 0) {
                PatentDigProject patentDigProject = patentDigProjects.get(0);
                String projectName = patentDigProject.getName();
                taskDetailsVO.getProjectTaskVO().setProjectName(projectName);
            }
        }
        //新建人员id集合
        List<String> createIds = new ArrayList<>();
        //添加分配任务的创建人id
        if (taskDetailsVO.getProjectTaskVO().getCreateId() != null) {
            createIds.add(taskDetailsVO.getProjectTaskVO().getCreateId());
        }
        //添加分配任务的负责人id
        if (taskDetailsVO.getProjectTaskVO().getHandler() != null) {
            createIds.add(taskDetailsVO.getProjectTaskVO().getHandler());
        }
        //添加文件上传人的id
        taskDetailsVO.getSystemFileList().forEach(
                item -> {
                    if (item.getCreateId() != null) {
                        createIds.add(item.getCreateId());
                    }
                }
        );
        //添加审查历史中的人员id
        taskDetailsVO.getAuditHistoryVOS().forEach(
                item -> {
                    if (item.getProjectTaskVO() != null) {
                        if (item.getProjectTaskVO().getCreateId() != null) {
                            createIds.add(item.getProjectTaskVO().getCreateId());
                        }
                        if (item.getProjectTaskVO().getHandler() != null) {
                            createIds.add(item.getProjectTaskVO().getHandler());
                        }
                    }
                    if (item.getTaskHandleResultVO() != null) {
                        if (item.getTaskHandleResultVO().getCreateId() != null) {
                            createIds.add(item.getTaskHandleResultVO().getCreateId());
                        }
                    }
                }
        );
        List<Personnel> personnels = new ArrayList<>();
        //查询创建人名称
        if (createIds.size() != 0) {
            String res = permissionService.getPersonnelByIdsFromPCS(createIds);
            JSONObject jsonObject = JSONObject.parseObject(res);
            personnels = JSONObject.parseArray(jsonObject.getString("data"), Personnel.class);
        }
        //装载人员信息
        //分配任务的创建人name
        if (taskDetailsVO.getProjectTaskVO() != null) {
            Personnel personnel = personnels.stream().filter(item -> item.getId().equals(taskDetailsVO.getProjectTaskVO().getCreateId())).findFirst().orElse(null);
            if (personnel != null) {
                taskDetailsVO.getProjectTaskVO().setCreateName(personnel.getPersonnelName());
            } else {
                throw new XiaoShiException("未获取到分配任务的创建人id信息");
            }
            //分配任务的负责人name
            Personnel personnel1 = personnels.stream().filter(item -> item.getId().equals(taskDetailsVO.getProjectTaskVO().getHandler())).findFirst().orElse(null);
            if (personnel1 != null) {
                taskDetailsVO.getProjectTaskVO().setHandlerName(personnel1.getPersonnelName());
            } else {
                throw new XiaoShiException("未获取到分配任务的负责人id信息");
            }
        }
        //装载所有文件的上传人name
        for (HandleResultFileVO handleResultFileVO : taskDetailsVO.getSystemFileList()) {
            if (handleResultFileVO != null) {
                Personnel personnel2 = personnels.stream().filter(item -> item.getId().equals(handleResultFileVO.getCreateId())).findFirst().orElse(null);
                if (personnel2 != null) {
                    handleResultFileVO.setCreateName(personnel2.getPersonnelName());
                } else {
                    throw new XiaoShiException("未获取到所有文件上传人id信息");
                }
            }
        }
        //装载所有审查历史中的人员name
        for (AuditHistoryVO auditHistoryVO : taskDetailsVO.getAuditHistoryVOS()) {
            if (auditHistoryVO.getProjectTaskVO() != null) {
                Personnel personnel3 = personnels.stream().filter(item -> item.getId().equals(auditHistoryVO.getProjectTaskVO().getCreateId())).findFirst().orElse(null);
                if (personnel3 != null) {
                    auditHistoryVO.getProjectTaskVO().setCreateName(personnel3.getPersonnelName());
                } else {
                    throw new XiaoShiException("未获取到分配任务的负责人id信息");
                }
                Personnel personnel4 = personnels.stream().filter(item -> item.getId().equals(auditHistoryVO.getProjectTaskVO().getHandler())).findFirst().orElse(null);
                if (personnel4 != null) {
                    auditHistoryVO.getProjectTaskVO().setHandlerName(personnel4.getPersonnelName());
                } else {
                    throw new XiaoShiException("未获取到分配任务的负责人id信息");
                }
            }
            if (auditHistoryVO.getTaskHandleResultVO() != null) {
                Personnel personnel5 = personnels.stream().filter(item -> item.getId().equals(auditHistoryVO.getTaskHandleResultVO().getCreateId())).findFirst().orElse(null);
                if (personnel5 != null) {
                    auditHistoryVO.getTaskHandleResultVO().setCreateName(personnel5.getPersonnelName());
                } else {
                    throw new XiaoShiException("未获取到分配任务的负责人id信息");
                }
            }
        }

    }

    /**
     * 取消/完成任务
     *
     * @param taskId
     * @param type
     */
    public void finishTask(Integer taskId, Integer type) {
        //处理人直接完成任务
        LambdaQueryWrapper<ProjectTask> queryWrapper = new LambdaQueryWrapper<>();
        queryWrapper.eq(ProjectTask::getId, taskId);
        ProjectTask projectTask = this.getOne(queryWrapper, false);
        if (projectTask != null) {
            //查询出当前任务的类型
            //如果是分配任务/或者协同任务
            if (projectTask.getType().equals(6)) {
                //类型为0，需要完成任务
                if (type.equals(0)) {
                    //完成需要判断不为审核中
                    if (projectTask.getStatus() != 1) {
                        projectTask.setStatus(3);
                        projectTask.updateById();
                    } else {
                        throw new XiaoShiException("任务状态为审核中，不可以完成");
                    }
                } else if (type.equals(1)) {
                    //类型为1，取消任务
                    projectTask.setStatus(5);
                    projectTask.updateById();
                    //所关联的审核任务的状态为处理中的设置为取消
                    //根据assoTaskId查询出所有任务，过滤状态为处理中的
                    Integer assoTaskId = projectTask.getAssoTaskId();
                    if (assoTaskId != null) {
                        LambdaQueryWrapper<ProjectTask> queryWrapper1 = new LambdaQueryWrapper<>();
                        queryWrapper1.eq(ProjectTask::getAssoTaskId, assoTaskId).eq(ProjectTask::getStatus, 2);
                        List<ProjectTask> projectTasks1 = this.list(queryWrapper1);
                        if (!projectTasks1.isEmpty()) {
                            projectTasks1.forEach(item -> {
                                item.setStatus(5);
                            });
                            this.updateBatchById(projectTasks1);
                        }
                    }
                    this.checkProjectPerson(2, projectTask.getHandler(), projectTask.getProjectId(), projectTask.getId());
                }
                //开卷审核项目(判断是报告还是挖掘项目)
            } else if (projectTask.getType().equals(1)) {
                Integer projectId = projectTask.getProjectId();
                //根据projectId查询类型
                LambdaQueryWrapper<Project> getType = new LambdaQueryWrapper<>();
                getType.eq(Project::getId, projectId);
                Project project = projectService.getOne(getType, false);
                Integer projectType = project.getType();
                //挖掘项目
                if (projectType != null && projectType.equals(3)) {
                    LambdaQueryWrapper<PatentDigProject> queryWrapper1 = new LambdaQueryWrapper<>();
                    queryWrapper1.eq(PatentDigProject::getProjectId, projectId);
                    PatentDigProject patentDigProject = patentDigProjectService.getOne(queryWrapper1, false);
                    if (patentDigProject != null) {
                        if (type.equals(0)) {
                            //直接同意
                            projectTask.setStatus(3);
                            projectTask.updateById();
                            patentDigProject.setState(2);
                            patentDigProject.updateById();
                        } else if (type.equals(1)) {
                            //取消
                            projectTask.setStatus(5);
                            projectTask.updateById();
                            patentDigProject.setState(4);
                            patentDigProject.updateById();
                            this.checkProjectPerson(2, projectTask.getHandler(), projectTask.getProjectId(), projectTask.getId());
                        } else if (type.equals(2)) {
                            //缺少资料
                            projectTask.setStatus(4);
                            projectTask.updateById();
                            patentDigProject.setState(5);
                            patentDigProject.updateById();
                        }
                    } else {
                        throw new XiaoShiException("未查询到专利挖掘项目");
                    }
                } else if (projectType != null && projectType.equals(2)) {//报告
                    LambdaQueryWrapper<ReportProject> queryWrapper1 = new LambdaQueryWrapper<>();
                    queryWrapper1.eq(ReportProject::getProjectId, projectId);
                    ReportProject reportProject = reportProjectService.getOne(queryWrapper1, false);
                    if (reportProject != null) {
                        if (type.equals(0)) {
                            //直接同意
                            projectTask.setStatus(3);
                            projectTask.updateById();
                            reportProject.setStatus(2);
                            reportProject.updateById();
                        } else if (type.equals(1)) {
                            //取消
                            projectTask.setStatus(5);
                            projectTask.updateById();
                            reportProject.setStatus(4);
                            reportProject.updateById();
                            this.checkProjectPerson(2, projectTask.getHandler(), projectTask.getProjectId(), projectTask.getId());
                        } else if (type.equals(2)) {
                            //缺少资料
                            projectTask.setStatus(4);
                            projectTask.updateById();
                            reportProject.setStatus(5);
                            reportProject.updateById();
                        }
                    } else {
                        throw new XiaoShiException("未查询到报告");
                    }
                }
            }
            //处理协同任务完成
            else if (projectTask.getType().equals(4)) {
                //获得请求人
                PersonnelVO personnelVO = cacheUtils.getLoginUser(loginUtils.getId());
                if (type.equals(0)) {
                    //判断请求人是否为创建人
                    if (personnelVO.getId() != null && personnelVO.getId().equals(projectTask.getCreateId())) {
                        projectTask.setStatus(3);
                        projectTask.updateById();
                    } else {
                        projectTask.setStatus(6);
                        projectTask.updateById();
                    }
                } else if (type.equals(1)) {
                    projectTask.setStatus(5);
                    projectTask.updateById();
                    this.checkProjectPerson(2, projectTask.getHandler(), projectTask.getProjectId(), projectTask.getId());
                }

            } else {
                if (type.equals(1)) {
                    projectTask.setStatus(5);
                    projectTask.updateById();
                    this.checkProjectPerson(2, projectTask.getHandler(), projectTask.getProjectId(), projectTask.getId());
                } else if (type.equals(0)) {
                    projectTask.setStatus(3);
                    projectTask.updateById();
                }
            }
        } else {
            throw new XiaoShiException("该任务不存在");
        }
    }


    @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
    public Object addMessage(Object object) {
        return null;
    }

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

    public List<Project> getProjectInfo(List<Integer> projectIds) {
        LambdaQueryWrapper<Project> queryWrapper = new LambdaQueryWrapper<>();
        queryWrapper.in(Project::getId, projectIds);
        List<Project> projects = projectService.list(queryWrapper);
        if (!projects.isEmpty()) {
            projects.forEach(item -> {
                Integer type = item.getType();
                if (type == 3) {
                    //挖掘项目
                    LambdaQueryWrapper<PatentDigProject> queryWrapper1 = new LambdaQueryWrapper<>();
                    queryWrapper1.eq(PatentDigProject::getProjectId, item.getId());
                    PatentDigProject patentDigProject = patentDigProjectService.getOne(queryWrapper1, false);
                    item.setName(patentDigProject.getName());
                }
            });
        }
        return projects;
    }

    /**
     * 添加侵权分析协同任务
     */
    @Transactional(propagation = Propagation.REQUIRED, rollbackFor = Throwable.class)
    public Integer addTortTask(TortTaskDTO tortTaskDTO) throws Exception {
        Integer projectId = tortTaskDTO.getProjectId();
        List<String> patentNos = tortTaskDTO.getPatentNos();
        //1.保存任务信息 project_task表
        if (tortTaskDTO == null) {
            throw new XiaoShiException("入参不能为空！");
        }
        //判断报告id不为空
        if (tortTaskDTO.getProjectId() == null) {
            throw new XiaoShiException("报告id不能为空!");
        }
        //判断协同人员类型不为空
        if (tortTaskDTO.getHandlerType() == null) {
            throw new XiaoShiException("协同人员类型不能为空!");
        }
        //判断任务名称不为空
        tortTaskDTO.setName(tortTaskDTO.getName().trim());
        String name = tortTaskDTO.getName();
        if (name == null || name.equals("")) {
            throw new XiaoShiException("任务名称不能为空!");
        }
        tortTaskDTO.setType(4);
        //获取登录人信息
        PersonnelVO personnelVO = new PersonnelVO();

        personnelVO = cacheUtils.getLoginUser(loginUtils.getId());

        ProjectTask projectTask = new ProjectTask();
        BeanUtils.copyProperties(tortTaskDTO, projectTask);
        projectTask.setCreateId(personnelVO.getId());
        projectTask.setStatus(2);
        projectTask.insert();
        Integer taskId = projectTask.getId();
        //2.保存任务和人员关联表信息
        if (taskId != null) {
            List<CCPerson> ccPeople = tortTaskDTO.getCcPeople();
            this.addTaskAndCCPeople(personnelVO.getId(), taskId, ccPeople);
            //发送给抄送人
            for (CCPerson item : ccPeople) {
                mailSendService.sentToCCMail(item.getPersonId(), item.getIfInner(), personnelVO.getId());
            }
        } else {
            throw new XiaoShiException("创建任务失败，未读取到任务id");
        }
        //3.从侵权分析中获得对比结果，并复制保存
        tortCompareRecordService.copyTortCompareRecords(tortTaskDTO.getProjectId(), taskId, personnelVO.getId());

        //保存es
        this.addCompareLiteratureByNosToEs(patentNos, taskId, projectId);
        //4.发送邮件通知协同人和抄送人
        String code = taskCodeService.addTaskCode(taskId);
        Boolean ifInner = true;
        if (tortTaskDTO.getHandlerType() == 0) {
            ifInner = true;
        } else {
            ifInner = false;
        }
        LambdaQueryWrapper<ReportProject> queryWrapper = new LambdaQueryWrapper<>();
        queryWrapper.eq(ReportProject::getProjectId, projectId);
        ReportProject reportProject = reportProjectService.getOne(queryWrapper, false);
        Integer reportType = null;
        if (reportProject != null) {
            reportType = reportProject.getReportType();
        }
        mailSendService.sendSynery(projectTask.getHandler(), ifInner, projectId, taskId, reportType, code);

        return projectTask.getId();
    }

    /**
     * 保存任务和人员关联表信息
     *
     * @param taskId
     * @param ccPeople
     */
    public void addTaskAndCCPeople(String createId, Integer taskId, List<CCPerson> ccPeople) {
        if (createId == null && createId.equals("")) {
            throw new XiaoShiException("createId不能为空");
        }
        if (taskId == null) {
            throw new XiaoShiException("taskId不能为空");
        }
        if (ccPeople != null && !ccPeople.isEmpty()) {
            List<AssoTaskPerson> assoTaskPeople = new ArrayList<>();
            ccPeople.forEach(item -> {
                AssoTaskPerson assoTaskPerson = new AssoTaskPerson();
                assoTaskPerson.setPersonId(item.getPersonId());
                assoTaskPerson.setIfInner(item.getIfInner());
                assoTaskPerson.setTaskId(taskId);
                assoTaskPerson.setCreateId(createId);
                assoTaskPeople.add(assoTaskPerson);
            });
            assoTaskPersonService.saveBatch(assoTaskPeople);
        }
    }

    /**
     * 根据任务id查询专利号
     *
     * @param taskId
     * @return
     */
    public String getPatentNoByTaskId(Integer taskId) {
        //根据任务id查询报告id
        if (taskId == null) {
            throw new XiaoShiException("taskId不能为空");
        }
        Integer projectId = tortCompareRecordService.getProjectIdByTaskId(taskId);
        String patentNo = this.getPatentNoByProjectId(projectId);
        return patentNo;
    }

    /**
     * 根据projectId查询专利号
     *
     * @param projectId
     * @return
     */
    public String getPatentNoByProjectId(Integer projectId) {
        //根据报告id查询专利号
        LambdaQueryWrapper<ReportProject> queryWrapper1 = new LambdaQueryWrapper<>();
        queryWrapper1.eq(ReportProject::getProjectId, projectId);
        ReportProject reportProject = reportProjectService.getOne(queryWrapper1, false);
        if (reportProject != null) {
            String patentNo = reportProject.getSignPatentNo();
            return patentNo;
        } else {
            throw new XiaoShiException("报告为空");
        }
    }

    /**
     * 侵权分析报告开卷审核任务
     *
     * @param reportAuditTaskDTO
     * @return
     */
    public Object addReportOpenAuditTask(ReportAuditTaskDTO reportAuditTaskDTO) {
        ReportProjectDTO reportProjectDTO = reportAuditTaskDTO.getReportProjectDTO();
        ProjectTaskDTO projectTaskDTO = reportAuditTaskDTO.getProjectTaskDTO();
        TaskFormDTO taskFormDTO = toTaskFormDTO(projectTaskDTO);

        //如果报告DTO不为空，则需要先建立报告
        if (reportProjectDTO != null) {
            Integer projectId = (Integer) reportProjectService.addMessage(reportProjectDTO);
            if (projectId != null) {
                projectTaskDTO.setProjectId(projectId);
                ProjectTask projectTask = this.addTaskByTaskFormDTO(taskFormDTO, projectId);
                Integer projectTaskId = projectTask.getId();
                if (projectTaskId != null) {
                    //将侵权分析报告置为开卷审核
                    LambdaUpdateWrapper<ReportProject> queryWrapper = new LambdaUpdateWrapper<>();
                    queryWrapper.eq(ReportProject::getProjectId, projectId);
                    queryWrapper.set(ReportProject::getStatus, 0);
                    reportProjectService.update(queryWrapper);

                }
                return projectTaskId;
            } else {
                throw new XiaoShiException("侵权分析报告新增失败");
            }
        } else {
            throw new XiaoShiException("侵权分析报告数据不能为空！");
        }
    }

    @Transactional(rollbackFor = Exception.class)
    public List<Integer> addMarkTask(MarkTaskDTO markTaskDTO) throws Exception {
        Integer projectId = markTaskDTO.getProjectId();
        List<MarkTaskDTO.MarkedField> markedFields = markTaskDTO.getMarkedFields();
        //获取人员专利
        List<PersonAssignedDTO> personAssignedDTOList = markTaskDTO.getPersonAssignedDTOList();
        //获取任务类型
        Integer taskType = markTaskDTO.getTaskType();
        //获取任务名称
        String taskName = markTaskDTO.getName();
        //获得截止时间
        Date deadLineTime = markTaskDTO.getDeadLineTime();
        List<Integer> ids = new ArrayList<>();
        StringRequest stringRequest = markTaskDTO.getStringRequest();
        //过滤出已经添加的专利
        PersonnelVO personnelVO = cacheUtils.getLoginUser(loginUtils.getId());
        //添加任务批次
        TaskBatch taskBatch = new TaskBatch();
        taskBatch.setCreateId(personnelVO.getId());
        taskBatch.insert();

        Integer taskBatchId = taskBatch.getId();

        List<String> patentNos = new ArrayList<>();
        List<Integer> nums = new ArrayList<>();
        personAssignedDTOList.forEach(item -> {
            if (item.getPatentNos() != null && item.getPatentNos().size() != 0) {
                patentNos.addAll(item.getPatentNos());
            } else {
                if (item.getPatentNum() != null) {
                    nums.add(item.getPatentNum());
                }
            }
        });


        Integer current = 1;
        for (PersonAssignedDTO item : personAssignedDTOList) {
            List<String> addPatentNos = new ArrayList<>();
            //创建任务
            ProjectTaskDTO projectTaskDTO = new ProjectTaskDTO();
            projectTaskDTO.setType(taskType);
            projectTaskDTO.setName(taskName);
            projectTaskDTO.setDeadLineTime(deadLineTime);
            projectTaskDTO.setHandler(item.getPersonId());
            projectTaskDTO.setHandlerType(0);
            projectTaskDTO.setProjectId(projectId);
            Integer taskId = this.addTask(projectTaskDTO);
            ids.add(taskId);
            //添加任务和标引关联
            this.addAssoTaskField(markedFields, taskId, taskBatchId, projectId);
            //根据检索式和已经添加的专利以及位置获得专利
            if (item.getPatentNos() == null || item.getPatentNos().size() == 0) {
                if (nums.size() > 0) {
                    Integer num = nums.remove(0);
                    stringRequest.setCurrent(Long.parseLong(current.toString()));
                    stringRequest.setSize(Long.parseLong(num.toString()));
                    stringRequest.setProjectId(projectId);
                    List<Patent> patentList = esPatentService.getPatentsWithNotNo(stringRequest, patentNos);
                    addPatentNos = patentList.stream().map(Patent::getPatentNo).collect(Collectors.toList());
                    current += num;
                }
            } else {
                addPatentNos = item.getPatentNos();
            }
            //添加专利
            this.addCompareLiteratureByNosToEs(addPatentNos, taskId, projectId);
        }
        return ids;
    }

    //添加对比文献和专利号关联
    private void addCompareLiteratureByNos(List<String> patentNos, Integer taskId, Integer projectId) {
        List<CompareLiterature> compareLiteratures = new ArrayList<>();
        if (patentNos == null || patentNos.size() == 0) {
            return;
        } else {
            patentNos.forEach(item -> {
                CompareLiterature compareLiterature = new CompareLiterature();
                compareLiterature.setLiteratureNo(item);
                compareLiterature.setProjectId(projectId);
                compareLiterature.setName(item);
                compareLiteratures.add(compareLiterature);
            });
        }
        compareLiteratureService.saveBatch(compareLiteratures);
    }


    /**
     * 添加FTO协同任务
     *
     * @param tortTaskDTO
     * @return
     */
    public Integer addFTOAssitTask(TortTaskDTO tortTaskDTO) {
        //1.保存任务信息 project_task表
        if (tortTaskDTO == null) {
            throw new XiaoShiException("入参不能为空！");
        }
        //判断报告id不为空
        Integer projectId = tortTaskDTO.getProjectId();
        if (projectId == null) {
            throw new XiaoShiException("报告id不能为空!");
        }
        //判断协同人员类型不为空
        if (tortTaskDTO.getHandlerType() == null) {
            throw new XiaoShiException("协同人员类型不能为空!");
        }
        //判断任务名称不为空
        tortTaskDTO.setName(tortTaskDTO.getName().trim());
        String name = tortTaskDTO.getName();
        if (name == null || name.equals("")) {
            throw new XiaoShiException("任务名称不能为空!");
        }
        tortTaskDTO.setType(4);
        //获取登录人信息
        PersonnelVO personnelVO = new PersonnelVO();

        personnelVO = cacheUtils.getLoginUser(loginUtils.getId());

        ProjectTask projectTask = new ProjectTask();
        BeanUtils.copyProperties(tortTaskDTO, projectTask);
        projectTask.setCreateId(personnelVO.getId());
        projectTask.setStatus(2);
        projectTask.insert();
        Integer taskId = projectTask.getId();
        //2.compareLiterature入库
        List<String> patentNos = tortTaskDTO.getPatentNos();
        if (!patentNos.isEmpty()) {
            try {
                this.addCompareLiteratureByNosToEs(patentNos, taskId, projectId);
                //3.从侵权分析中获得对比结果，并复制保存
                //taskId是协同任务id
                ftoCompareRecordService.copyFTOCompareRecords(tortTaskDTO.getProjectId(), taskId, personnelVO.getId(), patentNos);
            } catch (Exception e) {
                throw new XiaoShiException(e.toString());
            }
        }
        //4.保存任务和人员关联表信息
        if (taskId != null) {
            List<CCPerson> ccPeople = tortTaskDTO.getCcPeople();
            this.addTaskAndCCPeople(personnelVO.getId(), taskId, ccPeople);
            //发送给抄送人
            for (CCPerson item : ccPeople) {
                mailSendService.sentToCCMail(item.getPersonId(), item.getIfInner(), personnelVO.getId());
            }
        } else {
            throw new XiaoShiException("创建任务失败，未读取到任务id");
        }
        //5.发送邮件通知协同人
        //获取code码
        String code = taskCodeService.addTaskCode(taskId);
        Boolean ifInner = true;
        if (tortTaskDTO.getHandlerType() == 0) {
            ifInner = true;
        } else {
            ifInner = false;
        }
        LambdaQueryWrapper<ReportProject> queryWrapper = new LambdaQueryWrapper<>();
        queryWrapper.eq(ReportProject::getProjectId, projectId);
        ReportProject reportProject = reportProjectService.getOne(queryWrapper, false);
        Integer reportType = null;
        if (reportProject != null) {
            reportType = reportProject.getReportType();
        }
        mailSendService.sendSynery(projectTask.getHandler(), ifInner, projectId, taskId, reportType, code);
        return projectTask.getId();
    }

    /**
     * 添加任务与专利关联到ES
     *
     * @param patentNos
     * @param taskId
     * @param projectId
     * @throws Exception
     */
    private void addCompareLiteratureByNosToEs(List<String> patentNos, Integer taskId, Integer projectId) throws Exception {
        if (patentNos == null || patentNos.size() == 0) {
            return;
        } else {
            patentNos.forEach(item -> {
                //根据专利号查询专利
                PatentWithIdVO patentWithIdVO = null;
                try {
                    patentWithIdVO = esService.getIdByPatentNo(item);
                } catch (Exception e) {
                    e.printStackTrace();
                }
                if (patentWithIdVO != null) {
                    String id = patentWithIdVO.getId();
                    if (id != null || !id.trim().equals("")) {
                        Patent patent = new Patent();
                        EsProjectTask esProjectTask = new EsProjectTask();
                        esProjectTask.setProjectId(projectId);
                        esProjectTask.setTaskId(taskId);
                        PatentJoin patentJoin = new PatentJoin();
                        patentJoin.setParent(id);
                        patentJoin.setName("task");
                        patent.setPatentJoin(patentJoin);
                        patent.setProjectTask(esProjectTask);
                        try {
                            esService.addChildPatent(patent, id);
                        } catch (Exception e) {
                        }
                    }
                }
            });
        }
    }


    private void addAssoTaskField(List<MarkTaskDTO.MarkedField> markedFields, Integer taskId, Integer batchId, Integer projectId) {
        List<AssoTaskField> assoTaskFields = new ArrayList<>();
        if (markedFields == null || markedFields.size() == 0) {
            //根据projectId 查询所有标引栏位
            List<AllCustomFieldVO> customFieldVOS = customFieldService.getAllProjectCustomField(projectId);
            if (customFieldVOS != null && customFieldVOS.size() > 0) {
                customFieldVOS.forEach(item -> {
                    AssoTaskField assoTaskField = new AssoTaskField();
                    assoTaskField.setFieldId(item.getId());
                    assoTaskField.setFieldType(item.getType());
                    assoTaskField.setTaskId(taskId);
                    assoTaskField.setTaskBatchId(batchId);
                    assoTaskField.setProjectId(projectId);
                    assoTaskField.setFieldValueId(0);
                    assoTaskFields.add(assoTaskField);
                });
            }
        } else {
            markedFields.forEach(item -> {

                if (item.getValues() != null && item.getValues().size() > 0) {
                    item.getValues().forEach(i -> {
                        AssoTaskField assoTaskField = new AssoTaskField();
                        assoTaskField.setFieldId(item.getFieldId());
                        assoTaskField.setFieldType(item.getFieldType());
                        assoTaskField.setTaskId(taskId);
                        assoTaskField.setTaskBatchId(batchId);
                        assoTaskField.setProjectId(projectId);
                        assoTaskField.setFieldValueId(i);
                        assoTaskFields.add(assoTaskField);
                    });
                } else {
                    AssoTaskField assoTaskField = new AssoTaskField();
                    assoTaskField.setFieldId(item.getFieldId());
                    assoTaskField.setFieldType(item.getFieldType());
                    assoTaskField.setTaskId(taskId);
                    assoTaskField.setTaskBatchId(batchId);
                    assoTaskField.setProjectId(projectId);
                    assoTaskField.setFieldValueId(0);
                    assoTaskFields.add(assoTaskField);
                }
            });

        }
        assoTaskFieldService.saveBatch(assoTaskFields);
    }

    public Optional<ProjectTask> getByIdOpt(Integer id) {
        ProjectTask projectTask = projectTaskMapper.selectById(id);
        return Optional.ofNullable(projectTask);
    }

    /**
     *
     */
    public void getPatent(String patentNo, Integer taskId) {


    }

    /**
     * 更新任务
     *
     * @param updateProjectTaskDTO
     * @return
     */
    public Integer updateTask(UpdateProjectTaskDTO updateProjectTaskDTO) {
        if (updateProjectTaskDTO == null) {
            throw new XiaoShiException("入参为空");
        }
        Integer id = updateProjectTaskDTO.getId();
        ProjectTask projectTask = this.getById(id);
        if (projectTask != null) {
            BeanUtils.copyProperties(updateProjectTaskDTO, projectTask);
            projectTask.updateById();
        }
        return projectTask.getId();
    }

    //装载查询语句
    private List<String> loadSearchSql(List<String> sqls) {
        PersonnelVO personnelVO = cacheUtils.getLoginUser(loginUtils.getId());
        String id = personnelVO.getId();
        String rootSql = "(create_id =" + id + " or handler=" + id + ")";
        if (sqls.get(0) != null && !sqls.get(0).equals("")) {
            sqls.set(0, rootSql + " and" + "(" + sqls.get(0) + ")");

        } else {
            sqls.set(0, rootSql);
        }

        return sqls;

    }

    /**
     * 处理任务参与人员与项目可见人员
     *
     * @param type    1为新增 2为取消
     * @param handler
     */
    public void checkProjectPerson(Integer type, String handler, Integer projectId, Integer taskId) {
        //获取登录人信息
        Integer roleType = 2;
        PersonnelVO personnelVO = new PersonnelVO();

        personnelVO = cacheUtils.getLoginUser(loginUtils.getId());

        LambdaQueryWrapper<AssoProjectPerson> queryWrapper = new LambdaQueryWrapper<>();
        queryWrapper.eq(AssoProjectPerson::getProjectId, projectId);
        queryWrapper.eq(AssoProjectPerson::getRole, roleType);
        List<AssoProjectPerson> assoProjectPeople = assoProjectPersonService.list(queryWrapper);
        //新增任务的时候 需要将任务处理人添加到项目可见人中 先校验是否已经存在
        if (type.equals(1)) {
            AssoProjectPerson assoProjectPerson = new AssoProjectPerson();
            assoProjectPerson.setProjectId(projectId);
            assoProjectPerson.setPersonId(handler);
            assoProjectPerson.setCreateId(personnelVO.getId());
            assoProjectPerson.setRole(roleType);
            if (!assoProjectPeople.isEmpty()) {
                List<String> people = assoProjectPeople.stream().map(AssoProjectPerson::getPersonId).collect(Collectors.toList());
                if (!people.contains(handler)) {
                    assoProjectPerson.insert();
                }
            } else {
                assoProjectPerson.insert();
            }
        }
        //取消任务的时候 需要将任务处理人从项目可见人中去除 但是先校验是否还有别的任务导致他在项目可见人中
        else if (type.equals(2)) {
            if (!assoProjectPeople.isEmpty()) {
                LambdaQueryWrapper<ProjectTask> queryWrapper1 = new LambdaQueryWrapper<>();
                queryWrapper1.eq(ProjectTask::getProjectId, projectId)
                        .eq(ProjectTask::getHandlerType, 0)
                        .eq(ProjectTask::getHandler, handler)
                        .ne(ProjectTask::getStatus, 5);
                List<ProjectTask> projectTasks = this.list(queryWrapper1);
                if (projectTasks.isEmpty()) {
                    LambdaQueryWrapper<AssoProjectPerson> deleteWrapper = new LambdaQueryWrapper<>();
                    deleteWrapper.eq(AssoProjectPerson::getProjectId, projectId)
                            .eq(AssoProjectPerson::getPersonId, handler)
                            .eq(AssoProjectPerson::getRole, roleType);
                    assoProjectPersonService.remove(deleteWrapper);
                }
            }
        }
    }

    public ProjectTask addTaskByTaskFormDTO(TaskFormDTO taskFormDTO, Integer projectId) {
        String name = taskFormDTO.getName();
        Integer handleType = taskFormDTO.getHandlerType();
        String handleName = taskFormDTO.getHandler();
        Date deadLineTime = taskFormDTO.getDeadLineTime();
        Integer lastTaskId = taskFormDTO.getLastTaskId();
        Integer assoTaskId = taskFormDTO.getAssoTaskId();
        ProjectTask projectTask = new ProjectTask();
        projectTask.setName(name);
        projectTask.setHandlerType(handleType);
        projectTask.setHandler(handleName);
        projectTask.setDeadLineTime(deadLineTime);
        projectTask.setProjectId(projectId);
        projectTask.setType(taskFormDTO.getTaskType());
        projectTask.setAssoTaskId(assoTaskId);

        //任务状态置为处理中
        projectTask.setStatus(2);
        //获取登录人信息
        PersonnelVO personnelVO = new PersonnelVO();
        personnelVO = cacheUtils.getLoginUser(loginUtils.getId());
        if (lastTaskId != null) {
            ProjectTask projectTask1 = this.getById(lastTaskId);
            String lastName = projectTask1.getName();
            projectTask.setLastTaskId(lastTaskId);
            projectTask.setProjectId(projectTask1.getProjectId());
            projectTask.setProcessId(projectTask1.getProcessId());
            projectTask.setType(projectTask1.getType());
            String lastPath = projectTask1.getTaskPath();
            if (lastPath == null) {
                lastPath = projectTask1.getId() + "";
            } else {
                lastPath += "/" + projectTask1.getId();
            }
            projectTask.setTaskPath(lastPath);
            Integer b = 1;
            if (!lastPath.equals("")) {
                String[] a = lastPath.split("/");
                b = a.length + 1;
            }

            String newName = lastName + "-" + b + "级审核";
            projectTask.setName(newName);

        }

        //设置任务的发起人
        projectTask.setCreateId(personnelVO.getId());
        projectTask.insert();
        return projectTask;
    }

    public void addProjectTaskFileByFormDTO(FileFormDTO fileFormDTO, Integer taskId) {
        List<FileDTO> fileDTOS = fileFormDTO.getFiles();
        List<String> fileGuids = fileDTOS.stream().map(FileDTO::getGuid).collect(Collectors.toList());

        if (fileGuids != null && fileGuids.size() > 0) {
            AssoTaskFileDTO assoTaskFileDTO = new AssoTaskFileDTO();
            assoTaskFileDTO.setTaskId(taskId);
            assoTaskFileDTO.setFileGuids(fileGuids);
            assoTaskFileService.addTaskFile(fileDTOS, taskId);
        }
    }

    public Integer addFileExamineTask(AddFileExamineTaskDTO addFileExamineTaskDTO) {
        FileFormDTO fileFormDTO = addFileExamineTaskDTO.getFileForm();
        TaskFormDTO taskFormDTO = addFileExamineTaskDTO.getTaskForm();
        taskFormDTO.setTaskType(taskFormDTO.getTaskType());
        Integer projectId = fileFormDTO.getProjectId();
        ProjectTask projectTask = this.addTaskByTaskFormDTO(taskFormDTO, projectId);
        Integer taskId = projectTask.getId();
        this.addProjectTaskFileByFormDTO(fileFormDTO, taskId);

        //如果是内部人员
//        if (projectTask.getHandlerType().equals(0)) {
//            this.checkProjectPerson(1, projectTask.getHandler(), projectTask.getProjectId(), projectTask.getId());
//        }
        return projectTask.getId();
    }

    /**
     * 根据任务id查询任务详情以及处理结果以及审核历史
     *
     * @param getExamineHistoryDTO
     * @return
     */
    public List<TaskResultVO> getExamineHistory(GetExamineHistoryDTO getExamineHistoryDTO) throws IOException {
        List<TaskResultVO> taskDetailsVOs = new ArrayList<>();
        Integer taskId = getExamineHistoryDTO.getTaskId();
        String fileGuid = getExamineHistoryDTO.getFileGuid();
        Boolean ifGetLast = getExamineHistoryDTO.getIfGetLast();
        String rootGuid = fileGuid;
        if (fileGuid != null && !fileGuid.equals("")) {
            AssoTaskFile assoTaskFile = assoTaskFileService.getAssoTaskFileByGuid(fileGuid);
            if (assoTaskFile == null) {
                return new ArrayList<>();
            }
            if (taskId == null) {
                taskId = assoTaskFile.getTaskId();
            }
            if (assoTaskFile.getRootFileGuid() != null) {
                rootGuid = assoTaskFile.getRootFileGuid();
            }
        }
        //根据taskId 查询任务

        LambdaQueryWrapper<ProjectTask> queryWrapper = new LambdaQueryWrapper<>();
        ProjectTask projectTask = this.getById(taskId);
        Integer rootTaskId = projectTask.getAssoTaskId();
        if (rootTaskId == null) {
            String path = projectTask.getTaskPath();
            String key = null;
            if (path == null) {
                key = projectTask.getId() + "";
            } else {
                String[] paths = path.split("/");
                key = paths[0];
            }

            queryWrapper.apply("id=" + key + " or find_in_set(" + key + ",REPLACE(task_path, '/', ',')) ");
        } else {
            queryWrapper.eq(ProjectTask::getAssoTaskId, rootTaskId);
        }
        List<ProjectTask> projectTasks = new ArrayList<>();
        if (ifGetLast != null && ifGetLast) {
            queryWrapper.orderByDesc(ProjectTask::getCreateTime);
            ProjectTask projectTask1 = this.getOne(queryWrapper, false);
            if (projectTask1 != null) {
                projectTasks.add(projectTask1);
            }
        } else {
            queryWrapper.orderByAsc(ProjectTask::getCreateTime);
            projectTasks = this.list(queryWrapper);
        }


        List<Integer> taskIds = projectTasks.stream().map(ProjectTask::getId).collect(Collectors.toList());

        if (taskIds == null || taskIds.size() == 0) {
            return taskDetailsVOs;
        }
        LambdaQueryWrapper<TaskHandleResult> resultLambdaQueryWrapper = new LambdaQueryWrapper<>();
        resultLambdaQueryWrapper.in(TaskHandleResult::getTaskId, taskIds);
        List<TaskHandleResult> taskHandleResults = taskHandleResultService.list(resultLambdaQueryWrapper);
        List<AssoHandleResultFile> resultFiles = new ArrayList<>();
        List<Integer> resultIds = taskHandleResults.stream().map(TaskHandleResult::getId).collect(Collectors.toList());
        if (resultIds != null && resultIds.size() > 0) {
            LambdaQueryWrapper<AssoHandleResultFile> resultFileWrapper = new LambdaQueryWrapper<>();
            resultFileWrapper.in(AssoHandleResultFile::getTaskHandleResultId, resultIds);
            if (fileGuid != null && !fileGuid.equals("")) {
                resultFileWrapper.eq(AssoHandleResultFile::getRootFileGuid, rootGuid);
            }
            resultFiles = assoHandleResultFileService.list(resultFileWrapper);
        }


        List<String> fileGuids = resultFiles.stream().map(AssoHandleResultFile::getFileGuid).collect(Collectors.toList());
        List<SystemFile> systemFiles = new ArrayList<>();
        if (!fileGuids.isEmpty()) {
            String res = fileManagerService.getSystemFileFromFMS(fileGuids);
            systemFiles = JSONObject.parseArray(res, SystemFile.class);
        }

        for (ProjectTask projectTask1 : projectTasks) {
            TaskResultVO taskResultVO = new TaskResultVO();
            Integer status = projectTask1.getStatus();
            Integer taskId1 = projectTask1.getId();
            Integer handleType = projectTask1.getHandlerType();
            String handler = projectTask1.getHandler();
            TaskHandleResult taskHandleResult = taskHandleResults.stream().filter(item -> item.getTaskId().equals(taskId1)).findFirst().orElse(null);
            if (taskHandleResult != null) {
                BeanUtils.copyProperties(taskHandleResult, taskResultVO);
                List<String> temGuids = resultFiles.stream().filter(item -> item.getTaskHandleResultId().equals(taskHandleResult.getId())).map(AssoHandleResultFile::getFileGuid).collect(Collectors.toList());
                if (temGuids != null && temGuids.size() > 0) {
                    List<SystemFile> systemFileList = systemFiles.stream().filter(item -> temGuids.contains(item.getGuid())).collect(Collectors.toList());
                    taskResultVO.setFiles(systemFileList);
                }
            } else {
                taskResultVO.setNextAuditor(projectTask1.getCreateId());
            }
            if (handleType.equals(0)) {
                taskResultVO.setCreateId(handler);
            } else {
                taskResultVO.setCreateName(handler);
            }
            taskResultVO.setStatus(status);
            taskDetailsVOs.add(taskResultVO);
        }


        //装载名称
        this.loadTaskResultVos(taskDetailsVOs);
        return taskDetailsVOs;
    }

    /**
     * 装载任务详情的集合
     *
     * @param taskResultVOs
     * @throws IOException
     */
    public void loadTaskResultVos(List<TaskResultVO> taskResultVOs) throws IOException {
        //装载项目名称
        List<String> createIds = taskResultVOs.stream().map(TaskResultVO::getCreateId).collect(Collectors.toList());

        List<Personnel> personnels = new ArrayList<>();
        //查询创建人名称
        if (createIds.size() != 0) {
            String res = permissionService.getPersonnelByIdsFromPCS(createIds);
            JSONObject jsonObject = JSONObject.parseObject(res);
            personnels = JSONObject.parseArray(jsonObject.getString("data"), Personnel.class);
        }

        //装载所有审查历史中的人员name
        for (TaskResultVO taskResultVO : taskResultVOs) {
            if (taskResultVO.getCreateName() == null) {
                Personnel personnel = personnels.stream().filter(item -> item.getId().equals(taskResultVO.getCreateId())).findFirst().orElse(null);
                if (personnel != null) {
                    taskResultVO.setCreateName(personnel.getPersonnelName());
                } else {
                    throw new XiaoShiException("未获取到分配任务的负责人id信息");
                }
            }
        }
        return;
    }

    public TaskFormDTO toTaskFormDTO(ProjectTaskDTO projectTaskDTO) {
        TaskFormDTO taskFormDTO = new TaskFormDTO();
        taskFormDTO.setTaskType(1);
        taskFormDTO.setHandlerType(projectTaskDTO.getHandlerType());
        taskFormDTO.setHandler(projectTaskDTO.getHandler());
        taskFormDTO.setDeadLineTime(projectTaskDTO.getDeadLineTime());
        taskFormDTO.setName(projectTaskDTO.getName());
        taskFormDTO.setDescription(projectTaskDTO.getDescription());
        return taskFormDTO;
    }

    /**
     * 从审核结果文件中，复制文件
     *
     * @param assoHandleResultFiles
     * @param fileDTOS
     * @throws Exception
     */
    public void getCopyFileDTOs(List<AssoHandleResultFile> assoHandleResultFiles, List<FileDTO> fileDTOS) throws Exception {
        List<File> files = new ArrayList<>();
        for (AssoHandleResultFile assoHandleResultFile : assoHandleResultFiles) {
            String rootFileGuid = assoHandleResultFile.getFileGuid();
            File file = fileManagerService.getOrgTempFileByGuid(assoHandleResultFile.getFileGuid());
            files.add(file);
            if (fileDTOS != null) {
                List<String> guid2s = fileManagerService.uploadFileGetGuid2(Arrays.asList(file));
                if (guid2s != null && guid2s.size() > 0) {
                    FileDTO fileDTO = new FileDTO();
                    fileDTO.setGuid(guid2s.get(0));
                    fileDTO.setRootGuid(rootFileGuid);
                    fileDTOS.add(fileDTO);
                }
            }
        }
        files.forEach(item -> item.delete());
    }
}