flowable实现办结取回功能

已于 2024-04-03 15:18:51 修改
阅读量1.9k 收藏 8
点赞数 2
分类专栏： java开发 工作流 文章标签： flowable 工作流
于 2020-09-08 17:15:11 首次发布
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/unesco3187/article/details/108472667
版权 
package com.mei.flow.service;

import com.google.common.collect.Lists;
import com.mei.common.utils.SpringContextUtils;
import com.mei.common.utils.StringUtils;
import com.mei.flow.api.FlowService;
import com.mei.flow.config.EnumProcessDefine;
import com.mei.flow.constants.FlowConstants;
import lombok.extern.slf4j.Slf4j;
import ma.glasnost.orika.MapperFacade;
import org.flowable.bpmn.constants.BpmnXMLConstants;
import org.flowable.common.engine.impl.interceptor.Command;
import org.flowable.common.engine.impl.interceptor.CommandContext;
import org.flowable.engine.*;
import org.flowable.engine.history.HistoricActivityInstance;
import org.flowable.engine.impl.persistence.entity.*;
import org.flowable.engine.impl.util.CommandContextUtil;
import org.flowable.engine.repository.ProcessDefinition;
import org.flowable.engine.runtime.ProcessInstance;
import org.flowable.task.service.impl.persistence.entity.HistoricTaskInstanceEntityImpl;
import org.flowable.task.service.impl.persistence.entity.TaskEntityImpl;
import org.flowable.variable.api.history.HistoricVariableInstance;
import org.flowable.variable.service.impl.persistence.entity.HistoricVariableInstanceEntityImpl;
import org.flowable.variable.service.impl.persistence.entity.VariableInstanceEntity;
import org.flowable.variable.service.impl.persistence.entity.VariableInstanceEntityImpl;
import org.springframework.transaction.annotation.Transactional;

import java.io.Serializable;
import java.util.Iterator;
import java.util.List;

/**
 * @Author MR.MEI
 * @Description 办结取回
 * @Date 2020/07/10
 */
@Slf4j
public class FinishedCallBackCmd implements Command<Boolean>, Serializable {

    private static final long serialVersionUID = 1305995404093357323L;

    private String processInstanceId;

    public FinishedCallBackCmd(String processInstanceId) {
        this.processInstanceId = processInstanceId;
    }

