Added learning material from tutorial. Contents not changed yet and still reference tutorial

Author: jaboehri

docs/src/developer-documentation/concepts/bpmn/bpmn-model.md

@@ -0,0 +1,4 @@
+## BPMN Model
+
+The DSF expects BPMN 2.0 for its process execution. This write-up covers the BPMN elements 
+most commonly used in DSF process plugins.

docs/src/developer-documentation/concepts/bpmn/conditions.md

@@ -0,0 +1,12 @@
+### Conditions
+
+[Conditions](https://docs.camunda.org/manual/7.20/user-guide/process-engine/expression-language/#conditions)
+allow you to change the behaviour of BPMN processes during execution. There are two ways you
+are able to add decision logic to Conditions. The [Camunda Modeler](https://camunda.com/download/modeler/) refers to them as `Type`. You can find them in the ``Condition`` tab of
+certain BPMN elements. The first one is `Script`. This allows you to add arbitrary complexity
+to your decisions logic and is rarely used for process plugins. The more common Type is `Expression`.
+Expressions have the following syntax: `${expression}`. For this tutorial, _expression_ will
+use a boolean condition like `var == true`. You can learn more advanced features of Expressions [here](https://docs.camunda.org/manual/7.20/user-guide/process-engine/expression-language/).
+For this to work during BPMN process execution, the variable you want to use for the boolean
+condition must be available in the BPMN process variables before [Sequence Flow](../../concepts/bpmn/sequence-flow.md)
+reaches the evaluation of the expression.

docs/src/developer-documentation/concepts/bpmn/gateways.md

@@ -0,0 +1,20 @@
+### Gateways
+
+[Gateways](https://docs.camunda.org/manual/7.20/reference/bpmn20/gateways/) allow you to control the [Sequence Flow](../../concepts/bpmn/sequence-flow.md). Different
+types of gateways will be useful for different scenarios.
+
+#### Exclusive Gateways
+
+[Exclusive Gateways](https://docs.camunda.org/manual/7.20/reference/bpmn20/gateways/exclusive-gateway/)
+allow you to decide which [Sequence Flow](../../concepts/bpmn/sequence-flow.md) should be followed based on [conditions](https://docs.camunda.org/manual/7.20/user-guide/process-engine/expression-language/#conditions).
+[Conditions](https://docs.camunda.org/manual/7.20/user-guide/process-engine/expression-language/#conditions) are not part of the
+[Exclusive Gateways](https://docs.camunda.org/manual/7.20/reference/bpmn20/gateways/exclusive-gateway/) themselves. You set them
+through the sequence Flow Exiting the [Exclusive Gateway](https://docs.camunda.org/manual/7.20/reference/bpmn20/gateways/exclusive-gateway/).  
+In the [Camunda Modeler](https://camunda.com/download/modeler/), you can add conditions to [Sequence Flow](../../concepts/bpmn/sequence-flow.md) by selecting
+a [Sequence Flow](../../concepts/bpmn/sequence-flow.md) and opening the `Condition` tab. You can find more information on how to
+use Conditions [here](../../concepts/bpmn/conditions.md).
+
+#### Event-based Gateway
+
+The [Event-based Gateway](https://docs.camunda.org/manual/7.20/reference/bpmn20/gateways/event-based-gateway/)
+allows you model scenarios where you are expecting one out of a number of events to occur. 

docs/src/developer-documentation/concepts/bpmn/messaging.md

@@ -0,0 +1,33 @@
+### Messaging
+
+In order to enable communication with other lanes, pools or even entirely separate processes you need to be able
+to exchange information. In BPMN, you can use [Message Events](https://docs.camunda.org/manual/7.20/reference/bpmn20/events/message-events/)
+to model this information exchange. Modeling communication with [Message Events](https://docs.camunda.org/manual/7.20/reference/bpmn20/events/message-events/) in the same diagram
+uses Message Flow. Message Flow is typically represented by a dashed line arrow between BPMN elements with a black (send) or white (receive) envelope icon.
+The following BPMN collaboration diagram shows message exchange between two processes.
+
+<picture>
+  <source media="(prefers-color-scheme: dark)" srcset="figures/exercise3_message_flow_inverted.svg">
+  <source media="(prefers-color-scheme: light)" srcset="figures/exercise3_message_flow.svg">
+  <img alt="BPMN collaboration diagram with two processes using message flow to exchange information between two organizations" src="figures/exercise3_message_flow.svg">
+</picture>
+
+#### Message Start Event
+
+[Message Start Events](https://docs.camunda.org/manual/7.20/reference/bpmn20/events/message-events/#message-start-event)
+allow a BPMN process to be started by an incoming message. In the DSF, all BPMN processes are started via messages. Therefore,
+you will have to include a [Message Start Event](https://docs.camunda.org/manual/7.20/reference/bpmn20/events/message-events/#message-start-event) at
+the beginning of all of your BPMN models.
+
+#### Message Intermediate Throwing Event
+[Message Intermediate Throwing Events](https://docs.camunda.org/manual/7.20/reference/bpmn20/events/message-events/#message-intermediate-throwing-event)
+are used to send messages during process execution.
+
+#### Message Intermediate Catching Event
+[Message Intermediate Catching Events](https://docs.camunda.org/manual/7.20/reference/bpmn20/events/message-events/#message-intermediate-catching-event) serve as
+the counterpart to [Message Intermediate Throwing Events](messaging.md#message-intermediate-throwing-event).
+Use them whenever you expect to receive a message from another process or organization during execution.
+
+#### Message End Event
+The [Message End Event](https://docs.camunda.org/manual/7.20/reference/bpmn20/events/message-events/#message-end-event) will
+stop the execution of a BPMN process and finish by sending a message.

docs/src/developer-documentation/concepts/bpmn/sequence-flow.md

@@ -0,0 +1,3 @@
+### Sequence Flow
+BPMN 2.0 calls the continuous arrows connecting the BPMN elements in BPMN models, Sequence Flow.
+Sequence Flow exits one BPMN element and points at the next BPMN element to be processed.

docs/src/developer-documentation/concepts/bpmn/service-tasks.md

@@ -0,0 +1,7 @@
+### Service Tasks
+
+You will primarily use [Service Tasks](https://docs.camunda.org/manual/7.20/reference/bpmn20/tasks/service-task/)
+when creating BPMN models. They are different from regular BPMN Tasks in that they offer the ability to
+link an implementation to the [Service Task](https://docs.camunda.org/manual/7.20/reference/bpmn20/tasks/service-task/)
+which can be called and executed by a BPMN engine. The BPE (Business Process Engine) server of the DSF leverages
+this engine to execute your BPMN processes.

docs/src/developer-documentation/concepts/bpmn/timer-intermediate-catching-events.md

@@ -0,0 +1,7 @@
+### Timer Intermediate Catching Events
+
+A [Timer Intermediate Catching Event](https://docs.camunda.org/manual/7.17/reference/bpmn20/events/timer-events/#timer-intermediate-catching-event)
+allows you model stopwatch behavior. A timer is started once the BPMN execution arrives at the event.
+The duration until the timer runs out is specified using the [ISO 8601 Durations](http://en.wikipedia.org/wiki/ISO_8601#Durations) format.
+Examples can be found [here](https://docs.camunda.org/manual/7.17/reference/bpmn20/events/timer-events/#time-duration). After running out, the BPMN process executes the [Sequence Flow](../../concepts/bpmn/sequence-flow.md) following
+the [Timer Intermediate Catching Event](https://docs.camunda.org/manual/7.17/reference/bpmn20/events/timer-events/#timer-intermediate-catching-event).

docs/src/developer-documentation/concepts/dsf/about-version-placeholders-and-urls.md

@@ -0,0 +1,54 @@
+### About Versions, Placeholders and URLs
+
+#### Version Pattern
+
+Process plugin versions have to obey the pattern:
+```
+\d+\.\d+\.\d+\.\d+  Example: 1.0.1.2
+```
+
+The first two numbers (`1.0`) are used in FHIR resources and signal changes which break compatibility with previous
+process versions. For example, altering FHIR resources usually results in a breaking change. The latter two (`1.2`) signal changes which do not break compatibility with previous process versions. Specifically,
+the 4th number is reserved for bug-fixes and the 3rd number includes all other non-breaking changes.
+
+#### Placeholders
+
+To avoid the need to specify the version and release date for each [ActivityDefinition](../../concepts/fhir/activitydefinition.md), [CodeSystem](../../concepts/fhir/codesystem.md),
+[Task](../../concepts/fhir/task.md) profile and [ValueSet](../../concepts/fhir/valueset.md) resource,
+the placeholders `#{version}` and `#{date}` can be used when creating FHIR resources or even in BPMN models.
+They are replaced with the values returned by the methods `ProcessPluginDefinition#getResourceVersion`
+and `ProcessPluginDefinition#getReleaseDate` respectively during deployment of a process plugin by the DSF BPE server.  
+There is also a placeholder for the organization the DSF instance is running in: `#{organization}`. You would typically use
+this placeholder in [Draft Task Resources](draft-task-resources.md) but like the other placeholders, it can be used anywhere
+as long as the file gets loaded by the [BPE](https://dsf.dev/intro/info/architecture.html#business-process-engine-bpe).
+
+#### URLs
+
+BPMN models have an ID we call process definition key. The BPMN process definition key needs to be specified following the pattern:
+```
+^[-a-zA-Z0-9]+_[-a-zA-Z0-9]+$   Example: domainorg_processKey
+```
+In addition, the BPMN model needs to specify a version. You should be using the ``#{version}`` [placeholder](../../concepts/dsf/about-version-placeholders-and-urls.md#placeholders)
+for this as well. The DSF will also reference this process in URL form in FHIR resources:
+```
+http://domain.org/bpe/Process/processKey|1.0
+```
+
+As you can see, the version in the URL ``|1.0`` only uses the resource version and omits the code base version.
+As mentioned in [Version Pattern](about-version-placeholders-and-urls.md#version-pattern), this means that only changes to the first two
+version numbers are significant to signal compatibility when communicating with other process plugin instances.  
+The process definition key and URL are also related to each other. The DSF will try to match BPMN models 
+to FHIR resources by transforming the URL into a process definition key. That is why it is important you obey
+the pattern above.
+
+You will use the above URL as your instantiatesCanonical value for [Task](../../concepts/fhir/task.md) profile definitions as well as references
+to [Task](../../concepts/fhir/task.md) profiles in other resources.
+You will also use it as the URL value for your [ActivityDefinitions](../../concepts/fhir/activitydefinition.md). In this case though, you
+have to split up the URL into two parts. You will separate the version (``|1.0``) from the URL and use it as a value for the
+`ActivityDefinition.version` element. Since it refers to the plugin's resource version, you should also use the `#{version}`
+[placeholder](about-version-placeholders-and-urls.md#placeholders) here instead. Going by the example from above, you will be left with a URL that looks
+like this:
+```
+http://domain.org/bpe/Process/processKey
+```
+This will be the value for your `ActivityDefinition.url` element with `#{version}` as the value for your `ActivityDefinition.version` element.

docs/src/developer-documentation/concepts/dsf/bpmn-process-execution.md

@@ -0,0 +1,10 @@
+### BPMN Process Execution
+
+The BPMN process execution is the in-memory representation of a running BPMN process. BPMN processes have their 
+executions structured as a tree hierarchy. Each BPMN process 
+starts with the [process instance](https://docs.camunda.org/manual/7.20/user-guide/process-engine/process-engine-concepts/#process-instances)
+as its root level execution. If, for example, this root execution reaches a parallel gateway with two paths, it would spawn two child executions 
+under itself for them to process all tasks along their paths on their own.
+Executions can access all the BPMN elements from the BPMN model as well as the [BPMN process variables](../../concepts/dsf/bpmn-process-variables.md).
+You have access to this representation in your Java code when overriding certain methods in [Service](../../concepts/dsf/service-delegates.md) / [Message](../../concepts/dsf/message-delegates.md) Delegates
+like `doExecute` or `getAdditionalInputParameters` through the `execution` parameter.

docs/src/developer-documentation/concepts/dsf/bpmn-process-variables.md

@@ -0,0 +1,9 @@
+### BPMN Process Variables
+
+BPMN process variables hold additional information which has to be available during BPMN process execution.
+Variables can be directly related to BPMN elements like the boolean value for [Conditions](../../concepts/bpmn/conditions.md), but
+do not have to be. BPMN process variables are stored as key-value pairs with the key being the variable name.
+They are accessible during the entirety of the execution to all [Service](../../concepts/dsf/service-delegates.md) /
+[Message](../../concepts/dsf/message-delegates.md) Delegates.
+
+You can learn how to access to the BPMN process variables [here](../../guides/accessing-bpmn-process-variables.md).