Editing BPMN (section)

====Events====

Overview in [http://localhost/VisioExports/BPM.htm BPMN Events]

BPMN does not require to model events, but if there is a start event there has to be an end event and the other way round. This applies to different levels, so a surounding process may have a start, but a enclosed sub-process may not have a start event. Start event must not have an incoming sequence flow.

If the event has multiple incoming sequence flows, then this is considered '''uncontrolled''' flow. This means that
when a token arrives from one of the paths, the event will be enabled (to catch or throw). It will not wait for the arrival of
tokens from the other paths. If another token arrives from the same path or another path, then a separate instance of the Event
will be created. 

There are three types:
* Start Events (thin line)
* Intermediate Events (double line)
* End Events (thick line)
and two flavors:
* throwing (e.g. all end events are throwing)
* catching (e.g. all start event are catching)

=====Start Events=====
* There are six different Start events for starting a Process or a [[#Event_Sub-Process|Event Sub-Process]]. The [[#Event_Sub-Process|Event Sub-Process]] Start Events can be interrupting or Non-interrupting:
** [[#None_Start_Event|None/undefined/unspecified start event]]
** [[#Message_Start_Event|Message Start Event]]
** [[#Timer_Start_Event|Timer start event]]
** [[#Signal_Start_Event|Signal Start Event]]
** [[#Conditional_Start_Event|Conditional Start Event]]
** [[#Multiple_Start_Event|Multiple Start Event]] (one out of many events)
** [[#Parallel_Start_Event|Parallel Start Event]] (all out of many events)
* There are three additional interrupting [[#Event_Sub-Process|Event Sub-Process]] Start Events
** Escalation Start Event
** Error Start Event
** [[#Compensation_Start_Event|Compensation Start Event]]
* Since BPMN 2.0 there are two start gateways:
** [[#Event-based_Start_Gateway|Event-based Start Gateway]]
** [[#Parallel_Start_Event_Gateway|Event-based Parallel Start Gateway]]
* Start events are always catching.
* There can be more than one start event. For each event a separate process instance is started. There can also be none start event, but it's not recommended.
* There should be only one undefined start event.

======None Start Event======
* the None/undefined/unspecified start event represents normally the manual process start by an user
* if there are multiple None Start Events the naming is important if the Events are different or the same
* if there are multiple None Start Events in a Sub-Process only one triggered either by a targetRef attribut or by chance

======Message Start Event======

======Compensation Start Event======
* The Compensation Start Event MAY NOT be used for a top-level Process

======Timer Start Event======
* A specific time-date or a specific cycle (e.g., every Monday at 9am) can be set that will trigger the start of the Process.

======Signal Start Event======
* A Signal is for general communication within and across Process levels, across Pools and between Business Process Diagram
* There is a source but no specific intended target

======Conditional Start Event======
* triggered when condition becomes true
* triggered again when condition became false and then true again

======Multiple Start Event======
* starts if one out of many events occurs

======Parallel Start Event======
* several disjoint start events must occur once to create a process instance

======Event-based Start Gateway======
* no incoming sequence flow to gateway
* process instance will be start if one of the events of the outgoing path is catched
* a additional Event starts a new Process instance
* could be modelled with a None Start Event and following Event-based Gateway, but in this case a process instance is already there

======Event-based Parallel Start Gateway======
* all Events which in the sequence have to be there to start the Process

=====Intermediate Events=====
* Intermediate can be split in catching und sending/throwing. 
* Catching/receiving intermediate events are waiting until the event arrives, throwing events are throwing and continuing
* there are no throwing timer events, just catching
* Intermediate events at an activity borders are catching events, listening for the trigger and called '''boundary events'''. They can be located anywhere at the border.
* boundary events can be '''interrupting''' (solid line) or '''non-interrupting''' (dashed line). The interrupting event stops the activity immediately, including running [[#Event_Sub-Process|Event Sub-Processes]]
** Error, Compensation and Cancel Event are always interrupting (non-interrupting make no sense)
** Compensation is only called, if activity is completed
* boundary events are listening as long the activity is running
* None intermediate events can e.g. be used to model state transitions of objects
* there are 12 intermediate events:
** [[#None_Intermediate_Event|None/undefined Intermediate Event]]
** [[#Message_Intermediate_Event|Message Intermediate Event]]
** [[#Timer_Intermediate_Event|Timer Intermediate Event]]
** rule/condition
** [[#Error_Intermediate_Event|Error Intermediate Event]]
** [[#Signal_Intermediate_Event|Signal Intermediate Event]]
** [[#Link_Intermediate_Event|Link Intermediate Event]]
** [[#Compensation_Intermediate_Event|Compensating Intermediate Event]]
** [[#Escalation_Intermediate_Event|Escalation Intermediate Event]]
** [[#Cancel_Intermediate_Event|Cancel Intermediate Event]]
** [[#Multiple_Intermediate_Event|Multiple Intermediate Event]]
** [[#Parallel_Intermediate_Event|Parallel Intermediate Event]]

======None Intermediate Event======
* is used as a throwing event to model some state changes of the process
* not allowed on a boundary

======Message Intermediate Event======

======Timer Intermediate Event======
* at boundary in can be a stop-watch which starts when the activity starts or a alarm at a specific date/time

======Error Intermediate Event======
* there is a throwing and catching Error Intermediate Event
* Catching Error Intermediate Event is only for boundary and always interrupting, in case of multi-instances all instances are interrupted
* in case of boundary catching the Sub-Process was cancelled and the data is not available and potentially lost. This could be solved by an catching [[#Event_Sub-Process|Event Sub-Process]] Start Event.

======Signal Intermediate Event======
* a Signal is an undirected message

======Link Intermediate Event======
* conncecting sequence flow on different pages via a link id

======Compensation Intermediate Event======
* By default, the compensation throwing Event waits for the completion of the triggered compensation handler. Alternatively, compensation can just be triggered without waiting for its completion, by setting the throw Compensation Event’s waitForCompletion attribute to false
* Compensation handlers are associated to an Activity by a boundary catching Compensation Event. The handler can be triggered later in the process flow and is only executed if the Activity is completed successfully (other boundary event can only be triggered if the Activity is active and not completed).
* Triggered Compensation only refer to the own Process/Pool.

======Escalation Intermediate Event======
* meant for escalating to a higher level of responsibilities

======Cancel Intermediate Event======
* must be attached to a boundary of a Transaction Sub-Process
* will direct the flow after the Transaction has been rolled back and all compensation has been completed

======Multiple Intermediate Event======
* Catching if one of many events
* Throws all events

======Parallel Intermediate Event======
* no throwing, only catching
* all Events have to be there, to trigger the catch

=====End Events=====
* End Events signifies the end of a path in a process or subprocess. 
* End Events consume tokens.
* End Events are always throwing.
* there can be more than one End Event.
* a process instance lives until the last token arrived at an end event or a process terminating end event is reached. If the process is a Sub-Process it can be stopped prior through interrupting Intermediate Events. In this case the tokens are consumed by the Intermediate Event attached to the boundary.
* there six different end events:
** None/undefined
** message end event
** [[#Signal_End_Event|signal end event]]
** [[#Error_End_Event|error end event]]
** [[#Escalation_End_Event|escalation end event]]
** [[#Cancel_End_Event|cancel end event]]
** multiple consequences end event
** [[#Terminating_End_Event|terminating end event]]

======Signal End Event======
* for loose coupling (publisher subscribe)

======Error End Event======
* reaching in a process or subprocess immediately ends that process level, even if path are active
* the result can only be catched by an (nearest enclosing) intermediate error event attached to the subprocess boundary
* does not trigger compensation (different from Cancel End Event)

======Escalation End Event======
* like error end event, but process or subprocess is not aborted if there are still active path, so it triggers an additional activity

======Cancel End Event======
* another special end event, it's only used in transactional subprocess
* it interrupts the process or subprocess like the error end event

======Terminating End Event======
* ends the process level, even if there running paths
* doesn't propagate a result signal
* if it ends a subprocess, the next process level continues the normal flow