    @Override
    @Transactional
    public Boolean execute(CommandContext commandContext) {
        if (StringUtils.isEmpty(processInstanceId)) {
            log.error("流程实例id不能为空");
            return false;
        }

        RuntimeService runtimeService = SpringContextUtils.getBean(RuntimeService.class);
        HistoryService historyService = SpringContextUtils.getBean(HistoryService.class);
        RepositoryService repositoryService = SpringContextUtils.getBean(RepositoryService.class);
        ManagementService managementService = SpringContextUtils.getBean(ManagementService.class);
        FlowService flowService = SpringContextUtils.getBean(FlowService.class);
        MapperFacade mapperFacade = SpringContextUtils.getBean(MapperFacade.class);

        ProcessInstance processInstance = runtimeService.createProcessInstanceQuery().processInstanceId(processInstanceId).singleResult();
        if (null != processInstance) {
            log.error("processInstanceId:{},流程还未结束,不能取回",processInstance);
            return false;
        }

        HistoricProcessInstanceEntityImpl instance = (HistoricProcessInstanceEntityImpl) historyService.createHistoricProcessInstanceQuery()
                .processInstanceId(processInstanceId).singleResult();

        if (null == instance) {
            log.error("流程实例未找到");
            return false;
        }

        // 取得流程定义
        ProcessDefinition definition = repositoryService.createProcessDefinitionQuery().processDefinitionId(instance.getProcessDefinitionId()).singleResult();
        if (definition == null) {
            log.error("流程定义未找到");
            return false;
        }


        // 获取结束前那一步环节任务
        HistoricTaskInstanceEntityImpl previousFinishedTask = (HistoricTaskInstanceEntityImpl) historyService.createHistoricTaskInstanceQuery()
                .processInstanceId(processInstanceId).orderByHistoricTaskInstanceEndTime().desc().list().get(0);

        if (null == previousFinishedTask) {
            return false;
        }

        String hisActivityInstanceTableName = managementService.getTableName(HistoricActivityInstance.class);

        //删除endEvent记录、删除sequenceFlow END_TIME_时间最大的记录
        flowService.removeLastApproveHisActInstance(processInstanceId);
		/*
        	1.更新act_hi_actinst表最后一个任务节点的END_TIME为null
        	2.重新组装act_ru_actinst表中的内容
         */
        String sql = "select * from " + hisActivityInstanceTableName + " where PROC_INST_ID_ = #{processInstanceId} and ACT_TYPE_ = #{actType} order by END_TIME_ desc";
        HistoricActivityInstanceEntityImpl historicActivityInstance = (HistoricActivityInstanceEntityImpl) historyService.createNativeHistoricActivityInstanceQuery().sql(sql)
                .parameter("processInstanceId", processInstanceId)
                .parameter("actType", BpmnXMLConstants.ELEMENT_TASK_USER).list().get(0);
        historicActivityInstance.setEndTime(null);
        historicActivityInstance.setDurationInMillis(null);
        CommandContextUtil.getHistoricActivityInstanceEntityManager().update(historicActivityInstance);

        String querySql = "select * from " + hisActivityInstanceTableName + " where PROC_INST_ID_ = #{processInstanceId} and ACT_TYPE_ != #{actType}";
        List<HistoricActivityInstance> historicActivityInstanceList = historyService.createNativeHistoricActivityInstanceQuery().sql(querySql)
                .parameter("processInstanceId", processInstanceId)
                .parameter("actType", BpmnXMLConstants.ELEMENT_EVENT_END).list();


        // 重新构造execution
        for (int i = 0; i < 2; i++) {
            ExecutionEntityImpl newExecution = new ExecutionEntityImpl();
            newExecution.setProcessDefinitionId(instance.getProcessDefinitionId());
            newExecution.setProcessInstanceId(instance.getId());
            newExecution.setActive(true); // 设置为激活状态
            newExecution.setSuspensionState(1);
            newExecution.setTenantId(instance.getTenantId());
            newExecution.setStartTime(instance.getStartTime());
            newExecution.setCountEnabled(true);
            newExecution.setDeploymentId(instance.getDeploymentId());
            newExecution.setRootProcessInstanceId(processInstanceId);
            if (i == 0) {
                newExecution.setId(instance.getId());
                newExecution.setBusinessKey(instance.getBusinessKey());
                newExecution.setRevision(1);
                newExecution.setScope(true);
                newExecution.setStartActivityId("startEvent1");
                newExecution.setTaskCount(0);
//                newExecution.setVariables(processVariables);
            } else {
                newExecution.setId(previousFinishedTask.getExecutionId());
                newExecution.setRevision(1);
                newExecution.setScope(false);
                newExecution.setParentId(instance.getId());
                newExecution.setTaskCount(1);
                newExecution.setActivityId(historicActivityInstance.getActivityId());
//                newExecution.setVariables(taskVariables);
            }
            CommandContextUtil.getExecutionEntityManager().insert(newExecution);
        }

        //根据历史活动实例创建运行时活动实例
        for (HistoricActivityInstance activityInstance : historicActivityInstanceList) {
            ActivityInstanceEntity activityInstanceEntity = new ActivityInstanceEntityImpl();
            mapperFacade.map(activityInstance, activityInstanceEntity);
            CommandContextUtil.getActivityInstanceEntityManager().insert(activityInstanceEntity);
        }

        //处理候选人信息
 /*       List<HistoricIdentityLink> historicIdentityLinks = historyService.getHistoricIdentityLinksForProcessInstance(processInstanceId);

        List<HistoricIdentityLink> historicIdentityLinksForTask = historyService.getHistoricIdentityLinksForTask(previousFinishedTask.getId());

        historicIdentityLinks.addAll(historicIdentityLinksForTask);

        for (HistoricIdentityLink historicIdentityLink : historicIdentityLinks) {
            IdentityLinkEntityImpl identityLinkEntity = mapperFacade.map(historicIdentityLink, IdentityLinkEntityImpl.class);
            CommandContextUtil.getIdentityLinkService().insertIdentityLink(identityLinkEntity);
        }*/

        //更新最后任务信息
        previousFinishedTask.setEndTime(null);
        previousFinishedTask.setDurationInMillis(null);
        CommandContextUtil.getHistoricTaskService().updateHistoricTask(previousFinishedTask, false);

        // 重新构造运行任务
        TaskEntityImpl newTask = new TaskEntityImpl();
//        TaskEntityImpl newTask = (TaskEntityImpl) taskService.newTask();
        newTask.setId(previousFinishedTask.getId());
        newTask.setRevision(1);
        newTask.setExecutionId(previousFinishedTask.getExecutionId());
        newTask.setProcessInstanceId(previousFinishedTask.getProcessInstanceId());
        newTask.setProcessDefinitionId(previousFinishedTask.getProcessDefinitionId());
        newTask.setName(previousFinishedTask.getName());
        newTask.setTaskDefinitionKey(previousFinishedTask.getTaskDefinitionKey());
        newTask.setClaimTime(previousFinishedTask.getClaimTime());
        newTask.setAssignee(previousFinishedTask.getAssignee());
        newTask.setPriority(previousFinishedTask.getPriority());
        newTask.setCreateTime(previousFinishedTask.getCreateTime());
        newTask.setSuspensionState(1);
        newTask.setTenantId(instance.getTenantId());
        newTask.setCountEnabled(true);
        List<HistoricVariableInstance> historicVariableInstances = historyService.createHistoricVariableInstanceQuery()
                .processInstanceId(processInstanceId)
                .taskId(newTask.getId()).list();
        newTask.setVariableCount(historicVariableInstances.size());
        newTask.setIdentityLinkCount(0);
//        newTask.setIdentityLinkCount(historyService.getHistoricIdentityLinksForTask(newTask.getId()).size());
        CommandContextUtil.getTaskService().insertTask(newTask, true);

        // 置空实例部分信息
        instance.setEndTime(null);
        instance.setEndActivityId(null);
        instance.setDeleteReason(null);
        instance.setDurationInMillis(null);
        CommandContextUtil.getDbSqlSession().update(instance);

        //获取流程相关变量
        List<HistoricVariableInstance> processHistoricVariables = historyService.createHistoricVariableInstanceQuery()
                .processInstanceId(instance.getProcessInstanceId()).list();

        // 删除历史实例变量
        if (processHistoricVariables != null && processHistoricVariables.size() > 0) {
            for (Iterator<HistoricVariableInstance> iterator = processHistoricVariables.iterator(); iterator.hasNext(); ) {
                HistoricVariableInstanceEntityImpl historicVariable = (HistoricVariableInstanceEntityImpl) iterator.next();
                if(StringUtils.isEmpty(historicVariable.getTaskId())){
                    if (allowToAdd(historicVariable, definition)) {
                        VariableInstanceEntity variableInstanceEntity = new VariableInstanceEntityImpl();
                        variableInstanceEntity.setId(historicVariable.getId());
                        variableInstanceEntity.setType(historicVariable.getVariableType());
                        variableInstanceEntity.setName(historicVariable.getName());
                        variableInstanceEntity.setExecutionId(processInstanceId);
                        variableInstanceEntity.setProcessInstanceId(processInstanceId);
                        variableInstanceEntity.setValue(historicVariable.getValue());
                        org.flowable.task.service.impl.util.CommandContextUtil.getVariableInstanceEntityManager().insert(variableInstanceEntity);
                    }
                }
//                CommandContextUtil.getHistoricVariableService().deleteHistoricVariableInstance(historicVariable);
            }
        }

        //获取任务相关变量
        List<HistoricVariableInstance> taskHistoricVariables = historyService.createHistoricVariableInstanceQuery()
                .processInstanceId(instance.getProcessInstanceId()).taskId(previousFinishedTask.getId()).list();
        if (taskHistoricVariables != null && taskHistoricVariables.size() > 0) {
            for (Iterator<HistoricVariableInstance> iterator = taskHistoricVariables.iterator(); iterator.hasNext(); ) {
                HistoricVariableInstanceEntityImpl historicVariable = (HistoricVariableInstanceEntityImpl) iterator.next();

                if (allowToAdd(historicVariable, definition)) {
                    VariableInstanceEntity variableInstanceEntity = new VariableInstanceEntityImpl();
                    variableInstanceEntity.setId(historicVariable.getId());
                    variableInstanceEntity.setType(historicVariable.getVariableType());
                    variableInstanceEntity.setName(historicVariable.getName());
                    variableInstanceEntity.setExecutionId(previousFinishedTask.getExecutionId());
                    variableInstanceEntity.setProcessInstanceId(processInstanceId);
                    variableInstanceEntity.setTaskId(previousFinishedTask.getId());
                    variableInstanceEntity.setValue(historicVariable.getValue());
                    org.flowable.task.service.impl.util.CommandContextUtil.getVariableInstanceEntityManager().insert(variableInstanceEntity);
                }
//                    CommandContextUtil.getHistoricVariableService().deleteHistoricVariableInstance(historicVariable);
            }
        }
        return true;
    }

