工作流的向前加签向后加签

已于 2023-05-29 18:54:48 修改
阅读量1.6k 收藏 3
点赞数 2
分类专栏： 工作流 文章标签： java android spring
于 2022-12-30 18:08:50 首次发布
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/weixin_41118077/article/details/128497847
版权

提示：文章写完后，目录可以自动生成，如何生成可参考右边的帮助文档

向前加签向后加签

前言

公司业务要求需要加个向前加签 向后加签的功能，可难为死我小时了，只听过说加签转签 还有向前加签。

一、解决思路

向前加签：向前加一个节点 把当前节点数据删除 将新生成的节点置换到当前实例中
向后加签：向后加一个节点
既然是加节点 flowable 有动态修改节点的功能 参考 flowable 中的 InjectUserTaskInProcessInstanceCmd

二、代码

package com.process.commnd; /**
 * Created by Administrator on 2020/4/8.
 */

import org.apache.commons.lang3.StringUtils;
import org.flowable.bpmn.BpmnAutoLayout;
import org.flowable.bpmn.model.Process;
import org.flowable.bpmn.model.*;
import org.flowable.common.engine.impl.interceptor.Command;
import org.flowable.common.engine.impl.interceptor.CommandContext;
import org.flowable.engine.impl.cmd.AbstractDynamicInjectionCmd;
import org.flowable.engine.impl.context.Context;
import org.flowable.engine.impl.dynamic.BaseDynamicSubProcessInjectUtil;
import org.flowable.engine.impl.dynamic.DynamicUserTaskBuilder;
import org.flowable.engine.impl.persistence.entity.*;
import org.flowable.engine.impl.util.CommandContextUtil;
import org.flowable.engine.impl.util.ProcessDefinitionUtil;
import org.flowable.job.service.JobService;
import org.flowable.task.service.HistoricTaskService;
import org.flowable.task.service.impl.persistence.entity.HistoricTaskInstanceEntity;
import org.flowable.task.service.impl.persistence.entity.TaskEntity;
import org.flowable.variable.service.VariableService;
import org.springframework.beans.BeanUtils;

import java.util.*;

/**
 * 加签根据flag 区分是向前加 还是向后加
 * @author : shiyushan
 * @date : 2020/10/18 14:46
 */
public class CustomInjectUserTaskInProcessInstanceCmd extends AbstractDynamicInjectionCmd implements Command<Void> {

    protected String processInstanceId;
    protected DynamicUserTaskBuilder dynamicUserTaskBuilder;
    protected Boolean flag;
    protected String currentActivityId;
    protected String formKey;
    protected FlowElement currentFlowElement;


    public CustomInjectUserTaskInProcessInstanceCmd(String processInstanceId, Boolean flag, DynamicUserTaskBuilder dynamicUserTaskBuilder,
                                                    String currentActivityId,String formKey) {
        this.processInstanceId = processInstanceId;
        this.dynamicUserTaskBuilder = dynamicUserTaskBuilder;
        this.currentActivityId = currentActivityId;
        this.flag = flag;
        this.formKey = formKey;
    }

    @Override
    public Void execute(CommandContext commandContext) {
        createDerivedProcessDefinitionForProcessInstance(commandContext, processInstanceId);
        return null;
    }

    @Override
    protected void updateBpmnProcess(CommandContext commandContext, Process process,
                                     BpmnModel bpmnModel, ProcessDefinitionEntity originalProcessDefinitionEntity, DeploymentEntity newDeploymentEntity) {
        this.currentFlowElement = process.getFlowElement(currentActivityId);
        StartEvent initialStartEvent = getStartEvent(process);
        if (currentFlowElement != null) {
            UserTask userTask = getUserTask(process);
            if (flag) {
                addAfter(userTask, process);
            } else {
                addBefore(userTask, process);
            }
            addPoint(bpmnModel, initialStartEvent);
        }

        BaseDynamicSubProcessInjectUtil.processFlowElements(commandContext, process, bpmnModel, originalProcessDefinitionEntity, newDeploymentEntity);
    }

