Tabnine Logo
ServiceTask
Code IndexAdd Tabnine to your IDE (free)

How to use
ServiceTask
in
org.flowable.bpmn.model

Best Java code snippets using org.flowable.bpmn.model.ServiceTask (Showing top 20 results out of 315)

Refine searchRefine arrow

  • StringUtils
  • Common ways to obtain ServiceTask
private void myMethod () {
 ServiceTask s =
  • Codota Iconnew ServiceTask()
  • Smart code suggestions by Tabnine
}
origin: org.flowable/flowable-process-validation

protected void verifyImplementation(Process process, ServiceTask serviceTask, List<ValidationError> errors) {
  if (!ImplementationType.IMPLEMENTATION_TYPE_CLASS.equalsIgnoreCase(serviceTask.getImplementationType())
      && !ImplementationType.IMPLEMENTATION_TYPE_DELEGATEEXPRESSION.equalsIgnoreCase(serviceTask.getImplementationType())
      && !ImplementationType.IMPLEMENTATION_TYPE_EXPRESSION.equalsIgnoreCase(serviceTask.getImplementationType())
      && !ImplementationType.IMPLEMENTATION_TYPE_WEBSERVICE.equalsIgnoreCase(serviceTask.getImplementationType()) 
      && !ServiceTask.CASE_TASK.equalsIgnoreCase(serviceTask.getType()) 
      && StringUtils.isEmpty(serviceTask.getType())) {
    
    addError(errors, Problems.SERVICE_TASK_MISSING_IMPLEMENTATION, process, serviceTask,
        "One of the attributes 'class', 'delegateExpression', 'type', 'operation', or 'expression' is mandatory on serviceTask.");
  }
}
origin: org.flowable/flowable-process-validation

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");
  }
  if (serviceTask.isUseLocalScopeForResultVariable() && StringUtils.isEmpty(serviceTask.getResultVariableName())) {
    addWarning(errors, Problems.SERVICE_TASK_USE_LOCAL_SCOPE_FOR_RESULT_VAR_WITHOUT_RESULT_VARIABLE_NAME, process, serviceTask, "'useLocalScopeForResultVariable' is set, but no 'resultVariableName' is set. The property would not be used");
  }
}
origin: org.flowable/flowable5-engine

@Override
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());
}
origin: org.flowable/flowable-engine

public ServiceTaskExpressionActivityBehavior(ServiceTask serviceTask, Expression expression, Expression skipExpression) {
  this.serviceTaskId = serviceTask.getId();
  this.expression = expression;
  this.skipExpression = skipExpression;
  this.resultVariable = serviceTask.getResultVariableName();
  this.mapExceptions = serviceTask.getMapExceptions();
  this.useLocalScopeForResultVariable = serviceTask.isUseLocalScopeForResultVariable();
}
origin: org.flowable/flowable-bpmn-model

@Override
public ServiceTask clone() {
  ServiceTask clone = new ServiceTask();
  clone.setValues(this);
  return clone;
}
origin: org.flowable/flowable-engine

@Override
public ClassDelegate createClassDelegateServiceTask(ServiceTask serviceTask) {
  return classDelegateFactory.create(serviceTask.getId(), serviceTask.getImplementation(),
      createFieldDeclarations(serviceTask.getFieldExtensions()),
      serviceTask.isTriggerable(),
      getSkipExpressionFromServiceTask(serviceTask), serviceTask.getMapExceptions());
}
origin: org.flowable/flowable-bpmn-converter

  serviceTask = new ServiceTask();
