org.activiti.bpmn.model.ServiceTask Java Examples

/**
 * This method tests the scenario where a java delegate is not populated again with spring beans.
 */
@Test
public void testDelegateSpringBeansNotPopulatedAgain() throws Exception
{
    BpmnModel bpmnModel = getBpmnModelForXmlResource(ACTIVITI_XML_HERD_WORKFLOW);

    ServiceTask serviceTask = (ServiceTask) bpmnModel.getProcesses().get(0).getFlowElement("servicetask1");
    serviceTask.setImplementation(MockJavaDelegate.class.getCanonicalName());
    serviceTask.getFieldExtensions().clear();

    // Define the job definition
    jobDefinitionServiceTestHelper.createJobDefinitionForActivitiXml(getActivitiXmlFromBpmnModel(bpmnModel));

    // Executing the job twice so that the same JavaDelegate object is used and spring beans are not wired again.
    jobService.createAndStartJob(jobServiceTestHelper.createJobCreateRequest(TEST_ACTIVITI_NAMESPACE_CD, TEST_ACTIVITI_JOB_NAME));
    jobService.createAndStartJob(jobServiceTestHelper.createJobCreateRequest(TEST_ACTIVITI_NAMESPACE_CD, TEST_ACTIVITI_JOB_NAME));
}
 

@Test
public void testMapExceptionWithNoExceptionClass() throws Exception {
  resourceName = "mapException/mapExceptionNoExceptionClass.bpmn";

  BpmnModel bpmnModel = readXMLFile();
  FlowElement flowElement = bpmnModel.getMainProcess().getFlowElement("servicetaskWithAndTrueAndChildren");
  assertNotNull(flowElement);
  assertTrue(flowElement instanceof ServiceTask);
  assertEquals("servicetaskWithAndTrueAndChildren", flowElement.getId());
  ServiceTask serviceTask = (ServiceTask) flowElement;
  assertNotNull(serviceTask.getMapExceptions());
  assertEquals(1, serviceTask.getMapExceptions().size());
  assertNotNull(serviceTask.getMapExceptions().get(0).getClassName());
  assertEquals(0, serviceTask.getMapExceptions().get(0).getClassName().length());

}
 

/**
 * This method tests when wrong class name is used in service task, the process instance is created.
 */
@Test
public void testDelegateWrongClass() throws Exception
{
    BpmnModel bpmnModel = getBpmnModelForXmlResource(ACTIVITI_XML_HERD_WORKFLOW);
    ServiceTask serviceTask = (ServiceTask) bpmnModel.getProcesses().get(0).getFlowElement("servicetask1");

    serviceTask.setImplementation("ClassDoesNotExist");
    serviceTask.getFieldExtensions().clear();

    // Run a job with Activiti XML that will start cluster.
    try
    {
        jobServiceTestHelper.createJobFromActivitiXml(getActivitiXmlFromBpmnModel(bpmnModel), null);
        fail();
    }
    catch (Exception e)
    {
        assertEquals(ActivitiException.class, e.getClass());
        assertEquals("couldn't instantiate class ClassDoesNotExist", e.getMessage());
    }
}
 

/**
 * This method tests the scenario where a RuntimeException occurs but not thrown by java delegate.
 */
@Test
public void testDelegateRuntimeError() throws Exception
{
    BpmnModel bpmnModel = getBpmnModelForXmlResource(ACTIVITI_XML_HERD_WORKFLOW);

    ServiceTask serviceTask = (ServiceTask) bpmnModel.getProcesses().get(0).getFlowElement("servicetask1");

    serviceTask.setImplementation(MockJavaDelegate.class.getCanonicalName());

    FieldExtension exceptionField = new FieldExtension();
    exceptionField.setFieldName("exceptionToThrow");
    exceptionField.setExpression("${exceptionToThrow}");
    serviceTask.getFieldExtensions().clear();
    serviceTask.getFieldExtensions().add(exceptionField);

    List<Parameter> parameters = new ArrayList<>();

    Parameter parameter = new Parameter("exceptionToThrow", MockJavaDelegate.EXCEPTION_RUNTIME);
    parameters.add(parameter);

    executeWithoutLogging(Arrays.asList(ActivitiRuntimeHelper.class, BaseJavaDelegate.class), () -> {
        jobServiceTestHelper.createJobFromActivitiXml(getActivitiXmlFromBpmnModel(bpmnModel), parameters);
    });
}
 

