Executing automated steps

In this section, you’ll learn how to create your first BPMN 2.0 process with the Camunda Modeler and how to execute automated steps. Start by opening the Camunda Modeler.

Create a new BPMN diagram

Create a new BPMN diagram by clicking File > New File > BPMN Diagram (Camunda Platform).

Start with a simple process

Double-click the start event. A text box opens. Name the start event Payment Retrieval Requested.

When editing labels, you can add line breaks using Shift + Enter.

Click the start event. From its context menu, select the activity shape (rounded rectangle). It is placed automatically on the canvas; drag it to your preferred position. Name it Charge Credit Card. Change the activity type to Service Task by clicking the activity shape and using the wrench button.

Add an end event named Payment Received.

Configure the service task

There are different ways to execute service tasks with ASEE Flow. In this guide, we’ll use the external task pattern. Open the properties panel in the Camunda Modeler and click the service task you just created. Change the Implementation to External and use charge-card as the Topic.

Configure properties for execution

Because we’re modeling an executable process, we should give it an ID and set the isExecutable property to true. On the right-hand side of the canvas you find the properties panel. When you click empty space on the canvas, the panel displays the properties of the process itself. First, configure an ID for the process. Type payment-retrieval in the Id field. The ID is used by the process engine as an identifier for the executable process; it’s best practice to set it to a human-readable name. Second, type Payment Retrieval in the Name field. Finally, make sure the Executable checkbox is checked. If you don’t check this box, the process definition is ignored by the process engine.

Save the BPMN diagram

When you’re done, save your changes by clicking File > Save File As…. In the dialog, navigate to a folder of your choice and save the diagram as something like payment.bpmn.

Catch up: get the sources of Step-1

git clone https://github.com/camunda/camunda-get-started-quickstart.git
git checkout -f Step-1

Or download as a .zip.

Implement an external task worker

After modeling the process, we want to execute some business logic. ASEE Flow lets you implement your business logic in different languages — choose whichever suits your project best. In this quick start, we’ll show you how to use ready-to-go task clients in:

Java
JavaScript (Node.js)

If you prefer a different programming language, you can also use the REST API to access API operations over HTTP.

a) Using Java

In this section, you’ll implement an external task worker in Java.

Prerequisites

Make sure you have the following tools installed:

JDK 11
An IDE for Java projects (for example Eclipse)

Create a new Maven project

Start by creating a new Maven project in your IDE. In Eclipse, go to File > New > Other… to open the New Project Wizard, select Maven > Maven Project, and click Next. On the first page, select Create a simple project (you can skip archetype selection) and click Next. On the second page, configure the Maven coordinates; since we’re setting up a JAR project, select Packaging: jar. Click Finish.

Add the external task client dependency

Set up the Maven dependency to the external task client. Your pom.xml should look like this:

<project xmlns="http://maven.apache.org/POM/4.0.0" xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
	xsi:schemaLocation="http://maven.apache.org/POM/4.0.0 http://maven.apache.org/xsd/maven-4.0.0.xsd">
	<modelVersion>4.0.0</modelVersion>

	<groupId>org.camunda.bpm.getstarted</groupId>
	<artifactId>charge-card-worker</artifactId>
	<version>0.0.1-SNAPSHOT</version>

	<properties>
		<camunda.external-task-client.version>7.24.0</camunda.external-task-client.version>
		<maven.compiler.source>11</maven.compiler.source>
		<maven.compiler.target>11</maven.compiler.target>
	</properties>

	<dependencies>
		<dependency>
			<groupId>org.camunda.bpm</groupId>
			<artifactId>camunda-external-task-client</artifactId>
			<version>${camunda.external-task-client.version}</version>
		</dependency>
		<dependency>
			<groupId>org.slf4j</groupId>
			<artifactId>slf4j-simple</artifactId>
			<version>1.7.36</version>
		</dependency>
		<dependency>
			<groupId>jakarta.xml.bind</groupId>
			<artifactId>jakarta.xml.bind-api</artifactId>
			<version>4.0.2</version>
		</dependency>
	</dependencies>
</project>

Add the Java class

Next, create an ExternalTaskClient that subscribes to the charge-card topic. When the process engine encounters a service task configured to be externally handled, it creates an external task instance that our handler reacts to. We use long polling in the client to make communication more efficient. Create a package, for example org.camunda.bpm.getstarted.chargecard, and add a Java class such as ChargeCardWorker:

