►
From YouTube: Elsa Workflows Community Meeting 29
Description
Topics:
- Question from the community: Status of the company yet to be founded? Trying to establish a legal company within the next month to offer paid consultancy service and support
- Plans on establishing an App Store for Elsa for free and paid activities and workflows
- Release of Elsa 2.11, bugfixes (espescially Kafka), perfomance improvements, upgrades to new packages, small features
- Chat GPT helped fixing a problem in the Elsa V3 source code 😆
- Explained the usage of events in Elsa V3 with inputs/outputs/variables and calling the event via Postman
- Debugging an error about inputs and outputs on Events
- Noticed problems with events and multiple HTTP Responses
- Explanation of workflow correlation and usage in events
- Fixes in scoped variables within sub-workflows
- Preview integration of Elsa V3 designer in other UIs
A
A
B
A
So
the
the
time
schedule
is
a
good
question,
I
think
within
the
next
couple
of
months
we
should
have
be
able
to
form
a
legal
entity
and
the
the
main
objective
is
to
to
ensure
continuity
of
the
also
project,
because,
as
you
know,
it's
an
open
source
project
and
I'm
able
to
work
on
it,
because
customers
pay
me
to
to
work
on
it
because
they
need
it
for
their
system.
So
that's
very
good,
but
of
course
it
shouldn't
depend
on
just
one
person
right.
A
Yeah
I'm
very
excited
about
it
and
it's
it's
a
lot
of
fun.
Okay.
That
was
my
topic.
So
let's
make
a
note
of
that.
So
the
entity
for
now
at
least,
is
going
to
be
called
else.
It
did
so
probably
it
will
be
the
name
as
well,
but
if
anyone
has
any
cool
name,
you
know
for
a
consultancy,
gig
or
company
that
are
open
to
to
hearing
those
ideas.
A
But
for
now
it's
going
to
be
Elsa
digital
and
it's
going
to
offer
premium
support
services
around
Elsa
and
the
long-term
goal
is
for
this
entity
to
also
work
on
on
Commercial
Services,
like
a
marketplace
with
commercial
modules,
also
free
modules,
but
maybe
for
certain
paid
services
that
you
have
online.
Maybe
it
makes
sense
to
also
offer
integration
for
those
and
ask
a
license
fee
for
it.
For
example,
that's
cool
yeah
and
maybe
some
some
pre-baked
workflows
that
that
can
be
offered
for
sale
for
certain
scenarios.
A
That's
on
the
one
hand
and
on
the
other
hand
we
also
have
ideas
for
a
SAS,
so
think
logic,
apps,
say
think
save
here.
But
but
you
know
using
the
Elsa
framework
at
the
fair
list
and
initially
probably
the
same
designer
or
maybe
a
more
Enterprise
grade
studio.
So
you
have
you
know
deep
integration
with
your
own
system,
but
also
more
advanced
management
of
workflows
and
being
able
to
configure
it
in
a
way
that
you
know
serves
your
specific
business
needs
being
able
to
deploy
to
multiple
environments.
A
B
A
Yeah,
exactly
that's
the
the
the
main
idea
and
also
it's
nice
for
other.
You
know
third-party
developers
to
earn
a
bit
of
extra
income
if
they,
if
they're
able
to
publish
a
commercial
module
yeah
that
that's
going
to
be
very
cool
to
work
on
yeah,
great,
all
right
so
yeah
yep.
So
that's
that's.
Coming
a
couple
of
months
away
at
least
Elsa
2
has
2.11
has
been
released,
I
think
yesterday
or
the
day
before
yesterday
very
recently
and
I
figured.
Let's
take
a
quick
look
at
the
release,
notes
just
to
go
over.
A
What's
in
that
in
those
in
that
version,
all
right
so
I
have
never
used.
Kafka
myself,
I
haven't
written
any
of
this
module,
but
there's
a
few
folks
out
there
that
provided
a
module
to
integrate
with
Kafka
and
some
fixes
have
come
in
in
2.11
and
in
the
master
branches.
Even
follow-up
fixes
for
this.
So
probably
we'll
do
it
really
soon
for
Two
Eleven
one
to
also
provide
those
fixes
upgraded
the
reverse
packages,
so
just
the
package
updates
yeah.
A
So
this
this
is
a
bug
fix
which
has
to
do
when
using
fork
and
join
I.
Think
in
combination
with
resuming
or
actually
retrying
a
faulted,
workflow
so
think
of
having
a
workflow
instance
it
faulted.
Then
you
fix
the
issue
that
causes
cast
the
fault
and
to
begin
with,
then
you
want
to
retry
the
workfluences,
but
that
wouldn't
work
properly
before
it
is
fixed.
You
know,
that's
that's
been
fixed.
A
Muhammad
did
some
nice
performance
improvements,
I
haven't
tested
it
myself,
yet
I've
been
too
too
too
busy
with
the
Elsa
3
development,
but
I
believe
he
knows
this.
He
had
a
noticeable
Improvement
submitted
here.
So
that's
that's
good.
So
this
is
the
elsa2
designer,
not
the
new
designer
Elsa
tool,
which
is
based
on
X6.
This
is
the
Improvement
for
the
library,
the
dagger
Library,
that's
being
used
more
Kafka,
more
Kafka
delete
many
fixes.
Okay,
so
this
is
in
the
persistence
layer
for
postgres
nice.
So
that's
there
as
well.
A
Brential
manager
fixes
tension
specification
fixes
from
depend
about
some
packets
bumps
some
extensibility
to
customize
the
SQL
client
Factory
mediator
packets
upgrades
copy
paste
work,
making
that
work
across
multiple
domains.
So
this
is
related
to
the
new
designer
in
lc2,
which
is
based
on
X6
and
cop
paste
works,
but
in
a
limited
way.
So
this
fix
makes
this
allows
you
to
copy
paste
across
multiple
Elsa
instances.
It's
my
understanding,
I
haven't
tried
it,
but
that's
what
I
gathered
from
that
webpack
and
more
Kafka.
So
a
lot
of
Kafka
enhancements
here.
A
That
would
be
even
better,
but
if
not,
then
you
certainly
don't
want
Json
elements,
because
then
you
can't
use
that
syntax
or
dot
notation,
so
I
wanted
to
always
deserialize
into
either
a.net
type
or
an
expanded
object.
So
a
lot
of
work
has
been
done
into
ensuring
this.
So
it's
much
better.
Now,
I
did
a
small
change
here.
Actually,
I
should
show
this
one,
so
it's
not
nothing
big,
but
I.
Think
it's
more
or
intuitive
for
users.
Oh,
this
was
so
cool
the
chat
GPT.
A
Let
me
show
you
I
got
so
stuck
for
a
day
and
a
half
and
then
I
was
about
to
give
up
and
I
asked
chat,
GPT
to
help
me
and
it
actually
helped
me
like
it.
It
was
literally
well
figuratively
speaking,
life-saving.
Let
me
see
if
I
can
this
one
so
here?
Basically,
the
issue
was
that
I
have
a
customer
sorted
and
for
some
reason,
this
converter
when
executed,
outputs
the
following
Json,
where
the
type
this
is.
A
This
is
my
custom
metadata
field
for
storing
the
the.net
type,
with
output
twice
and
I
couldn't
figure
it
out
and
I've
been
stomping
banging
my
head
against
the
wall
for
a
day
and
a
half
so
I
I
put
in
this
this
issue
and
then
TPT
just
figured
out
the
issue:
it's
it
was
spot
on
and
it
in
hindsight
it
was
so
obvious,
but
it
wasn't
at
the
time.
You
know
how
it
is
right,
you're
too
deep
into
it,
and
you
you
start
to
have
tunnel
vision,
and
here
it
just
notices
the
issue
and
basic.
A
The
issue
was
that
because
of
I
think
it's
recursive
nature
and
yeah.
It
describes
that
the
right
method
I'm
writing
out
the
progressive
Json
element.
But
if
you
write
it
directly
to
the
writer,
then
you
might
write
it
again
and
that's
exactly
what
happened
and
then
he
suggested
a
little
change
here.
That's.
B
A
B
A
B
A
You
know
what
would
be
even
cooler,
so
that
would
be
very
cool
and
and
that's
going
to
be
there
right,
this
integration
with
chatgpt,
no
doubt.
But
what
about
the
following?
Where
you
know
how
it
is
right,
we
have
different
levels
of
programming,
languages,
the
lowest
level
being
ones
and
zeros.
Then
you
have
assembly,
and
then
you
have.
You
know
the
the
modern
languages
like.
B
A
Exactly
and
it's
at
the
end
of
the
day,
it's
all
specifications,
so
the
in
our
UF
also
workflows,
which
is
a
different
kind
of
specification.
It's
you
know
you
created
the
specification
visually
but
could
also
be
Json.
Doesn't
matter
is
just
a
higher
level
of
specifying
what
you
want
so
in
a
more
natural
language.
So
what
if
you
could
do
that?
Okay,
you
can
already
do
it
for
for
programs
or
Little
Snips
of
of
code,
at
least
but
I
I
can
imagine
also
having
the
ability
to
do
it
for
workflows.
A
So
you
describe
the
process
that
you
want,
the
more
you
information
you
give
it
the
better.
It
will
be
more
accurate.
It
will
be
in
in
the
workflow
outputs,
but
that
I
would
love
to
have
a
variation
of
tatibility.
That
can
do
that
for
you,
so
I'm
gonna
at
some
point,
I'm
gonna
dig
a
little
bit
into
that
that
that's
will
be
so
cool
right.
B
A
A
It's
a
good
way
to
communicate
from
your
application
with
the
workflow
back
and
forth,
so
the
workflow
can
communicate
with
your
application,
using
events
and
your
application
can
communicate
to
the
workflow
using
events,
and
that
can
happen
from
application
code
to
workflows,
but
also
across
workflows
or
even
within
the
same
workflow.
So
it's
a
very
Nifty
combo.
These
two
activities
so
I
want
to
just
show
you
how
it
works.
A
So,
for
example,
the
the
simplest
one
would
be
to
just
have
the
event
activity
Market,
as
can
start
workflows
to
turn
it
into
a
trigger
that
can
start
new
workflows
and
an
event
requires
you
to
provide
a
a
event
name.
So
maybe
order
submit
it.
So
when
you
have
this
event
with
this
name,
your
application
or
through
the
rest,
API
or
an
auto
workflow,
can
raise
an
event
with
this
name
or
the
submit
it.
A
And
then
that
would
kick
off
this
workflow
and,
of
course,
maybe
you
want
to
also
provide
some
the
order
itself
that
has
been
submitted
right.
So
if
the
application
provides
this
payloads,
you
can
capture
it
here
using
the
output
of
this
event,
so
it
will
transparently
forward
its
input.
So
you
have
to
know
that
when,
whenever
you
invoke
a
workflow,
you
can
provide
an
input
payload
and
this
event
will
whatever
input
it
receives,
will
be
forwarded
to
this
output
here.
A
So,
for
example,
let's
say
you
have
an
order,
and
that
also
gives
me
the
chance
to
mention
what
I
was
about
to
mention,
which
is
the
rename
of
expandable
optic
to
just
Json
as
experiment,
because
I
think
in
this
context,
the
purpose
of
of
an
expanded
object
is
in
order
to
be
able
to
treat
it
as
Json
objects
or
JavaScript
objects.
So
so
I
renamed
it
here,
but
we'll
use
it
like
that.
So
we
don't
need
a
strong.net
type.
Of
course
we
could.
We
can
register
our
own
types,
for
example,
order.
A
We
could
add
it
to
this
list
and
use
it
in
that
manner,
but
for
now
we'll
use
Json
and
then
we'll
capture
it
in
this
list.
First,
we
need
to
refresh
the
list
like
this,
and
so
here
we'll
capture
the
order
and
then
maybe
we
will
just
send
it
to
an
asp
response
which
would
only
work
if
this
workflow
is
evoked
from
a
HP
context
in
the
first
place.
So
that's
something
to
be
aware
of
when
using
ASAP
response,
of
course.
A
So
here
we'll
just
say:
let's
use
Liquid
order
received,
and
let's
imagine
that
the
order
has
a
a
product
field
which
represents
the
product
that
we
ordered
so
your
variables
that
order
that
all
right
and
then
the
content
will
be
the
content
type
will
be
just
like
text.
That's
it
all
right.
So,
let's,
let's
call
this
workflow
or
to
submit
it.
It
will
publish
this
and
now,
let's
show
how
to
invoke
this
event.
The
first
way
to
do
it
is
through
the
rest,
API,
that's
the
easiest
without
having
to
write
custom
code.
A
So
we'll
do
that.
So
here
we're
looking
at
the
rest,
API
endpoint
that
we
can
invoke
so
the
way
it
works.
It's
we
have
the
The
Base
address
at
which
the
Elsa
endpoints
are
listening,
which
is
your
localhost
slash,
l,
so
slash
API,
that's
configure
row
by
the
way
and
then
the
event
sets
that's
part
of
one
of
the
endpoints.
This
segment
is
the
event
name
and
I
should
not
have
copied
the
edit
that
out
of
habit,
we
don't
need
the
definition
ID.
Of
course
we
just
need
the
event
name,
which
is
already
here.
B
A
And
there's
a
couple
of
options
we
can
provide.
One
of
them
is
being
the
inputs
and
there's
another
option
to
control
whether
you
want
to
dispatch
the
workflow
so
basically
executed
in
the
background
asynchronously
in
response
to
a
message
that
was
sent
to
to
dispatch
the
workflow.
So
that
means
the
workflow
will
be
executed
by
some
message:
worker
or
synchronously,
which
means
it
will
execute
in
the
same
HP
context.
A
So
that's
what
we
want
here,
since
we
are
using
the
ASP
response
so
to
control
that
we
can
provide
a
field
called
workflow
execution,
Mount
I
think
it's
called
synchronous,
although
I
noticed
that
this
isn't
used.
So
probably
I
didn't
finish
the
implementation,
but
I
did
so
it's
just
an
email,
so
this
should
work.
Let's
see
and
of
course
we
need
to
provide
input.
A
So
we
do
that
through
the
input
field
which
maps
to
the
input
field
here
on
the
the
DTR,
against
which
the
request
will
be
model
bound
and
as
you
can
see,
it's
of
type
object,
so
you
can
provide
a
dictionary
of
value.
So
in
our
case
we're
gonna
give
the
P
name.
That's
going
to
be
order.
This
is
important
because,
whatever
name
we
specify
here
actually
so
forget
about
what
about
that,
I
I,
don't
remember!
Actually
what
the
let's
just,
let's
just
try
it
out
to
see
exactly
how
it
works.
A
A
It
could
be,
let's
see,
I'm,
not
getting
any
issues
here,
so
I
think
it's
fine
yeah,
so
id1.
So
basically,
the
value
here
will
represent
the
order,
if
I'm
not
mistaken,
but
we
will
see-
and
this
would
be
the
further
I
think
I
used
uppercase.
So
let's
use
some
uppercase
here
as
well,
and
this
would
be
pizza
now.
If
we
send
this
one
of
course.
A
First
we
need
to
authorize
or
create
an
access
token,
and
to
do
that
we
go
to
Identity
and
then
log
in
with
the
power
user,
and
now
we
can
try
it
again
all
right.
Let's
see,
what's
this,
it's
specified
version
definition.
Let
me
try
it
with
the
debugger
API
address
events.
Event
name
trigger
all
right.
Let's
see
what
happens.
I
wonder
if
this
is
one
of
my
previous
tests,
pointing
to
a
workflow
state
that
that's
now
responding
to
this,
because
we
are
not
using
correlation
or
scoping
it
to
workflow
instance.
A
So
let
me
just
make
sure
and
clean
the
database.
Let
me
also
make
sure
to
clean
the
bookmarks,
all
right
so
close,
but
no
cigar
we're
missing
the
the
input
here.
Let's
see
if
I
can
fix
it
quickly,
variables
order
products,
so
here
we
okay,
so
we
this
wasn't
captured.
So
let's
try
this
again.
This
is
captured
here
variables.
C
A
Let
me
just
try
this
in
JavaScript,
maybe
I'm
not
getting
the
syntax
right
and
if
not
it's
okay.
The
main
point
was
to
show
the
event,
but
it
would
be
nice
to
also
show
how
to
deal
with
the
the
inputs.
So,
let's
see
so
in
JavaScript,
you
say
like
this:
get
order:
dot,
product,
okay,
so
I
I'm
getting
the
binding
incorrect.
So
let
me
set
a
quick
breakpoint
here,
so
input
is
going
to
be
dictionary
so
now
I
wonder
if
there's
a
convention
that
I
invented
to
bind
the
variable
name
to
the
input.
A
So
let's
take
a
look
at
the
events
to
to
see
how
it
passes
along
the
ear,
the
input
as
its
outputs.
So
now
that
I
look
at
this
code,
I
I'm,
doubting
myself
that
it
that
I'm
actually
providing
or
passing
along
the
input.
So
it
could
be
that
that's
the
idea,
but
I
didn't
get
to
finish
that
implementation.
So
in
that
case,
let's
just
ignore
the
input
for
now.
This
is
the
end
point
here
we
get
the
input.
Input
looks
like
this.
It
has
a
order
key
and
then
expand
the
website
representing
the
order.
A
So
that's
that's
all
good,
then
we
publish
and
then
we
complete,
but
never
setting
the
result.
So
that's
the
issue
here,
I'll.
Just
let
me
take
a
quick
note,
all
right,
sorry
about
that.
I
should
have
tested
this
before
and
it's
fine
okay.
So
now,
let's
pretend
we
do
have
some
inputs,
then
yeah.
So
that's
what
I
want
to
show
as
one
way
to
trigger
events
is
to
to
do
it
through
rest
apis.
Of
course
it
doesn't
have
to
be
a
trigger
right.
A
We
could
also
imagine
having
a
workflow
that
starts
either
manually
from
the
application
or
to
buy
some
other
trigger.
Maybe
we
have
just
a
normal
starting
activity
or
a
normal
activity
like
this
one
where
we
say
submitting
border,
but
this
is
just
a
regular
right
line.
It's
not
a
trigger,
so
we
need
to
invoke
this
workflow
manually,
we'll
remove
this
trigger.
We
could
leave
it
as
is,
and
then
we
can
trigger
this
using
the
event.
A
But
then
it
would
start
at
this
point
and
ignore
this
activity
here
so,
but
to
be
clear:
I
prefer
to
uncheck
this
one
so
that
it
becomes
apparent
that
this
is
a
blocking
activity,
not
a
trigger,
so
updating
the
display
text.
So
what
will
happen
now?
We
will
invoke
this
workflow
and
it
will
execute
event,
but
that
will
create
a
bookmark
because
it's
now
a
blocking
activity
and
then
we
have
to
manually
trigger
the
events
like
we
did
just
just
a
second
ago
to
continue
or
resume
the
workflow.
A
So
this
time
we
do
need
the
definition
ID,
because
now
we're
gonna
use
another
rest
API
to
execute
this
particular
workflow
like
this,
so
now
I
would
executed.
We
received
an
instance
ID,
which
would
be
useful
for
the
in
case.
You
wanted
to
trigger
an
event
of
a
specific
workflow
instance
without
workflow
instance,
any
workflow
that's
either
either
uses
event
as
a
trigger
or
is
blocked
on
an
event.
By
that
event,
name
will
be
resumed,
so
you
can
use
events
to
resume
or
start
multiple
triggers.
A
But
if
you
don't
want
that,
you
will
want
to
scope
it
to
a
specific
workflow
instance,
and
in
that
case
you
you
will
want
to
take
a
note
of
this
for
now.
We'll
ignore
this
we'll
take
a
quick
look
at
the
workflow
instances
and
see
that
this
latest
workflow
instances
in
the
status
running
and
just
to
remind
those
who
who
are
used
to
elsa2
and
also
2
status
running
means
the
workforce
actually
actively
running
at
that
moment.
A
A
Yes,
that's
right,
you
know
still
it
would
be
suspended
in
elsa3
the
sub
status
is
suspended.
So
if
we
look
at
the
workflow
instances
or
yeah
where
flow
instances
here
we
see
that
the
status
is
running
but
the
sub
status
is
suspended.
So
this
is
basically
the
reason
it's
still
running.
It
could
also
be
finished
and
then
faulted,
so
the
workflow
is
done,
but
this
is
the
reason
it's
it's
done
because
it
faulted
or
because
it's
finished
or
because
it
was
canceled.
So
so
that's
a
that's
a
small
difference
there.
A
This
is
suspended
and
we
can
see
from
the
journal
that
the
event
one
it
has
completed-
that's
not
correct
it's.
We
should
make
this
a
little
bit
more
granular
because
it
yes
it
completed,
but
it
also
created
a
bookmark.
So
it
would
be
good
to
officially
be
able
to
communicate
that
to
the
to
this
user.
But
for
now
we
know
it's
blocked
here.
So
it's
waiting
for
this
event,
so
we
can
trigger
that
event
which
we
did
just
a
second
ago.
A
So,
let's
do
it
and
and
then
it
should
should
have
finished
and
it's
finished
indeed,
and
then
we
also
see
that
so
here
it
completed
and
then
here
it
it
was
resumed.
So
another
entry
is
made
here
but
yeah
there's
still
some
work
to
be
done
on
the
workflow
journal
and
then
it
finished
here.
So
that's
good
yeah
go
ahead.
B
I
I
figured
out
the
last
days,
I'm
still
working
on
other
two
and
I
didn't
find
any
duration
field
for
the
whole
workflow.
So
if
it's
finished
it
would
be
great
to
have
a
field
where
the
duration
is
is
written.
So,
yes,
I,
know,
I
could
use
the
created
and
the
ended
and
and
calculated
by
myself,
but
a
duration
field
would
be
great
for
the
future.
A
And
actually
we
have
this
in
elsa3,
but
we
are
hiding
the
first
two
entries.
The
first
one
would
be
the
workflow
itself,
which
is
an
activity
and
then
the
flowchart,
which
is
the
root
of
the
activity,
the
first
one
to
a
schedule,
and
we
we
thought
it
would
be
a
good
idea
to
hide
it,
because
it's
it's
always
the
same.
But
but
to
your
point,
if
we
were
to
show
that
again
that
we
should,
then
we
would
see
the
total
duration,
because
these
durations
are
for
for
this
activity
here.
So
yeah.
B
A
A
Exactly
so,
in
this
case
it
was
Postman
Postman
sent
an
ACP
request
which
caused
the
Elsa
engine
to
resume
this
this
one,
and
this
one
then
finish
resuming
or
yielding
control
back
to
the
flowchart
on
which
this
is
of
which
this
one
is
part
which
then
and
follow
this
connection
to
the
next
one
and
and
that's
still
happening
in
that
same
HP
context.
So
this
one
is
writing
back
to
to
that
HP
response
object
in
that
context,.
C
B
C
I
think
there
is
no
control
on
how
much
this
event
is
used
and
by
any
application,
and
in
that
case,
multiple
and
even
for
the
same
for
the
same
workflow
view.
If
you
just
use
the
same
workflow
definition
and
and
start
twice
this
workflow
you
can,
you
can
submit
order
twice.
It
will
start
to
instance
of
this
workflow.
A
Oh
yeah,
so
let's
do
that.
So,
let's
run
this
one
twice
so
execute
and
once
twice
so
now
we
have
two
instances
as
we
can
see
here,
they
are
all
both
running
and
suspended,
so
they
are
both
now
blocked
on
this
one.
So
now,
if
we
resume
a
trigger
the
event,
this
is
the
event.
Then
we'll
do
that
and
then
we
get
an
error
because
status
code
cannot
be
set
because
the
response
has
already
started.
A
B
A
The
the
headers
twice
right,
so
this
is
just
a
buggy
workflow
that
that
it
doesn't
make
much
sense.
You
should
probably
do
it
using
events.
If,
if
you
did
want
to
do
it,
you
have
to
be
because
maybe
there's
a
case
where
you
do
want
to
use
events
to
communicate
and
control
workflow
execution.
But
then
you
need
to
make
sure
that
the
event
is
only
used
for
one
workflowing,
so
send
it
to
so,
let's
see
how
that
works.
Let's
see
if
these
two
are
so
one
finished
and
one
faulted,
which
is
correct.
A
So
let's
do
it
again.
Let's
start
two
new
instances,
but
this
time
we
want
to.
Oh
sorry,
that's
the
wrong
one,
this
one.
So
we
start
two
instances
which
we
have
here,
but
now
we
want
to,
let's
say
only
resume
this
one
so
I
copy
the
ID.
Then
we
go
back
to
the
trigger
event
API,
but
this
time
we
want
to
to
Target
a
specific
one.
So
we
include
the
workflow
instance
ID
like
this.
So
now,
when
we
send
oh
start
index,
but
that's.
B
A
Yeah
all
right,
so
so
this
time
it
it
worked
because
only
one
where
flights
was
resumed,
so
but
you
make
a
good
point.
This
is
something
to
be
aware
of
when
dealing
with
workflows
that
can
put
tends
to
be
triggered
by
multiple
workflows
can
be
triggered,
and
if
they
involve
HP
responses,
that's
could
be
problematic
if
you're,
not
careful,
careful.
C
A
So
I
I'm,
referring
to
in
a
multi-tenant
environment
or
or
yeah,
because
that's
that's
true,
yes,
so
that
needs
to
be
be
taken
into
account,
maybe
using
some
some
some
token,
some
some
signature
or
something
like
a
SAS
token.
That
could
be.
That
could
be
it's
an
end.
That
would
have
to
be
validated
somehow,
of
course,
currently
this
endpoint
and
it
will
remain
protected.
This
endpoint
is
even
though
it's
available
available
publicly.
A
No
actually,
this
takes
advantage
of
the
bookmarks
and
the
triggers
so
yeah.
So
if
we
look
at
bookmarks
there's
currently
just
one
bookmark,
because
we
still
have
one
word,
for
instance,
that's
blocked
on
the
event
or
submitted
so
that
uses
the
same
mechanism
again
and
triggers
currently
should
be
empty.
A
But
if
we
used
it
as
a
starting
activity
and
marked
that
soon
can
start
workflow,
then
we
would
see
a
trigger
as
well
so
yeah,
but
yeah
good
point
with
the
security
we
I
know
with
the
I
think
in
Elsa
2,
when
you
generate
a
URL
to
trigger
a
signal,
it
includes
a
security
token
or
a
SAS
token,
a
shared
access
token
in
it.
That
makes
it
this,
so
that
will
be
at
least
good
to
have
this
option
for
events
as
well.
So
thank
you
for
that
yeah.
So
so
this.
A
This
is
how
you
can
resume
workflows,
using
events
that
using
a
workflow,
instant
study
and
of
course
you
can
also
do
it
using
correlation.
So
maybe
you
don't
have
a
workflow
instance,
but
or
you
want
to
do
it
through
a
business
entity,
baby
document
ID
or
a
customer
ID
or
in
this
case,
maybe
even
order
ID.
That
would
work
too
all
right,
so
we've
looked
at
doing
it
through
the
rest
API.
We
can
also
do
it
from
another
workflow,
so
maybe
yeah.
A
Let's
leave
this
is
let's
say
we
have
a
new
workflow
called
process
order
and
then
the
point
of
this
one
would
be
to
to
resume
the
other
workflow.
We
have
the
publish
event
activity
and
it
requires
you
to
specify
the
event
that
you
want
to
publish
and
again
this
could
potentially
publish
many
many
workflows
whether
they
are
suspended
or
or
started.
You
can
use
this
to
to
kick
off
multiple
workflows.
In
this
case
we
want
to
maybe
use
correlation
so
that
we
only
resume
the
workflow
instance
of
a
particular
order,
ID.
A
That
will
be
maybe
a
good
use
case.
So
let
me
find
the
event
name
here
like
this
correlation
ID
can
be
specified
here.
So
we
don't
have
a.
We
don't
have
one
right
now,
but
let's
imagine
we
would
we
received
the
order
as
input
of
to
this
to
this
workflow
and
then
the
order
would
be
greater
one.
Let's
say:
let's
go
here,
submitting
order,
let's
correlate.
This
word
flow
with
with
the
order,
ID
and
actually
I
don't
want
to
hard
code
this
I.
Maybe
we
should
just
provide
some
input.
So,
let's,
let's
do
that?
A
Let's
accept
some
inputs.
So
for
that
we
will
declare.
Oh,
we
can
use
this
order
in
this
case.
We're
just
gonna
use
the
set
variable
so
we'll
use
this
one
to
set
the
order
based
on
the
input
we
receive,
so
the
inputs
would
be
provided
through
the
rest
API
to
execute
the
workflow,
and
that
would
look
like
this.
So
let's
go
here.
A
If
you're
hearing,
weird
noises,
that's
my
dog
see
it's
very
vocal,
so
let's
say
inputs,
and
this
would
be
order,
and
this
would
have
a
ID
that
so
this
is
the
model
of
the
order.
It
will
be
stored
here
and
we
will
read
it
from
the
input
so
that
we
use
get
inputs
and
it
requires
you
to
specify
the
name
of
the
input
and
the
name
of
the
input
is
this
key
here.
So
this
is
just
handled
by
the
endpoint
which
understands
this
field,
and
then
it
sees
these
as
as
a
key
and
then
values.
A
So
the
key
is
ordered
so
we're.
Reading
the
order
from
the
inputs,
then
we're
going
to
submit
the
order
so
I
just
write
it
to
the
console.
Let's
be
fancy
here
and
just
use
the
order
name
or
the
I
mean
the
order,
ID
lowercase
and
then
we'll
also
correlate
this
workflow
instance
with
this
particular
order.
Id
all
right.
So
this
is
now
correlated
here.
This
event
will
be
blocking
the
workflow
yeah
and
then,
when
resumed
could.
B
A
A
A
A
Yeah
yeah,
it's
a
good
question
and-
and
here
we're
taking
advantage
of
that
feature,
so
we
are
story
associating
the
received
already
with
this
workplace
study,
which
is
convenient
because
from
the
other
workflow
we
don't
know
what
the
workflow
in
society
is
we
just
now.
We
want
to
publish
an
event
about
a
certain
order,
so
we
have
the
order
ID,
but
we
don't
know
which
workflow
instances
would
be
interested
in
that.
So
that's
that's
a
I
think
a
good
example
all
right
so
we'll
receive
this
is
okay.
A
Let's
so
we'll
publish
this
one
yeah,
so
the
flow
will
be
as
follows.
We
first
will
start
this
workflow
we'll
submit
an
order
and
then
this
workflow
will
be
blocked
and
the
way
to
resume
it
is
to
invoke
the
other
workflow.
Let's
take
a
look
at
the
other
workflow
process
order,
so
here
we
also
need
to
know
the
the
order
ID,
because
this
event
will
this
activity
will
publish
this
event
and
we'll
provide
the
the
the
correct
order
from
the
rest
API.
A
So,
let's
do
the
same
thing:
we'll
create
a
variable
here,
we'll
just
say
order:
ID,
we
don't
need
the
full
core
and
then
use
that
variable
to
set
the
orderly,
which
we
capture
from
the
input
that
we
know
will
we
will
receive
I
will
say,
get
inputs
or
directly
I
I.
We
might
make
this
case
insensitive,
and
maybe
it
already
is
casing
sensitive,
I'm,
not
sure,
but
I
think
might
be
more
helpful
to
make
this
not
case
sensitive,
but
for
now
it
is
so.
A
We
have
to
take
that
into
account
and
then
here
we'll
use
that
captured
inputs
get
order.
Id,
all
right,
we'll
publish
this,
and
then
let's
try
that
so
we're
gonna
Execute
Order
submitted
workflow.
That's
has
this
definition
ID,
which
should
be
the
same
as
we
already
have
here.
Yep
we're
gonna
submit
the
order
like
this
orderly
product.
Okay.
So
let's
see
what
we
see
here,
workflow
instances,
so
it
has
a
curl
is,
as
you
can
see
it's
running,
it
has
a
correlation
ID,
which
is
the
order
ID
that
we
provided
here.
A
So
that's
one
good.
So
now
we
want
to
resume
this
workflow,
but
we
want
to
do
it
using
the
other
workflow.
So
let
me
copy
this
request
and
call
it
process
order.
Let's
say
so
here:
we
need
to
use
the
definition
ID
of
the
other
workflow
this
one,
and
here
we
need
to
provide
input,
but
not
the
entire
object.
We
can
just
say
order,
ID,
one.
There
you
go
so
now
we
send
this
one.
A
This
one
was
executed
as
well
and,
to
be
honest,
I
would
have
expected
a
response
from
the
other
workflow,
but
maybe
maybe
it
is
publish
event
by
default,
uses
dispatch.
Let's
see,
if
that's
the
case,
okay
yeah,
so
it
uses
dispatch,
which
means
the
other
workflow
is
resumed,
but
in
in
a
background
worker
context
which
doesn't
have
HP
context,
so
it
would
have
written
something
to
the
response,
but
that
will
be
ignored
or
that
even
happened,
because
probably
some
logic
will
skip
that
otherwise
accessing
an
HP
response
that
doesn't
exist
would
cause
an
error.
A
Let's
see
what
happens
here,
so
we
see
process
order
finished
this
one
is
still
running
so
not
sure
why?
Okay,
so
I
think
there's
a
bug
here,
because
I
can
clearly
see
it
was
resumed,
as
you
can
see
here
when
this
executed
here,
then
it
was
resumed
and
then
it
went
to
write
a
speed
response,
but
I
think
this
may
have
faulted
or
at
least
led
into
a
path
that
doesn't
go
complete
this
activity
same
time.
If
this,
what
is
marked
as
completed
so
that's
interesting.
A
Let
me
refresh
this,
so
this
is
finished
running
suspended
okay,
so
it
didn't
fault
either.
I
think
it's!
It
led
into
a
code
path.
That's
not
handled!
Well,
so
I
need
to
debug
this,
but
to
make
this
example
work,
let's
just
replace
that
HP
response
with
a
console
right
line.
Okay,
let's
try
this
again,
so
we
go
to
execute
this.
A
Let's
change
this
order
to
two
and
then
we'll
go
to
process
order
and
resume
it
to
B2,
and
then,
if
that
worked,
then
we
should
see
this
right
leg
so
yeah,
so,
okay,
here's
some
hint
of
as
to
the
previous
execution.
This
is
the
first
one
and
I
think
this
may
be
was
the
last
one.
Maybe,
but
I
would
look
into
that.
So
that's
always
good
to
test
with
you
guys.
A
You
have
to
find
these
books
all
right
so
and
of
course,
the
third
way
to
deal
with
these
events
and
which
could
be
very
powerful,
is
to
integrate
with
your
application,
where
you
have
application
logic
that
uses
the
else
apis
internally,
not
the
rest
apis,
but
just
the
also
Services,
if
you're
else
engine
is
in
the
same
process.
Of
course,
as
your
application
to
to
to
invoke
these
events.
Okay,
cool
and
yeah.
There's
the
there's
a
very
simple
API
for
that
which
is,
of
course
used
by
the
endpoints
internally.
A
So,
basically,
you
would
use
the
event
publisher
and
it
has
two
methods
one
to
do:
synchronously
and
asynchronously
using
dispatch,
but
the
signature
is
the
same:
that's
cool
yeah!
So,
let's
see
if
I
well,
we
are
over
time,
but
just
to
see
if
there's
anything
else,
scope
variables,
that's
a
very
important
because
I
don't
know
if
I
fixed
it
last
week
already
but
or
maybe
I
was
in
a
process
of.
But
as
I've
shown
a
couple
of
times,
you
can
create
sub
workflows
or
workflows
that
you
can
use
as
activities.
A
For
example,
yeah
I
talked
about
this
right,
so
here,
for
example,
we
have
a
a
sum
workflow,
which
is
can
be
used
as
an
activity.
So
that
means
we
have
an
activity
here
called
sum,
and
this
one
it's
a
very
simple
workflow.
It
has
just
one
activity:
that's
that
sets
the
workflow
output
to
where
to
the
sum
of
its
inputs.
So
here
we
have
input
A
and
B
and
we
output
it
as
a
result.
A
What
you
would
see
is
one
activity
would
overwrite
the
variable
that
was
set
by
another
activity
or
higher
up
in
the
workflow,
which
would
cause
issues
but
that's
been
fixed,
so
every
activity
has
its
own
scope
of
very
variable.
So
here
we
have
a
b
and
result
and
then
we
can
have
a
workflow
that
uses
this
activity
like
the
the
sum
workflow,
which
is
consumingly
sum
activity.
Let
me
fix
this
so
here
here
we
have
variables
a
b
and
results,
but
they
are.
They
are
in
their
own
scope.
A
C
C
C
C
A
This
will
work
and
this
one
doesn't:
okay,
okay,
yes,
so
and
I
can
explain
why.
Let
me
find
the
this
one
right,
yes
yeah,
so
so
the
key
thing
is
this
line
here:
use
async,
workflow
State
exporter,
which
is
a
setting
you
configure
on
the
workflow
runtime,
okay,
and
if,
if
we
added
clicks,
I
can
add
it
here,
so
here
we're
not
configuring
the
the
runtime.
So
it's
using
the
default
one,
let's
just
copy
the
entire
thing.
A
Exactly
but
I
would
like
this
so
with
these
slides
that
should
not
work
because
the
what
happens
is
you,
you
won't
see
the
workplaces,
but
you
should
see
workflow
States.
So
here
the
default
runtime
uses
the
workflow
States
table
to
store
workflow,
instant
State,
and
the
idea
is
that
when
you
use
a
different
runtime,
let's
say
protoactor,
you
don't
need
database
storage
for
the
workflow
instances,
because
every
word
lenses
is
now
handled
in
memory
as
an
actor.
A
So
so
the
only
reason
we
have
this
table
for
the
default
runtime
is
because
we
need
to
have
this
somewhere.
So
it
could
be
a
memory,
but
but
then
it
does
doesn't
work
across
nodes.
So
we
have
tables
with
protractor.
You
don't
need
to
have
that.
It's
all
managed,
but
of
course,
if
you
want
to
persist
the
workflow
instances
and
and
be
able
to
look
at
it
from
the
designer
you
need,
you
need
a
place
to
cap
to
to
look
at
that.
A
So
in
order
to
capture
the
workflow
State
as
it
gets,
updated
or
created,
there's
a
thing
called
the
workflow
State
exporter
and
that's
just
a
let's
see.
So
that's
a
service
that
implements
I
work
for
State
export
and
this
one
is
invoked
by
the
runtime,
so
the
runtime
or
some
Handler
listens
for
workflow
state
or
workflows
is
executed
or
something
like
that
or
workflow
executed
I
believe
and
that
will
then
invoke
I
work
for
State
exporter,
but
by
default.
A
This
is
a
no
up,
no
up
or
no
operation,
but
if
you
do
want
to
capture
it,
just
install
the
async
word
for
State
export,
which
will
asynchronously
send
the
the
workflow
State
using
a
command
called
export,
worthless
state
to
DB
commands,
and
this
is
then
handled
by
the
persistence
layer
and
and
of
course
you
can
Implement
your
own
export.
If
you
wanted
to
export
to
elastic
servers
or
whatnot
and
I
think
actually,
there's
I
think
this
one
is
configurable
I.
Think.
C
A
Right
yeah,
so
so
the
the
workflow
runtime
by
default,
using
anti-frame
recorder,
will
use
workflow
state.
So
you
will
have
this
table,
but
the
designer
doesn't
use
this
one.
It
uses
workflow
instances
and-
and
the
reason
is
it's
decoupled,
so
workflow
States,
it's
only
there
if
you
use
the
default
runtime,
but
if
you
use
protoactive,
this
will
not
be
there,
but
you
still
want
access
to
work
for
instances,
but
you
need
to
up
in
to
that
for
performance
reasons.
A
Not
all
scenarios
require
references
to
be
captured,
although
to
be
fair,
probably
most
scenarios
do
require
it,
so
maybe
it
should
be
an
opt-out.
Instead,
we're
still,
you
know,
trying
to
determine
what's
the
most
commonly
used
scenario
and
provide
proper
defaults
or
sensible
defaults.
But
this
is
the
the
reason.
Okay.
C
C
I
have
a
great
so,
which
is
the
sample
project,
such
user
wrapper
and
and
Elsa
initial
package
to
create
an
interface
with
the
designer
and
some
other
button
that
allows
the
user
to
manipulate
the
designer.
And
for
because
of
this
we
can
see
that
the
designer
there
is
some
extensibility
point
that
are
missing
in
the
in
the
designer
to,
for
example,
load
a
load,
workflow,
publish
overflow,
etc,
etc.
But.
C
So
so
these
are
always
to
see
what
is
necessary
to
extern
the
designer
for
other
people
and
other
applications
yeah,
and
once
it's
good
with
the
same
work,
I
can
create
the
wrapper
for
a
few
GS
and
react.
Yes,
that's
the
same.
It's
just
an
output
Target
in
a
in
here
as
the
in
the
stencil
config
in
the
workflow
designer.
C
Yeah,
it's
is
everything:
okay,
okay,
so
yeah,
so
that's
a
demo
effect.
So,
first
of
all,
we
we
see
that
if
we
just
load
the
the
designers,
the
the
target,
the
HTML
tag
as
a
studio,
we
have
the
Elsa
background,
which
is
a
display,
and
here
I
have
set.
Only
the
the
designer
I
remove
the
the
toolbar
available
in
the
shell
and
I
have
created
my
own
button
and
using
the
service
inside
provided
by
the
the
Elsa
package.
I
can
interact
with
the
the
Overflow
I.
C
And
if
we
look
in
the
component,
the
ID
is
to
create
HTML
and
use
only
the
as
a
studio.
So
for
this
there
is
some
strange
Behavior,
because
I
need
to
specify
the
settings
for
the
axios
HTTP
client,
but
when
I
set
the
parameter
on
these
settings
here
that
studio
use
component
and
service
outside
are
this
is
in
the
different
service
are
well
set
when
you
use
all
the
Elsa
Studio
shell,
but
in
this
case
I
have
to
set
the
parameter
and
the
the
settings
manually.
So
this
is
done
in
the
init.
C
C
Then
I
set
the
Interceptor
to
be
sure
that
every
HTTP
call
used
by
the
the
studio
will
be
correctly
undertricated
and
then
to
be
sure
that
the
studio
doesn't
have
any
issue,
because
when
you
set
some
element,
I
have
to
to
be
sure
that
some
components
like
the
activity
descriptor
manager
are
set
because
they
are,
they
are
set
internally.
When
you
use
all
the
shell
and
I
have
to
set
all
this
information
before
otherwise.
C
I
get
an
error
and
I
can't
use
the
designer
I
use
the
service
workflow
API
to
occur,
the
the
backend
API
and
get
the
list
of
the
workflow
and
then
using
the
the
workflow
definition
plugin,
which
is
a
service
used
by
the
designer
component.
I,
can
show
the
the
workflow
definition
in
the
editor.
I
can
also
delete
and
and
publish,
but
to
to
succeed
to
do
this,
I
was
forced
to
expose
some
submitted
publicly
social
workflow
definition.
Editor
is
only
available.
C
C
So
just
a
quick,
quick
thing
because
I
was
not
able
to
to
to
use
this
syntax,
because
this
one
I
used
some
TS6
syntax
in
in
stencil
I,
cannot
use
the
left
syntaxis
in
on
Twitter.
So
I
have
to
allow
this
method
to
be
public,
same
thing
for
a
workflow,
updated
and
I.
I've
added
also
a
publish
current
workflow
to
to
be
able
to
publish
the
workflow
inside
the
designer,
and
this
one
is
public.
A
That
is
yeah
and
that
that
makes
sense
we
Pro
needs
to
do
some
policing
and
maybe
make
certain
methods
more
formal
through
services.
So
maybe
they
don't
have
to
use
the
plugin
object,
for
example,
but
maybe
we
extract
the
this
reusable
logic
into
a
service
that
you
can
use
from
your
angle,
application
which
is
possible.
That's
that's
pretty
amazing
that
you
can
use
the
container
dependency
Injection
Service
to
get
these
Services.
You
want
to
interact
with
and
just
use
it
from
angular.
That's
pretty
cool
and.
C
And
it
was
easier
with
the
Elder
V2,
because
in
angular
V2
we
use.
We
use
the
target,
for
example,
with
a
definition
ID,
for
example,
where
we
set
we've
set
as
a
studio
editor
with
a
definition,
ID
property
for
the
the
just
the
ID,
and
then
the
the
editor
use
the
access
client
to
get
all
the
definitions.
Now
the
component
directly
use
a
workflow
definition
object,
I.
B
C
A
C
Me
yeah
and
the
only
things
is
we
have
angular
okay
and
we
can
then
with
the
same
structure.
So
we
are.
If
we,
if
the
pair
PR
is
okay,
we
already
have
learner.
So
we
we
can
trade
other
directory,
create
the
react
component
library
to
create
a
view
open
library,
and
that
will
be
available
to
a
lot
of
a
lot
of
people.
And
the
last
thing
is
I.
A
C
It's
so
with
this
configuration
we've
got
in
the
app
we've
got
the
we
need
the
angular
Library.
So
it's
a
it's
a
package
that
we
can
publish
on
npm
and
I,
decide
to
to
name
it
Java
flow
designer
wrapper
and
the
the
user,
the
angular
developer.
We
need
this
package
and
the
initial
as
our
flow
designer
the
first
one.
The
wrapper
will
allow
it
to
include
this
module
in
his
angular
library
and
it
will
expose
all
the
components.
C
A
C
And
that's
why
also
I've
made
made
some
change
here
so
now
in
The
Stance,
if
I
get
package,
because
yes
I
change
this
one
to
export
all
the
type
necessary,
so
I
have
an
interface
that
D
that
TS,
with
all
necessary
type
export
for
the
user
and
I
also
export
the
different
service
from
the
index.ts
I.
Don't
really
understand
fully
why
we
need
always
different
and
different
file.
While
we
can
just
export
all
a
prom
component.deep.ds,
but
it
seems
that
not
all
the
component
and
all
the
service
are
automatically
exported.
A
Right
so,
if
I
understand
correctly,
as
people
start
integrating
the
designer
into
their
applications,
they
might
might
run
into
a
service
that
they
want
to
use,
but
it's
not
exported.
So
we
will
have
to
update
it
here,
but
then
it's
available
for
when
we
release
new
packets.
It's
not
something
that
that
the
angular
developer,
the
integrator
has
they
don't
do
it
on
their
end.
But
we
need
to
expose
these
services
and
types
this
way.
And
then
we
generate
the
packets
yeah.
C
Right
and
and
after
if
we
don't
change
anything
on
the
component
on
the
web
component,
we
don't
have
to
change
the
wrapper.
The
wrapper
is
for
the
web
component.
If
we,
for
example,
had
one
services
in
the
Elder
package,
the
angular
developer
just
need
to
update
the
Elsa
initial
package,
not
the
angular
wrapper,
because
the
definition
of
the
web
component
didn't
change.
Yeah
makes
sense
and.
A
C
No
I
think
I
think
we
don't
need
to
to
to
to
make
some
big
work.
We
just
need
to
use
the
react.
Output
Target,
like
I,
do
with
the
angular.
So
just
so
one
thing
is
because
we
use
some
specific
type
with
a
array
of
I
have
to
to
troubleshoot
this.
But
now
it's
done
for
angular
I
think
we
don't
have
any
issue
with
a
reactor
of.