How to model an event that can be triggered at any time by an actor?

[dan...@bouncecars.com]

Hello Everyone,

I would like to model an event that can be triggered at any time by an actor. How should I model this?

I have sketched a simple business process for a payment system.. is very incomplete but the point I try to highlight is that, as the event can be called at any time there is no clear time line position where to put it.

The pool/swimlane should reflect time elapsing.. but where do we place exceptions?

[Thomas Hildebrandt]

Hi Daniel,

Sounds like it could be done by including all actions in a subprocess and putting the event on the border of the subprocess?

Best

Thomas

IT University of Copenhagen 

Sendt fra min iPhone

--
--
You received this message because you are subscribed to the Google
Groups "BPMN Forum" group.
Public website: http://www.bpmnforum.com
To post to this group, send email to BPMN...@googlegroups.com
To unsubscribe from this group, send email to
BPMNforum+...@googlegroups.com
For more options, visit this group at
http://groups.google.com/group/BPMNforum?hl=en_US?hl=en

---
You received this message because you are subscribed to the Google Groups "BPMN Forum" group.
To unsubscribe from this group and stop receiving emails from it, send an email to BPMNforum+...@googlegroups.com.
For more options, visit https://groups.google.com/d/optout.

[István Dányi]

Hi Daniel and Thomas,

This is a typical question raised when you process cancellation should be solved. My thought is the following:

- Thomas's suggestion is appropriate, but with an important constraint: all process tasks in the sequence between the first and last related tasks must be interrupted. That is no 'must-do' task in this case, or that must be handled in the cancellation flow.

- Anyway, you can use Intermediate Event in all related tasks with other assigned following elements (merging Gateway and additional Tasks or a simple End event).

- However you should decide where you want to handle the other activities which might be performed differently depending on the actual status of the process (when event triggered). I suggest to do this in a separate process (e.g. Cancel xy process) to keep  the original process simple. In this case the Cancel process can send message to the original processes to stop it, but perform additional tasks by itself.

Hope it helps you.

Cheers,

Istvan

[dan...@bouncecars.com]

Hello Istvan,

thanks for your reply.

I find this a little hectic to model as the event can be triggered at any time so there is no clear start point of the branch for the complex gataway that could handle it.

For example there could be a "cancel" button in an app that can be clicked at any time by the user. So when modelling the user/server process interaction for a process where do we put the cancel event? And then, where do we put the handle cancel event on the server side?

So the issues I have are:
- This subprocess affects two actors and not only one and hence I find it a little hectic to model using swimlanes.
- When having multiple "sudden events" there could be multiple complex start points resulting in a difficult to read diagram (even if using subprocesses).

The only thing I can think of as alternatives is to use signals to model this external event but again being swimlanes chronological:

- how do we model the event triggering the signal? The signal can be triggered at any time so this solution would solve only half of the problem as makes it easier to model the subprocess but not the triggering event.

Please ask if I am unclear.

Thanks a lot

[István Dányi]

Hello Daniel,

I am afraid that I do not exactly understand what you would like to really solve. Anyway, I tried my best...

>>I find this a little hectic to model as the event can be triggered at any time so there is no clear start point of the branch for the

>> complex gataway that could handle it.

Yes, this can be really complicate if you want to depict triggers within a process which can be occur any time. That is why subprocess with boundary catching event was suggested. For example, both the receiving cancel invocation (catching events) and handling task (following the catching event) can be specified only once and separately.

>> For example there could be a "cancel" button in an app that can be clicked at any time by the user. So when modelling the

>> user/server process interaction for a process where do we put the cancel event? And then, where do we put the handle

>> cancel event on the server side?

Well, if you have a cancel button that can be pushed any time during the procedure, I would suggest to put the complete procedure in a sub-process and add a interrupting boundary catch event. BTW, I think of only one process, and not of interaction of a server and client processes. However, if you prefer two processes (which seems a little bit more complex) you can also use subprocess at client side: put all related tasks in the subprocess with the boundary catching event of pushing butting that is followed by throwing event of process cancellation. The latter can be populated towards the server side process. In this case you have to specify two different events.

>> So the issues I have are:

>> - This subprocess affects two actors and not only one and hence I find it a little hectic to model using swimlanes. 

>> - When having multiple "sudden events" there could be multiple complex start points resulting in a difficult to read diagram

>> (even if using subprocesses).

I think the suggested approach (catch cancel event) on server side process does not even if you have two actors. However it would be another problem that two users can interrupt their parallel work. (e.g. The user1's task flow can be interrupted not only because they push the "own" cancel button, but also user2 pushes its own button parallel.) In this case you have to specify additional catching events to ensure the implied effect on the other user.

>> The only thing I can think of as alternatives is to use signals to model this external event but again being swimlanes

>> chronological:
>> - how do we model the event triggering the signal? The signal can be triggered at any time so this solution would solve only

>> half of the problem as makes it easier to model the subprocess but not the triggering event.

Again, I am not sure what you consider your problem. If you define subprocess with boundary event, then you do not have to depict events throwing such trigger inside the subprocess. This is true for events originated from inside (subsprocess) and external process. In later case, however, you have to specify/explain from where the external trigger can be occured in the pool containing the subprocess. (e.g. a message flow between process pools, or using signals)

Hope it helped you somehow.

br,

Istvan