►
From YouTube: Elsa Workflows Community Meeting 25
Description
Topics
- Workflow query
- CI/CD
- Bookmark system
Demos
- Workflows as activities
- Run child workflow
Bugs:
- Workflow with two starting triggers (e.g. HttpEndpoint) doesn't work as advertized
- How to return output from composite activity?
- Publish workflow is hanging
A
B
A
A
C
A
B
A
It's
possible
and,
let's
see
so
I'll
move
you
out
of
the
way
close
this
one
all
right.
So
let
me
first
remove
these
two.
All
right,
so
I
want
to
show
the
ability
to
use
the
word
for
designer
to
create
a
composite
activity,
and
so
it
will
be
stored
as
a
word
for
definition,
but
then
it
will
be
usable
as
a
composite
activity
in
other
workflows
and
as
I've
shown
last
time.
The
process
is
very
simple
people
also.
Let's
say
we
want
to
create
a
reusable
activity.
A
Codes,
greeter
and
the
purpose
of
the
greater
activity
will
be
to
just
cancel
right
line,
somebody's
name,
and
then
the
key
will
be
of
this
demo
to
make
that
name
parameterized.
So,
of
course
we
can
just
hard
code,
any
name
here
we
could
say
hello
Alice.
You
would
name
this
activity
or
this
workflow
with
name
it's
the
greeter
activity
and
in
settings.
This
is
this
is
important
in
order
to
be
able
to
use
this
workflow
as
an
activity.
This
needs
to
be
set
to
go.
A
We
see
a
new
category
called
workflows
and
then
here
is
the
activity
that
we
have
here
on
the
designer.
So
if
we
now
go
and
create
a
new
workflow
and
we'll
just
call
this
workflow
one
we'll
add
greater
and
publish
this
one,
then
we
can
take
this
definition
ID
so
that
we
can
invoke
it
from
the
using
the
rest
API.
We
received
an
instant
ID,
so
that's
a
good
indication
that
the
workflow
executed
and,
of
course
we
are
using
the
right
line
activity,
which
means
we
need
to
switch
to
the
application
console.
A
And
here
we
see
the
message
being
printed
and
because
we
have
this
as
an
activity,
it's
now
easy
to
invoke
it
as
many
times
as
you
want,
which
of
course,
is
the
the
big
benefit
being
able
to
create
these
quote
subroutines
using
the
designer
and
then
use
them
elsewhere.
So
now,
I've
connected
the
Buns
together
I'll
execute
again
and
now
we
see
three
right
line:
outputs,
nothing
new
in
that
regard
compared
to
last
week,
but
what's
new
is
the
ability
to
parameterize
the
the
decomposite
activity.
So
let's
switch
back
to
the
greeter
workflow.
A
So
what
we
want
to
do
is
we
want
to
make
this
Dynamic.
So
in
order
to
do
that,
you
may
have
noticed
when
I
switched
usable
as
activity
to
yes,
this
tab
appeared
the
activity
tab
and
this
allows
you
to
define
the
inputs
and
the
outputs.
So
if
we
let's
say
we,
we
ask
for
a
person
name
that
will
be
the
name
of
the
argument,
the
technical
name,
then
the
type
would
be
string
and
then
a
display
name
or
user
friendly
name
which,
which
would
be
maybe
just.
D
A
And
put
a
description,
we
enter
something
like
the
name
for
the
person
to
create
all
right.
Now
that
we
have
this,
we
should
be
able
to
switch
this
to
JavaScript
and
then
use
a
JavaScript
expression
where
we
say
get
oh
get
person
name
so
I
need
to
figure
out
how
to
refresh
the
intellisense
type
definitions.
That's
that
are
being
generated
because
it
it
will
be
using
the
person
inputs
that
are
available,
but
yeah,
it's
not
updated.
Yet
I
will
probably
have
to
refresh
the
screen.
A
Actually,
let's
just
try
it
like
this
so
now
here
it
is,
but
because
Monaco
editor
was
already
initialized.
It
didn't
fetch
this.
So
probably
we
can
trigger
that.
Somehow.
That
will
be
a
good
Improvement,
but
in
any
case
now
we
can
use
this
inputs
in
this
JavaScript
expression.
We
publishing
updates
now
when
we
switch
back
to
the
workflow
the.
Currently
there
is
a
limitation
in
the
sense
that
this
greater
activity
instance,
it's
pinpointed
to
the
version
of
the
workflow
definition,
the
greater
word
for
definition.
A
At
the
time
it
was
instantiated
here
on
the
designer,
so
that
means
it
will
not
show
any
updated
settings.
So
now
I
will
have
to
recreate
these
activities.
Obviously
we're
gonna
fix
that
in
a
subsequent
iteration,
so
that
you
either
have
the
choice
to
always
use
the
latest
one
or
explicitly
up
create
these
activities
to
point
to
the
latest
version
Maybe
by
having
a
version
tab
allowing
you
to
see
which
version
you're
pointing
to
and
then
the
ability
to
point
to
the
latest
version,
for
example,
or
a
previous
version
for
that
matter.
A
But
until
then
let
me
replace
this
and
add
these
again.
So
now
we
can
say
now
we
see
the
name.
That's
the
argument.
We
created
the
input
parameter.
So
let's
call
this
one
Alice
this
one
blob
and
this
one
would
be
Chris
and
then
now
supposedly,
when
we
execute
this
one,
we
should
see
these
different
person
names
being
greeted
so
I
think
that's
a
very
nice
update
because
well
it
unlocks
a
lot
of
use
cases
for
having
this.
What.
B
A
A
A
Can
be
cases
where
you
have
multiple
or
maybe
you
just
want
to
move
these
temporarily
out
of
the
way
troubleshoot
something,
but
then
you
will
want
to
explicitly
control
which
one
is
the
starting
activity.
So
I,
let's,
let's
see
if
it
works.
Actually,
let's
uncheck
this
one
and
if
you
have
more
than
one
checked
it
will
take
the
first
one
programmatically.
However,
you
can
control
which
activity
you
use
to
start
with.
If
you
invoke
the
rest
API,
there
will
be
an
option
for
you
to
provide
the
activity
ID.
A
Yeah
for
sure,
so
let's
say
you
have
an
HTTP
endpoint
and
maybe
you
also
have
I,
don't
have
the
messaging
activities
enabled,
but
second
HTTP
yeah.
It
could
be
a
second
one
yeah,
so
you
would
have
end
points
one.
You
can
start.
This
is
important.
This
needs
to
be
checked
and
the
same
goes
for
this
one.
This
will
be
endpoint
two
and
let's
connect
to
this
one
to
this
one
and
this
one
to
this
one
like
so
so
this
should
work.
I
haven't
tested
it
in
a
while.
A
But
let's,
let's
see
what
happens
so
we
publish
this
one
and
now,
let's
first
try
HP
endpoints,
hello
Alice,
but
it's
spinning
for
some
reason.
So
it
did
invoke
this
one,
but
for
some
reason
it
it's
it
didn't
complete.
So
I
need
to
troubleshoot
what's
going
on
here,
but
that's,
but
that's
how
it's
going
to
work
and
then
for
endpoint2.
Let's
cancel
this,
yes,
yeah
I
need
to
figure
this
out.
This
is
not.
This
is
not
right.
It
should
go
with
the
of
course.
It
should
start
with
this
path.
Okay,
but
yeah,
good
question.
A
This
is
something
to
for
me
to
to
fix
all
right
yeah
so
that,
basically
it
for
the
workflows
with
activities,
I
didn't
show
the
ability
to
return
an
output.
Maybe
that's
that's
a
thing
to
try
as
well:
let's
create
another
activity
that
maybe
is
called
the
sum,
so
it
will
take
two
input,
arguments
and
return
the
sum
of
the
two
inputs,
so
let's
say
we'll
just
call
it
a.
D
A
A
Yeah,
so
we
would
say,
return
get
a
plus
get
B,
but
actually
it
should
not
be
returned.
We
want
to
set
it
to
this
output
I
wonder
if
I
actually
created
a
activity
to
to
do
it
like
this,
because
I
I
don't
do
I,
have
a
JavaScript
set
now
I,
don't
know
we're
going
to
set
output.
So
what
what
is
missing
right
now
to
to
make
this
work
is
a
function
to
set
the
output
because
I
I
think
I
tested
this,
but
now
I'm
I'm
wondering
how
how
how
I
did
test
it.
A
A
Yeah,
well,
that
would
only
affect
the
variables
here.
Okay,
you
cannot
set
the
output,
but
in
any
case
the
the
point
is
clear:
yes,
so
you
this
will
allow
you
to
actually
create
kind
of
functions
in
the
form
of
workflows
and
I
will
fix
that.
There's
someone
in
the
lobby
just
Alice
brother,
all
right!
So
all
right,
then
this
one
being
able
to
run
a
child
workflow
clean
this
up,
then
look
start
by
creating
a
child's
workflow.
It
will
have
three
activities.
This
one
will
say
child
star
art.
This
will
wait
for
two
seconds.
A
It
will
be
blocking
and
the
difference
between
non-blocking
and
blocking
is
that
if
you
select
blocking
the
delay,
activity
will
actually
create
a
bookmark
which
will
then
cause
the
workflow
instance
to
be
suspended
until
the
this
time
span
is
reached
and
then
whatever
scheduler
is
used,
will
then
resume
the
workflow.
That's
the
strategy
but
and
that's
very
useful
for
longer
durations,
but
for
sure
durations.
Maybe
you
just
want
to
use
non-blocking,
which
means
it
will
not
be
suspended.
It
will
just
use
actual
c-sharp.
You
know.net
task
that
DeLay
So.
A
B
A
B
A
Yeah
good
question:
no
so
because
the
the
workflow
Runner
executes
one
activity
at
the
time,
so
there's
no
parallelism.
It
indeed
means
if
this
one
is
being
delayed.
None
of
the
other
branches,
if
there
were
any
branches,
will
execute
so
it
will
block
the
entire
workflow.
That's
a
good
observation.
Okay,.
B
A
Yeah
so
I
don't
know
it's
a
it's
a
great
question:
I
don't
know,
but
but
I'm
leaving
it
up
to
the
user.
So
if
you
set
this
one
to
Auto,
then
you
can
don't.
You
can
just
not
care
about
it
and
then
the
by
default
I
think
it's
configured
that
if
the
time
span
is
five
seconds
or
below
it
will
use
the
non-blocking
one.
So
basically
I'm
going
to
change
these
names.
There
are
not
very
intuitive,
but
then
it
will
just
do
a
task
that
delay.
A
If
it's
higher
than
the
five
seconds,
then
it
will
create
a
bookmark
and
and
to
be
clear.
This
is
an
experimental
bit
of
functionality,
because
maybe
it
turns
out
to
be
utterly
useless.
If
you
have
workflows
with
multiple
branching
and
then
you
probably
don't
want
to
be
blocking
all
of
the
other
executions
or
activities
I
mean
in
any
case,
for
this
demo
doesn't
matter,
although
I
I
do
want
to
show
that
it
this
this
child
activity
or
child
workflow
being
called
also
works.
A
Fine
when
it
has
bookmarks
being
created
so
I'm
going
to
use
blocking
two
seconds
and
then
chance
done
all
right.
So,
let's
publish
this
child
and
then
here's
the
parent
workflow
and
for
the
parent
to
to
run
a
child
workflow
there's
a
new
activity
called
dispatch,
dispatch
workflow,
and
it
has
fourth
definition:
ID,
which
is
going
to
be
changed
to
just
workflow
definition
or
maybe
a
workflow,
and
it
allows
you
to
select
one
of
the
children.
A
I
have
to
make
a
small
change
here
so
that
it
doesn't
select
a
workflow
by
default,
because
it's
important
that
you
consciously
select
the
child,
workflow
plus
there's
a
bug
at
this
moment
where,
if
it's
the
the
default
selection
here,
it's
not
actually
picking
up
this
value.
So
when
I
submit
this
form
to
the
server,
the
value
will
be
an
empty
string.
So
that's
a
separate
bug
that
I
need
to
fix
to
work
around
that
for
now,
I'm
just
gonna
create
yet
another
workflow
called
workflow
one.
So
it's
back
of
course,
id2
publish.
A
So
if
I
publish
this
one,
it's
also
good,
then
I
just
change
it
temporarily
to
parent
which
is
itself
and
then
back
to
child.
So
it's
a
silly
workaround,
but
it
works
for
this
demo.
This
is
this
option.
Wait
for
completion
allows
you
to
do
the
following.
So
let's
say
you
have
this
workflow
right
line,
execute
the
child
workflow
and
then
another
right
line.
So
this
would
be
parent
start
parents
and
all
right.
A
So
if
we
were
to
execute
this
workflow
chances
are
that
you
will
read
parent
start,
then
parent
ends,
and
then
you
would
see
a
child
start
and
two
seconds
later.
The
other
right
line,
because
this
activity,
without
this
being
checked,
will
not
wait
for
completion
of
the
child
workflow.
But
let's
see,
if
that's
how
that
works
all
right.
So
as
we
can
see,
parent
start
and
parent
end,
not
sure
why
the
child
one
isn't
executing.
Let's
see
what
happens
if
I
check
this
one
parent
star,
jels
our
children,
all
right.
A
A
A
That
that
will
actually
fix
it.
Because
of
this
reason,
if
you
look
at
the
dispatch
workflow,
let
me
try
and
zoom
in
implementation.
It
imp,
oh
yeah,
okay,
oh
my
God,
all
right!
Let's
try
it
like
this,
so
the
the
activity
implements
an
interface
called
I,
bookmarks,
persisted
Handler
and
I'll.
Explain
it
briefly.
First,
let's
take
a
look
at
the
execute.
A
Async
implementation
is
as
follows:
if
we
want
the
the
child's
workflow,
if
we
want
to
wait
for
the
child
workflow
to
be
completed,
then
what
it's
going
to
do
it's
going
to
create
a
bookmark
and
that's
it.
So
it's
not
going
to
do
anything
else.
It's
it's
just
going
to
create
a
bookmark
with
some
payloads
of
the
child
instance
ID.
So
we
are
generating
child
in
society
and
then
we
create
a
bookmark
and
that's
it.
So
it
doesn't
do
anything
else.
A
If
we
have,
if
we
don't
check
this
one,
then
it
will
actually
complete
the
activity
immediately.
So
it's
it's
not
even
gonna
execute
the
child's
activity.
The
child
workflow
I
should
say-
and
the
reason
is,
is
that
the
reason
it
works
when
make
checking
that
checkbox
is
because
we
create
a
bookmark
and
because
we
implemented
this
interface,
bookmarks
persisted
Handler,
which
is
implemented
here.
A
A
If
this
finishes
even
before
this
current
execution
pipe
completes,
which
also
means
before
the
bookmark
were
but
bookmarks
were
created,
then
there
will
be
no
way
for
the
for
the
workflow
completion
Handler,
which
is
which
sits,
which
I
will
show
in
a
second
to
find
this
workflow,
because
the
bookmark
isn't
there
in
the
persistence
layer.
Yet
and
to
prove
to
circumvent
that
this
activity
will
dispatch
the
child's
workflow
only
after
the
bookmarks
have
persisted
and
that
Handler
that
I
just
mentioned
lives
here.
A
So
there's
a
dispatch,
workflow
request,
Handler
and
basically
it's
a
mediator
Handler
that
handles
the
sorry,
that's
the
wrong
one.
This
one
I
was
looking
for
resume
dispatch
workflow
it
handles
a
notification
of
workflow
executed,
so
I
imagine
the
child
workflow.
We
got
dispatched
it
executed
and
then
it
completed.
Then
this
Handler
will
actually
it
will
info,
be
invoked
anytime,
any
workflow
executes.
Here
we
are
going
to
check
if
the
status
is
finished,
if
not
we're
going
to
return.
A
By
this
thing,
of
course,
in
this
example,
there
would
just
be
one
and
then
they
should
always
only
be
one
when
using
the
the
dispatch
workflow
activity,
but
this
is
the
mechanism
of
being
used,
but
this
will
only
work
if
that
bookmark
created
by
the
dispatch
workflow
activity
was
actually
stored
in
the
resistance
layer.
So
the
fix
actually
is
should
be
straightforward.
A
Now,
let's
execute
this
one,
and
we
got
a
bit
of
an
error
that
given
child's
instance,
oh
yeah,
of
course
I
still
do
need
to
create
my
child
instance
ID
yeah
there
you
go
so
parent,
star
parent
ends
and
then
the
child's
workflow
had
a
chance
to
execute
all
right
so
well.
Thank
you
for
debugging
with
me.
That's
always
good
to
to
test
the
things
you
create
very.
C
B
A
B
A
So
we
see
the
parent
workflow
has
its
own
instance,
and
then
the
child
workflow
has
its
own
instance.
But
when
you
use
a
workflow
as
an
activity
and
that
activity
executes,
it's
not
going
to
create
a
separate
workflow
instance.
It
will
just
act
as
if
it
were
an
actual
composite
activity
within
the
same
workflow
context.
So
it
will
be
part
of
the
same
workflow
instance.
There.
B
A
Right
yeah
that
currently,
that
is,
that
is
partially
true.
There
is
a
way
to
provide
inputs
using
this
field,
which
could
be
any
object
through
JavaScript
expressions,
for
example,
but
currently
there's
no
no
way
for
you
to
receive
any
result
from
this
child
workflow,
which,
which
would
be
a
good
use
case
or
a
valid
use
case,
to
have
where
you
want
to
wait
for
the
child
workflow
to
complete
it
and
return
some
results.
That
has
to
be
added,
but
it's
not
currently
there.
Okay,
great.
A
So
it
actually
doesn't
it
yeah.
It
should
F1
I,
think
that
was
the
delay
yeah.
So
this
is
a
blocking
activity
so,
depending
on
what
you
configure
the
parent
workflow
with
so
here,
if
you
do
check
wait
for
completion,
it
will
mean
that,
while
this
executes
so
so
if,
for
example,
you
it
executes
the
delay
activity,
it
waits
for
two
seconds.
So
it's
a
blocking
activity.
That
means
this
workflow
will
not
continue
because
the
child
workflow
hasn't
finished.
Yet
so
as
soon
as
the
child
workflow
finishes,
then
execution
will.
C
C
A
Let's,
let's
see
if
I
understand
so
let's
say
we
have
this
as
a
trigger.
So
at
this
point
we
can
of
course
just
invoke
this
workflow
right.
We
can
just
trigger
this
endpoint.
That's
no
problem!
If
you
were
to
do
this,
to
invoke
this
workflow
from
the
parents
like
here
then-
and
this
is
checked,
so
what
will
happen
is
this
will
execute
this
will
execute
and
it
it
will
now
have
created
an
instance
of
the
child
workflow
child
workflow,
and
it
will
be
immediately
blocked
on
the
HP
endpoint
activity.
A
So
at
that
point
you
can
resume
the
child
instance
by
invoking
the
HTTP
endpoint
by
triggering
well
sending
an
HP
request
in
theory,
because
it's
an
interesting
use
case
because
the
child,
now
it
will
be
it-
will
have
executed
and
created.
The
bookmark
in
in
theory,
I
have
to
try
it,
but
it
will
also
have
created
a
trigger.
So
probably
what
will
happen?
Is
it
will?
A
If
you,
if
you
want
to
resume
this
workflow,
it
will
also
create
a
new
instance,
because
it's
also
used
as
a
as
a
trigger,
depending
on
on
whether
you
say
can
start
workflows.
You
do
not
check
this
one.
There
will
be
no
trigger,
so
if
the
ex,
if
the
desired
behavior
is
for
this
to
just
be
blocked
and
waiting
for
some
HP
request,
you
will
leave
this
one
unchecked.
So.
D
A
D
A
Execute
it.
So
what
do
we
see
here?
We
see
parent
start
parent
and
that's
not
good.
That
should
not
have
happened.
Let
me
see
if
I
can
see
why
wait
for
completion,
okay,
so
I'm
just
going
to
set
a
quick
breakpoint
here
and
at
the
end
point
all
right.
So
this
is
true,
so
it's
going
to
create
a
bookmark,
then
we
are
going
to
dispatch
the
child
workflow
and
then,
of
course
that
will
cause
the
HP
endpoint
to
be
executed,
and
here
it's
going
to
check
a
thing.
A
D
A
So
that's
not
the
case,
so
that's
good,
so
it
returns,
but
we'll
have
created
a
bookmark
once
this
one
finishes,
we
will
be
a
we
will.
We
should
see
this
one
fire.
So
let's
make
sure
this
is
status,
running
okay,
all
right,
so
we
are
not
going
to
resume
the
parent
workflow.
So
we
see
parent
starts
okay,
so
this
behaves
as
expected.
So
one
maybe
one
explanation
will
be
that
the
data
the
data
got
a
little
bit
corrupted,
maybe
with
some
of
the
existing
instances.
A
I
don't
know,
but
I
will
take
a
closer
look,
but
this
is
proper
behavior
and
now
to
resume
the
child
workflow
go
to
here
hit
sends
so
some
workflow
finish.
This
is
probably
the
the
child
workflow.
Let's
double
check,
yeah
okay,
this
is
the
child
worth
I
can
tell
because
of
the
HTTP
endpoint
here.
The
idea
is
incorrect.
I
need
to
look
into
this
as
well,
because
this
should
be
whatever
ID
I,
provided
it
or,
if
I
think,
but
I
will.
A
I
will
double
check
this
one
to
this
finished
so
now
it
should
trigger
the
parent
workflow.
Let's
see
what
happens
here,
parents
start
child
start,
child
done
child
support
child
done.
So
now
it's
doing
something
twice:
parent
and
well.
Let
me
try
again
without
the
any
of
the
breakpoints
and
any
of
the
states
any
of
the
bookmarks
so
execute
this
one.
So
we
have
parent
starts
and
then
we
say
HP
endpoints
of
endpoint
parent
start
child
start
child.parent.
So
this
is
the
correct
flow
yeah.
A
Actually
so,
let's,
let's
do
it
like
this
so
tiny
and
let's
create
a
new
workflow.
So
for
that
you
have
the
event.
So
let's
say
you
want
to
invoke
some
workflow
in
response
to
some
event.
You
use
this
one.
You
give
it
the
name
of
the
event,
so
maybe
call
this
one
order
create
it,
and
this
will
be
the
order
created
workflow.
So
if
you
wanted
to
invoke
this
one
there's
at
least
two
ways,
one
would
be
to
use
the
rest
API
and
another
one
would
be
to
use
the
publish
event
activity.
A
So
then
you
can
invoke
this
workflow
from
another
one.
So
that's
great
another
workflow
I'll,
just
call
it
order
publisher
and
then
add
the
publish
event
and
we'll
have
to
we'll
have
to
specify
the
event
to
invoke
already
created
optionally
in
a
correlation
ID.
If
you
don't
specify
a
correlation
ID,
then
any
no
workflows
either
starting
with
or
blocked
on
the
order
created,
event
name
will
be
started
or
resumed.
A
B
A
So
so,
let's,
let's
say
publishing
and
then
here
we
say,
publish
then
in
the
order
created,
we
say
or
decrease.
Okay.
So
if
we
copy
this
one
and
then
execute
it,
let
me
first
clean
out
this
outputs
for
seconds.
So
we
see
publishing
then
I
think
there's
there's
some
bug
recently
introduced
with
the
workflow
State
transitioning.
Oh
it
faulted.
So
it's
going
on
here.
Let's
see
what
what
is
this
could
be
just
an
expression.
Event
name
is
required:
okay,
publish
event,
even
name
okay.
So
let's,
let's
double
check
the
designer.
B
A
Validation
is
not
implemented
at
all
anywhere.
At
this
moment.
That's
I.
This
is
something
I
want
to
tackle
holistically,
instead
of
doing
it
ad
hoc
per
case,
because
it
involves
a
few
things
like
UI
feedback.
Of
course,
if
you
forget
something
and
the
ability
to
as
a
developer,
identify
which
fields
are
required
and
is,
should
there
be
just
this
notion
of?
Is
it
Fields
required,
Yes
or
No?
It
should
be.
Should
there
be
additional
validation
requirements
Etc,
so
I
want
to
take
that
thing
separately.
A
A
I,
like
it
all
right
and
it's
good
that
this
is
recorded,
So
I
can
watch
back
and
see
what
what
scenarios
weren't
working
yeah,
but
in
any
case
the
concept
is
Click
right,
yeah,
so
yeah,
but
there's
some
some
troubleshooting
to
do
and
it
needs
an
icon.
I
see
that's
missing
this
icon
all
right.
So
let
me
just
write
down
this
scenario.
Real
quick
I
forgot
this
to
do,
but
I
will
re-watch
this
session
later
and
update
my
notes
all
right.
So
you
had
a
question
about
workflow
query.
B
Yeah
to
to
query
workflow,
you
you've
got
to
input
a
bookmark
and
I
I.
Don't
know
how
to
how
the
internal
mechanism
is
to
compare
existing
bookmarks
with
the
bookmark
I
sent
to
the
query.
So
will
it
compare
each
and
every
property
within
the
bookmark?
If
it's
the
same,
and
is
there
some
kind
of
some
kind
of
if
I
leave
it
empty,
what
happens?
Will
it
take
all
of
the
properties
or
what
what
will
happen?
B
A
Yeah
yeah,
okay,
so
let
me
try
and
explain
it
using
elsa3.
The
system
is
very
similar
in
LSAT
2..
Sorry,
if
I'm
able
to
explain
also
three,
it
should
be
straightforward
to
also
understand
the
elsa2
bookmarking
system.
So
let's
take
an
example
of
this
event.
So
this
event,
when
executed,
we'll
create
a
bookmark.
So
let's
start
with
the
event
activity,
so
we
go
to
its
executasync
and,
of
course,
the
event
activity
can
also
be
used
as
a
trigger.
A
That's
why
we
see
this
bit
of
logic
here,
so
if
it's
not
a
trigger
of
a
workflow,
whatever
this
logic
is:
oh
okay,
so
this
is.
This
function
returns
true.
If
this
activity
is
triggered
for
the
first
time
and
not
being
resumed,
so
this
is
a
way
to
help
you
identify
for
the
activity
to
understand.
Do
I
need
to
actually
create
a
bookmark,
because
in
this
in
this
setup,
when
this
is
the
previous
activity
that
executed-
and
it
goes
to
this
one-
you
want
this
one
to
block
right.
A
But
if
it's
used
as
a
starting
point
and
then
this
workflow
was
triggered
because
this
event
was
received,
you,
don't
you
don't
don't
want
the
workflow
lenses
to
just
start
and
then
immediately
be
blocked
here.
You
just
want
it
to
continue.
So
that's
that's
what
this
logic
is
about.
So
let's
say
we
are
not
using
it
as
starting
activity,
but
we're
using
it
as
a
blocking
activity
like
this,
so
we
can
uncheck
this
one.
This
executes.
We
encounter
this
activity
and
we
are
here
in
the
execute
async,
which
means
it's
not
a
trigger
of.
A
A
So
it
is
for
this
event:
activity
I
created
this
event,
bookmark
payload
and
it
scares
arbitrary
data
which
is
relevant
for
the
events,
implementation
and-
and
here
it's
storing
the
event
name
and
the
reason
it's
storing
the
event
name
is
because
that
is
a
unique
property
for
this
event
that
the
user
provided,
because
when
the
system
is
going
to
actually
resume
this,
this
bookmark
or
resume
the
activity
by
having
a
bookmark
with
the
same
event.
Name,
that's
how
it
can
locate
it
in
a
database
and
I
will
dig
a
little
bit
deeper
into
that
aspect.
A
So
what
happens
here
in
in
the
create
bookmark?
Let
me
show
you:
it
will
create
a
bookmark
here
so
here
to
see
if
the
options
which
carries
the
payloads
that
we
just
instantiated
some
optional
stuff,
that
we
might
discuss
a
little
bit
later,
but
here's
the
key.
So
here
it's
creating
an
actual
bookmark
entity
which
will
be
persisted
in
the
database.
So
it's
going
to
generate
some
primary
key
value.
A
This
is
important.
The
activity
type
name
that
created
this
bookmark
and
a
hash-
and
this
has
value-
is
the
second
piece
or
maybe
even
the
primary
piece-
that
you
need
in
order
to
locate
The
Bookmark
tools
to
resume
the
way
this
works.
It
takes
the
activity
type
name,
it
takes
the
Json
serialized
value
of
your
payload
if
it
was
provided,
and
then
it
computes
a
hash.
A
So
that's
that's,
then
stored
as
part
of
the
bookmark.
So
now
we
have
a
bookmark
to
see
if
I
can
show
you
all
right,
I
switched
between.
So
let
me
refresh
all
right:
we
have
a
workflow.
We
have
right
line
an
event,
so
this
is
the
blocking
activity
and
something
else.
We
have
some
events,
so
we
publish
this.
Then
we
will
execute
this
workflow,
but
we
will
set
a
breakpoint
first
here,
all
right.
Okay,
let
me
try
again:
I
didn't
set
the
breakpoint
correctly,
all
right,
so
we
are
now
in
the
executed.
A
Sync
of
the
events-
oh
actually
I
set
the
breakpoint
here.
I
expected
this
one
to
hit,
but
it
didn't.
Let's
see
why
create
bookmark?
Okay,
so
here
we
have
the
activity,
Type
L.
So
that
event,
so
that's
a
fully
namespace
qualified
activity
type
name.
We
have
the
payload,
which
is
the
even
name
and
some
event
right.
It's
lowercased,
which
is
here,
it's
done
on
purpose,
so
that
when
some
arbitrary
application
that
publishes
the
event
it
doesn't
matter
whether
it's
uppercase
or
lowercase
or
uses
mixed
casing.
So
it's
it's
more
flexible
this
way.
A
So
that's
why
it's
it's
just
storing
it
as
a
normalized,
a
slower
case,
but
pointers.
It's
created
a
hash
with
this
value.
Then
it's
going
to
store
that
in
the
database,
so
I'm
gonna
complete
this
execution
and
show
a
database
for
a
second
okay.
So
if
we
look
at
bookmarks
no,
this
is
that
was
the
wrong
database.
It's,
oh
apologies.
This
is
Elsa
samples
word
for
sure.
A
We're
not
not
the
bundle
one
so
and
it
should
be
I
guess
this
one
so
I
think
the
samples
one
isn't
completely
configured
using
Entity
framework,
or
maybe
it's
configured
using
protoacter,
so
I
want
to
be
able
to
show
you
the
database
structure,
real,
quick,
so
I'm
going
to
switch
to
the
I,
also
workflow
server
web.
So
right
line
events
with
all
of
the
settings
in
text.
Yeah,
so
I'll
publish
this
one
execute
it
first
I
need
some
API
key
or
some
access
token
all
right.
A
So
we
have
the
event
name,
some
events
we're
creating
a
bookmark,
and
then
we
create
a
hash
of
the
combination
of
the
activity,
type
name
and
the
bookmark
payload
in
serverless
serialized
form.
So
we
have
some
hash
and
then
we
should
see
that
bookmark
persisted
in
in
the
database.
So
here
we
have
it.
So
here
we
have
a
bookmark.
It
consists
of
the
activity,
type
name,
the
hash
that
we
just
computed
associated
with
the
workflow
instance
ID.
A
That's
important
and
some
data,
and
this
data
is
not
used
for
filtering,
but
it
can
be
produced
by
the
activity,
that's
being
resumed
when
this
bookmark
is
invoked.
But
the
key
is
this
hash
here.
So
now,
let's
say
we
want
to.
We
are
blocked
on
this.
This
event
right
on
this
one.
If
we
look
at
the
workflow
instance,
it
starts
visually
shown
at
this
moment,
but
we
are
working
on
the
UI
so
that
you
will
see
that
it's
blocked
on
this
activity.
But
if
we
look
at
the
journal,
we
see
that
event.
One
has
started.
A
That's
this
activity,
but
it
hasn't
completed
like
the
other
others
or
like
right
line.
This
one
will
complete
as
soon
as
all
of
its
children
have
completed,
but
we
are
blocked
on
event
one.
So,
let's
resume
this
one.
But
let's
take
a
look
at
how
that
how
that
is
done
to
resume
the
event.
We
can
use
a
rest,
API
endpoint
here,
so
that
would
be
like
this,
so
we
say
workflows
and
then
the
name
of
the
event.
A
In
this
case
it
would
be
some
events,
but
this
goes
to
some
an
endpoints
gold
events
or
should
be
should
be
like
this.
So
the
events
endpoint.
Let's
take
a
look
at
this
one
because
that's
then
gonna
construct
The
Bookmark
for
filtering
and
resume
the
workflow
all
right.
So
it's
going
to
happen
here
here.
It's
going
to
use
an
event
publisher
with
this
high
level
service
that
internally
constructs
The
Bookmark.
So
let's
take
a
look
at
that
and
some
Base
address,
API
Base
address
so
I
think
I
should
use
API
Base
address
right.
A
Okay,
so
we
are
in
this
endpoint,
so
we
receive
this
request
to
trigger
an
event
with
the
name
of
some
events,
so
we're
going
to
step
into
this
guy
and
then
here
we
are
constructing
the
same
payload
that
was
persisted
earlier.
So
it's
the
event
bookmark
payload,
and
this
is
important
using
the
same
event
name.
So
that's
one!
Then
we
are
gonna,
get
the
activity,
type
name,
that's
associated
for
this
one
and
and
of
course
each
activity
knows
what
the
activity
name
is
used
to
create
its
own
bookmark.
It's
a
very
explicit
operation.
A
At
this
point,
maybe
we
will
revise
the
a
little
bit
to
to
make
it
a
little
bit
easier
for
other
developers
to
create
their
own
blocking
activities,
but
for
now
this
is
how
it
works.
So
we
create
a
activity,
type
name,
there's
a
bug
with
writer
that
doesn't
well.
That
shows
this
sort
of
thing,
but
the
actual
value
is
outside
that
event.
As
you
can
see
here,
so
that's
the
same
and
then,
let's
see,
then
it's
going
to
create
some
dto.
A
Here
that's
going
to
be
passing
through
the
workflow
dispatcher,
and
that
does
nothing
more
than
just
sending
it
to
some
queue
and
this
queue
will
then
process
that
that
request
that
dto.
So
let's
let's
go
to
that
Handler.
So
this
is
a
mass
transit
workflow
dispenser.
So
let's
go
to
the
work:
mass
transit,
dispatcher.
Sorry
I
just
need
to
check
what
the
message
was
again:
dispatch
trigger,
workflows,
request,
dispatch,
that's
gonna
end
up
here
and
that
will
send
a
mass
transit
message
called
dispatch
trigger
workflows.
So
that's
this
one
here
right
here.
A
So
let's
continue
so
now
we
are
in
Hue
worker
and
here's
gonna
use
the
workflow
runtime
and
it's
passing
along
all
of
this
information.
So
that's
again
the
activity
type
name,
the
bookmark
payloads
and
some
options.
If
you
look
at
this
runtime
implementation,
which
is
default
runtime,
that's
this
guy.
B
D
D
B
A
B
B
A
A
A
One
one
approach
could
be
to
have
this
notion
of
a
wild
card
where
you
just
enter
an
asterisk
symbol,
and
then
it
will
yeah.
That's
then,
what
you
you
would
have
to
and
you
you
would
have
to
create
your
own
interpreter
basically
off
of
this
of
this
payload,
so
that
you
can
recognize
this
this
or
what
you
could
do
is.
A
If
you
see
okay,
I
need
to
trigger
some
bookmark
for
a
given
activity
type,
but
but
if
you,
if
you
know
that
there
could
potentially
be
an
activity
type,
that's
create
a
bookmark
using
this
wild
card,
and
you
can
also
look
for
bookmarks
with
these
wild
cards.
But
it
depends
on
the
specifics,
but
what
I
have
for
the
telnex,
for
example,
is
there's
an
a
blocking
activity
or
a
trigger?
That's
called
call
initiated,
so
it
listens
for
inbound
phone
calls,
but
there
was
this
requirement
where
we
wanted
to
have
some
sort
of
fallback
workflow.
A
A
So
this
is
a
different
kind
of
payload
compared
to
the
incoming
call
from
bookmark
and
two
so
so
there's
there
are
three
kinds
of
payloads
one
to
capture
the
to
trigger,
based
on
the
inbound
phone
number
and
another
option
to
capture
phone
calls
based
on
the
destination
file
number,
so
the
no
phone
number
being
being
called.
But
let's
see
where
this
is
used
all
right.
So
this
incoming
call
activity
when
it's
requested
to
get
the
bookmark
payloads
it
creates
a
number
of
variants.
A
Basically,
so
it
creates
bookmark
payloads
for
the
prom,
so
the
outgoing
phone
numbers
and
the
inbound
phone
numbers
here
and
then,
if
you
enable
catsol
on
the
activity,
that
means
this
workflow
using
this
activity
with
cats
all
will
handle
all
phone
numbers.
So
if
that
one
is
checked,
it
will
create
this
bookmark
and
it
doesn't
have
to
store
any
any
information.
It's
just
handles
there.
In
this
case.
A
A
Yeah
you're
welcome.
Thank
you
for
the
great
question
this
is.
This
is
good
to
have
it
documented,
even
if
recorded
all
right
so
I'm
a
little
bit
of.
We
are
a
little
bit
of
time,
I'm
still
good
in
terms
of
time.
If
you
guys
need
to
go
just,
let
me
know
otherwise,
we
then
can
finish.
Maybe
with
the
cicd
section.
It's.
B
A
With
me
all
right,
so
cicd
Mohammed
has
been
working
a
lot
on
trying
to
fix
the
the
builds
pipeline
for
the
elsa2
packages,
for
which
we've
been
using
app
failure.
So
since
some
commit
at
some
points
with
some
changing
in
the
designer
application,
the
build
started
to
fill
building
those
client
assets
due
to
memory
limitations
of
the
VM
or
so
we
think,
or
so
it
seems
so.
A
It
seems
quite
tricky
to
to
get
that
figured
out
without
just
upgrading
to
paid
VM,
which
would
have
more
RAM,
and
probably
you
know,
allow
us
to
continue
building,
but
what
we
did
instead
is
or
what
Muhammad's
been
doing
instead
is
just
creating
a
GitHub
actions
of
for
the
CI
CD,
Pipeline
and
Mohammed
I
haven't
actually
looked
at
it.
Yet
maybe
we
can
do
it
real,
quick,
so.
A
C
Yeah,
so
there
are
some
few
advantages
here.
One
is
that
you
can
break
the
pipeline
into
multiple
jobs
and
these
jobs
can
have
some
dependency,
so
the
right
hand
side
you
can
see.
There
are
four
jobs
and
they
will
start
only
after
the
first
job
is
finished.
But
if
you
don't
create
a
dependency,
you
can
also
execute
in
parallel.
So
one
of
the
pain
points
with
the
up
there
was
that
we
needed
to
finish
for
run
upload
to
complete.
C
Then
we
do
the
next
one,
but
if,
for
some
reason,
Market
upload
fails,
The,
Next,
Step,
automatically
fails
and
workflow
doesn't
continue.
So
here
one
of
the
advantages
that
you
can
do
it
in
parallel
and
what
I
have
done
is
that
I
broke
it
to
two
parts.
One
is
to
build
and
create
the
packages
and
then,
after
creating
the
packages
we
can
decide
to
publish
based
on
in
the
condition.
So
the
condition
here
is
that
if
it
is
just
the
preview
build,
it
will
go
to
market.
C
And
the
other
thing
is
that
they
have
the
artifact
concept
here.
So
what
you
get
also
is
that
the
npm
package
and
the
nuget
packages-
also
you
can
download
directly
from
here.
So
for
any
reason,
if
you
want
to
download
and
troubleshoot
something
directly
on
this,
you
can
download
and
use
them
or
if
the
upload
fails
for
some
reason,
you
can
also
manually
upload
effects,
so
you
get
the
benefit
of
both.
You
have
the
artifacts.
C
So
normally
in
my
work,
we
use
Azure
pipelines,
which
has
similar
concepts
of
the
artifacts,
and
this
multi-staging
so
build
and
then
release
publish
all
these
things.
So
it
looks
like
GitHub.
Action
is
also
coming
into
shape
in
the
same
level.
So
it's
really
impressive
and
I
think
this
could
help
you
know
and
then
making
it
more
faster
and
more
streamlined,
because
if,
for
example,
my
get
publish
failed,
you
can
even
retry
only
the
publishing
part
without
having
to
go
back
and
rebuild
the
packages.
Nice.
C
So
one
advantage
here
also
is
we
say
common
version.
So
as
a
first
step
is
that
either
we
are
having
a
preview
or
the
release
version,
so
you
can
see
the
logic
to
set
the
line
24.,
you
see
the
version
either
using
this
preview
format
or
if
you
have
mapped
it
as
a
release.
So
we'll
just
use
the
release
name
as
the
version
number
and
this
will
set
for
both
the
nougat
and
the
npf.
C
B
A
A
C
A
A
But
that's
really
great.
Thank
you.
Thank
you
for
doing
this.
That's
gonna
make
my
life
better
and
and
also
hopefully
decrease
some
pain
and
suffering
for
those
people
using
the
designer
nougat
packets,
because
that
embeds
the
client
assets,
but,
as
Muhammad
explains
in
the
app
failure
script.
If
the
client
asset
build
fails,
the
overall
build
will
just
happily
continue,
building
out
the
packages,
but
then
without
the
client
assets
and
then,
as
whenever
you
update
to
the
latest
version
of
the
packets.
Surprise.
C
And
this
one's
marked
is
that
if
you
have,
if
you
have
a
separate
brand,
for
example,
we
have
a
separate
Branch
for
2.10
and
2.9
to
make
this
workflow
also
applicable
there.
We
need
to
update
the
file
in
the
respective
Branch,
because
the
way
it
works
is
that
it
always
excludes
from
the
same
Branch
where
the
trigger
has
happened.
So
if
you
mark
something
as
released
again
in
2.10
for
the
time
being,
it
will
just
execute
the
old
workflows.
So
we
need
to
update
the
workflows
there,
also
so
that
this
also
can
run
there.
A
Yeah,
it
makes
sense
yeah
yeah
we'll
do
that
as
before
or
whenever
we
need
to
do
another
release,
which
reminds
me
2.11
needs
to
be
released
soon.
It
contains
an
important
bug
fix
so
that
that
I'll
take
that
opportunity
to
update
the
build
script
as
well
and
get
a
little
bit
familiar
with
it
sure
all
right.
So
that's
a
good
to
do
then,
with
that
I
think
we
can
adjour
in
the
session.
Thank
you
for
joining
and
hopefully
see
you
guys
next
week.
This
is.