package org.camunda.bpm.getstarted.chargecard;

import java.util.logging.Logger;
import java.awt.Desktop;
import java.net.URI;

import org.camunda.bpm.client.ExternalTaskClient;

public class ChargeCardWorker {
  private final static Logger LOGGER = Logger.getLogger(ChargeCardWorker.class.getName());

  public static void main(String[] args) {
    ExternalTaskClient client = ExternalTaskClient.create()
        .baseUrl("http://localhost:8080/engine-rest")
        .asyncResponseTimeout(10000) // long polling timeout
        .build();

    // subscribe to an external task topic as specified in the process
    client.subscribe("charge-card")
        .lockDuration(1000) // the default lock duration is 20 seconds, but you can override this
        .handler((externalTask, externalTaskService) -> {
          // Put your business logic here

          // Get a process variable
          String item = externalTask.getVariable("item");
          Integer amount = externalTask.getVariable("amount");

          LOGGER.info("Charging credit card with an amount of '" + amount + "'€ for the item '" + item + "'...");

          // Complete the task
          externalTaskService.complete(externalTask);
        })
        .open();
  }
}

Run the worker

Run the Java application by right-clicking the ChargeCardWorker class and choosing Run as Java. Keep the worker running throughout this quick start guide.

Next step

Once your worker is running, continue to deploy your process and start some instances.

Catch up: get the sources of Step-2a

git clone https://github.com/camunda/camunda-get-started-quickstart.git
git checkout -f Step-2a

Or download as a .zip.

b) Using JavaScript (Node.js)

In this section, you’ll implement an external task worker in Node.js.

Prerequisites

Make sure you have the following tools installed:

Node.js >= v16 (download here)
An editor for JavaScript files

Create a new Node.js project

mkdir charge-card-worker
cd ./charge-card-worker
npm init -y

Enable ES modules

Add the following "type" field to your package.json:

{
  "main": "index.js",
  "type": "module",
  "scripts": {
    "test": "echo \"Error: no test specified\" && exit 1"
  }
}

Add the external task client JS library

npm install camunda-external-task-client-js
npm install -D open

Implement the Node.js script

Create an ExternalTaskClient that subscribes to the charge-card topic. Create a JavaScript file such as worker.js:

import { Client, logger } from 'camunda-external-task-client-js';

// configuration for the Client:
//  - 'baseUrl': url to the Process Engine
//  - 'logger': utility to automatically log important events
//  - 'asyncResponseTimeout': long polling timeout (then a new request will be issued)
const config = { baseUrl: 'http://localhost:8080/engine-rest', use: logger, asyncResponseTimeout: 10000 };

// create a Client instance with custom configuration
const client = new Client(config);

// subscribe to the topic: 'charge-card'
client.subscribe('charge-card', async function({ task, taskService }) {
  // Put your business logic here

  // Get a process variable
  const amount = task.variables.get('amount');
  const item = task.variables.get('item');

  console.log(`Charging credit card with an amount of ${amount}€ for the item '${item}'...`);

  // Complete the task
  await taskService.complete(task);
});

Run the Node.js script

node ./worker.js

Keep the worker running throughout this quick start guide.

Next step

Once your worker is running, continue to deploy your process and start some instances.

Catch up: get the sources of Step-2b

git clone https://github.com/camunda/camunda-get-started-quickstart.git
git checkout -f Step-2b

Or download as a .zip.

​Create a new BPMN diagram

​Start with a simple process

​Configure the service task

​Configure properties for execution

​Save the BPMN diagram

​Implement an external task worker

​a) Using Java

​Prerequisites

​Create a new Maven project

​Add the external task client dependency

​Add the Java class

​Run the worker

​Next step

​b) Using JavaScript (Node.js)

​Prerequisites

​Create a new Node.js project

​Enable ES modules

​Add the external task client JS library

​Implement the Node.js script

​Run the Node.js script

​Next step

Create a new BPMN diagram

Start with a simple process

Configure the service task

Configure properties for execution

Save the BPMN diagram

Implement an external task worker

a) Using Java

Prerequisites

Create a new Maven project

Add the external task client dependency

Add the Java class

Run the worker

Next step

b) Using JavaScript (Node.js)

Prerequisites

Create a new Node.js project

Enable ES modules

Add the external task client JS library

Implement the Node.js script

Run the Node.js script

Next step