protected void verifyWebservice(BpmnModel bpmnModel, Process process, ServiceTask serviceTask, List<ValidationError> errors) {
  if (ImplementationType.IMPLEMENTATION_TYPE_WEBSERVICE.equalsIgnoreCase(serviceTask.getImplementationType()) && StringUtils.isNotEmpty(serviceTask.getOperationRef())) {

    boolean operationFound = false;
    if (bpmnModel.getInterfaces() != null && !bpmnModel.getInterfaces().isEmpty()) {
      for (Interface bpmnInterface : bpmnModel.getInterfaces()) {
        if (bpmnInterface.getOperations() != null && !bpmnInterface.getOperations().isEmpty()) {
          for (Operation operation : bpmnInterface.getOperations()) {
            if (operation.getId() != null && operation.getId().equals(serviceTask.getOperationRef())) {
              operationFound = true;
            }
          }
        }
      }
    }

    if (!operationFound) {
      addError(errors, Problems.SERVICE_TASK_WEBSERVICE_INVALID_OPERATION_REF, process, serviceTask, "Invalid operation reference");
    }

  }
}
 

private String buildActivitiXml(String implementation, List<FieldExtension> fieldExtensionList) throws Exception
{
    BpmnModel bpmnModel = getBpmnModelForXmlResource(ACTIVITI_XML_ADD_EMR_STEPS_WITH_CLASSPATH);

    ServiceTask serviceTask = (ServiceTask) bpmnModel.getProcesses().get(0).getFlowElement("addStepServiceTask");

    serviceTask.setImplementation(implementation);
    serviceTask.getFieldExtensions().addAll(fieldExtensionList);

    return getActivitiXmlFromBpmnModel(bpmnModel);
}
 

protected void setPropertyFieldValue(String propertyName, String fieldName, ServiceTask task, ObjectNode propertiesNode) {
  for (FieldExtension extension : task.getFieldExtensions()) {
    if (fieldName.equalsIgnoreCase(extension.getFieldName())) {
      if (StringUtils.isNotEmpty(extension.getStringValue())) {
        setPropertyValue(propertyName, extension.getStringValue(), propertiesNode);
      } else if (StringUtils.isNotEmpty(extension.getExpression())) {
        setPropertyValue(propertyName, extension.getExpression(), propertiesNode);
      }
    }
  }
}
 

protected void setPropertyFieldValue(String name, ServiceTask task, ObjectNode propertiesNode) {
  for (FieldExtension extension : task.getFieldExtensions()) {
    if (name.substring(8).equalsIgnoreCase(extension.getFieldName())) {
      if (StringUtils.isNotEmpty(extension.getStringValue())) {
        setPropertyValue(name, extension.getStringValue(), propertiesNode);
      } else if (StringUtils.isNotEmpty(extension.getExpression())) {
        setPropertyValue(name, extension.getExpression(), propertiesNode);
      }
    }
  }
}
 

protected String buildActivitiXml(String implementation, List<FieldExtension> fieldExtensionList) throws Exception
{
    BpmnModel bpmnModel = getBpmnModelForXmlResource(ACTIVITI_XML_TEST_SERVICE_TASK_WITH_CLASSPATH);

    ServiceTask serviceTask = (ServiceTask) bpmnModel.getProcesses().get(0).getFlowElement(serviceTaskId);

    serviceTask.setImplementation(implementation);
    serviceTask.getFieldExtensions().addAll(fieldExtensionList);

    return getActivitiXmlFromBpmnModel(bpmnModel);
}
 

protected void executeParse(BpmnModel bpmnModel, Process element) {
  for (FlowElement flowElement : element.getFlowElements()) {
    if (!ServiceTask.class.isAssignableFrom(flowElement.getClass())) {
      continue;
    }
    ServiceTask serviceTask = (ServiceTask) flowElement;
    validateAsyncAttribute(serviceTask, bpmnModel, flowElement);
  }
}
 

