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.request.GroupRequest;
import cn.cslg.pas.common.model.request.QueryRequest;
import cn.cslg.pas.common.utils.CacheUtils;
import cn.cslg.pas.common.utils.LoginUtils;
import cn.cslg.pas.common.vo.business.*;
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.ProjectTaskMapper;
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.extension.service.impl.ServiceImpl;
import org.springframework.beans.BeanUtils;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.stereotype.Service;
import org.springframework.web.multipart.MultipartFile;

import java.io.IOException;
import java.util.ArrayList;
import java.util.List;
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 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;


    /**
     * 项目开卷审核任务
     * @param patentDigProjectTaskDTO
     * @return
     */
    public Object addProjectOpenAuditTask(PatentDigProjectTaskDTO patentDigProjectTaskDTO){
        PatentDigProjectDTO patentDigProjectDTO = patentDigProjectTaskDTO.getPatentDigProjectDTO();
        ProjectTaskDTO projectTaskDTO = patentDigProjectTaskDTO.getProjectTaskDTO();
        //如果专利挖掘项目DTO不为空，则需要先建立专利挖掘项目
        if (patentDigProjectDTO != null) {
            Integer projectId = (Integer) patentDigProjectService.addMessage(patentDigProjectDTO);
            projectTaskDTO.setProjectId(projectId);
            Integer projectTaskId = this.addTask(projectTaskDTO);
            return projectTaskId;
        } else {
            throw new XiaoShiException("挖掘项目数据不能为空！");
        }
    }

    /**
     * 新建任务
     * @param projectTaskDTO
     * @return
     */
    public Integer addTask(ProjectTaskDTO projectTaskDTO){
        //判断专题库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.setStatus(2);
        //获取登录人信息
        PersonnelVO personnelVO = new PersonnelVO();
        try {
            personnelVO = cacheUtils.getLoginUser(loginUtils.getId());
        } catch (Exception e) {
            throw new UnLoginException("未登录");
        }
        //设置任务的发起人
        projectTask.setCreateId(personnelVO.getId());
        projectTask.insert();
        if (projectTask.getAssoTaskId() == null && projectTask.getType() == 6) {
            projectTask.setAssoTaskId(projectTask.getId());
        }
        //新增任务可能会上传附件，如果附件不为空，则添加任务与附件关联
        if (projectTaskDTO.getFileGuids() != null) {
            AssoTaskFileDTO assoTaskFileDTO = new AssoTaskFileDTO();
            assoTaskFileDTO.setTaskId(projectTask.getId());
            assoTaskFileDTO.setFileGuids(projectTaskDTO.getFileGuids());
            assoTaskFileService.addTaskFile(assoTaskFileDTO);
        }
        //根据新增的审核任务的lastTaskId，将上一级任务状态改为审核中
        if (projectTask.getLastTaskId() != null) {
            LambdaQueryWrapper<ProjectTask> queryWrapper = new LambdaQueryWrapper<>();
            queryWrapper.eq(ProjectTask::getId, projectTask.getLastTaskId());
            List<ProjectTask> projectTasks = this.list(queryWrapper);
            if (projectTasks != null && projectTasks.size() != 0) {
                ProjectTask projectTask1 = projectTasks.get(0);
                projectTask1.setStatus(1);
                projectTask1.updateById();
            }
        }
        return projectTask.getId();
    }

    /**
     * 查询任务
     * @param queryRequest
     * @return
     * @throws Exception
     */
    @Override
    public Object queryMessage(QueryRequest queryRequest) throws Exception {
        List<String> sqls = formatQueryService.reSqls(queryRequest,"projectTask");
        //根据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<>();
        projectTaskVOS.forEach(
                item -> {
                    if (item.getCreateId() != null) {
                        createIds.add(item.getCreateId());
                    }
                    if (item.getHandler() != null) {
                        handlerIds.add(item.getHandler());
                    }
                }
        );
        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);
        }
        //装载信息
        for (ProjectTaskVO projectTaskVO : projectTaskVOS) {
            //装载人员信息
            Personnel personnel = personnels.stream().filter(item -> item.getId().equals(projectTaskVO.getCreateId())).findFirst().orElse(null);
            Personnel personnel2 = personnels2.stream().filter(item -> item.getId().equals(projectTaskVO.getHandler())).findFirst().orElse(null);
            if(personnel != null){
                projectTaskVO.setCreateName(personnel.getPersonnelName());
                projectTaskVO.setHandlerName(personnel2.getPersonnelName());
            } else {
                throw new XiaoShiException("未获取到当前登陆人信息");
            }
        }
    }

    /**
     * 根据任务id查询任务详情以及处理结果以及审核历史
     * @param taskId
     * @return
     */
    public TaskDetailsVO queryAuditHistory(Integer taskId) throws IOException {
        //新建返回VO类
        TaskDetailsVO taskDetailsVO = new TaskDetailsVO();
        //根据taskId查询此条任务详情
        LambdaQueryWrapper<ProjectTask> currentTaskWrapper = new LambdaQueryWrapper<>();
        currentTaskWrapper.eq(ProjectTask::getId, taskId);
        List<ProjectTask> currentTasks = this.list(currentTaskWrapper);
        ProjectTask currentTask = new ProjectTask();
        if (currentTasks != null && currentTasks.size() != 0) {
            currentTask = currentTasks.get(0);
        }
        //根据此条任务详情获取assoTaskId
        Integer assoTaskId = currentTask.getAssoTaskId();
        List<ProjectTask> allProjectTasks = new ArrayList<>();
        if (assoTaskId != null) {
            //根据assoTaskId获取最初任务的详情
            LambdaQueryWrapper<ProjectTask> assoTaskWrapper = new LambdaQueryWrapper<>();
            assoTaskWrapper.eq(ProjectTask::getId, assoTaskId);
            ProjectTask assoTask = this.list(assoTaskWrapper).get(0);
            //装载最初任务详情
            ProjectTaskVO projectTaskVO = new ProjectTaskVO();
            BeanUtils.copyProperties(assoTask, projectTaskVO);
            taskDetailsVO.setProjectTaskVO(projectTaskVO);
            //根据assoTaskId查询所有任务的id
            LambdaQueryWrapper<ProjectTask> allTaskWrapper = new LambdaQueryWrapper<>();
            allTaskWrapper.eq(ProjectTask::getAssoTaskId, assoTaskId);
            allProjectTasks = this.list(allTaskWrapper);
        }
        //新建审核历史返回VO以及集合
        List<AuditHistoryVO> auditHistoryVOS = new ArrayList<>();
        if (allProjectTasks != null) {
           for (ProjectTask item : allProjectTasks) {
               if (item != null) {
                   AuditHistoryVO auditHistoryVO = new AuditHistoryVO();
                   //任务详情VO
                   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);
                       }
                   }
                   auditHistoryVOS.add(auditHistoryVO);
               }
            }
            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.size() != 0) {
            resultIds = taskHandleResults.stream().map(TaskHandleResult::getId).collect(Collectors.toList());
        }
        List<HandleResultFileVO> handleResultFileVOS = new ArrayList<>();
        //根据所有的结果ids查询所有fileGuids
        if (resultIds != null) {
            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.size() != 0) {
                fileGuids = assoHandleResultFiles.stream().map(AssoHandleResultFile::getFileGuid).collect(Collectors.toList());
            }
            //调用文件系统查询文件信息接口
            if (fileGuids.size() != 0) {
                String res = fileManagerService.getSystemFileFromFMS(fileGuids);
                systemFiles = JSONObject.parseArray(res, SystemFile.class);
            }
            if (systemFiles.size() != 0) {
                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.setType(systemFile.getType());
                        handleResultFileVO.setOriginalName(systemFile.getOriginalName());
                    }
                    handleResultFileVOS.add(handleResultFileVO);
                }
            }
        }
        taskDetailsVO.setSystemFileList(handleResultFileVOS);
        //装载名称
        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信息");
                }
            }
        }

    }



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

    @Override
    public Object deleteMessage(List<Integer> ids) throws IOException {
        //TODO
        //删除审核结果与文件关联表
        //删除审核结果表
        //删除任务表
        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;
    }
}