八退回流程

最新推荐文章于 2023-03-27 18:36:40 发布

李氏程序员

最新推荐文章于 2023-03-27 18:36:40 发布

阅读量602

点赞数

分类专栏： Remember 代码

本文链接：https://blog.csdn.net/weixin_38441551/article/details/88390287

版权

Remember 代码专栏收录该内容

29 篇文章 0 订阅

订阅专栏

@ApiOperation(value = "退回单据（根据任务id）")
  @PostMapping(path = "/rollBack")
  public Response rollBack(@RequestBody WfSubmitVo submitVo) {
    // workflowService.rollBack(submitVo.getTaskId(),submitVo.getSubmitter(),submitVo.getComment());
	  Boolean  bl=workflowService.rollBack(submitVo.getTaskId(), submitVo.getSubmitter(), submitVo.getComment(), submitVo.getIsStart());
    //return Response.success().setMsg("退回成功");
	return Response.success().setData(bl);

  }

@Override
  @Transactional(timeout = 10, rollbackFor = Exception.class)
  public Boolean rollBack(String taskId, String submitter, String comment, Integer isStart) {
    isStart = 1;
    PaOption option = new PaOption();
    option.setSysId("PEX");
    option.setAgyCode("*");
    option.setOptCode(PaOptionEnum.PEX_NODE_IS_START.getCode());
    List<PaOption> list = paOptionService.selectOption(option);
    if (list != null && list.size() > 0) {
      isStart = Integer.parseInt(list.get(0).getOptValue());
    }
	  Boolean bl=false;
	  String billId = wfRuntimeService.getBussKey(taskId);
   // wfRuntimeService.get
   String processInstanceId= wfTaskService.getProcessInstanceId(taskId);
    PexContentBill contentBill = commonInfoService.selectById(billId);
    if (isStart != null && isStart == 1) {// 返回首节点
      commonInfoService.updateBillStatus(billId, PexBillStatusEnum.BAOCUN.getCode());
      wfRuntimeService.rollBack(taskId, submitter, comment, RollbackPosition.START, null, new DefaultEventCallback(contentBill) {
    	  @Override
        public void taskCompleted(PtyWfEvent event) {
          System.out.println("hello world!!!");
        }
      });
    } else {// 不是返回上一个节点
    	bl=wfRuntimeService.rollBack(taskId, submitter, comment, RollbackPosition.PREVIOUS, null, new DefaultEventCallback(contentBill) {
        public void taskCompleted(PtyWfEvent event) {

        }
      });
    }
   
    /*List<IdentityLinkEntity> links = commandContext.getIdentityLinkEntityManager()
			.findIdentityLinksByProcessInstanceId(task.getProcessInstanceId());
	return links.stream().filter(link -> {
		return "starter".equals(link.getType());
	}).findFirst().get().getUserId();*/
    if(bl){
     return true;	
    }else{
    	 String creator= wfRuntimeService.getStartUser(processInstanceId,contentBill.getCreator());
    	    //退回单据 默认清空流程变量
    	    String procInstanceId = wfTaskService.getProcessInstanceId(taskId);
    	    actHiVarInstDao.deleteRuVriables(procInstanceId);
    	return false;
    }
   
  }

/**
 * 选项枚举
 * */
public enum PaOptionEnum {
    
	FORBID_AUDIT_BEF_LAST_CLOSED("FORBID_AUDIT_BEF_LAST_CLOSED","上期未结账则不允许审核本期凭证"),
	BAD_DEBT_ACCRUED_METHORD("BAD_DEBT_ACCRUED_METHORD","坏账准备计提方法"),
	FORBID_VOUDATE_AFTER_SYSDATE("FORBID_VOUDATE_AFTER_SYSDATE","凭证日期不能滞后于系统日期"),
	FORBID_VOU_BEF_LAST_CLOSED("FORBID_VOU_BEF_LAST_CLOSED","上期未结账则不允许做本期凭证"), 
	FORBID_MODIFY_OTHERS("FORBID_MODIFY_OTHERS","禁止修改他人编制的凭证"),
	VOUNO_VOUDATE_INCREA_TOGETHER("VOUNO_VOUDATE_INCREA_TOGETHER","凭证号与凭证日期同时递增"),
	COST_ALLOCATION_RULE("COST_ALLOCATION_RULE","费用分摊规则"),
	FORBID_MODIFY_PROP_WHEN_USED("FORBID_MODIFY_PROP_WHEN_USED","已有发生的科目属性不允许修改"),
	FORBID_CLOSED_IF_IN_EXP_HAS_BAL("FORBID_CLOSED_IF_IN_EXP_HAS_BAL","收入支出科目有余额时不允许结账"),
	IF_BUDGET_CONTROL("IF_BUDGET_CONTROL","是否进行预算控制"),
	IF_BUDGET_CONTROL_BEF_VOU_SAVE("IF_BUDGET_CONTROL_BEF_VOU_SAVE","凭证保存是否控制预算"),
	INPUTER_AUDITER_SAME_OPERATOR("INPUTER_AUDITER_SAME_OPERATOR","制单人和审核人可为同操作员"),
	IF_SUBSYSTEM_VOU_EDITABLE("IF_SUBSYSTEM_VOU_EDITABLE","是否可以修改子系统传过来的凭证"),
	MEMO_REMIND_LIMIT("MEMO_REMIND_LIMIT","备查簿到期提醒阈值（天）"),
	PEX_TRAVEL_EXPENSE_PROVINCE("PEX_TRAVEL_EXPENSE_PROVINCE","财务报销差旅费默认省份"),
	PEX_SYS_DEP_PROJECT_NAME("PEX_SYS_DEP_PROJECT_NAME","系统部署项目名称"),
	PEX_NODE_IS_START("PEX_NODE_IS_START","财务报销是否退回到第一岗标识");

