Пример #1
0
 @Test
 public void testExecuteActionsAndStartInstance() throws Exception {
   IFormWorkflowAPI api = FormAPIFactory.getFormWorkflowAPI();
   Map<String, FormFieldValue> fieldValues = new HashMap<String, FormFieldValue>();
   FormFieldValue value1 = new FormFieldValue("Excel", String.class.getName());
   fieldValues.put("fieldId1", value1);
   List<FormAction> formActions = new ArrayList<FormAction>();
   formActions.add(
       new FormAction(
           ActionType.SET_VARIABLE,
           "Applications",
           "APPLICATION",
           "field_fieldId1",
           "submitButtonId"));
   ProcessInstanceUUID newProcessInstanceUUID =
       api.executeActionsAndStartInstance(
           bonitaProcess.getUUID(),
           fieldValues,
           formActions,
           Locale.ENGLISH,
           "submitButtonId",
           new HashMap<String, Object>());
   Assert.assertNotNull(newProcessInstanceUUID);
   QueryRuntimeAPI queryRuntimeAPI = AccessorUtil.getQueryRuntimeAPI();
   Object variableValue =
       queryRuntimeAPI.getProcessInstanceVariable(newProcessInstanceUUID, "Applications");
   Assert.assertEquals("Excel", variableValue.toString());
   AccessorUtil.getRuntimeAPI().deleteProcessInstance(newProcessInstanceUUID);
 }
Пример #2
0
 @Test
 public void testGetTaskEditState() throws Exception {
   QueryRuntimeAPI queryRuntimeAPI = AccessorUtil.getQueryRuntimeAPI();
   RuntimeAPI runtimeAPI = AccessorUtil.getRuntimeAPI();
   Collection<TaskInstance> tasks =
       queryRuntimeAPI.getTaskList(processInstanceUUID, ActivityState.READY);
   ActivityInstanceUUID uuid = null;
   for (TaskInstance activityInstance : tasks) {
     uuid = activityInstance.getUUID();
   }
   Assert.assertNotNull(uuid);
   IFormWorkflowAPI api = FormAPIFactory.getFormWorkflowAPI();
   Assert.assertEquals(ActivityEditState.EDITABLE, api.getTaskEditState(uuid));
   runtimeAPI.suspendTask(uuid, true);
   Assert.assertEquals(ActivityEditState.SUSPENDED, api.getTaskEditState(uuid));
   runtimeAPI.resumeTask(uuid, true);
   runtimeAPI.executeTask(uuid, true);
   Assert.assertEquals(ActivityEditState.NOT_EDITABLE, api.getTaskEditState(uuid));
   tasks = queryRuntimeAPI.getTaskList(processInstanceUUID, ActivityState.READY);
   for (TaskInstance activityInstance : tasks) {
     uuid = activityInstance.getUUID();
   }
   runtimeAPI.cancelProcessInstance(processInstanceUUID);
   Assert.assertEquals(ActivityEditState.CANCELED, api.getTaskEditState(uuid));
 }
Пример #3
0
 @Test
 public void testExecuteTaskActions() throws Exception {
   IFormWorkflowAPI api = FormAPIFactory.getFormWorkflowAPI();
   QueryRuntimeAPI queryRuntimeAPI = AccessorUtil.getQueryRuntimeAPI();
   Collection<TaskInstance> tasks =
       queryRuntimeAPI.getTaskList(processInstanceUUID, ActivityState.READY);
   for (TaskInstance activityInstance : tasks) {
     ActivityInstanceUUID uuid = activityInstance.getUUID();
     Map<String, FormFieldValue> fieldValues = new HashMap<String, FormFieldValue>();
     FormFieldValue value1 = new FormFieldValue("Excel", String.class.getName());
     fieldValues.put("fieldId1", value1);
     List<FormAction> formActions = new ArrayList<FormAction>();
     formActions.add(
         new FormAction(
             ActionType.SET_VARIABLE,
             "Applications",
             "APPLICATION",
             "field_fieldId1",
             "submitButtonId"));
     api.executeActions(uuid, fieldValues, formActions, Locale.ENGLISH);
   }
   Object variableValue =
       queryRuntimeAPI.getProcessInstanceVariable(processInstanceUUID, "Applications");
   Assert.assertEquals("Excel", variableValue.toString());
 }
Пример #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()));
    }
  }
Пример #5
0
 @Test
 public void testGetTaskFieldValue() throws Exception {
   IFormWorkflowAPI api = FormAPIFactory.getFormWorkflowAPI();
   QueryRuntimeAPI queryRuntimeAPI = AccessorUtil.getQueryRuntimeAPI();
   Collection<TaskInstance> tasks =
       queryRuntimeAPI.getTaskList(processInstanceUUID, ActivityState.READY);
   Object result = null;
   for (TaskInstance activityInstance : tasks) {
     ActivityInstanceUUID uuid = activityInstance.getUUID();
     result = api.getFieldValue(uuid, "${Applications}", Locale.ENGLISH, true);
   }
   Assert.assertNotNull(result);
   Assert.assertEquals("Word", result);
 }
Пример #6
0
 @Test
 public void testIsTaskOver() throws Exception {
   QueryRuntimeAPI queryRuntimeAPI = AccessorUtil.getQueryRuntimeAPI();
   RuntimeAPI runtimeAPI = AccessorUtil.getRuntimeAPI();
   Collection<TaskInstance> tasks =
       queryRuntimeAPI.getTaskList(processInstanceUUID, ActivityState.READY);
   ActivityInstanceUUID uuid = null;
   for (TaskInstance activityInstance : tasks) {
     uuid = activityInstance.getUUID();
   }
   Assert.assertNotNull(uuid);
   runtimeAPI.executeTask(uuid, true);
   IFormWorkflowAPI api = FormAPIFactory.getFormWorkflowAPI();
   Assert.assertTrue(api.isTaskOver(uuid));
 }
