Esempio n. 1
0
  @Test
  public void testGetActivityAttributesRemainingTime() throws Exception {
    ManagementAPI managementAPI = AccessorUtil.getManagementAPI();

    ProcessDefinition simpleProcess =
        ProcessBuilder.createProcess("simple_process", "1.0")
            .addHuman("john")
            .addHumanTask("task1", "john")
            .addActivityExecutingTime(100000000L)
            .done();

    BusinessArchive businessArchive = BusinessArchiveFactory.getBusinessArchive(simpleProcess);
    simpleProcess = managementAPI.deploy(businessArchive);

    ProcessInstanceUUID processInstanceUUID =
        AccessorUtil.getRuntimeAPI().instantiateProcess(simpleProcess.getUUID());

    try {
      Collection<TaskInstance> tasks =
          AccessorUtil.getQueryRuntimeAPI().getTaskList(processInstanceUUID, ActivityState.READY);
      ActivityInstanceUUID uuid = null;
      for (TaskInstance activityInstance : tasks) {
        uuid = activityInstance.getUUID();
      }
      Assert.assertNotNull(uuid);

      IFormWorkflowAPI api = FormAPIFactory.getFormWorkflowAPI();
      String remainingTime =
          (String)
              api.getAttributes(uuid, Locale.ENGLISH).get(ActivityAttribute.remainingTime.name());
      Assert.assertTrue(remainingTime.contains("1day 3hours"));
    } finally {
      AccessorUtil.getManagementAPI().deleteProcess(simpleProcess.getUUID());
    }
  }
Esempio n. 2
0
  public void testDeployBigBusinessArchive() throws Exception {
    ProcessDefinition process =
        ProcessBuilder.createProcess("bigProcess", "1.0")
            .addHuman(getLogin())
            .addHumanTask("step1", getLogin())
            .done();

    final int count = 1000;
    byte[] jar = Misc.generateJar(QuerierAPITest.class);
    Map<String, byte[]> resources = new HashMap<String, byte[]>();
    byte[] tmp;
    for (int i = 0; i < count; i++) {
      tmp = (byte[]) jar.clone();
      resources.put("resource" + i, tmp);
    }

    System.out.println(jar.length);
    BusinessArchive businessArchive = BusinessArchiveFactory.getBusinessArchive(process, resources);

    process = getManagementAPI().deploy(businessArchive);

    ProcessDefinition dbProcess = getQueryDefinitionAPI().getProcess(process.getUUID());
    assertNotNull(dbProcess);

    getManagementAPI().deleteProcess(process.getUUID());
  }
Esempio n. 3
0
  @Test
  public void testGetDefinitionAttachmentFileName() throws Exception {
    ManagementAPI managementAPI = AccessorUtil.getManagementAPI();

    File attachmentFile = File.createTempFile("attachment-test", ".txt");
    FileOutputStream fileOutputStream = new FileOutputStream(attachmentFile);
    fileOutputStream.write("test".getBytes("UTF-8"));
    fileOutputStream.close();

    ProcessDefinition attachmentProcess =
        ProcessBuilder.createProcess("attachment_process", "1.0")
            .addAttachment("attachment", attachmentFile.getPath(), attachmentFile.getName())
            .addHuman("john")
            .addHumanTask("task1", "john")
            .addHumanTask("task2", "john")
            .addTransition("transition", "task1", "task2")
            .done();

    BusinessArchive businessArchive = BusinessArchiveFactory.getBusinessArchive(attachmentProcess);
    attachmentProcess = managementAPI.deploy(businessArchive);

    try {
      IFormWorkflowAPI api = FormAPIFactory.getFormWorkflowAPI();
      String fileName = api.getAttachmentFileName(attachmentProcess.getUUID(), "${attachment}");
      Assert.assertEquals(attachmentFile.getName(), fileName);
    } finally {
      AccessorUtil.getCommandAPI()
          .execute(new WebDeleteDocumentsOfProcessCommand(attachmentProcess.getUUID()));
      AccessorUtil.getCommandAPI()
          .execute(new WebDeleteProcessCommand(attachmentProcess.getUUID()));
    }
  }