    String code;
    
    String name;

    PaOptionEnum(String code,String name) {
        this.code = code;
        this.name = name;
    }

    
    public String getCode() {
        return code;
    }
    
    public String getName() {
    	return name;
    }
    
}

@Override
	public String getBussKey(String taskId) {
		Task task = activitiEngine.getTaskService().createTaskQuery().taskId(taskId).singleResult();
		ProcessInstance pi = activitiEngine.getRuntimeService().createProcessInstanceQuery()
				.processInstanceId(task.getProcessInstanceId()).singleResult();
		// 3 通过流程实例获取“业务键”
		return pi.getBusinessKey();
	}

<update id="updateById" parameterType="com.pty.pex.entity.PexContentBill">
        UPDATE pex_bill SET
        <if test="billStatus != null">
                bill_status=#{billStatus,jdbcType=INTEGER},
            </if>
        WHERE bill_id=#{billId}
    </update>

@Override
	public Boolean rollBack(String taskId, String submitter, String comment, RollbackPosition position,
			String designatedNodeId, IWfEventCallback eventCallback) {
		Boolean bl=false;
		// 查询遍历
		ProcessDefinitionEntity processDefinitionEntity = null;
		String id = null;
		TaskDefinition taskDef = null;
		// 获取流程实例Id信息
		Task Task = activitiEngine.getTaskService().createTaskQuery().taskId(taskId).singleResult();
		String processInstanceId = activitiEngine.getTaskService().createTaskQuery().taskId(taskId).singleResult()
				.getProcessInstanceId();
		String executionId = activitiEngine.getTaskService().createTaskQuery().taskId(taskId).singleResult()
				.getExecutionId();
		// 获取流程发布Id信息
		String definitionId = activitiEngine.getRuntimeService().createProcessInstanceQuery()
				.processInstanceId(processInstanceId).singleResult().getProcessDefinitionId();

		processDefinitionEntity = (ProcessDefinitionEntity) ((RepositoryServiceImpl) activitiEngine
				.getRepositoryService()).getDeployedProcessDefinition(definitionId);

		List<Execution> execution = activitiEngine.getRuntimeService().createExecutionQuery().executionId(executionId)
				.list();
		if (execution.size() == 1) {
			// execution.getActivityId();
			// 当前流程节点Id信息
			String activitiId = execution.get(0).getActivityId();

			// 获取流程所有节点信息
			List<ActivityImpl> activitiList = processDefinitionEntity.getActivities();

			// 遍历所有节点信息
			for (ActivityImpl activityImpl : activitiList) {
				id = activityImpl.getId();

				// 找到当前节点信息
				if (activitiId.equals(id)) {

					// 判断上一个节点信息是 什么类型
					// type=lastNodeType(activityImpl, activityImpl.getId(),
					// processInstanceId);

					// 获取上一个节点信息
					 bl = nextTaskDefinition(activityImpl, activityImpl.getId(), processInstanceId);
					if(bl){
						return bl;
					}
					break;
				}
			}
		} else {

		}

		ActivitiEventListener eventListener = null;
		if (eventCallback != null) {
			eventListener = new PtyWfEventListener(eventCallback);
			activitiEngine.getRuntimeService().addEventListener(eventListener);
		}
		try {
			TaskService taskService = activitiEngine.getTaskService();
			Task task = taskService.createTaskQuery().taskId(taskId).singleResult();
			if (comment != null && !comment.isEmpty()) {
				taskService.addComment(taskId, task.getProcessInstanceId(), comment);
			}
			String assignee = taskService.createTaskQuery().taskId(taskId).singleResult().getAssignee();
			if (assignee == null) {
				taskService.claim(taskId, submitter);
			}
			RuntimeServiceImpl runtimeService = (RuntimeServiceImpl) activitiEngine.getRuntimeService();
			runtimeService.getCommandExecutor().execute(new RollbackTaskCmd(taskId, position, designatedNodeId));

			List<Task> newTask = activitiEngine.getTaskService().createTaskQuery()
					.processInstanceId(task.getProcessInstanceId()).list();
			// if(newTask.size()==1){
			List<HistoricActivityInstance> taskHisList = activitiEngine.getHistoryService()
					.createHistoricActivityInstanceQuery().executionId(task.getExecutionId()).finished()
					.orderByHistoricActivityInstanceEndTime().desc().list();
			
			if(position.name().equals("PREVIOUS")){
				if (taskHisList.size() != 0) {
					HistoricActivityInstance taskHis1 = activitiEngine.getHistoryService()
							.createHistoricActivityInstanceQuery().executionId(task.getExecutionId()).finished()
							.orderByHistoricActivityInstanceEndTime().desc().list().get(0);
					//删除上一个审批历史活动节点
					actHiActInstDao.delByTaskId(taskHis1.getTaskId());
					//删除当前审批历史活动节点
					actHiActInstDao.delByTaskId(taskId);
					// }

					// }else{

				}
			}else{
				List<HistoricActivityInstance> list=activitiEngine.getHistoryService()
				.createHistoricActivityInstanceQuery().executionId(task.getExecutionId()).activityType("userTask")
				.orderByHistoricActivityInstanceStartTime().desc().list();
				
				List<String> listTaskId=list.stream().map(HistoricActivityInstance::getTaskId).collect(Collectors.toList());
				listTaskId.remove(0);
				actHiActInstDao.delByTaskIds(listTaskId);
				
			}
			
			for (Task task2 : newTask) {
				ActRuTask actRuTask = new ActRuTask();
				actRuTask.setId(task2.getId());
				actRuTask.setIsReturn("1");
				actRuTaskDao.updateById(actRuTask);
			}

			// 删除任务id 回退节点的上一个节点使用
			/*
			 * actHiActInstDao.delByTaskId(taskHis1.getTaskId()); ActRuTask
			 * actRuTask = new ActRuTask(); actRuTask.setId(newTask.getId());
			 * actRuTask.setIsReturn("1"); actRuTaskDao.updateById(actRuTask);
			 */
		} catch (ActivitiException ex) {
			throw new RuntimeException(ex.getMessage() + "->" + ex.getCause().getMessage());
		} catch (Exception ex) {
			throw new RuntimeException(ex);
		} finally {
			if (eventListener != null) {
				activitiEngine.getRuntimeService().removeEventListener(eventListener);
			}
		}
		return bl;
	}

