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

 package com.famousPro.process.service.impl;

 import java.util.ArrayList;
 import java.util.HashMap;
 import java.util.List;
 import java.util.Map;

 import org.activiti.engine.FormService;
 import org.activiti.engine.HistoryService;
 import org.activiti.engine.RepositoryService;
 import org.activiti.engine.RuntimeService;
 import org.activiti.engine.TaskService;
 import org.activiti.engine.history.HistoricActivityInstance;
 import org.activiti.engine.impl.RepositoryServiceImpl;
 import org.activiti.engine.impl.persistence.entity.ProcessDefinitionEntity;
 import org.activiti.engine.impl.persistence.entity.TaskEntity;
 import org.activiti.engine.impl.pvm.PvmTransition;
 import org.activiti.engine.impl.pvm.process.ActivityImpl;
 import org.activiti.engine.impl.pvm.process.ProcessDefinitionImpl;
 import org.activiti.engine.impl.pvm.process.TransitionImpl;
 import org.activiti.engine.runtime.ProcessInstance;
 import org.activiti.engine.task.Task;

 import com.famousPro.common.service.impl.BaseServiceImp;
 import com.famousPro.common.util.IDGenerator;
 import com.famousPro.common.util.StringUtil;
 import com.famousPro.process.service.ProcessCoreService;
 import com.famousPro.process.service.ProcessOtherService;

 /**
  * 流程操作核心类
  * 此核心类主要处理：流程通过、驳回、会签、转办、中止、挂起等核心操作
  *
  * @author wangfuwei
  *
  */
 public class ProcessCoreServiceImpl extends BaseServiceImp implements
         ProcessCoreService {
     protected RepositoryService repositoryService;

     protected RuntimeService runtimeService;

     protected TaskService taskService;

     protected FormService formService;

     protected HistoryService historyService;

     protected ProcessOtherService processOtherService;

     /**
      * 根据当前任务ID，查询可以驳回的任务节点
      *
      * @param taskId
      *            当前任务ID
      */
     public List findBackAvtivity(String taskId) throws Exception {
         List rtnList = null;
         if (processOtherService.isJointTask(taskId)) {// 会签任务节点，不允许驳回
             rtnList = new ArrayList();
         } else {
             rtnList = iteratorBackActivity(taskId, findActivitiImpl(taskId,
                     null), new ArrayList(),
                     new ArrayList());
         }
         return reverList(rtnList);
     }

     /**
      * 审批通过(驳回直接跳回功能需后续扩展)
      *
      * @param taskId
      *            当前任务ID
      * @param variables
      *            流程存储参数
      * @throws Exception
      */
     public void passProcess(String taskId, Map variables)
             throws Exception {
         List tasks = taskService.createTaskQuery().parentTaskId(taskId)
                 .taskDescription("jointProcess").list();
         for (Task task : tasks) {// 级联结束本节点发起的会签任务
             commitProcess(task.getId(), null, null);
         }
         commitProcess(taskId, variables, null);
     }

     /**
      * 驳回流程
      *
      * @param taskId
      *            当前任务ID
      * @param activityId
      *            驳回节点ID
      * @param variables
      *            流程存储参数
      * @throws Exception
      */
     public void backProcess(String taskId, String activityId,
             Map variables) throws Exception {
         if (StringUtil.isNull(activityId)) {
             throw new Exception("驳回目标节点ID为空！");
         }

         // 查询本节点发起的会签任务，并结束
         List tasks = taskService.createTaskQuery().parentTaskId(taskId)
                 .taskDescription("jointProcess").list();
         for (Task task : tasks) {
             commitProcess(task.getId(), null, null);
         }

         // 查找所有并行任务节点，同时驳回
         List taskList = findTaskListByKey(findProcessInstanceByTaskId(
                 taskId).getId(), findTaskById(taskId).getTaskDefinitionKey());
         for (Task task : taskList) {
             commitProcess(task.getId(), variables, activityId);
         }
     }

     /**
      * 取回流程
      *
      * @param taskId
      *            当前任务ID
      * @param activityId
      *            取回节点ID
      * @throws Exception
      */
     public void callBackProcess(String taskId, String activityId)
             throws Exception {
         if (StringUtil.isNull(activityId)) {
             throw new Exception("目标节点ID为空！");
         }

         // 查找所有并行任务节点，同时取回
         List taskList = findTaskListByKey(findProcessInstanceByTaskId(
                 taskId).getId(), findTaskById(taskId).getTaskDefinitionKey());
         for (Task task : taskList) {
             commitProcess(task.getId(), null, activityId);
         }
     }

     /**
      * 中止流程(特权人直接审批通过等)
      *
      * @param taskId
      */
     public void endProcess(String taskId) throws Exception {
         ActivityImpl endActivity = findActivitiImpl(taskId, "end");
         commitProcess(taskId, null, endActivity.getId());
     }

     /**
      * 会签操作
      *
      * @param taskId
      *            当前任务ID
      * @param userCodes
      *            会签人账号集合
      * @throws Exception
      */
     public void jointProcess(String taskId, List userCodes)
             throws Exception {
         for (String userCode : userCodes) {
             TaskEntity task = (TaskEntity) taskService.newTask(IDGenerator
                     .generateID());
             task.setAssignee(userCode);
             task.setName(findTaskById(taskId).getName() + "-会签");
             task.setProcessDefinitionId(findProcessDefinitionEntityByTaskId(
                     taskId).getId());
             task.setProcessInstanceId(findProcessInstanceByTaskId(taskId)
                     .getId());
             task.setParentTaskId(taskId);
             task.setDescription("jointProcess");
             taskService.saveTask(task);
         }
     }

     /**
      * 转办流程
      *
      * @param taskId
      *            当前任务节点ID
      * @param userCode
      *            被转办人Code
      */
     public void transferAssignee(String taskId, String userCode) {
         taskService.setAssignee(taskId, userCode);
     }

     /**
      * ***************************************************************************************************************************************************
      * ************************************************以下为流程会签操作核心逻辑******************************************************************************
      * ***************************************************************************************************************************************************
      */

     /**
      * ***************************************************************************************************************************************************
      * ************************************************以上为流程会签操作核心逻辑******************************************************************************
      * ***************************************************************************************************************************************************
      */

     /**
      * ***************************************************************************************************************************************************
      * ************************************************以下为流程转向操作核心逻辑******************************************************************************
      * ***************************************************************************************************************************************************
      */

     /**
      * @param taskId
      *            当前任务ID
      * @param variables
      *            流程变量
      * @param activityId
      *            流程转向执行任务节点ID
      *            此参数为空，默认为提交操作
      * @throws Exception
      */
     private void commitProcess(String taskId, Map variables,
             String activityId) throws Exception {
         if (variables == null) {
             variables = new HashMap();
         }
         // 跳转节点为空，默认提交操作
         if (StringUtil.isNull(activityId)) {
             taskService.complete(taskId, variables);
         } else {// 流程转向操作
             turnTransition(taskId, activityId, variables);
         }
     }

     /**
      * 清空指定活动节点流向
      *
      * @param activityImpl
      *            活动节点
      * @return 节点流向集合
      */
     private List clearTransition(ActivityImpl activityImpl) {
         // 存储当前节点所有流向临时变量
         List oriPvmTransitionList = new ArrayList();
         // 获取当前节点所有流向，存储到临时变量，然后清空
         List pvmTransitionList = activityImpl
                 .getOutgoingTransitions();
         for (PvmTransition pvmTransition : pvmTransitionList) {
             oriPvmTransitionList.add(pvmTransition);
         }
         pvmTransitionList.clear();

         return oriPvmTransitionList;
     }

     /**
      * 还原指定活动节点流向
      *
      * @param activityImpl
      *            活动节点
      * @param oriPvmTransitionList
      *            原有节点流向集合
      */
     private void restoreTransition(ActivityImpl activityImpl,
             List oriPvmTransitionList) {
         // 清空现有流向
         List 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 variables) throws Exception {
         // 当前节点
         ActivityImpl currActivity = findActivitiImpl(taskId, null);
         // 清空当前流向
         List 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 iteratorBackActivity(String taskId,
             ActivityImpl currActivity, List rtnList,
             List tempList) throws Exception {
         // 查询流程定义，生成流程树结构
         ProcessInstance processInstance = findProcessInstanceByTaskId(taskId);

         // 当前节点的流入来源
         List incomingTransitions = currActivity
                 .getIncomingTransitions();
         // 条件分支节点集合，userTask节点遍历完毕，迭代遍历此集合，查询条件分支对应的userTask节点
         List exclusiveGateways = new ArrayList();
         // 并行节点集合，userTask节点遍历完毕，迭代遍历此集合，查询并行节点对应的userTask节点
         List parallelGateways = new ArrayList();
         // 遍历当前节点所有流入路径
         for (PvmTransition pvmTransition : incomingTransitions) {
             TransitionImpl transitionImpl = (TransitionImpl) pvmTransition;
             ActivityImpl activityImpl = transitionImpl.getSource();
             String type = (String) activityImpl.getProperty("type");
             /**
              * 并行节点配置要求：
              * 必须成对出现，且要求分别配置节点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 (StringUtil.isNull(id)) {// 并行起点ID为空，此节点流向不是并行终点，符合驳回条件，存储此节点
                 rtnList.add(currActivity);
             } else {// 根据并行起点ID查询当前节点，然后迭代查询其对应的userTask任务节点
                 currActivity = findActivitiImpl(taskId, id);
             }

             // 清空本次迭代临时集合
             tempList.clear();
             // 执行下次迭代
             iteratorBackActivity(taskId, currActivity, rtnList, tempList);
         }
         return rtnList;
     }

     /**
      * 反向排序list集合，便于驳回节点按顺序显示
      *
      * @param list
      * @return
      */
     private List reverList(List list) {
         List rtnList = new ArrayList();
         // 由于迭代出现重复数据，排除重复
         for (int i = list.size(); i > 0; i--) {
             if (!rtnList.contains(list.get(i - 1)))
                 rtnList.add(list.get(i - 1));
         }
         return rtnList;
     }

     /**
      * 根据当前节点，查询输出流向是否为并行终点，如果为并行终点，则拼装对应的并行起点ID
      *
      * @param activityImpl
      *            当前节点
      * @return
      */
     private String findParallelGatewayId(ActivityImpl activityImpl) {
         List 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 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 historicActivityInstances = historyService
                 .createHistoricActivityInstanceQuery().activityType("userTask")
                 .processInstanceId(processInstance.getId()).activityId(
                         activityId).finished()
                 .orderByHistoricActivityInstanceEndTime().desc().list();
         if (historicActivityInstances.size() > 0) {
             rtnVal = historicActivityInstances.get(0);
         }

         return rtnVal;
     }

     /**
      * *******************************************************************************************************
      * ********************************以上为查询流程驳回节点核心逻辑***********************************************
      * ********************************************************************************************************
      */

     /**
      * ********************************************************************************
      * **********************以下为activiti 核心service
      * set方法***************************
      * *********************************************************************************
      */
     public void setFormService(FormService formService) {
         this.formService = formService;
     }

     public void setHistoryService(HistoryService historyService) {
         this.historyService = historyService;
     }

     public void setRepositoryService(RepositoryService repositoryService) {
         this.repositoryService = repositoryService;
     }

     public void setRuntimeService(RuntimeService runtimeService) {
         this.runtimeService = runtimeService;
     }

     public void setTaskService(TaskService taskService) {
         this.taskService = taskService;
     }

     /**
      * ********************************************************************************
      * **********************以上为activiti 核心service
      * set方法***************************
      * *********************************************************************************
      */

     /**
      * ********************************************************************************
      * **********************以下为根据 任务节点ID 获取流程各对象查询方法**********************
      * *********************************************************************************
      */

     public void setProcessOtherService(ProcessOtherService processOtherService) {
         this.processOtherService = processOtherService;
     }

     /**
      * 根据任务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和任务key值查询所有同级任务集合
      *
      * @param processInstanceId
      * @param key
      * @return
      */
     private List findTaskListByKey(String processInstanceId, String key) {
         return taskService.createTaskQuery().processInstanceId(
                 processInstanceId).taskDefinitionKey(key).list();
     }

     /**
      * 根据任务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;
     }

     /**
      * 根据任务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和节点ID获取活动节点
      *
      * @param taskId
      *            任务ID
      * @param activityId
      *            活动节点ID
      *            如果为null或""，则默认查询当前活动节点
      *            如果为"end"，则查询结束节点
      *
      * @return
      * @throws Exception
      */
     private ActivityImpl findActivitiImpl(String taskId, String activityId)
             throws Exception {
         // 取得流程定义
         ProcessDefinitionEntity processDefinition = findProcessDefinitionEntityByTaskId(taskId);

         // 获取当前活动节点ID
         if (StringUtil.isNull(activityId)) {
             activityId = findTaskById(taskId).getTaskDefinitionKey();
         }

         // 根据流程定义，获取该流程实例的结束节点
         if (activityId.toUpperCase().equals("END")) {
             for (ActivityImpl activityImpl : processDefinition.getActivities()) {
                 List pvmTransitionList = activityImpl
                         .getOutgoingTransitions();
                 if (pvmTransitionList.isEmpty()) {
                     return activityImpl;
                 }
             }
         }

         // 根据节点ID，获取对应的活动节点
         ActivityImpl activityImpl = ((ProcessDefinitionImpl) processDefinition)
                 .findActivity(activityId);

         return activityImpl;
     }

     /**
      * ********************************************************************************
      * **********************以上为根据 任务节点ID 获取流程各对象查询方法**********************
      * *********************************************************************************
      */
 }