Flowable之任务撤回（支持主流程、子流程相互撤回）

已于 2024-10-07 21:08:21 修改
阅读量1.8k 收藏 12
点赞数 9
文章标签： windows
于 2024-10-01 18:37:29 首次发布
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/mxskymx/article/details/142673282
版权

撤回任务：主流程 > 主流程

处室主管【送科长审核】

处室主管【撤回科长审核】

流程日志

撤回任务：子流程 > 子流程

会办接收岗【送处室主管】

会办接收岗【撤回处室主管】

会办接收岗【同意】

撤回任务：子流程 > 主流程

处室主管【送会办】

处室主管【撤回送会办】

处室主管【再次送会办】【接收员同意】

撤回任务：主流程 > 子流程

会办主管【送经办人】

会办主管【撤回经办人】

会办主管【同意】

撤回任务：主流程 > 并行子流程

同时送2个会办，A接收员同意，B主管送经办人

B主管【撤回送经办人】

B主管【同意】

核心代码实现

public class RevokeTaskHandler extends FlowServiceFactory {

    @Resource
    private ProcessCmdMapper processCmdMapper;
    @Resource
    private SysDeptMapper deptMapper;

    /**
     * 检验当前任务是否允许撤回
     * @param finishTaskId
     */
    public void check(String finishTaskId){
        //查询下一个完成任务数量
        Integer afterFinishedNum = processCmdMapper.selectCountFinishedAfterTaskId(finishTaskId);
        if(afterFinishedNum>0){
            log.debug("taskId = {}, afterFinishedNum = {}", finishTaskId, afterFinishedNum);
            throw new RuntimeException("子任务已被处理，不允许撤回！");
        }
    }

    //查询撤回任务分组
    public List<RevokeBtnBo> findRevokeBtnList(String procInstId){
        List<HistoricTaskInstance> list = historyService.createHistoricTaskInstanceQuery().processInstanceId(procInstId).taskWithoutDeleteReason().orderByTaskCreateTime().asc().finished().list();
        Map<String, List<BtnItem>> map = new HashMap<>();
        Map<String, List<HistoricTaskInstance>> instMap = list.stream().collect(Collectors.groupingBy(t -> t.getScopeType()+":"+t.getScopeId()));
        String zbKey = null;
        List<String> keyList = new ArrayList<>();
        for(String key : instMap.keySet()){
            List<HistoricTaskInstance> instanceList = instMap.get(key);
            List<BtnItem> items = new ArrayList<>();
            for(HistoricTaskInstance bean : instanceList){
                BtnItem item = new BtnItem();
                item.setTaskId(bean.getId());
                item.setTaskName(bean.getName());
                item.setParentTaskId(bean.getParentTaskId());
                item.setProcInstId(bean.getProcessInstanceId());
                items.add(item);
            }
            if(key.startsWith("zb")){
                zbKey = key;
            }
            map.put(key, items);
            if(!keyList.contains(key) && !"null:null".equals(key)){
                keyList.add(key);
            }
        }
        List<BtnItem> zbList = null;
        List<BtnItem> nullList = map.remove("null:null");
        if(nullList!=null){
            zbList = map.get(zbKey);
            if(zbList!=null){
                zbList.addAll(0, nullList);
            }
        }

        List<RevokeBtnBo> btnBos = new ArrayList<>();
        for(String key : keyList){
            RevokeBtnBo bo = new RevokeBtnBo();
            bo.setKey(key);
            String[] split = key.split(":");
            String deptType = split[0];
            String deptId = split[1];
            String type = "hb".equals(deptType) ? "会办流程" : "主办流程";
            if(StrUtil.isNotBlank(deptId)){
                SysDept sysDept = deptMapper.selectById(deptId);
                String deptName = sysDept.getDeptName();
                bo.setName(String.format("%s > %s", type, deptName));
            }else {
                bo.setName(String.format("%s", type));
            }
            bo.setBthList(map.get(key));
            btnBos.add(bo);
        }

        //只保留会办流程：合并主流程
        Map<String, String> nameMap = btnBos.stream().collect(Collectors.toMap(RevokeBtnBo::getKey, RevokeBtnBo::getName));
        Map<String, List<BtnItem>> boMap = btnBos.stream().collect(Collectors.toMap(RevokeBtnBo::getKey, RevokeBtnBo::getBthList));
        List<RevokeBtnBo> boList = new ArrayList<>();
        for(String key : keyList){
            if(key.startsWith("hb")){
                RevokeBtnBo bo = new RevokeBtnBo();
                bo.setKey(key);
                bo.setName(nameMap.get(key));
                List<BtnItem> hbList = boMap.get(key);
                String parentTaskId = hbList.get(0).getParentTaskId();
                int index = 0;
                List<BtnItem> zbItemList = BeanUtil.copyToList(boMap.get(zbKey), BtnItem.class);
                for (int i = 0; i < zbItemList.size(); i++) {
                    BtnItem item = zbItemList.get(i);
                    if(parentTaskId.equals(item.getTaskId())){
                        index = i;
                        break;
                    }
                }
                zbItemList.addAll(index+1, hbList);
                bo.setBthList(zbItemList);
                boList.add(bo);
            }
        }
        if(boList.size()>0){
            return boList;
        }else {
            return btnBos;
        }
    }

