JBPM 用foreach做动态任务分配，另加驳回操作

<?xml version="1.0" encoding="UTF-8"?>

<process name="reject" xmlns="http://jbpm.org/4.4/jpdl">
    <start g="38,16,48,48" name="start1">  
        <transition to="报事"/>  
    </start>  
  
    <task assignee="task0" g="16,96,92,52" name="报事">  
        <transition to="拆单"/>  
    </task>  
  
    <task g="16,180,92,52" name="拆单" candidate-groups="工程师1,工程师2,工程3">
      <transition g="-72,-22" name="to foreach1" to="foreach1"/>  
    </task>  
    
    <foreach g="38,264,48,48" in="#{deptIds}" name="foreach1" var="deptId">
      <transition g="-52,-22" name="to task2" to="派单"/>
   </foreach>
  
    <task assignee="zg#{deptId}" g="16,344,92,52" name="派单">
      <transition name="to 处理确认" to="处理确认" g="-69,-22"/>
   </task>
  
   <join g="38,512,48,48" multiplicity="#{deptIdsLength}" name="join1">
      <transition g="-52,-22" name="to task3" to="是否回访"/>  
    </join>
    
  <task g="16,592,92,52" name="是否回访">
      <transition g="-50,-22" name="to end1" to="end1"/>
   </task>  
   
   <end g="38,676,48,48" name="end1"/>
   <task name="处理确认" g="16,428,92,52">
      <transition name="to join1" to="join1" g="-49,-22"/>
   </task>
</process>

<pre name="code" class="java">package rollback2;

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

import org.jbpm.api.Configuration;
import org.jbpm.api.Execution;
import org.jbpm.api.ProcessDefinition;
import org.jbpm.api.ProcessEngine;
import org.jbpm.api.ProcessInstance;
import org.jbpm.api.RepositoryService;
import org.jbpm.api.TaskService;
import org.jbpm.api.cmd.Command;
import org.jbpm.api.cmd.Environment;
import org.jbpm.api.model.Activity;
import org.jbpm.api.task.Task;
import org.jbpm.pvm.internal.env.EnvironmentFactory;
import org.jbpm.pvm.internal.env.EnvironmentImpl;
import org.jbpm.pvm.internal.model.ActivityImpl;
import org.jbpm.pvm.internal.model.ExecutionImpl;
import org.jbpm.pvm.internal.model.ProcessDefinitionImpl;
import org.jbpm.pvm.internal.model.TransitionImpl;
import org.jbpm.pvm.internal.repository.RepositoryServiceImpl;
import org.jbpm.pvm.internal.task.TaskDefinitionImpl;
import org.jbpm.pvm.internal.task.TaskImpl;
import org.junit.Before;
import org.junit.Test;

public class RollbackTest {
	ProcessEngine processEngine;
	
	String jdplPath;
	String pdkey;
	
	@Before
	public void setUp() throws Exception {
		processEngine = Configuration.getProcessEngine(); // 获取流程引擎
		jdplPath = "cn/moon/jpdl/reject.jpdl.xml";
	}
	
	/**
	 * 发布流程
	 */
	@Test
	public void deploy(){
		processEngine.getRepositoryService().createDeployment().addResourceFromClasspath(jdplPath).deploy();
	}
	
	@Test
	public void testApply(){
		/*
		Map<String, Object> values = new HashMap<String, Object>();
		List<Integer> deptIds = new ArrayList<Integer>();
		deptIds.add(1);
		deptIds.add(2);
		
		//FormView() "from .taskId"
		
		values.put("deptIds", deptIds);
		values.put("deptIdsLength", deptIds.size());
		*/
		
		processEngine.getExecutionService().startProcessInstanceByKey("reject", "gongdanhao1");
	}
	
	@Test
	public void takeTask() {
		String taskId = "490001"; // 从数据库中获取
		
		 Task task = processEngine.getTaskService().getTask(taskId);
		 //task.setAssignee("task5");
		 //String executionId = task.getExecutionId();
		 //processEngine.getExecutionService().
		// ProcessInstance processInstance = processEngine.getExecutionService().findProcessInstanceById(executionId);
		 //processInstance.get
		 // 根据当前任务得到当前流程实例ID
		 Map<String, Object> values = new HashMap<String, Object>();
			List<Integer> deptIds = new ArrayList<Integer>();
			deptIds.add(1);
			deptIds.add(2);
			//FormView() "from .taskId"
			
			values.put("deptIds", deptIds);
			values.put("deptIdsLength", deptIds.size());
		//processEngine.getTaskService().createTaskQuery().assignee("");
			processEngine.getTaskService().setVariables(taskId, values);
		 processEngine.getTaskService().findGroupTasks("工程3");	
		 //processEngine.getTaskService();
		 //processEngine.getTaskService().completeTask(taskId);
		
		
	}
	