private Boolean nextTaskDefinition(ActivityImpl activityImpl, String activityId, String processInstanceId) {

		PvmActivity ac = null;

		Object s = null;

		// 如果遍历节点为用户任务并且节点不是当前节点信息
		if ("userTask".equals(activityImpl.getProperty("type")) && !activityId.equals(activityImpl.getId())) {
			// 获取该节点下一个节点信息
			TaskDefinition taskDefinition = ((UserTaskActivityBehavior) activityImpl.getActivityBehavior())
					.getTaskDefinition();

			return false;
		} else {
			// 获取节点所有流向线路信息
			List<PvmTransition> outTransitions = activityImpl.getOutgoingTransitions();
			List<PvmTransition> outTransitionsTemp = null;

			List<PvmTransition> incomings = activityImpl.getIncomingTransitions();
			List<PvmTransition> incomingsTemp = null;

			for (PvmTransition pvmTransition : incomings) {
				ac = pvmTransition.getDestination();
				PvmActivity source = pvmTransition.getSource();
				String a = (String) source.getProperty("type");
				if ("exclusiveGateway".equals(source.getProperty("type"))) {
					incomingsTemp = source.getIncomingTransitions();
					if (incomingsTemp.size() == 1) {
						Boolean bl = nextTaskDefinition((ActivityImpl) incomingsTemp.get(0).getSource(),
								activityId, processInstanceId);
						ActHiActInst actHiActInst = new ActHiActInst();
						//排他网管节点
						actHiActInst.setActId(source.getId());
						actHiActInst.setProcInstId(processInstanceId);
						//删除排他网管节点
						actHiActInstDao.del(actHiActInst);
						return false;
					}

				} else if ("userTask".equals(source.getProperty("type"))) {
					TaskDefinition taskDefinition = ((UserTaskActivityBehavior) ((ActivityImpl) source)
							.getActivityBehavior()).getTaskDefinition();
					//return ((UserTaskActivityBehavior) ((ActivityImpl) ac).getActivityBehavior()).getTaskDefinition();
					return false;
				} else if ("parallelGateway".equals(source.getProperty("type"))) {
					// 并行网管
					return true;
					/*ActHiActInst actHiActInst = new ActHiActInst();
					actHiActInst.setActId(source.getId());
					actHiActInst.setProcInstId(processInstanceId);
					actHiActInstDao.del(actHiActInst);*/
				}

			}

		}
		return null;
	}

