• 基于jeecg-boot的flowable流程自定义业务驳回到发起人的一种处理方式

           有些粉丝，希望对自定义业务中，驳回到发起人进行处理，比如可以重新进行发起流程，下面就给出一种方式，当然不一定是最好的方式，只是提供一种参考而已，以后可以考虑动态根据流程状态或节点信息进行更加好的处理。

         这种方式目前前端不做修改，只做后端的一种处理。

        主要是增加两个逻辑:

    1、增加一个判断是发起人节点，isFirstInitiator  ，以后可以考虑增加驳回与退回的处理

    2、对于驳回里对于驳回到发起人后进行流程删除与关联删除，以便进行重新发起流程

    1. /**
    2.      * 驳回任务 for自定义业务
    3.      *
    4.      * @param flowTaskVo
    5.      */
    6.     @Override
    7.     public void taskRejectForDataId(FlowTaskVo flowTaskVo) {
    8.         if (taskService.createTaskQuery().taskId(flowTaskVo.getTaskId()).singleResult().isSuspended()) {
    9.             throw new CustomException("任务处于挂起状态");
    10.         }
    11.         // 当前任务 task
    12.         Task task = taskService.createTaskQuery().taskId(flowTaskVo.getTaskId()).singleResult();
    13.         // 获取流程定义信息
    14.         ProcessDefinition processDefinition = repositoryService.createProcessDefinitionQuery().processDefinitionId(task.getProcessDefinitionId()).singleResult();
    15.         // 获取所有节点信息
    16.         Process process = repositoryService.getBpmnModel(processDefinition.getId()).getProcesses().get(0);
    17.         // 获取全部节点列表，包含子节点
    18.         Collection allElements = FlowableUtils.getAllElements(process.getFlowElements(), null);
    19.         // 获取当前任务节点元素
    20.         FlowElement source = null;
    21.         if (allElements != null) {
    22.             for (FlowElement flowElement : allElements) {
    23.                 // 类型为用户节点
    24.                 if (flowElement.getId().equals(task.getTaskDefinitionKey())) {
    25.                     // 获取节点信息
    26.                     source = flowElement;
    27.                 }
    28.             }
    29.         }
    30.  
    31.         // 目的获取所有跳转到的节点 targetIds
    32.         // 获取当前节点的所有父级用户任务节点
    33.         // 深度优先算法思想：延边迭代深入
    34.         List parentUserTaskList = FlowableUtils.iteratorFindParentUserTasks(source, null, null);
    35.         if (parentUserTaskList == null || parentUserTaskList.size() == 0) {
    36.             throw new CustomException("当前节点为初始任务节点，不能驳回");
    37.         }
    38.         // 获取活动 ID 即节点 Key
    39.         List parentUserTaskKeyList = new ArrayList<>();
    40.         parentUserTaskList.forEach(item -> parentUserTaskKeyList.add(item.getId()));
    41.         // 获取全部历史节点活动实例，即已经走过的节点历史，数据采用开始时间升序
    42.         List historicTaskInstanceList = historyService.createHistoricTaskInstanceQuery().processInstanceId(task.getProcessInstanceId()).orderByHistoricTaskInstanceStartTime().asc().list();
    43.         // 数据清洗，将回滚导致的脏数据清洗掉
    44.         List lastHistoricTaskInstanceList = FlowableUtils.historicTaskInstanceClean(allElements, historicTaskInstanceList);
    45.         // 此时历史任务实例为倒序，获取最后走的节点
    46.         List targetIds = new ArrayList<>();
    47.         // 循环结束标识，遇到当前目标节点的次数
    48.         int number = 0;
    49.         StringBuilder parentHistoricTaskKey = new StringBuilder();
    50.         for (String historicTaskInstanceKey : lastHistoricTaskInstanceList) {
    51.             // 当会签时候会出现特殊的，连续都是同一个节点历史数据的情况，这种时候跳过
    52.             if (parentHistoricTaskKey.toString().equals(historicTaskInstanceKey)) {
    53.                 continue;
    54.             }
    55.             parentHistoricTaskKey = new StringBuilder(historicTaskInstanceKey);
    56.             if (historicTaskInstanceKey.equals(task.getTaskDefinitionKey())) {
    57.                 number++;
    58.             }
    59.             // 在数据清洗后，历史节点就是唯一一条从起始到当前节点的历史记录，理论上每个点只会出现一次
    60.             // 在流程中如果出现循环，那么每次循环中间的点也只会出现一次，再出现就是下次循环
    61.             // number == 1，第一次遇到当前节点
    62.             // number == 2，第二次遇到，代表最后一次的循环范围
    63.             if (number == 2) {
    64.                 break;
    65.             }
    66.             // 如果当前历史节点，属于父级的节点，说明最后一次经过了这个点，需要退回这个点
    67.             if (parentUserTaskKeyList.contains(historicTaskInstanceKey)) {
    68.                 targetIds.add(historicTaskInstanceKey);
    69.             }
    70.         }
    71.  
    72.  
    73.         // 目的获取所有需要被跳转的节点 currentIds
    74.         // 取其中一个父级任务，因为后续要么存在公共网关，要么就是串行公共线路
    75.         UserTask oneUserTask = parentUserTaskList.get(0);
    76.         // 获取所有正常进行的任务节点 Key，这些任务不能直接使用，需要找出其中需要撤回的任务
    77.         List runTaskList = taskService.createTaskQuery().processInstanceId(task.getProcessInstanceId()).list();
    78.         List runTaskKeyList = new ArrayList<>();
    79.         runTaskList.forEach(item -> runTaskKeyList.add(item.getTaskDefinitionKey()));
    80.         // 需驳回任务列表
    81.         List currentIds = new ArrayList<>();
    82.         // 通过父级网关的出口连线，结合 runTaskList 比对，获取需要撤回的任务
    83.         List currentUserTaskList = FlowableUtils.iteratorFindChildUserTasks(oneUserTask, runTaskKeyList, null, null);
    84.         currentUserTaskList.forEach(item -> currentIds.add(item.getId()));
    85.  
    86.  
    87.         // 规定：并行网关之前节点必须需存在唯一用户任务节点，如果出现多个任务节点，则并行网关节点默认为结束节点，原因为不考虑多对多情况
    88.         if (targetIds.size() > 1 && currentIds.size() > 1) {
    89.             throw new CustomException("任务出现多对多情况，无法撤回");
    90.         }
    91.  
    92.         // 循环获取那些需要被撤回的节点的ID，用来设置驳回原因
    93.         List currentTaskIds = new ArrayList<>();
    94.         currentIds.forEach(currentId -> runTaskList.forEach(runTask -> {
    95.             if (currentId.equals(runTask.getTaskDefinitionKey())) {
    96.                 currentTaskIds.add(runTask.getId());
    97.             }
    98.         }));
    99.         // 设置驳回意见
    100.         currentTaskIds.forEach(item -> taskService.addComment(item, task.getProcessInstanceId(), FlowComment.REJECT.getType(), flowTaskVo.getComment()));
    101.         SysUser loginUser = iFlowThirdService.getLoginUser();
    102.         try {
    103.             // 设置处理人
    104.             taskService.setAssignee(task.getId(), loginUser.getUsername());
    105.             // 如果父级任务多于 1 个，说明当前节点不是并行节点，原因为不考虑多对多情况
    106.             if (targetIds.size() > 1) {
    107.                 // 1 对 多任务跳转，currentIds 当前节点(1)，targetIds 跳转到的节点(多)
    108.                 runtimeService.createChangeActivityStateBuilder()
    109.                         .processInstanceId(task.getProcessInstanceId()).
    110.                         moveSingleActivityIdToActivityIds(currentIds.get(0), targetIds).changeState();
    111.             }
    112.             // 如果父级任务只有一个，因此当前任务可能为网关中的任务
    113.             if (targetIds.size() == 1) {
    114.                 // 1 对 1 或 多 对 1 情况，currentIds 当前要跳转的节点列表(1或多)，targetIds.get(0) 跳转到的节点(1)
    115.                 runtimeService.createChangeActivityStateBuilder()
    116.                         .processInstanceId(task.getProcessInstanceId())
    117.                         .moveActivityIdsToSingleActivityId(currentIds, targetIds.get(0)).changeState();
    118.             }
    119.             /*======================驳回  回调以及关键数据保存======================*/
    120.             //业务数据id
    121.             String dataId = flowTaskVo.getDataId();
    122.             if (dataId==null) return;
    123.             //如果保存数据前未调用必调的FlowCommonService.initActBusiness方法，就会有问题
    124.             FlowMyBusiness business = flowMyBusinessService.getByDataId(dataId);
    125.             // 驳回到了上一个节点等待处理
    126.             Task targetTask = taskService.createTaskQuery().processInstanceId(business.getProcessInstanceId()).active().singleResult();
    127.             //spring容器类名
    128.             String serviceImplName = business.getServiceImplName();
    129.             FlowCallBackServiceI flowCallBackService = (FlowCallBackServiceI) SpringContextUtils.getBean(serviceImplName);
    130.             Map values = flowTaskVo.getValues();
    131.             if (values ==null){
    132.                 values = MapUtil.newHashMap();
    133.                 values.put("dataId",dataId);
    134.             } else {
    135.                 values.put("dataId",dataId);
    136.             }
    137.             List beforeParamsCandidateUsernames = flowCallBackService.flowCandidateUsernamesOfTask(targetTask.getTaskDefinitionKey(), values);
    138.             //设置数据
    139.             String doneUsers = business.getDoneUsers();
    140.             // 处理过流程的人
    141.             JSONArray doneUserList = new JSONArray();
    142.             if (StrUtil.isNotBlank(doneUsers)){
    143.                 doneUserList = JSON.parseArray(doneUsers);
    144.             }
    145.             if (!doneUserList.contains(loginUser.getUsername())){
    146.                 doneUserList.add(loginUser.getUsername());
    147.             }
    148.             business.setActStatus(ActStatus.reject)
    149.                     .setTaskId(targetTask.getId())
    150.                     .setTaskNameId(targetTask.getTaskDefinitionKey())
    151.                     .setTaskName(targetTask.getName())
    152.                     .setDoneUsers(doneUserList.toJSONString())
    153.             ;
    154.             FlowElement targetElement = null;
    155.             if (allElements != null) {
    156.                 for (FlowElement flowElement : allElements) {
    157.                     // 类型为用户节点
    158.                     if (flowElement.getId().equals(targetTask.getTaskDefinitionKey())) {
    159.                         // 获取节点信息
    160.                         targetElement = flowElement;
    161.                     }
    162.                 }
    163.             }
    164.  
    165.             ProcessInstance processInstance = runtimeService.createProcessInstanceQuery().processInstanceId(targetTask.getProcessInstanceId()).singleResult();
    166.             String startUserId = processInstance.getStartUserId();
    167.             
    168.             if (targetElement!=null){
    169.                 UserTask targetUserTask = (UserTask) targetElement;
    170.                 business.setPriority(targetUserTask.getPriority());
    171.  
    172.                 if (StrUtil.equals(targetUserTask.getIncomingFlows().get(0).getSourceRef(),"startNode1")) {//是否为发起人节点
    173.                     //    开始节点。设置处理人为申请人
    174.                     business.setTodoUsers(JSON.toJSONString(Lists.newArrayList(business.getProposer())));
    175.                     taskService.setAssignee(business.getTaskId(),business.getProposer());
    176.                 } else {
    177.                     List sysUserFromTask = getSysUserFromTask(targetUserTask,startUserId);
    178.                     List collect_username = sysUserFromTask.stream().map(SysUser::getUsername).collect(Collectors.toList());
    179.                     //collect_username转换成realname
    180.                     List newusername = new ArrayList();
    181.                     for (String oldUser : collect_username) {
    182.                     	if(StringUtils.equalsAnyIgnoreCase(oldUser, "${INITIATOR}")) {//对发起人做特殊处理
    183.                     		SysUser sysUser = iFlowThirdService.getUserByUsername(startUserId);
    184.                             newusername.add(sysUser.getRealname());
    185.                     	}
    186.                     	else {
    187.                     	  SysUser sysUser = iFlowThirdService.getUserByUsername(oldUser);
    188.                           newusername.add(sysUser.getRealname());
    189.                     	}
    190.                     	
    191.                     }
    192.                     business.setTodoUsers(JSON.toJSONString(newusername));
    193.                     // 删除后重写
    194.                     for (String oldUser : collect_username) {
    195.                         taskService.deleteCandidateUser(targetTask.getId(),oldUser);
    196.                     }
    197.                     if (CollUtil.isNotEmpty(beforeParamsCandidateUsernames)){
    198.                         // 业务层有指定候选人，覆盖
    199.                         for (String newUser : beforeParamsCandidateUsernames) {
    200.                             taskService.addCandidateUser(targetTask.getId(),newUser);
    201.                         }
    202.                         business.setTodoUsers(JSON.toJSONString(beforeParamsCandidateUsernames));
    203.                     } else {
    204.                         for (String oldUser : collect_username) {
    205.                             taskService.addCandidateUser(targetTask.getId(),oldUser);
    206.                         }
    207.                     }
    208.                     if(collect_username.size() ==1) {
    209.                         targetTask.setAssignee(newusername.get(0).toString());
    210.                         taskService.addUserIdentityLink(targetTask.getId(), collect_username.get(0).toString(), IdentityLinkType.ASSIGNEE);
    211.                     }else if(collect_username.size() > 1){
    212.                         List list = historyService
    213.                                 .createHistoricActivityInstanceQuery()
    214.                                 .activityId(targetTask.getTaskDefinitionKey())
    215.                                 .orderByHistoricActivityInstanceStartTime()
    216.                                 .desc().list();
    217.                         for (HistoricActivityInstance historicActivityInstance : list) {
    218.                             if (StrUtil.isNotBlank(historicActivityInstance.getAssignee())) {
    219.                                 targetTask.setAssignee(historicActivityInstance.getAssignee());
    220.                                 taskService.addUserIdentityLink(targetTask.getId(), historicActivityInstance.getAssignee(), IdentityLinkType.ASSIGNEE);
    221.                                 break;
    222.                             }
    223.                         }
    224.                     }
    225.                 }
    226.             }
    227.             
    228.             //  重新查询当前任务
    229.             Task currentTask = taskService.createTaskQuery().processInstanceId(targetTask.getProcessInstanceId()).singleResult();
    230.             //判断是否是发起人节点,恢复自定义业务表单重新提交
    231.             if(isFirstInitiator(currentTask)) {
    232.                 //删除自定义业务任务关联表与流程历史表，以便可以重新发起流程。
    233.             	//(要是需要重新进行提交的话，那就要保留第一个发起人历史信息,自定义业务表单最好增加一个再次发起按钮来处理这种情况
    234.                 if (business != null) {
    235.                 	flowMyBusinessService.removeById(business);
    236.                 	// 对自定义业务，删除运行和历史的节点信息 
    237.                     this.deleteActivity(targetTask.getTaskDefinitionKey(), targetTask.getProcessInstanceId(), dataId);
    238.                 }
    239.             }
    240.             else {
    241.             	flowMyBusinessService.updateById(business);
    242.                 // 流程处理完后，进行回调业务层
    243.                 business.setValues(values);
    244.                 if (flowCallBackService!=null) flowCallBackService.afterFlowHandle(business);
    245.             }
    246.         } catch (FlowableObjectNotFoundException e) {
    247.             throw new CustomException("未找到流程实例，流程可能已发生变化");
    248.         } catch (FlowableException e) {
    249.             throw new CustomException("无法取消或开始活动");
    250.         }
    251.  
    252.     }
    253.     
    254.     /**
    255.     * 判断当前节点是否是第一个发起人节点
    256.     *
    257.     * @param flowTaskVo 请求实体参数
    258.     */
    259.     boolean isFirstInitiator(Task task) {
    260.         BpmnModel bpmnModel = repositoryService.getBpmnModel(task.getProcessDefinitionId());
    261.        //  获取当前活动节点
    262.         FlowNode currentFlowNode = (FlowNode) bpmnModel.getMainProcess().getFlowElement(task.getTaskDefinitionKey());
    263.         // 输入连线
    264.         List inFlows = currentFlowNode.getIncomingFlows();
    265.         for (SequenceFlow sequenceFlow : inFlows) {
    266.         	FlowElement sourceFlowElement = sequenceFlow.getSourceFlowElement();
    267.         	// 如果上个节点为开始节点
    268.             if (sourceFlowElement instanceof StartEvent) {
    269.             	log.info("当前节点为发起人节点,上个节点为开始节点：id=" + sourceFlowElement.getId() + ",name=" + sourceFlowElement.getName());
    270.                 return true;
    271.             }
    272.         }
    273. 		return false;	
    274.     }

         

  • 相关阅读:
    Perl区分文件换行符类型
    leetcode451:根据字符出现频率排序
    Spring容器启动流程
    Java Spring 通过 AOP 实现方法参数的重新赋值、修改方法参数的取值
    嵌入式图像处理机器视觉库YMCV使用
    2022.07.19 随机数字python
    C语言文件操作总结
    Glide 源码解析与原理总结——Glide.with
    mysql 8.0 版本innodb 内存管理锁 buffer pool mutex 变化
    理解 Vue.js 中的 immediate: true
  • 原文地址：https://blog.csdn.net/qq_40032778/article/details/132652886