	/**
	 * 把任务驳回到task0节点
	 */
	@Test
	public void testTaskForkOut (){
		processEngine.execute(new Command<Object>() {

			@Override
			public Object execute(Environment environment) throws Exception {
				String taskId = "430001"; // 直接查数据库任务表获取
				String activityName = "是否回访"; // 需要驳回到的指定节点名称
				
				TaskService taskService = environment.get(TaskService.class);
				RepositoryService repositoryService = (RepositoryServiceImpl)environment.get(RepositoryServiceImpl.class);
				TaskImpl task =  (TaskImpl) taskService.getTask(taskId);
				//task.setAssignee("task5");
			 	ExecutionImpl processInstance =  task.getExecution();
			 	ExecutionImpl execution = processInstance;
			 	
			 	ProcessDefinitionImpl procDefi =  (ProcessDefinitionImpl) repositoryService.createProcessDefinitionQuery()
			 		.processDefinitionId(execution.getProcessDefinitionId()).uniqueResult();
			 	
			 	// 取得当前流程的活动定义
			 	ActivityImpl activity = execution.getActivity();
			 	// 创建一个连接
			 	TransitionImpl transition = activity.createOutgoingTransition();
			 	transition.setSource(activity); // 设置当前活动为源活动
			 	transition.setDestination(procDefi.getActivity(activityName)); // 设置目的活动
			 	String transitionName = "" + new Date().getTime(); // 随便取个不重复的名字 
			 	transition.setName(transitionName); // 设为连接名
			 	activity.setDefaultOutgoingTransition(transition); // 设置当前活动默认指向
			 	
			 	if(execution.getIsProcessInstance()){ // 主实例，不是fork\foreach分支出来的实例
			 		task.take("feifei"); // 指定当前任务人
			 		task.complete(transitionName);
			 	}else{ // fork\foreach分支出来的实例，往外驳出
			 		processInstance = execution.getProcessInstance();
			 		processInstance.setState(ExecutionImpl.STATE_ACTIVE_ROOT);
			 		
			 		processInstance.setTransition(transition);
			 		processInstance.setActivity(activity);
			 		processInstance.take(transition);
			 		processInstance.setVariable("gdId", "工单ID"); // 返回驳回来源
			 		/*
			 		Collection<ExecutionImpl> executions = processInstance.getExecutions();
			 		ExecutionImpl[] executionArray = new ExecutionImpl[executions.size()];
			 		executions.toArray(executionArray);
			 		for(ExecutionImpl e : executionArray){
			 			e.end();
			 		}*/
			 		
			 		execution.end("error"); // 当前任务关闭结束
			 		
			 	}
			 	
				return null;
			}
			
		});
	}
	
	@Test
	public void testJump(){
		String taskId="300007";
		String preTaskName = "task1";
		String assignee = "jj";
		Task curTask = processEngine.getTaskService().getTask(taskId);
		//processEngine.getTaskService().completeTask("300005");
		Task preTask = jumpToPreTask(curTask, preTaskName, assignee);
		System.out.print("");
	}
	
	/**
	 * 从当前任务跳回上一任务 
	 * @param curTask
	 * @param toTaskName
	 * @param assignee
	 * @return
	 */
	public Task jumpToPreTask(Task curTask,String preTaskName ,String assignee){
		EnvironmentImpl env=null;  
        try{  
            TaskImpl task=(TaskImpl)curTask;  
            env=((EnvironmentFactory) processEngine).openEnvironment();  
            ProcessInstance pi=getProcessInstanceByTaskId(curTask.getId());  
              
            ProcessDefinitionImpl pd=(ProcessDefinitionImpl)getProcessDefinitionByTaskId(curTask.getId());  
            TaskDefinitionImpl taskDef= pd.getTaskDefinition(preTaskName);  
            //更换其Execution  
            ExecutionImpl exeImpl=(ExecutionImpl)pi;  
            //更换其活动的定义  
            Activity preActivity=pd.findActivity(preTaskName );  
            exeImpl.setActivity(preActivity);  
            task.setActivityName(preTaskName );  
            task.setName(preTaskName);  
            task.setDescription(preTaskName);  
            task.setExecution(exeImpl);  
            //更换执行人  
            task.setAssignee(assignee);  
            task.setCreateTime(new Date());  
            task.setSignalling(true);  
            task.setNew(true);  
            //更换流程任务的定义  
            if(taskDef!=null){  
                task.setTaskDefinition(taskDef);  
            }else{  
                //查看其是否为开始任务，这表示开始任务TODO  
                //String startName=jbpmService.getStartNodeName();  
                TaskDefinitionImpl taskDefinition = new TaskDefinitionImpl();  
                taskDefinition.setName(preTaskName);  
                taskDefinition.setPriority(1);  
                taskDefinition.setProcessDefinition(pd);  
                  
                ActivityImpl startActivityImpl=pd.findActivity(preTaskName);  
                  
                ActivityImpl startTaskImpl=pd.createActivity();  
                startTaskImpl.setName(preTaskName);  
                List outTrans=new ArrayList();  
                outTrans.addAll(startActivityImpl.getOutgoingTransitions());  
                startTaskImpl.setOutgoingTransitions(outTrans);  
              
            }  
            processEngine.getTaskService().saveTask(task);
            return task;  
        }finally{  
            if(env!=null)env.close();  
        }  
	} 
	
	/**
	 * 根据任务ID得到流程实例
	 * @param taskId
	 * @return
	 */
	public ProcessInstance getProcessInstanceByTaskId(String taskId){
		TaskImpl task = (TaskImpl) processEngine.getTaskService().getTask(taskId);
		ExecutionImpl processInstance =task.getExecution(); // 取得当前任务执行实例
		return processInstance;
	}
	
	/**
	 * 根据任务ID得到流程定义
	 * @param taskId
	 * @return
	 */
	public ProcessDefinition getProcessDefinitionByTaskId(String taskId){
		TaskImpl task = (TaskImpl) processEngine.getTaskService().getTask(taskId);
		ExecutionImpl processInstance =task.getExecution(); // 取得当前任务执行实例
		return processInstance.getProcessDefinition();
	}
}