    /**
     * 根据当前节点获取一个新的节点
     * 并设置新节点的处理人为被加签人
     * @param process
     * @return
     */
    private UserTask getUserTask(Process process) {
        UserTask userTask = new UserTask();
        BeanUtils.copyProperties(this.currentFlowElement, userTask);
        if (dynamicUserTaskBuilder.getId() != null) {
            userTask.setId(dynamicUserTaskBuilder.getId());
        } else {
            userTask.setId(dynamicUserTaskBuilder.nextTaskId(process.getFlowElementMap()));
        }
        dynamicUserTaskBuilder.setDynamicTaskId(userTask.getId());
        userTask.setFormKey(formKey);
        userTask.setName(dynamicUserTaskBuilder.getName());
        userTask.setAssignee(dynamicUserTaskBuilder.getAssignee());
        userTask.setCandidateUsers(new ArrayList<>());
        userTask.setCandidateGroups(new ArrayList<>());
        return userTask;
    }

    /**
     * 向前加签
     * 当前节点向前加线
     * 给新任务节点设置出口跟入口
     * @param userTask
     * @param process
     */
    private void addBefore(UserTask userTask, Process process) {
        UserTask currentFlowElement = (UserTask) this.currentFlowElement;

        List<SequenceFlow> outgoingFlows = new ArrayList<>();
        SequenceFlow outgoingFlow = new SequenceFlow(userTask.getId(), currentFlowElement.getId());
        outgoingFlow.setId("seq_" + UUID.randomUUID());
        outgoingFlows.add(outgoingFlow);
        process.addFlowElement(outgoingFlow);

        List<SequenceFlow> incomingFlows = new ArrayList<>();
        for (SequenceFlow sequenceFlow1 : currentFlowElement.getIncomingFlows()) {
            SequenceFlow sequenceFlow = new SequenceFlow(sequenceFlow1.getSourceRef(),userTask.getId());
            incomingFlows.add(getSequence(sequenceFlow, incomingFlows, sequenceFlow1));
            //删除原先节点的入线
            process.removeFlowElement(sequenceFlow1.getId());
            process.addFlowElement(sequenceFlow);
        }

        userTask.setOutgoingFlows(outgoingFlows);
        userTask.setIncomingFlows(incomingFlows);
        process.addFlowElement(userTask);
    }


    /**
     * 向后加签
     * 当前节点向后加线
     * 给新任务节点设置出口跟入口
     * @param userTask
     * @param process
     */
    private void addAfter(UserTask userTask, Process process) {
        UserTask currentFlowElement = (UserTask) this.currentFlowElement;
        List<SequenceFlow> outgoingFlows = new ArrayList<>();
        for (SequenceFlow sequenceFlow1 : currentFlowElement.getOutgoingFlows()) {
            SequenceFlow sequenceFlow = new SequenceFlow( userTask.getId(),sequenceFlow1.getTargetRef());
            outgoingFlows.add(getSequence(sequenceFlow, outgoingFlows, sequenceFlow1));
            //删除原先节点的出线
            process.removeFlowElement(sequenceFlow1.getId());
            process.addFlowElement(sequenceFlow);
        }

        List<SequenceFlow> incomingFlows = new ArrayList<>();
        SequenceFlow incomingFlow = new SequenceFlow(currentFlowElement.getId(), userTask.getId());
        incomingFlow.setId("seq_" + UUID.randomUUID());
        incomingFlows.add(incomingFlow);
        process.addFlowElement(incomingFlow);

        userTask.setOutgoingFlows(outgoingFlows);
        userTask.setIncomingFlows(incomingFlows);
        process.addFlowElement(userTask);
    }

