►
From YouTube: Elsa Workflows Community Meeting 17 ( 2022-07-12)
Description
Meeting 17
Topics
- Trailrun, mountainbiking
- Elsa 3 updates
- Elsa 3 flowchart
- Switch:
- all true cases should yield next action
- allow control of behavior (Match Any, Match First)
- Ask about bots to support writing or at least reading Q&A
Power Apps, K2
B
Yeah,
I
I
have
done
it.
I
was
running
the
algorithm
to
see
whether
or
not
it's
it
was
working,
but
maybe
we
can
just
discuss
the
workflow
that
I
created
to
see.
If
I
can,
if
I
have
all
the
edge
cases
in
there
or
if
we
can
think
of
other
edge
cases
that
need
to
be
handled
in
that
one
uj,
it's
about
a
parallel,
execute
execution
and
the
expectancy
that
you
have
from
a
workflow
to
have
it
like
execute
multiple
times
or
executed.
Once
when
you
have
a
split
and
a
fork.
B
A
A
So
that
would
be
great
yeah
great.
So
those
those
are
two
topics.
Let
me
just
dive
into
the
elsa
3
updates.
So
last
week
we
discussed
this
flowchart
execution.
We
also
talked
about
flow
decision
and
other
flow
type
of
activities.
At
that
point,
I
was
working
on
the
switch
activity
which,
as
you
may
know,
lets
you
add
cases
and
that
wasn't
fully
working
last
week,
but
now
it
should
be
good.
So
if
you
had
a
few
cases,
you
can
actually
go
into
an
individual
case
and
then
implement
that
case.
A
So
here,
for
example,
I
had
a
right
line
to
case
one
and
then
here
I
can
add
a
red
line
to
case
two
and
you
can
add
as
many
cases
as
you
like,
but
we
also
talked
about
you
know.
These
are
more
like
sequential
activities
and
we
talked
about
what,
if
you
want
flow
style
activities
like
the
flow
decision,
which
has
a
true
and
false
outcome,
and
we
now
also
have
one
for
the
flow
switch
which
behaves
similar
to
the
the
switch
activity.
A
But
in
that
you
can
add
a
bunch
of
cases,
but
instead
of
seeing
these
these
ports
embedded
in
the
activity,
they
will
appear
on
the
as
an
actual
outcome
like
true
and
false.
So
in
this
case
there's
a
little
bug.
So
I
broke
something,
but
you
can
imagine
there
will
be
multiple
little
bulbs
appearing
to
the
right
side
or
the
bottom
of
this
activity,
and
then
you
can
connect
additional
activities
so
that
works
almost
and
then
the
current
thing
that
I'm
working
on
is
reusable
or
custom
activities
that
you
can
configure
yeah.
A
So,
as
I
was
saying,
the
current
feature
I'm
working
on
is
custom
activities
and
there's
a
different
set
of
categories
that
could
entail
a
custom
activity.
Of
course
you
can
write
one
in
c
sharp,
but
what
I'm
working
on
is
using
the
designer
where
you
basically
create
a
new
flow
chart,
but
it
will
be
stored
as
an
activity
definition
and
then
the
ideas
is
that
you
can
have
your
custom
activities
appear
on
the
in
the
activity
browser
here
in
the
activity,
picker
and
then
drag
and
drop
them.
A
B
C
A
B
A
D
Thank
you.
Oh,
this
is
my
first
session
I'm
joining
and
I
think
I
can
add
to
that
switch
case
thing
of
how
I
think
is
a
pretty
cool
way
that
it
could
or
is
currently
working.
Sorry,
I
haven't
had
an
opportunity
to
actually
play
with
also
enough,
but
my
experience
lies
in
other
workflow
engines
and
something
that
I
that
works
really
well
is
if
the
lines
are
seen
as
any
and
all
logical
flows.
D
A
D
I
think
so,
okay,
if
we,
if
we
take
this
to
a
live
example,
let's
say
it's
a
purchase
order.
Let's
say
you
know
it.
It
also
has
three
lines:
if
it's
beneath
fifty
thousand
dollars,
if
it's
above
fifty
thousand
dollars
and
then
if
it's
above
a
hundred
thousand,
then
also
let
the
manager
know
send
them
an
email.
Then
if
something
is
above
fifty
thousand,
then
the
second
line
will
execute.
If
it's
of
a
hundred
thousand,
then
the
second
line
and
the
third
line
should
execute
and
yeah.
D
A
You
can
multiple
cases
adjacent
to
one
another
and
if
they
don't
have
a
body,
they
basically
allow
to
implement
different
conditions
that
map
to
a
certain
action
to
take.
Maybe
we
can
do
a
quick
example
here,
so
here
I
have
two
conditions
and
if
either
one
is
true,
then
it
will
perform
this
statement
and
if
this
one
is
true,
we'll
perform
that
statement.
Maybe
it's
not
an
exact
match,
because
these
are
expressions
that
evaluate
the
true
and
this
statement
is
more
like
it.
A
It
needs
to
match
this
thing
or
maybe
with
switch
expressions
in
since
c
sharp
at
nine.
I
believe
you
can
have
more
elaborate
conditions,
but
to
me
it
seems
to
be
similar.
So
in
that
case
maybe
you're
right,
then
it
should
be
that
any
condition
here
that
evaluates
a
true
should
yield
the
next
action
or
the
next
next
activity.
Yeah.
C
D
I
just
took
a
look
at
the
sorry,
I'm
I'm
I'm
sitting
on
my
cell
phone.
Oh
no
in
terms
of
that,
and
we
have
power
outages,
I'm
sitting
on
my
phone
and
I
just
went
through
documentation
of
how
the
previous
engines
that
I
worked
on
with
how
it
functions
and
an
activity
has
a
sorry.
An
event
has
a
set
of
activities
inside
of
it,
and
that
could
be
the
preceding
rule,
the
actual
activities
and
then
the
post
rule
so
preceding
rule
you
know,
doesn't
wait
for
certain
dates.
D
Does
it
wait
for
another
process,
whatever
that
blocks
it
from
continuing,
then
it
assigns
it
to
if
it
has
a
destination
role
where
it
goes,
and
then
it
initializes
the
activities.
So
that
would
be
email
events,
data
source
update
transactions
and
then
it
has
its
hard-coded
values,
which
would
be
a
loop
or
if
conditions
or
switch
cases,
and
so
on.
D
Then,
when
that
little
block
completes
it
itself
has
an
object
called
a
smart
object
is
aware
of
all
activities
preceding
and
post
rules,
and
you
know
all
values
where
it
equates
to
the
lines
connected
to
that
activity.
Is
then
essentially
like
little
listeners,
they
just
look
for
a
specific
value
and
see
if,
if
that
equates
to
true
and
then
they
execute,
so
I'm
not
too
sure
if
telling
a
a
block.
This
is
a
switch
case.
Oh
I'm,
not
too
sure.
Sorry,
I
don't
have
context
of
of
where
this
is.
A
Yeah
no
worries,
so
let
me
try
and
explain
so
in
ls3
we
have
this
switch
activity,
which
is
new
for
elsa
3.,
and
we
try
to
determine
the
correct
order.
This,
the
expected
behavior
or
the
behavior,
we
think,
makes
sense
and
we
talked
about.
Maybe
it
makes
sense
for
any
and
all
cases
that
evaluate
the
truth
to
schedule
the
next
activity.
A
D
D
B
D
A
At
least
it
gives
the
options
we
could
always
consider
allowing
the
the
implementer
the
developer
to
configure
if
this
is
an
available
option
to
the
users
or
not
that
we
will
have
to
see,
but
maybe
for
now
giving
these
options
makes
sense.
Then
we
can
gather
some
feedback
once
it's
used
by
by
actual
users
to
see
if
it's
too
complicated
or
if
there's
other
complaints
about
that
and.
A
Way
to
split
the
execution
into
multiple
branches,
the
switch
allows
you
to
split
into
one
or
more
branches
using
these
expressions,
but
from
any
outcome
here
from
any
port.
You
can
add-
or
you
can
create
multiple
connections
like
here
and
here,
but
in
this
case
you
you,
don't
you
don't
control
which
connections
are
evaluated
next
because
they
will
all
be
evaluated
so
from
this
flow
switch
example.
Here,
the
right
line
will
be
scheduled
as
well
as
the
flow
decision
here.
Both
will
execute
next
and
the
switch
and
or
and
or
the
flow.
B
Yeah,
I
actually
had
to
listen
to
that.
Regarding
that
switch,
they
were
designing
a
workflow
and
they
said
yeah.
Now
I
have
to
do
an
if
and
then
an
if
and
then.
If,
because
it
can
evaluate
to
multiple
items,
I
rather
have
a
switch
which
makes
the
workflow
way
nicer
to
see
just
having
a
lot
of
ifs
in
sequence
after
one
another,
they
opted
for
the
in
elsa
ii.
It
was
remote
match,
annie
if
the
match
first
approached.
Okay,.
B
A
A
Got
it
all
right,
very
cool
cody,
since
this
is
your
first
attendance,
let
me
just
briefly
introduce
you.
I
cody
is
managing
our
elsa
discord,
server,
he's
responsible
for
creating
these
nice
we're
assigning
these
nice
little
icons
and
organizing
the
things.
So,
thanks
for
doing
that,
that's
improving
the
discord
experience.
I
think
a
lot
yeah.
D
D
Does
anybody
have
any
experience
in
creating
discord
thoughts,
because
I
found
a
lack
of
support
bots,
for
instance,
all
these
questions
that
we
get
in
discord
if
we
can
have
a
thing
that
can
listen
for
questions
and
it
could
suggest
to
the
user?
Would
you
like
to
create
a
thread
or
use
an
actual
bot
to
create
an
issue?
Then
you
can
export
that
directly
to
github
or
reddit
or
into
a
document
or
an
actual
spreadsheet.
Anything
like
that,
so
you
can
at
least
have
things
you
know
well
organized
because
currently
it's
it's.
A
All
over
the
chat,
oh
yeah,
so
my
nephew
told
me
once
that
it
should
be
possible
to
build
a
knowledge
base
based
on
information
that
we
provide.
So
somebody
let's
say
somebody
asks
questions.
I
answer
the
question.
What
I
should
do
is
put
that
question
in
some
wiki,
for
example,
then
a
bot
can
query
this
wiki
and
automatically
provide
an
answer
to
a
user
who
asks
a
question
that
has
been
asked
before.
So
it
uses
some
sort
of
machine
learning,
algorithms
to
try
and
actually.
A
D
The
first
thing
is
just
to
get
all
these
questions
and
their
answers
that
you
provide
into
you
know
organized
same
spot
because,
right
now
a
lot
of
information
is
not
going
to
say
it's
going
lost,
it's
still
in
the
chat,
but
like
getting
all
of
that
answers
and
questions
out
of
the
chat
into
a
structured
format.
That's
an
actual
job.
That's
what
someone
has
to
do
full
time
for
quite
a
while
to
to
just
get
that
together.
So
the
sooner
you
can
get
something
like
that
going
more
time,
it'll
save!
Do
you.
A
D
What
I'm
looking
into
if
we
can
find
a
bot
that
can
actually,
you
know,
write
and
store
data
or
read
from
that,
then
yes,
that'll,
be
the
easiest.
Otherwise,
I
guess
the
local
storage
on
your
site
would
be
the
best
option,
as
the
second
option
just
to
get
it
somewhere
yeah
for
now.
So
I'll
look
into
those
two
things,
but
if
anybody
has
any
suggestions,
that'll
be
super
cool
and
then
I
can
get
this
sorted
quickly.
Awesome
those
switch
cases.
D
A
It
no
not
exactly
a
c-sharp.
The
implementation
is
actually
quite
straightforward.
Let
me
just
walk
you
through
it
quickly,
so
here
let's
say
I
have
three
cases.
The
most
simplest
of
conditions
are,
of
course,
boolean
literals
so
like
this,
but
since
these
are
javascript
expressions,
they
could
also
be
something
like.
Let's
say
I
have
a
variable
called
variable,
one
with
a
say:
it's
a
numeric
value.
This
is
a
z
index
issue
here.
Let
me
see
if
I
can
just
hit
enter
okay.
A
We'll
find
the
matching
case,
which
is
a
private
method
here,
for
that
it
uses
the
expression,
evaluator
and
then
basically
for
each
case,
which
is
an
array
of
switch
case
objects
here,
which
has
the
well
just
the
label,
the
condition
which
represents
the
javascript
expression.
In
this
example,
each
one
will
be
evaluated,
but
as
soon
as
it
finds
a
match,
that
switch
case
will
be
returned
as
a
matching
case
and
then
its
associated
activity
will
be
scheduled.
A
D
One
more
question
regarding
the
switch,
so
if
let's
say
the
parent
activity
or
event
block
is,
is
is
active
and
it
evaluates
and
and
this
event
block
has
a
switch
with
three
results.
One
of
those
results
are
depending
on
a
parallel
or
child
process
to
come
back,
but
it
doesn't
come
back
in
time,
but
another
line
evaluates
to
true
it
fires
off.
Will
this
activity
be
able
to
activate
it
again
once
the
child
process
or
sub-process
returns
with
the
result?
I'm.
A
D
D
A
D
D
A
Yeah,
okay,
so
the
way
it
works
right
now,
let's
say
we
have
case
one
and
it
does
something
simple
like
it
writes
some
text
and
then
we
have
the
second
case,
and
here
we
are
gonna,
do
some
work
and
it's
in
this
case
it's
a
delay
which
could
be
seen
as
a
background
job,
because
it
is
what
will
happen
here.
This
will
actually
cause
the
workflow
to
become
suspended
unless
there's
other
work
executing.
So
let
me
just
add
another
task
here.
B
A
Now
this
one
is
a
right
line.
Oh,
it
doesn't
update
this
thing,
that's
a
bug,
so
this
is
a
write
line.
This
is
a
some
process,
a
job
or
whatever,
and
this
is
another
right
line.
So,
let's
imagine
all
three
cases
will
match.
So
it's
all
they
all
evaluated
through.
That
means
the
right
line
will
execute.
The
delay
will
execute,
but
it
will
schedule
a
timer
using
quartz.net
and
this
one
will
execute
so
all
three
will
have
executed,
but
this
switch
contains
a
delay
activity
or
a
job
activity
that
causes
the
workflow
to
be
suspended.
A
There's
no
more
work
to
be
done
and
there's
a
blocking
activity
in
the
form
of
the
delay.
In
this
example,
now
the
workflow
instance
gets
suspended
until
the
timer
triggers
or
the
job
finishes.
Then
the
workflow
entries
will
be
resumed.
This
switch
will
not
evaluate
case
1,
2
and
3
anymore.
It
will
continue
with
whatever
workflow
is
going
on
here.
So
maybe
it
continues
with
this
work.
Another.
A
Doesn't
matter
once
this
case
is
done,
then
whatever
comes
next
after
the
switch
continues.
So
to
recap,
when
this-
let's,
let
me
add
this
one
here,
so
let's
say
this
is
the
start
of
the
workflow
goes
into
the
switch
one
two
and
three
will
execute,
but
in
two
we
know
there's
a
delay.
So
that
means
the
entire
workflow
is
waiting
on
that
delay.
A
In
this
example,
once
that
resumes
control
yields
back
to
the
switch
which
is
not
gonna,
evaluate
all
the
conditions
anymore,
it
already
did
that,
but
it's
gonna
complete
itself,
which
then
instructs
the
containing
flow
chart,
which
is
also
an
activity
to
schedule.
The
the
next
one
because
of
this
connection
here,
does
that
make
sense,
yeah
all
right,
cool,
yeah
and,
of
course,
here
I'm
using
the
sequential
switch,
but
we,
of
course,
with
the
flow
switch
instead
of
having
these
embedded
things,
it
would
be
well.
A
Let
me
just
take
the
if
else,
as
you
know,
as
a
simplified
example
of
a
switch,
so
this
decision
here
so
here
we
don't
have
nest
activities
but
just
two
outcomes,
and
here
we
could
have
a
delay.
This
is
not
a
perfect
example,
of
course,
because
here
either
it's
true
or
it's
false,
but
if
we
imagine
for
a
second
that
this
is
a
switch
overflow
switch
and
both
evaluated
through
then
it
worked
as
follows.
A
First,
this
one:
well,
we
don't
know
what
to
evaluate
first,
but
let's
say
this:
one
evaluates
first
we'll
write
the
line
and
then
execute
this
one,
and
then
it
will
schedule
the
delay,
wait
for
an
x
number
of
seconds
or
minutes
or
days
or
weeks
or
years,
and
once
this
is
done,
then
this
one
will
evaluate
and
that
will
then
finish
the
workflow
but
a
question
for
you.
We
had
a
discussion
last
week
about
the
following
scenario:
let's
say:
have
it
like
this
and
then
we
do
it
like
this
we'll
place
this
one.
A
We
have
a
starting
right
line
and
then
it
has
two
connections.
One
connection
goes
to
this
right
line,
and
another
connection
goes
to
the
delay.
So
as
a
user,
what
would
you
expect
to
happen?
Would
you
expect
to
for
this
right
line
to
execute
once
or
twice
when?
Actually,
when
this
workflow
executes.
D
A
D
A
D
A
For
you
to
yeah
exactly
so
in
this,
this
is
what
we've
discussed
last
time.
I
wasn't
sure
to
me:
it
made
sense
as
a
developer,
because
I
implemented
the
ncna
and
if
I
follow
the
logic
the
way
this
works
it
indeed,
it
schedules
rightline
and
right
line
as
well,
this
the
both
of
them
and
they
both
connect
to
this
one.
So
to
me,
it
made
sense
that
right
line
executes
twice.
A
D
A
A
Maintenance
maintenance
here,
maintainers
right
yeah
so
well,
I
did
a
little
bit
of
research
and
he
noticed
that
when
this
flowchart
executes
both
of
these
execute
in
parallel-
seemingly
I
am
not
convinced
yet
they
actually
are
executed
in
parallel.
I
will
look
into
that,
but
regardless
the
delete
activity
executes
once
so
this
is
the
flow.
So
it's
I
guess
it
goes
from
data
flow,
one
so
from
bottom
to
top
this
one
first
then
copy
data,
one
copy
data,
one
copy
one,
this
one
and
then
delete
once
so.
Somehow
here
is
a.
A
D
So
the
thing
is
that
I've
seen
you
know
making
a
product
for
an
end
user
of
I
don't
know
what
your
target
market
is
for
skills,
but
making
it,
for
you
know
more
user-friendly
means
more
people
want
to
use
it.
So
from
that
perspective,
if
you
would
make
all
of
these
events
inherently
a
join
okay,
well,
not
all
of
them.
I
mean
it
can't
take
all
of
these
things
in
in
consideration.
D
If
you,
if
you
run
a
parallel
line
or,
like
I
said
earlier,
a
sub
process
again,
it's
a
bit
difficult,
but
the
engines
I've
worked
with
somehow
got
it
right
to
all
all
event.
Blocks
are
inherently
joined,
so
if
you
connect
three
lines
to
one
event,
it'll
know
that
it
needs
to
wait
for
for
these
lines.
Okay,.
A
D
D
A
B
On
that-
and
maybe
we
should
also
look
at
the
example
that
I
created
to
have
this
discussion,
because
I
thought
in
the
beginning
as
well:
yes,
let's
do
just
this
and
make
a
default
same
behavior
and
you
can
run
in
so
many
different
scenarios
where
you
have
joins
that
aren't
coming
from
the
same
source,
eventually
or
loop
half
of
the
things
loop
back.
What
do
you
do
then,
or
have
for
each
loops?
B
There
are
a
lot
of
things
that
you
have
to
take
into
consideration,
whether
or
not
you
want
to
proceed
or
have
to
wait
for
the
sub
processes
or
the
activities
that
were
scheduled
to
wait
for
them
all
or
just
to
proceed.
So
yeah
that's
going
to
be
interesting
discussion.
What
is
the
default
value
or
the
default
behavior,
and
if
we
allow
it
to
be
overwritten
or
not,
do.
B
E
A
E
A
E
No,
no,
no,
no,
no!
No
it
just
it
just
doesn't
allow
the
loops
at
all
and
for
obvious
reason,
because
things
become
very
complicated,
because
I
think
a
simple
implementation
is
just
to
keep
some
flag
for
each
activity,
whether
it
executed
or
not.
If
it
is
already
executed,
and
you
and
again
it
gets
triggered
from
another
branch.
You
can
just
skip
it,
because
you
can
maintain
that
I
have
already
executed.
But
if
you
have
a
loop,
then
it
becomes
really
complicated
how
to
clear
that
flag
or
how
to
know
from
where
you
are
arrived.
Yeah.
B
C
B
But
let
me
share
it
once
that
I've
used
to
so.
Basically,
this
is
the
flow
that
I
use
to
determine.
Okay
is
my
algorithm.
Okay,
and
this
is
in
the
bpmn
notation
from
kavimo.
Is
it
maybe
I
make
it
a
bit
bigger?
So
so
you
have
a
starting
point
and
an
endpoint,
and
you
have
a
couple
of
activities.
The
intent
of
the
activities
doesn't
really
matter,
except
for
this
one.
This
is
a
loop,
and
so
when
you
start
the
first
one
is
quite
obvious.
B
This
one
will
get
executed
then
immediately
it
forks
into
two,
so
a2
and
a6
and
a2
is
in
loop
over
and
collection,
which
let's
say
it
has
two
items
in
it
and
for
each
item.
It's
gonna
activate,
a3
and
a4,
and
then
the
tricky
thing
is
what
is
a5
gonna?
Do
we
would
say
wait
for
all?
Does
that
mean
that
it
needs
to
wait
for
all
the
items
and
that
are
executed
for
a3
and
a4
in
the
loop
of
a2?
I
think.
D
It
should
be
a
three
four
and
sorry
if
I
can't
see
the
bottom
ones
at
a
six
yeah.
This
is
six,
that's
my
opinion,
because
it
should
be
aware
of
the
lines
that's
directly
connected
to
it.
If,
if
it
should
wait
for
something
as
far
as
the
loop,
I
think
the
loop
should
have
an
id
and
a
value,
and
in
i5
you
can
configure
it
to
only
continue
once
a2
is
satisfied,
like
I
said,
extra
mm-hmm
extra
steps
to
make
this
happen.
A5.
B
D
A
That's,
okay!
That's
all
right!
So
so
this
is
the
the
nice
thing
about
elsa
3
we
get
to
well.
It
is
already
a
major
refactoring.
In
fact
it's
a
rewrite
from
elsa
too.
So
it's
completely
different.
So
we
have
this
opportunity
to
get
as
perfect
as
possible
and
and
to
as
close
as
other
engines
out
there
as
possible.
So
it's
good
to
try
and
identify
what
the
big
players
are
doing
and
learn
from
them.
I
mean
if.
D
I
can
make
a
suggestion
to
to
what
could
really
change
how
all
of
this
works.
If
you
allow
custom
variables
to
exist
as
as
global
to
the
whole
workflow,
and
you
can
associate
those
variables
to
any
of
these
events.
Those
events
can
interact
with
that
variable.
The
same
way,
any
kind
of
loop
interacts
with
its
iterator
or
an
array,
or
whichever
it
reads
from
then
you
get
to
control
these
loops
a
little
bit
better.
D
I
think,
then,
you
can
have
your
I
your
I
plus
plus
you
can
have
all
those
things
configured
hard-coded,
for
instance,
if
you
would
configure
number
a5,
you'd
assign
loop
count
or
just
just
count
to
it
when
you
say
count
plus
plus
and
on
cue
one.
You
can
then
say.
Is
I
equal
to
10?
If
it
is
go
to
e1?
If
not
follow
c9
back
to
a2,
then
the
loop
will
sort
itself
out.
One
run
yeah.
B
That's
true,
but
the
difficulty
is
then,
when
you
configure
something
that
a5
needs
to
listen
to
as
a
variable.
That
is
global
for
the
instance,
and
that
is
executing.
That
means,
whenever
you
go
back
from
q1
through
c9
back
to
a2.
You
have
to
be
aware
of
that
and
that
you
then
somehow
reset
something
in
order
to
continue.
B
Otherwise
it
will,
for
instance,
in
the
first
iteration
have
that
variable
set
to
two,
because
it
has
two
iterations
and
when
you
go
back
it
is
already
set
to
two
and
when
it
comes
to
a5,
it's
already
at
four
at
that
point.
So
there
is
a
lot
of
yeah,
it's
more
like
programming
than
that.
You're
designing
a
workflow,
and
I.
B
Of
this
a5
to
have
like
a
property
to
say
how
it
should
continue
and
it
could
be
like
whenever
something
activates
it
just
execute,
it
always
execute.
Basically,
and
then
you
have
the
option
to
say,
wait
all
which
makes
it
wait
for
all
the
events
to
complete,
which
makes
for
each
iteration
of
a2.
It
will
wait
as
well.
So
if
this
has
two
items,
then
a3
and
a4
can
be
executed
twice
and
it
will
wait.
B
Both
of
them
are
finished,
including
a6,
and
then
it
will
continue
and
the
last
option
is
weight
any
which
makes
like
okay.
The
first
arrive
I
will
execute,
and
even
though
these
aren't
finished,
whenever
one
gets
finished
and
s
hits
the
a5,
it
will
not
execute
a5
again
because
it
was
already
executed.
But
then
the
tricky
part
is
okay.
What
if,
after
the
first
time
you
go
up?
What
do
you
then
do?
The
second
time
is
that
then
re-evaluating
the
a5
and
does
it
exclude
a6
as
well?
B
A
Exactly
so,
maybe
in
my
mind
at
least
and
correct
me,
if
you
think
I'm
wrong,
is
that
from
a
user's
point
of
view,
it
might
be
intuitive
what
should
happen.
So,
let
me,
let
me
explain
what
I
think
makes
sense
for
it
to
happen
and
then,
as
a
separate
item,
we
can
of
course
talk
about
the
technical,
implement
the
technical
implications
on
how
to
implement
this.
But
to
me
it
seems
logical
that
a6
executes
only
once
always
in
this
workflow
from
start
to
end.
C
A
B
E
A
That's
right
for
this
one
indeed,
so
the
for
each
sequential
activity
will
not
have
the
issue
because
everything
is
contained
within
the
body.
I
would
totally
like
to
support
this
kind
of
looping
construct
as
well,
so
this
would
maybe
be
a
flow
loop,
let's
say,
and
it
only
loops
if
you
explicitly
loop
back
into
it
in
this
example
on
france's
screen
through
the
c9
connection,
because
it
looks.
B
A
A
A
E
E
A
E
E
A
A
So
I
think
the
activity
itself,
of
course
it
is
a
loop
and
the
first
time
you
enter
through
c2.
It
will
evaluate
its
condition,
so
it
will
take
the
first
item
of
the
list
in
the
case
of
a
for
each
construct,
then
it
will
go
on
to
c4
and
c5
all
the
way
to
q1
and
then
it's
up
to
q1
whether
it's
gonna
move
back
in
through
c9
into
the
loopy
construct.
If,
if
you
remove
c9,
nothing
bad
should
happen,
it
will
just
go
straight
to
e1
and
that's
fine.
It's
a
send.
It's
not.
A
B
A
B
B
D
C
D
So
that's
the
risk
that
they
carry.
If
anything
I
mean
there
could
be
certain
checks
to
let
a
user
know
be
careful.
This
thing
might
run
away
and
that's
enough,
if
that's
not
a
concern,
then
I
would
say
the
only
thing
here
that
actually
has
to
even
care
from
where
or
what
line
or
what
event
it
comes
from
is
the
final
one.
It
should
just
check
how
many
times
should
this
loop
run
yeah,
but.
B
The
problem
lie
and
doesn't
lie
in
how
many
times
the
loop
must
run
it
and
needs
to
think
about
this.
Take,
for
example,
that
a3
and
a4
are
basically
approval
user
tasks
and
the
two
people
can
approve
it,
which,
let's
make
it,
let's
make
it
a
user
task,
and
this
is
also
a
huge
task.
What's
this
is
gonna,
send
the
mail
back
to
the
customer
and
say
you
are
approved,
okay,
what
you
you
need
to
then
be
configured
like
this
is
the
the
manager.
C
B
Says
always
approve
and
one
over
two
other
employees
need
to
approve
as
well.
What
you
don't
want
to
have
is
that
an
effort
a2
is
executed
and
a
three
says
approve,
and
it
sends
the
confirmation
to
the
customer.
Never
a4
proves
as
well
that
another
approval
is
sent
to
the
customer,
so
you
have
to
have
to
be
in
control
of
when
to
send
this
either
always
either.
I
think
any
of
those
any.
D
B
D
D
E
Implementation
point
of
view:
what
we
can
do
is
that
we
just
need
to
keep
a
flag
for
each
activity,
whether
it
excluded
or
not,
but
then
the
extra
thing
that
we
need
to
do.
For
example,
when
you
loop
back
to
a2,
then
we
need
to
clear
the
flag
for
all
the
depending
activities
all
the
way
so
so
first
pass,
we
will
flag
that
a6
is
completed
and
it
will
remain
completed
and
then
once
we
reach
a5
again
it
will
complete.
When
we
loop
back
to
c9,
then
we
need
to
clear
a2.
E
A
A
flag
in
some
one
way
or
another,
then
we
can
have
so
in
also
two.
We
have
this
join
activity
that
simply
looks
for
any
activity
that
completed
before
continue,
yes
or
no,
so
that's
the
the
weight
any
or
weight
all
right,
and
then
this
way
the
user
can
control
whether
they
want
to
wait
for
the
first
approver
or
wait
for
all
approvers
to
approve.
C
Just
just
one
thing
for
me:
as
a
user,
I
would
like
to
see
directly
if
I
want
to
wait
for
all
event
or
not,
so
I
think
we
have
to
choose
a
standard.
For
example,
we
we
have
to
wait
for
all
previous
events,
and
if
you
want,
for
example,
to
wait
for
any
of
c6
or
c7,
we
have
to
add
another
shape
to
to
wait
for
any
then
link
this
new
shape
to
a5.
What.
C
B
The
bpmn
to
have
it
like
this,
and
you
have
this.
Basically,
when
you
have
a
fork,
you
have
also
have
an
implicit
join
that
is
related
to
this,
even
if
you
have
multiple
ones
like
this
make
it
pretty.
If
you
have
like,
so
you
want
to
have
another
fork
that
you
even
have
to
do
it
like
this
away
and
have
an
explicit
joint
specifically
for
that
one.
So
each
fork
needs
to
have
a
counterpart
in
the
joint.
That's
the
bpmn
recommended
notation.