package com.pty.workflow.service.extend;

import java.util.ArrayList;
import java.util.List;
import java.util.Map;
import java.util.stream.Collectors;

import org.activiti.bpmn.model.ExclusiveGateway;
import org.activiti.bpmn.model.FlowElement;
import org.activiti.bpmn.model.FlowNode;
import org.activiti.bpmn.model.Process;
import org.activiti.bpmn.model.SequenceFlow;
import org.activiti.bpmn.model.StartEvent;
import org.activiti.bpmn.model.UserTask;
import org.activiti.engine.HistoryService;
import org.activiti.engine.delegate.event.ActivitiEventDispatcher;
import org.activiti.engine.delegate.event.ActivitiEventType;
import org.activiti.engine.delegate.event.impl.ActivitiEventBuilder;
import org.activiti.engine.history.HistoricActivityInstance;
import org.activiti.engine.history.HistoricTaskInstance;
import org.activiti.engine.impl.HistoricTaskInstanceQueryImpl;
import org.activiti.engine.impl.cmd.GetDeploymentProcessDefinitionCmd;
import org.activiti.engine.impl.cmd.NeedsActiveTaskCmd;
import org.activiti.engine.impl.context.Context;
import org.activiti.engine.impl.interceptor.CommandContext;
import org.activiti.engine.impl.persistence.entity.ExecutionEntity;
import org.activiti.engine.impl.persistence.entity.IdentityLinkEntity;
import org.activiti.engine.impl.persistence.entity.ProcessDefinitionEntity;
import org.activiti.engine.impl.persistence.entity.TaskEntity;
import org.activiti.engine.impl.persistence.entity.VariableInstanceEntity;
import org.activiti.engine.impl.pvm.process.ActivityImpl;
import org.activiti.engine.task.Task;

import com.pty.workflow.api.RollbackPosition;

import lombok.extern.slf4j.Slf4j;

@Slf4j
/* @Service */
public class RollbackTaskCmd extends NeedsActiveTaskCmd<Void> {

	/**
	 * 
	 */
	private static final long serialVersionUID = 1264547749014497759L;

	private RollbackPosition _position;

	private String _designatedNodeId;

	public RollbackTaskCmd(String taskId, RollbackPosition position, String... designatedNodeId) {
		super(taskId);
		_position = position;
		if (designatedNodeId.length > 0) {
			_designatedNodeId = designatedNodeId[0];
		}
	}

	@Override
	protected Void execute(CommandContext commandContext, TaskEntity task) {

		ActivitiEventDispatcher eventDispatcher = Context.getProcessEngineConfiguration().getEventDispatcher();
		// TODO(liubo): 增加退回的enum
		if (eventDispatcher.isEnabled()) {
			eventDispatcher
					.dispatchEvent(ActivitiEventBuilder.createEntityEvent(ActivitiEventType.TASK_COMPLETED, task));
		}

		if (task.getExecutionId() != null) {
			ExecutionEntity executionEntity = commandContext.getExecutionEntityManager()
					.findExecutionById(task.getExecutionId());
			if (_position.equals(RollbackPosition.START)) {
				rollback2Start(commandContext, task, executionEntity);
			} else if (_position.equals(RollbackPosition.PREVIOUS)) {
				rollback2Previous(commandContext, task, executionEntity);
			} else if (_position.equals(RollbackPosition.DESIGNATED)) {
				rollback2Designated(commandContext, task, executionEntity);
			}
			// Context.getAgenda().planTriggerExecutionOperation(executionEntity);
		}
		return null;
	}

