全部事项和待办事项查询功能完善

xiangpei

2024-11-29 07c4ad96c75dc93b39e002feb19845219fede415

全部事项和待办事项查询功能完善

 business/src/main/java/com/ycl/constant/TaskTypeConstant.java

New file
@@ -0,0 +1,19 @@
package com.ycl.constant;

import lombok.Data;

/**
 * @author：xp
 * @date：2024/11/29 8:30
 */
public class TaskTypeConstant {

    public final static String ALL = "all"; // 全部任务
    public final static String TODO = "todo"; // 待办任务
    public final static String CURRENT = "current"; // 当前环节
    public final static String REMAINING = "remaining"; // 剩余任务
    public final static String TIMELY = "timely"; // 及时完成的任务
    public final static String WILL_OVER_TIME = "willOvertime"; // 即将超时任务
    public final static String urge = "urge"; // 督办

}

 business/src/main/java/com/ycl/controller/ProjectProcessController.java

@@ -2,6 +2,7 @@

import com.ycl.common.group.Update;
import com.ycl.common.group.Add;
import com.ycl.domain.query.TaskQuery;
import org.springframework.validation.annotation.Validated;
import org.springframework.security.access.prepost.PreAuthorize;
import lombok.RequiredArgsConstructor;
@@ -55,10 +56,17 @@
        return projectProcessService.detail(projectId, processId);
    }

    @PostMapping("/start/{projectId}/{processId}")
    @PostMapping("/start/{projectId}/{processDefId}")
    @ApiOperation(value = "启动流程", notes = "启动流程")
//    @PreAuthorize("@ss.hasPermi('projectProcess:start')")
    public Result startProcess(@PathVariable("projectId") String projectId, @PathVariable("processId") String processId) {
        return projectProcessService.startProcess(projectId, processId);
    public Result startProcess(@PathVariable("projectId") String projectId, @PathVariable("processDefId") String processDefId) {
        return projectProcessService.startProcess(projectId, processDefId);
    }

    @GetMapping("/detail/task/list")
    @ApiOperation(value = "获取任务列表", notes = "获取任务列表")
//    @PreAuthorize("@ss.hasPermi('projectProcess:detail')")
    public Result taskList(TaskQuery query) {
        return projectProcessService.taskList(query);
    }
}

 business/src/main/java/com/ycl/domain/entity/ProjectProcess.java

@@ -23,12 +23,12 @@
    /** 项目ID */
    private Long projectId;

    @TableField("flowable_process_id")
    @TableField("process_def_id")
    /** 流程定义ID */
    private String flowableProcessId;
    private String processDefId;

    @TableField("process_instance_id")
    @TableField("process_ins_id")
    /** 流程实例id */
    private String processInstanceId;
    private String processInsId;

}

 business/src/main/java/com/ycl/domain/form/ProjectProcessForm.java