    public void handle(String finishTaskId, String targetTaskId, String comment){
        //查询被撤回的已办任务
        HistoricTaskInstance targetTask = historyService.createHistoricTaskInstanceQuery().taskId(targetTaskId).singleResult();
        //找到所有需要撤回的任务id(包括主子流程)
        Set<String> revokeTaskIds = new HashSet<>();
        List<RevokeBtnBo> revokeBtnList = findRevokeBtnList(targetTask.getProcessInstanceId());
        for(RevokeBtnBo bo : revokeBtnList){
            boolean find = false;
            List<BtnItem> bthList = bo.getBthList();
            for (BtnItem btnItem : bthList){
                String taskId = btnItem.getTaskId();
                if(!find){
                    find = targetTaskId.equals(taskId);
                }
                if(find){
                    revokeTaskIds.add(taskId);
                }
            }
        }
        log.info("revokeTaskIds = {}", revokeTaskIds);

        //判断目标节点是否在主流程中
        List<FlowNode> targetNodes = findFlowNodesInMainProcess(targetTask.getProcessDefinitionId(), targetTask.getTaskDefinitionKey());
        //查询下级待办任务列表
        List<ProcessTodoTask> todoTaskList = listTodoTask(finishTaskId);
        if(todoTaskList!=null && todoTaskList.size()>0){
            for(ProcessTodoTask task : todoTaskList){
                //发送撤回消息
                pushMessageAddComment(task, comment);
            }
            ProcessTodoTask todoTask = todoTaskList.get(0);
            if(targetNodes.size()==0) {
                //目标节点在子流程内，即撤回到子流程内
                RevokeType type = todoTask.isSubProcess() ? RevokeType.sub2sub : RevokeType.main2sub;
                revokeTodoTask(todoTask, targetTask, type);
            }else {
                //目标节点在主流程内，即撤回到主流程内
                RevokeType type = todoTask.isSubProcess() ? RevokeType.sub2main : RevokeType.main2main;
                revokeTodoTask(todoTask, targetTask, type);
            }
        }else {
            throw new RuntimeException("未找到待办任务，不支持撤回！");
        }

        //撤回节点（任务、流程线、网关等逻辑删除）
        for(String taskId : revokeTaskIds){
            Integer taskNum = processCmdMapper.updateRevokeTask(taskId);
            Integer actNum = processCmdMapper.updateRevokeAct(taskId);
            log.info("success revokeTask = {}, revokeAct = {}", taskNum, actNum);
        }
    }

