任务统计bug

xiangpei

2025-03-26 f9504e80579c35586c2adb0f2e4a384d31aac22f

 business/src/main/java/com/ycl/service/impl/ProjectProcessServiceImpl.java

@@ -18,6 +18,7 @@
import com.ycl.domain.entity.*;
import com.ycl.domain.form.*;
import com.ycl.domain.json.*;
import com.ycl.domain.query.ProcessLogQuery;
import com.ycl.domain.vo.*;
import com.ycl.event.event.TaskLogEvent;
import com.ycl.mapper.ProjectEngineeringMapper;
@@ -28,6 +29,7 @@
import com.baomidou.mybatisplus.extension.service.impl.ServiceImpl;
import com.ycl.domain.query.ProjectProcessQuery;
import com.ycl.service.common.TaskCommonService;
import com.ycl.system.domain.base.AbsQuery;
import com.ycl.system.service.ISysDeptService;
import com.ycl.system.service.ISysDictTypeService;
import com.ycl.system.service.ISysRoleService;
@@ -49,6 +51,7 @@
import org.flowable.task.api.Task;
import org.flowable.task.api.TaskQuery;
import org.flowable.task.api.history.HistoricTaskInstance;
import org.flowable.task.api.history.HistoricTaskInstanceQuery;
import org.springframework.context.ApplicationEventPublisher;
import org.springframework.stereotype.Service;
import lombok.RequiredArgsConstructor;
@@ -302,14 +305,53 @@
        taskStatistics.setTimelyFinishedTaskNum(this.getTimelyTaskNum(projectProcess.getProcessInsId()));
        taskStatistics.setOvertimeTaskNum(this.getOvertimeTaskNum(projectProcess.getProcessInsId()));
        taskStatistics.setWillOvertimeTaskNum(this.getWillOvertimeTaskNum(projectProcess.getProcessInsId()));
//        taskStatistics.setCurrentTask(this.getCurrentNodeTaskList(projectProcess.getProcessInstanceId()));
        taskStatistics.setWaitTaskNum(this.getWaitTaskNum(projectProcess.getProcessInsId()));
        taskStatistics.setJumpTaskNum(this.getJumpTaskNum(projectProcess.getProcessInsId()));
        detail.setStatistics(taskStatistics);

        Result result = Result.ok();

        // 代办任务
        this.getTodoTaskList(projectProcess.getProjectId(), projectProcess.getProcessInsId(), "", 5, 1, result);
//        // 代办任务
//        this.getTodoTaskList(projectProcess.getProjectId(), projectProcess.getProcessInsId(), "", 5, 1, result);
        return result.data(detail);
    }

    /**
     * 容缺任务计数
     * @param processInsId
     * @return
     */
    private Long getWaitTaskNum(String processInsId){
        // 查出容缺过的任务
        List<ProcessLog> allWaitTaskList = new LambdaQueryChainWrapper<>(processLogService.getBaseMapper())
                .eq(ProcessLog::getProcessInsId, processInsId)
                .eq(ProcessLog::getEventType, ProcessLogEventTypeEnum.WAIT)
                .orderByDesc(ProcessLog::getGmtCreate)
                .list();
        // 排除容缺后又完成的任务
        List<ProcessLog> finishedTaskList = new LambdaQueryChainWrapper<>(processLogService.getBaseMapper())
                .eq(ProcessLog::getProcessInsId, processInsId)
                .in(ProcessLog::getEventType, ProcessLogEventTypeEnum.FINISHED, ProcessLogEventTypeEnum.REJECT)
                .list();
        List<String> finishedTaskIds = finishedTaskList.stream().map(ProcessLog::getTaskId).distinct().collect(Collectors.toList());
        // 得到未完成的容缺任务
        List<String> waitTaskIds = allWaitTaskList.stream().filter(log -> !finishedTaskIds.contains(log.getTaskId())).map(ProcessLog::getTaskId).collect(Collectors.toList());
        if (CollectionUtils.isEmpty(waitTaskIds)) {
            return 0L;
        }
        // 容缺的任务都属于历史任务，只是需要补表单数据
        List<HistoricTaskInstance> hisTaskList = historyService.createHistoricTaskInstanceQuery()
                .processInstanceId(processInsId)
                .taskIds(waitTaskIds)
                .includeIdentityLinks()
                .orderByHistoricTaskInstanceStartTime()
                .desc()
                .list();
        hisTaskList = this.distinctHisTask(hisTaskList);
        // 排除运行时任务
        List<String> runTaskKeys = taskService.createTaskQuery().processInstanceId(processInsId).list().stream().map(Task::getTaskDefinitionKey).collect(Collectors.toList());
        hisTaskList = hisTaskList.stream().filter(his -> !runTaskKeys.contains(his.getTaskDefinitionKey())).collect(Collectors.toList());
        return Long.valueOf(hisTaskList.size());
    }

    @Override
@@ -333,6 +375,9 @@
                break;
            case TaskTypeConstant.WAIT:
                this.getWaitTask(query.getProjectId(), query.getProcessDefId(), projectProcess.getProcessInsId(), query.getTaskName(), (int) query.getCurrentPage(), (int) query.getPageSize(), ok);
                break;
            case TaskTypeConstant.JUMP:
                this.getJumpTask(query.getProjectId(), query.getProcessDefId(), projectProcess.getProcessInsId(), query.getTaskName(), (int) query.getCurrentPage(), (int) query.getPageSize(), ok);
                break;
            case TaskTypeConstant.REMAINING:
                this.getRemainingTask(query.getProjectId(), query.getProcessDefId(), projectProcess.getProcessInsId(), query.getTaskName(), (int) query.getCurrentPage(), (int) query.getPageSize(), ok);