Пример #7
0
 @Test
 public void testGetProcessInstanceNextTask() throws Exception {
   QueryRuntimeAPI queryRuntimeAPI = AccessorUtil.getQueryRuntimeAPI();
   RuntimeAPI runtimeAPI = AccessorUtil.getRuntimeAPI();
   Collection<TaskInstance> tasks =
       queryRuntimeAPI.getTaskList(processInstanceUUID, ActivityState.READY);
   ActivityInstanceUUID uuid = null;
   for (TaskInstance activityInstance : tasks) {
     uuid = activityInstance.getUUID();
   }
   Assert.assertNotNull(uuid);
   runtimeAPI.executeTask(uuid, true);
   IFormWorkflowAPI api = FormAPIFactory.getFormWorkflowAPI();
   ActivityInstanceUUID activityInstanceUUID =
       api.getProcessInstanceNextTask(uuid.getProcessInstanceUUID());
   Assert.assertEquals("Approval", activityInstanceUUID.getActivityName());
 }
Пример #8
0
 @Test
 public void testExecuteActionsAndTerminateWithAPIAccessor() throws Exception {
   IFormWorkflowAPI api = FormAPIFactory.getFormWorkflowAPI();
   QueryRuntimeAPI queryRuntimeAPI = AccessorUtil.getQueryRuntimeAPI();
   Collection<TaskInstance> tasks =
       queryRuntimeAPI.getTaskList(processInstanceUUID, ActivityState.READY);
   for (TaskInstance activityInstance : tasks) {
     ActivityInstanceUUID uuid = activityInstance.getUUID();
     Map<String, FormFieldValue> fieldValues = new HashMap<String, FormFieldValue>();
     List<FormAction> formActions = new ArrayList<FormAction>();
     formActions.add(
         new FormAction(
             ActionType.EXECUTE_SCRIPT,
             "Applications",
             "APPLICATION",
             "${" + BonitaConstants.API_ACCESSOR + ".getManagementAPI()}",
             "submitButtonId"));
     // api.executeActionsAndTerminate(uuid, fieldValues, formActions, Locale.ENGLISH,
     // "submitButtonId", new HashMap<String, Object>());
   }
 }
Пример #9
0
 @Override
 protected void executeConnector() throws Exception {
   final APIAccessor accessor = getApiAccessor();
   final QueryRuntimeAPI queryRuntimeAPI =
       accessor.getQueryRuntimeAPI(AccessorUtil.QUERYLIST_JOURNAL_KEY);
   final Set<LightActivityInstance> activities =
       queryRuntimeAPI.getLightActivityInstances(getProcessInstanceUUID(), taskName);
   LightTaskInstance task;
   if (activities.size() == 0) {
     // No step found.
     author = null;
   } else if (activities.size() == 1) {
     // Only one step has the given name.
     final LightActivityInstance lightActivityInstance = activities.iterator().next();
     if (lightActivityInstance.isTask()) {
       task = lightActivityInstance.getTask();
       author = task.getEndedBy();
     }
   } else {
     // More than one step have the same name.
     // This is possible in case of iterations.
     // Only consider the current iteration / the latest iteration.
     final List<LightTaskInstance> orderedActivities = new ArrayList<LightTaskInstance>();
     for (LightActivityInstance lightActivityInstance : activities) {
       if (lightActivityInstance.isTask()
           && lightActivityInstance.getTask().getEndedBy() != null) {
         orderedActivities.add(lightActivityInstance.getTask());
       }
     }
     Collections.sort(
         orderedActivities,
         new Comparator<LightTaskInstance>() {
           public int compare(LightTaskInstance o1, LightTaskInstance o2) {
             return o1.getEndedDate().compareTo(o2.getEndedDate());
           }
         });
     author = orderedActivities.iterator().next().getEndedBy();
   }
 }
Пример #10
0
  @Test
  public void testGetActivityAttributesCandidates() throws Exception {
    QueryRuntimeAPI queryRuntimeAPI = AccessorUtil.getQueryRuntimeAPI();
    RuntimeAPI runtimeAPI = AccessorUtil.getRuntimeAPI();
    Collection<TaskInstance> tasks =
        queryRuntimeAPI.getTaskList(processInstanceUUID, ActivityState.READY);
    ActivityInstanceUUID uuid = null;
    for (TaskInstance activityInstance : tasks) {
      uuid = activityInstance.getUUID();
    }
    Assert.assertNotNull(uuid);
    runtimeAPI.executeTask(uuid, true);
    tasks = queryRuntimeAPI.getTaskList(processInstanceUUID, ActivityState.READY);
    for (TaskInstance activityInstance : tasks) {
      uuid = activityInstance.getUUID();
    }
    Assert.assertNotNull(uuid);

    IFormWorkflowAPI api = FormAPIFactory.getFormWorkflowAPI();
    String candidates =
        (String) api.getAttributes(uuid, Locale.ENGLISH).get(ActivityAttribute.candidates.name());
    Assert.assertTrue(candidates.contains("john"));
    Assert.assertTrue(candidates.contains("jack"));
  }
Пример #11
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());
    }
  }