射洪市项目管理系统
blame | 历史 | 补丁 | 提交 | 提交对比 | ignore whitespace
xiangpei
2025-03-26 cde5e6335dd02db4d2137ba6d5f330544e764b3d 
 business/src/main/java/com/ycl/service/impl/ProjectProcessServiceImpl.java


@@ -51,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;


@@ -304,14 +305,14 @@


        taskStatistics.setTimelyFinishedTaskNum(this.getTimelyTaskNum(projectProcess.getProcessInsId()));


        taskStatistics.setOvertimeTaskNum(this.getOvertimeTaskNum(projectProcess.getProcessInsId()));


        taskStatistics.setWillOvertimeTaskNum(this.getWillOvertimeTaskNum(projectProcess.getProcessInsId()));


        taskStatistics.setToleranceNum(this.getToleranceTask(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);


    }




@@ -320,7 +321,7 @@


     * @param processInsId


     * @return


     */


    private Long getToleranceTask(String processInsId){


    private Long getWaitTaskNum(String processInsId){


        // 查出容缺过的任务


        List<ProcessLog> allWaitTaskList = new LambdaQueryChainWrapper<>(processLogService.getBaseMapper())


                .eq(ProcessLog::getProcessInsId, processInsId)


@@ -330,7 +331,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());


        // 得到未完成的容缺任务


@@ -338,7 +339,19 @@


        if (CollectionUtils.isEmpty(waitTaskIds)) {


            return 0L;


        }


        return Long.valueOf(waitTaskIds.size());


        // 容缺的任务都属于历史任务，只是需要补表单数据


        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


@@ -362,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);


@@ -1399,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


@@ -1450,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)


@@ -1840,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(jumpTaskIds)) {


            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(jumpTaskIds)) {


            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,


@@ -1858,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());


        // 得到未完成的容缺任务


@@ -1876,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<>();


@@ -1998,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());


@@ -2156,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());


    }




    /**


@@ -2176,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())) {