@@ -378,7 +423,50 @@
                    .endOr();
        }
        result.total(taskQuery.count());
        List<Task> taskList = taskQuery.listPage(pageSize * (pageNum - 1), pageSize);
        List<Task> allTodoList = taskQuery.list();
        List<TaskOrderVO> orderList = new ArrayList<>();
        allTodoList.stream().forEach(task -> {
            TaskOrderVO order = new TaskOrderVO();
            order.setTaskId(task.getId());
            // 计算办理时间，超时的排前面，没超时的由低到高排序，没超时时间的排最后
            ProcessCoding processCoding = processCodingService.getByTaskId(task.getId(), task.getProcessInstanceId());
            if (Objects.nonNull(processCoding)) {
                if (StringUtils.isNotBlank(processCoding.getRedTime())) {
                    Long overtime = getTime(processCoding.getRedTime());
                    long durationTime = 0l;
                    if (Objects.nonNull(processCoding.getStartTaskTime())) {
                        durationTime = ((new Date()).getTime() - processCoding.getStartTaskTime().getTime()) / 1000;
                    }
                    if (overtime > durationTime) {
                        order.setNum((overtime - durationTime) / 3600);
                    } else {
                        order.setNum(-2000000L);
                    }
                } else {
                    order.setNum(2000000L);
                }
            } else {
                order.setNum(2000000L);
            }
            orderList.add(order);
        });
        // 升序排列
        Collections.sort(orderList, Comparator.comparingLong(TaskOrderVO::getNum));
        int startNum = pageSize * (pageNum - 1);
        int endNum = startNum + pageSize;
        if (startNum >= orderList.size()) {
            result.data(new ArrayList<>()).total(0L);
            return;
        }
        int end = Math.min(endNum, orderList.size());
        List<String> targetTaskIds = orderList.subList(startNum, end).stream().map(TaskOrderVO::getTaskId).collect(Collectors.toList());
        List<Task> taskList = targetTaskIds.stream().map(taskId -> {
            List<Task> list = allTodoList.stream().filter(task -> task.getId().equals(taskId)).collect(Collectors.toList());
            if (CollectionUtils.isEmpty(list)) {
                return null;
            }
            return list.get(0);
        }).filter(Objects::nonNull).collect(Collectors.toList());
        List<IndexCustomerTaskVO> vos = new ArrayList<>();
        for (Task task : taskList) {
            IndexCustomerTaskVO taskVO = new IndexCustomerTaskVO();
@@ -923,6 +1011,37 @@
        return Result.ok("操作成功");
    }

    @Override
    public Result getProcessMsg(AbsQuery q) {
        // 查自己的日志
        ProcessLogQuery query = new ProcessLogQuery();
        if (! SecurityUtils.isAdmin(SecurityUtils.getUserId())) {
            query.setUserId(SecurityUtils.getUserId());
        }
        query.setEventTypeList(Arrays.asList(ProcessLogEventTypeEnum.DELEGATE.getValue(),
                ProcessLogEventTypeEnum.REJECT.getValue(),
                ProcessLogEventTypeEnum.JUMP.getValue(),
                ProcessLogEventTypeEnum.FINISHED.getValue(),
                ProcessLogEventTypeEnum.WAIT.getValue()));
        query.setCurrentPage(q.getCurrentPage());
        query.setPageSize(q.getPageSize());
        Result result = processLogService.projectProcessLogPage(query);
        List<ProcessLogVO> logs = (List<ProcessLogVO>) result.get("data");

        logs.stream().forEach(log -> {
            if (ProcessLogEventTypeEnum.FINISHED.equals(log.getEventType())) {
                log.setContent("您完成了任务：" + log.getTaskName());
            } else if (ProcessLogEventTypeEnum.REJECT.equals(log.getEventType())) {
                log.setContent("您驳回了任务：" + log.getTaskName());
            } else if (ProcessLogEventTypeEnum.WAIT.equals(log.getEventType())) {
                log.setContent("您容缺了任务：" + log.getTaskName());
            } else if (ProcessLogEventTypeEnum.JUMP.equals(log.getEventType())) {
                log.setContent("您跳过了任务：" + log.getTaskName());
            }
        });
        return Result.ok().data(logs).total((Long) result.get("total"));
    }

    /**
     * 查询待办任务
     *
@@ -1169,11 +1288,13 @@
                vo.setExecutionId(hisTaskList.get(0).getExecutionId());
                vo.setCreateTime(hisTaskList.get(0).getStartTime());
                // 查询实际处理人
                long handlerUserId = Long.parseLong(hisTaskList.get(0).getAssignee());
                SysUser handlerUser = sysUserService.selectUserById(handlerUserId);
                if (Objects.nonNull(handlerUser)) {
                    vo.setActualHandlerUserId(hisTaskList.get(0).getAssignee());
                    vo.setActualHandlerUserName(handlerUser.getNickName());
                if (StringUtils.isNotBlank(hisTaskList.get(0).getAssignee())) {
                    long handlerUserId = Long.parseLong(hisTaskList.get(0).getAssignee());
                    SysUser handlerUser = sysUserService.selectUserById(handlerUserId);
                    if (Objects.nonNull(handlerUser)) {
                        vo.setActualHandlerUserId(hisTaskList.get(0).getAssignee());
                        vo.setActualHandlerUserName(handlerUser.getNickName());
                    }
                }
                vo.setTaskDefinitionKey(hisTaskList.get(0).getTaskDefinitionKey());
                this.setHandler(vo, hisTaskList.get(0).getIdentityLinks());
@@ -1270,13 +1391,7 @@
                            taskVO.getHandlerUnitId().add(dept.getDeptId());
                            taskVO.getHandlerUnitName().add(dept.getDeptName());
                            taskVO.getPromoterName().add(this.getDeptLeaderShowName(dept));
                            String[] str = dept.getAncestors().split(",");
                            if (str.length >= 4){
                                taskVO.getPromoterUnitName().add(dept.getParentName() +"-"+dept.getDeptName());
                            }else {
                                taskVO.getPromoterUnitName().add(dept.getDeptName());
                            }

                            taskVO.getPromoterUnitName().add(this.setDeptNameWithParentName(dept));
                        }
                    }
                } else {
@@ -1300,15 +1415,25 @@
     */
    private Long getTimelyTaskNum(String processInsId) {
        // 查出已完成的任务key
        List<HistoricTaskInstance> hisTaskList = historyService.createHistoricTaskInstanceQuery()
        HistoricTaskInstanceQuery query = historyService.createHistoricTaskInstanceQuery()
                .processInstanceId(processInsId)
                .finished()
                .list();
        hisTaskList = this.distinctHisTask(hisTaskList);
                .includeIdentityLinks()
                .orderByTaskCreateTime()
                .desc();
        List<HistoricTaskInstance> hisTaskList = query.list();
        if (CollectionUtils.isEmpty(hisTaskList)) {
            return 0L;
        }

        hisTaskList = this.distinctHisTask(hisTaskList);
        // 排除跳过、容缺的任务，因为这两个操作都会完成任务而产生历史任务
        List<String> jumpAndWaitTaskKeys = new LambdaQueryChainWrapper<>(processLogService.getBaseMapper())
                .eq(ProcessLog::getProcessInsId, processInsId)
                .in(ProcessLog::getEventType, ProcessLogEventTypeEnum.JUMP, ProcessLogEventTypeEnum.WAIT) // TODO 如果运行时任务正好是被驳回的，需要想办法排除调被驳回的任务，不能直接在这加 ProcessLogEventTypeEnum.REJECT
                .list().stream().map(ProcessLog::getTaskDefKey).collect(Collectors.toList());
        List<String> runtimeTaskKey = taskService.createTaskQuery().processInstanceId(processInsId).list().stream().map(Task::getTaskDefinitionKey).collect(Collectors.toList());
        jumpAndWaitTaskKeys.addAll(runtimeTaskKey);
        hisTaskList = hisTaskList.stream().filter(hisTask -> jumpAndWaitTaskKeys.indexOf(hisTask.getTaskDefinitionKey()) == -1).collect(Collectors.toList());
        List<String> hisTaskKeys = hisTaskList.stream().map(HistoricTaskInstance::getTaskDefinitionKey).distinct().collect(Collectors.toList());
        Map<String, HistoricTaskInstance> hisTaskMap = hisTaskList.stream().collect(Collectors.toMap(HistoricTaskInstance::getTaskDefinitionKey, his -> his));
        // 查出时间正常的任务key
@@ -1351,21 +1476,32 @@
        int endNum = startNum + pageSize;

        // 查出已完成的任务key
        List<HistoricTaskInstance> hisTaskList = historyService.createHistoricTaskInstanceQuery()
        HistoricTaskInstanceQuery query = historyService.createHistoricTaskInstanceQuery()
                .processInstanceId(processInsId)
                .finished()
                .taskNameLike(taskName)
                .includeIdentityLinks()
                .orderByTaskCreateTime()
                .desc()
                .list();
                .desc();
        if (StringUtils.isNotBlank(taskName)) {
            query.taskNameLike(taskName);
        }
        List<HistoricTaskInstance> hisTaskList = query.list();
        if (CollectionUtils.isEmpty(hisTaskList)) {
            result.total(0);
            return new ArrayList<>();
        }

        hisTaskList = this.distinctHisTask(hisTaskList);
        // 排除跳过、容缺的任务，因为这两个操作都会完成任务而产生历史任务
        List<String> jumpAndWaitTaskKeys = new LambdaQueryChainWrapper<>(processLogService.getBaseMapper())
                .eq(ProcessLog::getProcessInsId, processInsId)
                .eq(ProcessLog::getProjectId, projectId)
                .in(ProcessLog::getEventType, ProcessLogEventTypeEnum.JUMP, ProcessLogEventTypeEnum.WAIT)
                .list().stream().map(ProcessLog::getTaskDefKey).collect(Collectors.toList());
        List<String> runtimeTaskKey = taskService.createTaskQuery().processInstanceId(processInsId).list().stream().map(Task::getTaskDefinitionKey).collect(Collectors.toList());
        jumpAndWaitTaskKeys.addAll(runtimeTaskKey);
        hisTaskList = hisTaskList.stream().filter(hisTask -> jumpAndWaitTaskKeys.indexOf(hisTask.getTaskDefinitionKey()) == -1).collect(Collectors.toList());
        List<String> hisTaskKeys = hisTaskList.stream().map(HistoricTaskInstance::getTaskDefinitionKey).distinct().collect(Collectors.toList());
        Map<String, HistoricTaskInstance> hisTaskMap = this.distinctHisTask(hisTaskList).stream().collect(Collectors.toMap(HistoricTaskInstance::getTaskDefinitionKey, his -> his));
        Map<String, HistoricTaskInstance> hisTaskMap = hisTaskList.stream().collect(Collectors.toMap(HistoricTaskInstance::getTaskDefinitionKey, his -> his));
        // 查出时间正常的任务key
        List<ProcessCoding> codeList = new LambdaQueryChainWrapper<>(processCodingService.getBaseMapper())
                .eq(ProcessCoding::getProcessInsId, processInsId)
@@ -1448,14 +1584,16 @@
                vo.setCreateTime(hisTask.getStartTime());

                // 查询实际处理人
                long handlerUserId = Long.parseLong(hisTask.getAssignee());
                SysUser handlerUser = sysUserService.selectUserById(handlerUserId);
                if (Objects.nonNull(handlerUser)) {
                    vo.getHandlerId().add(handlerUserId);
                    vo.getHandlerName().add(this.getUserShowName(handlerUser));
                    if (Objects.nonNull(handlerUser.getDept())) {
                        vo.getHandlerUnitId().add(handlerUser.getDept().getDeptId());
                        vo.getHandlerUnitName().add(handlerUser.getDept().getDeptName());
                if (StringUtils.isNotBlank(hisTask.getAssignee())) {
                    long handlerUserId = Long.parseLong(hisTask.getAssignee());
                    SysUser handlerUser = sysUserService.selectUserById(handlerUserId);
                    if (Objects.nonNull(handlerUser)) {
                        vo.getHandlerId().add(handlerUserId);
                        vo.getHandlerName().add(this.getUserShowName(handlerUser));
                        if (Objects.nonNull(handlerUser.getDept())) {
                            vo.getHandlerUnitId().add(handlerUser.getDept().getDeptId());
                            vo.getHandlerUnitName().add(handlerUser.getDept().getDeptName());
                        }
                    }
                }
                vo.setTaskDefinitionKey(hisTask.getTaskDefinitionKey());
@@ -1662,6 +1800,8 @@
        return Long.valueOf(tList.size());
    }



    /**
     * 查询即将超时的任务
     *
@@ -1737,6 +1877,351 @@
        return vos;
    }

    @Override
    public void getIndexWaitTask(String s, int pageSize, int pageNum, Result result) {
        // 查出容缺过的任务
        List<ProcessLog> allWaitTaskList = new LambdaQueryChainWrapper<>(processLogService.getBaseMapper())
                .eq(ProcessLog::getEventType, ProcessLogEventTypeEnum.WAIT)
                .orderByDesc(ProcessLog::getGmtCreate)
                .list();
        // 排除容缺后又完成的任务
        List<ProcessLog> finishedTaskList = new LambdaQueryChainWrapper<>(processLogService.getBaseMapper())
                .eq(ProcessLog::getEventType, ProcessLogEventTypeEnum.FINISHED)
                .list();
        List<String> finishedTaskIds = finishedTaskList.stream().map(ProcessLog::getTaskId).distinct().collect(Collectors.toList());
        // 得到未完成的容缺任务
        List<String> waitTaskIds = allWaitTaskList.stream().filter(log -> !finishedTaskIds.contains(log.getTaskId())).map(ProcessLog::getTaskId).collect(Collectors.toList());
        if (CollectionUtils.isEmpty(waitTaskIds)) {
            result.total(0l);
            result.data(new ArrayList<>());
            return;
        }
        List<HistoricTaskInstance> hisTasks = waitTaskIds.stream().map(waitTaskId -> {
            List<ProcessLog> logs = allWaitTaskList.stream().filter(item -> item.getTaskId().equals(waitTaskId)).collect(Collectors.toList());
            HistoricTaskInstance hisTask = null;
            if (org.apache.commons.collections4.CollectionUtils.isNotEmpty(logs)) {
                // 容缺的任务都属于历史任务，只是需要补表单数据
                HistoricTaskInstanceQuery query = historyService.createHistoricTaskInstanceQuery()
                        .processInstanceId(logs.get(0).getProcessInsId())
                        .taskId(waitTaskId)
                        .includeIdentityLinks()
                        .orderByHistoricTaskInstanceStartTime()
                        .desc();
                if (!SecurityUtils.getLoginUser().getUser().isAdmin()) {
                    query
                            .or()
                            .taskCandidateGroupIn(taskCommonService.getCurrentUserGroups())
                            .taskCandidateUser(SecurityUtils.getUserId() + "")
                            .taskAssignee(SecurityUtils.getUserId() + "")
                            .endOr();
                }
                List<HistoricTaskInstance> hisTaskList = query.list();
                hisTaskList = this.distinctHisTask(hisTaskList);
                if (org.apache.commons.collections4.CollectionUtils.isNotEmpty(hisTaskList)) {
                    hisTask = hisTaskList.get(0);
                }
            }
            return hisTask;
        }).filter(Objects::nonNull).collect(Collectors.toList());

        if (CollectionUtils.isEmpty(hisTasks)) {
            result.total(0l);
            result.data(new ArrayList<>());
            return;
        }
        int startNum = pageSize * (pageNum - 1);
        int endNum = startNum + pageSize;
        if (startNum >= hisTasks.size()) {
            result.total(0l);
            // 如果起始索引超出了列表的大小，返回一个空列表
            result.data(new ArrayList<>());
            return;
        }
        result.total(hisTasks.size());
        int end = Math.min(endNum, hisTasks.size());
        List<HistoricTaskInstance> targetTask = hisTasks.subList(startNum, end);

        // 转换成VO
        List<IndexCustomerTaskVO> vos = targetTask.stream().map(userTask -> {
            IndexCustomerTaskVO vo = new IndexCustomerTaskVO();
            vo.setProcessInsId(userTask.getProcessInstanceId());
            vo.setProcessDefId(userTask.getProcessDefinitionId());

            // 查出流程
            ProcessInstance process = runtimeService.createProcessInstanceQuery().processInstanceId(userTask.getProcessInstanceId()).singleResult();
            String deployId = "";
            String processName = "";
            if (Objects.nonNull(process)) {
                deployId = process.getDeploymentId();
                processName = process.getProcessDefinitionName();
            } else {
                HistoricProcessInstance hisProcess = historyService.createHistoricProcessInstanceQuery().processInstanceId(userTask.getProcessInstanceId()).singleResult();
                deployId = hisProcess.getDeploymentId();
                processName = hisProcess.getProcessDefinitionName();
            }

            String finalDeployId = deployId;
            String finalProcessName = processName;

            vo.setDeployId(finalDeployId);
            vo.setTaskName(userTask.getName());
            vo.setProcessName(finalProcessName);

            // 一个任务可能有多个候选人/组，所以需要使用list
            List<Long> handlerIds = new ArrayList<>(2);
            List<String> handlerNames = new ArrayList<>(2);
            List<Long> handlerUnitIds = new ArrayList<>(2);
            List<String> handlerUnitNames = new ArrayList<>(2);
            List<String> promoterNames = new ArrayList<>(2);
            List<String> promoterUnitNames = new ArrayList<>(2);
            vo.setHandlerId(handlerIds);
            vo.setHandlerName(handlerNames);
            vo.setHandlerUnitId(handlerUnitIds);
            vo.setHandlerUnitName(handlerUnitNames);
            vo.setPromoterName(promoterNames);
            vo.setPromoterUnitName(promoterUnitNames);

            ProjectProcess projectProcess = new LambdaQueryChainWrapper<>(baseMapper)
                    .eq(ProjectProcess::getProcessInsId, userTask.getProcessInstanceId())
                    .one();
            if (Objects.isNull(projectProcess)) {
                throw new RuntimeException("项目流程未启动");
            }
            String projectId = "";
            String projectName = "";
            if (Objects.nonNull(projectProcess)) {
                if (projectProcess.getProjectType().equals(ProjectProcessTypeEnum.PROJECT)) {
                    ProjectInfo project = projectInfoMapper.selectById(projectProcess.getProjectId());
                    if (Objects.nonNull(project)) {
                        projectId = projectProcess.getProjectId();
                        projectName = project.getProjectName();
                    }
                } else if (projectProcess.getProjectType().equals(ProjectProcessTypeEnum.ENGINEERING)) {
                    ProjectEngineering engineering = projectEngineeringMapper.selectById(projectProcess.getProjectId());
                    if (Objects.nonNull(engineering)) {
                        projectId = projectProcess.getProjectId();
                        projectName = engineering.getProjectName();
                    }
                }
            }
            vo.setProjectId(projectId);
            vo.setProjectName(projectName);
            List<UserTask> uTaskList = this.getAllUserTaskElement(userTask.getProcessDefinitionId()).stream().filter(item -> item.getId().equals(userTask.getTaskDefinitionKey())).collect(Collectors.toList());
            if (CollectionUtils.isEmpty(uTaskList)) {
                throw new RuntimeException("未找到流程任务设计");
            }
            this.setCandidateInfo(uTaskList.get(0), vo, projectProcess.getProjectId(), userTask.getProcessInstanceId());

            vo.setTaskStatus(TaskStatusEnum.WAIT);
            // 如果是已完成的，信息需要单独赋值
            vo.setTaskId(userTask.getId());
            vo.setExecutionId(userTask.getExecutionId());
            vo.setCreateTime(userTask.getStartTime());

            vo.setTaskDefinitionKey(userTask.getTaskDefinitionKey());

            this.distinctVo(vo);
            return vo;
        }).collect(Collectors.toList());
        result.data(vos);
    }

    /**
     * 获取跳过任务
     *
     * @param processInsId
     * @return
     */
    private Long getJumpTaskNum(String processInsId) {
        // 查出跳过的任务
        List<ProcessLog> allJumpTaskList = new LambdaQueryChainWrapper<>(processLogService.getBaseMapper())
                .eq(ProcessLog::getProcessInsId, processInsId)
                .eq(ProcessLog::getEventType, ProcessLogEventTypeEnum.JUMP)
                .orderByDesc(ProcessLog::getGmtCreate)
                .list();
        // 排除驳回的
        List<String> rejectTaskIds = new LambdaQueryChainWrapper<>(processLogService.getBaseMapper())
                .select(ProcessLog::getTaskId)
                .eq(ProcessLog::getProcessInsId, processInsId)
                .eq(ProcessLog::getEventType, ProcessLogEventTypeEnum.REJECT)
                .orderByDesc(ProcessLog::getGmtCreate)
                .list().stream().map(ProcessLog::getTaskId).collect(Collectors.toList());

        List<String> jumpTaskIds = allJumpTaskList.stream().map(ProcessLog::getTaskId).collect(Collectors.toList());
        jumpTaskIds.removeAll(rejectTaskIds);
        if(CollectionUtils.isEmpty(rejectTaskIds)) {
            return 0L;
        }
        List<HistoricTaskInstance> hisTaskList = historyService.createHistoricTaskInstanceQuery()
                .processInstanceId(processInsId)
                .finished()
                .taskIds(jumpTaskIds)
                .includeIdentityLinks()
                .orderByHistoricTaskInstanceStartTime()
                .desc()
                .list();
        hisTaskList = this.distinctHisTask(hisTaskList);
        // 排除运行时任务
        List<String> runTaskKeys = taskService.createTaskQuery().processInstanceId(processInsId).list().stream().map(Task::getTaskDefinitionKey).collect(Collectors.toList());
        hisTaskList = hisTaskList.stream().filter(his -> !runTaskKeys.contains(his.getTaskDefinitionKey())).collect(Collectors.toList());
        return Long.valueOf(hisTaskList.size());
    }

    /**
     * 获取跳过任务
     *
     * @param projectId
     * @param processDefinitionId
     * @param processInsId
     * @param taskName
     * @param pageNum
     * @param pageSize
     * @param result
     * @return
     */
    private List<CustomerTaskVO> getJumpTask(String projectId,
                                             String processDefinitionId,
                                             String processInsId,
                                             String taskName,
                                             Integer pageNum,
                                             Integer pageSize,
                                             Result result) {
        // 查出跳过的任务
        List<ProcessLog> allJumpTaskList = new LambdaQueryChainWrapper<>(processLogService.getBaseMapper())
                .eq(ProcessLog::getProcessInsId, processInsId)
                .eq(ProcessLog::getEventType, ProcessLogEventTypeEnum.JUMP)
                .like(StringUtils.isNotBlank(taskName), ProcessLog::getTaskName, taskName)
                .orderByDesc(ProcessLog::getGmtCreate)
                .list();
        // 排除驳回的
        List<String> rejectTaskIds = new LambdaQueryChainWrapper<>(processLogService.getBaseMapper())
                .select(ProcessLog::getTaskId)
                .eq(ProcessLog::getProcessInsId, processInsId)
                .eq(ProcessLog::getEventType, ProcessLogEventTypeEnum.REJECT)
                .like(StringUtils.isNotBlank(taskName), ProcessLog::getTaskName, taskName)
                .orderByDesc(ProcessLog::getGmtCreate)
                .list().stream().map(ProcessLog::getTaskId).collect(Collectors.toList());

        List<String> jumpTaskIds = allJumpTaskList.stream().map(ProcessLog::getTaskId).collect(Collectors.toList());
        jumpTaskIds.removeAll(rejectTaskIds);
        if(CollectionUtils.isEmpty(rejectTaskIds)) {
            result.total(0l);
            return new ArrayList<>();
        }
        List<HistoricTaskInstance> hisTaskList = historyService.createHistoricTaskInstanceQuery()
                .processInstanceId(processInsId)
                .finished()
                .taskIds(jumpTaskIds)
                .includeIdentityLinks()
                .orderByHistoricTaskInstanceStartTime()
                .desc()
                .list();
        hisTaskList = this.distinctHisTask(hisTaskList);
        // 排除运行时任务
        List<String> runTaskKeys = taskService.createTaskQuery().processInstanceId(processInsId).list().stream().map(Task::getTaskDefinitionKey).collect(Collectors.toList());
        hisTaskList = hisTaskList.stream().filter(his -> !runTaskKeys.contains(his.getTaskDefinitionKey())).collect(Collectors.toList());
        if (CollectionUtils.isEmpty(hisTaskList)) {
            result.total(0l);
            return new ArrayList<>();
        }
        int startNum = pageSize * (pageNum - 1);
        int endNum = startNum + pageSize;
        if (startNum >= hisTaskList.size()) {
            result.total(0l);
            // 如果起始索引超出了列表的大小，返回一个空列表
            return new ArrayList<>();
        }
        result.total(hisTaskList.size());
        int end = Math.min(endNum, hisTaskList.size());
        List<HistoricTaskInstance> targetTaskList = hisTaskList.subList(startNum, end);

        // 转换成VO
        // 得到目标任务对应的定义
        List<String> taskDefs = targetTaskList.stream().map(HistoricTaskInstance::getTaskDefinitionKey).collect(Collectors.toList());
        Map<String, HistoricTaskInstance> keyMap = targetTaskList.stream().collect(Collectors.toMap(HistoricTaskInstance::getTaskDefinitionKey, his -> his));
        List<UserTask> finishedUserTaskElement = this.getAllUserTaskElement(processDefinitionId).stream().filter(el -> taskDefs.contains(el.getId())).collect(Collectors.toList());

        // 查出流程
        ProcessInstance process = runtimeService.createProcessInstanceQuery().processInstanceId(processInsId).singleResult();
        String deployId = "";
        String processName = "";
        if (Objects.nonNull(process)) {
            deployId = process.getDeploymentId();
            processName = process.getProcessDefinitionName();
        } else {
            HistoricProcessInstance hisProcess = historyService.createHistoricProcessInstanceQuery().processInstanceId(processInsId).singleResult();
            deployId = hisProcess.getDeploymentId();
            processName = hisProcess.getProcessDefinitionName();
        }

        String finalDeployId = deployId;
        String finalProcessName = processName;
        List<CustomerTaskVO> vos = finishedUserTaskElement.stream().map(userTask -> {
            CustomerTaskVO vo = new CustomerTaskVO();
            vo.setProcessInsId(processInsId);
            vo.setProcessDefId(processDefinitionId);
            vo.setDeployId(finalDeployId);
            vo.setTaskName(userTask.getName());
            vo.setProcessName(finalProcessName);

            // 一个任务可能有多个候选人/组，所以需要使用list
            List<Long> handlerIds = new ArrayList<>(2);
            List<String> handlerNames = new ArrayList<>(2);
            List<Long> handlerUnitIds = new ArrayList<>(2);
            List<String> handlerUnitNames = new ArrayList<>(2);
            List<String> promoterNames = new ArrayList<>(2);
            List<String> promoterUnitNames = new ArrayList<>(2);
            vo.setHandlerId(handlerIds);
            vo.setHandlerName(handlerNames);
            vo.setHandlerUnitId(handlerUnitIds);
            vo.setHandlerUnitName(handlerUnitNames);
            vo.setPromoterName(promoterNames);
            vo.setPromoterUnitName(promoterUnitNames);

            this.setCandidateInfo(userTask, vo, projectId, processInsId);
            HistoricTaskInstance hisTask = keyMap.get(userTask.getId());
            if (Objects.nonNull(hisTask)) {
                vo.setTaskStatus(TaskStatusEnum.JUMP);
                // 如果是已完成的，信息需要单独赋值
                vo.setTaskId(hisTask.getId());
                vo.setExecutionId(hisTask.getExecutionId());
                vo.setCreateTime(hisTask.getStartTime());

                // 查询实际处理人
                if (StringUtils.isNotBlank(hisTask.getAssignee())) {
                    long handlerUserId = Long.parseLong(hisTask.getAssignee());
                    SysUser handlerUser = sysUserService.selectUserById(handlerUserId);
                    if (Objects.nonNull(handlerUser)) {
                        vo.getHandlerId().add(handlerUserId);
                        vo.getHandlerName().add(this.getUserShowName(handlerUser));
                        if (Objects.nonNull(handlerUser.getDept())) {
                            vo.getHandlerUnitId().add(handlerUser.getDept().getDeptId());
                            vo.getHandlerUnitName().add(handlerUser.getDept().getDeptName());
                        }
                    }
                }
                this.setHandler(vo, hisTask.getIdentityLinks());
                vo.setTaskDefinitionKey(hisTask.getTaskDefinitionKey());
            }
            this.distinctVo(vo);
            return vo;
        }).collect(Collectors.toList());
        result.data(vos);
        return vos;
    }

    /**
     * 容缺任务分页
     *
     * @param projectId
     * @param processDefinitionId
     * @param processInsId
     * @param taskName
     * @param pageNum
     * @param pageSize
     * @param result
     * @return
     */
    private List<CustomerTaskVO> getWaitTask(String projectId,
                                             String processDefinitionId,
                                             String processInsId,
@@ -1744,6 +2229,7 @@
                                             Integer pageNum,
                                             Integer pageSize,
                                             Result result) {

        // 查出容缺过的任务
        List<ProcessLog> allWaitTaskList = new LambdaQueryChainWrapper<>(processLogService.getBaseMapper())
                .eq(ProcessLog::getProcessInsId, processInsId)
@@ -1754,7 +2240,7 @@
        // 排除容缺后又完成的任务
        List<ProcessLog> finishedTaskList = new LambdaQueryChainWrapper<>(processLogService.getBaseMapper())
                .eq(ProcessLog::getProcessInsId, processInsId)
                .eq(ProcessLog::getEventType, ProcessLogEventTypeEnum.FINISHED)
                .in(ProcessLog::getEventType, ProcessLogEventTypeEnum.FINISHED, ProcessLogEventTypeEnum.REJECT)
                .list();
        List<String> finishedTaskIds = finishedTaskList.stream().map(ProcessLog::getTaskId).distinct().collect(Collectors.toList());
        // 得到未完成的容缺任务
@@ -1772,7 +2258,9 @@
                .desc()
                .list();
        hisTaskList = this.distinctHisTask(hisTaskList);

        // 排除运行时任务
        List<String> runTaskKeys = taskService.createTaskQuery().processInstanceId(processInsId).list().stream().map(Task::getTaskDefinitionKey).collect(Collectors.toList());
        hisTaskList = hisTaskList.stream().filter(his -> !runTaskKeys.contains(his.getTaskDefinitionKey())).collect(Collectors.toList());
        if (CollectionUtils.isEmpty(hisTaskList)) {
            result.total(0l);
            return new ArrayList<>();
@@ -1840,12 +2328,14 @@
                vo.setCreateTime(hisTask.getStartTime());

                // 查询实际处理人
                long handlerUserId = Long.parseLong(hisTask.getAssignee());
                SysUser handlerUser = sysUserService.selectUserById(handlerUserId);
                if (Objects.nonNull(handlerUser)) {
                    vo.getHandlerId().add(handlerUserId);
                    if (Objects.nonNull(handlerUser.getDept())) {
                        vo.getHandlerUnitId().add(handlerUser.getDept().getDeptId());
                if (StringUtils.isNotBlank(hisTask.getAssignee())) {
                    long handlerUserId = Long.parseLong(hisTask.getAssignee());
                    SysUser handlerUser = sysUserService.selectUserById(handlerUserId);
                    if (Objects.nonNull(handlerUser)) {
                        vo.getHandlerId().add(handlerUserId);
                        if (Objects.nonNull(handlerUser.getDept())) {
                            vo.getHandlerUnitId().add(handlerUser.getDept().getDeptId());
                        }
                    }
                }
                this.setHandler(vo, hisTask.getIdentityLinks());
@@ -1892,8 +2382,14 @@

        // 排除进行中的任务和已完成的任务
        List<String> runTaskKeyList = taskService.createTaskQuery().processInstanceId(processInsId).list().stream().map(Task::getTaskDefinitionKey).collect(Collectors.toList());
        List<String> finishedTaskKeyList = historyService.createHistoricTaskInstanceQuery().processInstanceId(processInsId).finished().list().stream().map(HistoricTaskInstance::getTaskDefinitionKey).distinct().collect(Collectors.toList());
        allUserTaskElement = allUserTaskElement.stream().filter(el -> !runTaskKeyList.contains(el.getId()) && !finishedTaskKeyList.contains(el.getId())).collect(Collectors.toList());
        List<String> finishedTaskKeyList = new LambdaQueryChainWrapper<>(processLogService.getBaseMapper())
                .select(ProcessLog::getTaskDefKey)
                .eq(ProcessLog::getProcessInsId, processInsId)
                .in(ProcessLog::getEventType, ProcessLogEventTypeEnum.FINISHED, ProcessLogEventTypeEnum.JUMP, ProcessLogEventTypeEnum.WAIT)
                .list().stream().map(ProcessLog::getTaskDefKey).collect(Collectors.toList());
        finishedTaskKeyList.addAll(runTaskKeyList);
//        List<String> finishedTaskKeyList = historyService.createHistoricTaskInstanceQuery().processInstanceId(processInsId).finished().list().stream().map(HistoricTaskInstance::getTaskDefinitionKey).distinct().collect(Collectors.toList());
        allUserTaskElement = allUserTaskElement.stream().filter(el -> finishedTaskKeyList.indexOf(el.getId()) == -1).collect(Collectors.toList());
        // 模拟模糊查询
        if (StringUtils.isNotBlank(taskName)) {
            allUserTaskElement = allUserTaskElement.stream().filter(taskEl -> taskEl.getName().contains(taskName)).collect(Collectors.toList());
@@ -2050,14 +2546,18 @@
            // 运行时未找到流程，说明流程已经结束了
            return 0L;
        }
        // 查出已完成的任务，用总任务数-已完成的就得到剩余事项
        List<HistoricTaskInstance> list = historyService.createHistoricTaskInstanceQuery()
                .processInstanceId(process.getProcessInstanceId())
                .finished()
                .list();
        long num = list.stream().map(HistoricTaskInstance::getTaskDefinitionKey).distinct().count();
        List<UserTask> allUserTaskElement = this.getAllUserTaskElement(processDefinitionId);

        return totalNum - num;
        // 排除进行中的任务和已完成的任务
        List<String> runTaskKeyList = taskService.createTaskQuery().processInstanceId(processInsId).list().stream().map(Task::getTaskDefinitionKey).collect(Collectors.toList());
        List<String> finishedTaskKeyList = new LambdaQueryChainWrapper<>(processLogService.getBaseMapper())
                .select(ProcessLog::getTaskDefKey)
                .eq(ProcessLog::getProcessInsId, processInsId)
                .in(ProcessLog::getEventType, ProcessLogEventTypeEnum.FINISHED, ProcessLogEventTypeEnum.JUMP, ProcessLogEventTypeEnum.WAIT)
                .list().stream().map(ProcessLog::getTaskDefKey).collect(Collectors.toList());
        finishedTaskKeyList.addAll(runTaskKeyList);
        allUserTaskElement = allUserTaskElement.stream().filter(el -> finishedTaskKeyList.indexOf(el.getId()) == -1).collect(Collectors.toList());
        return Long.valueOf(allUserTaskElement.size());
    }

    /**
@@ -2070,6 +2570,7 @@
     */
    private void setCandidateInfo(UserTask userTask, CustomerTaskVO vo, String projectId, String processInsId) {
        if (StringUtils.isNotBlank(userTask.getAssignee())) {
            vo.setHandlerType(HandlerTypeEnum.USER);
            SysUser sysUser = sysUserService.selectUserById(Long.parseLong(userTask.getAssignee()));
            if (Objects.nonNull(sysUser)) {
                if (Objects.nonNull(sysUser.getDept())) {
@@ -2092,7 +2593,7 @@
                        // 部门
                        SysDept dept = sysDeptService.selectDeptById(Long.parseLong(split[1]));
                        if (Objects.nonNull(dept)) {
                            vo.getPromoterUnitName().add(dept.getDeptName());
                            vo.getPromoterUnitName().add(this.setDeptNameWithParentName(dept));
                            vo.getPromoterName().add(this.getDeptLeaderShowName(dept));
                        }
                    }
@@ -2108,6 +2609,19 @@
    }

    /**
     * 设置部门名称时带上上级部门名称
     * @param dept
     */
    private String setDeptNameWithParentName(SysDept dept) {
        String[] str = dept.getAncestors().split(",");
        if (str.length >= 4){
            return dept.getParentName() + "  /  " + dept.getDeptName();
        }else {
            return dept.getDeptName();
        }
    }

    /**
     * 设置任务的发起人&处理人   只有待办任务和已完成任务才会掉这个方法
     *
     * @param taskVO