►
From YouTube: Elsa Workflows Community Meeting 15 ( 2022-06-28)
Description
Meeting 15
Topics
- Elsa 2
○ Cascading dropdown lists
- Elsa 3
○ Nested activities
Workflow journal
A
Foreign
welcome
back
so
today,
I
wanted
to
show
a
couple
of
things:
I
wanted
to
start
with
a
cool
update
from
Jay.
He
implemented
a
feature
that
lets
you
implement,
cascading
drop
down
lists
in
LSAT
2,
without
make
changes
to
the
front
end
and
to
show
that
off.
There
is
a
small
example
in
the
Elsa
sample
server
host
application,
which
has
a
dynamic
vehicle
activity.
So
first
I
will
show
what
it
looks
like
from
the
designer's
perspective,
and
I
will
dig
in
a
little
bit
in
the
into
this
activity
to
check
out
what
it
takes.
A
Its
values
depends
on
the
values
selected
in
the
model
drop
down
list.
So,
for
example,
if
we
change
this
to
a
show,
then
we
saw
the
let's
change
to
a
different
set
of
values
and
then,
depending
on
the
selected
model,
in
this
example,
the
set
of
colors
changes
as
well.
These
are
cascading
drop
down
lists
all
right.
So
what
does
it
take
to
implement
this?
So
for
that?
Let's
take
a
look
at
the
activity
implementation.
So
here
we
are
yeah
I'll
zoom
in
a
little
bit.
A
So,
first
we
declare
the
brand
property
and,
as
you
can
see,
it
uses
a
UI
hint
of
drop
down.
The
second
one
uses
a
drop
down
as
well.
This
is
the
model
property
and
the
color
and
to
provide
the
available
set
of
options.
You
configure
its
property
with
an
options
provider
and
the
options
provided
needs
to
be
a
type
of
a
class
that
implements
the
eye
activity,
property
options
provider.
In
this
example,
the
dynamic
vehicle
activity
class
itself
implements
this
interface,
but
this
is
not
required.
A
A
I
runtime
select
list
provider
which
exposes
the
get
select
list,
async
methods,
and
this
will
be
involved
from
the
designer
through
an
API
endpoint
into
this
function,
and
here
you
will
receive
the
cascading
drop
down
context
and
from
this
context
you
will
get
the
name
of
the
drop
down
list
for
which
you
need
to
provide
values.
So
here
I
just
set
up
a
dummy
data
source,
but
you
can
of
course
get
data
from
the
database
directly
and
just
to
show
you
the
Gap
data
source
implementation.
A
It
returns
a
array
containing
Brands,
so
this
is
one
brand.
This
is
the
second
brand
and
each
brand
has
a
set
of
models
and
each
model
has
a
set
of
colors.
So
this
is
a
dummy
data
source
and
then,
depending
on
the
value
being
requested,
I
select.
The
brands
from
the
data
source
is
a
set
of
models
are
selected.
Then
I
first
need
to
know.
What's
the
current
brand
and
the
current
brand
is
provided
through
the
dependency
values
object.
That's
a
dictionary!
That's
provided
through
this
context
here.
A
So
it's
a
little
bit
too
dig
through,
but
the
nice
thing
about
this
is
the
only
place
where
you
need
to
configure.
Cascading
drop
downs
is
from
this
activity
or,
as
I
mentioned,
you
can
implement
this
in
a
separate
class,
but
you
don't
have
to
make
any
changes
to
the
front
end
to
make
this
work
all
right.
Next,
up,
I've
been
working
on
the
elsa3
designer
last
week.
I
showed
some
progress
on
the
ability
to
embed
activities
within
another
activity.
A
This
has
been
refined
some
more
so
we
will
look
through
that
and
then
we'll
also
take
a
look
at
the
workflow
Journal
progress.
So
let's
switch
to
Elsa
3
servers
running
and
the
designer
project
is
running
as
well.
So
here
it
is.
This
is
the
dashboard.
So,
first,
let's
take
a
look
at
the
flowchart
demo.
I
think
this
is
basically
what
this
lets
me
show.
You
is
the
ability
to
actually
add
flowchart
activities
to
the
designer
and
being
able
to
edit
its
contents.
So
what
we
have
here
there's
a
simple
right
line
activity.
A
Then
there's
a
flowchart
activity
and
if
we
click
the
pencil
button,
we
enter
its
designer.
So,
as
you
can
see,
we
went
from
flowchart
1,
which,
by
the
way,
is
the
the
root
activity.
So
this
is
the
first
activity
to
execute
from
the
workflow
definition
and
then
the
second
flowchart
this
flowchart
activity.
This
is
only
the
workflow.
If
you
will
so
it
starts
with
another
right
line.
Activity
that
writes
the
text,
hello
world,
then
a
triple
dot
which
itself
this
activity
is
also
a
flow
chart.
A
So
we
can
drill
into
that
one
and
the
only
thing
this
thing
does
is
iterates
over
a
set
of
items
and
in
this
case
it's
looping
over
an
array
of
three
dots
so
just
to
mimic
some
progress.
And
then
the
body
looks
like
this,
so
it
waits
for
one
second
and
then
prints
the
current
item,
which
of
course
is
a
DOT
okay.
So
let's
go
back
up
so
now
we
are
here.
A
So
we
are
printing,
hello
world,
then
every
so
many
milliseconds
I
think
three
quarters
of
a
second
will
print
a
period
and
then
final
right
line
activity
from
this
flow
chart
and
we
go
up
one
level.
We
write
the
end
right
line
all
right,
so
let's
publish
this
workflow
and
then
we
will
give
it
a
run
and
see
if
it
works.
Well
that
execute
so
I'm
switching
back
to
the
console,
and
indeed
we
see
the
start
right
line
activity.
Then
we
enter
the
flowchart
activity
which
writes
hello
worlds,
every
second
or
every
750
milliseconds.
A
It
writes
the
current
item
in
the
list
and
another
right
line
and
then
in
the
root
layer.
The
final
right
line,
so
this
ability
to
group
activities
is
very
powerful
because
it
lets
you
create
a
maintainable
workflow
where
you
can
group
functionality
together
in
higher
level
activities
like
this,
but
the
next
step,
of
course,
will
be
the
ability
to
visually
Define
custom
activities
from
the
designer
so
basically
being
able
to
create
your
own
activity,
library
from
the
designer
without
having
to
write
them
in
source
code.
A
A
There's
no
type
of
variable,
of
course,
there's
a
data
type,
but
there
will
be
a
by
direction
if
you
will,
and
in
Direction,
in
an
out
Direction,
which
is
very
similar
to
Windows
workflow
Foundation
4..
These
variables
are
linked
to
the
workflow
definition
itself,
but
container
activity
such
as
the
flowchart
type,
they
can
have
their
own
scope
of
variables
as
well,
so
that
will
be
leveraged.
The
second
type
of
or
second
category
of
custom
activities
will
be
templated
activities.
So
imagine
you
have
different
kinds
of
HP
endpoints.
Maybe
they
listen
for
certain
web
events.
A
You
want
to
use
them
across
workflows.
What
you
could
do
is
create
a
new
activity,
configure
its
values
using
and
for
example,
here
you
can
configure
supported
methods,
policy
and
a
path,
although
HP
endpoint
one
is
or
HP.
Endpoint
is
a
not
a
good
example,
because,
typically
you
will
only
want
one
kind
of
endpoint.
So
let
me
find
another
example.
Well
to
be
honest,
the
set
of
activities
here
is
a
little
bit
limited.
A
Maybe
it
will
be
a
run
JavaScript
activity
right,
so
you
want
to
execute
a
bit
of
logic,
but
instead
of
having
to
copy
and
paste
this
script
and
all
of
the
activities
where
you
want
to
use
it
across
workflows,
you
would
just
create
one
templated
run
JavaScript
activity
with
the
specific
codes
you
want
to
execute
and
then
that
template
becomes
available
as
a
different
activity.
For
example,
it
would
be
execute
my
custom
logic
activity
right
underneath
scripting
or
another
category
that
you
can
specify.
A
So
that's
the
second
category
of
custom
activities
that
you
will
be
able
to
implement
and
the
third
category
will
be
scripted
activities.
So
what
it
will
allow
you
to
do
is
you
will
manage
a
set
of
scripts.
So
these
are
not
activities,
they
are
just
script
definitions
and-
and
they
could
be
of
any
language
that
the
system
supports.
A
So
initially
it
will
be
just
JavaScript,
but
it
could
also
contain
python
c-sharp
even
and
anything
else,
this
system
will
be
extensible
and
the
nice
thing
about
this
will
be
that
users
will
now
be
able
to
implement
activity
logic
from
the
designer
these
definitions.
These
scripted
definitions
will
become
available
as
activities
and
I'm
thinking
of
maybe
implementing
node.js
so
that
you
can
write,
use,
JavaScript
and
write
activities
the
same
way.
A
You
can
do
it
in
c-sharp
directly,
where
you
have
access
to
all
of
the
services
in
the
runtime
Etc,
but
instead
of
doing
it
from
c-sharp
source
code,
where
you
have
to
compile
everything,
you
can
do
it
straight
from
the
designer
and
it
will
be
evaluated
at
runtime.
This
is
just
an
idea.
It's
going
to
be
experimental,
but
we
will
see
how
far
we
get
with
that
all
right.
A
So
let
me
clean
this
up,
so
the
final
topic
is
the
workflow
journal
and
the
workflow
Journal
is
is
a
list
of
steps
that
a
workflow
went
through
as
it
executed.
So
for
that
we
will
look
at
the
workflow
instances.
I
will
take
the
last
one
that
I
just
run,
and
the
idea
of
of
the
word,
for
instance
viewer,
is
that
it
shows
you
the
workflow
definition
at
the
time
it
executed.
A
So
it's
bound
to
the
version
of
the
word
for
definition
when
it
executed,
it
doesn't
have
navigational
support
yet
the
same
way
it
does
with
the
workflow
definition
editor,
but
that's
coming
we'll
close
this
now
we'll
open
it
here.
It
is
so
what
we
see
on
the
left
hand,
side
is
the
journal
and
the
way
it
works.
A
It
starts
from
the
root,
so
every
word
for
definition,
starts
with
a
single
activity
and
when
created
using
the
designer,
that
will
always
be
a
flowchart
for
now
and
the
flowchart
contains,
as
you
can
see,
three
activities,
the
start
activity,
the
print
hello
world
activity,
this
one
and
the
Ant
activity.
So
that's
what
we
see
here
so
first,
it
executed
the
flowchart
and
as
part
of
that
flowchart
it
executed,
start
print,
hello,
world
and
ends
and
of
course,
the
print
hello
world
itself
is
also
a
floater.
A
So
we
can
drill
into
this
one
I,
don't
think
this.
Oh
this
actually
works
surprisingly
enough,
but
yeah.
So
drilling
into
that
one.
We
see
that
hello
world
executed
the
dot
dot
activity,
which
itself
is
also
a
flowchart,
and
then
the
little
Micro
World
rightline
activity
executed
here,
and
we
can
drill
into
this
one
as
well,
and
indeed
it
executed
the
for
its,
and
you
can
see
the
three
iterations
of
the
foreign
go
into
this
one.
You
should
be
able
to
expand
this
one
and
see
that
both
wait.
A
One
second
execute
it
for
about
almost
a
second.
So
this
makes
sense
because
it
was
configured
to
three
quarters
of
a
second.
So
it's
not
very
accurate,
at
least
the
recording
of
the
execution
time.
I,
don't
want
to
say:
quartz
isn't
accurate.
Maybe
it
is,
but
there
may
be
some
lag
time
between
when
it
executed
and
the
event
got
locked
and
persist
in
the
database
and
then,
of
course,
the
print
current
item
executed
as
well
and
then
the
second
iteration
and
the
third
one.
So
this
is
what
the
workflow
Journal
looks
like
right.
A
Now,
it's
an
initial
version
we
might
enhance
it,
maybe
make
it
more
visual
that
we
are
in
a
lower
in
and
there's
a
level
of
the
hierarchy
right
now.
It
could
be
confusing.
I
think
that
everything
is
at
the
same
level,
and
yet
it's
nested,
but
yeah
we'll
give
it
some
thought
all
right.
So
I
briefly
mentioned
what
will
be
next
and
that's
the
ability
to
create
custom
activities
from
the
designer
another
feature
that
I'm
planning
on
working
on
is
flow
node
activities.
So
let
me
show
you
why
we
need
it.
A
Let
me
just
create
a
new
workflow
to
show
that
so
let's
say
we
have
a
right
line
activity
and
an
if
activity
and
another
right
line.
So,
as
you
can
see,
the
effectivity
has
a
den
and
an
else
Port,
as
it's
called
right
now.
These
are
properties
on
the
effectivity
in
the
area
of
type
I
activity,
so
we
can
add
one
activity
or
assign
one
activity
to
the
Dell
property
and
you
throw
the
designer.
A
This
will
also
be
a
flowchart
for
now
I'm
planning
on
adding
support
for
the
ability
to
drag
and
drop
an
individual
activity
straight
into
one
of
these
ports,
so
that
it
doesn't
doesn't
have
to
be
a
flowchart
and
maybe
also
being
able
to
do
it
straight
from
the
designer
into
it.
But
it
will
maybe
that
comes
later.
But
what
I
want
to
talk
about
is
the
the
fact
that
then,
and
else
ports
they
are
enclosed
within
the.
A
If
so,
there's
there's
no
way
to
right
now
to
have
logic
in
the
current
view,
from
where
you
can
connect
another
activity
to
the
den
and
staying
in
the
same
level
in
this
in
the
same
flowchart,
and
for
that
we
need
a
different
kind
of
activity
and
I
call
that
the
float
out
flow
activities
and
what
it
allows
you
to
do
is
to
have
a
similar
activity
that
we
have
in
LSAT
2,
where
we
have
two
outcomes,
a
true
and
a
false
outcome.
So
it's
a
it's
conceptually
a
little
bit
different.
A
It
will
still
have
a
condition
to
configure,
but
instead
of
the
activity,
scheduling
the
then
or
the
else
activity,
it
will
communicate
to
the
flowchart
activity
that
the
true
order,
false
outcome,
ICU
of
it,
and
that
will
then
cause
the
flowchart
activity
to
schedule.
The
next
outcome
or
the
next
activity
connected
to
the
true
order,
false
outcome.
You
have
that
kind
of
activity.
A
Similarly,
we'll
have
a
version
of
the
switch
activity
which
right
now
behaves
similar
to
if,
where
you
have
embedded
activities,
but
the
flow
switch
activity
will
have
outcomes
like
these
little
ports
here
from
which
you
can
connect
other
activities
in
a
more
in
a
flowchart
style.
So
yeah
I'm
pretty
excited
about
that.
Overall,
it's
coming
along
nicely.
A
There's
there's
a
little
bit
of
work
to
do
on
the
runtime
itself,
just
some
optimizations
and
implementing
a
runtime
that
does
not
rely
on
the
protoacter
framework,
although
the
protoactive
framework
is
great
when
you
are
hosting
in
a
multi-node
environment,
but
I
also
would
like
to
offer
a
runtime
that's
simpler,
but
maybe
more
suitable
in
single
node
environments.
Maybe
if
you
implement
a
workflow
service
just
to
do
some
some
tasks,
maybe
you
don't
need
an
actor
framework
all
right!
That's
all
I
had
I'll
see
you
next
week.