@Override
protected void executeValidation(BpmnModel bpmnModel, Process process, List<ValidationError> errors) {
  List<ServiceTask> serviceTasks = process.findFlowElementsOfType(ServiceTask.class);
  for (ServiceTask serviceTask : serviceTasks) {
    verifyImplementation(process, serviceTask, errors);
    verifyType(process, serviceTask, errors);
    verifyResultVariableName(process, serviceTask, errors);
    verifyWebservice(bpmnModel, process, serviceTask, errors);
  }

}
 

protected FlowElement convertJsonToElement(JsonNode elementNode, JsonNode modelNode, Map<String, JsonNode> shapeMap) {
  ServiceTask task = new ServiceTask();
  task.setType(ServiceTask.MAIL_TASK);
  addField(PROPERTY_MAILTASK_TO, elementNode, task);
  addField(PROPERTY_MAILTASK_FROM, elementNode, task);
  addField(PROPERTY_MAILTASK_SUBJECT, elementNode, task);
  addField(PROPERTY_MAILTASK_CC, elementNode, task);
  addField(PROPERTY_MAILTASK_BCC, elementNode, task);
  addField(PROPERTY_MAILTASK_TEXT, elementNode, task);
  addField(PROPERTY_MAILTASK_HTML, elementNode, task);
  addField(PROPERTY_MAILTASK_CHARSET, elementNode, task);

  return task;
}
 

protected void mapProperties(Object element) {
	ServiceTask serviceTask = (ServiceTask) element;
	if (ImplementationType.IMPLEMENTATION_TYPE_CLASS.equals(serviceTask.getImplementationType())) {
		createPropertyNode("Class", serviceTask.getImplementation());
	} else if (ImplementationType.IMPLEMENTATION_TYPE_EXPRESSION.equals(serviceTask.getImplementationType())) {
		createPropertyNode("Expression", serviceTask.getImplementation());
	} else if (ImplementationType.IMPLEMENTATION_TYPE_DELEGATEEXPRESSION.equals(serviceTask.getImplementationType())) {
		createPropertyNode("Delegate expression", serviceTask.getImplementation());
	}
	createPropertyNode("Result variable name", serviceTask.getResultVariableName());
}
 

void validateAsyncAttribute(ServiceTask serviceTask, BpmnModel bpmnModel,
    FlowElement flowElement) {
  if (!serviceTask.isAsynchronous()) {
    bpmnModel.addError("Please set value of 'activiti:async'" +
        "attribute as true for task:" + serviceTask.getName(), flowElement.getId());
  }
}
 

protected void verifyResultVariableName(Process process, ServiceTask serviceTask, List<ValidationError> errors) {
  if (StringUtils.isNotEmpty(serviceTask.getResultVariableName())
      && (ImplementationType.IMPLEMENTATION_TYPE_CLASS.equals(serviceTask.getImplementationType()) || ImplementationType.IMPLEMENTATION_TYPE_DELEGATEEXPRESSION.equals(serviceTask
          .getImplementationType()))) {
    addError(errors, Problems.SERVICE_TASK_RESULT_VAR_NAME_WITH_DELEGATE, process, serviceTask, "'resultVariableName' not supported for service tasks using 'class' or 'delegateExpression");
  }
}
 

/**
 * This method tests the scenario when an error that is not workflow related is throws while workflow is executing an Async type task like Timer. This error
 * is logged as ERROR.
 */