	// 退回到流程初始的任务节点
	private void rollback2Start(CommandContext commandContext, TaskEntity task, ExecutionEntity executionEntity) {
		// TODO(liubo): 设置creator
		String creator=this.getProcessCreator(task, commandContext);
		task.setVariable("creator", this.getProcessCreator(task, commandContext));
		List<TaskEntity> tasks = commandContext.getTaskEntityManager().findTasksByExecutionId(task.getExecutionId());
		tasks.forEach(taskEntity -> {
			// commandContext.getTaskEntityManager().delete(taskEntity);
			commandContext.getTaskEntityManager().deleteTask(taskEntity, null, false);
		});
		Process process = Context.getProcessEngineConfiguration().getRepositoryService()
				.getBpmnModel(task.getProcessDefinitionId()).getMainProcess();
		String firstUserTaskNode = process.findFlowElementsOfType(StartEvent.class).get(0).getOutgoingFlows().get(0)
				.getTargetRef();
		task.fireEvent("rollback");
		executionEntity.removeTask(task);
		executionEntity.executeActivity(executionEntity.getProcessDefinition().findActivity(firstUserTaskNode));
	}

	// 退回到上一个任务节点
	private void rollback2Previous(CommandContext commandContext, TaskEntity task, ExecutionEntity executionEntity) {
		commandContext.getTaskEntityManager().deleteTask(task, null, false);
		// HistoryManager historyManager = commandContext.getHistoryManager();
		// historyManager.recordTaskEnd(taskId, "shareniu-jump");
		Process process = Context.getProcessEngineConfiguration().getRepositoryService()
				.getBpmnModel(task.getProcessDefinitionId()).getMainProcess();
		List<FlowElement> prevNode = getPrevousNode(task, process);
		
		
		List<Task> list = Context.getProcessEngineConfiguration().getTaskService().createTaskQuery()
				.processInstanceId(task.getProcessInstanceId()).list();
		if (list.size() >= 2) {
			for (Task task2 : list) {
				if (!task2.getId().equals(task.getId())) {
					commandContext.getTaskEntityManager().deleteTask((TaskEntity) task2, null, false);
				}
			}

		}
		prevNode.stream().forEach(node -> {
			if (node == null) {
				throw new RuntimeException("前置任务节点未找到");
			}
			if (((FlowNode) node).getIncomingFlows().stream().anyMatch(ele -> {
				String s=ele.getSourceRef();
				return StartEvent.class.isAssignableFrom(process.getFlowElement(ele.getSourceRef()).getClass());
			})) {
				task.setVariable("creator", this.getProcessCreator(task, commandContext));
			}
			// TODO(liubo):如果退回的是第一个任务节点，将creator注入
			task.fireEvent("rollback");
			executionEntity.removeTask(task);
			
	        /*String processDefinitionId = task.getProcessDefinitionId();
	        ProcessDefinitionEntity processDefinitionEntity = new GetDeploymentProcessDefinitionCmd(processDefinitionId).execute(commandContext);
	        ActivityImpl activityImpl = processDefinitionEntity.findActivity(task.getTaskDefinitionKey());
	         Map<String, Object> currMap = activityImpl.getProperties();
	         if (currMap.containsKey("multiInstance")) { // 删除当前多实例任务
	        	// executionEntity= task.getExecution().getParent().getParent(); //taskEntity.getExecution();
	        this.deleteExecution(task);
	        }
	         
	         executionEntity.setProcessInstance(executionEntity);
	         executionEntity.setProcessDefinitionId(historicActivityInstanceEntity.getProcessDefinitionId());
	         executionEntity.setActivity(targetActivity);
	         executionEntity.setActive(false);
	         executionEntity.setConcurrent(false);
	         executionEntity.setCachedEntityState(0);*/

	        

			executionEntity.executeActivity(executionEntity.getProcessDefinition().findActivity(node.getId()));
		});
	}
	
