Activiti从当前任务任意回退至已审批任务

http://www.verydemo.com/demo_c161_i143918.html

[java]  view plain copy

1. import java.util.HashMap;  
2. import java.util.Iterator;  
3. import java.util.List;  
4. import java.util.Map;  
5. import org.activiti.engine.ActivitiException;  
6. import org.activiti.engine.RepositoryService;  
7. import org.activiti.engine.impl.ProcessEngineImpl;  
8. import org.activiti.engine.impl.RepositoryServiceImpl;  
9. import org.activiti.engine.impl.db.DbSqlSession;  
10. import org.activiti.engine.impl.db.DbSqlSessionFactory;  
11. import org.activiti.engine.impl.db.ListQueryParameterObject;  
12. import org.activiti.engine.impl.persistence.entity.ExecutionEntity;  
13. import org.activiti.engine.impl.persistence.entity.HistoricTaskInstanceEntity;  
14. import org.activiti.engine.impl.persistence.entity.IdentityLinkEntity;  
15. import org.activiti.engine.impl.persistence.entity.ProcessDefinitionEntity;  
16. import org.activiti.engine.impl.persistence.entity.TaskEntity;  
17. import org.activiti.engine.impl.pvm.process.ActivityImpl;  
18. import org.activiti.rest.api.ActivitiUtil;  
19. import org.apache.ibatis.session.SqlSession;  
20. import org.apache.ibatis.session.SqlSessionFactory;  
21.   
22. /* 
23. * 2013.01.25 
24. * 
25. * 任务回退 
26. * 
27. * 需求：从当前任务 任意回退至已审批任务 
28. * 方法：通过activiti源代码里的sqlSession直接修改数据库 
29. * 
30. * 第一步 完成历史TASK覆盖当前TASK 
31. * 用hi_taskinst修改当前ru_task 
32. * ru_task.ID_=hi_taskinst.ID_ 
33. * ru_task.NAME_=hi_taskinst.NAME_ 
34. * ru_task.TASK_DEF_KEY_=hi_taskinst.TASK_DEF_KEY_ 
35. * 
36. * 第二步 
37. * 修改当前任务参与人列表 
38. * ru_identitylink 用ru_task.ID_去ru_identitylink 索引 
39. * ru_identitylink.TASK_ID_=hi_taskinst.ID_ 
40. * ru_identitylink.USER_ID=hi_taskinst.ASSIGNEE_ 
41. * 
42. * 第三步修改流程记录节点 把ru_execution的ACT_ID_ 改为hi_taskinst.TASK_DEF_KEY_ 
43. * 
44. * author:pvii007 
45. * version:1.0 
46. */  
47. public class DbTaskReturn  
48. {  
49.     public static final int I_NO_OPERATION = 0;  
50.   
51.     public static final int I_DONE = 1;  
52.   
53.     public static final int I_TASK_NOT_FOUND = 2;  
54.   
55.     public static final int I_ROLLBACK = 3;  
56.   
57.     /* 
58.     * 实现回退方法 
59.     */  
60.     public static int dbBackTo(String currentTaskId, String backToTaskId)  
61.     {  
62.         int result = DbTaskReturn.I_NO_OPERATION;  
63.         SqlSession sqlSession = getSqlSession();  
64.         TaskEntity currentTaskEntity = getCurrentTaskEntity(currentTaskId);  
65.         HistoricTaskInstanceEntity backToHistoricTaskInstanceEntity = getHistoryTaskEntity(backToTaskId);  
66.         if (currentTaskEntity == null || backToHistoricTaskInstanceEntity == null)  
67.         {  
68.             return DbTaskReturn.I_TASK_NOT_FOUND;  
69.         }  
70.         String processDefinitionId = currentTaskEntity.getProcessDefinitionId();  
71.         String executionId = currentTaskEntity.getExecutionId();  
72.         String currentTaskEntityId = currentTaskEntity.getId();  
73.         String backToHistoricTaskInstanceEntityId = backToHistoricTaskInstanceEntity.getId();  
74.         String backToTaskDefinitionKey = backToHistoricTaskInstanceEntity.getTaskDefinitionKey();  
75.         String backToAssignee = backToHistoricTaskInstanceEntity.getAssignee();  
76.         boolean success = false;  
77.         try  
78.         {  
79.             // 1.  
80.             StepOne_use_hi_taskinst_to_change_ru_task(sqlSession, currentTaskEntity, backToHistoricTaskInstanceEntity);  
81.             // 2.  
82.             StepTwo_change_ru_identitylink(sqlSession, currentTaskEntityId, backToHistoricTaskInstanceEntityId,  
83.                 backToAssignee);  
84.             // 3.  
85.             StepThree_change_ru_execution(sqlSession, executionId, processDefinitionId, backToTaskDefinitionKey);  
86.             success = true;  
87.         }  
88.         catch (Exception e)  
89.         {  
90.             throw new ActivitiException("dbBackTo Exception", e);  
91.         }  
92.         finally  
93.         {  
94.             if (success)  
95.             {  
96.                 sqlSession.commit();  
97.                 result = DbTaskReturn.I_DONE;  
98.             }  
99.             else  
100.             {  
101.                 sqlSession.rollback();  
102.                 result = DbTaskReturn.I_ROLLBACK;  
103.             }  
104.             sqlSession.close();  
105.         }  
106.         return result;  
107.     }  
108.   
109.     private static void StepThree_change_ru_execution(SqlSession sqlSession, String executionId,  
110.             String processDefinitionId, String backToTaskDefinitionKey) throws Exception  
111.     {  
112.         List<ExecutionEntity> currentExecutionEntityList = sqlSession.selectList("selectExecution", executionId);  
113.         if (currentExecutionEntityList.size() > 0)  
114.         {  
115.             ActivityImpl activity = getActivitiImp(processDefinitionId, backToTaskDefinitionKey);  
116.             Iterator<ExecutionEntity> execution = currentExecutionEntityList.iterator();  
117.             while (execution.hasNext())  
118.             {  
119.                 ExecutionEntity e = execution.next();  
120.                 e.setActivity(activity);  
121.                 p(sqlSession.update("updateExecution", e));  
122.             }  
123.         }  
124.     }  
125.   
126.     private static void StepTwo_change_ru_identitylink(SqlSession sqlSession, String currentTaskEntityId,  
127.             String backToHistoricTaskInstanceEntityId, String backToAssignee) throws Exception  
128.     {  
129.         ListQueryParameterObject para = new ListQueryParameterObject();  
130.         para.setParameter(currentTaskEntityId);  
131.         List<IdentityLinkEntity> currentTaskIdentityLinkEntityList = sqlSession.selectList("selectIdentityLinksByTask",  
132.             para);  
133.         if (currentTaskIdentityLinkEntityList.size() > 0)  
134.         {  
135.             Iterator<IdentityLinkEntity> identityLinkEntityList = currentTaskIdentityLinkEntityList.iterator();  
136.             IdentityLinkEntity identityLinkEntity;  
137.             TaskEntity tmpTaskEntity;  
138.             tmpTaskEntity = new TaskEntity();  
139.             tmpTaskEntity.setId(backToHistoricTaskInstanceEntityId);  
140.             while (identityLinkEntityList.hasNext())  
141.             {  
142.                 identityLinkEntity = identityLinkEntityList.next();  
143.                 identityLinkEntity.setTask(tmpTaskEntity);  
144.                 identityLinkEntity.setUserId(backToAssignee);  
145.                 Map<String, Object> parameters = new HashMap<String, Object>();  
146.                 parameters.put("id", identityLinkEntity.getId());  
147.                 sqlSession.delete("deleteIdentityLink", parameters);  
148.                 sqlSession.insert("insertIdentityLink", identityLinkEntity);  
149.             }  
150.         }  
151.     }  
152.   
153.     private static void StepOne_use_hi_taskinst_to_change_ru_task(SqlSession sqlSession, TaskEntity currentTaskEntity,  
154.             HistoricTaskInstanceEntity backToHistoricTaskInstanceEntity) throws Exception  
155.     {  
156.         sqlSession.delete("deleteTask", currentTaskEntity);  
157.         currentTaskEntity.setName(backToHistoricTaskInstanceEntity.getName());  
158.         currentTaskEntity.setTaskDefinitionKey(backToHistoricTaskInstanceEntity.getTaskDefinitionKey());  
159.         currentTaskEntity.setId(backToHistoricTaskInstanceEntity.getId());  
160.         sqlSession.insert("insertTask", currentTaskEntity);  
161.     }  
162.   
163.     public static void p(Object o)  
164.     {  
165.         System.out.println(o);  
166.     }  
167.   
168.     private static ActivityImpl getActivitiImp(String processDefinitionId, String taskDefinitionKey)  
169.     {  
170.         RepositoryService repositoryService = ActivitiUtil.getRepositoryService();  
171.         ProcessDefinitionEntity processDefinition = (ProcessDefinitionEntity) ((RepositoryServiceImpl) repositoryService)  
172.                 .getDeployedProcessDefinition(processDefinitionId);  
173.         List<ActivityImpl> activitiList = processDefinition.getActivities();  
174.         boolean b;  
175.         Object activityId;  
176.         for (ActivityImpl activity : activitiList)  
177.         {  
178.             activityId = activity.getId();  
179.             b = activityId.toString().equals(taskDefinitionKey);  
180.             if (b)  
181.             {  
182.                 return activity;  
183.             }  
184.         }  
185.         return null;  
186.     }  
187.   
188.     private static TaskEntity getCurrentTaskEntity(String id)  
189.     {  
190.         return (TaskEntity) ActivitiUtil.getTaskService().createTaskQuery().taskId(id).singleResult();  
191.     }  
192.   
193.     private static HistoricTaskInstanceEntity getHistoryTaskEntity(String id)  
194.     {  
195.         return (HistoricTaskInstanceEntity) ActivitiUtil.getHistoryService().createHistoricTaskInstanceQuery()  
196.                 .taskId(id).singleResult();  
197.     }  
198.   
199.     private static SqlSession getSqlSession()  
200.     {  
201.         ProcessEngineImpl processEngine = (ProcessEngineImpl) ActivitiUtil.getProcessEngine();  
202.         DbSqlSessionFactory dbSqlSessionFactory = (DbSqlSessionFactory) processEngine.getProcessEngineConfiguration()  
203.                 .getSessionFactories().get(DbSqlSession.class);  
204.         SqlSessionFactory sqlSessionFactory = dbSqlSessionFactory.getSqlSessionFactory();  
205.         return sqlSessionFactory.openSession();  
206.     }  
207. }