    public void revokeTodoTask(ProcessTodoTask todoTask, HistoricTaskInstance targetTask, RevokeType type) {
        String targetName = targetTask.getName();
        String targetKey = targetTask.getTaskDefinitionKey();
        String instanceId = targetTask.getProcessInstanceId();
        if (type == RevokeType.main2main) {
            log.info(">>>> 主流程内任务撤回 {} > {}", todoTask.getTaskName(), targetName);
            revokeExecutionId(todoTask.getExecutionId(), targetKey);
            //更新待办任务类型参数
            updateTodoTask(targetTask);
        } else if (type == RevokeType.sub2main) {
            log.info(">>>> 子流程撤回到主流程 {} > {}", todoTask.getTaskName(), targetName);
            revokeExecutionId(todoTask.getExecutionId(), targetKey);
            //更新待办任务类型参数
            updateTodoTask(targetTask);
        } else if (type == RevokeType.main2sub) {
            log.info(">>>> 主流程撤回到子流程 {} > {}", todoTask.getTaskName(), targetName);
            String scopeType = targetTask.getScopeType();
            //查询会办子流程中待办任务数量
            Integer number = processCmdMapper.selectCountByScopeType(instanceId, scopeType);
            if(number>0){
                //普通撤回
                revokeExecutionId(todoTask.getExecutionId(), targetKey);
                //更新待办任务类型参数
                updateTodoTask(targetTask);
            }else {
                //撤回多个活动
                revokeProcessInstanceId(instanceId, targetKey);
                //更新待办任务类型参数
                updateTodoTask(targetTask);
                List<Execution> childList = runtimeService.createExecutionQuery().parentId(instanceId).list();
                if(childList!=null && childList.size()==1){
                    //还原子流程活动实例
                    ExecutionEntityImpl root = (ExecutionEntityImpl) runtimeService.createExecutionQuery().executionId(instanceId).singleResult();
                    ExecutionEntityImpl child = (ExecutionEntityImpl) childList.get(0);
                    Map<String, Object> varMap = this.getInstancesVariables(instanceId);
                    managementService.executeCommand(new AddChildExecutionCmd(root, child, varMap));
                }
            }
        } else if (type == RevokeType.sub2sub) {
            log.info(">>>> 子流程内任务撤回 {} > {}", todoTask.getTaskName(), targetKey);
            revokeActivityId(instanceId, todoTask.getTaskKey(), targetKey);
            //更新待办任务类型参数
            updateTodoTask(targetTask);
        } else {
            throw new RuntimeException("不支持撤回类型！");
        }
    }

    //更新待办任务，参数与撤回前参数保持一致
    private void updateTodoTask(HistoricTaskInstance targetTask){
        String targetKey = targetTask.getTaskDefinitionKey();
        List<Task> list = taskService.createTaskQuery().processInstanceId(targetTask.getProcessInstanceId()).taskDefinitionKey(targetKey).orderByTaskCreateTime().desc().list();
        if(list!=null && list.size()>0){
            Task task = list.get(0);
            String taskId = task.getId();
            String parentTaskId = targetTask.getParentTaskId();
            String scopeId = targetTask.getScopeId();
            String scopeType = targetTask.getScopeType();
            taskService.setAssignee(taskId, targetTask.getAssignee());
            if(scopeType!=null){
                processCmdMapper.updateRuTaskScopeInfo(taskId, scopeId, scopeType);
                processCmdMapper.updateHiTaskScopeInfo(taskId, scopeId, scopeType);
            }
            if(StrUtil.isNotBlank(parentTaskId)){
                processCmdMapper.updateRuParentTaskId(taskId, parentTaskId);
                processCmdMapper.updateHiParentTaskId(taskId, parentTaskId);
            }
        }
    }

    //查询下一级待办任务
    private List<ProcessTodoTask> listTodoTask(String finishTaskId){
        List<HistoricTaskInstance> todoList = historyService.createHistoricTaskInstanceQuery().taskParentTaskId(finishTaskId).unfinished().list();
        List<ProcessTodoTask> todoTaskList = new ArrayList<>();
        for(HistoricTaskInstance task : todoList){
            todoTaskList.add(build(task));
        }
        return todoTaskList;
    }

    private ProcessTodoTask build(HistoricTaskInstance task){
        ProcessTodoTask bean = new ProcessTodoTask();
        bean.setTaskId(task.getId());
        bean.setTaskName(task.getName());
        bean.setTaskKey(task.getTaskDefinitionKey());
        bean.setProcInstId(task.getProcessInstanceId());
        bean.setExecutionId(task.getExecutionId());
        String targetKey = task.getTaskDefinitionKey();
        List<FlowNode> todoNodes = findFlowNodesInMainProcess(task.getProcessDefinitionId(), targetKey);
        bean.setSubProcess(todoNodes.size()==0);
        return bean;
    }