	/*public void deleteExecution(TaskEntity taskEntity) {
		// 删除未处理任务信息
          List<TaskEntity> taskEntities = Context.getCommandContext().getTaskEntityManager().findTasksByProcessInstanceId(taskEntity.getProcessInstanceId());
		for (TaskEntity taskEntity2 : taskEntities) {
		List<VariableInstanceEntity> varLis = Context.getCommandContext().getVariableInstanceEntityManager().findVariableInstancesByExecutionId(taskEntity2.getExecutionId());
		for (VariableInstanceEntity variableInstanceEntity : varLis) {
		Context.getCommandContext().getVariableInstanceEntityManager().delete(variableInstanceEntity);
		}
		Context.getCommandContext().getExecutionEntityManager().delete(taskEntity2.getExecution());
		}
// 获取多实例同节点处理任务
		HistoricTaskInstanceQueryImpl historicTaskInstanceQueryImpl = new HistoricTaskInstanceQueryImpl();
		 historicTaskInstanceQueryImpl.taskDefinitionKey(taskEntity.getTaskDefinitionKey());
		 historicTaskInstanceQueryImpl.processInstanceId(taskEntity.getProcessInstanceId());
		 historicTaskInstanceQueryImpl.setFirstResult(0);
		 historicTaskInstanceQueryImpl.setMaxResults(999);
		 historicTaskInstanceQueryImpl.orderByTaskCreateTime().asc();
		 List<HistoricTaskInstance> historicTaskInstanceList = (List<HistoricTaskInstance>) Context.getCommandContext()
		 .getHistoricTaskInstanceEntityManager().findHistoricTaskInstancesByQueryCriteria(historicTaskInstanceQueryImpl);
		 if (historicTaskInstanceList != null && historicTaskInstanceList.size() > 0) {
		for (HistoricTaskInstance historicTaskInstance : historicTaskInstanceList) {
		ExecutionEntity executionEntity = Context.getCommandContext().getExecutionEntityManager().findExecutionById(historicTaskInstance.getExecutionId());
		if(executionEntity != null) { 
		List<VariableInstanceEntity> hisVarLis = Context.getCommandContext().getVariableInstanceEntityManager().findVariableInstancesByExecutionId(executionEntity.getId());
		for (VariableInstanceEntity variableInstanceEntity : hisVarLis) {
		Context.getCommandContext().getVariableInstanceEntityManager().delete(variableInstanceEntity);
}
		 Context.getCommandContext().getExecutionEntityManager().delete(executionEntity);
		}
		}
		 }
		// 删除多实例父节点信息
		ExecutionEntity parent = Context.getCommandContext().getExecutionEntityManager().findExecutionById(taskEntity.getExecution().getParentId());
		List<VariableInstanceEntity> varLis = Context.getCommandContext().getVariableInstanceEntityManager().findVariableInstancesByExecutionId(parent.getId());
		for (VariableInstanceEntity variableInstanceEntity : varLis) {
		Context.getCommandContext().getVariableInstanceEntityManager().delete(variableInstanceEntity);
		}
		Context.getCommandContext().getExecutionEntityManager().delete(parent);
		    }
		
		 public void deleteExecution(ExecutionEntity executionEntity) {
		Context.getCommandContext().getExecutionEntityManager().delete(executionEntity);
		    }
*/
	private void rollback2Designated(CommandContext commandContext, TaskEntity task, ExecutionEntity executionEntity) {
		throw new RuntimeException("暂不支持退回到任一指定节点");
	}

	/*private List<FlowNode> getPrevousNode(TaskEntity task, Process process) {
		
		ProcessDefinitionEntity processDefinitionEntity = null;

		String id = null;

		TaskDefinition taskDef = null;
		String type = null;
		Map<String, Object> map = new HashMap<String, Object>();
		// 获取流程实例Id信息
		TaskService taskService = Context.getProcessEngineConfiguration().getTaskService();
		Task Task = Context.getProcessEngineConfiguration().getTaskService().createTaskQuery().taskId(taskId)
				.singleResult();
		String processInstanceId = Context.getProcessEngineConfiguration().getTaskService().createTaskQuery()
				.taskId(taskId).singleResult().getProcessInstanceId();
		String executionId = Context.getProcessEngineConfiguration().getTaskService().createTaskQuery().taskId(taskId)
				.singleResult().getExecutionId();
		// 获取流程发布Id信息
		String definitionId = Context.getProcessEngineConfiguration().getRuntimeService().createProcessInstanceQuery()
				.processInstanceId(processInstanceId).singleResult().getProcessDefinitionId();

		processDefinitionEntity = (ProcessDefinitionEntity) ((RepositoryServiceImpl) Context
				.getProcessEngineConfiguration().getRepositoryService()).getDeployedProcessDefinition(definitionId);

		List<Execution> execution = Context.getProcessEngineConfiguration().getRuntimeService().createExecutionQuery()
				.executionId(executionId).list();
		if (execution.size() == 1) {
			// execution.getActivityId();
			// 当前流程节点Id信息
			String activitiId = execution.get(0).getActivityId();

			// 获取流程所有节点信息
			List<ActivityImpl> activitiList = processDefinitionEntity.getActivities();

			// 遍历所有节点信息
			for (ActivityImpl activityImpl : activitiList) {
				id = activityImpl.getId();

				// 找到当前节点信息
				if (activitiId.equals(id)) {

					// 判断上一个节点信息是 什么类型
					map = lastNodeType(activityImpl, activityImpl.getId(), processInstanceId);

					break;
				}
			}
		} else {

		}

		if (map.get("type") != null && map.get("type").equals("parallelGateway")) {
			List<FlowNode> flowNodes = new ArrayList<FlowNode>();

			String activityId = (String) map.get("activityId");
			FlowNode node = (FlowNode) process.getFlowElement(activityId);
			List<SequenceFlow> list = node.getIncomingFlows();
			for (SequenceFlow sequenceFlow : list) {
				FlowElement flowElement = process.getFlowElement(sequenceFlow.getSourceRef());
				FlowNode flowNode = (FlowNode) flowElement;
				flowNodes.add(flowNode);
			}

			return flowNodes;
		} else if (map.get("type").equals("userTask")) {
			List<FlowNode> flowNodes = new ArrayList<FlowNode>();
			List<HistoricActivityInstance> taskHis = Context.getProcessEngineConfiguration().getHistoryService()
					.createHistoricActivityInstanceQuery().executionId(task.getExecutionId()).finished()
					.orderByHistoricActivityInstanceEndTime().desc().list();

			FlowNode flowNode = (FlowNode) process.getFlowElement(taskHis.get(0).getActivityId());
			flowNodes.add(flowNode);
			return flowNodes;
		} else{
			List<FlowNode> flowNodes = new ArrayList<FlowNode>();
			List<HistoricActivityInstance> taskHis3 = Context.getProcessEngineConfiguration().getHistoryService()
					.createHistoricActivityInstanceQuery().executionId(task.getExecutionId()).finished()
					.orderByHistoricActivityInstanceEndTime().desc().list();
			FlowNode flowNode = (FlowNode) process.getFlowElement(taskHis3.get(0).getActivityId());
			flowNodes.add(flowNode);
			return flowNodes;

		}

	}*/

