/**
*
* @param taskId 义务id
* @param msg 批注
* @param endActivityId 停止节点的activitiyId
* @throws Exception
*/
public void turnBackNew(String taskId, String msg, String endActivityId) throws Exception {
Map<String, Object> variables;
// 获得当前义务
HistoricTaskInstance currTask = historyService
.createHistoricTaskInstanceQuery().taskId(taskId)
.singleResult();
// 获得流程实例
ProcessInstance instance = runtimeService
.createProcessInstanceQuery()
.processInstanceId(currTask.getProcessInstanceId())
.singleResult();
if (instance == null) {
throw new RuntimeException("流程已停止");
}
variables = instance.getProcessVariables();
// 获得流程定义
ProcessDefinitionEntity definition = (ProcessDefinitionEntity) ((RepositoryServiceImpl) repositoryService)
.getDeployedProcessDefinition(currTask
.getProcessDefinitionId());
if (definition == null) {
throw new RuntimeException("流程定义未找到");
}
// 获得上一步运动
ActivityImpl currActivity = ((ProcessDefinitionImpl) definition)
.findActivity(currTask.getTaskDefinitionKey());
List<ActivityImpl> rtnList = new ArrayList<>();
List<ActivityImpl> tempList = new ArrayList<>();
List<ActivityImpl> activities = iteratorBackActivity(
taskId,
currActivity,
rtnList,
tempList
);
if (activities == null || activities.size() <= 0) throw new RuntimeException("没有可以选择的驳回节点!");
List<Task> list = taskService.createTaskQuery().processInstanceId(instance.getId()).list();
for (Task task : list) {
if (!task.getId().equals(taskId)) {
task.setAssignee("消除标志");
commitProcess(task.getId(), null, endActivityId);
}
}
turnTransition(taskId, activities.get(0).getId(), null);
}
/**
* @param taskId 当前义务ID
* @param variables 流程变量
* @param activityId 流程转向履行义务节点ID<br>
* 此参数为空，默以为提交操作
* @throws Exception
*/
private void commitProcess(String taskId, Map<String, Object> variables,
String activityId) throws Exception {
if (variables == null) {
variables = new HashMap<String, Object>();
}
// 跳转节点为空，默许提交操作
if (activityId == null || activityId.equals("")) {
taskService.complete(taskId, variables);
} else {// 流程转向操作
turnTransition(taskId, activityId, variables);
}
}
/**
* 清空指定运动节点流向
*
* @param activityImpl 运动节点
* @return 节点流向聚集
*/
private List<PvmTransition> clearTransition(ActivityImpl activityImpl) {
// 存储当前节点所有流向临时变量
List<PvmTransition> oriPvmTransitionList = new ArrayList<PvmTransition>();
// 获得当前节点所有流向，存储到临时变量，然后清空
List<PvmTransition> pvmTransitionList = activityImpl
.getOutgoingTransitions();
for (PvmTransition pvmTransition : pvmTransitionList) {
oriPvmTransitionList.add(pvmTransition);
}
pvmTransitionList.clear();
return oriPvmTransitionList;
}
/**
* 还原指定运动节点流向
*
* @param activityImpl 运动节点
* @param oriPvmTransitionList 原有节点流向聚集
*/
private void restoreTransition(ActivityImpl activityImpl,
List<PvmTransition> oriPvmTransitionList) {
// 清空现有流向
List<PvmTransition> pvmTransitionList = activityImpl
.getOutgoingTransitions();
pvmTransitionList.clear();
// 还原之前流向
for (PvmTransition pvmTransition : oriPvmTransitionList) {
pvmTransitionList.add(pvmTransition);
}
}
/**
* 流程转向操作
*
* @param taskId 当前义务ID
* @param activityId 目的节点义务ID
* @param variables 流程变量
* @throws Exception
*/
private void turnTransition(String taskId, String activityId,
Map<String, Object> variables) throws Exception {
// 当前节点
ActivityImpl currActivity = findActivitiImpl(taskId, null);
// 清空当前流向
List<PvmTransition> oriPvmTransitionList = clearTransition(currActivity);
// 创立新流向
TransitionImpl newTransition = currActivity.createOutgoingTransition();
// 目的节点
ActivityImpl pointActivity = findActivitiImpl(taskId, activityId);
// 设置新流向的目的节点
newTransition.setDestination(pointActivity);
// 履行转向义务
taskService.complete(taskId, variables);
// 删除目的节点新流入
pointActivity.getIncomingTransitions().remove(newTransition);
// 还原之前流向
restoreTransition(currActivity, oriPvmTransitionList);
}
/**
* 迭代重复流程树构造，查询当前节点可驳回的义务节点
*
* @param taskId 当前义务ID
* @param currActivity 当前运动节点
* @param rtnList 存储回退节点聚集
* @param tempList 临时存储节点聚集（存储一次迭代进程中的同级userTask节点）
* @return 回退节点聚集
*/
private List<ActivityImpl> iteratorBackActivity(String taskId,
ActivityImpl currActivity, List<ActivityImpl> rtnList,
List<ActivityImpl> tempList) throws Exception {
// 查询流程定义，生成流程树构造
ProcessInstance processInstance = findProcessInstanceByTaskId(taskId);
// 当前节点的流入起源
List<PvmTransition> incomingTransitions = currActivity
.getIncomingTransitions();
// 条件分支节点聚集，userTask节点遍历终了，迭代遍历此聚集，查询条件分支对应的userTask节点
List<ActivityImpl> exclusiveGateways = new ArrayList<ActivityImpl>();
// 并行节点聚集，userTask节点遍历终了，迭代遍历此聚集，查询并行节点对应的userTask节点
List<ActivityImpl> parallelGateways = new ArrayList<ActivityImpl>();
// 遍历当前节点所有流入路径
for (PvmTransition pvmTransition : incomingTransitions) {
TransitionImpl transitionImpl = (TransitionImpl) pvmTransition;
ActivityImpl activityImpl = transitionImpl.getSource();
String type = (String) activityImpl.getProperty("type");
/**
* 并行节点配置请求：<br>
* 必需成对涌现，且请求分离配置节点ID为:XXX_start(开端)，XXX_end(停止)
*/
if ("parallelGateway".equals(type)) {// 并行线路
String gatewayId = activityImpl.getId();
String gatewayType = gatewayId.substring(gatewayId
.lastIndexOf("_") + 1);
if ("START".equals(gatewayType.toUpperCase())) {// 并行出发点，停止递归
return rtnList;
} else {// 并行终点，临时存储此节点，本次重复停止，迭代聚集，查询对应的userTask节点
parallelGateways.add(activityImpl);
}
} else if ("startEvent".equals(type)) {// 开端节点，停止递归
return rtnList;
} else if ("userTask".equals(type)) {// 用户义务
tempList.add(activityImpl);
} else if ("exclusiveGateway".equals(type)) {// 分支线路，临时存储此节点，本次重复停止，迭代聚集，查询对应的userTask节点
currActivity = transitionImpl.getSource();
exclusiveGateways.add(currActivity);
}
}
/**
* 迭代条件分支聚集，查询对应的userTask节点
*/
for (ActivityImpl activityImpl : exclusiveGateways) {
iteratorBackActivity(taskId, activityImpl, rtnList, tempList);
}
/**
* 迭代并行聚集，查询对应的userTask节点
*/
for (ActivityImpl activityImpl : parallelGateways) {
iteratorBackActivity(taskId, activityImpl, rtnList, tempList);
}
/**
* 依据同级userTask聚集，过滤最近产生的节点
*/
currActivity = filterNewestActivity(processInstance, tempList);
if (currActivity != null) {
// 查询当前节点的流向是不是为并行终点，并获得并行出发点ID
String id = findParallelGatewayId(currActivity);
if (id == null || id.equals("")) {// 并行出发点ID为空，此节点流向不是并行终点，符合驳回条件，存储此节点
rtnList.add(currActivity);
} else {// 依据并行出发点ID查询当前节点，然后迭代查询其对应的userTask义务节点
currActivity = findActivitiImpl(taskId, id);
}
// 清空本次迭代临时聚集
tempList.clear();
// 履行下次迭代
iteratorBackActivity(taskId, currActivity, rtnList, tempList);
}
return rtnList;
}
/**
* 依据当前节点，查询输出流向是不是为并行终点，如果为并行终点，则拼装对应的并行出发点ID
*
* @param activityImpl 当前节点
* @return
*/
private String findParallelGatewayId(ActivityImpl activityImpl) {
List<PvmTransition> incomingTransitions = activityImpl
.getOutgoingTransitions();
for (PvmTransition pvmTransition : incomingTransitions) {
TransitionImpl transitionImpl = (TransitionImpl) pvmTransition;
activityImpl = transitionImpl.getDestination();
String type = (String) activityImpl.getProperty("type");
if ("parallelGateway".equals(type)) {// 并行线路
String gatewayId = activityImpl.getId();
String gatewayType = gatewayId.substring(gatewayId
.lastIndexOf("_") + 1);
if ("END".equals(gatewayType.toUpperCase())) {
return gatewayId.substring(0, gatewayId.lastIndexOf("_"))
+ "_start";
}
}
}
return null;
}
/**
* 依据流入义务聚集，查询最近一次的流入义务节点
*
* @param processInstance 流程实例
* @param tempList 流入义务聚集
* @return
*/
private ActivityImpl filterNewestActivity(ProcessInstance processInstance,
List<ActivityImpl> tempList) {
while (tempList.size() > 0) {
ActivityImpl activity_1 = tempList.get(0);
HistoricActivityInstance activityInstance_1 = findHistoricUserTask(
processInstance, activity_1.getId());
if (activityInstance_1 == null) {
tempList.remove(activity_1);
continue;
}
if (tempList.size() > 1) {
ActivityImpl activity_2 = tempList.get(1);
HistoricActivityInstance activityInstance_2 = findHistoricUserTask(
processInstance, activity_2.getId());
if (activityInstance_2 == null) {
tempList.remove(activity_2);
continue;
}
if (activityInstance_1.getEndTime().before(
activityInstance_2.getEndTime())) {
tempList.remove(activity_1);
} else {
tempList.remove(activity_2);
}
} else {
break;
}
}
if (tempList.size() > 0) {
return tempList.get(0);
}
return null;
}
/**
* 查询指定义务节点的最新记载
*
* @param processInstance 流程实例
* @param activityId
* @return
*/
private HistoricActivityInstance findHistoricUserTask(
ProcessInstance processInstance, String activityId) {
HistoricActivityInstance rtnVal = null;
// 查询当前流程实例审批停止的历史节点
List<HistoricActivityInstance> historicActivityInstances = historyService
.createHistoricActivityInstanceQuery().activityType("userTask")
.processInstanceId(processInstance.getId()).activityId(
activityId).finished()
.orderByHistoricActivityInstanceEndTime().desc().list();
if (historicActivityInstances.size() > 0) {
rtnVal = historicActivityInstances.get(0);
}
return rtnVal;
}
/**
* 依据义务ID和节点ID获得运动节点 <br>
*
* @param taskId 义务ID
* @param activityId 运动节点ID <br>
* 如果为null或""，则默许查询当前运动节点 <br>
* 如果为"end"，则查询停止节点 <br>
* @return
* @throws Exception
*/
private ActivityImpl findActivitiImpl(String taskId, String activityId)
throws Exception {
// 获得流程定义
ProcessDefinitionEntity processDefinition = findProcessDefinitionEntityByTaskId(taskId);
// 获得当前运动节点ID
if (activityId == null || "".equals(activityId)) {
activityId = findTaskById(taskId).getTaskDefinitionKey();
}
// 依据流程定义，获得该流程实例的停止节点
if (activityId.toUpperCase().equals("END")) {
for (ActivityImpl activityImpl : processDefinition.getActivities()) {
List<PvmTransition> pvmTransitionList = activityImpl
.getOutgoingTransitions();
if (pvmTransitionList.isEmpty()) {
return activityImpl;
}
}
}
// 依据节点ID，获得对应的运动节点
ActivityImpl activityImpl = ((ProcessDefinitionImpl) processDefinition)
.findActivity(activityId);
return activityImpl;
}
/**
* 依据义务ID获得流程定义
*
* @param taskId 义务ID
* @return
* @throws Exception
*/
private ProcessDefinitionEntity findProcessDefinitionEntityByTaskId(
String taskId) throws Exception {
// 获得流程定义
ProcessDefinitionEntity processDefinition = (ProcessDefinitionEntity) ((RepositoryServiceImpl) repositoryService)
.getDeployedProcessDefinition(findTaskById(taskId)
.getProcessDefinitionId());
if (processDefinition == null) {
throw new Exception("流程定义未找到!");
}
return processDefinition;
}
/**
* 依据义务ID获得义务实例
*
* @param taskId 义务ID
* @return
* @throws Exception
*/
private TaskEntity findTaskById(String taskId) throws Exception {
TaskEntity task = (TaskEntity) taskService.createTaskQuery().taskId(
taskId).singleResult();
if (task == null) {
throw new Exception("义务实例未找到!");
}
return task;
}
/**
* 依据义务ID获得对应的流程实例
*
* @param taskId 义务ID
* @return
* @throws Exception
*/
private ProcessInstance findProcessInstanceByTaskId(String taskId)
throws Exception {
// 找到流程实例
ProcessInstance processInstance = runtimeService
.createProcessInstanceQuery().processInstanceId(
findTaskById(taskId).getProcessInstanceId())
.singleResult();
if (processInstance == null) {
throw new Exception("流程实例未找到!");
}
return processInstance;
}/**
*
* @param taskId 义务id
* @
阅读背景：
activiti会签情况下任意节点退回
来源：互联网
分享到：
