* Copyright 1996-2013 Founder International Co.,Ltd.

*

* Licensed under the Apache License, Version 2.0 (the "License");

* you may not use this file except in compliance with the License.

* You may obtain a copy of the License at

*

*      http://www.apache.org/licenses/LICENSE-2.0

*

* Unless required by applicable law or agreed to in writing, software

* distributed under the License is distributed on an "AS IS" BASIS,

* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.

* See the License for the specific language governing permissions and

* limitations under the License.

*

* @author yangchenhui

*/

 

  /**

   * 测试启动并提交，手工启动流程。

   */

  @Deployment(resources = { "com/founder/fix/fixflow/test/engine/api/task/TaskServiceNewTest.bpmn"})

  public void testStartAndSubmit(){

   

    //创建一个通用命令

    ExpandTaskCommand expandTaskCommand = new ExpandTaskCommand();

    //设置流程名

    expandTaskCommand.setProcessDefinitionKey("TaskServiceNewTest");

    //设置流程的业务关联键

    expandTaskCommand.setBusinessKey("BK_testStartProcessInstanceByKey");

    //命令类型，可以从流程引擎配置中查询   启动并提交为startandsubmit

    expandTaskCommand.setCommandType("startandsubmit");

    //设置提交人

    expandTaskCommand.setInitiator("1200119390");

    //设置命令的id,需和节点上配置的按钮编号对应，会执行按钮中的脚本。

    expandTaskCommand.setUserCommandId("HandleCommand_2");

    //执行这个启动并提交的命令，返回启动的流程实例

    ProcessInstance processInstance = (ProcessInstance)taskService.expandTaskComplete(expandTaskCommand, null);

    String processInstanceId = processInstance.getId();

    //验证是否成功启动

    assertNotNull(processInstanceId);

   

    // 创建任务查询

    TaskQuery taskQuery = taskService.createTaskQuery();

    // 查找 1200119390 的这个流程实例的当前独占任务

    List<TaskInstance> taskInstances = taskQuery.taskAssignee("1200119390").processInstanceId(processInstanceId).taskNotEnd().list();

    // 获取一条任务

    TaskInstance taskInstance = taskInstances.get(0);

    //验证这个待办是否为空

    assertNotNull(taskInstance);

    String nodeId = taskInstance.getNodeId();

    //验证流程实例是否在第二个节点

    assertEquals(nodeId, "UserTask_2");

  }

 

  /**

   * 测试提交命令，提交和启动并提交的区别在于：1.第一个节点是共享：则启动并提交=启动+接收任务+提交 2.第一个节点是独占：则启动并提交=启动+提交

   */

  @Deployment(resources = { "com/founder/fix/fixflow/test/engine/api/task/TaskServiceNewTest.bpmn"})

  public void testSubmit(){

   

    //启动流程命令

    StartProcessInstanceCommand startProcessInstanceCommand = new StartProcessInstanceCommand();

    //设置流程编号

    startProcessInstanceCommand.setProcessDefinitionKey("TaskServiceNewTest");

    //设置业务关联键

    startProcessInstanceCommand.setBusinessKey("BK_testStartProcessInstanceByKey");

    //设置流程启动人

    startProcessInstanceCommand.setStartAuthor("1200119390");

    //启动流程，只启动流程 ，流程停在第一步

    ProcessInstance processInstanceQueryTo = runtimeService

        .noneStartProcessInstance(startProcessInstanceCommand);

    String processInstanceId = processInstanceQueryTo.getId();

    //验证是否成功启动

    assertNotNull(processInstanceId);

    TaskQuery taskQuery = taskService.createTaskQuery();

    // 查找 1200119390 的这个流程实例的当前独占任务

    List<TaskInstance> taskInstances = taskQuery.taskAssignee("1200119390").processInstanceId(processInstanceId).taskNotEnd().list();

    // 获取一条任务

    TaskInstance taskInstance = taskInstances.get(0);

    String nodeId = taskInstance.getNodeId();

    //验证流程实例是否在第一个节点

    assertEquals(nodeId, "UserTask_1");

   

    //创建一个通用命令

    ExpandTaskCommand expandTaskCommand = new ExpandTaskCommand();

    //设置命令类型

    expandTaskCommand.setCommandType("submit");

    //设置任务号

    expandTaskCommand.setTaskId(taskInstance.getId());

    //设置命令ID  与节点上处理命令中一致，会执行按钮脚本

    expandTaskCommand.setUserCommandId("HandleCommand_3");

    //设置业务关联键

    expandTaskCommand.setBusinessKey("BK_testStartProcessInstanceByKey");

    //设置提交人

    expandTaskCommand.setInitiator("1200119390");

    //执行这个启动并提交的命令，返回启动的流程实例

    taskService.expandTaskComplete(expandTaskCommand, null);

    taskQuery = taskService.createTaskQuery();

    // 查找 1200119390 的这个流程实例的当前独占任务

    taskInstances = taskQuery.taskAssignee("1200119390").processInstanceId(processInstanceId).taskNotEnd().list();

    //验证是否成功启动

    taskInstance = taskInstances.get(0);

    nodeId = taskInstance.getNodeId();

    //验证当前任务是否在第二个节点

    assertEquals(nodeId, "UserTask_2");

  }

 

  /**

   * 测试通用命令 通用按钮只会驱动流程令牌离开，执行表达式命令，不做额外操作

   */

  @Deployment(resources = { "com/founder/fix/fixflow/test/engine/api/task/TaskServiceNewTest.bpmn"})

  public void testGeneral(){

   

    //创建一个通用命令

    ExpandTaskCommand expandTaskCommand = new ExpandTaskCommand();

    //设置流程名

    expandTaskCommand.setProcessDefinitionKey("TaskServiceNewTest");

    //设置流程的业务关联键

    expandTaskCommand.setBusinessKey("BK_testStartProcessInstanceByKey");

    //命令类型，可以从流程引擎配置中查询   启动并提交为startandsubmit

    expandTaskCommand.setCommandType("startandsubmit");

    //设置提交人

    expandTaskCommand.setInitiator("1200119390");

    //设置命令的id,需和节点上配置的按钮编号对应，会执行按钮中的脚本。

    expandTaskCommand.setUserCommandId("HandleCommand_2");

    //执行这个启动并提交的命令，返回启动的流程实例

    ProcessInstance processInstance = (ProcessInstance)taskService.expandTaskComplete(expandTaskCommand, null);

    String processInstanceId = processInstance.getId();

    //验证是否成功启动

    assertNotNull(processInstanceId);

   

    // 创建任务查询

    TaskQuery taskQuery = taskService.createTaskQuery();

    // 查找 1200119390 的这个流程实例的当前独占任务

    List<TaskInstance> taskInstances = taskQuery.taskAssignee("1200119390").processInstanceId(processInstanceId).taskNotEnd().list();

    // 获取一条任务

    TaskInstance taskInstance = taskInstances.get(0);

    //验证这个待办是否为空

    assertNotNull(taskInstance);

    String nodeId = taskInstance.getNodeId();

    //验证流程实例是否在第二个节点

    assertEquals(nodeId, "UserTask_2");

   

    //创建通用命令

    ExpandTaskCommand expandTaskCommandGeneral=new ExpandTaskCommand();

    //设置命令为领取任务

    expandTaskCommandGeneral.setCommandType("general");

    //设置命令的ID，需和节点上配置的按钮编号对应，会执行其中脚本

    expandTaskCommandGeneral.setUserCommandId("HandleCommand_2");

    //设置命令的处理任务号

    expandTaskCommandGeneral.setTaskId(taskInstance.getId());

    //领取任务

    taskService.expandTaskComplete(expandTaskCommandGeneral, null);

   

    //创建流程实例查询

    ProcessInstanceQuery processInstanceQuery = runtimeService.createProcessInstanceQuery();

    //获得上面的流程实例

    ProcessInstance process = processInstanceQuery.processInstanceId(processInstanceId).singleResult();

    //验证流程实例是否已经结束，结束说明通用按钮已经驱动流程离开当前节点。

    assertTrue(process.hasEnded());

  }

  /**

   * 测试接收任务和释放任务，TaskServiceCandidateTest流程中的任务分配类型为共享模式

   */

  @Deployment(resources = { "com/founder/fix/fixflow/test/engine/api/task/TaskServiceCandidateTest.bpmn"})

  public void testClaim(){

    //创建一个通用命令

    ExpandTaskCommand expandTaskCommand = new ExpandTaskCommand();

    //设置流程名

    expandTaskCommand.setProcessDefinitionKey("TaskServiceCandidateTest");

    //设置流程的业务关联键

    expandTaskCommand.setBusinessKey("BK_testStartProcessInstanceByKey");

    //命令类型，可以从流程引擎配置中查询   启动并提交为startandsubmit

    expandTaskCommand.setCommandType("startandsubmit");

    //设置提交人

    expandTaskCommand.setInitiator("1200119390");

    //设置命令的id,需和节点上配置的按钮编号对应，会执行按钮中的脚本。

    expandTaskCommand.setUserCommandId("HandleCommand_2");

    //执行这个启动并提交的命令，返回启动的流程实例

    ProcessInstance processInstance = (ProcessInstance)taskService.expandTaskComplete(expandTaskCommand, null);

    String processInstanceId = processInstance.getId();

    //验证是否成功启动

    assertNotNull(processInstanceId);

   

    // 创建任务查询

    TaskQuery taskQuery = taskService.createTaskQuery();

    // 查找 1200119390 的这个流程实例的当前独占任务

    List<TaskInstance> taskInstances = taskQuery.taskAssignee("1200119390").processInstanceId(processInstanceId).taskNotEnd().list();

    //未领任务前 独占任务应该为0

    assertEquals(taskInstances.size(), 0);

    //获取1200119390的本流程实例的共享任务

    taskInstances = taskQuery.taskCandidateUser("1200119390").processInstanceId(processInstanceId).taskNotEnd().list();

    //验证此时的共享任务为1

    assertEquals(taskInstances.size(), 1);

   

    //获取当前任务节点

    TaskInstance taskInstance = taskInstances.get(0);

    //创建通用命令

    ExpandTaskCommand expandTaskCommandClaim=new ExpandTaskCommand();

    //设置命令为领取任务

    expandTaskCommandClaim.setCommandType("claim");

    //设置命令的ID，需和节点上配置的按钮编号对应，会执行其中脚本

    expandTaskCommandClaim.setUserCommandId("HandleCommand_3");

    //设置命令的处理任务号

    expandTaskCommandClaim.setTaskId(taskInstance.getId());

    //领取任务

    taskService.expandTaskComplete(expandTaskCommandClaim, null);

   

    //重置任务查询 查询共享

    taskQuery = taskService.createTaskQuery();

    // 查找 1200119390 的这个流程实例的当前共享任务

    taskInstances = taskQuery.taskCandidateUser("1200119390").processInstanceId(processInstanceId).taskNotEnd().list();

    //领取任务后，共享任务数为0

    assertEquals(taskInstances.size(), 0);

    //重置任务查询 查询独占

    taskQuery = taskService.createTaskQuery();

    // 查找 1200119390 的这个流程实例的当前独占任务

    taskInstances = taskQuery.taskAssignee("1200119390").processInstanceId(processInstanceId).taskNotEnd().list();

    //领取任务后，独占任务数为1

    assertEquals(taskInstances.size(), 1);

   

    //取得当前任务

    taskInstance = taskInstances.get(0);

    //取得任务所在节点

    String nodeId = taskInstance.getNodeId();

    //验证当前任务是否在第二个节点

    assertEquals(nodeId, "UserTask_4");

   

    //创建通用命令

    ExpandTaskCommand expandTaskCommandRelease=new ExpandTaskCommand();

    //设置命令为释放任务

    expandTaskCommandRelease.setCommandType("releaseTask");

    //设置命令的id,需和节点上配置的按钮编号对应，会执行按钮中的脚本。

    expandTaskCommandRelease.setUserCommandId("HandleCommand_4");

    //设置命令的处理任务号

    expandTaskCommandRelease.setTaskId(taskInstance.getId());

    //领取任务

    taskService.expandTaskComplete(expandTaskCommandRelease, null);

   

    //重置任务查询 查询独占

    taskQuery = taskService.createTaskQuery();

    // 查找 1200119390 的这个流程实例的当前独占任务

    taskInstances = taskQuery.taskAssignee("1200119390").processInstanceId(processInstanceId).taskNotEnd().list();

    //释放任务后，独占任务数为0

    assertEquals(taskInstances.size(), 0);

    //重置任务查询 查询共享

    taskQuery = taskService.createTaskQuery();

    // 查找 1200119390 的这个流程实例的当前共享任务

    taskInstances = taskQuery.taskCandidateUser("1200119390").processInstanceId(processInstanceId).taskNotEnd().list();

    //释放任务后，共享任务数为1

    assertEquals(taskInstances.size(), 1);

    //取得当前任务

    taskInstance = taskInstances.get(0);

    //取得任务所在节点

    nodeId = taskInstance.getNodeId();

    //验证当前任务是否在第二个节点

    assertEquals(nodeId, "UserTask_4");

   

  }

  /**

   * 测试退回上一步

   */

  @Deployment(resources = { "com/founder/fix/fixflow/test/engine/api/task/TaskServiceNewTest.bpmn"})

  public void testRollBackTaskPreviousStep(){

    //创建一个通用命令

    ExpandTaskCommand expandTaskCommand = new ExpandTaskCommand();

    //设置流程名

    expandTaskCommand.setProcessDefinitionKey("TaskServiceNewTest");

    //设置流程的业务关联键

    expandTaskCommand.setBusinessKey("BK_testStartProcessInstanceByKey");

    //命令类型，可以从流程引擎配置中查询   启动并提交为startandsubmit

    expandTaskCommand.setCommandType("startandsubmit");

    //设置提交人

    expandTaskCommand.setInitiator("1200119390");

    //设置命令的id,需和节点上配置的按钮编号对应，会执行按钮中的脚本。

    expandTaskCommand.setUserCommandId("HandleCommand_2");

    //执行这个启动并提交的命令，返回启动的流程实例

    ProcessInstance processInstance = (ProcessInstance)taskService.expandTaskComplete(expandTaskCommand, null);

    String processInstanceId = processInstance.getId();

    //验证是否成功启动

    assertNotNull(processInstanceId);

   

    // 创建任务查询

    TaskQuery taskQuery = taskService.createTaskQuery();

    // 查找 1200119390 的这个流程实例的当前独占任务

    List<TaskInstance> taskInstances = taskQuery.taskAssignee("1200119390").processInstanceId(processInstanceId).taskNotEnd().list();

    //验证此时的独占任务为1

    assertEquals(taskInstances.size(), 1);

    TaskInstance taskInstance = taskInstances.get(0);

    String nodeId = taskInstance.getNodeId();

    assertEquals(nodeId, "UserTask_2");

   

    //创建通用命令

    ExpandTaskCommand expandTaskCommandRollBack=new ExpandTaskCommand();

    //设置命令为退回上一步

    expandTaskCommandRollBack.setCommandType("rollBackTaskPreviousStep");

    //设置命令按钮的iD,与节点上处理命令设置一致

    expandTaskCommandRollBack.setUserCommandId("HandleCommand_3");

    //设置命令的处理任务号

    expandTaskCommandRollBack.setTaskId(taskInstance.getId());

    //执行退回操作

    taskService.expandTaskComplete(expandTaskCommandRollBack, null);

    //重置任务查询

    taskQuery = taskService.createTaskQuery();

    // 查询此流程实例的当前任务号

    taskInstances = taskQuery.processInstanceId(processInstanceId).taskNotEnd().list();

    taskInstance = taskInstances.get(0);

    //查询当前任务号的节点名称

    nodeId = taskInstance.getNodeId();

    //验证退回操作后任务是否回到UserTask_1节点

    assertEquals(nodeId, "UserTask_1");

  }

  /**

   * 测试退回指定步骤

   */

  @Deployment(resources = { "com/founder/fix/fixflow/test/engine/api/task/TaskServiceNewTest.bpmn"})

  public void testRollBackTaskByExpression(){

    //创建一个通用命令

    ExpandTaskCommand expandTaskCommand = new ExpandTaskCommand();

    //设置流程名

    expandTaskCommand.setProcessDefinitionKey("TaskServiceNewTest");

    //设置流程的业务关联键

    expandTaskCommand.setBusinessKey("BK_testStartProcessInstanceByKey");

    //命令类型，可以从流程引擎配置中查询   启动并提交为startandsubmit

    expandTaskCommand.setCommandType("startandsubmit");

    //设置提交人

    expandTaskCommand.setInitiator("1200119390");

    //设置命令的id,需和节点上配置的按钮编号对应，会执行按钮中的脚本。

    expandTaskCommand.setUserCommandId("HandleCommand_2");

    //执行这个启动并提交的命令，返回启动的流程实例

    ProcessInstance processInstance = (ProcessInstance)taskService.expandTaskComplete(expandTaskCommand, null);

    String processInstanceId = processInstance.getId();

    //验证是否成功启动

    assertNotNull(processInstanceId);

   

    // 创建任务查询

    TaskQuery taskQuery = taskService.createTaskQuery();

    // 查找 1200119390 的这个流程实例的当前独占任务

    List<TaskInstance> taskInstances = taskQuery.taskAssignee("1200119390").processInstanceId(processInstanceId).taskNotEnd().list();

    //验证此时的独占任务为1

    assertEquals(taskInstances.size(), 1);

    //取得当前任务

    TaskInstance taskInstance = taskInstances.get(0);

    //取得当前任务节点

    String nodeId = taskInstance.getNodeId();

    //验证是否在第二个节点

    assertEquals(nodeId, "UserTask_2");

   

    //创建通用命令

    ExpandTaskCommand expandTaskCommandRollBack=new ExpandTaskCommand();

    //设置命令为退回制定步骤

    expandTaskCommandRollBack.setCommandType("rollBackTaskByExpression");

    //设置命令按钮的iD,与节点上处理命令设置一致

    expandTaskCommandRollBack.setUserCommandId("HandleCommand_4");

    //设置命令的处理任务号

    expandTaskCommandRollBack.setTaskId(taskInstance.getId());

    //执行退回操作

    taskService.expandTaskComplete(expandTaskCommandRollBack, null);

    //重置任务查询

    taskQuery = taskService.createTaskQuery();

    // 查询此流程实例的当前任务号

    taskInstances = taskQuery.processInstanceId(processInstanceId).taskNotEnd().list();

    taskInstance = taskInstances.get(0);

    //查询当前任务号的节点名称

    nodeId = taskInstance.getNodeId();

    //验证退回操作后任务是否回到UserTask_1节点

    assertEquals(nodeId, "UserTask_1");

  }

  /**

   * 测试退回-节点

   */

  @Deployment(resources = { "com/founder/fix/fixflow/test/engine/api/task/TaskServiceNewTest.bpmn"})

  public void testRollBack(){

    //创建一个通用命令

    ExpandTaskCommand expandTaskCommand = new ExpandTaskCommand();

    //设置流程名

    expandTaskCommand.setProcessDefinitionKey("TaskServiceNewTest");

    //设置流程的业务关联键

    expandTaskCommand.setBusinessKey("BK_testStartProcessInstanceByKey");

    //命令类型，可以从流程引擎配置中查询   启动并提交为startandsubmit

    expandTaskCommand.setCommandType("startandsubmit");

    //设置提交人

    expandTaskCommand.setInitiator("1200119390");

    //设置命令的id,需和节点上配置的按钮编号对应，会执行按钮中的脚本。

    expandTaskCommand.setUserCommandId("HandleCommand_2");

    //执行这个启动并提交的命令，返回启动的流程实例

    ProcessInstance processInstance = (ProcessInstance)taskService.expandTaskComplete(expandTaskCommand, null);

    String processInstanceId = processInstance.getId();

    //验证是否成功启动

    assertNotNull(processInstanceId);

   

    // 创建任务查询

    TaskQuery taskQuery = taskService.createTaskQuery();

    // 查找 1200119390 的这个流程实例的当前独占任务

    List<TaskInstance> taskInstances = taskQuery.taskAssignee("1200119390").processInstanceId(processInstanceId).taskNotEnd().list();

    //验证此时的独占任务为1

    assertEquals(taskInstances.size(), 1);

    //获得当前任务

    TaskInstance taskInstance = taskInstances.get(0);

    //获得任务节点

    String nodeId = taskInstance.getNodeId();

    //验证是否在第二个节点

    assertEquals(nodeId, "UserTask_2");

   

    //创建通用命令

    ExpandTaskCommand expandTaskCommandRollBack=new ExpandTaskCommand();

    //设置命令为退回-节点

    expandTaskCommandRollBack.setCommandType("rollBack");

    //设置命令按钮的iD,与节点上处理命令设置一致

    expandTaskCommandRollBack.setUserCommandId("HandleCommand_5");

    //设置命令的处理任务号

    expandTaskCommandRollBack.setTaskId(taskInstance.getId());

    //设置命令所需的额外参数 rollBackNodeId

    Map <String,Object> paraMap = new HashMap<String,Object>();

    paraMap.put("rollBackNodeId", "UserTask_1");

    //设置命令参数

    expandTaskCommandRollBack.setParamMap(paraMap);

    //执行退回操作

    taskService.expandTaskComplete(expandTaskCommandRollBack, null);

    //重置任务查询

    taskQuery = taskService.createTaskQuery();

    // 查询此流程实例的当前任务号

    taskInstances = taskQuery.processInstanceId(processInstanceId).taskNotEnd().list();

    taskInstance = taskInstances.get(0);

    //查询当前任务号的节点名称

    nodeId = taskInstance.getNodeId();

    //验证退回操作后任务是否回到UserTask_1节点

    assertEquals(nodeId, "UserTask_1");

  }

  /**

   * 测试退回-任务

   */

  @Deployment(resources = { "com/founder/fix/fixflow/test/engine/api/task/TaskServiceNewTest.bpmn"})

  public void testRollBackTaskByTaskId(){

    //创建一个通用命令

    ExpandTaskCommand expandTaskCommand = new ExpandTaskCommand();

    //设置流程名

    expandTaskCommand.setProcessDefinitionKey("TaskServiceNewTest");

    //设置流程的业务关联键

    expandTaskCommand.setBusinessKey("BK_testStartProcessInstanceByKey");

    //命令类型，可以从流程引擎配置中查询   启动并提交为startandsubmit

    expandTaskCommand.setCommandType("startandsubmit");

    //设置提交人

    expandTaskCommand.setInitiator("1200119390");

    //设置命令的id,需和节点上配置的按钮编号对应，会执行按钮中的脚本。

    expandTaskCommand.setUserCommandId("HandleCommand_2");

    //执行这个启动并提交的命令，返回启动的流程实例

    ProcessInstance processInstance = (ProcessInstance)taskService.expandTaskComplete(expandTaskCommand, null);

    String processInstanceId = processInstance.getId();

    //验证是否成功启动

    assertNotNull(processInstanceId);

   

    // 创建任务查询

    TaskQuery taskQuery = taskService.createTaskQuery();

    // 查找 1200119390 的这个流程实例的当前独占任务

    List<TaskInstance> taskInstances = taskQuery.taskAssignee("1200119390").processInstanceId(processInstanceId).taskNotEnd().list();

    //验证此时的独占任务为1

    assertEquals(taskInstances.size(), 1);

    //获得当前任务

    TaskInstance taskInstance = taskInstances.get(0);

    //获得当前任务节点

    String nodeId = taskInstance.getNodeId();

    //验证是否在第二个节点

    assertEquals(nodeId, "UserTask_2");

   

    //重置任务查询

    taskQuery = taskService.createTaskQuery();

    // 查询此流程实例的已经处理过的 UserTask_1节点的任务编号

    taskInstances = taskQuery.processInstanceId(processInstanceId).taskIsEnd().nodeId("UserTask_1").list();

    //处理过的 UserTask_1节点的任务编号

    String taskId = taskInstances.get(0).getId();

       

    //创建通用命令

    ExpandTaskCommand expandTaskCommandRollBack=new ExpandTaskCommand();

    //设置命令为退回-节点

    expandTaskCommandRollBack.setCommandType("rollBackTaskByTaskId");

    //设置命令按钮的iD,与节点上处理命令设置一致

    expandTaskCommandRollBack.setUserCommandId("HandleCommand_6");

    //设置命令的处理任务号

    expandTaskCommandRollBack.setTaskId(taskInstance.getId());

    //设置命令所需的额外参数 rollBackTaskId--需要退回的任务号

    Map <String,Object> paraMap = new HashMap<String,Object>();

    paraMap.put("rollBackTaskId", taskId);

    //设置命令参数

    expandTaskCommandRollBack.setParamMap(paraMap);

    //执行退回操作

    taskService.expandTaskComplete(expandTaskCommandRollBack, null);

    //重置任务查询

    taskQuery = taskService.createTaskQuery();

    // 查询此流程实例的当前任务号

    taskInstances = taskQuery.processInstanceId(processInstanceId).taskNotEnd().list();

    taskInstance = taskInstances.get(0);

    //查询当前任务号的节点名称

    nodeId = taskInstance.getNodeId();

    //验证退回操作后任务是否回到UserTask_1节点

    assertEquals(nodeId, "UserTask_1");

  }

 

  /**

   * 测试保存草稿 ， 保存草稿后，会将当前任务存为草稿状态

   */

  @Deployment(resources = { "com/founder/fix/fixflow/test/engine/api/task/TaskServiceNewTest.bpmn"})

  public void testSaveTaskDraft(){

    //创建一个通用命令

    ExpandTaskCommand expandTaskCommand = new ExpandTaskCommand();

    //设置流程名

    expandTaskCommand.setProcessDefinitionKey("TaskServiceNewTest");

    //设置流程的业务关联键

    expandTaskCommand.setBusinessKey("BK_testStartProcessInstanceByKey");

    //命令类型，可以从流程引擎配置中查询   启动并提交为startandsubmit

    expandTaskCommand.setCommandType("startandsubmit");

    //设置提交人

    expandTaskCommand.setInitiator("1200119390");

    //设置命令的id,需和节点上配置的按钮编号对应，会执行按钮中的脚本。

    expandTaskCommand.setUserCommandId("HandleCommand_2");

    //执行这个启动并提交的命令，返回启动的流程实例

    ProcessInstance processInstance = (ProcessInstance)taskService.expandTaskComplete(expandTaskCommand, null);

    String processInstanceId = processInstance.getId();

    //验证是否成功启动

    assertNotNull(processInstanceId);

   

    // 创建任务查询

    TaskQuery taskQuery = taskService.createTaskQuery();

    // 查找 1200119390 的这个流程实例的当前独占任务

    List<TaskInstance> taskInstances = taskQuery.taskAssignee("1200119390").processInstanceId(processInstanceId).taskNotEnd().list();

    //获得任务实例

    TaskInstance taskInstance = taskInstances.get(0);

    //获得当前任务节点

    String nodeId = taskInstance.getNodeId();

    //验证是否在第二个节点

    assertEquals(nodeId, "UserTask_2");

     

    //保存草稿操作前，验证任务为非草稿状态

    assertEquals(taskInstance.isDraft(),false);

    //创建通用命令

    ExpandTaskCommand expandTaskCommandSaveTaskDraft=new ExpandTaskCommand();

    //设置命令为保存草稿

    expandTaskCommandSaveTaskDraft.setCommandType("saveTaskDraft");

    //设置命令按钮的iD,与节点上处理命令设置一致

    expandTaskCommandSaveTaskDraft.setUserCommandId("HandleCommand_7");

    //设置命令的处理任务号

    expandTaskCommandSaveTaskDraft.setTaskId(taskInstance.getId());

    //执行这个启动并提交的命令，返回启动的流程实例

    taskService.expandTaskComplete(expandTaskCommandSaveTaskDraft, null);

   

    taskQuery = taskService.createTaskQuery();

    // 查找 1200119390 的这个流程实例的当前独占任务

    taskInstance = taskQuery.taskAssignee("1200119390").processInstanceId(processInstanceId).taskNotEnd().list().get(0);

    //保存草稿操作后，验证任务为草稿状态

    assertEquals(taskInstance.isDraft(),true);

  }

 

  /**

   * 测试删除实例 ---该命令尚未完善

   */

  @Deployment(resources = { "com/founder/fix/fixflow/test/engine/api/task/TaskServiceNewTest.bpmn"})

  public void testDeleteProcessInstance(){

    //创建一个通用命令

    ExpandTaskCommand expandTaskCommand = new ExpandTaskCommand();

    //设置流程名

    expandTaskCommand.setProcessDefinitionKey("TaskServiceNewTest");

    //设置流程的业务关联键

    expandTaskCommand.setBusinessKey("BK_testStartProcessInstanceByKey");

    //命令类型，可以从流程引擎配置中查询   启动并提交为startandsubmit

    expandTaskCommand.setCommandType("startandsubmit");

    //设置提交人

    expandTaskCommand.setInitiator("1200119390");

    //设置命令的id,需和节点上配置的按钮编号对应，会执行按钮中的脚本。

    expandTaskCommand.setUserCommandId("HandleCommand_2");

    //执行这个启动并提交的命令，返回启动的流程实例

    ProcessInstance processInstance = (ProcessInstance)taskService.expandTaskComplete(expandTaskCommand, null);

    String processInstanceId = processInstance.getId();

    //验证是流程实例是否存在

    assertNotNull(processInstanceId);

   

   

//    TaskQuery taskQuery = taskService.createTaskQuery();

//    // 查找 1200119390 的这个流程实例的当前独占任务

//    List<TaskInstance> taskInstances = taskQuery.taskAssignee("1200119390").processInstanceId(processInstanceId).taskNotEnd().list();

//    //取得当前任务

//    TaskInstance taskInstance = taskInstances.get(0);

//    //创建通用命令

//    ExpandTaskCommand expandTaskCommandSaveTaskDraft=new ExpandTaskCommand();

//    //设置命令为删除实例

//    expandTaskCommandSaveTaskDraft.setCommandType("deleteProcessInstance");

//    //设置命令按钮的iD,与节点上处理命令设置一致

//    expandTaskCommandSaveTaskDraft.setUserCommandId("HandleCommand_8");

//    //设置命令的处理任务号

//    expandTaskCommandSaveTaskDraft.setTaskId(taskInstance.getId());

//    //执行这个启动并提交的命令，返回启动的流程实例

//    taskService.expandTaskComplete(expandTaskCommandSaveTaskDraft, null);

   

//    // 重置任务查询

//    taskQuery = taskService.createTaskQuery();

//    //获取此任务实例的任务数

//    int taskCount = taskQuery.processInstanceId(processInstanceId).list().size();

    //验证实例相关任务被删除

//    assertEquals(taskCount,0);

  }

  /**

   * 测试暂停和恢复任务，暂停和恢复需成对出现，暂停任务后，任务为暂停状态，只可以有恢复按钮

   */

  @Deployment(resources = { "com/founder/fix/fixflow/test/engine/api/task/TaskServiceNewTest.bpmn"})

  public void testSuspendAndContinueTask(){

    //创建一个通用命令

    ExpandTaskCommand expandTaskCommand = new ExpandTaskCommand();

    //设置流程名

    expandTaskCommand.setProcessDefinitionKey("TaskServiceNewTest");

    //设置流程的业务关联键

    expandTaskCommand.setBusinessKey("BK_testStartProcessInstanceByKey");

    //命令类型，可以从流程引擎配置中查询   启动并提交为startandsubmit

    expandTaskCommand.setCommandType("startandsubmit");

    //设置提交人

    expandTaskCommand.setInitiator("1200119390");

    //设置命令的id,需和节点上配置的按钮编号对应，会执行按钮中的脚本。

    expandTaskCommand.setUserCommandId("HandleCommand_2");

    //执行这个启动并提交的命令，返回启动的流程实例

    ProcessInstance processInstance = (ProcessInstance)taskService.expandTaskComplete(expandTaskCommand, null);

    String processInstanceId = processInstance.getId();

    //验证是流程实例是否存在

    assertNotNull(processInstanceId);

   

    // 创建任务查询

    TaskQuery taskQuery = taskService.createTaskQuery();

    // 查找 1200119390 的这个流程实例的当前独占任务

    List<TaskInstance> taskInstances = taskQuery.taskAssignee("1200119390").processInstanceId(processInstanceId).taskNotEnd().list();

    //取得当前任务

    TaskInstance taskInstance = taskInstances.get(0);

   

    //暂停任务前，任务为非暂停状态

    assertEquals(taskInstance.isSuspended(),false);

    //创建通用命令

    ExpandTaskCommand expandTaskCommandSuspendTask=new ExpandTaskCommand();

    //设置命令为暂停任务

    expandTaskCommandSuspendTask.setCommandType("suspendTask");

    //设置命令按钮的iD,与节点上处理命令设置一致

    expandTaskCommandSuspendTask.setUserCommandId("HandleCommand_9");

    //设置命令的处理任务号

    expandTaskCommandSuspendTask.setTaskId(taskInstance.getId());

    //执行这个暂停任务的命令

    taskService.expandTaskComplete(expandTaskCommandSuspendTask, null);

   

    taskQuery = taskService.createTaskQuery();

    // 查找 1200119390 的这个流程实例的当前独占任务

    taskInstance = taskQuery.taskAssignee("1200119390").processInstanceId(processInstanceId).taskNotEnd().list().get(0);

    //暂停任务后，验证任务为暂停状态

    assertEquals(taskInstance.isSuspended(),true);

   

   

    //创建通用命令

    ExpandTaskCommand expandTaskCommandContinueTask=new ExpandTaskCommand();

    //设置命令为恢复任务

    expandTaskCommandContinueTask.setCommandType("continueTask");

    //设置命令按钮的iD,与节点上处理命令设置一致

    expandTaskCommandContinueTask.setUserCommandId("HandleCommand_10");

    //设置命令的处理任务号

    expandTaskCommandContinueTask.setTaskId(taskInstance.getId());

    //执行这个恢复任务的命令

    taskService.expandTaskComplete(expandTaskCommandContinueTask, null);

    //重置任务查询

    taskQuery = taskService.createTaskQuery();

    // 查找 1200119390 的这个流程实例的当前独占任务

    taskInstance = taskQuery.taskAssignee("1200119390").processInstanceId(processInstanceId).taskNotEnd().list().get(0);

    //恢复任务操作后，验证任务为未暂停状态

    assertEquals(taskInstance.isSuspended(),false);

  }

  /**

   * 测试转办和还回操作，转办和还回操作需成对出现，转办后，任务会到选择的人待办中，并且只有还回按钮使流程回到转办人

   */

  @Deployment(resources = { "com/founder/fix/fixflow/test/engine/api/task/TaskServiceNewTest.bpmn"})

  public void testPendingAndResolved(){

    //创建一个通用命令

    ExpandTaskCommand expandTaskCommand = new ExpandTaskCommand();

    //设置流程名

    expandTaskCommand.setProcessDefinitionKey("TaskServiceNewTest");

    //设置流程的业务关联键

    expandTaskCommand.setBusinessKey("BK_testStartProcessInstanceByKey");

    //命令类型，可以从流程引擎配置中查询   启动并提交为startandsubmit

    expandTaskCommand.setCommandType("startandsubmit");

    //设置提交人

    expandTaskCommand.setInitiator("1200119390");

    //设置命令的id,需和节点上配置的按钮编号对应，会执行按钮中的脚本。

    expandTaskCommand.setUserCommandId("HandleCommand_2");

    //执行这个启动并提交的命令，返回启动的流程实例

    ProcessInstance processInstance = (ProcessInstance)taskService.expandTaskComplete(expandTaskCommand, null);

    String processInstanceId = processInstance.getId();

    //验证是流程实例是否存在

    assertNotNull(processInstanceId);

   

    TaskQuery taskQuery = taskService.createTaskQuery();

    // 查找 1200119390 的这个流程实例的当前独占任务

    TaskInstance taskInstance = taskQuery.taskAssignee("1200119390").processInstanceId(processInstanceId).taskNotEnd().list().get(0);

    //暂停任务后，验证任务为暂停状态

    assertEquals(taskInstance.getNodeId(),"UserTask_2");

   

   

    //创建通用命令

    ExpandTaskCommand expandTaskCommandPending=new ExpandTaskCommand();

    //设置命令为转办任务

    expandTaskCommandPending.setCommandType("pending");

    //设置命令按钮的iD,与节点上处理命令设置一致

    expandTaskCommandPending.setUserCommandId("HandleCommand_11");

   

    Map<String,Object> paramsMap = new HashMap<String,Object>();

    //设置转办的用户号

    paramsMap.put("pendingUserId", "13223212313");

    expandTaskCommandPending.setParamMap(paramsMap);

    //设置命令的处理任务号

    expandTaskCommandPending.setTaskId(taskInstance.getId());

    //执行这个转办的命令

    taskService.expandTaskComplete(expandTaskCommandPending, null);

    //重置任务查询

    taskQuery = taskService.createTaskQuery();

    // 查找 13223212313 的这个流程实例的当前独占任务

    taskInstance = taskQuery.taskAssignee("13223212313").processInstanceId(processInstanceId).taskNotEnd().list().get(0);

    //转办操作后，转办接收人的待办中存在这条任务

    assertNotNull(taskInstance);

   

    //查询是否有还回命令

    List<TaskCommandInst> taskCommandInsts=taskService.GetTaskCommandByTaskInstance(taskInstance,false);

    boolean isHaveResolvedCommand = false;

    //循环查找是否有还回命令

    for(TaskCommandInst taskCommandInst:taskCommandInsts){

      if("resolved".equals(taskCommandInst.getTaskCommandType())){

        isHaveResolvedCommand = true;

        break;

      }

    }

    //验证存在还回命令

    assertEquals(isHaveResolvedCommand,true);

   

    //创建通用命令

    ExpandTaskCommand expandTaskCommandResolved=new ExpandTaskCommand();

    //设置命令为还回任务

    expandTaskCommandResolved.setCommandType("resolved");

    //设置命令按钮的iD,与节点上处理命令设置一致

    expandTaskCommandResolved.setUserCommandId("HandleCommand_12");

    //设置命令的处理任务号

    expandTaskCommandResolved.setTaskId(taskInstance.getId());

    //执行这个还回任务的命令

    taskService.expandTaskComplete(expandTaskCommandResolved, null);

    //重置任务查询

    taskQuery = taskService.createTaskQuery();

    // 查找 1200119390 的这个流程实例的当前独占任务

    taskInstance = taskQuery.taskAssignee("1200119390").processInstanceId(processInstanceId).taskNotEnd().list().get(0);

    //还回操作后，任务回到换来的处理人

    assertNotNull(taskInstance);

   

    //查询是否有还回命令

    taskCommandInsts=taskService.GetTaskCommandByTaskInstance(taskInstance,false);

    isHaveResolvedCommand = false;

    //循环查找是否有还回命令

    for(TaskCommandInst taskCommandInst:taskCommandInsts){

      //如果存在类型为还回的按钮则结束

      if("resolved".equals(taskCommandInst.getTaskCommandType())){

        isHaveResolvedCommand = true;

        break;

      }

    }

    //验证不存在还回命令

    assertEquals(isHaveResolvedCommand,false);

  }

 

  /**

   * 测试追回操作  追回按钮需要配置在可以被追回的节点上，表达式中配置可以有追回操作的的节点编号，不配置则前面所有节点均可追回

   */

  @Deployment(resources = { "com/founder/fix/fixflow/test/engine/api/task/TaskServiceNewTest.bpmn"})

  public void testRecover(){

    //创建一个通用命令

    ExpandTaskCommand expandTaskCommand = new ExpandTaskCommand();

    //设置流程名

    expandTaskCommand.setProcessDefinitionKey("TaskServiceNewTest");

    //设置流程的业务关联键

    expandTaskCommand.setBusinessKey("BK_testStartProcessInstanceByKey");

    //命令类型，可以从流程引擎配置中查询   启动并提交为startandsubmit

    expandTaskCommand.setCommandType("startandsubmit");

    //设置提交人

    expandTaskCommand.setInitiator("1200119390");

    //设置命令的id,需和节点上配置的按钮编号对应，会执行按钮中的脚本。

    expandTaskCommand.setUserCommandId("HandleCommand_2");

    //执行这个启动并提交的命令，返回启动的流程实例

    ProcessInstance processInstance = (ProcessInstance)taskService.expandTaskComplete(expandTaskCommand, null);

    String processInstanceId = processInstance.getId();

    //验证是流程实例是否存在

    assertNotNull(processInstanceId);

   

    TaskQuery taskQuery = taskService.createTaskQuery();

    // 查找 1200119390 的这个流程实例的当前独占任务

    TaskInstance taskInstance = taskQuery.taskAssignee("1200119390").processInstanceId(processInstanceId).taskNotEnd().list().get(0);

    //查询是否有追回命令

    List<TaskCommandInst> taskCommandInsts=taskService.GetTaskCommandByTaskInstance(taskInstance,true);

    boolean isHaveRecoverCommand = false;

    //循环查找是否有追回命令

    for(TaskCommandInst taskCommandInst:taskCommandInsts){

      //如果存在类型为追回的按钮则结束

      if("recover".equals(taskCommandInst.getTaskCommandType())){

        isHaveRecoverCommand = true;

        break;

      }

    }

    //验证存在追回命令

    assertEquals(isHaveRecoverCommand,true);

   

    //创建通用命令

    ExpandTaskCommand expandTaskCommandRecover=new ExpandTaskCommand();

    //设置命令为暂停实例

    expandTaskCommandRecover.setCommandType("recover");

    //设置命令按钮的iD,与节点上处理命令设置一致

    expandTaskCommandRecover.setUserCommandId("HandleCommand_13");

    //设置命令的处理任务号

    expandTaskCommandRecover.setTaskId(taskInstance.getId());

    //设置追回命令必须的参数recoverNodeId

    Map<String,Object> map = new HashMap<String,Object>();

    map.put("recoverNodeId", "UserTask_1");

    expandTaskCommandRecover.setParamMap(map);

    //执行这个追回的命令

    taskService.expandTaskComplete(expandTaskCommandRecover, null);

    //重置任务查询

    taskQuery = taskService.createTaskQuery();

    // 查找当前流程实例的当前处理任务

    taskInstance = taskQuery.processInstanceId(processInstanceId).taskNotEnd().list().get(0);

    //验证任务是否被追回到UserTask_1节点

    assertEquals("UserTask_1", taskInstance.getNodeId());

  }

 

  /**

   * 测试暂停和恢复流程实例

   */

  @Deployment(resources = { "com/founder/fix/fixflow/test/engine/api/task/TaskServiceNewTest.bpmn"})

  public void testSuspendProcessInstance(){

    //创建一个通用命令

    ExpandTaskCommand expandTaskCommand = new ExpandTaskCommand();

    //设置流程名

    expandTaskCommand.setProcessDefinitionKey("TaskServiceNewTest");

    //设置流程的业务关联键

    expandTaskCommand.setBusinessKey("BK_testStartProcessInstanceByKey");

    //命令类型，可以从流程引擎配置中查询   启动并提交为startandsubmit

    expandTaskCommand.setCommandType("startandsubmit");

    //设置提交人

    expandTaskCommand.setInitiator("1200119390");

    //设置命令的id,需和节点上配置的按钮编号对应，会执行按钮中的脚本。

    expandTaskCommand.setUserCommandId("HandleCommand_2");

    //执行这个启动并提交的命令，返回启动的流程实例

    ProcessInstance processInstance = (ProcessInstance)taskService.expandTaskComplete(expandTaskCommand, null);

    String processInstanceId = processInstance.getId();

    //验证是流程实例是否存在

    assertNotNull(processInstanceId);

   

    TaskQuery taskQuery = taskService.createTaskQuery();

    // 查找 1200119390 的这个流程实例的当前独占任务

    TaskInstance taskInstance = taskQuery.taskAssignee("1200119390").processInstanceId(processInstanceId).taskNotEnd().list().get(0);

    //创建通用命令

    ExpandTaskCommand expandTaskCommandSuspendProcessInstance=new ExpandTaskCommand();

    //设置命令为暂停实例

    expandTaskCommandSuspendProcessInstance.setCommandType("suspendProcessInstance");

    //设置命令按钮的iD,与节点上处理命令设置一致

    expandTaskCommandSuspendProcessInstance.setUserCommandId("HandleCommand_14");

    //设置命令的处理任务号

    expandTaskCommandSuspendProcessInstance.setTaskId(taskInstance.getId());

    //执行这个暂停实例的命令

    taskService.expandTaskComplete(expandTaskCommandSuspendProcessInstance, null);

    //根据实例号得到流程实例

    processInstance = runtimeService.getProcessInstance(processInstanceId);

   

    //验证实例处理暂停状态

    assertEquals(processInstance.isSuspended(),true);

   

    //创建通用命令

    ExpandTaskCommand expandTaskCommandContinueProcessInstance=new ExpandTaskCommand();

    //设置命令为恢复实例

    expandTaskCommandContinueProcessInstance.setCommandType("continueProcessInstance");

    //设置命令按钮的iD,与节点上处理命令设置一致

    expandTaskCommandContinueProcessInstance.setUserCommandId("HandleCommand_15");

    //设置命令的处理任务号

    expandTaskCommandContinueProcessInstance.setTaskId(taskInstance.getId());

    //执行这个恢复实例的命令

    taskService.expandTaskComplete(expandTaskCommandContinueProcessInstance, null);

    //根据实例号得到流程实例

    processInstance = runtimeService.getProcessInstance(processInstanceId);

   

    //验证流程实例已处于非暂停状态

    assertEquals(processInstance.isSuspended(),false);

  }

 

  /**

   * 测试暂停和恢复流程实例

   */

  @Deployment(resources = { "com/founder/fix/fixflow/test/engine/api/task/TaskServiceTest.bpmn"})

  public void testTermination(){

    //创建一个通用命令

    ExpandTaskCommand expandTaskCommand = new ExpandTaskCommand();

    //设置流程名

    expandTaskCommand.setProcessDefinitionKey("Process_TaskServiceTest");

    //设置流程的业务关联键

    expandTaskCommand.setBusinessKey("BK_testStartProcessInstanceByKey");

    //命令类型，可以从流程引擎配置中查询   启动并提交为startandsubmit

    expandTaskCommand.setCommandType("startandsubmit");

    //设置提交人

    expandTaskCommand.setInitiator("1200119390");

    //设置命令的id,需和节点上配置的按钮编号对应，会执行按钮中的脚本。

    expandTaskCommand.setUserCommandId("HandleCommand_2");

    Map<String, Object> mapVariables = new HashMap<String, Object>();

    //设置变量，流程线条上用到，amount<300时走独占任务，否则都共享任务

    mapVariables.put("amount", 280);

    expandTaskCommand.setTransientVariables(mapVariables);

    //执行这个启动并提交的命令，返回启动的流程实例

    ProcessInstance processInstance = (ProcessInstance)taskService.expandTaskComplete(expandTaskCommand, null);

    String processInstanceId = processInstance.getId();

    //验证是否成功启动

    assertNotNull(processInstanceId);

    //验证流程启动后实例状态为running(运行中)

    assertEquals(ProcessInstanceType.RUNNING, processInstance.getInstanceType());

    // 创建任务查询

    TaskQuery taskQuery = taskService.createTaskQuery();

    // 查找 1200119390 的这个流程实例的当前独占任务

    List<TaskInstance> taskInstances = taskQuery.taskAssignee("1200119390").processInstanceId(processInstanceId).taskNotEnd().list();

    //验证更新时间不为空

    assertNotNull(processInstance.getUpdateTime());

    TaskInstance taskInstance = taskInstances.get(0);

    //创建通用命令

    ExpandTaskCommand expandTaskCommandSuspendProcessInstance=new ExpandTaskCommand();

    //设置命令为暂停实例

    expandTaskCommandSuspendProcessInstance.setCommandType("terminationProcess");

    //设置命令按钮的iD,与节点上处理命令设置一致

    expandTaskCommandSuspendProcessInstance.setUserCommandId("HandleCommand_2");

    //设置命令的处理任务号

    expandTaskCommandSuspendProcessInstance.setTaskId(taskInstance.getId());

    //执行这个暂停实例的命令

    taskService.expandTaskComplete(expandTaskCommandSuspendProcessInstance, null);

    //根据实例号得到流程实例

    processInstance = runtimeService.getProcessInstance(processInstanceId);

    //验证实例状态为TERMINATION（终止）

    assertEquals(ProcessInstanceType.TERMINATION, processInstance.getInstanceType());

    //验证更新时间不为空

    assertNotNull(processInstance.getUpdateTime());

    //验证流程实例已经结束

    assertTrue(processInstance.hasEnded());

    //重置任务查询

    taskQuery = taskService.createTaskQuery();

    // 查找 1200119390 的这个流程实例的当前独占任务

    taskInstances = taskQuery.taskAssignee("1200119390").processInstanceId(processInstanceId).taskNotEnd().list();

    //验证任务已经被结束

    assertEquals(0, taskInstances.size());

  }

  /**

   * 测试接收任务和释放任务的taskService中的现有方法，不 以命令的形式，TaskServiceCandidateTest流程中的任务分配类型为共享模式

   */

  @Deployment(resources = { "com/founder/fix/fixflow/test/engine/api/task/TaskServiceCandidateTest.bpmn"})

  public void testClaimMethod(){

    //创建一个通用命令

    ExpandTaskCommand expandTaskCommand = new ExpandTaskCommand();

    //设置流程名

    expandTaskCommand.setProcessDefinitionKey("TaskServiceCandidateTest");

    //设置流程的业务关联键

    expandTaskCommand.setBusinessKey("BK_testStartProcessInstanceByKey");

    //命令类型，可以从流程引擎配置中查询   启动并提交为startandsubmit

    expandTaskCommand.setCommandType("startandsubmit");

    //设置提交人

    expandTaskCommand.setInitiator("1200119390");

    //设置命令的id,需和节点上配置的按钮编号对应，会执行按钮中的脚本。

    expandTaskCommand.setUserCommandId("HandleCommand_2");

    //执行这个启动并提交的命令，返回启动的流程实例

    ProcessInstance processInstance = (ProcessInstance)taskService.expandTaskComplete(expandTaskCommand, null);

    String processInstanceId = processInstance.getId();

    //验证是否成功启动

    assertNotNull(processInstanceId);

   

    // 创建任务查询

    TaskQuery taskQuery = taskService.createTaskQuery();

    // 查找 1200119390 的这个流程实例的当前独占任务

    List<TaskInstance> taskInstances = taskQuery.taskAssignee("1200119390").processInstanceId(processInstanceId).taskNotEnd().list();

    //未领任务前 独占任务应该为0

    assertEquals(taskInstances.size(), 0);

    //获取1200119390的本流程实例的共享任务

    taskInstances = taskQuery.taskCandidateUser("1200119390").processInstanceId(processInstanceId).taskNotEnd().list();

    //验证此时的共享任务为1

    assertEquals(taskInstances.size(), 1);

   

    //获取当前任务节点

    TaskInstance taskInstance = taskInstances.get(0);

    //接收任务，userid不传的话将会去线程副本中获取

    taskService.claim(taskInstance.getId(), null);

   

    //重置任务查询 查询共享

    taskQuery = taskService.createTaskQuery();

    // 查找 1200119390 的这个流程实例的当前共享任务

    taskInstances = taskQuery.taskCandidateUser("1200119390").processInstanceId(processInstanceId).taskNotEnd().list();

    //领取任务后，共享任务数为0

    assertEquals(taskInstances.size(), 0);

    //重置任务查询 查询独占

    taskQuery = taskService.createTaskQuery();

    // 查找 1200119390 的这个流程实例的当前独占任务

    taskInstances = taskQuery.taskAssignee("1200119390").processInstanceId(processInstanceId).taskNotEnd().list();

    //领取任务后，独占任务数为1

    assertEquals(taskInstances.size(), 1);

   

    //取得当前任务

    taskInstance = taskInstances.get(0);

    //取得任务所在节点

    String nodeId = taskInstance.getNodeId();

    //验证当前任务是否在第二个节点

    assertEquals(nodeId, "UserTask_4");

    //释放任务

    taskService.release(taskInstance.getId());

    //重置任务查询 查询独占

    taskQuery = taskService.createTaskQuery();

    // 查找 1200119390 的这个流程实例的当前独占任务

    taskInstances = taskQuery.taskAssignee("1200119390").processInstanceId(processInstanceId).taskNotEnd().list();

    //释放任务后，独占任务数为0

    assertEquals(taskInstances.size(), 0);

    //重置任务查询 查询共享

    taskQuery = taskService.createTaskQuery();

    // 查找 1200119390 的这个流程实例的当前共享任务

    taskInstances = taskQuery.taskCandidateUser("1200119390").processInstanceId(processInstanceId).taskNotEnd().list();

    //释放任务后，共享任务数为1

    assertEquals(taskInstances.size(), 1);

    //取得当前任务

    taskInstance = taskInstances.get(0);

    //取得任务所在节点

    nodeId = taskInstance.getNodeId();

    //验证当前任务是否在第二个节点

    assertEquals(nodeId, "UserTask_4");

   

  }

  /**

   * 测试设置代理人---该命令尚未实现

   */

  @Deployment(resources = { "com/founder/fix/fixflow/test/engine/api/task/TaskServiceNewTest.bpmn"})

  public void testSetAssignee(){

    //创建一个通用命令

    ExpandTaskCommand expandTaskCommand = new ExpandTaskCommand();

    //设置流程名

    expandTaskCommand.setProcessDefinitionKey("TaskServiceNewTest");

    //设置流程的业务关联键

    expandTaskCommand.setBusinessKey("BK_testStartProcessInstanceByKey");

    //命令类型，可以从流程引擎配置中查询   启动并提交为startandsubmit

    expandTaskCommand.setCommandType("startandsubmit");

    //设置提交人

    expandTaskCommand.setInitiator("1200119390");

    //设置命令的id,需和节点上配置的按钮编号对应，会执行按钮中的脚本。

    expandTaskCommand.setUserCommandId("HandleCommand_2");

    //执行这个启动并提交的命令，返回启动的流程实例

    ProcessInstance processInstance = (ProcessInstance)taskService.expandTaskComplete(expandTaskCommand, null);

    String processInstanceId = processInstance.getId();

    //验证是否成功启动

    assertNotNull(processInstanceId);

   

    TaskQuery taskQuery = taskService.createTaskQuery();

    // 查找 1200119390 的这个流程实例的当前独占任务

    TaskInstance taskInstance = taskQuery.taskAssignee("1200119390").processInstanceId(processInstanceId).taskNotEnd().list().get(0);

   

    String taskId = taskInstance.getId();

    taskService.setAssignee(taskId, "121231231");

    taskQuery = taskService.createTaskQuery();

    taskInstance = taskQuery.taskId(taskId).singleResult();

    //assertEquals("121231231", taskInstance.getAssignee());

  }

  /**

   * 测试查询可退回的任务

   */

  @Deployment(resources = { "com/founder/fix/fixflow/test/engine/api/task/TaskServiceNewTest.bpmn"})

  public void testGetRollBackTask(){

    //创建一个通用命令

    ExpandTaskCommand expandTaskCommand = new ExpandTaskCommand();

    //设置流程名

    expandTaskCommand.setProcessDefinitionKey("TaskServiceNewTest");

    //设置流程的业务关联键

    expandTaskCommand.setBusinessKey("BK_testStartProcessInstanceByKey");

    //命令类型，可以从流程引擎配置中查询   启动并提交为startandsubmit

    expandTaskCommand.setCommandType("startandsubmit");

    //设置提交人

    expandTaskCommand.setInitiator("1200119390");

    //设置命令的id,需和节点上配置的按钮编号对应，会执行按钮中的脚本。

    expandTaskCommand.setUserCommandId("HandleCommand_2");

    //执行这个启动并提交的命令，返回启动的流程实例

    ProcessInstance processInstance = (ProcessInstance)taskService.expandTaskComplete(expandTaskCommand, null);

    String processInstanceId = processInstance.getId();

    //验证是否成功启动

    assertNotNull(processInstanceId);

   

    TaskQuery taskQuery = taskService.createTaskQuery();

    // 查找 1200119390 的这个流程实例的当前独占任务

    TaskInstance taskInstance = taskQuery.taskAssignee("1200119390").processInstanceId(processInstanceId).taskNotEnd().list().get(0);

    //查询可退回的任务

    List<TaskInstance> taskInstances = taskService.getRollBackTask(taskInstance.getId());

    //验证可退回任务数为1

    assertEquals(1, taskInstances.size());

    //获得可退回的任务

    taskInstance = taskInstances.get(0);

    //验证是否是第一个节点

    assertEquals("UserTask_1",taskInstance.getNodeId());

  }

 

  /**

   * 测试查询可退回的节点

   */

  @Deployment(resources = { "com/founder/fix/fixflow/test/engine/api/task/TaskServiceNewTest.bpmn"})

  public void testGetRollBackNode(){

    //创建一个通用命令

    ExpandTaskCommand expandTaskCommand = new ExpandTaskCommand();

    //设置流程名

    expandTaskCommand.setProcessDefinitionKey("TaskServiceNewTest");

    //设置流程的业务关联键

    expandTaskCommand.setBusinessKey("BK_testStartProcessInstanceByKey");

    //命令类型，可以从流程引擎配置中查询   启动并提交为startandsubmit

    expandTaskCommand.setCommandType("startandsubmit");

    //设置提交人

    expandTaskCommand.setInitiator("1200119390");

    //设置命令的id,需和节点上配置的按钮编号对应，会执行按钮中的脚本。

    expandTaskCommand.setUserCommandId("HandleCommand_2");

    //执行这个启动并提交的命令，返回启动的流程实例

    ProcessInstance processInstance = (ProcessInstance)taskService.expandTaskComplete(expandTaskCommand, null);

    String processInstanceId = processInstance.getId();

    //验证是否成功启动

    assertNotNull(processInstanceId);

   

    TaskQuery taskQuery = taskService.createTaskQuery();

    // 查找 1200119390 的这个流程实例的当前独占任务

    TaskInstance taskInstance = taskQuery.taskAssignee("1200119390").processInstanceId(processInstanceId).taskNotEnd().list().get(0);

    //查询可退回的节点

    List<UserTaskBehavior> userTaskBehaviors = taskService.getRollBackNode(taskInstance.getId());

    //验证可退回节点数为1

    assertEquals(1, userTaskBehaviors.size());

    //获得可退回的节点

    UserTaskBehavior userTaskBehavior = userTaskBehaviors.get(0);

    //验证是否是第一个节点

    assertEquals("UserTask_1",userTaskBehavior.getId());

  }

  /**

   * 测试查询获取任务的上一步骤任务对象(非会签情况下上一步骤只有一个任务,会签情况下可能会有多个任务)

   */

  @Deployment(resources = { "com/founder/fix/fixflow/test/engine/api/task/TaskServiceNewTest.bpmn"})

  public void testGetPreviousStepTaskByTaskId(){

    //创建一个通用命令

    ExpandTaskCommand expandTaskCommand = new ExpandTaskCommand();

    //设置流程名

    expandTaskCommand.setProcessDefinitionKey("TaskServiceNewTest");

    //设置流程的业务关联键

    expandTaskCommand.setBusinessKey("BK_testStartProcessInstanceByKey");

    //命令类型，可以从流程引擎配置中查询   启动并提交为startandsubmit

    expandTaskCommand.setCommandType("startandsubmit");

    //设置提交人

    expandTaskCommand.setInitiator("1200119390");

    //设置命令的id,需和节点上配置的按钮编号对应，会执行按钮中的脚本。

    expandTaskCommand.setUserCommandId("HandleCommand_2");

    //执行这个启动并提交的命令，返回启动的流程实例

    ProcessInstance processInstance = (ProcessInstance)taskService.expandTaskComplete(expandTaskCommand, null);

    String processInstanceId = processInstance.getId();

    //验证是否成功启动

    assertNotNull(processInstanceId);

   

    TaskQuery taskQuery = taskService.createTaskQuery();

    // 查找 1200119390 的这个流程实例的当前独占任务

    TaskInstance taskInstance = taskQuery.taskAssignee("1200119390").processInstanceId(processInstanceId).taskNotEnd().list().get(0);

    //获取任务的上一步骤任务对象(非会签情况下上一步骤只有一个任务,会签情况下可能会有多个任务)

    List<TaskInstance> taskInstances = taskService.getPreviousStepTaskByTaskId(taskInstance.getId());

    //验证任务数是否为1

    assertEquals(1, taskInstances.size());

    //获得任务

    taskInstance = taskInstances.get(0);

    //验证是否是第一个节点

    assertEquals("UserTask_1",taskInstance.getNodeId());

  }

 

 

  /**

   * 测试任务的各种查询，任务查询中，除了(共享，独占)和（类别）分别为or关系，其他查询之间均为and关系，taskQuery每次查询都会保存一个条件，所以需要时注意重置查询

   */

  @Deployment(resources = { "com/founder/fix/fixflow/test/engine/api/task/TaskServiceTest.bpmn"})

  public void testTaskQuery(){

   

    TaskQuery taskQuery = taskService.createTaskQuery();

    List<TaskInstance> taskInstances = taskQuery.taskAssignee("1200119390").processDefinitionKey("Process_TaskServiceTest").taskNotEnd().list();

    for(int i = 0;i<50;i++){

      //创建一个通用命令

      ExpandTaskCommand expandTaskCommand = new ExpandTaskCommand();

      //设置流程名

      expandTaskCommand.setProcessDefinitionKey("Process_TaskServiceTest");

      //设置流程的业务关联键

      expandTaskCommand.setBusinessKey("BK_testStartProcessInstanceByKey");

      //命令类型，可以从流程引擎配置中查询   启动并提交为startandsubmit

      expandTaskCommand.setCommandType("startandsubmit");

      //设置提交人

      expandTaskCommand.setInitiator("1200119390");

      //设置命令的id,需和节点上配置的按钮编号对应，会执行按钮中的脚本。

      expandTaskCommand.setUserCommandId("HandleCommand_2");

     

     

      Map<String, Object> mapVariables = new HashMap<String, Object>();

      //设置变量，流程线条上用到，amount<300时走独占任务，否则都共享任务

      int amount = 280+i;

      mapVariables.put("amount", amount);

      expandTaskCommand.setTransientVariables(mapVariables);

      //执行这个启动并提交的命令，返回启动的流程实例

      ProcessInstance processInstance = (ProcessInstance)taskService.expandTaskComplete(expandTaskCommand, null);

      String processInstanceId = processInstance.getId();

      //验证是否成功启动

      assertNotNull(processInstanceId);

    }

   

    taskQuery = taskService.createTaskQuery();

    // 查找 1200119390 的这个流程实例的当前独占任务

    taskInstances = taskQuery.taskAssignee("1200119390").processDefinitionKey("Process_TaskServiceTest").taskNotEnd().list();

    //验证独占任务为20

    assertEquals(20, taskInstances.size());

    //重置任务查询

    taskQuery = taskService.createTaskQuery();

    //取得此流程，此用户的共享任务

    List<TaskInstance> taskInstancesCandidate = taskQuery.taskCandidateUser("1200119390").processDefinitionKey("Process_TaskServiceTest").taskNotEnd().list();

    //验证共享任务为30

    assertEquals(30, taskInstancesCandidate.size());

    //重置任务查询

    taskQuery = taskService.createTaskQuery();

    //查询 1200119390 的这个流程定义的共享和独占任务（此流程的待办事项）

    List<TaskInstance> taskAssigneeAndCandidate =  taskQuery.taskCandidateUser("1200119390").taskAssignee("1200119390").processDefinitionKey("Process_TaskServiceTest").taskNotEnd().list();

    //验证共享和独占任务的总和为50

    assertEquals(50, taskAssigneeAndCandidate.size());

    //重置任务查询

    taskQuery = taskService.createTaskQuery();

    //查询1200119390 的这个流程定义的已办任务

    List<TaskInstance> taskEnd = taskQuery.processDefinitionKey("Process_TaskServiceTest").taskAssignee("1200119390").taskIsEnd().addTaskType(TaskInstanceType.FIXFLOWTASK).list();

    //验证已办任务是否为50

    assertEquals(50, taskEnd.size());

    //取得第一条任务

    TaskInstance taskInstance = taskEnd.get(0);

    //验证任务中的流程定义名称不为空

    assertNotNull(taskInstance.getProcessDefinitionName());

    //测试分页 取1-9条

    taskEnd = taskQuery.listPage(1, 9);