    private boolean allowToAdd(HistoricVariableInstanceEntityImpl historicVariable, ProcessDefinition definition) {
        if (null == historicVariable.getValue()) {
            CommandContextUtil.getHistoricVariableService().deleteHistoricVariableInstance(historicVariable);
        }
        List<String> notAllowToAddList = Lists.newArrayList();
        notAllowToAddList.add(FlowConstants.FLOW_FILTER_KEY_HANDLE_TIME);
        notAllowToAddList.add(FlowConstants.TASK_AUDIT_STATUS);
        if (EnumProcessDefine.PRO_TASK_FLOW_KEY.getCode().equals(definition.getKey())) {
            notAllowToAddList.add("flowBizProcurementResultData");
            notAllowToAddList.add("filterEntryProcurementResultTime");
        }
        if (null != historicVariable.getValue() && !notAllowToAddList.contains(historicVariable.getName())) {
            return true;
        } else {
            CommandContextUtil.getHistoricVariableService().deleteHistoricVariableInstance(historicVariable);
            return false;
        }
    }
}

贴出一些封装的方法
//删除endEvent记录、删除sequenceFlow END_TIME_时间最大的记录
flowService.removeLastApproveHisActInstance(processInstanceId);

    public void removeLastApproveHisActInstance(String processInstanceId) {
        flowMapper.deleteHistoricActivityInstanceByProcessInstanceIdAndActType(processInstanceId, BpmnXMLConstants.ELEMENT_EVENT_END);
        String sql = "select * from act_hi_actinst where PROC_INST_ID_ = #{processInstanceId} and ACT_TYPE_ = #{actType} order by END_TIME_ desc";
        HistoricActivityInstance historicActivityInstance = historyService.createNativeHistoricActivityInstanceQuery().sql(sql)
                .parameter("processInstanceId", processInstanceId)
                .parameter("actType", BpmnXMLConstants.ELEMENT_SEQUENCE_FLOW).list().get(0);
        flowMapper.deleteHistoricActivityInstanceById(historicActivityInstance.getId());
    }