    //撤回已经办理的任务
    private void revokeActivityId(String procInstId, String todoTaskKey, String targetKey){
        runtimeService.createChangeActivityStateBuilder().processInstanceId(procInstId).moveActivityIdTo(todoTaskKey, targetKey).changeState();
    }

    //撤回已经办理的任务
    private void revokeProcessInstanceId(String procInstId, String targetKey){
        List<String> executionIds = new ArrayList<>();
        List<Execution> executions = runtimeService.createExecutionQuery().parentId(procInstId).list();
        executions.forEach(execution -> executionIds.add(execution.getId()));
        if(executionIds.size()>0){
            runtimeService.createChangeActivityStateBuilder().moveExecutionsToSingleActivityId(executionIds, targetKey).changeState();
        }
    }

    //撤回已经办理的任务
    private void revokeExecutionId(String executionId, String targetKey){
        runtimeService.createChangeActivityStateBuilder().moveExecutionToActivityId(executionId, targetKey).changeState();
    }

    //添加撤回意见并给用户发送消息
    private void pushMessageAddComment(ProcessTodoTask todoTask, String comment){
        if (StrUtil.isBlank(comment)) {
            comment = "撤回意见：无";
        }else {
            if(!comment.contains("撤回意见")){
                comment = String.format("撤回意见：%s", comment);
            }
        }
        // 设置办理人为当前登录人
        taskService.setOwner(todoTask.getTaskId(), sessionService.getUserId());
        //添加驳回意见
        taskService.addComment(todoTask.getTaskId(), todoTask.getProcInstId(), CommentType.revoke.name(), comment);
        //给撤回的子任务发送消息通知
        messageHandler.doHandle(SysMsgType.revoke.name(), todoTask.getTaskId(), todoTask.getTaskName());
    }

    private Map<String, Object> getInstancesVariables(String procInstId) {
        Integer nrOfInstances = 0, nrOfActive = 0, nrOfCompleted = 0;
        //查询所有活动ids
        List<RuExecutionItem> ruExecutionList = processCmdMapper.selectRuExecutionIdList(procInstId);
        for(RuExecutionItem item : ruExecutionList){
            Map<String, Object> map = getExecutionInstancesVariables(item.getId());
            Integer instances = (Integer) map.get("nrOfInstances");
            Integer active = (Integer) map.get("nrOfActiveInstances");
            Integer completed = (Integer) map.get("nrOfCompletedInstances");
            if(instances!=null){
                nrOfInstances += instances;
            }
            if(active!=null){
                nrOfActive += active;
            }
            if(completed!=null){
                nrOfCompleted += completed;
            }
        }
        Map<String, Object> example = new HashMap<>();
        example.put("nrOfInstances", nrOfInstances);
        example.put("nrOfActiveInstances", nrOfActive);
        example.put("nrOfCompletedInstances", nrOfCompleted);
        return example;
    }
}
/**
 * 流程任务自定义接口
 *
 * @author: mx
 * @date: 2024-08-08 14:59
 */
@Mapper
public interface ProcessCmdMapper {

    //查询taskId之后的已完成任务（如果存在则不可以撤回）
    @Select("select count(*) from act_hi_taskinst where PARENT_TASK_ID_=#{taskId} and END_TIME_ is not null and DELETE_REASON_ is null")
    Integer selectCountFinishedAfterTaskId(String taskId);

    //查询taskId之后的未完成任务（如果存在则可以撤回）
    @Select("select count(*) from act_hi_taskinst where PARENT_TASK_ID_=#{taskId} and END_TIME_ is null and DELETE_REASON_ is null")
    Integer selectCountUnfinishedAfterTaskId(String taskId);

    //查询会办分组下待办任务数量
    @Select("select count(*) from act_hi_taskinst where PROC_INST_ID_=#{procInstId} and SCOPE_TYPE_=#{scopeType} and END_TIME_ is null and DELETE_REASON_ is null")
    Integer selectCountByScopeType(String procInstId, String scopeType);