if (StringUtils.isNotEmpty(BpmnXMLUtil.getAttributeValue(ATTRIBUTE_TASK_SERVICE_CLASS, xtr))) {
  serviceTask.setImplementationType(ImplementationType.IMPLEMENTATION_TYPE_CLASS);
  serviceTask.setImplementation(BpmnXMLUtil.getAttributeValue(ATTRIBUTE_TASK_SERVICE_CLASS, xtr));
} else if (StringUtils.isNotEmpty(BpmnXMLUtil.getAttributeValue(ATTRIBUTE_TASK_SERVICE_EXPRESSION, xtr))) {
  serviceTask.setImplementationType(ImplementationType.IMPLEMENTATION_TYPE_EXPRESSION);
  serviceTask.setImplementation(BpmnXMLUtil.getAttributeValue(ATTRIBUTE_TASK_SERVICE_EXPRESSION, xtr));
} else if (StringUtils.isNotEmpty(BpmnXMLUtil.getAttributeValue(ATTRIBUTE_TASK_SERVICE_DELEGATEEXPRESSION, xtr))) {
  serviceTask.setImplementationType(ImplementationType.IMPLEMENTATION_TYPE_DELEGATEEXPRESSION);
  serviceTask.setImplementation(BpmnXMLUtil.getAttributeValue(ATTRIBUTE_TASK_SERVICE_DELEGATEEXPRESSION, xtr));
  serviceTask.setImplementationType(ImplementationType.IMPLEMENTATION_TYPE_WEBSERVICE);
  serviceTask.setOperationRef(parseOperationRef(xtr.getAttributeValue(null, ATTRIBUTE_TASK_OPERATION_REF), model));
serviceTask.setResultVariableName(BpmnXMLUtil.getAttributeValue(ATTRIBUTE_TASK_SERVICE_RESULTVARIABLE, xtr));
if (StringUtils.isEmpty(serviceTask.getResultVariableName())) {
  serviceTask.setResultVariableName(BpmnXMLUtil.getAttributeValue("resultVariable", xtr));
serviceTask.setUseLocalScopeForResultVariable(Boolean.valueOf(BpmnXMLUtil.getAttributeValue(ATTRIBUTE_TASK_SERVICE_USE_LOCAL_SCOPE_FOR_RESULT_VARIABLE, xtr)));
serviceTask.setType(serviceTaskType);
serviceTask.setExtensionId(BpmnXMLUtil.getAttributeValue(ATTRIBUTE_TASK_SERVICE_EXTENSIONID, xtr));
if (StringUtils.isNotEmpty(BpmnXMLUtil.getAttributeValue(ATTRIBUTE_TASK_SERVICE_SKIP_EXPRESSION, xtr))) {
  serviceTask.setSkipExpression(BpmnXMLUtil.getAttributeValue(ATTRIBUTE_TASK_SERVICE_SKIP_EXPRESSION, xtr));
origin: org.flowable/flowable-json-converter

protected void addField(String name, JsonNode elementNode, ServiceTask task) {
  FieldExtension field = new FieldExtension();
  field.setFieldName(name.substring(8));
  String value = getPropertyValueAsString(name, elementNode);
  if (StringUtils.isNotEmpty(value)) {
    if ((value.contains("${") || value.contains("#{")) && value.contains("}")) {
      field.setExpression(value);
    } else {
      field.setStringValue(value);
    }
    task.getFieldExtensions().add(field);
  }
}
origin: org.flowable/flowable-bpmn-converter

@Override
protected void writeAdditionalAttributes(BaseElement element, BpmnModel model, XMLStreamWriter xtw) throws Exception {
  ServiceTask serviceTask = (ServiceTask) element;
  if (ImplementationType.IMPLEMENTATION_TYPE_CLASS.equals(serviceTask.getImplementationType())) {
    writeQualifiedAttribute(ATTRIBUTE_TASK_SERVICE_CLASS, serviceTask.getImplementation(), xtw);
  } else if (ImplementationType.IMPLEMENTATION_TYPE_EXPRESSION.equals(serviceTask.getImplementationType())) {
    writeQualifiedAttribute(ATTRIBUTE_TASK_SERVICE_EXPRESSION, serviceTask.getImplementation(), xtw);
  } else if (ImplementationType.IMPLEMENTATION_TYPE_DELEGATEEXPRESSION.equals(serviceTask.getImplementationType())) {
    writeQualifiedAttribute(ATTRIBUTE_TASK_SERVICE_DELEGATEEXPRESSION, serviceTask.getImplementation(), xtw);
  }
  if (StringUtils.isNotEmpty(serviceTask.getResultVariableName())) {
    writeQualifiedAttribute(ATTRIBUTE_TASK_SERVICE_RESULTVARIABLE, serviceTask.getResultVariableName(), xtw);
  }
  if (StringUtils.isNotEmpty(serviceTask.getType())) {
    writeQualifiedAttribute(ATTRIBUTE_TYPE, serviceTask.getType(), xtw);
  }
  if (StringUtils.isNotEmpty(serviceTask.getExtensionId())) {
    writeQualifiedAttribute(ATTRIBUTE_TASK_SERVICE_EXTENSIONID, serviceTask.getExtensionId(), xtw);
  }
  if (StringUtils.isNotEmpty(serviceTask.getSkipExpression())) {
    writeQualifiedAttribute(ATTRIBUTE_TASK_SERVICE_SKIP_EXPRESSION, serviceTask.getSkipExpression(), xtw);
  }
  if (serviceTask.isTriggerable()) {
    writeQualifiedAttribute(ATTRIBUTE_ACTIVITY_TRIGGERABLE, "true", xtw);
  }
  if (serviceTask.isUseLocalScopeForResultVariable()) {
    writeQualifiedAttribute(ATTRIBUTE_TASK_SERVICE_USE_LOCAL_SCOPE_FOR_RESULT_VARIABLE, "true", xtw);
  }
}
origin: org.flowable/flowable5-engine

@Override
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(), serviceTask.getMapExceptions());
}
origin: org.flowable/flowable-engine

protected Expression getSkipExpressionFromServiceTask(ServiceTask serviceTask) {
  Expression result = null;
  if (StringUtils.isNotEmpty(serviceTask.getSkipExpression())) {
    result = expressionManager.createExpression(serviceTask.getSkipExpression());
  }
  return result;
}
origin: org.flowable/flowable-process-validation

protected void verifyType(Process process, ServiceTask serviceTask, List<ValidationError> errors) {
  if (StringUtils.isNotEmpty(serviceTask.getType())) {
    if (!serviceTask.getType().equalsIgnoreCase("mail") && !serviceTask.getType().equalsIgnoreCase("mule") && !serviceTask.getType().equalsIgnoreCase("camel")
        && !serviceTask.getType().equalsIgnoreCase("shell") && !serviceTask.getType().equalsIgnoreCase("dmn") 
        && !serviceTask.getType().equalsIgnoreCase("http") && !serviceTask.getType().equalsIgnoreCase("case")) {
      addError(errors, Problems.SERVICE_TASK_INVALID_TYPE, process, serviceTask, "Invalid or unsupported service task type");
    }
    if (serviceTask.getType().equalsIgnoreCase("mail")) {
      validateFieldDeclarationsForEmail(process, serviceTask, serviceTask.getFieldExtensions(), errors);
    } else if (serviceTask.getType().equalsIgnoreCase("shell")) {
      validateFieldDeclarationsForShell(process, serviceTask, serviceTask.getFieldExtensions(), errors);
    } else if (serviceTask.getType().equalsIgnoreCase("dmn")) {
      validateFieldDeclarationsForDmn(process, serviceTask, serviceTask.getFieldExtensions(), errors);
    } else if (serviceTask.getType().equalsIgnoreCase("http")) {
      validateFieldDeclarationsForHttp(process, serviceTask, serviceTask.getFieldExtensions(), errors);
    } else if (serviceTask.getType().equalsIgnoreCase("case")) {
      validateFieldDeclarationsForCase(process, (CaseServiceTask) serviceTask, errors);
    }
  }
}
origin: org.flowable/flowable-engine

if (StringUtils.isNotEmpty(serviceTask.getType())) {
  if (serviceTask.getType().equalsIgnoreCase("mail")) {
    serviceTask.setBehavior(bpmnParse.getActivityBehaviorFactory().createMailActivityBehavior(serviceTask));
  } else if (serviceTask.getType().equalsIgnoreCase("mule")) {
    serviceTask.setBehavior(bpmnParse.getActivityBehaviorFactory().createMuleActivityBehavior(serviceTask));
  } else if (serviceTask.getType().equalsIgnoreCase("camel")) {
    serviceTask.setBehavior(bpmnParse.getActivityBehaviorFactory().createCamelActivityBehavior(serviceTask));
  } else if (serviceTask.getType().equalsIgnoreCase("shell")) {
    serviceTask.setBehavior(bpmnParse.getActivityBehaviorFactory().createShellActivityBehavior(serviceTask));
  } else if (serviceTask.getType().equalsIgnoreCase("dmn")) {
    serviceTask.setBehavior(bpmnParse.getActivityBehaviorFactory().createDmnActivityBehavior(serviceTask));
  } else if (serviceTask.getType().equalsIgnoreCase("http")) {
    serviceTask.setBehavior(bpmnParse.getActivityBehaviorFactory().createHttpActivityBehavior(serviceTask));
    LOGGER.warn("Invalid type: '{}' for service task {}", serviceTask.getType(), serviceTask.getId());
} else if (ImplementationType.IMPLEMENTATION_TYPE_CLASS.equalsIgnoreCase(serviceTask.getImplementationType())) {
  serviceTask.setBehavior(bpmnParse.getActivityBehaviorFactory().createClassDelegateServiceTask(serviceTask));
} else if (ImplementationType.IMPLEMENTATION_TYPE_DELEGATEEXPRESSION.equalsIgnoreCase(serviceTask.getImplementationType())) {
  serviceTask.setBehavior(bpmnParse.getActivityBehaviorFactory().createServiceTaskDelegateExpressionActivityBehavior(serviceTask));
origin: org.flowable/flowable5-engine

activity.setAsync(serviceTask.isAsynchronous());
activity.setFailedJobRetryTimeCycleValue(serviceTask.getFailedJobRetryTimeCycleValue());
activity.setExclusive(!serviceTask.isNotExclusive());
if (StringUtils.isNotEmpty(serviceTask.getType())) {
  if (serviceTask.getType().equalsIgnoreCase("mail")) {
    activity.setActivityBehavior(bpmnParse.getActivityBehaviorFactory().createMailActivityBehavior(serviceTask));
  } else if (serviceTask.getType().equalsIgnoreCase("mule")) {
    activity.setActivityBehavior(bpmnParse.getActivityBehaviorFactory().createMuleActivityBehavior(serviceTask, bpmnParse.getBpmnModel()));
  } else if (serviceTask.getType().equalsIgnoreCase("camel")) {
    activity.setActivityBehavior(bpmnParse.getActivityBehaviorFactory().createCamelActivityBehavior(serviceTask, bpmnParse.getBpmnModel()));
  } else if (serviceTask.getType().equalsIgnoreCase("shell")) {
    activity.setActivityBehavior(bpmnParse.getActivityBehaviorFactory().createShellActivityBehavior(serviceTask));
    LOGGER.warn("Invalid service task type: '{}'  for service task {}", serviceTask.getType(), serviceTask.getId());
} else if (ImplementationType.IMPLEMENTATION_TYPE_CLASS.equalsIgnoreCase(serviceTask.getImplementationType())) {
  activity.setActivityBehavior(bpmnParse.getActivityBehaviorFactory().createClassDelegateServiceTask(serviceTask));
} else if (ImplementationType.IMPLEMENTATION_TYPE_DELEGATEEXPRESSION.equalsIgnoreCase(serviceTask.getImplementationType())) {
  activity.setActivityBehavior(bpmnParse.getActivityBehaviorFactory().createServiceTaskDelegateExpressionActivityBehavior(serviceTask));
} else if (ImplementationType.IMPLEMENTATION_TYPE_EXPRESSION.equalsIgnoreCase(serviceTask.getImplementationType())) {
  activity.setActivityBehavior(bpmnParse.getActivityBehaviorFactory().createServiceTaskExpressionActivityBehavior(serviceTask));
origin: org.flowable/flowable-engine

@Override
public ActivityBehavior createHttpActivityBehavior(ServiceTask serviceTask) {
  try {
    Class<?> theClass = null;
    FieldExtension behaviorExtension = null;
    for (FieldExtension fieldExtension : serviceTask.getFieldExtensions()) {
      if ("httpActivityBehaviorClass".equals(fieldExtension.getFieldName()) && StringUtils.isNotEmpty(fieldExtension.getStringValue())) {
        theClass = Class.forName(fieldExtension.getStringValue());
        behaviorExtension = fieldExtension;
        break;
      }
    }
    if (behaviorExtension != null) {
      serviceTask.getFieldExtensions().remove(behaviorExtension);
    }
    if (theClass == null) {
      // Default Http behavior class
      theClass = Class.forName("org.flowable.http.bpmn.impl.HttpActivityBehaviorImpl");
    }
    List<FieldDeclaration> fieldDeclarations = createFieldDeclarations(serviceTask.getFieldExtensions());
    addExceptionMapAsFieldDeclaration(fieldDeclarations, serviceTask.getMapExceptions());
    return (ActivityBehavior) ClassDelegate.defaultInstantiateDelegate(theClass, fieldDeclarations, serviceTask);
  } catch (ClassNotFoundException e) {
    throw new FlowableException("Could not find org.flowable.http.HttpActivityBehavior: ", e);
  }
}
origin: org.flowable/flowable-json-converter

@Override
protected FlowElement convertJsonToElement(JsonNode elementNode, JsonNode modelNode, Map<String, JsonNode> shapeMap) {
  ServiceTask task = new ServiceTask();
  if (StringUtils.isNotEmpty(getPropertyValueAsString(PROPERTY_SERVICETASK_CLASS, elementNode))) {
    task.setImplementationType(ImplementationType.IMPLEMENTATION_TYPE_CLASS);
    task.setImplementation(getPropertyValueAsString(PROPERTY_SERVICETASK_CLASS, elementNode));
  } else if (StringUtils.isNotEmpty(getPropertyValueAsString(PROPERTY_SERVICETASK_EXPRESSION, elementNode))) {
    task.setImplementationType(ImplementationType.IMPLEMENTATION_TYPE_EXPRESSION);
    task.setImplementation(getPropertyValueAsString(PROPERTY_SERVICETASK_EXPRESSION, elementNode));
  } else if (StringUtils.isNotEmpty(getPropertyValueAsString(PROPERTY_SERVICETASK_DELEGATE_EXPRESSION, elementNode))) {
    task.setImplementationType(ImplementationType.IMPLEMENTATION_TYPE_DELEGATEEXPRESSION);
    task.setImplementation(getPropertyValueAsString(PROPERTY_SERVICETASK_DELEGATE_EXPRESSION, elementNode));
    task.setTriggerable(true);
  if (StringUtils.isNotEmpty(getPropertyValueAsString(PROPERTY_SERVICETASK_RESULT_VARIABLE, elementNode))) {
    task.setResultVariableName(getPropertyValueAsString(PROPERTY_SERVICETASK_RESULT_VARIABLE, elementNode));
    task.setUseLocalScopeForResultVariable(true);
  task.setSkipExpression(getPropertyValueAsString(PROPERTY_SKIP_EXPRESSION, elementNode));
            field.setExpression(getValueAsString(PROPERTY_SERVICETASK_FIELD_EXPRESSION, itemNode));
          task.getFieldExtensions().add(field);
origin: org.flowable/flowable-process-validation

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");
    }
  }
}
origin: org.flowable/flowable-json-converter

if (baseElement instanceof ServiceTask) {
  ServiceTask serviceTask = (ServiceTask) baseElement;
  if ("mail".equalsIgnoreCase(serviceTask.getType())) {
    stencilId = STENCIL_TASK_MAIL;
  } else if ("camel".equalsIgnoreCase(serviceTask.getType())) {
    stencilId = STENCIL_TASK_CAMEL;
  } else if ("mule".equalsIgnoreCase(serviceTask.getType())) {
    stencilId = STENCIL_TASK_MULE;
  } else if ("http".equalsIgnoreCase(serviceTask.getType())) {
    stencilId = STENCIL_TASK_HTTP;
  } else if ("dmn".equalsIgnoreCase(serviceTask.getType())) {
    stencilId = STENCIL_TASK_DECISION;
  } else if ("shell".equalsIgnoreCase(serviceTask.getType())) {
    stencilId = STENCIL_TASK_SHELL;
  } else {
  if (StringUtils.isNotEmpty(flowElement.getName())) {
    propertiesNode.put(PROPERTY_NAME, flowElement.getName());
  if (StringUtils.isNotEmpty(flowElement.getDocumentation())) {
    propertiesNode.put(PROPERTY_DOCUMENTATION, flowElement.getDocumentation());
    if (StringUtils.isNotEmpty(loopDef.getLoopCardinality()) || StringUtils.isNotEmpty(loopDef.getInputDataItem()) || StringUtils.isNotEmpty(loopDef.getCompletionCondition())) {
origin: org.flowable/flowable-bpmn-model

  public void setValues(ServiceTask otherElement) {
    super.setValues(otherElement);
    setImplementation(otherElement.getImplementation());
    setImplementationType(otherElement.getImplementationType());
    setResultVariableName(otherElement.getResultVariableName());
    setType(otherElement.getType());
    setOperationRef(otherElement.getOperationRef());
    setExtensionId(otherElement.getExtensionId());
    setSkipExpression(otherElement.getSkipExpression());
    setUseLocalScopeForResultVariable(otherElement.isUseLocalScopeForResultVariable());
    setTriggerable(otherElement.isTriggerable());

    fieldExtensions = new ArrayList<>();
    if (otherElement.getFieldExtensions() != null && !otherElement.getFieldExtensions().isEmpty()) {
      for (FieldExtension extension : otherElement.getFieldExtensions()) {
        fieldExtensions.add(extension.clone());
      }
    }

    customProperties = new ArrayList<>();
    if (otherElement.getCustomProperties() != null && !otherElement.getCustomProperties().isEmpty()) {
      for (CustomProperty property : otherElement.getCustomProperties()) {
        customProperties.add(property.clone());
      }
    }
  }
}
origin: org.flowable/flowable-ui-admin-rest

  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());
    createPropertyNode("Use local scope for result variable", serviceTask.isUseLocalScopeForResultVariable());
  }
}
org.flowable.bpmn.modelServiceTask

Most used methods

  • getType
  • getImplementationType
  • getResultVariableName
  • getFieldExtensions
  • getImplementation
  • getSkipExpression
  • isUseLocalScopeForResultVariable
  • getOperationRef
  • <init>
  • isTriggerable
  • setImplementation
  • setImplementationType
  • setImplementation,
  • setImplementationType,
  • setResultVariableName,
  • setSkipExpression,
  • setType,
  • getCustomProperties,
  • getExtensionId,
  • setExtensionId,
  • setOperationRef,
  • setTriggerable

Popular in Java

  • Creating JSON documents from java classes using gson
  • addToBackStack (FragmentTransaction)
  • setRequestProperty (URLConnection)
  • startActivity (Activity)
  • EOFException (java.io)
    Thrown when a program encounters the end of a file or stream during an input operation.
  • DecimalFormat (java.text)
    A concrete subclass of NumberFormat that formats decimal numbers. It has a variety of features desig
  • HashSet (java.util)
    HashSet is an implementation of a Set. All optional operations (adding and removing) are supported.
  • Scanner (java.util)
    A parser that parses a text string of primitive types and strings with the help of regular expressio
  • HttpServlet (javax.servlet.http)
    Provides an abstract class to be subclassed to create an HTTP servlet suitable for a Web site. A sub
  • HttpServletRequest (javax.servlet.http)
    Extends the javax.servlet.ServletRequest interface to provide request information for HTTP servlets.
  • PhpStorm for WordPress
Tabnine Logo

  • Products

    Search for Java codeSearch for JavaScript code

  • IDE Plugins

    IntelliJ IDEAWebStormAndroid StudioEclipseVisual Studio CodePyCharmSublime TextPhpStormVimAtomGoLandRubyMineEmacsJupyterRiderDataGripAppCode

  • Company

    About UsContact UsCareers

  • Resources

    FAQBlogTabnine AcademyStudentsTerms of usePrivacy policyJava Code IndexJavascript Code Index
Get Tabnine for your IDE now