单元测试代码：

   @Test
    public void finishCallBack(){
        FinishedCallBackCmd callBack = new FinishedCallBackCmd("c9c2d598-c0f9-11ea-8147-00ff1bb9adc3");
        processEngine.getProcessEngineConfiguration().getCommandExecutor().execute(callBack);
    }

我是梅先生
关注
专栏目录
Flowable工作流之任务回退
桐花思雨
10-30 5840
有的时候，一个任务节点会存在多个候选人，例如 提交一个任务，这个任务既可以 处理，又可以 处理，当一个候选人认领任务之后，但是又不想处理任务了，此时我们可以将任务回退，那么针对这种情况，我们该如何处理？今天一起来看看我们先从最简单的串行流程来分析，案例流程图如下 完整的 文件内容 上面的流程就是一个非常简单的串行任务，定义了 个用户任务，使用变量来指派处理人分别是 ，在流程的执行过程中我们可以通过回退来演示具体的效果
工作流引擎设计之取回任务定义
碧荷故乡_胡奇的专栏
07-25 2637
取回（Withdraw Work Item）取回是针对本人的“已办任务”的操作，即取回已办任务。何谓取回：参与者提交任务后，发现自己办理此任务有误或不应该立刻提交等情况，需要将此已办理完成的任务取回重新办理或稍后再提交。取回原则：执行取回以不影响其他执行者已经办理的任务及下一步参与者已经完成的工作为基本指导原则。如果前活动仍在执行状态，即下一步活动还没有被激活，则只要流程定义允许，任务
flowable查询流程实例信息和已处理任务
最新发布
猿脑2.0的博客
08-21 792
在Flowable中查询流程办理记录，通常指的是查询流程实例的历史活动（HistoricActivityInstance）和任务历史（HistoricTaskInstance）。这些记录包含了流程执行过程中的关键信息，如任务的执行人、执行时间、流程状态等。
Flowable 任务如何认领，回退？
江南一点雨的专栏
10-11 3419
上篇文章松哥和大家分享了 Flowable 中设置任务处理人的四种方式，不过那四种方式都是针对单个任务处理人，有的时候，一个任务节点会存在多个候选人，例如 zhangsan 提交一个任务，这个任务即可以 lisi 处理，又可以 wangwu 处理，那么针对这种多个任务候选人的情况，我们该如何处理？其实思路很简答，就是重新为任务设置处理人，且处理人为 null，这就是将任务回退了，接下来其他人可以重新认领该任务了。另外一种常见的需求就是，已经知道了要处理的流程实例了，但是不知道应该由谁来处理，此时通过查询。
工作流体系----审批提交后快速取回（9）
Thubier
09-10 611
当我们在审批事项时，可能存在细节错误。这时工作流产品应该提供特定场景下的取回功能。
【笔记】Flowable工作流重启已经结束的流程
努力，学习！
06-30 2425
在Flowable中，流程实例的名称（process instance name）是一个可选的属性，并且不会自动从历史流程实例中继承。如果你需要将已终止的流程实例重新激活，可以创建一个新的流程实例，或者使用历史流程实例中的数据进行修复。请注意，如果重新发起的流程实例需要使用历史流程实例的数据作为变量的值，你需要根据业务需求将这些数据复制到新的流程实例中。请注意，重新发起的新流程实例与原始已终止的流程实例是独立的。当你重新发起一个新的流程实例时，新的流程实例将被视为全新的实例，其。
工作流flowable任务退回（任务跳转）、任务重新触发、任务删除的实现
IccBoY_超越
01-08 7566
在进行flowable工作流的运用中，会涉及到任务的的一些特殊操作，如：退回，跳转，删除，重新触发等
Flowable-6.3.1
07-10
Flowable是Activiti原班主创人员从Activiti分离出来的一套工作流引擎，是一个业务流程管理(BPM)和工作流系统，适用于开发人员和系统管理员。其核心是超快速、稳定的BPMN2流程引擎，易于与 Spring集成使用。 Flowable...
Springboot+Flowable 实现工作流开发流程.docx
12-11
在本文中，我们将深入探讨如何使用SpringBoot和Flowable实现工作流开发流程。SpringBoot是一个流行的Java框架，它简化了微服务和Web应用的构建，而Flowable则是一个强大的业务流程管理(BPM)和工作流引擎，适用于企业...
flowable实现转交功能
05-16
在Flowable中实现转交功能，可以通过以下步骤来完成： 1. 定义一个用户任务，并指定任务的候选人或候选组。 2. 当任务被分配给用户后，可以使用Flowable提供的API将任务转交给其他用户。可以通过以下代码实现： ``...
flowable实现抄送功能
11-15
Flowable提供了丰富的API和工具，可以轻松地实现各种工作流场景，包括抄送功能。 实现抄送功能的一种方法是使用Flowable提供的事件机制。当任务被创建或完成时，可以触发事件并将抄送人添加到任务中。以下是一个...
基于jeecgboot-vue3的Flowable流程--抄送我的功能
宁波阿成的博客
06-11 446
基于jeecgboot-vue3的Flowable流程--抄送我的功能
基于jeecg-boot的flowable流程收回功能实现（全网首创功能）
宁波阿成的博客
08-20 1500
基于jeecg-boot的flowable流程收回功能实现（全网首创功能）
Flowable入门系列文章73 - 历史 01
分享牛
12-02 946
flowable入门、flowable现状、flowable开源产品、flwoable入门系列、flowable课程、flowable与activiti区别 Flowable是用Java编写的轻量级业务流程引擎。Flowable流程引擎允许您部署BPMN 2.0流程定义（用于定义流程的行业XML标准），创建 流程定义的流程实例，运行查询，访问活动或历史流程实例以及相关数据等等。本节将逐步介绍各种概念和API，通过您可以在自己的开发 机器上进行的实例进行实现。
flowable删除组成员
随风往事
02-19 496
【代码】flowable删除组成员。
基于jeecgboot的flowable流程增加节点表单的支持（三）
宁波阿成的博客
10-17 627
基于jeecgboot的flowable流程增加节点表单的支持（三） 在流程流转过程中增加节点表单的后端修改
Activiti进阶（四）——流程变量的设置和获取
时光匆匆独白 将颠沛磨成卡带
06-30 713
流程变量在整个工作流中扮演很重要的作用。例如：请假流程中有请假天数、请假原因等一些参数都为流程变量的范围。流程变量的作用域范围是只对应一个流程实例。也就是说各个流程实例的流程变量是不相互影响的。这篇博文就简单的为大家介绍下流程变量的设置和获取。      一、设置流程变量      流程变量的设置方式有两种，一是通过基本类型设置，第二种是通过JavaBean类型
Flowable实战（二）：表结构以及变量表单介绍
FeiChangWuRao的博客
08-13 5802
发现很多教程很乱，有的是浅尝则止比如说就是一个demo就完事了，有的是比较乱，可能是之前使用过别的工作流，很多东西就直接带过，看的云里雾里的。比如说一些名词，都不清楚怎么回事。这里发现还是官方的文档不错，这里推荐一个材料是一个flowable的中文文档，涉及到的比较全面，不一定全看，但是可以当工具书一样查找使用。...
flowable中反序列化流程变量失败Couldn‘t deserialize object in variable ‘xxxx‘
forgetmetoo的博客
08-03 4534
flowable中反序列化流程变量失败Couldn't deserialize object in variable 'xxxx' 项目中使用flowable来进行自动化流程，需要将每个步骤执行的结果使用流程变量来保存，由于数据类型未知，采用fastjson来保存对象变量，使用flowable的api进行变量存储： Map<String, Object> rootNodeMap = new HashMap<>(); String responseNode = "response";
评论 10
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值