Activiti之流程通过、驳回、会签、转办、中止、挂起等核心操作封装(Activiti5.9)

1. package com.famousPro.process.service.impl;  
2. import java.util.ArrayList;  
3. import java.util.HashMap;  
4. import java.util.List;  
5. import java.util.Map;  
6. import org.activiti.engine.FormService;  
7. import org.activiti.engine.HistoryService;  
8. import org.activiti.engine.RepositoryService;  
9. import org.activiti.engine.RuntimeService;  
10. import org.activiti.engine.TaskService;  
11. import org.activiti.engine.history.HistoricActivityInstance;  
12. import org.activiti.engine.impl.RepositoryServiceImpl;  
13. import org.activiti.engine.impl.persistence.entity.ProcessDefinitionEntity;  
14. import org.activiti.engine.impl.persistence.entity.TaskEntity;  
15. import org.activiti.engine.impl.pvm.PvmTransition;  
16. import org.activiti.engine.impl.pvm.process.ActivityImpl;  
17. import org.activiti.engine.impl.pvm.process.ProcessDefinitionImpl;  
18. import org.activiti.engine.impl.pvm.process.TransitionImpl;  
19. import org.activiti.engine.runtime.ProcessInstance;  
20. import org.activiti.engine.task.Task;  
21. import com.famousPro.common.service.impl.BaseServiceImp;  
22. import com.famousPro.common.util.IDGenerator;  
23. import com.famousPro.common.util.StringUtil;  
24. import com.famousPro.process.service.ProcessCoreService;  
25. import com.famousPro.process.service.ProcessOtherService;  
26. public class ProcessCoreServiceImpl extends BaseServiceImp implements  
27.         ProcessCoreService {  
28.     protected RepositoryService repositoryService;  
29.     protected RuntimeService runtimeService;  
30.     protected TaskService taskService;  
31.     protected FormService formService;  
32.     protected HistoryService historyService;  
33.     protected ProcessOtherService processOtherService;  
34.     public List<ActivityImpl> findBackAvtivity(String taskId) throws Exception {  
35.         List<ActivityImpl> rtnList = null;  
36.         if (processOtherService.isJointTask(taskId)) {// 会签任务节点，不允许驳回  
37.             rtnList = new ArrayList<ActivityImpl>();  
38.         } else {  
39.             rtnList = iteratorBackActivity(taskId, findActivitiImpl(taskId,  
40.                     null), new ArrayList<ActivityImpl>(),  
41.                     new ArrayList<ActivityImpl>());  
42.         }  
43.         return reverList(rtnList);  
44.     }  
45.     public void passProcess(String taskId, Map<String, Object> variables)  
46.             throws Exception {  
47.         List<Task> tasks = taskService.createTaskQuery().parentTaskId(taskId)  
48.                 .taskDescription("jointProcess").list();  
49.         for (Task task : tasks) {// 级联结束本节点发起的会签任务  
50.             commitProcess(task.getId(), null, null);  
51.         }  
52.         commitProcess(taskId, variables, null);  
53.     }  
54.     public void backProcess(String taskId, String activityId,  
55.             Map<String, Object> variables) throws Exception {  
56.         if (StringUtil.isNull(activityId)) {  
57.             throw new Exception("驳回目标节点ID为空！");  
58.         }  
59.         // 查询本节点发起的会签任务，并结束  
60.         List<Task> tasks = taskService.createTaskQuery().parentTaskId(taskId)  
61.                 .taskDescription("jointProcess").list();  
62.         for (Task task : tasks) {  
63.             commitProcess(task.getId(), null, null);  
64.         }  
65.         // 查找所有并行任务节点，同时驳回  
66.         List<Task> taskList = findTaskListByKey(findProcessInstanceByTaskId(  
67.                 taskId).getId(), findTaskById(taskId).getTaskDefinitionKey());  
68.         for (Task task : taskList) {  
69.             commitProcess(task.getId(), variables, activityId);  
70.         }  
71.     }  
72.     public void callBackProcess(String taskId, String activityId)  
73.             throws Exception {  
74.         if (StringUtil.isNull(activityId)) {  
75.             throw new Exception("目标节点ID为空！");  
76.         }  
77.         // 查找所有并行任务节点，同时取回  
78.         List<Task> taskList = findTaskListByKey(findProcessInstanceByTaskId(  
79.                 taskId).getId(), findTaskById(taskId).getTaskDefinitionKey());  
80.         for (Task task : taskList) {  
81.             commitProcess(task.getId(), null, activityId);  
82.         }  
83.     }  
84.     public void endProcess(String taskId) throws Exception {  
85.         ActivityImpl endActivity = findActivitiImpl(taskId, "end");  
86.         commitProcess(taskId, null, endActivity.getId());  
87.     }  
88.     public void jointProcess(String taskId, List<String> userCodes)  
89.             throws Exception {  
90.         for (String userCode : userCodes) {  
91.             TaskEntity task = (TaskEntity) taskService.newTask(IDGenerator  
92.                     .generateID());  
93.             task.setAssignee(userCode);  
94.             task.setName(findTaskById(taskId).getName() + "-会签");  
95.             task.setProcessDefinitionId(findProcessDefinitionEntityByTaskId(  
96.                     taskId).getId());  
97.             task.setProcessInstanceId(findProcessInstanceByTaskId(taskId)  
98.                     .getId());  
99.             task.setParentTaskId(taskId);  
100.             task.setDescription("jointProcess");  
101.             taskService.saveTask(task);  
102.         }  
103.     }  
104.     public void transferAssignee(String taskId, String userCode) {  
105.         taskService.setAssignee(taskId, userCode);  
106.     }  
107.     private void commitProcess(String taskId, Map<String, Object> variables,  
108.             String activityId) throws Exception {  
109.         if (variables == null) {  
110.             variables = new HashMap<String, Object>();  
111.         }  
112.         // 跳转节点为空，默认提交操作  
113.         if (StringUtil.isNull(activityId)) {  
114.             taskService.complete(taskId, variables);  
115.         } else {// 流程转向操作  
116.             turnTransition(taskId, activityId, variables);  
117.         }  
118.     }  
119.     private List<PvmTransition> clearTransition(ActivityImpl activityImpl) {  
120.         // 存储当前节点所有流向临时变量  
121.         List<PvmTransition> oriPvmTransitionList = new ArrayList<PvmTransition>();  
122.         // 获取当前节点所有流向，存储到临时变量，然后清空  
123.         List<PvmTransition> pvmTransitionList = activityImpl  
124.                 .getOutgoingTransitions();  
125.         for (PvmTransition pvmTransition : pvmTransitionList) {  
126.             oriPvmTransitionList.add(pvmTransition);  
127.         }  
128.         pvmTransitionList.clear();  
129.         return oriPvmTransitionList;  
130.     }  
131.     private void restoreTransition(ActivityImpl activityImpl,  
132.             List<PvmTransition> oriPvmTransitionList) {  
133.         // 清空现有流向  
134.         List<PvmTransition> pvmTransitionList = activityImpl  
135.                 .getOutgoingTransitions();  
136.         pvmTransitionList.clear();  
137.         // 还原以前流向  
138.         for (PvmTransition pvmTransition : oriPvmTransitionList) {  
139.             pvmTransitionList.add(pvmTransition);  
140.         }  
141.     }  
142.     private void turnTransition(String taskId, String activityId,  
143.             Map<String, Object> variables) throws Exception {  
144.         // 当前节点  
145.         ActivityImpl currActivity = findActivitiImpl(taskId, null);  
146.         // 清空当前流向  
147.         List<PvmTransition> oriPvmTransitionList = clearTransition(currActivity);  
148.         // 创建新流向  
149.         TransitionImpl newTransition = currActivity.createOutgoingTransition();  
150.         // 目标节点  
151.         ActivityImpl pointActivity = findActivitiImpl(taskId, activityId);  
152.         // 设置新流向的目标节点  
153.         newTransition.setDestination(pointActivity);  
154.         // 执行转向任务  
155.         taskService.complete(taskId, variables);  
156.         // 删除目标节点新流入  
157.         pointActivity.getIncomingTransitions().remove(newTransition);  
158.         // 还原以前流向  
159.         restoreTransition(currActivity, oriPvmTransitionList);  
160.     }  
161.     private List<ActivityImpl> iteratorBackActivity(String taskId,  
162.             ActivityImpl currActivity, List<ActivityImpl> rtnList,  
163.             List<ActivityImpl> tempList) throws Exception {  
164.         // 查询流程定义，生成流程树结构  
165.         ProcessInstance processInstance = findProcessInstanceByTaskId(taskId);  
166.         // 当前节点的流入来源  
167.         List<PvmTransition> incomingTransitions = currActivity  
168.                 .getIncomingTransitions();  
169.         // 条件分支节点集合，userTask节点遍历完毕，迭代遍历此集合，查询条件分支对应的userTask节点  
170.         List<ActivityImpl> exclusiveGateways = new ArrayList<ActivityImpl>();  
171.         // 并行节点集合，userTask节点遍历完毕，迭代遍历此集合，查询并行节点对应的userTask节点  
172.         List<ActivityImpl> parallelGateways = new ArrayList<ActivityImpl>();  
173.         // 遍历当前节点所有流入路径  
174.         for (PvmTransition pvmTransition : incomingTransitions) {  
175.             TransitionImpl transitionImpl = (TransitionImpl) pvmTransition;  
176.             ActivityImpl activityImpl = transitionImpl.getSource();  
177.             String type = (String) activityImpl.getProperty("type");  
178.             if ("parallelGateway".equals(type)) {// 并行路线  
179.                 String gatewayId = activityImpl.getId();  
180.                 String gatewayType = gatewayId.substring(gatewayId  
181.                         .lastIndexOf("_") + 1);  
182.                 if ("START".equals(gatewayType.toUpperCase())) {// 并行起点，停止递归  
183.                     return rtnList;  
184.                 } else {// 并行终点，临时存储此节点，本次循环结束，迭代集合，查询对应的userTask节点  
185.                     parallelGateways.add(activityImpl);  
186.                 }  
187.             } else if ("startEvent".equals(type)) {// 开始节点，停止递归  
188.                 return rtnList;  
189.             } else if ("userTask".equals(type)) {// 用户任务  
190.                 tempList.add(activityImpl);  
191.             } else if ("exclusiveGateway".equals(type)) {// 分支路线，临时存储此节点，本次循环结束，迭代集合，查询对应的userTask节点  
192.                 currActivity = transitionImpl.getSource();  
193.                 exclusiveGateways.add(currActivity);  
194.             }  
195.         }  
196.         for (ActivityImpl activityImpl : exclusiveGateways) {  
197.             iteratorBackActivity(taskId, activityImpl, rtnList, tempList);  
198.         }  
199.         for (ActivityImpl activityImpl : parallelGateways) {  
200.             iteratorBackActivity(taskId, activityImpl, rtnList, tempList);  
201.         }  
202.         currActivity = filterNewestActivity(processInstance, tempList);  
203.         if (currActivity != null) {  
204.             // 查询当前节点的流向是否为并行终点，并获取并行起点ID  
205.             String id = findParallelGatewayId(currActivity);  
206.             if (StringUtil.isNull(id)) {// 并行起点ID为空，此节点流向不是并行终点，符合驳回条件，存储此节点  
207.                 rtnList.add(currActivity);  
208.             } else {// 根据并行起点ID查询当前节点，然后迭代查询其对应的userTask任务节点  
209.                 currActivity = findActivitiImpl(taskId, id);  
210.             }  
211.             // 清空本次迭代临时集合  
212.             tempList.clear();  
213.             // 执行下次迭代  
214.             iteratorBackActivity(taskId, currActivity, rtnList, tempList);  
215.         }  
216.         return rtnList;  
217.     }  
218.     private List<ActivityImpl> reverList(List<ActivityImpl> list) {  
219.         List<ActivityImpl> rtnList = new ArrayList<ActivityImpl>();  
220.         // 由于迭代出现重复数据，排除重复  
221.         for (int i = list.size(); i > 0; i--) {  
222.             if (!rtnList.contains(list.get(i - 1)))  
223.                 rtnList.add(list.get(i - 1));  
224.         }  
225.         return rtnList;  
226.     }  
227.     private String findParallelGatewayId(ActivityImpl activityImpl) {  
228.         List<PvmTransition> incomingTransitions = activityImpl  
229.                 .getOutgoingTransitions();  
230.         for (PvmTransition pvmTransition : incomingTransitions) {  
231.             TransitionImpl transitionImpl = (TransitionImpl) pvmTransition;  
232.             activityImpl = transitionImpl.getDestination();  
233.             String type = (String) activityImpl.getProperty("type");  
234.             if ("parallelGateway".equals(type)) {// 并行路线  
235.                 String gatewayId = activityImpl.getId();  
236.                 String gatewayType = gatewayId.substring(gatewayId  
237.                         .lastIndexOf("_") + 1);  
238.                 if ("END".equals(gatewayType.toUpperCase())) {  
239.                     return gatewayId.substring(0, gatewayId.lastIndexOf("_"))  
240.                             + "_start";  
241.                 }  
242.             }  
243.         }  
244.         return null;  
245.     }  
246.     private ActivityImpl filterNewestActivity(ProcessInstance processInstance,  
247.             List<ActivityImpl> tempList) {  
248.         while (tempList.size() > 0) {  
249.             ActivityImpl activity_1 = tempList.get(0);  
250.             HistoricActivityInstance activityInstance_1 = findHistoricUserTask(  
251.                     processInstance, activity_1.getId());  
252.             if (activityInstance_1 == null) {  
253.                 tempList.remove(activity_1);  
254.                 continue;  
255.             }  
256.             if (tempList.size() > 1) {  
257.                 ActivityImpl activity_2 = tempList.get(1);  
258.                 HistoricActivityInstance activityInstance_2 = findHistoricUserTask(  
259.                         processInstance, activity_2.getId());  
260.                 if (activityInstance_2 == null) {  
261.                     tempList.remove(activity_2);  
262.                     continue;  
263.                 }  
264.                 if (activityInstance_1.getEndTime().before(  
265.                         activityInstance_2.getEndTime())) {  
266.                     tempList.remove(activity_1);  
267.                 } else {  
268.                     tempList.remove(activity_2);  
269.                 }  
270.             } else {  
271.                 break;  
272.             }  
273.         }  
274.         if (tempList.size() > 0) {  
275.             return tempList.get(0);  
276.         }  
277.         return null;  
278.     }  
279.     private HistoricActivityInstance findHistoricUserTask(  
280.             ProcessInstance processInstance, String activityId) {  
281.         HistoricActivityInstance rtnVal = null;  
282.         // 查询当前流程实例审批结束的历史节点  
283.         List<HistoricActivityInstance> historicActivityInstances = historyService  
284.                 .createHistoricActivityInstanceQuery().activityType("userTask")  
285.                 .processInstanceId(processInstance.getId()).activityId(  
286.                         activityId).finished()  
287.                 .orderByHistoricActivityInstanceEndTime().desc().list();  
288.         if (historicActivityInstances.size() > 0) {  
289.             rtnVal = historicActivityInstances.get(0);  
290.         }  
291.         return rtnVal;  
292.     }  
293.     public void setFormService(FormService formService) {  
294.         this.formService = formService;  
295.     }  
296.     public void setHistoryService(HistoryService historyService) {  
297.         this.historyService = historyService;  
298.     }  
299.     public void setRepositoryService(RepositoryService repositoryService) {  
300.         this.repositoryService = repositoryService;  
301.     }  
302.     public void setRuntimeService(RuntimeService runtimeService) {  
303.         this.runtimeService = runtimeService;  
304.     }  
305.     public void setTaskService(TaskService taskService) {  
306.         this.taskService = taskService;  
307.     }  
308.     public void setProcessOtherService(ProcessOtherService processOtherService) {  
309.         this.processOtherService = processOtherService;  
310.     }  
311.     private TaskEntity findTaskById(String taskId) throws Exception {  
312.         TaskEntity task = (TaskEntity) taskService.createTaskQuery().taskId(  
313.                 taskId).singleResult();  
314.         if (task == null) {  
315.             throw new Exception("任务实例未找到!");  
316.         }  
317.         return task;  
318.     }  
319.     private List<Task> findTaskListByKey(String processInstanceId, String key) {  
320.         return taskService.createTaskQuery().processInstanceId(  
321.                 processInstanceId).taskDefinitionKey(key).list();  
322.     }  
323.     private ProcessInstance findProcessInstanceByTaskId(String taskId)  
324.             throws Exception {  
325.         // 找到流程实例  
326.         ProcessInstance processInstance = runtimeService  
327.                 .createProcessInstanceQuery().processInstanceId(  
328.                         findTaskById(taskId).getProcessInstanceId())  
329.                 .singleResult();  
330.         if (processInstance == null) {  
331.             throw new Exception("流程实例未找到!");  
332.         }  
333.         return processInstance;  
334.     }  
335.     private ProcessDefinitionEntity findProcessDefinitionEntityByTaskId(  
336.             String taskId) throws Exception {  
337.         // 取得流程定义  
338.         ProcessDefinitionEntity processDefinition = (ProcessDefinitionEntity) ((RepositoryServiceImpl) repositoryService)  
339.                 .getDeployedProcessDefinition(findTaskById(taskId)  
340.                         .getProcessDefinitionId());  
341.         if (processDefinition == null) {  
342.             throw new Exception("流程定义未找到!");  
343.         }  
344.         return processDefinition;  
345.     }  
346.     private ActivityImpl findActivitiImpl(String taskId, String activityId)  
347.             throws Exception {  
348.         // 取得流程定义  
349.         ProcessDefinitionEntity processDefinition = findProcessDefinitionEntityByTaskId(taskId);  
350.         // 获取当前活动节点ID  
351.         if (StringUtil.isNull(activityId)) {  
352.             activityId = findTaskById(taskId).getTaskDefinitionKey();  
353.         }  
354.         // 根据流程定义，获取该流程实例的结束节点  
355.         if (activityId.toUpperCase().equals("END")) {  
356.             for (ActivityImpl activityImpl : processDefinition.getActivities()) {  
357.                 List<PvmTransition> pvmTransitionList = activityImpl  
358.                         .getOutgoingTransitions();  
359.                 if (pvmTransitionList.isEmpty()) {  
360.                     return activityImpl;  
361.                 }  
362.             }  
363.         }  
364.         // 根据节点ID，获取对应的活动节点  
365.         ActivityImpl activityImpl = ((ProcessDefinitionImpl) processDefinition)  
366.                 .findActivity(activityId);  
367.         return activityImpl;  
368.     }  
369. }