►
From YouTube: Elsa Workflows Community Meeting 23 ( 2022-10-27)
Description
Topics
- Demos
○ Frans & alter ego
○ Jay: dispatcher
○ Elsa 3 updates: forks & joins, auth
Links
Proposal: Parallel Processing of Branches · Issue #2872 · elsa-workflows/elsa-core (github.com)
Workflow-driven UI:
Documentation: https://medium.com/@fanekkie/part-1-ui-driven-by-elsa-workflows-6d0e868ea6c
GitHub repo: FransVanEk/ElsaDrivenUI: A demonstration project to use Elsa as UI engine (github.com)
A
Hi
everyone
and
welcome
today
we're
using
teams,
as
you
noticed
just
to
see
if
this
works
better.
We
did
a
test
now
a
minute
ago
and
it
worked
pretty
well
so
so
I'm
hopeful
that
this
time
the
audio
will
be
good
and
the
screen
will
be
good
as
well.
So
for
today's
meeting,
I
have
one
demo
that
I
would
like
to
show
which
is
called
asynchronous
activities.
I,
don't
know.
If
anybody
else
has
a
meeting.
A
A
C
A
A
A
A
Database
disk
image
map
alrighty.
So
let
me
just
got
this
for
a
second
and
delete
this
database
right,
so
just
to
show
you
what
a
job
could
look
like
in
in
Elsa
using
lsas
apis,
it
doesn't
have
to
be
an
else.
A
job
right
could
also
be
a
hang
priority.
App
doesn't
matter,
but
Elsa
comes
with
a
job
Runner
out
of
the
box
that
operates
or
runs
jobs
in
memory.
So
it's
not
like
Hang
Fire,
where
you
have
persistent
jobs.
A
Not
yet,
please,
maybe
we'll
have
that
as
a
as
a
feature
later
on,
but
for
now
it's
just
something
to
get
going
with
jobs
and
to
implement
a
job.
You
create
a
class
that
derives
from
job
and
then
implement
the
executive
method
and
that's
it,
and
this
is
not
an
activity,
so
you
could
have
custom
code.
Let's
say
you
have
an
asp.net
controller
and
you
want
to
kick
off
a
background
job
to
process
some
work.
Maybe
you
want
to
index
the
blockchain.
A
It
says
this
demonstrates
or
process
some
videos
or
whatever
it
doesn't
matter.
The
point
being
you
have
some
long-running
work
to
do,
and
you
don't
want
to
block
the
UI
or
other
processes
like
workflows.
You
just
want
to
kick
off
the
job,
and
once
it's
done,
you
want
to
be
notified
about
that.
So
in
this
case
the
workflow
needs
to
be
notified
about
a
finished
job
so
that
the
workflow
can
continue.
That's
a
typical
use
case
to
make
this
simpler.
A
A
It
has
a
job
activity
provider
and
what
is
an
activity
provider?
It
provides
activity
types
to
the
system
and
in
this
case
it's
doing
it
based
on
available
jobs
that
are
registered
with
the
system.
The
default
activity
provider
provides
activities
to
the
system
by
reflecting
on
classes
that
Implement
eye
activity,
so
you
can
imagine
different
kinds
of
providers
and
they
all
work
together
in
the
sense
that
they
all
contribute
to
the
total
set
of
activities
that
you
would
see
in
the
toolbox
here.
A
So
that
has
a
little
background
of
activity
providers.
It
works
the
same
in
Elsa
too,
so
this
one
takes
the
job
registry.
So
that's
that's
like
a
little
dictionary
containing
the
available
job
types
that
we
have
in
the
system
and
then
it's
the
the
this
provider
instantiate
activity,
descriptors
and
as
part
of
this
descriptor,
we
have
a
Constructor
that
takes
care
of
instantiating
the
activity
to
activate
so
here
I'm
using
a
job
activity,
any
job
activities,
it's
a
general
purpose,
job
activity
that
that
you
configure
with
a
job
type
to
instantiate
and
execute
or
schedule.
A
A
I
would
say
it
isn't,
because
in
elsa3
you
have
to
explicitly
register
the
activity
types
that
you
want
to
be
displayed
in
the
uis,
but
because
I
didn't
do
that.
You
don't
see
this
job
activity
in
the
toolbox
here,
but
in
theory
you
could
do
it
and
then
it
would
appear
here
as
a
job
activity
activity
which
you
then
have
to
manually
configure
with
the
job
type,
but
because
I'm,
using
the
activity,
type
provider
of
the
classes
that
Implement
job
will
appear
here
as
an
activity.
A
Like
so
yeah
and
then
what
will
happen
here
is.
Excuse
me.
My
throat
is
a
little
bit
right,
so
yeah,
sorry
about
that,
so
the
right
line
will
execute.
First,
then
this
will
execute
it
will
sketch
and
queue
the
job
execute.
In
the
background,
while
that
happens,
this
workflow
instance
will
be
suspended,
so
it
will
be
or
will
go
out
of
memory,
and
then
it
will
resume
the
workflow
once
until
finishes
and
then
ends
with
the
final
language,
so
I've
already
demoed.
A
Of
course,
if
we
Branch
out
to
other
branches
that
are
performing
work,
then
the
workflow
will
not
be
suspended,
yet
it
will
only
get
suspended
once
there
is
no
more
work
to
be
done
and
there's
a
blocking
activity
or
there's
a
there,
are
bookmarks
added
to
the
system
and
then
but
an
activity
executes
in
the
foreground,
so
to
say
so,
a
right
line
executes
in
the
foreground
this
one
as
well.
It's
also
right
line
this
one
executes
in
the
background.
A
A
A
A
A
The
workflow
would
be
executing
several
seconds
as
I
mentioned
and
if
I
add
another
one
and
I
four
create
a
fork
like
this,
then
in
elsa2
and
currently
in
Elsa
3.
This
workflow
in
total
will
take
15
seconds
to
complete,
because
this
is
not
a
true
parallel
Fork.
The
way
this
works,
it's
it's
sequential.
So
it's
first
gonna
execute
this
one.
Then
second,
one
audio
all
the
way
around,
depending
on
the
order
in
which
you
created
these
connections.
A
But
it's
not
truly
parallel
and
that's
that's
a
limitation
of
the
Elsa
II
engine
and
before
the
pr
that
I
created
today.
It
was
a
limitation
in
this
system
as
well,
but
to
work
around
that
you
could
create
a
a
job
and
now
you
can
also
create
activities
and
the
key
will
be
to
specify
the
the
kind
of
the
activity.
A
So
what
we
have
here
is
we
have
a
an
activity
attribute
which
allows
you
to
provide
information
like
the
namespace
to
uniquely
identify
this
activity
to
avoid
name
collisions,
basically,
a
category
which
is
used
in
the
activity
picker,
a
description
which
is
also
used
in
the
activity,
picker
and
a
kind,
and
we
have
a
bunch
of
them.
So
we
have
the
default.
One
is
an
action,
so
that's
like
brightline
send
email
out
of
the
box,
they
are
now
actions
and-
and
so
they
are
activities
that
run
in
the
foreground.
A
We
have
triggers
which
are
activities
like
HTTP,
endpoint
message
received
or
timer.
That's
those
kind
of
activities,
and
then
we
have
job
and
a
job
will
execute.
In
the
background
always
and
then
we
have
task
and
the
task
is-
could
be
a
job
or
it
could
be
an
action
the
and
this
depends
on
what
the
user
configures.
So
what
I
used
here
is
I
configured
this
activity
as
a
task,
so
this
allows
the
user
to
select
this
task
Tab
and
then
execute
asynchronously,
so
the
difference
will
be
so.
These
are
not
configured
as
asynchronously.
A
A
A
A
So
now,
as
you
can
see,
it
takes
a
long
time
and
if
we
go
to
the
console,
we
see
that
it's
it's
running
that
long
well
that
this
this
heavy
activity
in
the
foreground,
so
only
after
it
was
done
executing
we
would
return.
Her
I
received
a
response
from
the
server
and
now
I'm
gonna
change
this
to
running
to
execute
asynchronously.
So
in
other
words,
in
the
background,
so
we'll
publish
this
again
and
this
time,
when
I
do
a
new
execution,
we
will
get
an
instant
study
immediately
in
the
meantime
that
activity
executes.
A
In
the
background-
and
at
this
point
the
workflow
instance
is
suspended
and
only
after
the
job
finished
will
workflow
execution
resume,
and
this
enables
us
to
do
things
like
well.
It
achieves
close
to
True
parallelism
and
I'm,
saying
close,
because
it's
still
not
entirely
parallel,
because
these
brands
are
still
execute
sequentially
one
after
the
other,
but
because
these
activities
execute
in
the
background
they
get
basically
Intuit
into
a
as
a
job,
both
of
them
and
that's
a
quick
operation.
So
they
both
execute
quickly.
A
A
A
D
A
If
you're
talking
your
muted,
oh
sorry
about
that
thanks
Christina,
so
I
was
saying:
that's
right!
That's
a
good
question!
So
let's
update
brightline
to
right
end
and
this
one
start,
and
these
are
asynchronous
again.
Let's
let's
see
that
indeed,
this
one
executes.
Lastly,
even
even
though
these
execute
asynchronously,
because
that's
the
the
nice
thing
about
this
setup,
the
workflow
orchestration
is
still
synchronous
and,
as
you
can
see
it
right
and
just
once.
D
A
That's
right,
so
so
indeed,
when
I,
whenever
I
invoke
this
API
endpoint,
it
will
not
not
sure
if
it's
going
to
do
yeah,
it's
it's
invoking
it
synchronously,
because
it's
executed
so
that
we
have
dispatch
dispatch,
will
always
return
immediately.
Even
if
you
don't
use
backgrounds
running
activities
right,
because
we
are
sending
a
message
to
a
queue
and
then
the
consumer
of
that
method
tool
execute
the
workflows-
or
this
already
happens
in
the
background,
but
the
workflow
itself
will
still
take
let's
say
15
seconds.
A
If
you
don't
run
those
activities
in
the
background,
execute
will
run
the
workflow
from
start
until
it
gets
either
suspended
or
when
it
finishes.
But
yes,
because
because
those
two
activities
are
scheduled
to
execute
in
the
background,
it
will
return
a
result
quickly,
at
least
the
instance
that
it
will
be
returned.
And
if
you
were
to
inspect
the
status
of
this
instance,
it
would
still
be
set
to
running
for
executing.
B
We
also
Revisited
and
join
and
and
the
option
there
to
have
an
explicit,
join
and
indicate
that
there
was
some
cancellation
on
the
execution
of
the
branches
and
I
would
like
to
revisit
that
at
one
point,
because
I
find
it
a
bit
confusing,
but
thinking
of
that
would
then,
if
we
had
an
explicit,
join
there
and
one
of
them,
maybe
there
are
some
other
steps
as
well.
Just
arrived
arrived
first.
A
It's
it's
very,
it
seems
very
convenient
to
be
and
that
that
it
will
automatically
cancel
If,
This
Were,
a
timer,
and
this
were
a
user
event
that
you're
waiting
for
to
just
cancel
it.
But
maybe
in
other
cases
you
do
want
to
do
some
additional
stuff,
as
you,
as
you
pointed
out
during
one
of
the
last
meetings,
so
you
you
want
some
control
so
and
what
the
default
should
be.
I
don't
know,
but
maybe
on
the
flow
join
you
should
have
in
the
settings.
A
B
A
Yeah
that
sounds
nice
to
have
explicit
control
to
cancel
some
trigger
yeah,
so
I
I
would
like
to.
If
you
want,
if
you
can,
maybe
you
can
show
it
to
us
how
this
works
in
BP
command
at
some
at
some
point
for
inspiration,
because
then
we
can
learn
from
that
and
use
it.
So
so
I
like
having
that
option
as
well.
B
A
Do
that
all
right,
but
for
now
for
the
second
part
of
your
question,
whenever
this
joint
happens,
it's
not
gonna
cancel
this.
So
what
what
the
join
will
do
is
it
will
clean
any
bookmarks,
but
it
has
no
awareness
of
ongoing
jobs
in
the
background.
So
this
is
a
good
topic
to
to
consider
and
talk
about
what,
but
what
should
happen
should
we
control
have
some
control
using
either
explicit
activities
and
or
a
setting
on
the
flow
join
to
control?
A
C
Yeah,
probably
it
is
something
that
maybe
we
need
to
Define
for
a
background.
What
would
be
the
kind
of
behavior?
So
if,
for
example,
we
are
executing
some
long-running
database
job,
so
probably
it
has
to
be
rolled
back
or
something.
But
if
you
are
copying
files-
or
maybe
it
is
fine
that
we
just
interrupted
in
between
so
maybe
it
is
something
that
we
need
to
Define
in
the
job
level.
What
could
be
the
canceling
Behavior.
A
I'm
hearing
some
background
noise,
which
is
a
little
bit
distracting,
not
sure
who,
who
that
is.
But
if,
if
you
have
a
mic
against
your
beard
or
something
maybe
move
it
a
little
bit
further,
so
Muhammad,
if
I
understand
correctly
you're
suggesting
to
have
some
behavior
on
a
given
job,
the
control
when
it
should
be
canceled,
I'm,
not
sure
I
I
understood
that
that
suggestion.
Maybe
you
can
elaborate
a
little
bit
not.
C
B
No
me
neither
so
no,
but
in
bpmn
there
is
something
like
an
event
that
you
can
put
on
an
activity
as
well.
That
is
compensation
which
basically
says
whenever
something
fails.
In
that
case,
the
compensation
needs
to
be
taken
or
need
to
be
activated
and
from
there
on,
you
can
Define
what
needs
to
be
activated
to
do
for
incision
role
by
Common
transaction
or
a
database,
and
so
on.
A
So
that's
for
failure
of
faults.
Is
there
also
something
for
cancellation
so
so,
as
Muhammad
suggested?
Let's
say.
Indeed,
we
want
to
cancel
using
some
activity,
some
job
and
then
the
job
should
either
have
built-in
logic
to
undo
what
it
did.
Is
there
something
for
that
in
in
bpmn
handling,
cancellations
and
not
just
false.
D
A
All
right,
so
what
do
you
guys
think
about
this
thing?
That
I
did
because
I'm
not
entirely
sure
I
think
on
the
one
hand,
it's
nice.
On
the
other
hand,
it
could
be
a
little
bit
unintuitive
or
confusing,
because
from
from
first
looks
what
you
know,
what's
the
difference
between
an
action
and
a
task,
another
implementation
could
have
been
to
just
say:
well,
maybe
an
activity
could
be
an
action
and
a
job.
A
B
B
A
A
Let
me
see
if
I
forgot
something
in
terms
of
the
implementation.
Oh,
it
is
there's
one
thing
that
hasn't
been
done
yet
and
that's
the
following.
This
takes
me
to
the
implementation
of
the
of
this.
This
background
execution
of
activities
so
just
to
show
you
the
workflow
core
Library,
that's
a
middleware
component
to
execute
activities,
and
it
currently
it
has
two
middleware
components.
A
This
is
synchronous
execution,
but
I
want
to
show
you
how
the
asynchronous
execution
was
implemented.
Now
the
workflow
core
Library
doesn't
have
any
notion
of
jobs,
so
I
I
want
to
keep
the
work,
the
core
Library
as
lean
as
possible,
because
this
could
also
be
used
in
other
environments.
Where
you
don't
need
asynchronous
processing
or
background
processing
like
jobs,
so
what
I
did
instead
I
created
another
implementation
of
an
activity,
execution,
middleware
components
in
the
job
activities
Library,
and
this
this
middleware?
A
A
In
the
background,
then
it's
not
calling
into
the
base
implementation,
but
instead
it's
going
to
create
a
job
in
the
end,
schedule
that
or
submit
that
job
to
the
queue
and
this
this
job
will
then
actually
execute
the
activity
that
it's
that
that
is
part
of
the
job
being
created
here.
So
here,
I
instantiate,
a
job
assign
it
some
properties
like
the
activity
to
execute
and
some
details
for
the
job
to
be
able
to
resume
the
workflow
once
the
activity
finished
execution
or
the
job
business
execution.
A
So
imagine
I
submit
a
job
to
the
queue
and
this
job
finishes
before
the
creative
bookmark
was
given
a
chance
to
be
registered
in
the
in
the
global
bookmark
registry,
which
is
an
important
component
in
the
Elsa
engine,
because
this
is
how
resuming
workflows
work.
So
if,
let's
say
timer
triggers
or
job
finishes
or
a
message
gets
received,
then
those
handlers
will
resume
Associated
workflows
or
trigger
new
workflows
by
looking
up
bookmarks
being
registered.
But
if
the
bookmark
isn't
there
and
the
job
finishes
before
that,
bookmark
exists.
A
There's
no
workflow
to
be
resumed,
and
you
can
imagine
that
if
the
job
Indeed
finishes
beforehand
later
on
the
bookmark
gets
created,
it
will
never
be
resumed
this
workflow.
So
it
will
be
stuck
forever
and
this
is
a
problem,
and
this
can
be
easily
created
this
problematic
scenario
by
creating
a
fork
workflow
where
in
one
branch
you
start
some
work
and
in
the
other
brands
you
perform
a
heavy
operation
in
the
foreground
and
if
that
Branch
executes
first,
then
the
the
the
other
brands
will
not
have
a
chance
to
execute
or
even
worse.
A
If
that
one
executed
and
scheduled
the
job
and
then
the
other
brands
executes
immediately
up
and
then
taking
a
long
time.
The
workflow
will
not
enter
the
suspended
State
and
because,
at
that
point,
that's
when
the
the
bookmarks
get
stored
in
the
database.
So
it's
it's
a
big
timing
concern,
but
this
is
something
I
I
still
need
to
fix,
and
one
idea,
I
have
is
to
take
a
similar
process.
A
We
do
in
Elsa
too,
where
basically,
what
we
do
instead
of
doing
this
work
of
submitting
the
job
to
a
queue
right
here
in
in
in
in
this
state,
we
would
do
it
after
a
workflow
gets
suspended.
So
only
at
that
point
what
we've
actually
scheduled
a
job
so
that
we
can
be
sure
that
bookmarks
have
been
saved
in
the
registry
and
then
it's
safe
to
submit
a
job,
because
if
it
were
to
complete
immediately
it's
no
problem
because
the
bookmark
would
be
there.
A
Well,
yeah,
when
it's
suspense
indeed,
because
so
so
it
shouldn't
happen
as
it
executes,
because
there
may
be
more
activities
to
be
run
and
the
reason
I'm
saying
suspended
is
because
the
bookmark
needs
to
be
safe
there.
So
if
the
bookmark
were
saved
regardless
of
the
workflow
being
suspended,
then
it
doesn't
matter
but
right
now,
that's
the
the
moment
at
which
bookmarks
get
persisted
in
the
bookmark
store
is
when
workloads
get
to
spend
I.
Think
now
that
you
asked
it
I'm
thinking,
maybe
that's
not
entirely
true.
A
Maybe
these
bookmarks
get
persisted
regardless
of
the
the
workflow
being
suspended.
I
need
to
double
check.
It
depends
on
the
the
queue
containing
the
work
for
the
workflow
Engine
2
process
and
I.
Think
as
long
as
it's
processing
stuff
is
not
being
sent
to
the
the
database,
but
yeah
I
need
to
double
too.
A
Yeah,
that's
exactly
right,
so
let's
say
we
have
here
a
process,
video
that
executes
in
the
foreground.
Let's
say
this
is
a
this
could
be.
This
could
even
be
a
loop
during
this
thing,
a
hundred
times
in
the
foreground,
and
if
this
executes
first,
then
this
will
never
be
well.
It
will
be
scheduled
eventually,
but
only
after
this
one
businesses,
that's
right.
A
Yeah,
maybe
on
the
other
hand,
you
can
always
put
work
in
a
job
right.
So
if
you
do
something
like
that,
then
maybe
you
should
put
it
in
a
job
or
maybe
that
we
could
have
some
sort
of
custom
or
some
sort
of
activity.
That's
like
a
container
that
would
ever
work
is
part
of
it.
Whatever
activities
are
part
of
it,
those
who
execute
in
the
background,
so
it
could
make
it
easy
for
users,
but
for
a
developer.
A
They
should
probably
just
implement
it
as
a
as
a
job
in
the
first
place
or
a
task,
and
then
the
user
can
mark
them
to
execute
asynchronously.
But
if
you
run
into
those
scenarios,
then
yeah,
you
need
to
make
sure
those
activities
execute
asynchronously,
because
the
Elsa
engine
itself
will
not
schedule
the
activities
themselves.
Asynchronously.
A
And
we
can
try
to
solve
that,
but
I
think
it's
it's
so
complicated
to
actually
schedule
in
parallel
the
activities,
because
then
at
some
point
no
activity
is
complete,
but
because
you
have
now
multiple
executions
on
different
threads.
Potentially
you
need
to
somehow
merge
the
state
back
into
a
single
object
into
a
single
state
of
the
workflow,
and
then
you
can.
You
know
if,
if
some
process
executed
before
the
other
one-
and
maybe
they
both
updated
a
variable,
but
it's
what
which,
which
version?
Would
you
take?
A
But
maybe
it's
solvable
I
I
I,
don't
know
too
much
about
it,
but
I
think
this
combination,
it's
okay,
because
if
you,
if
you
run
into
the
scenario
you
just
described,
you
can
always,
you
always
have
an
at
least
an
option
to
design
your
workflow
a
little
bit
differently
by
running
that
work
in
a
background
job,
and
then
you
won't
have
the
issue
and
I
think
that's
more
important
that
we
at
least
have
a
workaround
or
a
solution.
Even
if
it's
not
not
ideal.
D
B
That's
if
it
would
go
to
that
one:
oh,
that's
fun,
it
doesn't
so
okay.
So
basically,
this
is
the
implementation.
That
is
a
typical
implementation
for
a
UI
that
interacts
with
an
Elsa
engine
and
basically
the
Elsa
engine
already
contains
controllers
and
workflow
instances
if
they
are
activated
already
bookmarks
and
triggers.
And
it's
a
bit
about
what
we
discussed
in
the
previous
topic.
B
And
if
we
look
at
the
perspective
of
this,
we
start
off
with
the
simple
bookmark
or
not
even
a
simple
bookmark.
We
just
use
this
the
default
way
in
which
and
UI
can
trigger
the
execution
of
the
workflow,
and
in
this
case
it's
just
having
a
blocking
activity
and
sending
a
signal,
and
that
signal
basically
tells
the
workflow
to
continue.
B
And
this
gives
the
opportunity
to
get
a
list
back
of
all
the
tasks
that
a
user
might
perform,
given
the
workflow
instances
that
are
activated.
So
basically,
this
is
the
overview
page
often
to
do
a
list,
and
you
can
use
filters
to
see
which
specific
tasks
there
are.
So
you
can
have
different
lists
in
the
UI
indicating
what
needs
to
be
done.
B
B
Instance,
I
subscribe
to
the
signals
that
are
related
to
that
specific
workflow
instance
ID.
So
I,
don't
listen
to
all
the
events.
I
just
say
whenever
something
happens
for
an
workflow
instance
that
I'm
currently
looking
at
by
this
ID,
please
notify
me
and
certain
R
provides
that
functionality
that
you
can
subscribe
to
a
group
and
the
group
is
done
for
each
workflow
instance
that
is
running
and
whenever
something
is
popping
up
in
that
group,
some
conversation
in
the
signalr,
the
UI,
can
leverage
on
that
and
activate
and
screen.
B
So
let's
look
at
how
that
is
implemented,
so
we
have
several
scenarios
and
basically
this
is
the
simple
ads
dot.
I
didn't
do
anything
Implement
no
implementation
here,
but
whenever
I
press
this
button
it
will
create
an
workflow
instance.
Here
we
have
the
instance
ID
and
when
I
press
this
one
basically
all
I
do
is
send
the
signal
back,
no
payload
indicating
continue
and
then
it
magically
disappears.
B
B
B
B
We
go
further
and
we
can
go
into
an
automatic
mode,
and
this
is
not
using
Circle
r.
This
UI
responds
to
the
signal
and
knows
which
what
type
of
form
to
show
for
this
signal.
So
it
asks
about
and
some
details
and
if
I
continue,
I
run
in
them
in
trouble
with
timing,
and
this
is
because
I
sent
the
signal
and
I
immediately
request
the
status
of
this
workflow
and
we
talked
about
the
timing
issues
in
the
previous
topic
as
well,
and
the
engine
didn't
fully
execute
this
activity.
B
B
So
this
is
one
of
the
reasons
that
you
would
like
to
have.
That
signal
are
in
place
because
then
you
just
whenever
you
send
a
signal,
you
remove
the
form
and
you
wait
for
the
signal
to
indicate
now.
You
I
have
to
show
a
new
form
and
if
we
look
at
how
that
would
work,
basically
the
same
form
I
could
press
continue
and
we
see
the
execution
of
the
engine
in
the
background.
Basically,
these
are
some
timer
jobs,
and
now
it
automatically
shows
the
workflow
user
task
for
this
particular
step.
B
If
we
look
at
these
samples,
they
use
down
sample
six,
and
let
me
go
first
to
the
engine.
It
will
show
you
that
we
have
now
and
a
couple
of
workflows
some
are
finished.
I
will
remove
everything
and
delete
them.
So
we
have
nothing
here
in
the,
as
instance
running,
but
still,
if
I
go
to
this
one
I
can
have
this
screen
where
I
can
fill
in
some
details.
B
B
D
B
Then,
finally,
in
and
the
sample
that
I
made-
and
you
can
see
here-
these
four
menu
options-
five,
if
you
count
in
home,
but
you
can
make
it
really
Dynamic
and
that
the
engine
is
really
driving.
The
UI
and
I
will
show
you
that
by
going
to
this
workflow
definitions,
I
don't
have
any
I
will
create
a
workflow
import.
B
B
B
And
put
it
like,
so
something
that
we
can
recognize
that
it
is
actually
working
on
that
one
we
save
it,
publish
it
and
by
publishing
it
it
will
show
that
there
is
a
new
trigger
here,
because
it
starts
with
the
user
task.
And
if
we
go
to
the
UI
and
we
refresh
this
one,
we
see
that
this
star,
Dynamic
menu
item
is
now
added.
B
I
click
that
one
we
see
that
the
form
is
created
here
that
we
have
the
ability
to
put
in
some
details.
We
continue,
we
have
an
other
layout,
activating
it
will
save
and
it
will
end
the
workflow
and,
if
I
look
at
the
execution
of
this
one
refresh
it,
and
so
we
have
this
Dynamic
screen
go
to
the
instances
and
we
will
see
that
in
the
journal.
All
the
data
that
was
put
in
is
actually
as
the
s
and
the
payload
of
the
signal
added
to
the
journal,
and
you
can
act
upon
that.
D
C
B
B
The
problem
that
I
ran
into
was
I
could
get
the
status
from
a
user
task,
but
because
there
were
also
some
other
steps
in
between
user
tasks,
and
sometimes
the
to-do
list
was
shortened
because
the
engine
was
executing
a
non-user
task
at
that
moment
and
that's
confused.
Sometimes
the
users
saying
yeah
but
I'm
working
on
this,
this
file,
and
sometimes
it's
there
and
sometimes
it's
not
there.
So
I'm
gonna
create
an
additional
blog
post
about
that.
How
to
overcome
that
using
metadata
on
the
workflow
instance.
B
A
A
B
B
A
A
I
use
it
a
lot
myself
in
customer
projects,
but
there's
also
a
lot
of
users
who
who
rely
on
the
stable
releases,
for
you
know
for
good
reason,
because
the
the
migrate
releases
they
can
be
volatile
or
they
can
contain
sudden
breaking
changes.
So
it's
not
ideal
to
be
testing
all
the
time,
but
it's
also
not
ideal
to
have
to
wait
for
an
actual
release
on
nougat.
Then
people
you
know
upgrade
the
packets
and
then
boom
stuff
gets
broken,
takes
prices
and
that's
and
and
the
the
problem
there
is.
A
If
it's
deemed
to
be
a
release,
you
should
you
should
you
would
expect
it
to
be
stable
and
tested,
but
I
the
the
project
relies
on
many
people,
testing
out
certain
features
and
fixes
over
a
certain
course
of
time,
because
well
me
personally,
I
can't
be
testing
every
feature
all
the
time.
It's
a
little
bit
time
consuming
so
I
Rely
a
little
bit
on
others
to
test
as
well.
So
the
suggestion
was
to
do
pre-releases
on
nougat
so
that
people
will
see.
A
Oh
okay,
there's
a
new
release
candidate
for
a
living
version
of
nougat.
Let's
try
it
out
so
because
it's
a
pre-release,
you
know,
there's
still
this
little
caveat
that
it
may
not
work
entirely
properly
yet,
but
it's
about
to
be
released.
There
is
there's
no
major
changes
to
be
expected
in
in
that
release
candidate,
so
people
can
try
it
out
and
if
they
see
issues,
of
course
they
can
report.
A
A
So
2.9
is
here
available
as
a
brand
there's
two
branches
right
now,
because
there
was
a
PR
that
introduced
EF,
core
7
and.net
7..
But
for
me
this
I
ran
into
issues
because
of
I.
Don't
know
if
it's
because
of
the
M2
Chip,
but
I
wasn't
able
to
Target
.net
or
the
same
project
that
that
uses.net
5
and.net7
at
the
same
time,
I,
don't
recall
the
details
exactly,
but
there
was
there
were
some
some
issues
and
it
has
to
do
with
the
MS
build
being
in
two
folders
on
my
machine.
A
A
Maybe
it
would
be
as
simple
as
that:
I,
don't
in
any
case.
For
that
reason,
because
I
haven't
figured
it
out
yet
I
created
a
2.9
x,
Net
5
prince.
So
this
does
not
include.net
7.
Yet
because
I
imagine
many
people
are
still
on
that.
Five
at
least
I
am
so
so
yeah,
so
this
contains
the
latest
fixes
of
the
two
points:
9.0
release
a
2.9.1,
even
I,
think
and
then
we
are
about
to
release
2.9.2
yes,
okay,
yeah,
so
2.9.1
has
been
released,
still
contains
issues,
so
2.9.2
is
in
the
making.
A
A
Yeah
yeah
so
I,
don't
think
the
at
least
for
me
personally,
I,
don't
think
it's
the
goal
for
everyone
to
skip
Net
7
until
net
eight.
It
should
be
up
to
anyone
and
everyone
themselves
to
decide
if
they
want
to
Target
that
platform.
But
yeah,
though
in
in
my
view
it's
not
like
that
Net
7
is
not
supported,
it
will
be
supported
and
that's
after
for
a
while
I,
don't
know
for
how
long,
but
then
at
some
point
it's
out
of
support,
but
it's
not
like
it's
never
supported
right.
A
C
A
Yeah
yeah
exactly
so,
the
monster
breath
is
broken
because
of
that
yard.
So
I
think
you
should
fix
it
so
somebody's
making
a
lot
of
windy
noise
Let's,
let's
move
ourselves
when
we're
not
speaking
thanks,
so
yeah
I
agree
with
the
most
friends
should
work
without
the
the
next
seven,
because
that's
still
on
the
preview
so
and
now
it's
it's
broken
for
many
people
who
don't
have
seven
installed,
at
least
for
me.
It's
broken
so
I'm
gonna
fix
that.
A
So
what
I'm
gonna
do
is
merge
Master
into
2.9
points,
X
I'm,
gonna,
delete
net
five
and
instead
create
a
net
seven,
so
people
who
do
want
to
use
Net
7
and
then
yes,
core
seven
Etc.
They
should
then
use
this
brand
and
yeah.
We
need
to
figure
out
how
we
can
still
provide
builds
can
make
them
available
on
my
gate.
Actually
that
should
shouldn't
be
too
harsh.
B
D
C
C
Yeah,
okay,
so
this
is
the
Safari
browser.
It's
it's
visible,
so
maybe
next
time
then
I
will
come
straight
how
to
run
from
code
spaces.
There
are
some
few
tweaks
that
we
need
to
do
it,
but
finally,
I
was
able
to
make
it
run.
It's
not
optimal,
but
if
you
are
doing
some
code
changes
on
the
go,
you
don't
have
your
machine.
It
can
be
for
help.
So
I
will
present
that
next
time.