►
From YouTube: Elsa Workflows Community Meeting 33
Description
- Documentation updates
- Sample application demonstrating webhooks and RunTask activity
A
A
Yeah,
it
seems
like
it's
really
picking
up
so
yeah,
it's
good
to
see
all
right.
So
let
me
start
sharing
my
screen,
so
lots
of
activities,
as
you
noticed
on
elsa3.
My
list
is
very
small,
but
you
know
size.
Isn't
everything
if
you
look
at
the
documentation
updates,
it's
just
a
single
line,
but
it's
a
lot
of
work
and
it's
something.
I
want
to
show
at
least
the
current
progress.
Do
you
have
any
topics
you
would
like
to
add
to
this
list
before
we
start.
A
All
right
good,
then
yeah,
let's,
let's
Dive
Right
In,
so
one
thing
I
did
was
cleaning
up
the
the
menu
so
there's
there's.
There
are
still
some
for
a
force
like
the
JavaScript
and
liquids
and
user
tasks,
but
everything
else
at
least
there's
some
content,
so
it
it's
not
in
its
final
shape.
It's
an
ongoing
process,
of
course,
but
we
have.
A
A
If
you
want
to
try
it
out,
there's
also
a
new
section
about
loading
workflows
from
Json,
so
some
users
prefer
to
have
their
word
for
definition,
stored
as
part
of
the
source
code
repository
or
maybe
stored
elsewhere,
and
then,
instead
of
loading
it
from
the
database,
you
want
to
load
it
from
files,
and
this
explains
how
you
can
go
about
it.
So
it
starts
off
with
a
console
application
to
really
simple
stuff.
A
Really,
it's
just
you
just
create
a
service
provider,
and
then
you
populate
the
Registries,
which
is
the
activity
registry
and
the
expression
provider
registry.
Normally
this
would
happen
during
using
a
hosted
service,
but
when
you
run
a
console
app,
there's
no
hosted
services,
so
you
have
to
invoke
this
manually
in
order
to
get
them
most
functionality
going.
At
least
of
course,
you
don't
really
need
this
either.
If,
if
you
want
to
execute
certain
simple
workflows,
then
it's
then
it's
okay,
but
usually
you
want
those
Registries
to.
B
A
There
and
then
here
it's
using
a
standard
API
to
read
contents
from
some
file,
which
represents
a
workflow.
Then
you
need
an
activity
serializer
to
deserialize
this
Json
into
an
actual
workflow
object,
and
once
you
have
your
hands
on
this
workflow
I'll
check,
you
can
just
run
it
using
the
workflow
Runner
and
and
that's
it,
and
in
this
example,
we're
using
a
very
simple
hello
world
workflow
that
consists.
That
starts
with
a
flowchart.
So
this
is
a
workflow
that
was
designed
using
the
designer.
A
You
don't
need
a
flowchart,
but
when
you
use
the
designer
it
will
always
use
a
flowchart
and
then
it
just
has
one
activity
which
is
a
right
line
activity,
and
it
writes
this
this
string
to
the
console
and
that's
it.
So
that's
that's
one
way,
but
more
practically,
probably
you
will
have
an
asp.net
core
workflow
server,
that
from
that
you
want
to
read
from
Json
files,
maybe
from
some
directory
or
maybe
from
blob
storage
or
whatever
the
case
may
be.
A
What
was
it
called
I
think
storage.net
I
think
was
the
previous,
or
was
the
name
of
the
previous
library
that
I
used
in
LSAT
2.,
but
that
project
has
been
archived.
So
this
is
this
is
a
new
project
that
either
is
a
fork
of
it
I'm
not
entirely
sure,
but
it
has
the
same
functionality
and
and
I
think
even
more.
It
also
has
support
for
messaging
and
some
other
other
things.
A
A
So
here
it's
just
walking
you
through
the
default
configuration
where
you
all
you
need
to
do
is
just
call
use
fluent
storage
provider
on
the
Elsa
module
and
that's
it
and
then
it
uses
default
configurations,
and,
as
I
mentioned,
it
will
look
for
files
in
the
workflows
folder.
So
here
I'm
creating
the
same
workflow
file
that
we
use
in
the
console
application.
Then
you
just
start
the
application
and
and
because
it's
it's
a
word
for
definition
provider,
all
of
the
workflows
in
this
folder
will
be
available
as
workflow.
A
So
you
can
run
them
the
same
way.
You
run
any
workflow,
you
create
using
the
designer,
so
here
the
definition
of
these
hello
world.
So
if
you
are
using
the
rest
API
you
use
that
that
hello
world's
definition
in
the
URL
here.
So
that's
that's
an
another
article.
User
tasks
remains
to
be
done
and
could
be
done
on
the
POC.
A
That
Christina
wrote
as
a
as
a
example
reference
application
that
might
be
nice
yeah
and
then
contribution
from
another
from
a
customer
where
they
they
explain
how
you
can
invoke
workflows,
there's
multiple
ways,
so
you
can
use
just
an
ACP
endpoint
that
that
is
a
trigger
so
through
HTTP
endpoint.
That's
a
very
easy
way
to
kick
off,
workflows,
of
course,
and
there's
the
then
of
course
there's
the
API,
which
we
just
looked
at
as
well
here.
A
So
it's
it's
a
nice
summary
of
doing
that,
and
it
also
mentions
the
dispatch
API.
So
this
one
is
executing
it
well
quotes
synchronously.
Of
course
it
still
uses
async
await,
but
it
waits
for
the
entire
request
to
complete
before
it
returns,
and
this
bets,
on
the
other
hand,
just
sends
a
message
to
some
service
bus
and
then
the
service
worker
will
somewhere
in
the
background,
actually
execute
the
workflow.
So
the
eight
speed
request
itself
will
return
pretty
much
instantaneously.
A
So
it's
a
way
to
asynchronously
start
workflows
without
having
to
wait
for
the
first
burst
of
execution
of
the
workflow
to
complete
so
very
nice
contribution.
There
worked
on
the
Core
Concepts,
so
programmatic
versus
designer
workflows,
so
it
starts
explaining.
What's
the
difference
and
of
course,
as
you
know,
you
can
create
workflows
using
c-sharp
classes
or
you
can
use
the
designer.
So
here's
it's
more
of
a
an
introduction.
A
A
Let's
say
you
have
something
in
the
designer,
but
now
you
want
to
implement
it
in
code.
How
do
you
translate
it
to
so?
This
is
an
initial
attempt,
at
least
to
try
and
explain
the
the
common
fact
aspects,
but
also
what
what
the
differences
are
and,
as
it
turns
out,
there's
there's
a
big
overlap,
because
whether
you
create
it
in
code
or
in
the
designer
at
the
end
of
the
day,
what
you're
creating
is
an
object
graph
representing
your
workflow,
so
the
designer
creates
a
Json
format.
A
That
is,
that
is,
that
can
be
mapped
onto
an
actual
workflow
graph
and
the
other
way
around.
If
you
construct
an
object
graph,
if
you
were
to
serialize
it,
that
would
be
the
same
Json
yeah.
So
this
is.
This
is
a
good
one
to
go
through
if
you're
new,
to
elsa3
to
get
an
initial
understanding,
and
then
we
continue
with
the
workflow
and
there's
some
repetition.
A
So
here
again
it
explains
what
what
is
the
workflow
so
but
it
it
looks
at
it
from
slightly
different
angles,
so
as
an
I'm
hoping
that
it
will
make
it
easier
to
to
get
the
hang
of
of
various
aspects
of
Elsa,
so
it
talks
about
workflow
execution.
What
is
what
is
the
definition?
What
is
an
instance?
What
is
an
execution
context
so
and
again
it's
it's.
Of
course
an
initial
iteration
will
will
expand
on
this,
as
as
we
get
feedback
same
goes
for
activity.
What
is
an
activity?
How
do
you
create
one?
A
It
talks
about
input
and
output
and
outcomes
talks
about
activity
metadata.
So
that's,
like
you
know,
namespace
category
description.
It
talks
about
composite
activities
and
it
even
shows
a
little
example
based
on
the
effectivity,
and
here
it
shows
the
effectivity
in
action.
It
mentions
blocking
activities
and,
of
course
triggers-
and
this
is
a
a
light
introduction
to
this
concept.
So
of
course,
there
will
be
more
detailed,
tutorials
or
guides
on
on
creating
custom
activities,
for
example,
and
through
guides.
A
We'll
also
show
how
how
input
output
Works
in
practice
here
it
just
explains
the
concept
and
a
very
simple
example
created
the
end
code.
So
here
we
have
the
a
custom
activity
called
sum
which
takes
two
inputs
and
it
sums
those
inputs
together
and
returns
an
outcome.
And
what
do
you
have
here?
We
have
outputs
and
we
also
show
how
how
to
use
it
in
the
designer.
So
this
this
custom
composite
activity
called
sum-
is
used
here
in
the
designer.
Actually,
no
I
need
to
take
that
back.
A
A
We
have
workflow
runtime,
we
have
Registries,
so
it
would
be
good
to
to
get
get
a
an
understanding
of
what
fits
were
and
when
to
use
what
the
concept
of
trigger
and
the
concept
of
a
bookmark.
But
this
is
it's
a
it's
a
little
bit
meager
in
terms
of
explanation,
so
that
it
should
be
expanded
a
little
bit
with
some
examples.
Probably
same
goes
for
this.
This
activity
Library
it's
a
good
start,
but
of
course
we'll
we'll
want
a
little
bit
more
detail,
maybe
some
context
of
when
to
use
a
given
activity.
A
Maybe
an
example
use
case.
Etc
definitely
work
in
progress
and,
as
I
mentioned,
JavaScript
liquid
needs
to
needs
to
be
added
soon
as
well,
because
otherwise
it
becomes
hard
to
understand
what
functions
you
can
use.
Even
though
there's
intellisense
it
would
be
good
to
to
have
an
overview
all
the
same.
So
yeah
lots
of
work
has
been
done
already,
but
lots
of
work
has
yet
to
be
done
for
the
RC
the
for
the
end
of
this,
the
next
month,
May
31.
B
A
No,
but
thank
you
for
reminding
me:
let's
add
it
to
the
list:
let's
see,
maybe
it's
already
there.
So
this
is
my
little
checklist
to
to
to
collect
topics
all
right,
I,
don't
forget
and
and
to
check
off
what
has
been
done
and
see.
If
there's
persistence,
I,
don't
think
so.
So
let
me,
let
me
add
it
not
really
important
to
to
have
something
about
persistence.
A
All
right
so
I
mentioned
the
external
application
integration
which
relies
on
the
Run
task
activity,
so
I
figured.
Maybe
this
is
a
nice
topic
to
to
demonstrate
how
it
could
work
in
in
practice.
So
let
me
stop
this
one.
The
designer
is
running
yeah.
Okay,
so
for
this,
for
this
demo,
I
have
two
applications,
which
is
just
the
normal,
just
a
workflow
server.
So
that's
the
the
stand,
the
reference
application
here
in
the
bundle
we
have
also
workflow
server
web,
so
I'm
gonna
start
this
one
and
the
designer
I
start
separately.
A
A
Well,
not
the
nuget
packets,
but
the
project
which
then
references,
the
npm
packets,
so
that
started
and
the
other
application
is
the
the
external
application
which
I
created
in
asp.net
core,
because
that's
my
favorite
framework,
but
it
could
have
been
PHP
or
Ruby
on
Rails.
Just
as
long
as
the
framework
supports
HTTP
communication,
then
you
can
use
whatever
and
that
application
is
this
one.
So
I
have
a
a
sample
application
called
onboarding.
A
So
so
those
those
steps
you
orchestrate
in
Elsa,
but
the
actual
activities
of
you
know
performing
those
tasks
like
setting
up
an
email
account
that's
handled
in
this
application
here
and
it's
not
done
automatically.
Although
some
of
these
tasks
could
be
automated,
maybe
others
are
relying
on
on
people
doing
the
actual
work
and
the
point
is
it
doesn't
matter
from
the
workflow's
perspective?
All
it
does
it's
just
fires.
A
A
So
imagine
you
have
some
application
that
kicks
off
this
workflow
or
maybe
right
now
we'll
do
it
using
Postman
doesn't
really
matter
what
the
source
is,
but
you
need
to
somehow
trigger
the
workflow.
You
provide
the
input
in
the
form
of
an
employee
consisting
of
an
email
address
and
a
name,
and
then
we
assign
this
information
to
the
employee
variable
which
we
declared
here
and
it's
of
type.
What's
here
at
least
it's
listed
as
object,
but
I
I,
I
notice,
there's
a
little
bug.
A
It's
just
an
expander
object,
but
so
Json
is
it's
like
an
alias
so
like
that,
once
that
variable
is
set,
we
kick
off
the
tasks
that
will
not
execute
in
Elsa
itself,
but,
as
I
mentioned,
will
be
dispatched
to
the
external
application,
and
for
that
we
are
using
the
Run
task
activity
and
it's
a
it's
a
very
general
purpose
activity
which
allows
you
to
specify
the
task
name,
which
could
be
treated
as
an
identifier
in
your
external
app
to
ident,
to
determine
what
you
want
to
do.
So
you
have
to
Imagine
This.
A
This
activity
will
indirectly
invoke
some
web
hook
that
that
is
an
endpoint
in
your
external
application
and
it
receives
some
payloads
and
the
payloads
receives
the
the
task
name.
Whatever
payloads
you
provide
and
some
additional
information
about
the
workflow
instance
itself
and
and
in
the
future,
maybe
some
additional
metadata.
This
description
is
wrong,
any
async
additional
pair,
so
it
should
just
be
any
I
suspect
this
might
have
been
co-pilots.
A
A
It's
it's
also
it's
a
blocking
activity,
so
it
will
do
it
will
send
this
status
to
your
external
application
and
then
wait
until
the
external
application
reports
back
that
the
task
has
been
completed
so
until
then
the
workflow
will
be
sitting
here,
so
the
workflow
will
be
suspended.
Go
out
of
memory
doesn't
matter
it's
just
it's
just
waiting
for
the
external
application
to
report
completion
of
the
task.
A
When
that
happens,
execution
splits
into
four
branches,
which
means
all
four
activities
will
run
at
the
same
time
or
they
will
be
executed
sequentially
one
by
one,
but
that
happens
very
fast.
So
it's
not
like
it's.
It
has
to
wait
before
this
one
completes
before
this
one
executes,
so
this
will
create
a
bookmark.
This
will
create
a
bookmark,
and
this
one
and
this
one
after
or
it
creates
The
Bookmark
and
then
dispatches
the
task
to
the
external
application.
So
these
things
will
create
four
tasks
at
the
same
time
in
the
external
application.
A
So
the
effect
will
be
that
initially,
we'll
just
see
one
task
for
for
a
user
to
complete
and
as
soon
as
they
complete
the
task,
they
will
see
new
tasks
coming
in
four
of
them
to
be
precise
and
once
all
four
have
been
completed
only
as
once
they
are
all
completed,
it
will
merge
into
the
send
welcome
email,
so
so
yeah
and
it
will.
This
will
of
course,
execute
just
once
at
the
end.
A
So,
let's
see
how
it
works,
for
that
I
do
need
to
start
SMTP
for
Dev,
which
is
the
SMTP
servers
for
local
development.
Okay
and
then
you
need
to
we'll
kick
off
this
workflow
and
it's
draft.
So
let's
make
sure
it's
published,
go
to
postman
and
copy
the
definition
ID
like
that
and
notice
that
I
already
have
the
input
prepared
here
so
I'm
going
to
send
as
the
input
I'm
going
to
send
an
object
called
employee
with
a
name
and
an
email
address.
A
A
If,
if
we
find
that
it
might
be
too
big
of
a
response
to
send
back,
I
don't
know,
but
this
could
be
an
option
of
getting
back
as
a
response.
The
entire
object
right,
so
the
workflow
executed.
We
should
be
able
to
see
the
workflow
instance
here
and,
as
we
can
see
here,
the
set
variable
was
executed
and
create
email
account.
That's
the,
although
it
says
completed,
that's
not
accurate,
it's
it
should
be
waiting
or
or
some
other
name,
because
it
definitely
didn't
complete.
A
It's
it's
actually
blocked
on
this
one,
and
we
can
see
here
the
payload
that
was
sent
as
as
part
of
this
activity.
It's
the
it's,
this
Json
all
right.
So
let's
take
a
look
at
the
external
app
I'll
refresh
the
page,
and
it
looks
like
something
didn't
go
right.
So,
let's
see
if
we
can
figure
it
out.
First
thing
to
look
at
is
the
application
console?
Oh
I,
think
I,
see
I
I,
think
I
I
started
the
wrong
workflow
server,
because
I
don't
see
any
web
hooks
identified
here.
A
So
what
the
Run
task
does
internally,
it
just
fires,
a
domain
notification
or
domain
event
that
is
then
handled
by
the
webhook
module,
which
we
have
here.
The
web
hooks
module
what
it
will
do
internally.
It
will
invoke
a
web
hook,
and
that
looks
like
this,
so
the
web
hook
looks
for
for
web
registration
in
one
second.
This
is
a
level
too
deep.
So
the
Run
task
request
is
a
notification
that
is
published
by
the
Run
task
activity
handled
by
this
Handler,
and
it
will
what
it
will
do.
A
It
will
use
the
web
hook
dispatcher
to
fire
this
web
hook
event.
So
this
Web
book,
event's
name,
is
run
test,
so
it's
very
much
specific
to
the
Run
task
activity
and
then
this
dispatcher
looks
for
all
registered
web
hooks,
but
we
don't
have
any
configures
in
this
application,
but
we
should
have
it
in
the
onboarding
workflow
server.
So
here
we
have
a
section
called
webhooks
with
some
exposed
endpoints
by
the
external
application.
So
here
we
registered
this
workbook.
So
let's,
let's
switch
to
this
application
all
right.
Let's
refresh
okay!
Well
one
second!
A
So
here
I
didn't
create
a
workflow
in
the
designer
because
I
didn't
I
didn't
add
support
for
cross-riching
resource
sharing.
Of
course
that's
why
we
are
seeing
these
errors,
so
here
I
created
everything
in
in
code,
which
is
functionally
the
same.
What
I
could
do
is
just
copy
and
paste
this
these
settings
to
the
workflow
server.
A
Actually,
let's
do
that
because
maybe
you
Muhammad
doesn't
believe
me
so
I'm
gonna
show
it
will
work
and
then
making
sure
that
webhooks
is
installed.
I,
don't
think
so.
Let
me
see
so
we'll
do
it
like
this
and
then
we'll
say,
use
web
hooks
and
then
we'll
configure
it
like
this.
So
here
we're
reading
it
from
the
from
app
settings
or
from
the
configuration
it
contains.
The
app
settings
like
this
okay.
A
So
now
we
have
the
webhooks
module
installed
and
enabled,
let's
run
the
workflow
again
and
let's
see
if
we
see
something
now
I
was
thinking
to
myself.
I
should
try
it
before
the
meeting,
but
I
was
so
I
was
too
confident
that
it
would
work,
but
I
I
broke
something
somewhere,
let's
see
if
we
can
find
it
all
right.
Let's
do
a
little
debugging
session.
I'm
gonna
set
a
breakpoint
in
the
dispenser.
Not
this
one
but
I
think
I'm
gonna
set
one
here
all
right.
A
Well,
it
will
help
if
I
attach
the
bar
first
I
was
running
in
without
debugger
okay.
So
here
we
are
in
the
Run
task
activity,
we're
going
to
dispatch
this
notification
and
that
did
not
end
up
in
the
didn't
end
up
here
seems
let's
try
again,
so
we
are
using
the
asynchronous
dispatcher
and
that's
going
to
publish
this
event
here
so
web
hooks.
Okay.
So
here
we
are
in
the
Run
task,
Handler
in
the
webhooks
module,
so
we're
getting
closer,
and
here
we
have
the
background
web
hook
dispatcher.
A
So,
let's
see
here
we
got
zero
registration,
so
I
made
an
error
with
the
configuration.
Probably
so
we
have
one
web
regrets
tracing
provider,
which
is
the
options
web
hook
registration
provider
and
that
one
is
returning
nothing,
okay,
options,
endpoints,
so
something
is
not
right.
Here.
Let's
go
back
to
program
use
webhooks
configuration
get,
Section
bind
to
webhooks
web
hooks,
endpoints
all
right.
Let's,
let's
restart
this
application,
oh
as
Dom
I
see
so
webhooks
is
not
options.
It's
a
webhooks
feature,
so
I
didn't
look
at
the
any
type.
So
let
me
let
me
stop
this.
A
A
Then
here
we're
going
to
invoke
it.
Then
here
we
are
here
we
get
into
the
HTTP
web
looking
Focus,
so
this
is
still
in
the
workflow
server
and
it's
now
about
to
make
an
API
call
to
the
external
application
on
the
registered
URL,
which
is
the
5002
ports,
API
webhooks
from
task
and
then
to
be
clear.
That's
is
up
to
the
external
application
to
determine
what
the
endpoint
should
look
like.
So
here
it's
configured
like
this,
so
we're
invoking
it.
Now
we
get
a
successful
response,
so
that's
good.
A
The
width
also
should
mean
that
now
the
this,
this
external
application
should
have
created
a
task.
So
let's,
let's
make
sure,
that's
the
case
all
right,
so
here
it
is,
and
just
for
for
your
information.
Just
taking
quick
look
at
the
API
endpoints
internal
implementation.
Here
we
have
the
webbook
controller,
so
this
is
the
endpoint
exposed.
A
So
we
just
invoke
this
action,
which
receives
a
web
hook,
event
model,
which
is
declared
here
locally
to
this
project,
and
it
consists
of
the
event
type
that
we
discussed
the
payloads
and
a
timestamp
when
the
webbook
was
fired
and
then
what
we
do
here.
We
just
create
a
new
onboarding
task
instance
and
store
it
in
a
database,
and
that's
it
so
very,
very
simple
here
and
then,
of
course,
in
the
home
controller
in
the
index
action
we
list
all
of
the
available
tasks.
So
that's
what
we
see
here.
A
So
we
have
one
task
for
this
employee
to
be
on
board
and
the
task
is
to
create
an
email
account
for
a
new
employee.
So
I
imagine
you
are
somebody
from
it
of
this
company
and
now
you
set
it
up
and
then
you
click
on
the
complete
button.
It's
because
we
have
still
the
debugger
attached.
We
we
we
continued
the
workflow
and
the
workflow
is
now
firing
off
the
additional
tasks.
So
that's
why
we
are
in
this
debugger
again.
A
So
let's
ignore
this
at
the
screen,
although
it's
refreshed
because
the
workflow
server
executes
asynchronously,
depending
on
how
fast
it
executed,
we
would
have
seen
the
task
appear
here
or
not,
but
usually
you
wouldn't
see
it
unless
you
do
a
regular
refresh
or
if
you
use
Implement
some
signalr
communication.
That's
that's
beyond
this
outside
the
scope
of
this
demo.
But
if
you
refresh
the
page,
you
will
see
the
the
new
the
newly
create
tasks.
So
these
are
the
tasks
we
we
see
here,
so
creating
a
slack
account
GitHub
Etc.
A
So
to
be
sure
we
we
haven't
received
an
email.
Yet,
of
course,
we
first
need
to
complete
the
remaining
tasks,
so
we'll
create
a
slack
account
done
or
add
them
to
the
HR
System
and
by
the
way.
The
reason
this
demo
shows
creating
multiple
tasks
is
because
the
first
task,
this
one
is
a
dependency
for
all
of
these,
so
just
to
to
show
that
you,
you
can
choose
to
have
sequential
tasks
or
even
tasks
running
in
parallel,
maybe
even
assigned
to
different
members
of
your
staff.
A
So
that's
just
that's
the
reason
why
this
is
running
in
parallel
because
individually,
they
are
not
dependent
on
one
another.
They
just
depend
on
the
employee
having
an
actual
account
set
up
all
right.
So
then,
the
final
one,
and
now
we
should
have
received
an
email.
Oh
look:
we
have
a
refresh
our
refresh
error,
so
let
me
refresh
here-
and
indeed
we
received
an
email
sent
to
the
new
employee,
so
the
new
employee
is
being
welcomed
on
board
all
right
and,
of
course
it
also
works
when
you
have
multiple
employees.
A
So
if
you
look
at
the
onboarding
web
example,
I
mean
the
the
workflow
server
example.
There's
a
sample
HP
file
that
can
send
multiple
requests,
so
I
could
send
one
for
the
for
for
these
employees
at
once.
So,
let's,
let's
see
how
it
works,
so
I
fired
three
of
those
requests,
so
the
we
have
three
more
workflow
instances
running
at
this
point,
which
also
means
we
should
see
at
least
three
well
just
three
tasks
in
the
in
the
dashboard.
If
it
worked
so
something
went,
went
wrong.
A
It
seems,
of
course,
because
the
these
calls
are
tailored
to
this
workflow
server,
which
has,
as
I
mentioned,
the
workflow
implemented
in
codes,
which
has
its
has
a
different
definition
ID.
So
here
I'm
using
onboarding
workflow,
that's
the
definition
of
this.
So
of
course
this
doesn't
exist
in
the
workflow
that
we
created
in
the
designer.
But
that's
okay.
A
Now
that
we're
looking
at
this
file,
let's
take
a
look
at
the
workflow,
how
you
would
implement
it
in
code,
so
in
code
you,
you
have
to
implement
the
I
workflow
interface
or
derive
your
class
from
workflow
base,
which
brings
a
few
convenience
methods
for
you.
So
this
is
the
recommendation
to
implement
this
base
class.
Then
you
get
a
workflow
Builder
this.
This
is
a
new
activity
called
parallel,
so
it's
it's.
The
opposite
of
sequence.
A
Parallel
also
allows
you
to
set
a
list
of
activities
to
run,
but
instead
of
them
running
sequentially
it
they
run
at
the
same
time.
So
we
have
them
running
in
parallel,
which
is
suitable
for
this
example.
Right
in
the
designer.
However,
there's
no
designer
support
for
parallel
or
sequence
activities,
but
using
the
flowchart
activity
you
can
achieve
the
same
effect
because
of
the
forking
and
joining
capabilities
of
a
flowchart.
So
but
but
when
using
Code,
a
parallel
is
more
convenient
to
use
than
having
to
use
the
flowchart.
A
A
That's
right,
so
the
the
Run
task
activity
creates
a
bookmark
and
then
suspense.
Well,
it
creates
a
bookmark
and
that's
it.
It
doesn't
complete
itself.
It
also
doesn't
block
the
activity
workplaces
from
from
you
know,
going
out
of
memory,
so
it
will
just
the
the
workflow
Runner
will
just
see,
for
example,
if
it
Encounters
this
activity,
which
creates
a
bookmark,
it
doesn't
complete,
which
means
no
subsequent
activities
will
be
scheduled,
which
means
the
workflow
will
now
become
suspended.
A
There's
no
more
work
to
be
done,
so
it's
just
going
to
go
to
sleep
until
the
bookmark
gets
resumed.
So
how
does
this
bookmark
get
results?
I'm
glad
you
asked
that
happens
like
this.
So
let
me
show
you
the
external
application,
so
the
external
application.
We
have
the
home
controller
and
remember
we
have
buttons
right.
So
let
me
run
the
workflow
just
real
quick.
So
here
we
have
the
complete
button
when
we
click
this
one
in
the
external
application.
We
invoke
this
action
and
then
what
it
does.
A
A
So
it
invokes
an
endpoint
on
the
workflow
server
called
tasks,
task,
ID
and
then
complete,
and
this
endpoint
on
the
workflow
server
will
then
resume
The
Bookmark
associated
with
this
task,
and
it
will
also
include
any
results
so
in
this
demo
we're
not
providing
any
any
input,
but
we
could
provide
some
some
additional
data
if
we
wanted
to
which
can
then
be
used
in
the
workflow.
So
let's
take
a
look
at
this
endpoint
from
the
workflow
server.
For
that
we
go
to
Elsa,
workflows
API.
Here
we
have
a
tasks
resource
and
then
the
complete
endpoints.
A
So
this
endpoint
will
be
invoked
on
the
server
and
it's
internally
just
differs
to
the
task
reporter.
So
this
is
an
API
to
report
completion
of
a
given
task.
So
it's
Associated
by
this
task.
Id-
and
here
you
can
see
it's
gonna
construct
a
bookmark
to
be
resumed,
so
it's
It's
associated
by
this
task.
That's
how
it's
able
to
locate
The
Bookmark,
which
is
part
of
the
hash
of
the
bookmark,
and
we
provide
some
input.
If
we,
you
know
it
could
it
can
be
now,
but
it
could
also
have
some
application
specific
data.
A
Then
we
generate
the
activity
type
name
which
we
need
in
order
to
resume
a
bookmark.
We
need
to
provide
it
with
a
bookmark
payload
and
the
activity
type
name
associated
with
The
Bookmark
the
input,
and
then
we
just
dispatch
this
request,
and
this
will
then
cause
the
blocked
activity
to
be
resumed,
which
will
then,
if
we
look
at
the
Run
task
activity,
so
here
just
to
go
over
the
execute
method.
What
it
will
do.
It
will
create
this
bookmark
as
mentioned,
and
then
when
this
bookmark
gets
resumed.
We
we
end
up
in
this
method
here.
A
So
when
we're
creating
a
bookmark,
we
specify
this
callback,
and
this
callback
will
then
be
invoked
by
the
runtime
all
it
does.
It
just
sets
any
input
that
it
receives.
It
will
pass
it
along
as
its
output
and
now,
in
our
case,
we
don't
have
any
inputs
or
there
will
be
no
output,
but
then
it
will
complete
itself
so
through
the
complete
activity.
A
A
A
You
could
also
have
chosen
to
send
a
service
bus
message
to
some
queue
and
then
have
to
work
for
Server,
listen
on
that
queue
and
then
the
consumer
would
then
you
know
resume
the
workflow,
so
it's
very
extensible,
but
out
of
the
box,
will
have
a
couple
of
convenient
modules
to
to
to
allow
you
to
just
use
it
without
having
to
implement
it
yourself.
So
HP
webhook
communication
is
just
very
common.
B
A
B
A
Yeah
I
was
anticipating
that
question
and
the
answer
is
right
now:
there's
no
support
yet,
but
it
I
think
it
makes
sense
to
be
able
to
configure
a
run
task,
maybe
with
additional
outcomes
so
either
it
should
be
a
fixed
predefined
set,
let's
say
completed
and
canceled.
They
may
be
failed,
for
example,
so
that
the
external
application
can
provide
the
the
actual
result,
whether
it
succeeded,
canceled
or
failed,
or
maybe
to
be
configurable,
and
then
it
becomes
very
application
specific.
So
maybe
for
create
email
accounts.
A
There
could
be
two
results,
one
would
be
okay
and
another
one
could
be
already
exists
as
you
as
you
mentioned,
and
then
for
creating
the
slack
account.
There
could
be
different
results.
Different
outcomes,
which
you
can
do
already
today,
of
course,
is
to
just
provide
the
actual
result
through
the
through
the
output
that
you
can
send
from
the
external
application.
So
from
the
external
application
you
can,
you
can
pass
along
some
arbitrary
application,
specific
data
which
could
include
details
about
whether
the
tasks
succeeded
or
not,
and
then
in
your
workflow.
A
You
can
handle
this
data
by
using
the
flow
switch
activity
or
the
flow
decision
activity
to
to
set
up
a
condition
based
on
the
on
the
input
you
received,
but
to
keep
your
workflow
concise.
It
would
be
nicer
to
be
able
to
map
it
to
actual
outcomes
so
that
you
don't
have
to
do
this
flow
decision
or
flow
of
flow
switch
activities.
Yeah.
A
Yeah
yeah,
that
would
be
a
good
enhancement
to
have
but
yeah
yeah
and,
as
you
can
see
this
this
way
you
can
have
simple
orchestration
but
have
the
actual
complexity
of
your
task,
details
implemented
elsewhere
in
your
own
application,
or
even
in
the
also
workflow
itself.
Of
course,
you
can
always
create
custom
activities.
That's
that's
a
very
easy
way,
but
maybe
maybe
there's
a
reason
where
you
just
want
to
use
this
these
activities
and
then
handle
the
the
domain
event
in
your
workflow
server
application
manually.
A
B
B
Do
you
have
any
certain
Target
systems
that
you
want
to
demonstrate,
for
example,
service
now
or
similar
systems
that
you
want
to
demonstrate
this
integration,
because
I
I
think
this
will
be
also
a
good
way
to
promote
this
functionality
that
many
companies
they're
already
using
some
help
desk
system
or
service
system,
and
they
might
have
many
workloads
where
they
want
to
do
more
integration,
which
is
not
coming
out
of
the
box?
That's.
A
B
Application
yeah
I'm
not
sure
how
it
can
be
done,
but
because
there
might
be
a
commercial
application,
but
if,
if
we
can,
for
example,
demonstrate
certain
system,
maybe
service,
now
fresh
service
or
any
kind
of
these
help
desk
systems,
then
we
can.
We
can.
You
know,
promote
this.
This
feature,
as
it
has
a
really
strong
feature
that
we
can
utilize.
B
I'm
not
sure
it
is
the
same
site.
Maybe
it's
I
need
to
check.
It
looks
different,
so
I
think
I'm,
not
sure
this
is
the
same
one
or
not,
but
yeah,
but
we
commonly
use
it,
for
example,
for
help
desk
support
and
I
just
sent
an
email
that
I'm
having
a
problem
with
my
PC.
They
register
it
as
a
ticket
and
then
the
ticket
will
start
a
certain
process
internally
and
sometimes
they
need
to
integrate
with
our
system.
For
example,
procurement.
You
need
to
buy
a
new
hardware
and.
B
B
A
So,
of
course
you
will
have
people
will
have
to
create
your
own
test
accounts,
but
then
they
can
actually
give
it
a
test,
drive
sure
nice
yeah,
that's
good!
So,
as
you
can
see
just
two
little
items,
but
we're
already
over
time.
Of
course,
we
had
a
little
bit
of
a
debugging
session
might
might
have
been
instructive
as
well.
Do
you
have
any
any
questions
at
this
point?
Mohammed.
B
It's
really
interesting
and
I
think
it's
coming
to
a
very
good
shape,
so
really
excited
for
this,
and
personally
I
hope.
I
can
start
using
sf3
soon.
I
have
it
on
my
mind,
also
because
so
far
I'm
still
stuck
with
elsa2,
because
this
is
what
we
have.
This
is
what
we're
working
on
in
production,
but
it's
really
really
exciting.
I
I
really
want
to
get
on
board
of
this,
and
I
have
many
ideas
that.
A
I
want
to
be
great
yeah
I,
look
forward
to
hearing
those
ideas
and
also
getting
your
feedback
on
when
you
actually
get
your
hands
dirty
on
it.
I'm
I'm,
I,
share
the
excitement,
I
think
it's
it's
coming
again,
coming
together
quite
nicely,
as
you
say,
but
I
also
realize
there's
a
lot
of
things
yet
to
be
done.
Lots
of
smaller
details.
Well,
some
are
small.
Some
are
more
serious,
but
I
think
we're
we're
getting
ready
for
a
decent
RC
at
the
end
of
May,
because
already
it's
it's
becoming
quite
useful,
yeah.