1、自行受理跳转bug修复 2、联合处置流程优化

liyj

2024-09-15 3ce77531a4e13d749d58fea1a13695a80fbb9516

 dyh-service/dyh-mediate/src/main/java/cn/huge/module/flow/service/FlowInfoService.java

@@ -2,11 +2,24 @@

import cn.huge.base.common.exception.ServiceException;
import cn.huge.base.common.utils.DateUtils;
import cn.huge.base.common.utils.FieldUtils;
import cn.huge.base.common.utils.IdUtils;
import cn.huge.base.common.utils.ObjectUtils;
import cn.huge.module.client.api.impl.UtilsClientImpl;
import cn.huge.module.flow.dao.mapper.FlowInfoMapper;
import cn.huge.module.flow.domain.po.FlowInfo;
import cn.huge.module.flow.domain.po.FlowNode;
import com.baomidou.mybatisplus.core.conditions.query.QueryWrapper;
import com.baomidou.mybatisplus.extension.service.impl.ServiceImpl;
import com.google.common.collect.Maps;
import org.apache.commons.collections.CollectionUtils;
import org.flowable.engine.HistoryService;
import org.flowable.engine.RepositoryService;
import org.flowable.engine.RuntimeService;
import org.flowable.engine.TaskService;
import org.flowable.engine.runtime.ProcessInstance;
import org.flowable.task.api.Task;
import org.springframework.beans.BeanUtils;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.stereotype.Service;
import lombok.extern.slf4j.Slf4j;
@@ -38,7 +51,18 @@
    private FlowInfoMapper mapper;

    @Autowired
    private FlowNodeService flowNodeService;
    @Autowired
    private UtilsClientImpl utilsClient;

    @Autowired
    private RuntimeService runtimeService;
    @Autowired
    private TaskService taskService;
    @Autowired
    private HistoryService historyService;
    @Autowired
    private RepositoryService repositoryService;

    /**
    * 更新对象
@@ -130,4 +154,124 @@
        }
    }

    /**
     * 封装任务节点
     * @param flowableId 流程定义编号
     * @param task 流程任务
     * @return FlowNodeBaseDTO
     */
    public FlowNode getFlowNode(String flowableId, Task task){
        // 封装任务节点
        FlowNode flowNode = null;
        if (ObjectUtils.isNotEmpty(task)) {
            flowNode = flowNodeService.listByFlowAndNode(flowableId, task.getTaskDefinitionKey());
            if (ObjectUtils.isNotEmpty(flowNode)) {
                flowNode.setProcessInstanceId(task.getProcessInstanceId());
                flowNode.setProcessTaskId(task.getId());
            }
        }
        return flowNode;
    }

    /**
     * 单节点业务操作-根据流程编号启动流程
     * @param flowableId 流程定义编号
     * @param businessId 业务编号
     * @return FlowNodeBaseDTO
     */
    public FlowNode startFlow(String flowableId, String businessId) {
        try {
            // 启动任务
            ProcessInstance processInstance = runtimeService.startProcessInstanceByKey(flowableId, businessId);
            Task nextTask = getTaskByProcdefId(processInstance.getId());
            // 封装任务节点
            FlowNode flowNode = this.getFlowNode(flowableId, nextTask);
            return flowNode;
        }catch (Exception e){
            log.error("service方法[FlowInfoService.startFlow]调用异常："+e, e);
            throw new ServiceException("FlowInfoService.startFlow", e);
        }
    }

    /**
     * 单节点业务操作-通过当前任务编号完成当前任务
     * @param flowableId 流程定义编号
     * @param taskId 任务编号
     * @param operation 操作调解
     * @param handlerUserId 任务执行者
     * @return FlowNodeBaseDTO
     */
    public FlowNode completeTask(String flowableId, String taskId, String operation, String handlerUserId) {
        try{
            Task task = findTaskById(taskId);
            task.setAssignee(handlerUserId);
            Map flowParam = Maps.newHashMap();
            flowParam.put("operation", operation);
            taskService.complete(task.getId(), flowParam);
            Task nextTask = getTaskByProcdefId(task.getProcessInstanceId());
            FlowNode flowNode = this.getFlowNode(flowableId, nextTask);
            return flowNode;
        }catch (Exception e){
            log.error("service方法[FlowInfoService.completeByTaskId]调用异常："+e, e);
            throw new ServiceException("FlowInfoService.completeByTaskId", e);
        }
    }

    /**
     * 单节点业务操作-任务指定人员
     * @param taskId 任务编号
     * @param handlerUserId 任务候选人
     */
    public void appointTaskOwner(String taskId, String handlerUserId) {
        try{
            Task task = findTaskById(taskId);
            taskService.addCandidateUser(task.getId(), handlerUserId);
        }catch (Exception e){
            log.error("service方法[FlowInfoService.appointTaskOwner]调用异常："+e, e);
            throw new ServiceException("FlowInfoService.appointTaskOwner", e);
        }
    }

    /**
     * 根据流程实例Id获取任务
     * @param processInstanceId 流程实例Id
     * @return Task
     */
    public Task getTaskByProcdefId(String processInstanceId){
        Task task = taskService.createTaskQuery().processInstanceId(processInstanceId).singleResult();
        return task;
    }

    /**
     * 根据任务ID，获取任务
     * @param taskId 任务ID
     * @return Task
     */
    public Task findTaskById(String taskId) {
        return taskService.createTaskQuery().taskId(taskId).singleResult();
    }

    /**
     * 根据流程实例Id获取当前所有任务
     * @param processInstanceId 流程示例编号
     * @return List<Task>
     */
    public List<Task> getTaskByProcdefIds(String processInstanceId){
        List<Task> tasks = taskService.createTaskQuery().processInstanceId(processInstanceId).list();
        return tasks;
    }

    /**
     * 结束流程
     * @param processInstanceId 流程示例编号
     */
    public void endFlow(String processInstanceId) {
        try{
            runtimeService.deleteProcessInstance(processInstanceId,"");
        }catch (Exception e){
            log.error("service方法[FlowInfoService.endFlow]调用异常："+e, e);
            throw new ServiceException("FlowInfoService.endFlow", e);
        }
    }

}