	private List<FlowElement> getPrevousNode(TaskEntity task, Process process) {
		/*List<HistoricActivityInstance> historyActivitys = Context.getProcessEngineConfiguration().getHistoryService()
				.createNativeHistoricActivityInstanceQuery("").list();*/
		
		List<HistoricActivityInstance> taskHis = Context.getProcessEngineConfiguration().getHistoryService()
				.createHistoricActivityInstanceQuery().processInstanceId(task.getProcessInstanceId()).finished()
				.orderByHistoricActivityInstanceEndTime().desc().list();
		
		List<HistoricActivityInstance> taskHis1 = Context.getProcessEngineConfiguration().getHistoryService()
				.createHistoricActivityInstanceQuery().processInstanceId(task.getProcessInstanceId()).finished()
				.orderByHistoricActivityInstanceEndTime().desc().list();
		HistoricActivityInstance maxExecuteElement = taskHis.stream().filter(activity->{
			FlowElement ele = process.getFlowElement(activity.getActivityId());
			if (ele == null) {
				return false;
			}
			if (!(ele instanceof FlowNode)) {
				return false;
			}
			if (activity.getActivityType().equals("exclusiveGateway")) {
				return false;
			}
			return true;
		}).max((a, b)->{
			return a.getEndTime().compareTo(b.getEndTime());
		}).get();
		List<SequenceFlow> list2=new ArrayList<>();
		List<FlowElement> listFlowElement=new ArrayList<FlowElement>();
		if (maxExecuteElement.getActivityType().equals("userTask")) {
			FlowNode node = (FlowNode)process.getFlowElement(maxExecuteElement.getActivityId());
			List<SequenceFlow> list=node.getOutgoingFlows();
			
			for (SequenceFlow sequenceFlow : list) {
				
				String targetRef=sequenceFlow.getTargetRef();
				FlowNode node2 = (FlowNode) process.getFlowElement(targetRef);
				
				String name=node2.getName();
				if(name==null){
					list2=node2.getIncomingFlows();
					for (SequenceFlow sequenceFlow2 : list2) {
						FlowElement flowElement=process.getFlowElement(sequenceFlow2.getSourceRef());
						listFlowElement.add(flowElement);
					}
				}else{
					FlowElement  flowElement =process.getFlowElement(maxExecuteElement.getActivityId());
					listFlowElement.add(flowElement);
				}
			}
			
			return listFlowElement;
			//return Arrays.asList(process.getFlowElement(maxExecuteElement.getActivityId()));
		} else if (maxExecuteElement.getActivityType().equals("parallelGateway")) {
			FlowNode node = (FlowNode)process.getFlowElement(maxExecuteElement.getActivityId());
			return node.getIncomingFlows().stream().map(sequence->{
				return process.getFlowElement(sequence.getSourceRef());
			}).collect(Collectors.toList());
		} else {
			return new ArrayList<FlowElement>();
		}
	}
	