    /**
     * 组装新连线
     *
     * @param sequenceFlow
     * @param incomingFlows
     * @param sequenceFlow1
     */
    private SequenceFlow getSequence(SequenceFlow sequenceFlow, List<SequenceFlow> incomingFlows, SequenceFlow sequenceFlow1) {
        sequenceFlow.setSkipExpression(sequenceFlow1.getSkipExpression());
        sequenceFlow.setConditionExpression(sequenceFlow1.getConditionExpression());
        sequenceFlow.setExtensionElements(sequenceFlow1.getExtensionElements());
        sequenceFlow.setExecutionListeners(sequenceFlow1.getExecutionListeners());
        sequenceFlow.setName(sequenceFlow1.getName());
        sequenceFlow.setId("seq_" + UUID.randomUUID());
        return sequenceFlow;
    }


    /**
     * 新增坐标点
     *
     * @param bpmnModel
     * @param initialStartEvent
     */
    private void addPoint(BpmnModel bpmnModel, StartEvent initialStartEvent) {
        GraphicInfo elementGraphicInfo = bpmnModel.getGraphicInfo(currentFlowElement.getId());
        if (elementGraphicInfo != null) {
            double yDiff = 0;
            double xDiff = 80;
            if (elementGraphicInfo.getY() < 173) {
                yDiff = 173 - elementGraphicInfo.getY();
                elementGraphicInfo.setY(173);
            }

            Map<String, GraphicInfo> locationMap = bpmnModel.getLocationMap();
            for (String locationId : locationMap.keySet()) {
                if (initialStartEvent.getId().equals(locationId)) {
                    continue;
                }

                GraphicInfo locationGraphicInfo = locationMap.get(locationId);
                locationGraphicInfo.setX(locationGraphicInfo.getX() + xDiff);
                locationGraphicInfo.setY(locationGraphicInfo.getY() + yDiff);
            }

            Map<String, List<GraphicInfo>> flowLocationMap = bpmnModel.getFlowLocationMap();
            for (String flowId : flowLocationMap.keySet()) {

                List<GraphicInfo> flowGraphicInfoList = flowLocationMap.get(flowId);
                for (GraphicInfo flowGraphicInfo : flowGraphicInfoList) {
                    flowGraphicInfo.setX(flowGraphicInfo.getX() + xDiff);
                    flowGraphicInfo.setY(flowGraphicInfo.getY() + yDiff);

                }
            }
            new BpmnAutoLayout(bpmnModel).execute();
        }
    }

    /**
     * 得到开始节点
     * @param process
     * @return
     * @author: shiyushan
     * @version: 1.0.0
     * @date: 2023/1/2 6:57 下午
     */
    private StartEvent getStartEvent(Process process) {
        List<StartEvent> startEvents = process.findFlowElementsOfType(StartEvent.class);
        StartEvent initialStartEvent = null;
        for (StartEvent startEvent : startEvents) {
            if (startEvent.getEventDefinitions().size() == 0) {
                initialStartEvent = startEvent;
                break;

            } else if (initialStartEvent == null) {
                initialStartEvent = startEvent;
            }
        }
        return initialStartEvent;
    }