    //查询流程任务中第1个targetKey对应完成的节点
    TaskItem selectTaskItem(String procInstId, String targetKey);

    //查询已完成任务节点
    List<TaskItem> selectFinishTaskListByRevoke(String procInstId);

    //查询procInstId节点(重复节点取最新一条记录)
    List<ActItem> selectActInstList(String procInstId);

    @Select("select GROUP_ID_ from act_hi_identitylink where TASK_ID_=#{taskId} and TYPE_='candidate' ")
    String selectRoleBYTaskId(String taskId);

    //查询节点出现数量
    @Select("select ACT_ID_, count(1) as number from act_hi_actinst where PROC_INST_ID_=#{procInstId} and (DELETE_REASON_ is null or DELETE_REASON_ not in('MI_END')) and ACT_TYPE_='userTask' group by ACT_ID_")
    List<ActIdNum> selectActIdNumList(String procInstId);

    //查询当前任务key
    @Select("select TASK_DEF_KEY_ from act_hi_taskinst where ID_=#{taskId}")
    String selectTaskKey(String taskId);

    //更新任务描述（自动完成日志说明）
    @Update("update act_hi_taskinst set DESCRIPTION_=#{message} where ID_=#{taskId}")
    Integer updateTaskDescription(String taskId, String message);

    //更新任务类型（scopeId为部门ID, SCOPE_TYPE_为任务类型）
    @Update("update act_hi_taskinst set SCOPE_ID_=#{scopeId}, SCOPE_TYPE_=#{scopeType} where ID_=#{taskId}")
    Integer updateHiTaskScopeInfo(String taskId, String scopeId, String scopeType);

    //更新任务类型（scopeId为部门ID, SCOPE_TYPE_为任务类型）
    @Update("update act_ru_task set SCOPE_ID_=#{scopeId}, SCOPE_TYPE_=#{scopeType} where ID_=#{taskId}")
    Integer updateRuTaskScopeInfo(String taskId, String scopeId, String scopeType);

    //更新任务对应的上个完成任务id
    @Update("update act_hi_taskinst set PARENT_TASK_ID_=#{parentTaskId} where ID_=#{taskId} and PARENT_TASK_ID_ is null")
    Integer updateHiParentTaskId(String taskId, String parentTaskId);

    //更新任务对应的上个完成任务id
    @Update("update act_ru_task set PARENT_TASK_ID_=#{parentTaskId} where ID_=#{taskId} and PARENT_TASK_ID_ is null")
    Integer updateRuParentTaskId(String taskId, String parentTaskId);

    //更新节点对应的上个完成任务id  and TASK_ID_ is null
    @Update("update act_hi_actinst set TASK_ID_=#{finishTaskId} where PROC_INST_ID_=#{procInstId} and START_TIME_>#{endTime}")
    Integer updateHiActTaskId(String procInstId, String finishTaskId, Date endTime);

    //更新节点对应的上个完成任务id
    @Update("update act_ru_actinst set TASK_ID_=#{finishTaskId} where PROC_INST_ID_=#{procInstId} and TASK_ID_ is null and START_TIME_>#{endTime}")
    Integer updateRuActTaskId(String procInstId, String finishTaskId, Date endTime);

    //查询公文ID
    @Select("select BUSINESS_KEY_ from act_hi_procinst where PROC_INST_ID_=#{procInstId}")
    String selectBusinessKey(String procInstId);

    //查询所有公文相关的procInstId
    @Select("select PROC_INST_ID_ from act_hi_procinst where BUSINESS_KEY_=#{businessKey} order by START_TIME_ asc")
    List<String> selectProcInstIdList(String businessKey);

    //查询procInstId对应的活动idList
    @Select("select ID_, ACT_ID_, IS_ACTIVE_, IS_SCOPE_ from act_ru_execution where PROC_INST_ID_=#{procInstId} and VAR_COUNT_>0 and IS_ACTIVE_=1")
    List<RuExecutionItem> selectRuExecutionIdList(String procInstId);

    //撤回已完成历史任务
    @Update("update act_hi_taskinst set DELETE_REASON_='撤回' where PARENT_TASK_ID_=#{finishTaskId} or ID_=#{finishTaskId}")
    Integer updateRevokeTask(String finishTaskId);