@@ -28,8 +28,8 @@
    private Long projectId;

    @NotBlank(message = "流程ID不能为空", groups = {Add.class, Update.class})
    @ApiModelProperty("流程ID")
    private String flowableProcessId;
    @ApiModelProperty("流程定义ID")
    private String processDefId;

    public static ProjectProcess getEntityByForm(@NonNull ProjectProcessForm form, ProjectProcess entity) {
        if(entity == null) {

 business/src/main/java/com/ycl/domain/query/TaskQuery.java

New file
@@ -0,0 +1,33 @@
package com.ycl.domain.query;

import com.ycl.system.domain.base.AbsQuery;
import lombok.Data;

/**
 * @author：xp
 * @date：2024/11/29 8:12
 */
@Data
public class TaskQuery extends AbsQuery {

    /**
     * 项目id
     */
    private Long projectId;

    /**
     * 流程定义id
     */
    private String processDefId;

    /**
     * 任务名称
     */
    private String taskName;

    /**
     * 任务类型
     */
    private String taskType;

}

 business/src/main/java/com/ycl/domain/vo/CustomerTaskVO.java

New file
@@ -0,0 +1,111 @@
package com.ycl.domain.vo;

import com.ycl.common.enums.business.TaskStatusEnum;
import lombok.Data;

import java.util.Date;

/**
 * 任务回显内容
 *
 * @author：xp
 * @date：2024/11/29 10:59
 */
@Data
public class CustomerTaskVO {

    /**
     * flowable中的任务id
     */
    private String taskId;

    /**
     * flowable流程实例id
     */
    private String processInsId;

    /**
     * flowable流程定义id
     */
    private String processDefId;

    /**
     * 部署id
     */
    private String deployId;

    /**
     * 执行id
     */
    private String executionId;

    /**
     * 任务名称
     */
    private String taskName;

    /**
     * 流程名称
     */
    private String processName;

    /**
     * 发起人id
     */
    private Long promoterId;

    /**
     * 发起人姓名
     */
    private String promoterName;

    /**
     * 发起人单位
     */
    private Long promoterUnitId;

    /**
     * 发起人单位名称
     */
    private String promoterUnitName;

    /**
     * 处理人
     */
    private String handlerName;

    /**
     * 发起人id
     */
    private Long handlerId;

    /**
     * 处理人单位id
     */
    private Long handlerUnitId;

    /**
     * 处理人单位名称
     */
    private String handlerUnitName;

    /**
     * 办理期限
     */
    private String timeLimit;

    /**
     * 剩余时间
     */
    private String remainingTime;

    /**
     * 任务状态
     */
    private TaskStatusEnum taskStatus;

    /**
     * 任务创建时间
     */
    private Date createTime;
}

 business/src/main/java/com/ycl/domain/vo/ProjectProcessVO.java

@@ -21,13 +21,13 @@
@ApiModel(value = "项目管理基础信息表响应数据", description = "项目管理基础信息表响应数据")
public class ProjectProcessVO extends ProjectInfoVO {

    /** 流程id */
    @ApiModelProperty("流程id")
    private String flowableProcessId;
    /** 流程定义id */
    @ApiModelProperty("流程定义id")
    private String processDefId;

    @ApiModelProperty("流程名称")
    private String flowableProcessName;

    @ApiModelProperty("流程实例id")
    private String processInstanceId;
    private String processInsId;
}

 business/src/main/java/com/ycl/service/ProjectProcessService.java

@@ -5,6 +5,8 @@
import com.ycl.common.base.Result;
import com.ycl.domain.form.ProjectProcessForm;
import com.ycl.domain.query.ProjectProcessQuery;
import com.ycl.domain.query.TaskQuery;

import java.util.List;

/**
@@ -41,9 +43,17 @@
    /**
     * 启动流程
     *
     * @param processId  流程定义id
     * @param processDefId  流程定义id
     * @param projectId  项目id，作为业务id存入activity表
     * @return
     */
    Result startProcess(String projectId, String processId);
    Result startProcess(String projectId, String processDefId);

    /**
     * 查询任务列表
     *
     * @param query
     * @return
     */
    Result taskList(TaskQuery query);
}

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

@@ -10,10 +10,13 @@
import com.ycl.common.core.domain.entity.SysRole;
import com.ycl.common.core.domain.entity.SysUser;
import com.ycl.common.enums.FlowComment;
import com.ycl.common.enums.business.TaskStatusEnum;
import com.ycl.common.utils.SecurityUtils;
import com.ycl.constant.TaskTypeConstant;
import com.ycl.domain.dto.FlowTaskDto;
import com.ycl.domain.entity.ProjectInfo;
import com.ycl.domain.entity.ProjectProcess;
import com.ycl.domain.vo.CustomerTaskVO;
import com.ycl.domain.vo.ProjectProcessDetailVO;
import com.ycl.mapper.ProjectInfoMapper;
import com.ycl.mapper.ProjectProcessMapper;
@@ -26,15 +29,15 @@
import com.ycl.system.service.ISysRoleService;
import com.ycl.system.service.ISysUserService;
import org.apache.commons.lang3.StringUtils;
import org.flowable.bpmn.model.BpmnModel;
import org.flowable.bpmn.model.FlowElement;
import org.flowable.bpmn.model.*;
import org.flowable.bpmn.model.Process;
import org.flowable.bpmn.model.StartEvent;
import org.flowable.engine.*;
import org.flowable.engine.history.HistoricProcessInstance;
import org.flowable.engine.repository.ProcessDefinition;
import org.flowable.engine.runtime.ProcessInstance;
import org.flowable.identitylink.api.IdentityLink;
import org.flowable.identitylink.api.IdentityLinkInfo;
import org.flowable.identitylink.api.history.HistoricIdentityLink;
import org.flowable.task.api.Task;
import org.flowable.task.api.TaskQuery;
import org.flowable.task.api.history.HistoricTaskInstance;
@@ -81,13 +84,62 @@
        return Result.ok().data(page.getRecords()).total(page.getTotal());
    }

    @Override
    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);
        }
        return Result.ok("流程变更成功");
    }

    @Override
    @Transactional(rollbackFor = Exception.class)
    public Result startProcess(String projectId, String processDefId) {
        ProcessDefinition processDefinition = repositoryService.createProcessDefinitionQuery().processDefinitionId(processDefId)
                .latestVersion().singleResult();
        if (Objects.nonNull(processDefinition) && processDefinition.isSuspended()) {
            return Result.error("该流程已被挂起,请先激活流程");
        }
        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("流程启动成功");
    }

    /**
     * 获取流程详情
     * @param projectId
     * @return
     */
    @Override
    public Result detail(Long projectId, String processId) {
    public Result detail(Long projectId, String processDefId) {
        // 项目信息
        ProjectInfo projectInfo = new LambdaQueryChainWrapper<>(projectInfoMapper)
                .select(ProjectInfo::getId, ProjectInfo::getProjectName, ProjectInfo::getProjectCode)
@@ -100,7 +152,7 @@

        ProjectProcess projectProcess = new LambdaQueryChainWrapper<>(baseMapper)
                .eq(ProjectProcess::getProjectId, projectId)
                .eq(ProjectProcess::getFlowableProcessId, processId)
                .eq(ProjectProcess::getProcessDefId, processDefId)
                .one();
        if (Objects.isNull(projectProcess)) {
            return Result.error("该项目未设置流程");
@@ -113,110 +165,86 @@

        ProjectProcessDetailVO.TaskStatistics taskStatistics = new ProjectProcessDetailVO.TaskStatistics();
        // 状态统计
        taskStatistics.setTotalTaskNum(this.getTotalTaskNum(processId));
        taskStatistics.setTodoTaskNum(this.getTodoTaskNum(projectProcess.getProcessInstanceId()));
        taskStatistics.setTotalTaskNum(this.getTotalTaskNum(processDefId));
        taskStatistics.setTodoTaskNum(this.getTodoTaskNum(projectProcess.getProcessInsId()));
//        taskStatistics.setCurrentTask(this.getCurrentNodeTaskList(projectProcess.getProcessInstanceId()));
        taskStatistics.setRemainingTaskNum(this.getNotFinishedTaskNum(projectProcess.getProcessInstanceId()));
        taskStatistics.setRemainingTaskNum(this.getNotFinishedTaskNum(projectProcess.getProcessInsId()));
        detail.setStatistics(taskStatistics);

        Result result = Result.ok();

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


    @Override
    public Result projectSetProcess(ProjectProcessForm form) {
        // 查询该项目是否已经绑定过流程了，检查绑定的流程是否在运行，在运行就删了
        ProjectProcess pp = new LambdaQueryChainWrapper<>(baseMapper)
                .eq(ProjectProcess::getProjectId, form.getProjectId())
    public Result taskList(com.ycl.domain.query.TaskQuery query) {
        // 获取项目对应的流程实例id
        ProjectProcess projectProcess = new LambdaQueryChainWrapper<>(baseMapper)
                .eq(ProjectProcess::getProjectId, query.getProjectId())
                .eq(ProjectProcess::getProcessDefId, query.getProcessDefId())
                .one();
        if (Objects.nonNull(pp)) {
            // TODO 处理之前绑定过的流程数据
            new LambdaUpdateChainWrapper<>(baseMapper)
                    .eq(ProjectProcess::getProjectId, form.getProjectId())
                    .set(ProjectProcess::getFlowableProcessId, form.getFlowableProcessId())
                    .update();
        } else {
            ProjectProcess entity = ProjectProcessForm.getEntityByForm(form, null);
            baseMapper.insert(entity);
        if (Objects.isNull(projectProcess)) {
            throw new RuntimeException("该项目未配置流程");
        }
        return Result.ok("流程变更成功");
        Result ok = Result.ok();
        switch (query.getTaskType()) {
            case TaskTypeConstant.ALL:
                this.getAllUserTask(query.getProcessDefId(), projectProcess.getProcessInsId(), query.getTaskName (), (int)query.getCurrentPage(), (int)query.getPageSize(), ok);
            case TaskTypeConstant.TODO:
                this.getTodoTaskList(projectProcess.getProcessInsId(), query.getTaskName(), (int)query.getPageSize(), (int)query.getCurrentPage(), ok);
            case TaskTypeConstant.CURRENT:

            case TaskTypeConstant.REMAINING:

            default:


        }
        return ok;
    }

    @Override
    @Transactional(rollbackFor = Exception.class)
    public Result startProcess(String projectId, String processId) {
        ProcessDefinition processDefinition = repositoryService.createProcessDefinitionQuery().processDefinitionId(processId)
                .latestVersion().singleResult();
        if (Objects.nonNull(processDefinition) && processDefinition.isSuspended()) {
            return Result.error("该流程已被挂起,请先激活流程");
        }
        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(processId, 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::getFlowableProcessId, processId)
                .set(ProjectProcess::getProcessInstanceId, processInstance.getProcessInstanceId())
                .update();
        return Result.ok("流程启动成功");
    }


    private void getTodoTaskList(String processInstanceId, String name, Integer pageNum, Integer pageSize, Result result) {
    private void getTodoTaskList(String processInsId, String taskName, int pageSize, int pageNum, Result result) {
        TaskQuery taskQuery = taskService.createTaskQuery()
                .active()
                .processInstanceId(processInstanceId)
                .processInstanceId(processInsId)
                .includeProcessVariables()
                .orderByTaskCreateTime().desc();

//        TODO 传入名称查询不到数据?
        if (StringUtils.isNotBlank(name)) {
            taskQuery.processDefinitionNameLike(name);
        if (StringUtils.isNotBlank(taskName)) {
            taskQuery.processDefinitionNameLike(taskName);
        }
        result.total(taskQuery.count());
        List<Task> taskList = taskQuery.listPage(pageSize * (pageNum - 1), pageSize);
        List<FlowTaskDto> flowList = new ArrayList<>();
        List<CustomerTaskVO> vos = new ArrayList<>();
        for (Task task : taskList) {
            FlowTaskDto flowTask = new FlowTaskDto();
            CustomerTaskVO taskVO = new CustomerTaskVO();
            // 当前流程信息
            flowTask.setTaskId(task.getId());
            flowTask.setTaskDefKey(task.getTaskDefinitionKey());
            flowTask.setCreateTime(task.getCreateTime());
            flowTask.setProcDefId(task.getProcessDefinitionId());
            flowTask.setExecutionId(task.getExecutionId());
            flowTask.setTaskName(task.getName());
            taskVO.setTaskId(task.getId());
            taskVO.setCreateTime(task.getCreateTime());
            taskVO.setProcessDefId(task.getProcessDefinitionId());
            taskVO.setExecutionId(task.getExecutionId());
            taskVO.setTaskName(task.getName());
            taskVO.setTaskStatus(TaskStatusEnum.TODO);
            // 流程定义信息
            ProcessDefinition pd = repositoryService.createProcessDefinitionQuery()
                    .processDefinitionId(task.getProcessDefinitionId())
                    .singleResult();
            flowTask.setDeployId(pd.getDeploymentId());
            flowTask.setProcDefName(pd.getName());
            flowTask.setProcDefVersion(pd.getVersion());
            flowTask.setProcInsId(task.getProcessInstanceId());
            taskVO.setDeployId(pd.getDeploymentId());
            taskVO.setProcessName(pd.getName());
            taskVO.setProcessInsId(task.getProcessInstanceId());

            // 流程发起人信息
            HistoricProcessInstance historicProcessInstance = historyService.createHistoricProcessInstanceQuery()
                    .processInstanceId(task.getProcessInstanceId())
                    .singleResult();
            SysUser startUser = sysUserService.selectUserById(Long.parseLong(historicProcessInstance.getStartUserId()));
            flowTask.setStartUserId(startUser.getUserId().toString());
            flowTask.setStartUserName(startUser.getNickName());
            flowTask.setStartDeptName(Objects.nonNull(startUser.getDept()) ? startUser.getDept().getDeptName() : "");
            taskVO.setPromoterId(startUser.getUserId());
            taskVO.setPromoterName(startUser.getNickName());
            taskVO.setPromoterUnitName(Objects.nonNull(startUser.getDept()) ? startUser.getDept().getDeptName() : "");
            taskVO.setPromoterUnitId(Objects.nonNull(startUser.getDept()) ? startUser.getDept().getDeptId() : null);
            // 流程处理人信息
            List<IdentityLink> identityLinksForTask = taskService.getIdentityLinksForTask(task.getId());
            for (IdentityLink identityLink : identityLinksForTask) {
@@ -224,34 +252,179 @@
                if (StringUtils.isNotBlank(identityLink.getUserId())) {
                    SysUser sysUser = sysUserService.selectUserById(Long.parseLong(identityLink.getUserId()));
                    if (Objects.nonNull(sysUser)) {
                        flowTask.setAssigneeId(sysUser.getUserId());
                        taskVO.setHandlerId(sysUser.getUserId());
                        if (Objects.nonNull(sysUser.getDept())) {
                            flowTask.setAssigneeDeptName(sysUser.getDept().getDeptName());
                            taskVO.setHandlerUnitId(sysUser.getDept().getDeptId());
                            taskVO.setHandlerUnitName(sysUser.getDept().getDeptName());
                        }
                        flowTask.setAssigneeName(sysUser.getNickName());
                        taskVO.setHandlerName(sysUser.getNickName());
                    }
                // 绑定的是角色，查出角色名称
                    // 绑定的是角色，查出角色名称
                } else if (StringUtils.isNotBlank(identityLink.getGroupId())) {
                    SysRole role = sysRoleService.selectRoleById(Long.parseLong(identityLink.getGroupId()));
                    if (Objects.nonNull(role)) {
                        flowTask.setAssigneeId(Long.parseLong(identityLink.getGroupId()));
                        flowTask.setAssigneeDeptName("由拥有角色：【" + role.getRoleName() + "】的人处理");
                        flowTask.setAssigneeName("暂未处理");
                        taskVO.setHandlerUnitId(Long.parseLong(identityLink.getGroupId()));
                        taskVO.setHandlerUnitName("由拥有角色：【" + role.getRoleName() + "】的人处理");
                        taskVO.setHandlerName("暂未处理");
                        taskVO.setHandlerId(null);
                    }
                }
            }
            flowList.add(flowTask);
            vos.add(taskVO);
        }
        result.put("taskList", flowList);
        result.put("taskList", vos);
    }

    /**
     * 获取流程节点数（总任务数，不包含开始、结束等特殊的，只统计UserTask类型的）
     * 获取所有任务
     *
     * @param processDefinitionId  流程定义id
     * @param processDefinitionId 流程运行id
     * @param processInsId 流程实例id
     * @param pageNum
     * @param pageSize
     * @param result
     * @return
     */
    private Long getTotalTaskNum(String processDefinitionId) {
    private List<CustomerTaskVO> getAllUserTask(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);
                } else {
                    vo.setTaskStatus(TaskStatusEnum.FINISHED);
                    // 如果是已完成的，信息需要单独赋值
                    vo.setTaskId(historicTask.getId());
                    vo.setExecutionId(historicTask.getExecutionId());
                    vo.setCreateTime(historicTask.getStartTime());
                    // 查询实际处理人
                    long handlerUserId = Long.parseLong(historicTask.getAssignee());
                    SysUser handlerUser = sysUserService.selectUserById(handlerUserId);
                    if (Objects.nonNull(handlerUser)) {
                        vo.setHandlerId(handlerUserId);
                        vo.setHandlerName(handlerUser.getNickName());
                    }
                    this.setPromoterAndHandler(vo, historicTask.getIdentityLinks());
                }
            } else {
                vo.setTaskStatus(TaskStatusEnum.TODO);
                vo.setTaskId(task.getId());
                vo.setExecutionId(task.getExecutionId());
                vo.setCreateTime(task.getCreateTime());
                this.setPromoterAndHandler(vo, null);
            }
            return vo;
        }).collect(Collectors.toList());
        result.data(vos);
        return vos;
    }

    /**
     * 设置任务的发起人&处理人
     *
     * @param taskVO
     * @param identityLinkInfos 如果是已完成的任务，用这个去取关联的用户/用户组
     */
    private void setPromoterAndHandler(CustomerTaskVO taskVO, List<? extends IdentityLinkInfo> identityLinkInfos) {
        // 流程发起人信息
        HistoricProcessInstance historicProcessInstance = historyService.createHistoricProcessInstanceQuery()
                .processInstanceId(taskVO.getProcessInsId())
                .singleResult();
        SysUser startUser = sysUserService.selectUserById(Long.parseLong(historicProcessInstance.getStartUserId()));
        taskVO.setPromoterId(startUser.getUserId());
        taskVO.setPromoterName(startUser.getNickName());
        taskVO.setPromoterUnitId(Objects.nonNull(startUser.getDept()) ? startUser.getDept().getDeptId() : null);
        taskVO.setPromoterUnitName(Objects.nonNull(startUser.getDept()) ? startUser.getDept().getDeptName() : "");
        // 流程处理人信息
        if (TaskStatusEnum.TODO.equals(taskVO.getTaskStatus())) {
            List<IdentityLink> identityLinksForTask = taskService.getIdentityLinksForTask(taskVO.getTaskId());
            for (IdentityLink identityLink : identityLinksForTask) {
                // 绑定的是用户，查出用户姓名、部门
                if (StringUtils.isNotBlank(identityLink.getUserId())) {
                    SysUser sysUser = sysUserService.selectUserById(Long.parseLong(identityLink.getUserId()));
                    if (Objects.nonNull(sysUser)) {
                        taskVO.setHandlerId(sysUser.getUserId());
                        if (Objects.nonNull(sysUser.getDept())) {
                            taskVO.setHandlerUnitId(sysUser.getDept().getDeptId());
                            taskVO.setHandlerUnitName(sysUser.getDept().getDeptName());
                        }
                        taskVO.setHandlerName(sysUser.getNickName());
                    }
                    // 绑定的是角色，查出角色名称
                } else if (StringUtils.isNotBlank(identityLink.getGroupId())) {
                    SysRole role = sysRoleService.selectRoleById(Long.parseLong(identityLink.getGroupId()));
                    if (Objects.nonNull(role)) {
                        taskVO.setHandlerUnitId(Long.parseLong(identityLink.getGroupId()));
                        taskVO.setHandlerUnitName("由拥有角色：【" + role.getRoleName() + "】的人处理");
                        taskVO.setHandlerName("暂未处理");
                        taskVO.setHandlerId(null);
                    }
                }
            }
        } else if (TaskStatusEnum.FINISHED.equals(taskVO.getTaskStatus())){
            for (IdentityLinkInfo identityLink : identityLinkInfos) {
                // 绑定的是用户，查出用户姓名、部门
                if (StringUtils.isNotBlank(identityLink.getUserId())) {
                    SysUser sysUser = sysUserService.selectUserById(Long.parseLong(identityLink.getUserId()));
                    if (Objects.nonNull(sysUser)) {
//                        taskVO.setHandlerId(sysUser.getUserId());
                        if (Objects.nonNull(sysUser.getDept())) {
                            taskVO.setHandlerUnitId(sysUser.getDept().getDeptId());
                            taskVO.setHandlerUnitName(sysUser.getDept().getDeptName());
                        }
//                        taskVO.setHandlerName(sysUser.getNickName());
                    }
                    // 绑定的是角色，查出角色名称
                } else if (StringUtils.isNotBlank(identityLink.getGroupId())) {
                    SysRole role = sysRoleService.selectRoleById(Long.parseLong(identityLink.getGroupId()));
                    if (Objects.nonNull(role)) {
                        taskVO.setHandlerUnitId(Long.parseLong(identityLink.getGroupId()));
                        taskVO.setHandlerUnitName("由拥有角色：【" + role.getRoleName() + "】的人处理");
//                        taskVO.setHandlerName(role.getRoleName());
//                        taskVO.setHandlerId(null);
                    }
                }
            }
        }

    }

    /**
     * 获取某个流程的所有任务节点
     *
     * @param processDefinitionId
     * @return
     */
    private List<UserTask> getAllUserTaskElement(String processDefinitionId) {
        // 获取流程定义
        ProcessDefinition processDefinition = repositoryService.createProcessDefinitionQuery()
                .processDefinitionId(processDefinitionId)
@@ -273,15 +446,21 @@
            throw new IllegalStateException("无法获取流程对象: " + processDefinition.getKey());
        }

        // 计算任务节点数量
        Long taskNodeCount = 0L;
        List<FlowElement> flowElements = process.getFlowElements().stream().toList();
        for (FlowElement flowElement : flowElements) {
            if (flowElement instanceof org.flowable.bpmn.model.UserTask) {
                taskNodeCount++;
            }
        }
        return taskNodeCount;
        List<UserTask> userTaskElements = flowElements.stream().filter(flowElement -> flowElement instanceof UserTask).map(flowElement -> {
            return (UserTask) flowElement;
        }).collect(Collectors.toList());
        return userTaskElements;
    }

    /**
     * 获取流程节点数（总任务数，不包含开始、结束等特殊的，只统计UserTask类型的）
     *
     * @param processDefinitionId  流程定义id
     * @return
     */
    private Long getTotalTaskNum(String processDefinitionId) {
        return Long.valueOf(this.getAllUserTaskElement(processDefinitionId).size());
    }

    /**

 business/src/main/resources/mapper/ProjectProcessMapper.xml

@@ -37,7 +37,7 @@
        <result column="gmt_update_time" property="gmtUpdateTime" />
        <result column="update_by" property="updateBy" />
        <result column="create_by" property="createBy" />
        <result column="flowable_process_id" property="flowableProcessId" />
        <result column="process_def_id" property="processDefId" />
<!--        <association property="id" column=""-->
    </resultMap>

@@ -47,7 +47,7 @@
    <select id="getById" resultMap="BaseResultMap">
        SELECT
            TPP.project_id,
            TPP.flowable_process_id,
            TPP.process_def_id,
            TPP.id
        FROM
            t_project_process TPP
@@ -59,7 +59,7 @@
    <select id="getPage" resultMap="BaseResultMap">
        SELECT
            PI.*,
            TPP.flowable_process_id
            TPP.process_def_id
        FROM
            t_project_info PI
                LEFT JOIN t_project_process TPP ON TPP.project_id = PI.id AND TPP.deleted = 0 AND PI.deleted = 0

 common/src/main/java/com/ycl/common/enums/business/TaskStatusEnum.java

New file
@@ -0,0 +1,29 @@
package com.ycl.common.enums.business;

import com.fasterxml.jackson.annotation.JsonValue;
import lombok.Getter;

/**
 * 工作流任务状态
 *
 * @author：xp
 * @date：2024/11/29 11:13
 */
@Getter
public enum TaskStatusEnum {

    NOT_START("not_start", "未开始"),
    TODO("todo", "待办"),
    FINISHED("finished", "已完成")
    ;

    private final String value;

    @JsonValue
    private final String desc;

    TaskStatusEnum(String value, String desc) {
        this.value = value;
        this.desc = desc;
    }
}

 flowable/src/main/java/com/ycl/service/impl/FlowTaskServiceImpl.java

@@ -113,12 +113,14 @@
     * @return
     */
    @Override
    @Transactional(rollbackFor = Exception.class)
    public AjaxResult completeSubmitForm(String taskId, Map<String, Object> variables) {
        Task task = taskService.createTaskQuery().taskId(taskId).singleResult();
        if (Objects.isNull(task)) {
            return AjaxResult.error("任务不存在");
        }
//        variables.put(taskId + "formJson", variables.get("formJson"));
        // 先让当前用户认领这个任务
        taskService.claim(taskId, SecurityUtils.getUserId() + "");
        taskService.addComment(taskId, task.getProcessInstanceId(), FlowComment.SUBMIT.getType(), "完成提交");
        taskService.complete(taskId, variables);
        return AjaxResult.success("提交成功");

 system/src/main/java/com/ycl/system/domain/base/AbsQuery.java

@@ -13,9 +13,9 @@
public class AbsQuery {

    @ApiModelProperty(value = "当前页", required = true)
    private Long currentPage = 1L;
    private long currentPage = 1L;

    @ApiModelProperty(value = "每页条数", required = true)
    private Long pageSize = 10L;
    private long pageSize = 10L;

}