@Test(expected = ActivitiException.class)
public void testActivitiReportableError() throws Exception
{
    BpmnModel bpmnModel = getBpmnModelForXmlResource(ACTIVITI_XML_HERD_TIMER_WITH_CLASSPATH);

    ServiceTask serviceTask = (ServiceTask) bpmnModel.getProcesses().get(0).getFlowElement("servicetask1");

    FieldExtension exceptionField = new FieldExtension();
    exceptionField.setFieldName("exceptionToThrow");
    exceptionField.setExpression("${exceptionToThrow}");
    serviceTask.getFieldExtensions().add(exceptionField);

    jobDefinitionServiceTestHelper.createJobDefinitionForActivitiXml(getActivitiXmlFromBpmnModel(bpmnModel));

    List<Parameter> parameters = new ArrayList<>();

    Parameter parameter = new Parameter("exceptionToThrow", MockJavaDelegate.EXCEPTION_BPMN_ERROR);
    parameters.add(parameter);

    Job job = jobService.createAndStartJob(jobServiceTestHelper.createJobCreateRequest(TEST_ACTIVITI_NAMESPACE_CD, TEST_ACTIVITI_JOB_NAME, parameters));
    org.activiti.engine.runtime.Job timer = activitiManagementService.createJobQuery().processInstanceId(job.getId()).timers().singleResult();
    if (timer != null)
    {
        executeWithoutLogging(Arrays.asList(ActivitiRuntimeHelper.class, TimerExecuteNestedActivityJobHandler.class), () -> {
            activitiManagementService.executeJob(timer.getId());
        });
    }
}
 

@Override
protected BaseElement convertXMLToElement(XMLStreamReader xtr, BpmnModel model) throws Exception {
  ServiceTask serviceTask = new ServiceTask();
  BpmnXMLUtil.addXMLLocation(serviceTask, xtr);
  if (StringUtils.isNotEmpty(xtr.getAttributeValue(ACTIVITI_EXTENSIONS_NAMESPACE, ATTRIBUTE_TASK_SERVICE_CLASS))) {
    serviceTask.setImplementationType(ImplementationType.IMPLEMENTATION_TYPE_CLASS);
    serviceTask.setImplementation(xtr.getAttributeValue(ACTIVITI_EXTENSIONS_NAMESPACE, ATTRIBUTE_TASK_SERVICE_CLASS));

  } else if (StringUtils.isNotEmpty(xtr.getAttributeValue(ACTIVITI_EXTENSIONS_NAMESPACE, ATTRIBUTE_TASK_SERVICE_EXPRESSION))) {
    serviceTask.setImplementationType(ImplementationType.IMPLEMENTATION_TYPE_EXPRESSION);
    serviceTask.setImplementation(xtr.getAttributeValue(ACTIVITI_EXTENSIONS_NAMESPACE, ATTRIBUTE_TASK_SERVICE_EXPRESSION));

  } else if (StringUtils.isNotEmpty(xtr.getAttributeValue(ACTIVITI_EXTENSIONS_NAMESPACE, ATTRIBUTE_TASK_SERVICE_DELEGATEEXPRESSION))) {
    serviceTask.setImplementationType(ImplementationType.IMPLEMENTATION_TYPE_DELEGATEEXPRESSION);
    serviceTask.setImplementation(xtr.getAttributeValue(ACTIVITI_EXTENSIONS_NAMESPACE, ATTRIBUTE_TASK_SERVICE_DELEGATEEXPRESSION));

  } else if ("##WebService".equals(xtr.getAttributeValue(null, ATTRIBUTE_TASK_IMPLEMENTATION))) {
    serviceTask.setImplementationType(ImplementationType.IMPLEMENTATION_TYPE_WEBSERVICE);
    serviceTask.setOperationRef(parseOperationRef(xtr.getAttributeValue(null, ATTRIBUTE_TASK_OPERATION_REF), model));
  }

  serviceTask.setResultVariableName(xtr.getAttributeValue(ACTIVITI_EXTENSIONS_NAMESPACE, ATTRIBUTE_TASK_SERVICE_RESULTVARIABLE));
  if (StringUtils.isEmpty(serviceTask.getResultVariableName())) {
    serviceTask.setResultVariableName(xtr.getAttributeValue(ACTIVITI_EXTENSIONS_NAMESPACE, "resultVariable"));
  }

  serviceTask.setType(xtr.getAttributeValue(ACTIVITI_EXTENSIONS_NAMESPACE, ATTRIBUTE_TYPE));
  serviceTask.setExtensionId(xtr.getAttributeValue(ACTIVITI_EXTENSIONS_NAMESPACE, ATTRIBUTE_TASK_SERVICE_EXTENSIONID));

  if (StringUtils.isNotEmpty(xtr.getAttributeValue(ACTIVITI_EXTENSIONS_NAMESPACE, ATTRIBUTE_TASK_SERVICE_SKIP_EXPRESSION))) {
    serviceTask.setSkipExpression(xtr.getAttributeValue(ACTIVITI_EXTENSIONS_NAMESPACE, ATTRIBUTE_TASK_SERVICE_SKIP_EXPRESSION));
  }
  parseChildElements(getXMLElementName(), serviceTask, model, xtr);

  return serviceTask;
}
 

