Latest tutorial pass fixes

docs/src/process-development/api-v2/bpmn/execution-listeners.md

@@ -0,0 +1,8 @@
+---
+title: Execution Listeners
+icon: creative
+---
+
+## Execution Listeners
+
+[Execution Listeners](https://docs.operaton.org/docs/documentation/user-guide/model-api/bpmn-model-api/delegation-code/#execution-listener) can be registered to various flow elements like process, events, tasks, gateways and sequence flows. They are called when the process execution arrives at the flow element they are registered to. 

docs/src/process-development/api-v2/bpmn/gateways.md

@@ -5,16 +5,16 @@ icon: creative
 
 ## Gateways
 
-[Gateways](https://docs.camunda.org/manual/7.21/reference/bpmn20/gateways/) allow modelling of decision-based and concurrent workflows. [Exclusive Gateways](#exclusive-gateways) model a decision where one flow gets pursued over other flows. [Event-based Gateways](#event-based-gateways) also model a decision, but are based on events. [Parallel Gateways](#parallel-gateways) model concurrency.
+[Gateways](https://docs.operaton.org/docs/documentation/reference/bpmn20/gateways/) allow modelling of decision-based and concurrent workflows. [Exclusive Gateways](#exclusive-gateways) model a decision where one flow gets pursued over other flows. [Event-based Gateways](#event-based-gateways) also model a decision, but are based on events. [Parallel Gateways](#parallel-gateways) model concurrency.
 
 ### Exclusive Gateways
 
-[Exclusive Gateways](https://docs.camunda.org/manual/7.21/reference/bpmn20/gateways/exclusive-gateway/) decide which one out of multiple [Sequence Flow](sequence-flow.md) should be followed based on [conditions](https://docs.camunda.org/manual/7.21/user-guide/process-engine/expression-language/#conditions). [Conditions](https://docs.camunda.org/manual/7.21/user-guide/process-engine/expression-language/#conditions) are not part of the [Exclusive Gateways](https://docs.camunda.org/manual/7.21/reference/bpmn20/gateways/exclusive-gateway/) themselves. They are set through the sequence flow exiting the [Exclusive Gateway](https://docs.camunda.org/manual/7.21/reference/bpmn20/gateways/exclusive-gateway/).  In the [Camunda Modeler](https://camunda.com/download/modeler/), conditions can be added to [Sequence Flows](sequence-flow.md) by selecting a [Sequence Flow](sequence-flow.md) and opening the `Condition` tab. More information on how to use Conditions can be found in [Conditions](conditions.md).
+[Exclusive Gateways](https://docs.operaton.org/docs/documentation/reference/bpmn20/gateways/exclusive-gateway) decide which one out of multiple [Sequence Flow](sequence-flow.md) should be followed based on [conditions](https://docs.camunda.org/manual/7.21/user-guide/process-engine/expression-language/#conditions). [Conditions](https://docs.camunda.org/manual/7.21/user-guide/process-engine/expression-language/#conditions) are not part of the [Exclusive Gateways](https://docs.operaton.org/docs/documentation/reference/bpmn20/gateways/exclusive-gateway) themselves. They are set through the sequence flow exiting the [Exclusive Gateway](https://docs.operaton.org/docs/documentation/reference/bpmn20/gateways/exclusive-gateway).  In the [Camunda Modeler](https://camunda.com/download/modeler/), conditions can be added to [Sequence Flows](sequence-flow.md) by selecting a [Sequence Flow](sequence-flow.md) and opening the `Condition` tab. More information on how to use Conditions can be found in [Conditions](conditions.md).
 
 ### Event-based Gateways
 
-The [Event-based Gateway](https://docs.camunda.org/manual/7.21/reference/bpmn20/gateways/event-based-gateway/) models a decision in the workflow. But instead of [conditions](./conditions.md), the [Event-based Gateway](https://docs.camunda.org/manual/7.21/reference/bpmn20/gateways/event-based-gateway/) uses the triggering of an event to decide which [Sequence Flow](sequence-flow.md) to pursue.
+The [Event-based Gateway](https://docs.operaton.org/docs/documentation/reference/bpmn20/gateways/event-based-gateway) models a decision in the workflow. But instead of [conditions](./conditions.md), the [Event-based Gateway](https://docs.operaton.org/docs/documentation/reference/bpmn20/gateways/event-based-gateway) uses the triggering of an event to decide which [Sequence Flow](sequence-flow.md) to pursue.
 
 ### Parallel Gateways
 
-[Parallel Gateways](https://docs.camunda.org/manual/latest/reference/bpmn20/gateways/parallel-gateway/) model concurrent workflows. Their outgoing flows can be joined together again with another [Parallel Gateway](https://docs.camunda.org/manual/latest/reference/bpmn20/gateways/parallel-gateway/). This makes process execution wait for both flows to arrive at the gateway before continuing.
+[Parallel Gateways](https://docs.operaton.org/docs/documentation/reference/bpmn20/gateways/parallel-gateway/) model concurrent workflows. Their outgoing flows can be joined together again with another [Parallel Gateway](https://docs.operaton.org/docs/documentation/reference/bpmn20/gateways/parallel-gateway/). This makes process execution wait for both flows to arrive at the gateway before continuing.

docs/src/process-development/api-v2/bpmn/index.md

@@ -8,6 +8,7 @@ The DSF uses BPMN 2.0 to model processes. Specifically, the [Camunda 7](https://
 
 ## Details
 - [Conditions](conditions.md)
+- [Execution Listeners](execution-listeners.md)
 - [Gateways](gateways.md)
 - [Messaging](messaging.md)
 - [Sequence Flow](sequence-flow.md)

docs/src/process-development/api-v2/bpmn/messaging.md

@@ -6,19 +6,22 @@ icon: creative
 
 ## Messaging
 
-Enabling communication with other lanes, pools or even entirely separate processes requires the ability to exchange information. In BPMN, [Message Events](https://docs.camunda.org/manual/7.21/reference/bpmn20/events/message-events/) are used to model this information exchange. Modeling communication with [Message Events](https://docs.camunda.org/manual/7.21/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.
+Enabling communication with other lanes, pools or even entirely separate processes requires the ability to exchange information. In BPMN, [Message Events](https://docs.operaton.org/docs/documentation/reference/bpmn20/events/message-events/) and [Message Send Tasks](https://docs.operaton.org/docs/documentation/reference/bpmn20/tasks/send-task) are used to model this information exchange. Using them to model communication 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.
 
 ![BPMN collaboration diagram with two processes using message flow to exchange information between two organizations](/photos/developer-documentation/message_flow.svg)
 
 ### Message Start Event
 
-[Message Start Events](https://docs.camunda.org/manual/7.21/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, a [Message Start Event](https://docs.camunda.org/manual/7.21/reference/bpmn20/events/message-events/#message-start-event) has to be included at the beginning of all of your BPMN models.
+[Message Start Events](https://docs.operaton.org/docs/documentation/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, it is mandatory to include a [Message Start Event](https://docs.operaton.org/docs/documentation/reference/bpmn20/events/message-events#message-start-event) at the beginning of all DSF BPMN models.
 
-### Message Intermediate Throwing Event
-[Message Intermediate Throwing Events](https://docs.camunda.org/manual/7.21/reference/bpmn20/events/message-events/#message-intermediate-throwing-event) are used to send messages during process execution.
+#### Message Intermediate Throwing Event
+[Message Intermediate Throwing Events](https://docs.operaton.org/docs/documentation/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.21/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 it is expected to receive a message from another process or organization during execution.
+#### Message Intermediate Catching Event
+[Message Intermediate Catching Events](https://docs.operaton.org/docs/documentation/reference/bpmn20/events/message-events#message-intermediate-catching-event) serve as the counterpart to [Message Intermediate Throwing Events](messaging.md#message-intermediate-throwing-event). They are used to receive a message from another process or organization during execution.
 
-### Message End Event
-The [Message End Event](https://docs.camunda.org/manual/7.21/reference/bpmn20/events/message-events/#message-end-event) will stop the execution of a BPMN process and finish by sending a message.
+#### Message End Event
+The [Message End Event](https://docs.operaton.org/docs/documentation/reference/bpmn20/events/message-events#message-end-event) will stop the execution of a BPMN process and finish by sending a message.
+
+#### Message Send Task
+Same as the [Message Intermediate Throwing Event](#message-intermediate-throwing-event), the [Message Send Task](https://docs.operaton.org/docs/documentation/reference/bpmn20/tasks/send-task/) is used to send messages during process execution but is also intended to execute some kind of business logic at the same time.

docs/src/process-development/api-v2/bpmn/service-tasks.md

@@ -5,4 +5,4 @@ icon: creative
 
 ## Service Tasks
 
-One of the most common types of BPMN Tasks used for modeling DSF processes is the [Service Task](https://docs.camunda.org/manual/7.21/reference/bpmn20/tasks/service-task/). 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.21/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 BPMN processes.
+One of the most common types of BPMN Tasks used for modeling DSF processes is the [Service Task](https://docs.operaton.org/docs/documentation/reference/bpmn20/tasks/service-task). They are different from regular BPMN Tasks in that they offer the ability to link a Java class to the [Service Task](https://docs.operaton.org/docs/documentation/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 BPMN processes and their associated code.

docs/src/process-development/api-v2/bpmn/timer-intermediate-catching-events.md

@@ -5,4 +5,4 @@ icon: creative
 
 ## Timer Intermediate Catching Events
 
-A [Timer Intermediate Catching Event](https://docs.camunda.org/manual/7.21/reference/bpmn20/events/timer-events/#timer-intermediate-catching-event) allows for modelling 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.21/reference/bpmn20/events/timer-events/#time-duration). After running out, the BPMN process executes the [Sequence Flow](sequence-flow.md) following the [Timer Intermediate Catching Event](https://docs.camunda.org/manual/7.21/reference/bpmn20/events/timer-events/#timer-intermediate-catching-event).
+A [Timer Intermediate Catching Event](https://docs.operaton.org/docs/documentation/reference/bpmn20/events/timer-events#timer-intermediate-catching-event) allows modelling 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.operaton.org/docs/documentation/reference/bpmn20/events/timer-events#time-duration). After running out, the BPMN process executes the [Sequence Flow](sequence-flow.md) following the [Timer Intermediate Catching Event](https://docs.operaton.org/docs/documentation/reference/bpmn20/events/timer-events#timer-intermediate-catching-event).

docs/src/process-development/api-v2/bpmn/user-tasks.md

@@ -5,4 +5,7 @@ icon: creative
 
 ## User Tasks
 
-User Tasks define a process step that requires some kind of human interaction. Usually this is done by providing some kind of form the user can fill out. The Camunda Modeler allows to configure these forms as either a proprietary format called [Camunda Forms](https://docs.camunda.io/docs/guides/utilizing-forms/) or custom forms called `Embedded or External Task Forms`. The DSF uses such `External Task Forms` in the form of [Questionnaire](https://www.hl7.org/fhir/R4/questionnaire.html) and [Questionnaire Response](https://www.hl7.org/fhir/R4/questionnaireresponse.html) resources. This mechanism is further expanded upon in [User Tasks in the DSF](../guides/user-tasks-in-the-dsf.md).
+User Tasks define a process step that requires some kind of human interaction. Usually this is done by providing some kind of form the user can fill out. Operaton supports three kinds of forms: [Embedded Forms](https://docs.operaton.org/docs/documentation/user-guide/task-forms/#embedded-task-forms), [Operaton Forms](https://docs.operaton.org/docs/documentation/user-guide/task-forms/#embedded-task-forms) and [External Task Forms](https://docs.operaton.org/docs/documentation/user-guide/task-forms/#external-task-forms). The DSF uses `External Task Forms` in the form of [Questionnaire](https://www.hl7.org/fhir/R4/questionnaire.html) and [Questionnaire Response](https://www.hl7.org/fhir/R4/questionnaireresponse.html) resources.
+
+## Related Topics
+[Questionnaire and QuestionnaireResponse](../fhir/questionnaire-and-questionnaireresponse.md), [User Tasks in the DSF](../guides/user-tasks-in-the-dsf.md)

docs/src/process-development/api-v2/concept.md

@@ -5,6 +5,7 @@ icon: info
 
 ## BPMN
 - [Conditions](bpmn/conditions.md)
+- [Execution Listener](bpmn/execution-listeners.md)
 - [Gateways](bpmn/gateways.md)
 - [Messaging](bpmn/messaging.md)
 - [Sequence Flow](bpmn/sequence-flow.md)
@@ -14,35 +15,35 @@ icon: info
 ## FHIR
 - [ActivityDefinition](fhir/activitydefinition.md)
 - [Codesystem](fhir/codesystem.md)
+- [Questionnaire and QuestionnaireResponse](fhir/questionnaire-and-questionnaireresponse.md)
 - [Task](fhir/task.md)
 - [ValueSet](fhir/valueset.md)
 
 ## DSF
-- [BPMN Process Execution](dsf/bpmn-process-execution.md)
+- [Activities](dsf/activities.md)
 - [BPMN Process Variables](dsf/bpmn-process-variables.md)
 - [Draft Task Resources](dsf/draft-task-resources.md)
 - [Environment Variables](dsf/environment-variables.md)
 - [Message Correlation](dsf/message-correlation.md)
-- [Message Delegates](dsf/message-delegates.md)
+- [Message Activities](dsf/message-activities.md)
+- [Messaging](dsf/messaging.md)
 - [Organization Identifiers](dsf/organization-identifiers.md)
 - [Process Plugin API](dsf/process-plugin-api.md)
 - [Process Plugin Definition](dsf/process-plugin-definition.md)
 - [Read Access Tag](dsf/read-access-tag.md)
 - [Requester and Recipient](dsf/requester-and-recipient.md)
-- [Service Delegates](dsf/service-delegates.md)
 - [Spring Framework Integration](dsf/spring-framework-integration.md)
 - [Target and Targets](dsf/target-and-targets.md)
 - [Versions, Placeholders and URLs](dsf/versions-placeholders-urls.md)
 
 ## Guides
 - [Accessing BPMN Process Variables](guides/accessing-bpmn-process-variables.md)
 - [Accessing Task Resources During Execution](guides/accessing-task-resources-during-execution.md)
-- [Adding Task Input Parameters to Task Profiles](guides/adding-task-input-parameters-to-task-profiles.md)
+- [Adding Task Parameters to Task Profiles](guides/adding-task-parameters-to-task-profiles.md)
 - [Configuring Read Access Tags](guides/configuring-read-access-tags.md)
 - [Creating ActivityDefinitions](guides/creating-activity-definitions.md)
 - [Creating CodeSystems for DSF Processes](guides/creating-codesystems-for-dsf-processes.md)
 - [Creating Task Resources Based on a Definition](guides/creating-task-resources-based-on-a-definition.md)
 - [Creating ValueSets for DSF Processes](guides/creating-valuesets-for-dsf-processes.md)
 - [Managing Multiple Incoming Messages and Missing Messages](guides/managing-mutiple-incoming-messages-and-missing-messages.md)
-- [Setting Targets for Message Events](guides/setting-targets-for-message-events.md)
 - [Starting a Process via Task Resources](guides/starting-a-process-via-task-resources.md)

docs/src/process-development/api-v2/dsf/activities.md

@@ -0,0 +1,37 @@
+---
+title: Activities
+icon: creative
+---
+
+### Activities
+
+Activities are Java interfaces that represent certain BPMN elements which can/need to specify a Java class as their `Implementation` value. Implementing Activity interfaces and [registering them as Spring beans](spring-framework-integration.md) causes the DSF to execute the code provided by the implementation when the process execution reaches the corresponding flow element. The value for the `Implementation` field of BPMN elements expects the fully qualified class name:
+```
+org.package.myClass
+```
+
+### List of Activities
+- ExecutionListener
+- MessageEndEvent
+- MessageIntermediateThrowEvent
+- MessageSendTask
+- ServiceTask
+- UserTaskListener
+
+### ExecutionListener
+`ExecutionListener` is the interface to be implemented for a class set as the Java implementation for [Execution Listeners](../bpmn/execution-listeners.md) attached to certain flow elements.
+
+### MessageEndEvent
+`MessageEndEvent` is the interface to be implemented for a class set as the Java implementation for Message End Events. It inherits from the `MessageActivity` interface which specifies additional methods specific to [messaging](messaging.md).
+
+### MessageIntermediateThrowEvent
+`MessageIntermediateThrowEvent` is the interface to be implemented for a class set as the Java implementation for Message Intermediate Throw Events. It inherits from the `MessageActivity` interface which specifies additional methods specific to [messaging](messaging.md).
+
+### MessageSendTask
+`MessageSendTask` is the interface to be implemented for a class set as the Java implementation for Message Send Tasks. It inherits from the `MessageActivity` interface which specifies additional methods specific to [messaging](messaging.md).
+
+### ServiceTask
+`ServiceTask` is the interface to be implemented for a class set as the Java implementation for Service Tasks.
+
+### UserTaskListener
+`ServiceTask` is the interface to be implemented for a class set as the Java implementation for Service Tasks's Task Listener. Task Listeners have properties that separate them from [Execution Listeners](../bpmn/execution-listeners.md). More on Task Listeners in the guide on [User Tasks in the DSF](../guides/user-tasks-in-the-dsf.md)