SimpleBPMN is a plugin for DokuWiki - in order to work with it you have to have it installed. You can download it from downloads page.

SimpleBPMN Notation

SimpleBPMN is a JSON based notation focusing on the Process Diagrams. Since BPMN has more types of sub-models, SimpleBPMN covers only some elements that is offered by BPMN itself.

In this tutorial, you will get to know how to prepare BP models using SimpleBPMN plugin. Let's start!

If you need a quick introduction to Business Process, see this page.

The SimpleBPMN notation is case-sensitive. The whole code on the Wiki page should be between <bpmn> </bpmn> tags. Inside tags Process is defined between braces {}. The whole Process can have (optionally) name (first specified thing after opening brace); afterwards there are definitions of all the objects in process.

General rules:

• after identifier of object or after particular attribute of object there is colon (:)
• after object id with colon there are (usually) braces ({}) inside which are defined attributes of object
• after each object/attribute at the same level (eg. attributes of the same object) there is comma (,)
• names of objects/attributes are written in quotes (“”)
• in case of flow instead of braces there are brackets ([])
• comments after two slashes
• each object has to have identifier and can have optional parameters

Rules in practice:

{  //opening braces

	name: "Process 1", //optional name
	events:{
	        ...
	},
	activities:{
		...
	},
	gates:{
		...
	},
	flow:{
		...
	}
} //closing braces

Additional tag options

To <bpmn> tag there can be added additional parameters:

• subprocess=collapse or subprocess=expand - it's used for sub-processes to specify how it should be displayed
• diagram=before or diagram=after - used to specify position of diagram to the code block

Defining events - there are tree sections corresponding to tree event types:

{
	events:{
		start:{	
		},
		end:{
		},
		intermediate:{
		}
	}
...
}

Event schema

Event can have specified parameters:

• name - possible value: string in quotes “”; name of the event
• type - possible value: see Table 1; specifies what event is connected to the event (eg. message); default type is none (no particular type is specified)
• throwing - default: false, possible value: true; eg. error throwing vs error catching; default state for intermediate events is catching unless specified throwing:true - it can be done for: Message, Escalation, Compensation, Link, Signal and Multiple Events.
• nonInterrupting - default: false, possible value: true; specifies whether or not the event interrupts the whole process (and should be dealt with) or not, eg. Interrupting error makes some new branch of the flow on order to do something with the error vs nonInterrupting error only indicates sth and doesn't change the flow; default false, affected events: Message, Timer, Escalation, Conditional, Signal, Multiple and Parallel Multiple.

If there are parameters specified for the event there have to be event id, colon (:) and parameters in braces ({}) - like event_id1. However when there is only name specified for the event shorter version can be used - see event_id2.

{
...
	events:{
		...
		intermediate:{
			event_id1: {
				name: "Intermediate event 1",
				type: message,
				nonInterrupting: true,
				throwing: true
			},
                        event_id2: "Intermediate event 2",
                        ...
		}
	},
...
}

Table 1 - Events: Values for type parameter

Types of Events

As mentioned before, activities can have one of four types (activityType): Task, Transaction, Event Sub-Process and Call Activity. Assuming only basic attributes are defined (see schema Activity 1 below) default type of Activity is Task, other kind of activities can be set by using the type attribute (see the table). Additionally, an Activity can be recognized as Sub-Process when inside the activity definition (after the basic attributes) there are tags events, activities, gateways and flow (see schema Activity 2).

Parameters of activity:

• name - possible value: string in quotes ””; name of the activity;
• type - possible value: see Table 2; type is defined according to participant of task (see Task section ); can be defined only for Tasks, they are ignored while defined in Sub-Process;
• activityType - possible value: see Table 3; decribed above;
• markers - possible value: see Table 4; list of values (seperated with commas);
• boundary - possible value: identifier of event; activities can be interrupted by some event, eg. for the task of implementing assignment till the end of semester the event that will interrupt this task is actual end of the semester. Therefore if boundary is defined the task will have additional event “sticked” to it, which means that it can be intruded by this event. Events themselves must be defined in the parent event:intermediate section.
• instantiate - default: false; possible values: true;

Boundary Activity Example - Example which has a boundary activity - when the time is up for the masters it gets interrupted.

Activity defined as default type - Task.

{
...
	activities:{
		activity_id1: {
			name: "Activity 1",
			type: user,
			activityType: transaction,
			markers: [loop],
			boundary: [event_in_parent_id],
			instantiate: true
		}
	},
...
}

Defining Sub-Process

Activity defined as Sub-Process (thanks to defining events, activities, gateways and flow).

{
...
	activities:{
		activity_id2: {
			name: "Activity 2 - Sub-Process",
			type: manual,
			markers: [parallel],
			boundary: [event_id],
			events:{
			},
			activities:{
			},
			gateways:{
			},
			flow:{
			}
		}
	},
...
}

{
...
	activities: {
		[[bpmn>parent_link:subprocess_link]]

	},
...
}</bpmn>

Example of Sub-Process defined as in schema above

Example of Sub-Process defined by marker subprocess

Activity without additional parameters can be shortened only to identifier and name:

{
...
	activities: ...
		activity_id3: "Activity 3 - Shortened",
...
}

Table 2 - Acitivities: Values for type parameter - Only for Tasks!

Table 3 - Acitivities: Values for activityType parameter

Table 4 - Acitivities: Values for markers parameter

Possible parameters for gateway:

• name - possible value: string in quotes ””; name of the activity;
• type - default: exclusive; possible values: see Table 5;

{
	gateways:{
		gateway_id: {
			name: "Gateway 1",
			type: parallel
		}
	},
}

Table 5 - Gateways: Values for type parameter

Order of Flow Elements (which are the elements available in SimpleBPMN) is provided by Sequence Flow. Sequence Flow has exactly one source and one target. It can connect all the elements: events, tasks, sub-processes and gateways. When defining flow always connect two elements and use brackets (see schema below).

There are three types of flow connections between elements:

• normal connection;
• conditional connection - it will make the “Condition” appear above the arrow;
• default connection.

To define it see schema.

{
...
	flow:{
		flow_normal: [
			object_from_id,
			object_to_id
		],
		flow_conditional: [
			object_from_id,
			object_to_id,
			"Condition"
		],
		flow_default: [
			object_from_id,
			object_to_id,
			true
		]
	}
...
}

Complicated example from book BPMN 2.0 by Example

Description