    @Override
    protected void updateExecutions(CommandContext commandContext, ProcessDefinitionEntity processDefinitionEntity,
                                    ExecutionEntity processInstance, List<ExecutionEntity> childExecutions) {

        ExecutionEntityManager executionEntityManager = CommandContextUtil.getExecutionEntityManager(commandContext);
        VariableService variableService = CommandContextUtil.getVariableService(commandContext);
        JobService jobService = CommandContextUtil.getJobService(commandContext);

        BpmnModel bpmnModel = ProcessDefinitionUtil.getBpmnModel(processDefinitionEntity.getId());

        ActivityInstanceEntityManager manager = CommandContextUtil.getActivityInstanceEntityManager();
        org.flowable.task.service.TaskService taskService = CommandContextUtil.getTaskService(commandContext);
         HistoricTaskService historicTaskService = CommandContextUtil.getHistoricTaskService(commandContext);

        List<TaskEntity> taskEntities = taskService.findTasksByProcessInstanceId(processInstanceId);
        if (!flag) {
            ExecutionEntity execution = executionEntityManager.createChildExecution(processInstance);
            execution.setVariable("assigneeList_"+dynamicUserTaskBuilder.getId(), Arrays.asList(dynamicUserTaskBuilder.getAssignee()));
            ActivityInstanceEntity activityInstance = manager.findUnfinishedActivityInstance(execution);
            // 删除当前活动任务
            String parentId ="";
            for (TaskEntity taskEntity : taskEntities) {
                taskEntity.getIdentityLinks().stream().forEach(identityLinkEntity -> {
                    taskEntity.deleteUserIdentityLink(identityLinkEntity.getUserId(), "candidate");
                    taskEntity.deleteUserIdentityLink(identityLinkEntity.getUserId(), "participant");
                });
                if (taskEntity.getTaskDefinitionKey().equals(currentFlowElement.getId())) {
                    taskService.deleteTask(taskEntity, true);
                }

              //得到父级实例
                ExecutionEntity executionEntity = executionEntityManager.findById(taskEntity.getExecutionId());
                parentId = executionEntity.getParentId();
            }
            //删除相关联的实例 特别注意如果是会签另一个实例已同意所以进程未删除
            if (StringUtils.isNotBlank(parentId)) {
                ExecutionEntity parentExecution = executionEntityManager.findById(parentId);
                List<ExecutionEntity> executions = executionEntityManager.findChildExecutionsByParentExecutionId(parentId);
                for (ExecutionEntity childExecution : executions) {
                    if (!childExecution.getId().equals(execution.getId())) {
                        jobService.deleteJobsByExecutionId(childExecution.getId());
                        variableService.deleteVariablesByExecutionId(childExecution.getId());
                        executionEntityManager.delete(childExecution);
                    }
                }
                if (StringUtils.isNotBlank(parentExecution.getActivityId())) {
                    jobService.deleteJobsByExecutionId(parentExecution.getId());
                    variableService.deleteVariablesByExecutionId(parentExecution.getId());
                    executionEntityManager.delete(parentExecution);
                    System.out.println("删除父实例");
                }
            }

            List<HistoricTaskInstanceEntity> historyList = historicTaskService.findHistoricTasksByProcessInstanceId(execution.getProcessInstanceId());
            for (HistoricTaskInstanceEntity history : historyList) {
                if (history.getTaskDefinitionKey().equals(currentFlowElement.getId())) {
                    history.setDeleteReason("加签被删除");
                    history.setEndTime(new Date());
                    historicTaskService.updateHistoricTask(history,false);
                }
            }
            //任务节点结束
            if (activityInstance!=null) {
                activityInstance.setEndTime(new Date());
                manager.update(activityInstance);
            }
            //设置活动后的节点
            UserTask userTask = (UserTask) bpmnModel.getProcessById(processDefinitionEntity.getKey()).getFlowElement(dynamicUserTaskBuilder.getId());
            execution.setCurrentFlowElement(userTask);
            Context.getAgenda().planContinueProcessOperation(execution);
        }else {
            processInstance.setVariable("assigneeList_"+dynamicUserTaskBuilder.getId(), Arrays.asList(dynamicUserTaskBuilder.getAssignee()));
        }
    }
}

测试

    @Autowired
    protected ManagementService managementService;
        private void addSign(WfSignPo vo,FlowEnum type) {
        managementService.executeCommand(new CustomInjectUserTaskInProcessInstanceCmd(task.getProcessInstanceId(), flag, dynamicUserTaskBuilder, task.getTaskDefinitionKey()));
    }
稻草@613
关注
  • 2
    点赞
  • 踩
  • 3
    收藏
    觉得还不错? 一键收藏
  • 1
    评论
