►
From YouTube: Elsa Workflows Community Meeting 27
Description
Elsa Community Meeting 27
Updates
- Revised store API
- Flow HTTP Request
- Improved JSON handling for HTTP workflows
- Improved parent/child workflows
- Added ability to upgrade composite activities
- Improved workflow instance journal
- Fixed checkbox issue
- HTTP RouteTable fixed
A
Same
took
a
minute
yeah
all
right,
so
let
me
start
sharing
the
screen
and
then
maybe
we
can
do
some
updates.
So
I've
been
quite
busy
with
Elsa
three
past
week,
which
was
really
good.
There
was
this
team
from
a
customer
that
that
are
going
to
adopt
Elsa
3,
but
wanted
to
tackle
some
of
the
issues
with
some
issues
with
the
designer
some
missing
functionalities.
So
we
were
able
to
to
do
a
lot.
A
That
was
pretty
awesome,
so
I
thought
maybe
it's
nice
to
go
over
some
of
these
items,
so
I
created
little
list
of
updates.
I
can
talk
you
through
it.
Of
course.
If
you
have
any
topics
or
questions,
we
can
add
them
to
the
agenda
as
well.
So
what
do
you
guys
think
on
that?
I
will
start
from
the
top
all
the
way
to
the
bottom,
the
store
API?
A
A
So
there
were
all
sorts
of
not
arbitrary,
but
it
seemed
arbitrary
because
I
would
add
functions
based
on
a
given
use
case,
so
it
made
the
interface
a
little
bit
clunky
in
my
eyes,
so
I
simplified
it
by
employing
a
a
model,
that's
similar
to
the
specification
pattern,
but
not
the
way
it
was
done
in
Elsa
to
where
it
was
too
open-ended
and
too
too
flexible,
which
made
it
really
hard
for
implementers
to.
You
know
to
realize
what
are
the
various
permutations?
A
What
are
the
actual
specifications
out
there
to
implement
so
that
made
it
very
tricky
to
to
to
implement
custom
persistent
stores,
so
here
I
took
sort
of
a
middle
ground,
I
guess
where,
for
example,
taking
the
workflow
instance
store?
That's
not
this
one
well,
this
is
not
a
good
example.
Let
me
let
me
open
a
different
one.
A
So,
let's
take
a
look
at
the
workflow
instance
store
in
the
management
module,
so
it
has
just
basically
one
two
well
three
four
sets
of
of
methods,
and
let's
take
a
look
at
to
find
this
thing
guys
you,
as
you
can
see
the
what
they
all
have
in
common.
Are
they
just
accept
a
filter
which
is
basically
your
specification
and
actually,
let's
take
a
look
at
the
filter,
the
work
lenses
filter.
The
specification
is
well.
A
This
filter
is
used
as
a
bunch
of
fields
that,
if
they
are
set,
they
will
be
included
in
the
query
and
if
not,
they
will
not
be
considered.
So,
for
example,
if
you
wanted
to
get
all
workflow
instances
of
a
given
status,
you
would
just
set
the
workflow
status
or
maybe
you're
interested
in
a
single
workflow
instance.
Then
you
just
set
the
ID,
or
maybe
you
want
multiple.
Then
you
set
a
collection
of
IDs.
This
one
also
supports
a
search
term,
so
it's
very
tailored
towards
this
given
persistent
store,
but
the
API
is
very
clean.
A
So
the
caller
would
just
instantiate
a
word
for
definition.
Filter
fill
out
the
fields
that
they
want
to
fill
to
buy,
and
that's
it
it's
a
little
bit
inspired
also
on
the
API,
where
you
also
can
construct,
which
is
more
advanced
of,
of
course,
more
Dynamic
this
one.
But
the
usage
is
nice,
where
you
just
have
an
object
that
you
configure
and
then
fire
away.
The
the
request
here
are
the
the
variants
for
getting
single
items
and
multiple
items
multiple
matches,
and
there
are
some
overloads.
A
For
example,
if
you
wanted
to
order
by
a
given
property
on
the
workflow
definition,
then
you
would
use
this
overload
where
you
get
to
specify
the
order.
So
the
same
refactoring
has
been
applied
to
all
of
the
other
stores,
so
including
the
workflow
definition
store.
Workflow
instance
store.
We,
we
saw
the
other
one
here
somewhere
in
the
right
time.
There
you
go
so
we
have
bookmark
store,
trigger
store
and
the
word
for
execution,
lock,
store
and
the
workflow
state
store,
and
some
of
them
are
simpler.
A
C
Quick
quick
question:
what
is
the
advantage
of
creating
a
specific
class
filter
regarding,
for
example,
directly
passing
an
expression
funky
Christian
like
it?
It
does
in
the
Azure
table,
SDK
or
Azure
blob
SDK,
for
example,.
A
Yeah
good
question,
so
we
could
do
it,
but
then
it
depends
on
the
underlying
persistence
mechanisms
in
API
if
it
can
actually
translate
that
expression
into
something
meaningful
for
the
online
resistance
store
and
for
Entity
framework
word
would
work
out,
maybe
also
for
the
scene.
I
I
don't
know,
but
maybe
that
will
work
out
too,
probably
also
for
mongodb
or
most
certainly
it
should
work
out
for
that.
A
But
what,
if
you
have
a
very,
very
special,
specific
or
specialized
persistent
store,
maybe
in
the
form
of
a
web
API
that
you
implemented,
and
you
want
to
use
your
API
to
read
and
write
data
in
that
case,
it
would
be
probably
very
hard
to
translate
these
Expressions
to
API
calls
or
parameters
you
want
to
send
to
your
API.
So
that's
the
that's
pretty
much
the
only
reason
so
as
not
to
rely
on
Expressions
being
able
to
to
be
translated.
A
C
A
A
There's
only
an
implementation
for
workflow
instance
store
and
workflow
execution
like
this
store,
but
it
could
also
be
used
for
other
stores
if,
if
we
wanted
to
but
I
I,
don't
think
at
this
point
at
least
that
it
doesn't
make
that
doesn't
add
much
value
yeah,
but
maybe
maybe
that
will
change
in
the
future
contracts.
A
So
here
we
have
the
workflow
execution
lock
store,
and
if
we
look
at
its
implementations,
we
have
EF
core
elastics
elastic,
workflow,
store
and
memory
implementation,
so
the
EF
core
memory
they're
very
similar,
because,
let's
see
here,
we
have
find
then
here
it
calls
a
method
called
filter
which
is
private
here
and
basically
what
it
does.
It
takes
the
the
filter
and
calls
on
apply
on
the
filter,
which
is
just
a
method
on
the
filter
itself.
It
translates
the
well.
It
applies
its
properties
onto
the
queryable
that
spacing
receives
here
using
simple
logic.
A
So,
if
some
field
is
not
now,
then
it
will
update
the
queryable
by
some
appropriate
condition.
But
that's
the
pattern
here
and
to
get
back
to
your
point.
If
we
were
to
allow
just
Expressions
directly,
then
we
wouldn't
even
need
this
separate
object,
but
let's
look
at
the
other
implementation
elastic.
It
has
a
similar
throats
here.
It
also
has
a
filter,
but
then,
of
course,
the
how
the
filter
is
applied
here
is
is
different.
So,
yes,
here
it's
of
course,
you're
familiar
of
course
with
the
elasticsearch
SDK.
So
here
it
uses
maths
Fields.
A
If
there
were
a
translation
between
expressions
and
elastic
search
queries,
then
that
would
simplify
things,
but
at
the
same
time
it's
I
think
this
is
a
good
proof
concept
that
it
doesn't
matter
what
the
actual
underlying
persistence
is
at
this
API
service
level,
you
just
provide
your
filter
object
and
the
implementation
takes
care
of
creating
the
correct
query.
Okay,.
A
All
right
so
the
there's
a
new
activity
called
flow,
HTTP
request,
which
is
like
the
HP
request
activity
and
just
to
remind
you
what
that
looks
like.
Let
me
start
the
designer
and
the
back
ends
all
right.
So
let's
say
we
have
HP
request
this
one
was
there
before
we
have
a
new
one.
Let
me
let
me
explain
the
reason
for
this
one.
So
first
we
add
HP
request.
Let's
say
we
want
to
make
a
request
to
get
a
single
user
from
our
backends,
for
example
this
URL,
and
then
that's
it.
A
Of
course
we
want
to
capture
the
output,
so
we
can
get
the
HP
response
stored
in
a
variable
so
that
we
could
test
what
the
status
code
is.
Maybe
if
it's
200
we
want
to
go
left
and
if
it's
400,
we
want
to
do
something
else.
So
that
would
look
like
this.
We
would
create
an
HP
response
variable
and
then
this
the
response
being
stored
in
this
variable.
We
could
now
add
a
if
or
maybe
a
row
decision-
and
here
we
could
say
return
is
get
HP
response,
dot
status
codes.
A
Let's
say
if
it's
200,
then
we
would
return
true,
but
otherwise
we
return
false.
So
we
could
just
do
it
like
this.
If
it's
100,
it's
true,
otherwise,
it's
of
course
we
could
also
go
with
a
flow
switch
and
then
we
can
handle
multiple
status
codes
if
we
wanted
to,
but
just
let's
imagine
this
is
what
we
want
to
do
so.
This
works.
This
is
fine,
but
we
can
do
it
better
using
the
low
ASP
requests,
which
inherits
from
eight
speed
requests
or
actually
both
these
activities.
A
A
We
can
provide
the
expected
status
codes
that
we
want
to
handle
so,
let's
say
200
and
400
and
as
you
can
see
on
the
outputs
immediately,
we
get
the
expected
status
codes
available
as
outcomes
so
that
we
can
get
rid
of
the
decision
here
for
the
switch
whatever
we
wanted
to
use.
So
this
is
like
a
built-in
switch,
so
that's
new,
which
makes
it
a
little
bit
easier
to
model
your
Globe.
So
that's
awesome.
B
A
Good
question
so,
and
that
also
takes
me
back
to
the
reason
we
see
it
here,
but
when
I
mentioned
it's
not
implemented
it's.
The
difference
is
similar
to
when
we
have
the
flow
decision
here,
where
we
have
the
true
and
false
outcomes
as
ports
as
the
as
as
these
ports
here,
but
we
also
have,
if
so,
if
and
flow.
This
is
in
there
functionally
the
same,
but
in
terms
of
modeling
they're
different.
So
this
one
here
also
allows
you
to
set
a
condition.
It
could
be
the
same
condition
here.
A
Let's
say
it's
like
this
and
here
what
we
can
do
is
do
something
if
this
is
true
and
if
something
is
false
and
then
continue
on
with
the
rest
of
the
Vlog.
So
we
could
maybe
just
continue
with
this
one
here,
and
that
is
not
possible
with
this
flow
decision
here
you
have
either
true
and
false,
and
that's
it
so
it's
it's
this
direction
or
this
direction
in
here
you
have
some
embedded
logic.
You
can
Implement
and
then
continue
on
with
the
main
flow.
Similarly,
with
the
HP
request
activity,
you
can
do
that
as
well.
A
So
here
you
could
have
expected
status
codes
like
200s
400s,
so
now
there's
an
error
why?
This
is
why
you
are
seeing
this
issue
here,
but
let's
pretend
there's
no
issue.
What
would
happen
is
you
would
see
similar
to
HC
with?
If
you
see
you
would
see
200
and
400,
so
you
can
then
execute
some
subflow
in
response
to
some
status
code
and
then
continue
on
with
the
with
the
main
flow.
So
this
this
flowchart
model
here
that
we
are
using
it's
like
a
hybrid
between
flowcharts
and
sequential
workflows,
okay,.
A
Yeah,
so
exactly
this
is
this
is
designed
for
you
using
flowchart
diagrams,
but
you
can
imagine
if
we
have
a
sequential
diagram
editor
similar
to
what
we
have
in
Windows
workflow
Foundation.
You
would
probably
use
the
this
one
here.
That's
Now
hidden
from
view
because
the
in
those
diagrams
the
ports
here
they
don't
make
sense
and
these
ports
here
they
are
used
as
connection
points.
So
you
can
create
connections
between
these
ports
and
that
makes
sense
in
the
flow
chart,
but
it
doesn't
make
sense
in
a
sequential
diagram.
Do.
C
C
A
I'm
thinking,
maybe
we
can
add
it
in
this
documentation
here,
where
we
add
a
section
called
activities
or
activity
Library
here
categorized,
so
we
can
list
all
of
The,
Primitives
ones,
the
flow
ones
or
or
depending
on
how
we
want
to
categorize.
There
would
be
an
HTTP
category
and
that
would
then
display
at
least
those
two
activities
with
a
description
and
use
cases.
Etc.
C
Do
you
think
it
could
be
useful
to
to
because
this
information
will
be
sourced
on
the
activity,
class
or
activity
development
to
be
able
to
generate
a
documentation
directly,
and
do
you
think
it
could
be
interesting
to
have
this
kind
of
information
directly
when
we
create
the
buffer
yeah?
A
But
it
would
also
be
good
to
have
XML
or
generated
documentation
based
on
XML,
so
that
you
have
more
details
on
on
the
specifics,
and
this
is
more
like
a
like
a
guide
yeah.
But
it's
a
it's
a
good
point,
because
it's
important
as
a
newcomer
and
you
see
these
variants
it's.
It
can
be
very
confusing
when
to
use
what
without
proper
guidance
and
documentation,
yeah
and
of
course,
some
users
may
have
a
preference.
A
Maybe
the
maturity
fuses
will
just
be
dealing
with
sequential
or
not
sequential,
but
floater
diagrams
when
using
designer,
and
they
may
not
ever
want
to
even
see
the
sequential
ones
and
always
use
these
these
things
and
that
will
be
configurable
from
the
application.
First,
then,
in
the
future
that
would
be
configuration
driven
and
then
you
can
also
assign
it
to
potentially
to
user
permissions
and
roles,
but
those
are
roadmap
items
all
right.
So
that's
that's.
The
thing
flow
ATP
request,
improved
Json
handling
for
HTTP
workflows.
A
So
as
we
found
when
doing
typical
scenarios,
for
example,
where
you
expose
an
HP
endpoint
on
your
workflow,
receive
some
Json
payloads,
and
maybe
you
just
want
to
access
some
fields
on
it
or
Echo
back
the
the
Json
object
to
the
response
that
didn't
work
very
fluidly,
but
that's
a
lot
of
improvement
has
to
be
made
there
so
just
to
show
you
is
a
simple
example:
let's
say
we
have
an
HTTP
endpoint
here
and
we
make
yeah.
Let's
say
we
just
want
to
Echo
back
what
we
received.
A
A
It
has
a
support
field
and
data
represents
a
user.
It
seems
so
there's
a
couple
of
things
or
more
than
a
couple
of
things
we
can
capture
from
the
inbound
request.
The
raw
HP
request
can
be
captured
here
using
the
result
of
type
HTTP
request,
which
is
an
actual
C
sharp
object.
Although
yeah
I
think
this
is
actually
a
non-serializable
request
that
you
get
from.net,
but
let
me
let
me
double
check
to
make
sure
I'm
not
saying
anything.
That's
not
true
here
right,
so
this
HP
request
lives
in
the
Microsoft
aspin.
A
It
creates
to
be
namespace,
and
important
here
is
that
this
is
non-sterilizable.
So
when
you
are
going
to
capture
this
one
through
a
variable,
it's
important
to
set
the
storage
to
memory,
because
otherwise
the
system
is
going
to
try
and
serialize
it
and
it
might.
It
will
likely
fail
in
this
case
on
this
topic.
Thinking
of
making
this
a
little
bit
more
intelligent
where
it,
it
already
knows,
based
on
the
type,
whether
it's
realizable
or
not,
and
usually
using
the
correct
storage
automatically
or
at
least
a
supported
store
like
memory.
A
A
But
for
now,
just
this
little
heads
up
this
little
bug,
we
still
need
to
fix
where
it
doesn't
rebind
when
we
change
the
variables,
but
it's
on
the
list
and
to
work
around
that
just
click
away
and
then
Focus
again
and
then
it
should
be
there
like
so,
but
for
this
demo,
I
just
will
take
the
parse
content
directly.
So
this
HP
endpoint
will
also
parse
the
inbound
request
body
into
the
target
type
of
whatever
variable
you
have
selected.
So
if
you
have
a
variable
of
type
string,
it
will
not
do
any
parsing.
A
It
will
just
read
the
request
body
and
store
it
as
a
string.
But
if
you
specify
iterate.net
type
or
an
expandable
object
or
just
object,
it
will
try
and
parse
the
string
content
into
a
Json
object
or
in
the
case
of
a.net
type.
It
will
deserialize
it
into
that
type.
So
here,
since
we
don't
have
any.net
type,
we'll
just
use
an
expand,
the
object,
we
could
also
choose
to
go
with
object
and
internally
by
default
it
will
deserialize
into
an
expanded
object.
A
You
could
also
choose
to
use
a
Json
object,
which
is
it
which
lives
in
the
system
text
Json
namespace.
If
you
wanted
to
use
that
API
to
then
Traverse,
your
Json
object.
So
it's
up
to
you,
but
this
one
is
usually
the
most
convenient
because
then
you
can
use
that
notation
to
access
fields
on
your
incoming
Json
payload.
So
let's
call
this
user
payload
and
then
we
just
want
to
write
it
back.
Just
the
whole
object,
so
we
should
be
able
to
say
get
user
payload.
A
We
don't
have
to
set
a
content
type
if
we
we
can,
but
if
we
don't,
it
will
default
to
application
Json.
If
the
content
is
complex
object
and
if
it's
a
string,
then
it
will
default
to
plain
text
and
of
course
you
can
explicitly
control
the
content
type
that
you
want
to
use.
If
the
content
type
you
want
to
use
doesn't
exist
in
this
list,
you
can
always
switch
to
JavaScript
or
liquid
and
just
enter
the
content
type
you
want
and,
of
course,
we'll
make
this
configurable
at
some
point
yeah.
A
If
you
want
to
provide
some
response,
headers
that
works
too,
all
you
need
to
do
is
just
return.
A
JavaScript
object
where
the
field
names
are
the
keys
and
the
values
are
the
values
so,
for
example
like
this,
and
this
will
be
parsed
into
a
dictionary
and
maybe
copied
into
the
response
stream.
Okay.
So
this
let's
try
this
one
out.
If
we
send
this
one
Base
address,
workflows,
demo,
of
course,
I.
Don't
I
should
not
forget
to
set
this
one.
A
As
can
start
workflow
checking
this
box
on
a
activity
that
supports
triggers
will
create
a
triggering
system
so
that
you
can
actually
invoke
this
one.
So,
as
you
can
see,
we
send
this
data
and
we
received
it
back,
as
is
we
could
also
choose
to
just
return
this
field,
so
that
would
look
like
like
this.
So
so
we
could
say
the
Theta,
because
this
is
an
expanded
object
with
Dynamic
access
to
its
Fields,
publish
this
and
then
try
it
again.
A
We
just
get
that
section,
and
this
works
for
individual
Fields
as
well,
of
course,
and
even
constructing
custom
LTX
that
that
works
as
well.
So
you
could
just
say
user
like
this,
so
this
makes
it
very
easy
and
convenient
to
quickly
Implement
API
endpoints,
using
Wordpress,
if
you
wanted
to
another
common
use
case,
is
to
actually
make
a
call
to
some
backend
system.
Let's
imagine
this
thing.
This
API
is
our
backend,
so
in
in
response
to
the
HP
endpoint
activity,
we
will
send
an
ATB
request
like
this,
and
then
the
method
is
get
content.
A
Type
will
be
selected
automatically,
based
on
the
response,
content
type
and
the
outputs.
We
already
created
a
variable
called
user
payload
which
well
it's
a
dynamic
object,
so
we
can
use
it
here.
We'll
ignore
this
payload
here
we
can
actually
just
unset
it
we're
not
going
to
do
anything
here.
Keep
this
as
that's
fine,
but
here
when
we
send
the
HP
request
to
this
back
end,
this
Mac
API.
We
want
to
store
it
in
the
user
payload
here.
A
Here
too,
we
can
capture
the
HTTP
response
if
we
wanted
to
which
allows
you
to
access
more
objects
that
that
are
part
of
the
HP
response
object,
such
as
cookies
and
headers,
but
here
we're
just
interested
in
the
in
the
response
body
and
because
we
we
use
the
same
model
when
we
were
just
doing
the
demo
a
minute
ago.
The
model
will
be
the
same,
so
we
don't
need
to
change
this
code
here
this.
This
will
just
work
because
it
has
a
data
field.
A
Okay,
so
now,
when
we
submit
this
again,
nothing
seems
to
have
changed,
but
of
course
we
know
that.
Actually
let
me
not
send
anything
here
and
do
it
again.
You
see
it.
This
content
came
from
this
ASP
request
and
then
we
echoed
it
back
well,
more
or
less,
because
we
are
modifying
the
result
model
here,
a
little
bit
all
right.
So
we
also
improved
community
education,
the
composition
between
parents
and
child
workflows.
What
I
will
show
is
the
ability
to
create
composite
activities
using
the
designer
by
creating
workflow
definitions.
A
So
what
we
can
do
is
create
a
workflow
definition,
design
a
reusable
bit
of
logic,
mark
it
as
reusable
or
as
an
activity,
and
then
we
can
use
that
so
I
already
did
the
demo
one
during
one
of
during
one
of
the
last
meetings,
but
it's
been
improved
a
little
bit
more.
There's
now
also
the
ability
to
configure
the
out
possible
outcomes.
So,
let's
take
a
look.
Let's
say
we
create
a
simple
sum
operation.
A
That's
not
the
correct
word
in
this
context,
but
I
by
lack
of
a
better
way.
Words
we'll
use
it
like
this.
This
is
the
activity
name.
Of
course
we
are
creating
a
word
for
definition,
but
by
setting
useless
activity
to
yes,
it's
a
it
will
be
useful
as
an
activity,
and
then
this
name
will
be
used
for
that
activity
type.
We
can
say
it
provide
some
description.
It
turns
positive
if
the
value
is
greater
than
zero.
Let's
do
it
like
this.
So
we'll
add
another
outcome
called
neutral
if
it's
zero,
alright.
A
So
these
are
the
outcomes,
but
of
course
we
need
some
input.
We
need
some
value,
some
number
to
determine
whether
it's
positive
value
or
negative
value
or
a
neutral
value.
So
we'll
add
a
value
of
type
int
and
we'll
call
this
or
this
is
the
this
will
be
the
display
name
as
presented
to
the
user.
That's
using
this
composite
activity,
so
we'll
call
this
value.
So
here
we
have
an
inputs,
we
can
provide
an
output,
but
in
this
case
I
will
just
demo
the
the
outcomes.
A
Actually,
let's
do
both
so
we'll
also
provide
the
some
textual
presentation
of
the
positivity,
so
we'll
say
positivity
of
type
string.
Okay.
So
this
is
basically
the
the
interface
the
the
function
signature,
if
you
will,
if
you
think
of
this
workflow
as
a
function,
but
now
comes
the
implementation,
and
for
that
we
will
maybe
use
JavaScript
or
actually,
let's
use
it.
Let's
switch
a
switch
switch
sounds
perfect
all
right,
so
we
use
this
flow
switch.
C
A
Here
exactly
yes,
yeah,
as
you
can
see
in
these
here,
these
are
embedded
ports
and
these
are
external
ports,
yeah,
okay,
so
so
good!
So
now
we
have
handled
this
input
and
we
can
return
the
positivity.
But
the
question
is
now:
how
do
we
provide
the
output
here
and
also,
how
do
we
communicate
the
outcome
and
for
that
we
have
I,
think
complete
yeah.
So
using
the
complete
activity
we
can
control
the
outcome
of
the
current
scope
or
the
current
workflow.
A
So
here
we'll
say
for
positive:
we'll
return
the
positive
outcome,
so
this
list
is
fed
from
the
outcomes
here.
So
we'll
connect
these
two
and
then
the
same
goes
for
so
let's
there's
a
name:
positive,
negative
and
neutral
okay,
so
that
handles
sending
back
the
outcomes.
And
the
question
is:
how
do
we
provide
the
outputs
and
that's
this
one
here
set
where
workflow
outputs
and
we
can
either
basically
repeat
the
logic
here
as
to
set
the
value.
A
So
here
we
can
set
the
output
to
positive,
so
that's
directly
bound
to
here,
and
the
value
could
be
basically
a
copy
of
what
we
implemented
here,
which
is
the
easiest
in
this
example
I
think.
But
of
course
you
could
also
add
a
set
workflow
output
in
each
Brands
and
do
it
this
way,
but
to
keep
the
flow
well
I
want
to
say
to
keep
the
flow
simple.
A
C
There
is
no
other
importance
in
settings
or
output
and
then
complete
the
workload
we
can
complete
before
settings.
Workflow
output.
A
Actually,
that's
clever
yeah,
of
course
we
set
first,
the
output
them
to
the
switch
on
the
output.
Here
we
could,
it
doesn't
provide
some
output,
but
but
you're
right
of
course,
yes,
and
we
could
even
store
the
the
actual
positivity
in
a
variable.
Then
we
use
that
variable
to
set
the
output
and
also
switch
on
the
variable
here
if
we
needed
to
yeah
because
well,
actually,
then
we
don't
even
need
this
flow
switch
because
then
we
can
just
switch
to
JavaScript
and
return
the
outcome
here.
That's
that's
the
easiest
one.
C
A
Yes,
that's
even
simpler:
you
can
just
do
JavaScript,
actually
I
think
we
would
be
missing.
We
can
set
the
output,
that's
okay,
but
so
the
dentist
JavaScript
have
to
return
the
output,
but
then
there's
no
way
to
set
the
outcome,
so
we
would
either
need
another
JavaScript
and
then
a
function
to
set
it
and
I've
seen
in,
for
example,
Orchards
there
they
have
also
JavaScript
activity,
and
it
has
a
function
called
set
outcome,
I
believe
and
then
then
you
can
also
specify
the
list
of
possible
outcomes
and
then
they
they
appear
as
ports
here.
A
So
that's
that's.
Another
could
be
a
either
a
separate
activity
or
an
enhancement
to
run
JavaScript
but
yeah,
but
that
works
too
in
part.
But
for
now,
let's
do
it
like
this.
The
positivity
and
notice
that
I'm
not
using
positivity
as
which
is
which
would
conflict
with
the
output
name
here,
potentially
I
I
haven't
tested
it.
So
I
don't
want
to
accidentally
cause
some
weird
Behavior
I
do
need
to
test
this
before
before
long,
but
for
now
it
is
to
be
safe.
I
will
just
call
it
the
positivity
and
it
will
be
a
string.
A
Of
course
object
will
work
because
an
object
can
be
anything,
but
in
this
case
it
I
like
to
be
specific,
so
we
have
a
variable
to
positivity.
Then
we
need
to
set
that
value
using
that
variable.
Okay,
so
here
we
have
a
string
for
the
positivity.
That's
this
one.
Then
we
will
connect
it
to
setting
the
output
positivity
and
the
output
what
we
get
the
positivity
like,
so
that
we
that
handles
setting
this
and
then
finally,
we
just
need
one
set
outcome
outcome
would
be
a
JavaScript
expression.
A
You
can
take
positivity
so
just
test
this
one,
all
right,
so
good
thinking,
Mohammed.
That
was
that's
much
much
easier,
all
right.
So
now
that
we
published
this
one,
we
have
a
new
category
called
workflows
which
contains
this
activity
here,
so
we
can
use
this
now
as
an
activity.
So
if
we
go
back
to
the
workflow
here,
we
can
add
it
here.
So
here
we
see
the
outcomes
positive,
negative
neutral.
Here
we
can
provide
a
value,
so
we
could
say:
let's
try,
let's
try.
Actually,
let's,
let's
make
it
pyramid
the
rise
rule.
A
So
let's
say
we
start
this
workflow
from
an
HP
endpoint
and
we'll
create
a
new
variable
called
The
Arc,
so
that
this
will
be
the
contain
a
it.
Let's
say:
it's
a
dynamic
object
and
it
will
contain
the
value
as
a
as
a
field
on
the
Json
and
we'll
capture
it
here
as
the
arc.
Then
he
will
use
that
as
an
input.
So
we'll
say
for
the
value
you
will
use
a
JavaScript
expression
codes
get
the
arc
which
will
be
an
object
containing
a
field
called
value,
but
here
we'll
be
sending
Json.
C
C
A
Then
the
outputs
we
will
capture
seeing
this,
and
this
is
a
string
and
we'll
also.
We
can
also
connect
some
logic
here,
so
we
could
maybe
Echo
back
to
the
to
the
ASP
client.
We
can
say
positive,
negative
and
neutral
all
right.
So,
let's
see
if
this
works
not
found.
Oh
yeah,
let's
make
this
a
post,
so
we
received
an
okay.
We
didn't
get
any
content
back.
So
that's
an
issue.
Let's
see
if
we
can
look
at
the
workflow
instance
here
so
here
we
have
the
journal.
So
we
have
the
end
point
here
post.
A
This
is
not
right.
This
should
be
the
evaluated
value.
So
let
me
double
check
something
JavaScript.
Okay,
it
looks
like
I
broke
something
in
the
process
and
this
is
not
being
evaluated.
So
so
that's
unfortunate
for
this
demo,
but
you
can
see
the
the
way
it's
going
to
work
so
having
the
main
point
being
being
able
to
create
composite
activities
easily
using
the
designer
without
having
to
do
it
in
C
sharp.
Of
course
you
can
still
do
that,
but
this
is.
A
This
provides
a
a
faster
way
and
also
more
clear
in
case
you
do
have
some
more
complicated
logic,
it's
easier
to
look
at
it
visually
than
potentially
in
C
sharp
and
the
ability
to
connect
these
these
outcomes.
But
let's
see
if,
if
it
at
least
Works
without
JavaScript,
so
let's
imagine
that
we
received
it
like
this.
Well,
that's
I
should
have
I
should
have
tested
this
before
the
demo.
This
is
this.
Is
too
bad?
Let
me
let
me
quickly
check
the
back
ends
here
and
just
double
check.
A
A
Maybe
it
could
be
neutral
negative,
so
the
casing
is
is
correct
so
that
shouldn't
be
oh,
that's,
okay,
I
will
I,
will
double
check
this
after
the
call
and
make
sure
it
works
the
next
time
I
demo,
this
one
yeah.
So
let's
see
what's
next,
so
this
one
is
covered.
This
one
is
covered,
although
we
found
some
issues
ability
to
upgrade
composite
activities.
So
that's
related
to
this
one
here.
So
now
we
have
two
two
versions.
This
one
is
published.
This
was
version
one
yeah,
and
here
we
have
version
two.
A
So
let's,
let's
imagine
we
we
make
a
change
where
we
say
we
accept
yet
another
inputs
parameter.
Let's
go
to
the
input.
Two
of
type
object
doesn't
matter,
but
the
point
is
the
signature
has
changed.
We
published
this
one.
Oh
I
was
wondering
why
I
didn't
publish
and
that's
because
it
requires
you
for
now,
at
least
as
a
safety
guard
to
be
on
the
on
the
draft,
because
you
can't
publish
anything,
but
the
latest
version.
A
Of
course,
I
will
probably
change
it
to
when
you
click
publish
it
will
just
take
the
the
current
latest
one,
but
this
was
a
quick
fix
to
make
sure
it
didn't
break
anything.
If
you
were
looking
at
an
older
version,
so
switching
back
to
the
latest
version
here,
then
publishing
will
work
and
again
so
the
signature
has
changed
here
or
wait.
Where
did
my
inputs?
Go
I,
don't
know
what
happened
there.
A
If
we
look
at
version,
its
current
version
is
what,
but
we
have
a
new
version
published
and
the
reason
it
doesn't
do
this
automatically
is
because
if
you
change
the
implementation
or
the
signature
or
both
or
either
of
a
composite
activity,
then
you
could
potentially
break
other
workflows
out
there
that
are
in
production,
they're
running
so
you
want
to
you,
don't
want
to
risk
that.
A
A
But
now,
if
we
upgrade,
we
are
now
at
the
latest
version
and
then
we
can
take
advantage
of
the
update
here,
probably
we'll
add
some
tooling,
so
that
you
can
do
it
in
bulk,
on
maybe
whole
workflow
definitions
or
maybe
a
selection
of
workflow
definitions
where
you
want
to
apply
or
upgrade
the
composite
activities.
But
we'll
have
to
think
more
about
that.
For
now
it's
it's
this
manual
operation,
which
is
a
little
bit
of
work,
but
but
it's
the
it's.
It's
the
safest
option
for
now,
I.
C
A
That's
a
good
good
suggestion
right
now.
You
would
do
it
by
going
to
the
composite
definition
here,
let's
say-
and
you
say
let's
say
this:
one
has
a
bug
and
this
one
is
okay,
so
you
can
say
revert
it
will
create
a
new
version,
but
based
on
this
one,
so
this
this
is
a
copy
of
this
one.
You
can
publish
this
and
then
revert
to
the
the
latest
version
here,
but
I
I
agree.
It
would
be
good
to
just
be
able
to
select
the
version
you
want
to
use.
A
A
But
let's
say
we
delete
version
four
right,
so
we're
just
gonna.
Try
it
so
I'm
gonna
go
here.
I'm
gonna
revert
the
revert,
so
we
we
can't
delete
it
now,
because
it's
the
published
version,
but
I'll
just
do
this
one,
and
now
we
should
be
able
to
delete
this
one
and
since
it
didn't
disappear,
I
suspect
something
in
the
back
end.
Didn't
go
well,
nothing
wrong
here.
What
about
the
console?
Oh
yeah,
so
we
got
issues
here.
So
this
is.
A
This
is
something
we
need
to
improve
in
Safeguard,
but
for
now
you're
more
or
less
protected.
By
doing
something
like
that
and
you're
you
just
you
just
get
an
error,
but
the
question
is
what
should
happen
if
we
delete
a
version
that
is
used
to
be
maybe
prevent
it
prevent
the
user
from
doing
so
by
checking
to
see
if
there's
any
usages,
probably.
A
A
C
I
I
think
at
least
we
we
must
show
the
usage.
We
must
be
able
to
show
the
usage,
and
then
we
can
think
about
how
we
can
work
on
it
because
I
think
it's
very
difficult,
because
if
we
decide
to
change
all
the
workflow,
we
need
to
republish
all
the
workflow
Etc.
It
could
be
a
breaking
something
it
could
be,
create
some
issue
and
a
done
done
time
in
the
in
This
Server.
So
it's
a
it's
a
real
question.
Yeah.
A
C
A
So
yeah,
so
that's
a
thing.
We
definitely
need
to
improve
here,
but
for
now,
as
you
can
see
that
doesn't
even
work,
I
wonder
if
you
can
delete
any
version
in
the
first
place,
nope
latest
version
Oh
find
filter,
it's
the
post,
okay.
So
this
this
error
seems
to
be
unrelated
to
using
these
things,
but
put
some
bug
that
cut
in
introduced.
Well,
thank
you
for
the
question
Muhammad
and
and
showing.
A
It
sounds
like
you've,
you've
you've
gone
through
things,
yeah.
C
A
C
A
So
that
stems
from
from
the
bug
that
now
seems
to
have
corrupted
some
state,
so
what
I
will
do
is
open
the
database
and
do
some
cleanup
all
right
refresh
all
right.
So
let
me
show
this
following.
So
let's
say
we
have
two
right
lines:
publish
this
one,
take
a
note
of
definition.
Id
now,
I'm
gonna
run
this
workflow
using
the
execute
endpoint
so
that
this
workflow
executed
and
now
we're
going
to
look
at
the
workflow
instance.
So
here
we
have
one
instance.
A
This
is
the
journal,
so
it
shows
the
activities
that
executed
and
what's
different
now
in
this
version,
is
that
originally
it
would
just
show
the
expression
actually
now.
This
is
a
poor
demo,
because
it
doesn't
show
you
the
difference.
Let
me
fix
that
real
quick.
Let's
imagine
this
was
not
a
literal,
but
let's
say
it's
a
JavaScript
that
says
return
hello.
A
Let
me
execute
this
one
again,
all
right.
So,
as
you
can
see,
it
doesn't
display
the
string
extra,
the
JavaScript
expression
return,
hello,
but
the
evaluated
result
that's
different
here.
So
that's
a
that's
a
good
Improvement
and
also,
if
you
may
have
noticed
in
one
of
the
previous
demos,
even
when
using
composite
activities.
Even
though
you
don't
see
the
activities
on
the
designer
yet
we'll
add
that
capability
later,
you
will
be
able
to
look
at
the
executed
activities
of
those
composite
activities
and
inspect
their
values
here
and
what's
nice
as
compared
to
Elsa
too.
A
This
does
not
only
show
you
the
the
latest
state
of
the
activity,
but
you
can
click
on
the
journal
items
here
and
and
inspect
the
state
of
the
activity
at
that
time.
So
if
we
were
doing
this,
for
example,
in
a
loop,
we
should
be
able
to
see
the
state
of
the
activity
on
a
given
iteration
and
now
I
haven't
tried
that
but
sounds
like
something
fun
to
do
so
and
easy
as
well.
So
let's
say
we
have
a
looping
construct,
so
we're
gonna
just
delete
this.
A
One
here
delete
this
one
for
now,
and
then
we
say
or
one
two
three.
So
this
is
a
like
a
C
sharp
four
loop
from
one
to
three
we're
gonna
capture,
the
current
value
in
a
variable
like
that
and
then
for
each
iteration,
we'll
write,
something
so
we'll
say
right
line.
A
My
property
panel
doesn't
want
to
update
okay,
so
I,
don't
know
what
Eclipse
was
about,
but
here
we
have
the
right
line
and
we're
gonna
write
the
current
value,
so
we're
going
to
say
turn
or
we
don't
need
to
return
necessarily
we'll
just
say
current
step.
Then
we'll
get
the
current
value
like
this
right.
We
executed
the
workflow.
This
is
the
outputs
now
we'll
take
a
look
at
the
workflow
instance.
A
So
here
we
see
the
the
four
okay
so
looks
like
there's
an
issue
you
here
with
the
I,
don't
know
where
this
comes
from,
but
the
idea
was
for
each
iteration
to
see
well,
basically
see
three
right
lines
and
then
be
able
to
click
on
those
right
lines
and
see
it
appear
here.
But
unfortunately
it's
not
allowing
me
to
do
so
so
for
now
I
didn't
actually
know
you
were
able
to
drill
into
it.
A
Yeah.
Finally,
there
was
some
small
issue
fixed
with
the
checkbox
doesn't
seem
very
important
in
light
of
these
issues
that
I
just
encountered,
but
just
to
share
what
I
was
about
is
if
you
use
the
HTTP
endpoint
it
has
this
checkbox
here.
If
you
were
to
not
do
anything
but
just
publish,
it
would
suddenly
be
checked,
so
that's
fixed
and
then
finally,
there
was
an
issue
with
the
8
HP
route
table
which
is
used
for
routed
parameters.
A
So
let's
say
you
have
an
HP
endpoint
and
you
want
a
path
like,
let's
say
users,
and
then
some
user
ID
right
like
in
an
API
controller.
You
can
provide
a
route
parameter
in
the
routes.
So
here
we
can
do
that
as
well
that
that
that
works.
But
there
was
an
issue.
If
you
stop
the
application
and
start
it
again,
the
routes
would
the
route
table
would
not
be
re-initialized
based
on
the
triggers
of
of
a
workflow.
So
that's
me
fixed.
It
also
means
we.
A
We
should
be
able
to
read
this
ID
by
capturing
the
route
data.
So
that's
an
object
dictionary
and
then
this
will
contain
a
one
entry
with
a
key
of
ID
which
is
retrieved
from
this
route.
It
will
contain
the
value
of
this
route,
so
let's
say
number
two
and
then
we
should
be
able
to
make
a
request
here.
A
So
that
sounds
like
another
fun
thing
to
do,
but
we
can
say:
URL
actually
switch
this
one
to
JavaScript,
then
we'll
do
it
like
this,
so
we'll
say,
get
route
params
and
now
I'm,
not
sure
if
I
am
able
to
use
that
syntax
I,
don't
think
so,
since
this
is
a
dictionary
and
it's
not
an
expanded
object,
so
I'm
gonna
guess
it's
gonna
be
like
this
ID
all
right.
Let's
see
if
this
works,
so
the
route
was
users
ID
ide2.
We
now
exists
so
workflows.
Users
to
this
is
a
get.
A
So,
let's
change
this
to
that
and
that
worked,
so
we
were
able
to
capture
this
route
parameter
use
it
in
a
request
to
the
back
end
or
request
and
request
regress
re-exist
soon.
So
we
can
try.
Let's
what
do
we
get
with
three?
This
is
a
different
user
all
right,
so
that
was
the
the
final
one
that
I
wanted
to
show,
but
as
it's
clear,
it's
not
yet
ready
for
prime
time
there's
still
some
some
some
some
small,
some
bigger
issues
to
to
correct.
B
So
what
do
you
guys
think
yeah
to
school?
I
have
one
question
by
looking
at
this
demo,
so
suppose
I
have
a
workflow
that
needs
to
connect
to
certain
API
and
collect
the
data
periodically,
and
for
this
API
I
need
to
have
an
access
token,
so
I
need
to
log
in
get
an
access
token
and
then
use
it
in
the
workflow.
And
this
token
maybe
will
expire
after
several
hours.
But
I
don't
want
to
request
a
new
token.
Every
time
I
execute
the
workflow.
C
A
That
would
be
similar
to
using
a
set
variable,
so
the
variable
is
like
a
cash
but
either
stored
as
part
of
of
the
workflow
or
maybe
a
redis
storage,
or,
as
you
said,
as
you
suggest,
maybe
there
should
be
a
a
cast
activity
that
could
make
sense.
It
could
make
sense
to
to
store
stuff
in
the
cache
and
then
you
can
request
this
access.
A
Token
store
it
in
Cache
use
it,
but
but
you
would
have
to
do
some
logic
right
to
check
if
to
see
if
the
gas
value
is
still
there
or
maybe
even
handle
the
401
response
from
your
initial
HP
or
your
yeah,
your
HP
request.
You
could,
for
example,
use
this
this
thing
here
to
make
your
API
call
and
initially
it.
If
there's
no
token,
it
will
respond
with
a
401,
so
it
would
say
you
basically
would
expect
to
go
out
to
0
and
401.
A
So
what
you
could
do
in
the
401
Brands,
you
would
say
authenticate.
Let's
say:
let's
say
this
is
authenticate,
and
then
you
can
just
try
again
so
because
here
authenticate
will
in
the
output,
you
will
capture
the
response
here:
HP
response
which
will
carry
the
access
token
or
maybe,
as
part
of
a
Json
object.
You
would
set
it
to
some
some
cash
value,
maybe
or
a
variable.
Let's
keep
it
simple
for
now
and
use
a
variable
access
token.
So
this
would
be
like.
Let's
use
use
data.
A
C
A
Store
access
token
and
then
there
we
can
try
the
request
again.
We
can
go
back
here
and
this
time.
Ideally
this,
of
course,
will
include
your
access
token
in
the
settings
here
in
the
authorization
you
have
access
token
like
so
and
and
what's
nice
here
is
because
of
this
automatic
Loop.
You
don't
have
to
do
anything
else.
You
can
now
just
to
continue
on
to
whatever
else
you
need
to
do.
C
Yeah
yeah
and
if
we
have
some
some
cache
mechanism,
we
can
just
encapsulate
this
into
a
composite
to
our
flow,
get
the
access
token.
If
it's,
if
it
is
found,
we
check
the
the
time
Etc
and
if
it's
not
found
or
if
it
is
that
time
is
incorrect,
we
can
get
a
new
access
token
and
add
it
into
the
cache.
A
A
Then
that's
all
I
have
I'll
be
working
on
those
issues.
We
get
closer
to
potential
release
candidates
material
every
every
day.
Now
so
realistically,
hopefully
a
month
from
now,
we
can
do
a
release
candidate
with
with
with
a
stable
version,
good
yeah
yeah,
pretty
excited
about
that
all
right,
then.
Thank
you
guys
for
attending
and
I'll
see
you
next
next
time.
Yes,
thank
you.
Bye,
bye,
thank.