项目启动流程、变更流程逻辑调整

xiangpei

2024-11-29 de04015a9eaf4a9928a1cba6cdfceed03146a720

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

@@ -85,52 +85,69 @@
    }

    @Override
    @Transactional(rollbackFor = Exception.class)
    public Result projectSetProcess(ProjectProcessForm form) {
        // 查询该项目是否已经绑定过流程了，检查绑定的流程是否在运行，在运行就删了
        ProjectProcess pp = new LambdaQueryChainWrapper<>(baseMapper)
                .eq(ProjectProcess::getProjectId, form.getProjectId())
                .one();
        if (Objects.nonNull(pp)) {
            // TODO 处理之前绑定过的流程数据
            new LambdaUpdateChainWrapper<>(baseMapper)
                    .eq(ProjectProcess::getProjectId, form.getProjectId())
                    .set(ProjectProcess::getProcessDefId, form.getProcessDefId())
                    .update();
        } else {
            ProjectProcess entity = ProjectProcessForm.getEntityByForm(form, null);
            baseMapper.insert(entity);
        if (Objects.isNull(pp)) {
            throw new RuntimeException("该项目未绑定流程");
        }
        if (Objects.nonNull(pp.getProcessInsId())) {
            HistoricProcessInstance historicProcessInstance =
                    historyService.createHistoricProcessInstanceQuery().processInstanceId(pp.getProcessInsId()).singleResult();
            // 删除之前流程的数据
            if (historicProcessInstance.getEndTime() != null) {
                historyService.deleteHistoricProcessInstance(historicProcessInstance.getId());
            } else {
                // 删除流程实例
                runtimeService.deleteProcessInstance(pp.getProcessInsId(), "");
                // 删除历史流程实例
                historyService.deleteHistoricProcessInstance(pp.getProcessInsId());
            }
        }
        String processInsId = this.startPro(form.getProjectId(), form.getProcessDefId());
        new LambdaUpdateChainWrapper<>(baseMapper)
                .eq(ProjectProcess::getProjectId, form.getProjectId())
                .set(ProjectProcess::getProcessDefId, form.getProcessDefId())
                .set(ProjectProcess::getProcessInsId, processInsId)
                .update();
        return Result.ok("流程变更成功");
    }

    @Override
    @Transactional(rollbackFor = Exception.class)
    public Result startProcess(String projectId, String processDefId) {
    public Result startProcess(Long projectId, String processDefId) {
        String processInsId = this.startPro(projectId, processDefId);
        ProjectProcess entity = new ProjectProcess();
        entity.setProjectId(projectId);
        entity.setProcessDefId(processDefId);
        entity.setProcessInsId(processInsId);
        baseMapper.insert(entity);
        return Result.ok("流程启动成功");
    }

    /**
     * 启动流程
     *
     * @param projectId
     * @param processDefId
     * @return
     */
    private String startPro(Long projectId, String processDefId) {
        ProcessDefinition processDefinition = repositoryService.createProcessDefinitionQuery().processDefinitionId(processDefId)
                .latestVersion().singleResult();
        if (Objects.nonNull(processDefinition) && processDefinition.isSuspended()) {
            return Result.error("该流程已被挂起,请先激活流程");
            throw new RuntimeException("该流程已被挂起,请先激活流程");
        }
        Map<String, Object> variables = new HashMap<>(2);
        // 设置流程发起人Id到流程中
        SysUser sysUser = SecurityUtils.getLoginUser().getUser();
        identityService.setAuthenticatedUserId(sysUser.getUserId().toString());
        variables.put(ProcessConstants.PROCESS_INITIATOR, sysUser.getUserId());
        ProcessInstance processInstance = runtimeService.startProcessInstanceById(processDefId, projectId, variables);
//        // 流程发起时 跳过发起人节点
//        // 给第一步申请人节点设置任务执行人和意见
//        Task task = taskService.createTaskQuery().processInstanceId(processInstance.getProcessInstanceId()).singleResult();
//        if (Objects.nonNull(task)) {
//            taskService.addComment(task.getId(), processInstance.getProcessInstanceId(), FlowComment.NORMAL.getType(), sysUser.getNickName() + "发起流程申请");
//            taskService.complete(task.getId(), variables);
//        }
        // 项目流程关联流程实例id
        new LambdaUpdateChainWrapper<>(baseMapper)
                .eq(ProjectProcess::getProjectId, projectId)
                .eq(ProjectProcess::getProcessDefId, processDefId)
                .set(ProjectProcess::getProcessInsId, processInstance.getProcessInstanceId())
                .update();
        return Result.ok("流程启动成功");
        ProcessInstance processInstance = runtimeService.startProcessInstanceById(processDefId, projectId + "", variables);
        return processInstance.getId();
    }

    /**
@@ -167,6 +184,7 @@
        // 状态统计
        taskStatistics.setTotalTaskNum(this.getTotalTaskNum(processDefId));
        taskStatistics.setTodoTaskNum(this.getTodoTaskNum(projectProcess.getProcessInsId()));
        taskStatistics.setRemainingTaskNum(this.getRemainingTaskNum(processDefId, projectProcess.getProcessInsId()));
//        taskStatistics.setCurrentTask(this.getCurrentNodeTaskList(projectProcess.getProcessInstanceId()));
        taskStatistics.setRemainingTaskNum(this.getNotFinishedTaskNum(projectProcess.getProcessInsId()));
        detail.setStatistics(taskStatistics);
@@ -192,19 +210,32 @@
        switch (query.getTaskType()) {
            case TaskTypeConstant.ALL:
                this.getAllUserTask(query.getProcessDefId(), projectProcess.getProcessInsId(), query.getTaskName (), (int)query.getCurrentPage(), (int)query.getPageSize(), ok);
                break;
            case TaskTypeConstant.TODO:
                this.getTodoTaskList(projectProcess.getProcessInsId(), query.getTaskName(), (int)query.getPageSize(), (int)query.getCurrentPage(), ok);
                ok.data(ok.get("taskList"));
                break;
            case TaskTypeConstant.CURRENT:

                break;
            case TaskTypeConstant.REMAINING:

                this.getRemainingTask(query.getProcessDefId(), projectProcess.getProcessInsId(), query.getTaskName (), (int)query.getCurrentPage(), (int)query.getPageSize(), ok);
                break;
            default:

                break;

        }
        return ok;
    }

    /**
     * 查询待办任务
     *
     * @param processInsId
     * @param taskName
     * @param pageSize
     * @param pageNum
     * @param result
     */
    private void getTodoTaskList(String processInsId, String taskName, int pageSize, int pageNum, Result result) {
        TaskQuery taskQuery = taskService.createTaskQuery()
                .active()
@@ -212,7 +243,6 @@
                .includeProcessVariables()
                .orderByTaskCreateTime().desc();

//        TODO 传入名称查询不到数据?
        if (StringUtils.isNotBlank(taskName)) {
            taskQuery.processDefinitionNameLike(taskName);
        }
@@ -349,12 +379,103 @@
    }

    /**
     * 查询剩余事项（未开始的任务）
     *
     * @param processDefinitionId
     * @param processInsId
     * @param taskName
     * @param pageNum
     * @param pageSize
     * @param result
     * @return
     */
    private List<CustomerTaskVO> getRemainingTask(String processDefinitionId, String processInsId, String taskName, Integer pageNum, Integer pageSize, Result result) {
        int startNum = pageSize * (pageNum - 1);
        int endNum = startNum + pageSize;
        List<UserTask> allUserTaskElement = this.getAllUserTaskElement(processDefinitionId);
        result.total(allUserTaskElement.size());
        if (startNum >= allUserTaskElement.size()) {
            // 如果起始索引超出了列表的大小，返回一个空列表
            return new ArrayList<>();
        }
        if (StringUtils.isNotBlank(taskName)) {
            // 模拟模糊查询
            allUserTaskElement = allUserTaskElement.stream().filter(taskEl -> taskEl.getName().contains(taskName)).collect(Collectors.toList());
        }
        int end = Math.min(endNum, allUserTaskElement.size());
        List<UserTask> userTasks = allUserTaskElement.subList(startNum, end);
        // 查出流程
        ProcessInstance process = runtimeService.createProcessInstanceQuery().processInstanceId(processInsId).singleResult();
        // 判断任务状态
        List<CustomerTaskVO> vos = userTasks.stream().map(userTask -> {
            CustomerTaskVO vo = new CustomerTaskVO();
            vo.setProcessInsId(process.getId());
            vo.setProcessDefId(processDefinitionId);
            vo.setDeployId(process.getDeploymentId());
            vo.setTaskName(userTask.getName());
            vo.setProcessName(process.getProcessDefinitionName());
            Task task = taskService.createTaskQuery().processInstanceId(process.getId()).taskDefinitionKey(userTask.getId()).singleResult();
            if (Objects.isNull(task)) {
                // 如果任务在运行时没找到，那么可能为未开始或者已完成，只查询未开始的
                HistoricTaskInstance historicTask = historyService.createHistoricTaskInstanceQuery()
                        .processInstanceId(process.getProcessInstanceId())
                        .taskDefinitionKey(userTask.getId())
                        .includeIdentityLinks()
                        .singleResult();
                if (Objects.isNull(historicTask)) {
                    vo.setTaskStatus(TaskStatusEnum.NOT_START);
                    return vo;
                } else {
                    return null;
                }
            } else {
                return null;
            }
        }).filter(Objects::nonNull).collect(Collectors.toList());
        result.data(vos);
        return vos;
    }

    /**
     * 查询剩余事项（未开始的任务）数量
     *
     * @param processDefinitionId 流程定义id
     * @param processInsId 流程实例id
     * @return
     */
    private Long getRemainingTaskNum(String processDefinitionId, String processInsId) {

        List<UserTask> allUserTaskElement = this.getAllUserTaskElement(processDefinitionId);
        // 查出流程
        ProcessInstance process = runtimeService.createProcessInstanceQuery().processInstanceId(processInsId).singleResult();
        long num = 0L;
        // 判断任务状态
        for (UserTask userTask : allUserTaskElement) {
            Task task = taskService.createTaskQuery().processInstanceId(process.getId()).taskDefinitionKey(userTask.getId()).singleResult();
            if (Objects.isNull(task)) {
                // 如果任务在运行时没找到，那么可能为未开始或者已完成，只查询未开始的
                HistoricTaskInstance historicTask = historyService.createHistoricTaskInstanceQuery()
                        .processInstanceId(process.getProcessInstanceId())
                        .taskDefinitionKey(userTask.getId())
                        .includeIdentityLinks()
                        .singleResult();
                if (Objects.isNull(historicTask)) {
                    num++;
                }
            }
        }
        return num;
    }


    /**
     * 设置任务的发起人&处理人
     *
     * @param taskVO
     * @param identityLinkInfos 如果是已完成的任务，用这个去取关联的用户/用户组
     */
    private void setPromoterAndHandler(CustomerTaskVO taskVO, List<? extends IdentityLinkInfo> identityLinkInfos) {
        // TODO 发起人是否应为上一节点的处理人
        // 流程发起人信息
        HistoricProcessInstance historicProcessInstance = historyService.createHistoricProcessInstanceQuery()
                .processInstanceId(taskVO.getProcessInsId())