Esempio n. 4
0
  @Test
  public void testGetActivityAttachmentFileName() throws Exception {
    RuntimeAPI runtimeAPI = AccessorUtil.getRuntimeAPI();
    ManagementAPI managementAPI = AccessorUtil.getManagementAPI();
    QueryRuntimeAPI queryRuntimeAPI = AccessorUtil.getQueryRuntimeAPI();

    File attachmentFile = File.createTempFile("attachment-test", ".txt");
    FileOutputStream fileOutputStream = new FileOutputStream(attachmentFile);
    fileOutputStream.write("test".getBytes("UTF-8"));
    fileOutputStream.close();

    ProcessDefinition attachmentProcess =
        ProcessBuilder.createProcess("attachment_process", "1.0")
            .addAttachment("attachment", attachmentFile.getPath(), attachmentFile.getName())
            .addHuman("john")
            .addHumanTask("task1", "john")
            .addHumanTask("task2", "john")
            .addTransition("transition", "task1", "task2")
            .done();

    BusinessArchive businessArchive = BusinessArchiveFactory.getBusinessArchive(attachmentProcess);
    attachmentProcess = managementAPI.deploy(businessArchive);

    ProcessInstanceUUID instanceUUID = runtimeAPI.instantiateProcess(attachmentProcess.getUUID());

    try {
      IFormWorkflowAPI api = FormAPIFactory.getFormWorkflowAPI();
      ActivityInstanceUUID activityInstanceUUID = null;
      Collection<TaskInstance> tasks =
          queryRuntimeAPI.getTaskList(instanceUUID, ActivityState.READY);
      for (TaskInstance activityInstance : tasks) {
        activityInstanceUUID = activityInstance.getUUID();
      }
      Assert.assertNotNull(activityInstanceUUID);
      String fileName = api.getAttachmentFileName(activityInstanceUUID, "${attachment}", true);
      Assert.assertEquals(attachmentFile.getName(), fileName);

      runtimeAPI.executeTask(activityInstanceUUID, true);
      fileName = api.getAttachmentFileName(activityInstanceUUID, "${attachment}", true);
      Assert.assertEquals(attachmentFile.getName(), fileName);

      File attachmentFile2 = File.createTempFile("new-attachment-test", ".txt");
      tasks = queryRuntimeAPI.getTaskList(instanceUUID, ActivityState.READY);
      for (TaskInstance activityInstance : tasks) {
        activityInstanceUUID = activityInstance.getUUID();
      }
      Assert.assertNotNull(activityInstanceUUID);
      runtimeAPI.addAttachment(
          instanceUUID, "attachment", attachmentFile2.getName(), "test".getBytes("UTF-8"));
      fileName = api.getAttachmentFileName(activityInstanceUUID, "${attachment}", true);
      Assert.assertEquals(attachmentFile2.getName(), fileName);
    } finally {
      AccessorUtil.getCommandAPI()
          .execute(new WebDeleteDocumentsOfProcessCommand(attachmentProcess.getUUID(), true));
      AccessorUtil.getRuntimeAPI().deleteProcessInstance(instanceUUID);
      AccessorUtil.getCommandAPI()
          .execute(new WebDeleteProcessCommand(attachmentProcess.getUUID()));
    }
  }