	/*private List<FlowElement> getPrevousNode(TaskEntity task, Process process) {
		List<HistoricActivityInstance> historyActivitys = Context.getProcessEngineConfiguration().getHistoryService()
				.createNativeHistoricActivityInstanceQuery().list();
		HistoricActivityInstance maxExecuteElement = historyActivitys.stream().filter(activity->{
			FlowElement ele = process.getFlowElement(activity.getActivityId());
			if (ele == null) {
				return false;
			}
			if (!(ele instanceof FlowNode)) {
				return false;
			}
			if (activity.getActivityType().equals("exclusiveGateway")) {
				return false;
			}
			return true;
		}).max((a, b)->{
			return a.getEndTime().compareTo(b.getEndTime());
		}).get();
		if (maxExecuteElement.getActivityType().equals("userTask")) {
			return Arrays.asList(process.getFlowElement(maxExecuteElement.getActivityId()));
		} else if (maxExecuteElement.getActivityType().equals("parallelGateway")) {
			FlowNode node = (FlowNode)process.getFlowElement(maxExecuteElement.getActivityId());
			return node.getIncomingFlows().stream().map(sequence->{
				return process.getFlowElement(sequence.getSourceRef());
			}).collect(Collectors.toList());
		} else {
			return new ArrayList<FlowElement>();
		}
	}*/
	
	
	/*private Map<String, Object> lastNodeType(ActivityImpl activityImpl, String id, String processInstanceId) {
		PvmActivity ac = null;

		Object s = null;

		// 如果遍历节点为用户任务并且节点不是当前节点信息
		if ("userTask".equals(activityImpl.getProperty("type")) && !id.equals(activityImpl.getId())) {

		} else {
			// 获取节点所有流向线路信息
			List<PvmTransition> outTransitions = activityImpl.getOutgoingTransitions();
			List<PvmTransition> outTransitionsTemp = null;

			List<PvmTransition> incomings = activityImpl.getIncomingTransitions();
			List<PvmTransition> incomingsTemp = null;

			for (PvmTransition pvmTransition : incomings) {
				ac = pvmTransition.getDestination();
				PvmActivity source = pvmTransition.getSource();
				String a = (String) source.getProperty("type");
				if ("exclusiveGateway".equals(source.getProperty("type"))) {
					incomingsTemp = source.getIncomingTransitions();
					if (incomingsTemp.size() == 1) {
						String actId = source.getId();
						Map<String, Object> map = new HashMap<String, Object>();
						map.put("activityId", source.getId());
						map.put("type", "exclusiveGateway");
						return map;
					}

				} else if ("userTask".equals(source.getProperty("type"))) {
					String actId = source.getId();
					Map<String, Object> map = new HashMap<String, Object>();
					map.put("activityId", source.getId());
					map.put("type", "userTask");
					return map;

				} else if ("parallelGateway".equals(source.getProperty("type"))) {
					String actId = source.getId();
					Map<String, Object> map = new HashMap<String, Object>();
					map.put("activityId", source.getId());
					map.put("type", "parallelGateway");
					return map;
				}

			}

		}
		return null;
	}*/

	private String getProcessCreator(TaskEntity task, CommandContext commandContext) {
		List<IdentityLinkEntity> links = commandContext.getIdentityLinkEntityManager()
				.findIdentityLinksByProcessInstanceId(task.getProcessInstanceId());
		return links.stream().filter(link -> {
			return "starter".equals(link.getType());
		}).findFirst().get().getUserId();
	}

	@Deprecated
	private FlowNode getPrevTaskNode(String processId, FlowElement curNode, Process process,
			HistoryService historyService) {
		if (curNode == null) {
			return null;
		}
		if (!FlowNode.class.isAssignableFrom(curNode.getClass())) {
			return null;
		}
		List<SequenceFlow> sequences = ((FlowNode) curNode).getIncomingFlows();
		for (SequenceFlow seq : sequences) {
			FlowElement ele = process.getFlowElement(seq.getSourceRef());
			if (UserTask.class.isAssignableFrom(ele.getClass())) {
				try {
					HistoricActivityInstance his = historyService.createHistoricActivityInstanceQuery()
							.processDefinitionId(processId).activityId(ele.getId())
							.orderByHistoricActivityInstanceEndTime().desc().singleResult();
					return (FlowNode) ele;
				} catch (Exception ex) {
					log.error("error", ex);
				}
			} else if (ExclusiveGateway.class.isAssignableFrom(ele.getClass())) {
				return getPrevTaskNode(processId, ele, process, historyService);
			}
		}
		return null;
	}

}

李氏程序员

关注

0
点赞
踩
0

收藏

觉得还不错? 一键收藏
0
评论
八退回流程

@ApiOperation(value = "退回单据（根据任务id）") @PostMapping(path = "/rollBack") public Response rollBack(@RequestBody WfSubmitVo submitVo) { // workflowService.rollBack(submitVo.getTaskId(),submitVo.ge...
复制链接

扫一扫

专栏目录

八 退回流程

八退回流程