专栏目录
Flowable工作流之加签（委派）、转签（转办）
桐花思雨
10-31 1万+
顾名思义就是增加一道审批签名，这道审批往往是临时增加的，标准流程没有规定要走的在现实工作流程中，加签功能使用率颇高；有时，审批人对内容不太确定，不太敢做主，就会找更高层的领导进行加签；这样就可以规避个人风险；出问题大家一起担。有时为了表示对领导尊重，或者让领导知道这回事，也需要使用加签功能任务在 这里， 这个时候需要 核对一下，等 核对之后又回到 这里，这时 才能继续自己的任务任务在 这里， 这个时候需要 处理这个事情，处理完毕之后就不用管了，继续后面的审批环节完成后的流程图如下 文件内容
勇者斗恶龙11 游戏 流行壁纸 高清 新标签 主题-crx插件
04-06
这种古朴在经历了多年打磨设计后，终究没有成为古板，而是继承了系列作品的诸多优点，保留着自己最精华的部分，怀揣着勇气与梦想顺着时代向前迈进。我们从该系列的所有游戏中收集了高清背景。你会发现游戏中所有角色...
工作流实战_21_flowable 加签 任务向前加签 向后加签
Gblfy_Blog
12-12 5178
项目地址：https://gitee.com/lwj/flowable.git 分支flowable-base 视频讲解地址 https://www.bilibili.com/video/av78471660/ 加签：同时让多人处理任务 1、向前加签 任务在A这里，A这个时候需要BCD核对一下，等BCD核对之后又回到A这里 2、向后加签 任务在A这里，A这个时候需要BCD处理这个事情，处理完毕之后...
21.flowable 加签 向前加签 向后加签
热门推荐
liuwenjun05101的博客
12-08 1万+
项目地址：https://gitee.com/lwj/flowable.git 分支flowable-base 视频讲解地址 https://www.bilibili.com/video/av78471660/ 加签：同时让多人处理任务 1、向前加签 任务在A这里，A这个时候需要BCD核对一下，等BCD核对之后又回到A这里 2、向后加签 任务在A这里，A这个时候需要BCD处理这个事情，处理完毕之后...
工作流——加签功能详解
weixin_30470643的博客
06-17 1546
　　加签：顾名思义就是增加一道审批签名，这个道审批往往是临时增加的，标准流程没有规定要走的。　 　　在现实工作流程中，加签功能使用率颇高；有时，审批人对内容不太确定，不太敢做主，就会找更高层的领导进行加签；这样就可以规避个人风险；出问题大家一起担。有时为了表示对领导尊重，或者让领导知道这回事，也需要使用加签功能。加签功能也许是中国特色吧。 　　由于这个加签功能，本来就是不在标准流程中...
【flowable】十一、flowable加签和转签
return
10-23 3990
flowable加签和转签同时让多人处理任务，但是不同于网关操作。1、向前加签 任务在A这里，A这个时候需要BCD核对一下，等BCD核对之后又回到A这里 2、向后加签 任务在A这里，A这个时候需要BCD处理这个事情，处理完毕之后就不用管了，继续后面的审批环节创建一个新的流程：就一个简单的流程，员工请假申请，总经理审批 部署流程并启动： 员工完成任务： 正常流程，员工完成任务后到总经理审批但，实际中会出现特殊情况，还需要董事长审批，但在流程设计中并没有董事长这个流程节点。所以需要用到加签的功能。加签功能 任
Excel公式与函数大辞典.宋翔(带书签高清文字版).pdf
03-02
3.5.6 EOMONTH——计算从指定日期向前或向后几个月后的那个月最后一天的日期 140 3.5.7 NETWORKDAYS——计算日期间的所有工作日数 141 3.5.8 NETWORKDAYS.INTL——计算日期间的所有工作日数，使用参数指明周末的...
Pycharm for Mac 快捷键中文版
05-24
* ⇧⌘ ⌨：向后 / 向前导航 * ⌘ [ / ⌘ ]：转到上一个 / 下一个方法 * ⌃ ↑ / ⌃ ↓：转到行 / 列… * ⌘ L：转到代码块结束 / 开始 * ⌥ ⌘ ] / ⌥ ⌘ [：添加到收藏夹 * ⌥ ⇧ F：切换书签 * ...
Pycharm的一些快捷键使用，方便整理
最新发布
01-12
PyCharm 快捷键使用指南 PyCharm 作为一款功能强大且流行的集成开发环境（IDE），其快捷键的...* 向后导航 / 向前 Ctrl + Alt + Left / Right * 转到上一个 / 下一个方法 Alt + Up / Down * 转到行 / 列... Ctrl + G
openwebflow：基于Activiti的工作流引擎扩展，接管了Activiti对活动权限以及用户表的管理，并提供了催办，代办，加签（包括前加签后加签），自由迁移，划分分组等功能
02-03
什么是OpenWebFlow OpenWebFlow是基于Activiti（官方网站 ，代码托管在 ）扩展的工作流引擎，其扩展的功能包括： 完全接管了Activiti对活动（activity）权限的管理。Activiti允许在设计模型的时候指定每个活动的执行权限，但是，业务系统可能需要根据实际情况动态设置这些任务的执行权限（如：动态的组）。OpenWebFlow完全实现了与流程定义阶段的解压缩，即用户对活动的访问控制信息单独管理（而不是在流程定义中预先写死），这样有利于动态调整权限，详见； 完全接管了Activiti对用户表（IDENTITY_XXX表）的管理。在标准的工作流定义中，每个队列
【专题讲解】工作流引擎会签，加签，主持人，组长模式专题讲解.docx
04-11
ccflow工作流，开源工作流引擎
jbpm工作流（会签，串签）
06-13
jbpm的流程部署 流程开始 任务提交 查询已办，待办
jBPM4.4 会签（带加签、减签功能）
09-03
jBPM4.4 会签（带加签、减签功能），通过查找资料，个人摸索，利用task节点实现了会签功能，加签、减签功能是我自己摸索出来的，是不是能满足大家的需求，仅供参考。
工作流 （跳转，加签）
wq123123423432的博客
03-27 1257
flowable与activiti 的跳转，加签可以通过以下方式处理 1 executionEntity.setCurrentFlowElement(targetFlowElement); commandContext.getCurrentEngineConfiguration() .getEventDispatcher() .dispatchEvent(FlowableEventBuilder.createEntityEvent(FlowableEngineEven
flwoable如何实现后加签（动态添加节点）
nixzmdi1的专栏
05-28 9092
flowable的功能基本都是基于命令模式实现的，flowalble提供了一个方法，可以调用我们自己编写的命令。 ManagementService managementService;这个service里有个executeCommand方法 入参为Command，今天就是基于这个方法来实现后加签的。有兴趣的同学还可以看下这个service的其它方法。 AbstractDynamicInjectionCmd 由flowable提供的基础命令，修改流程的基类。 下面是实现后加签的命令源码 自定义后加签c
基于jeecg-boot的flowable流程加签功能实现
宁波阿成的博客
08-22 1536
基于jeecg-boot的flowable流程加签功能实现
c#版工作流之加签（9）
Thubier
09-23 297
审批加签，主要的目的是解决审批过程中审批业务需要系统配置之外的人员参与时，提供给业务人员的一种操作可能，使具体业务能基于现实需求完成相关审签。
flowable前后加签
10-17
在Flowable中，加签和前后加签都可以通过动态修改流程定义来实现。具体来说，可以通过以下步骤实现： 1. 定义一个用户任务节点，作为加签节点。 2. 在需要加签的地方，使用Flowable API动态修改流程定义，将原本的任务节点替换为加签节点。 3. 在加签节点中，使用Flowable API动态添加新的任务节点，作为加签的人员。 4. 在加签人员完成任务后，使用Flowable API动态修改流程定义，将加签节点替换为原本的任务节点。 具体实现可以参考Flowable官方文档中的例子：https://www.flowable.com/open-source/docs/bpmn/ch15-Extensions/#_dynamic_user_task_creation

“相关推荐”对你有帮助么？

  • 非常没帮助
  • 没帮助
  • 一般
  • 有帮助
  • 非常有帮助
提交
评论 1
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值