Esempio n. 5
0
  @Test
  public void testGetSubprocessNextTask() throws Exception {
    RuntimeAPI runtimeAPI = AccessorUtil.getRuntimeAPI();
    ManagementAPI managementAPI = AccessorUtil.getManagementAPI();

    ProcessDefinition childProcess =
        ProcessBuilder.createProcess("child_process", "1.0")
            .addHuman("john")
            .addHumanTask("childTask", "john")
            .done();

    ProcessDefinition parentProcess =
        ProcessBuilder.createProcess("parent_process", "1.0")
            .addHuman("john")
            .addSubProcess("subTask", "child_process")
            .addHumanTask("parentTask", "john")
            .addTransition("transition", "subTask", "parentTask")
            .done();

    BusinessArchive childBusinessArchive = BusinessArchiveFactory.getBusinessArchive(childProcess);
    childProcess = managementAPI.deploy(childBusinessArchive);

    BusinessArchive parentBusinessArchive =
        BusinessArchiveFactory.getBusinessArchive(parentProcess);
    parentProcess = managementAPI.deploy(parentBusinessArchive);

    ProcessInstanceUUID instanceUUID = runtimeAPI.instantiateProcess(parentProcess.getUUID());

    try {
      IFormWorkflowAPI api = FormAPIFactory.getFormWorkflowAPI();
      ActivityInstanceUUID activityInstanceUUID = api.getProcessInstanceNextTask(instanceUUID);
      Assert.assertNull(activityInstanceUUID);
      activityInstanceUUID = api.getRelatedProcessesNextTask(instanceUUID);
      Assert.assertEquals("childTask", activityInstanceUUID.getActivityName());

      runtimeAPI.executeTask(activityInstanceUUID, true);
      activityInstanceUUID =
          api.getRelatedProcessesNextTask(activityInstanceUUID.getProcessInstanceUUID());
      Assert.assertEquals("parentTask", activityInstanceUUID.getActivityName());
    } finally {
      runtimeAPI.deleteProcessInstance(instanceUUID);

      managementAPI.deleteProcess(parentProcess.getUUID());
      managementAPI.deleteProcess(childProcess.getUUID());
    }
  }
Esempio n. 6
0
  private ProcessDefinition buildSubProcess() throws Exception {
    ProcessDefinition subProcess =
        ProcessBuilder.createProcess("sub_process", "1.0")
            .addBooleanData("terminateit", false)
            .addHuman("john")
            .addHumanTask("task1sub", "john")
            .addSystemTask("activity2sub")
            .addTransition("transition1", "task1sub", "activity2sub")
            .done();

    BusinessArchive businessArchive = BusinessArchiveFactory.getBusinessArchive(subProcess);
    return AccessorUtil.getManagementAPI().deploy(businessArchive);
  }
Esempio n. 7
0
  @Before
  public void setUp() throws Exception {

    login("john", "bpm");

    URL testBarURL = getClass().getResource("/approvalWorkflow.bar");
    if (testBarURL == null) {
      throw new RuntimeException("File approvalWorkflow.bar was not found.");
    }
    BusinessArchive businessArchive =
        BusinessArchiveFactory.getBusinessArchive(new File(testBarURL.toURI()));
    bonitaProcess = AccessorUtil.getManagementAPI().deploy(businessArchive);
    processInstanceUUID = AccessorUtil.getRuntimeAPI().instantiateProcess(bonitaProcess.getUUID());
  }
Esempio n. 8
0
  private ProcessDefinition buildIterationProcess() throws Exception {
    ProcessDefinition iterationProcess =
        ProcessBuilder.createProcess("complex_iteration_process", "1.0")
            .addBooleanData("terminateit", false)
            .addHuman("john")
            .addHumanTask("task1", "john")
            .addSubProcess("subprocess", "sub_process")
            .addSubProcessInParameter("terminateit", "terminateit")
            .addSubProcessOutParameter("terminateit", "terminateit")
            .addHumanTask("task2", "john")
            .addTransition("transition1", "task1", "subprocess")
            .addTransition("transition2", "subprocess", "subprocess")
            .addCondition("!terminateit")
            .addTransition("transition3", "subprocess", "task2")
            .addCondition("terminateit")
            .done();

    BusinessArchive businessArchive = BusinessArchiveFactory.getBusinessArchive(iterationProcess);
    return AccessorUtil.getManagementAPI().deploy(businessArchive);
  }