protected FlowElement convertJsonToElement(JsonNode elementNode, JsonNode modelNode, Map<String, JsonNode> shapeMap) {
  ServiceTask task = new ServiceTask();
  task.setType("mule");
  addField("endpointUrl", PROPERTY_MULETASK_ENDPOINT_URL, elementNode, task);
  addField("language", PROPERTY_MULETASK_LANGUAGE, elementNode, task);
  addField("payloadExpression", PROPERTY_MULETASK_PAYLOAD_EXPRESSION, elementNode, task);
  addField("resultVariable", PROPERTY_MULETASK_RESULT_VARIABLE, elementNode, task);
  return task;
}
 

public ClassDelegate createClassDelegateServiceTask(ServiceTask serviceTask) {
  Expression skipExpression;
  if (StringUtils.isNotEmpty(serviceTask.getSkipExpression())) {
    skipExpression = expressionManager.createExpression(serviceTask.getSkipExpression());
  } else {
    skipExpression = null;
  }
  return new ClassDelegate(serviceTask.getId(), serviceTask.getImplementation(), createFieldDeclarations(serviceTask.getFieldExtensions()), 
      skipExpression, serviceTask.getMapExceptions());
}
 

private void validateModel(BpmnModel model) {

    // check service task with andChildren Set to True
    FlowElement flowElement = model.getMainProcess().getFlowElement("servicetaskWithAndTrueAndChildren");
    assertNotNull(flowElement);
    assertTrue(flowElement instanceof ServiceTask);
    assertEquals("servicetaskWithAndTrueAndChildren", flowElement.getId());
    ServiceTask serviceTask = (ServiceTask) flowElement;
    assertNotNull(serviceTask.getMapExceptions());
    assertEquals(3, serviceTask.getMapExceptions().size());

    // check a normal mapException, with hasChildren == true
    assertEquals("myErrorCode1", serviceTask.getMapExceptions().get(0).getErrorCode());
    assertEquals("com.activiti.Something1", serviceTask.getMapExceptions().get(0).getClassName());
    assertTrue(serviceTask.getMapExceptions().get(0).isAndChildren());

    // check a normal mapException, with hasChildren == false
    assertEquals("myErrorCode2", serviceTask.getMapExceptions().get(1).getErrorCode());
    assertEquals("com.activiti.Something2", serviceTask.getMapExceptions().get(1).getClassName());
    assertFalse(serviceTask.getMapExceptions().get(1).isAndChildren());

    // check a normal mapException, with no hasChildren Defined, default
    // should
    // be false
    assertEquals("myErrorCode3", serviceTask.getMapExceptions().get(2).getErrorCode());
    assertEquals("com.activiti.Something3", serviceTask.getMapExceptions().get(2).getClassName());
    assertFalse(serviceTask.getMapExceptions().get(2).isAndChildren());

    // if no map exception is defined, getMapException should return a not
    // null
    // empty list
    FlowElement flowElement1 = model.getMainProcess().getFlowElement("servicetaskWithNoMapException");
    assertNotNull(flowElement1);
    assertTrue(flowElement1 instanceof ServiceTask);
    assertEquals("servicetaskWithNoMapException", flowElement1.getId());
    ServiceTask serviceTask1 = (ServiceTask) flowElement1;
    assertNotNull(serviceTask1.getMapExceptions());
    assertEquals(0, serviceTask1.getMapExceptions().size());

  }
 