    //撤回已完成历史节点
    @Update("update act_hi_actinst set DELETE_REASON_='撤回' where TASK_ID_=#{finishTaskId}")
    Integer updateRevokeAct(String finishTaskId);
}

flowable工作流中的并行流程回退
weixin_45804142的博客
02-10 1910
flowable并行流程回退
flowable实现流程回退任务
qq_42622871的博客
12-08 9062
参考文章： flowable审批，在下个节点没审批前，如何撤回审批。 Flowable 快速入门教程：任务驳回与回退 flowable实战（五）flowable驳回/退回上一步/退回到 一、背景 公司项目是统一在公司自己的框架下实现的，然后现在在做的项目使用了flowable工作流。 昨儿忽然提了一个需求：在中心签领之前，企业可以撤回任务。比如企业上报了自己的信息，中心端需要签领后审核，但忽然企业发现自己上报的信息有些问题，这时可以点击【撤回】按钮，将该条上报信息撤回。（串行普通节点的回退）。 其中部分代码
Flowable回退问题:用户节点回退到并行节点审批通过后流程不自动流转
最新发布
看世界的小gui的博客
04-22 409
在二级审批用户节点进行退回操作时，退回到并行节点的任意一个节点上，再操作完并行节点的审批过后发现流程并没有往下流转，而是到并行网关的时候卡住了。按照预想的话，在并行节点审批过后流程应该流转的二级审批节点上。我们看到在重新审批完成回退节点后，并没有为流转到二级审批（地市）节点。
工作流flowable实现撤回
gong1421407008的博客
04-19 7220
flowable工作流
若依 flowable 回退、查询已办、最新 bug 修复方法，
qq_41577703的博客
03-01 320
问题解决了，我是在revoke process方法里用手写SQL改了hi task 表的delete reason字段值（原本要用框架api改，但框架没有提供修改历史任务表的api），然后在finished list方法里用flowable的API查询过滤删除理由字段值为空的历史任务数据。
springboot使用flowable（3）
qq_21277357的博客
11-26 1868
现在的流程,已经被撤回了一次,上一轮的审批过程也不知道在什么地方，所以这就是我们之前设计历史审批表的原因了，我们要看到他历史审批,不管他经历过多少轮，我们都能在历史审批表中查看到。可以看到 不管他撤回多少次,我们都能看到以前的审批信息,如果你之前上传了附件,也可以拿这个这个地址字段，在你的代码进行扩展。审批完成之后,领导说这个审批的流程有问题,不想要了,要撤回，那么我们来开发一个撤回的功能。可以看到数据已经更改，这样我们就可以发起新的流程了。
Flowable工作流之任务回退
桐花思雨
10-30 6274
有的时候，一个任务节点会存在多个候选人，例如 提交一个任务，这个任务既可以 处理，又可以 处理，当一个候选人认领任务之后，但是又不想处理任务了，此时我们可以将任务回退，那么针对这种情况，我们该如何处理？今天一起来看看我们先从最简单的串行流程来分析，案例流程图如下 完整的 文件内容 上面的流程就是一个非常简单的串行任务，定义了 个用户任务，使用变量来指派处理人分别是 ，在流程的执行过程中我们可以通过回退来演示具体的效果
Flowable实现回退功能（关于ruoyi-vue-pro代码学习）
weixin_56555958的博客
12-04 7503
这个方法用了递归调用，通过我们传过来的当前任务的节点，往前找，找到所有的任务节点，这个方法有三个参数，第一个是我们需要传过来的当前节点，第二个节点是已经连过线的节点，这个参数的意义是当我们递归的时候，已经走过的流程就不需要在走一遍了，避免重复，最后一个参数也就是我们存放数据的参数，我们将最后要返回的结果都存在这个集合里面；这样迭代完之后，我们就获取到了当前任务节点之前的所有节点（用户节点），接下来就得判断这些节点那些不是串行节点，需要将这些节点去掉，就是我们需要的数据；类似非串行、子流程无法退回。
基于jeecg-boot的flowable流程收回功能实现（全网首创功能）
宁波阿成的博客
08-20 1635
基于jeecg-boot的flowable流程收回功能实现（全网首创功能）
17.flowable 流程实例撤回
liuwenjun05101的博客
12-06 9674
项目地址：https://gitee.com/lwj/flowable.git 分支flowable-demo 视频讲解地址 https://space.bilibili.com/485524575/channel/detail?cid=94579 1、演示 2、代码 public ReturnVo<String> revokeProcess(RevokeVo revokeVo) { ...
工作流flowable任务退回（任务跳转）、任务重新触发、任务删除的实现
IccBoY_超越
01-08 8862
在进行flowable工作流的运用中，会涉及到任务的的一些特殊操作，如：退回，跳转，删除，重新触发等
工作流中的回退业务实现
04-11
关键词：回退，回退业务，工作流 工作流回退模式分析 　　回退（Rollback WorkItem） 　　回退工作流参自己“待办任务”（实际工作项）种操作，即参主动回退待办任务列表任务已经执行过人工节点。 　　什么回退？ 　　参接受任务，不应由自己办理此任务或以执行办理有误等，需此接受任务回退给以某个节点执行重新办理。
Activiti5实现任务撤回，任意跳转（代码+注释 spring-activiti-withdraw.zip）
12-24
activiti没有撤回，由于业务的需求需要实现撤回，在参考别人代码后以两种方式实现了任意节点的跳转。代码真实可用，如有问题可联系我 第一种方式： 1、获取当前节点，获取跳转节点 2、获取节点的所有流出流向，把流向保存到临时变量oldPvmTransitionList 3、清空流向，即删除流向 4、新增流向，将流向的Destination设置成跳转节点 5、领取任务，完成任务 6、删除当前节点的流向，将流向还原成临时变量oldPvmTransitionList中的值 第二种方式具体看代码。。。
enterprise-flowable:工作流，包含：单人审批、多人审批、流程分支、指定退回、流程图展示
04-13
Flowable支持定义这种简单任务分配，通过工作流模型定义任务节点，并指定唯一的参与者。开发者可以使用Flowable的API或服务任务来实现审批逻辑。 3. **多人审批**： 多人审批涉及多个参与者共同完成一个任务。...
flowable 会签任务撤回
08-23
所以，flowable会签任务撤回可以通过将任务回退到起始节点来实现。<span class="em">1</span><span class="em">2</span><span class="em">3 #### 引用[.reference_title] - *1* *2* *3* [flowable，199boge，进阶]...
Springboot +Flowable，任务认领和回退（一）
weixin_40991408的博客
05-06 1166
Springboot +Flowable，任务认领和回退（一）
ruoyi-nbcio-plus基于vue3的flowable的自定义业务撤回申请组件的升级修改
宁波阿成的博客
04-10 486
ruoyi-nbcio-plus基于vue3的flowable的自定义业务撤回申请组件的升级修改
flowable审批，在下个节点没审批前，如何撤回审批。
qq_42797418的博客
11-03 6175
flowable审批，如何撤回审批 flowable在审批过后，在下个节点还没有审批前，执行撤回操作重新审批。 这个跟驳回有所不同，驳回是后续节点人员操作，一个是主动，一个是被动。 这是自己随便写的，刚接触工作流，如有不对，望各位大佬指出。 //RevokeProcessVo 是封装的对象 包含流程实例ID、撤回人ID、撤回意见等...这里只用上了这3个，就不多说 public JSONObject withdraw(RevokeProcessVo revokeVo) { JSO
工作流实战_17_flowable 流程实例撤回
Gblfy_Blog
12-20 4156
项目目地址：https://gitee.com/lwj/flowable.git 分支flowable-base 视频讲解地址 https://www.bilibili.com/video/av78129693/ 1、 演示 2、代码 public ReturnVo<String> revokeProcess(RevokeVo revokeVo) { ReturnVo...
评论 13
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包

打赏作者

星梦天河

你的鼓励将是我创作的最大动力

¥1 ¥2 ¥4 ¥6 ¥10 ¥20
扫码支付：¥1
获取中
扫码支付

您的余额不足，请更换扫码支付或充值

打赏作者

实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

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

余额充值