Esempio n. 9
0
  @Test
  public void testGetSubprocessLoopNextTask() throws Exception {
    RuntimeAPI runtimeAPI = AccessorUtil.getRuntimeAPI();
    ManagementAPI managementAPI = AccessorUtil.getManagementAPI();
    QueryRuntimeAPI queryRuntimeAPI = AccessorUtil.getQueryRuntimeAPI();
    IFormWorkflowAPI api = FormAPIFactory.getFormWorkflowAPI();

    ProcessDefinition childProcess =
        ProcessBuilder.createProcess("sub_process", "1.0")
            .addIntegerData("counter")
            .addHuman("john")
            .addHumanTask("task1", "john")
            .addHumanTask("task2", "john")
            .addConnector(Event.taskOnFinish, SetVarConnector.class.getName(), true)
            .addInputParameter("variableName", "counter")
            .addInputParameter("value", "${++counter}")
            .addTransition("transition1", "task1", "task2")
            .done();

    ProcessDefinition processWithSubProcess =
        ProcessBuilder.createProcess("parent_process", "1.0")
            .addHuman("john")
            .addIntegerData("counter", 0)
            .addSubProcess("subprocess", "sub_process")
            .addSubProcessInParameter("counter", "counter")
            .addSubProcessOutParameter("counter", "counter")
            .addLoop("counter < 10", false)
            .addHumanTask("task3", "john")
            .addTransition("transition2", "subprocess", "task3")
            .done();

    BusinessArchive childBusinessArchive = BusinessArchiveFactory.getBusinessArchive(childProcess);
    childProcess = managementAPI.deploy(childBusinessArchive);

    BusinessArchive parentBusinessArchive =
        BusinessArchiveFactory.getBusinessArchive(processWithSubProcess);
    processWithSubProcess = managementAPI.deploy(parentBusinessArchive);

    ProcessInstanceUUID processInstanceUUID =
        runtimeAPI.instantiateProcess(processWithSubProcess.getUUID());

    try {
      for (int i = 0; i < 10; i++) {
        Set<ActivityInstance> activityInstances =
            queryRuntimeAPI.getActivityInstances(processInstanceUUID);
        Assert.assertEquals(i + 1, activityInstances.size());
        for (ActivityInstance activityInstance : activityInstances) {
          Assert.assertEquals("subprocess", activityInstance.getActivityName());
        }

        ProcessInstance processInstance = queryRuntimeAPI.getProcessInstance(processInstanceUUID);
        Set<ProcessInstanceUUID> childrenInstanceUUID = processInstance.getChildrenInstanceUUID();
        for (ProcessInstanceUUID childInstanceUUID : childrenInstanceUUID) {
          ProcessInstance childInstance = queryRuntimeAPI.getProcessInstance(childInstanceUUID);
          if (InstanceState.STARTED.equals(childInstance.getInstanceState())) {
            Collection<TaskInstance> taskInstances =
                queryRuntimeAPI.getTaskList(childInstanceUUID, ActivityState.READY);
            Assert.assertEquals(1, taskInstances.size());
            TaskInstance childTaskInstance = taskInstances.iterator().next();
            Assert.assertEquals("task1", childTaskInstance.getActivityName());
            Assert.assertEquals(ActivityState.READY, childTaskInstance.getState());
            runtimeAPI.executeTask(childTaskInstance.getUUID(), true);

            taskInstances = queryRuntimeAPI.getTaskList(childInstanceUUID, ActivityState.READY);
            Assert.assertEquals(1, taskInstances.size());
            childTaskInstance = taskInstances.iterator().next();
            Assert.assertEquals("task2", childTaskInstance.getActivityName());
            Assert.assertEquals(ActivityState.READY, childTaskInstance.getState());
            runtimeAPI.executeTask(childTaskInstance.getUUID(), true);

            if (i < 9) {
              ActivityInstanceUUID activityInstanceUUID =
                  api.getRelatedProcessesNextTask(childInstance.getUUID());
              Assert.assertEquals("task1", activityInstanceUUID.getActivityName());
            }

            childInstance = queryRuntimeAPI.getProcessInstance(childInstanceUUID);
            Assert.assertEquals(InstanceState.FINISHED, childInstance.getInstanceState());
          }
        }
      }

      Collection<TaskInstance> taskInstances =
          queryRuntimeAPI.getTaskList(processInstanceUUID, ActivityState.READY);
      Assert.assertEquals(1, taskInstances.size());
      TaskInstance taskInstance = taskInstances.iterator().next();
      Assert.assertEquals("task3", taskInstance.getActivityName());
      Assert.assertEquals(ActivityState.READY, taskInstance.getState());
      runtimeAPI.executeTask(taskInstance.getUUID(), true);
    } finally {
      managementAPI.deleteProcess(processWithSubProcess.getUUID());
      managementAPI.deleteProcess(childProcess.getUUID());
    }
  }