private void validateModel(BpmnModel model) {
  FlowElement flowElement = model.getMainProcess().getFlowElement("servicetask");
  assertNotNull(flowElement);
  assertTrue(flowElement instanceof ServiceTask);
  assertEquals("servicetask", flowElement.getId());
  ServiceTask serviceTask = (ServiceTask) flowElement;
  assertEquals("servicetask", serviceTask.getId());
  assertEquals("Service task", serviceTask.getName());

  List<FieldExtension> fields = serviceTask.getFieldExtensions();
  assertEquals(2, fields.size());
  FieldExtension field = fields.get(0);
  assertEquals("testField", field.getFieldName());
  assertEquals("test", field.getStringValue());
  field = fields.get(1);
  assertEquals("testField2", field.getFieldName());
  assertEquals("${test}", field.getExpression());

  List<ActivitiListener> listeners = serviceTask.getExecutionListeners();
  assertEquals(3, listeners.size());
  ActivitiListener listener = listeners.get(0);
  assertTrue(ImplementationType.IMPLEMENTATION_TYPE_CLASS.equals(listener.getImplementationType()));
  assertEquals("org.test.TestClass", listener.getImplementation());
  assertEquals("start", listener.getEvent());
  listener = listeners.get(1);
  assertTrue(ImplementationType.IMPLEMENTATION_TYPE_EXPRESSION.equals(listener.getImplementationType()));
  assertEquals("${testExpression}", listener.getImplementation());
  assertEquals("end", listener.getEvent());
  listener = listeners.get(2);
  assertTrue(ImplementationType.IMPLEMENTATION_TYPE_DELEGATEEXPRESSION.equals(listener.getImplementationType()));
  assertEquals("${delegateExpression}", listener.getImplementation());
  assertEquals("start", listener.getEvent());

  assertEquals("R5/PT5M", serviceTask.getFailedJobRetryTimeCycleValue());
}
 

public ServiceTaskExpressionActivityBehavior createServiceTaskExpressionActivityBehavior(ServiceTask serviceTask) {
  Expression expression = expressionManager.createExpression(serviceTask.getImplementation());
  Expression skipExpression;
  if (StringUtils.isNotEmpty(serviceTask.getSkipExpression())) {
    skipExpression = expressionManager.createExpression(serviceTask.getSkipExpression());
  } else {
    skipExpression = null;
  }
  return new ServiceTaskExpressionActivityBehavior(serviceTask.getId(), expression, skipExpression, serviceTask.getResultVariableName());
}
 

@Override
public MailActivityBehavior createMailActivityBehavior(ServiceTask serviceTask) {
  return wrappedActivityBehaviorFactory.createMailActivityBehavior(serviceTask);
}
 

@Override
public ActivityBehavior createDmnActivityBehavior(ServiceTask serviceTask) {
  return wrappedActivityBehaviorFactory.createDmnActivityBehavior(serviceTask);
}
 

@Override
public ServiceTaskExpressionActivityBehavior createServiceTaskExpressionActivityBehavior(ServiceTask serviceTask) {
  return wrappedActivityBehaviorFactory.createServiceTaskExpressionActivityBehavior(serviceTask);
}
 

public Class<? extends BaseElement> getHandledType() {
  return ServiceTask.class;
}
 

public ShellActivityBehavior createShellActivityBehavior(ServiceTask serviceTask) {
  List<FieldDeclaration> fieldDeclarations = createFieldDeclarations(serviceTask.getFieldExtensions());
  return (ShellActivityBehavior) ClassDelegate.defaultInstantiateDelegate(
      ShellActivityBehavior.class, fieldDeclarations);
}
 

public WebServiceActivityBehavior createWebServiceActivityBehavior(ServiceTask serviceTask)
{
	return _source.createWebServiceActivityBehavior(serviceTask);
}
 

@Override
public ServiceTaskExpressionActivityBehavior createServiceTaskExpressionActivityBehavior(ServiceTask serviceTask) {
	return wrappedActivityBehaviorFactory.createServiceTaskExpressionActivityBehavior(serviceTask);
}
 

@Override
public WebServiceActivityBehavior createWebServiceActivityBehavior(ServiceTask serviceTask) {
	return wrappedActivityBehaviorFactory.createWebServiceActivityBehavior(serviceTask);
}