►
From YouTube: Elsa Workflows Community Meeting 31
Description
- Elsa 2.11 dashboard showing wrong version.
○ Should do a 2.11 release
- Flowchart logic improvements (looping + joining)
- Refactored background activity execution
- Refactored scheduling
- Fixed timer activity
- Quartz.Net
- Hangfire
- CRON activity
- Activity cancellation
- Activity descriptor modifiers
A
A
You
should
be
able
to
see
my
screen
now:
okay,
all
right,
so
that's
nice
and
big.
So
what
I
wanted
to
show
is
the
default
implementation
for
the
scheduler.
So
there's
this
is
the
scheduling
module.
It
contains
Quran
activity,
delay,
activity,
started
activity
and
a
timer
activity,
and
we
can
go
over
those
in
more
detail
in
a
second.
A
The
main
point
now
is
that
there's
one
contract
called
workflow
scheduler
and
it
allows
you
to
schedule
a
workflow
at
a
either
at
the
recurring
interfall
or
just
in
a
future
date
or
using
a
a
crown
expression,
and
this
works
for
starting
new
workflows,
but
also
for
resuming
existing
workflows,
and
that
in
this
API
is
what
these
activities
take
advantage
of.
So
there's
three
implementations
right
now,
so
there's
the
default,
workflow
scheduler,
there's
a
Hang,
Fire
implementation
and
there's
a
quartz
implementation,
which
is
the
most
accurate
one.
A
I
think
when
it
comes
to
scheduling,
recurring
tasks
and
fireworks
too,
but
you
need
to
make
sure
to
configure
its
sliding
in
for
pulling
into
follow
or
something
like
that
to
be
every
second,
for
example,
depending
on
how
angfire
is
great.
On
the
other
end
for
long
running
tasks,
that's
what
it's!
What
where
it
really
shines,
so
there's
also
an
implementation
for
that,
and
this
has
to
do
with
the
running
actives.
In
the
background,
so
it's
a
little
bit
unrelated
to
the
timing.
A
I
will
show
you
how
this
works
as
well
back
to
the
list
yeah
in
any
case.
So
that's
there's
a
lot
of
refactoring
done
for
the
scheduling.
I
just
mentioned
background
activity.
Execution
has
been
refactored
and
I
will
do
a
demo
on
this
one
that
makes
it
a
negativity,
called
cron
and
I've
been
working
on
activity
cancellation.
So,
of
course,
let's
imagine
you
have
a
workflow
that
has
a
fork
and
it
branches
into
a
timer
activity
or
delay
activity
and
maybe
a
event
activity,
and
then
you
have
a
join.
A
So
let
me
let
me
actually
show
you
in
the
desire
it's
easier
all
right.
So,
for
example,
here
let
me
zoom
out
just
a
little
bit
like
this.
So
here
we
have
a
have
a
fork
and
we
have
two
branches.
This
one
will
wait
for
five
seconds.
This
will
wait
for
10
seconds
and
then
here's
a
join
and
this
join
is
configured
to
be
to
wait
or,
oh,
that's,
sorry
avoid
any.
That's
the
correct
setting
await
any
means
that
the
workflow
will
continue
as
soon
as
one
of
the
inbound
branches
complete.
A
So
obviously,
in
this
case,
this
Branch
will
complete
before
this
Branch,
because
this
one
will
wait
for
10
seconds.
So
it
will
continue
this
path
and
the
flow
join.
What
it
will
do.
It
will
clear
all
of
the
bookmarks
of
the
other
inbound
path.
So
this
this
will
have
created
a
bookmark
which
will
be
deleted
and,
as
a
result
of
deleting
this
delay,
bookmark
the
pending
trigger
used
by
Quartz
or
Hang
Fire
or
the
default
one
will
also
be
deleted.
A
This
doesn't
yet
work
entirely
well
for
hangfire
I
noticed
that
it
will
still
try
to
resume
the
workflow,
so
the
job
doesn't
actually
get.
Canceled
doesn't
hurt
the
workflow
execution
because
they
will
no
longer
be
a
bookmark,
so
the
workflow
will
not
be
able
to
respond
to
that.
So
that's,
okay,
but
just
to
to
keep
to
make
it
extra
clean.
It
should
actually
cancel
the
job,
especially
if
you
have
jobs
that
perform
heavy
work.
Maybe
you
just
don't
want
that
to
actually
start
executing
right.
A
If,
let's
say
this
is
not
a
10
second
delay,
but
maybe
this
is
some
heavy
indexing
that
you're
gonna
start
in
the
background,
but
you
want
to
cancel
it
because
this
Brand's
completed
first.
It
should
not
start
that
work
and
right
now
it
will
start
to
work
at
least
the
Hang
Fire,
so
I
need
to
fix
that.
But
that's
the
point
of
canceling
activities.
A
So
in
response
to
clearing
the
bookmarks
activities
that
created
this
bookmark
get
an
opportunity
to
to
can
to
undo
whatever
the
work
they
they
scheduled
all
right
and
just
finally,
an
activity,
descriptor
modifier
API
was
implemented
and
what
is
what
does
that
mean?
So
in
elsa2
we
have
a
quartz
provider
for
the
timer
activities
and
a
Hang
Fire
provider
for
the
timer
activities
as
well,
but
depending
on
the
provided
use,
you
need
to
provide
a
different
Syntax
for
the
crown
expression
so
so
quartz.
A
This
is
a
different
interpretation
of
the
crown
expression
compared
to
Hang
Fire
and
and
to
make
this
visible
to
the
user.
We
need,
we
need.
A
way
to.
You
know,
update
the
description
so,
for
example,
here
sorry,
this
isn't.
Of
course
this
is
the
delay.
This
doesn't
involved
Chrome
but,
let's
add
a
chrome
activity.
Let's
use
this
one.
So
here
we
have
a
current
activity
used
as
a
trigger
and
it
has
a
current
expression
and
so
right
now
this
description
says
the
current
expression
of
which
the
timer
should
execute.
A
But
if
we
change
to
using
chords,
so
let's
change
it
to
chords
for
a
second,
so
I'm
gonna
switch
to
the
quartz
integration
sample
project,
so
here
I'm
using
it
in
this,
of
course,
it's
a
different
project,
so
it
has
a
different
database
and
it
has
different
workflow
definitions,
but
it
doesn't
matter.
This
is
the
same
productivity
here.
It's
just
used
as
a
blocking
activity,
but
here
you
can
see
that
the
description
was
updated.
A
So
it's
it's
specifically
mentions
the
quartz
of
netchron
expression
and,
of
course,
we
could
also
include
maybe
a
link
to
a
crown
Builder
UI
that
that
we
did
in
lc2.
So
here
we
can
do
the
same.
But
the
point
is
the
ability
to
change
this
for
for
a
given
module,
in
this
case
the
quartz
module,
and
that
happens
through
activity,
the
descriptor
modifiers.
So
as
an
example,
let's
open
the
quartz
module
and
then
here
we
have
the
class
called
connectivity,
descriptor
modifiers,
that's
a
class
that
implements
this
interface,
so
your
module.
A
Your
application
can
also
implement
this
interface
and
it
gives
you
access
to
the
activity
descriptor
and
which
is
like
a
blueprint
for
activities
in
the
system,
and
they
are
most
of
these
activities.
They
are
described
from
classes
that
Implement
our
activity
and
and
they
are
using
using
reflection-
they
are
being
reflected
upon
in
into
activity
descriptors
and
and
so
that's
just
one
source.
So
it
doesn't
matter
from
where
your
activity,
the
script,
has
come
from
it's
this
type,
that's
used
also
by
the
designer
to
to
display.
A
So
here
we
are
updating
the
description
for
the
activity
descriptor
and
we
can
even,
of
course,
change
the
descriptions
for
its
input.
So
here
there's
a
bit
of
logic
that
finds
the
input
fields
of
type
of
name
with
the
name
Crone
expression.
So
that's
that's
this
field
here
and
then
we're
setting
the
description
to
something
specific
for
quartz.
A
B
That
I
just
created
a
new
editor
yeah
an
Elsa
tool,
so
there
was
that
I
I
just
looked
at
how
you
created
it
was
the
drop
down
the
checkbox.
These
kinds
of
editors,
I
just
created
a
chrome
editor
and
then
I
just
plugged
the
library
there.
So
whenever
the
change
happens,
it
will
render
the
text
description.
Yeah.
A
It
makes
sense,
because
it's
separate
input
editor
for
Crown,
also
gives
us
the
option
to
make
the
UI
better
to
to
do
something
like
like
what
we
have
here.
Chrome
editor,
something
like
this.
Of
course,
this
might
be
a
little
bit
too
advanced.
Maybe
but
probably
we
can
use
some
standard
JavaScript.
B
B
A
A
Yeah
exactly
I
think
in
Elsa
treat
right
now
as
well.
So
this
is
a
supported
expression
for
quartz,
but
maybe
not
use
it
when
using
Coronas
depending
on
how
it's
configured
so
something
to
be
aware
of,
and
maybe
to
make
a
little
bit
more
configurable,
also
from
the
application
developer's
point
of
view
where
they,
maybe
they
have
strong
preferences,
whether
they
want
to
support
seconds
or
not
and
maybe
to
support
years
or
not.
But
for
now
it's
just
an
initial
implementation,
all
right!
So,
let's
see,
if
there's
something
cool
that
I
can
show.
A
Let
me
switch
back
to
just
this
one
and
by
this
one
this
is
just
just
a
reference
or
a
server
application.
It
doesn't
use
Hang,
Fire
or
quartz.net,
which,
which
also
shows
that
you
can
still
use
timers
and
background
jobs.
So
there's
there
are
default
implementations,
but
they
are
not
suitable
for
multi-nodes
clusters,
because
it's
all
in
memory
and
all
local.
So
you
do
want
to
use
quartz
and
or
Hang
Fire
when
you
start
hosting
in
in
a
cluster
just
as
I.
A
Don't
all
right
so
just
to
show
the
time
racer
so
I'm
going
to
invoke
this
forward
flow
manually
and
then
it's
going
to
start
it's
going
to
wait.
Five
seconds
write
this
text
five
seconds
pass
and
then
join
join
into
a
single
Brands
here
and
let's
add
one
test
and
oh
yeah
I
forgot
to
mention
so
notice,
the
the
nice
notifications.
A
So
that's
that's
been
in
fixed,
so
it
was
partially
implemented
at
some
point
and
also
notice
that
if
you
can
see
briefly
that
it
animates
a
little
bit,
but
it's
it's
plug,
the
publishing
happens
so
fast.
So
it's
really
we're
really
quickly
updated.
So
you
don't
really
see
it,
but
this
is
a
good
Improvement
all
right.
A
So
let's
do
this
and
I'm
gonna
run
it
in
Postman
and
let's
keep
an
eye
out
on
the
application,
console
of
course
wait
five
seconds
and
then
it
ended
and
then
after
five
seconds
we
we
either
see
that
it
did
another
attempt
to
run
the
workflow
or
probably
my
default.
Implementation
does
the
right
thing
and
it
cancels
the
10
second
timer.
So
we
we
don't
even
see
it
well.
We
would
use
Hang
Fire,
we
do
see
an
attempt
for
by
Hank
fire
to
actually
run
the
workflow,
but
I
will
fix
that
yeah.
A
A
And
we'll
use
it
as
a
as
a
as
a
trigger
okay,
I'll
just
try
one
I'm,
really
bad
at
cron
expressions.
So
let's
try
five
seconds,
see
what
it
says
and,
of
course,
let's
do
something
useful,
like
writing
the
the
time
steps
so
from
events,
that's
new
date.
Let's
not
forget
this
to
be
turned
into
a
trigger
like
this.
A
Now
as
soon
as
I
publish
the
background.
Okay,
so
there's
an
issue
with
parsing,
unexpected
character.
I
have
a
better
idea:
I'll
import,
a
workflow
that
I
know
actually
works
there.
You
go
that's
this
one
instead
and
we'll
delete
this
one
and
publish
this
one,
and
this
will
write
Hank
fire
Crown
event.
Well,
it's
not
Hang
Fire.
We
aren't
it's
using
it
for,
but
that
doesn't
matter
so
at
least
it
works.
So
every
five
seconds
we'll
see
this
workflow
execute
this
is
cool.
A
So
this
is
a
very
easy
way
to
schedule
tasks
and
in
these
tasks
they
don't
have
to
be
short-lived,
like
here,
just
writing
a
console
statement
that
that's
not
very
helpful.
Maybe
you
do
want.
You
want
to
kick
off
some
work,
which
could
be
done
using
Hang,
Fire
or
maybe
invoke
API
calls
like
here.
We
have
an
asp
request
and
that's
actually
the
focus
of
this
one.
The
background
activity
canceller,
which
I
want
to
show.
So
imagine
you
have
a
task
or
a
job,
a
recurring
job.
A
So
here
we
start
with
the
right
line,
but
you
can
of
course
start
it
with
a
crown
like
here
or
connected
to
this
one
here.
So
this
will
start
so
now,
every
five
seconds.
This
workflow
is
gonna
fire
and
then
it's
gonna
do
two
things.
It's
gonna
wait
for
five
seconds
here.
Let's
update
the
display
text
wait
five
seconds.
A
Then
it's
gonna
continue
into
this
join
and
this
one
is
going
to
fire
a
very
slow
request
and
it's
gonna
make
a
call
to
a
local
API,
endpoint
called
slow
and
internally,
it's
going
to
do
a
task
that
delay
for
10
seconds.
So
that
means
that
this
will
never
finish
right
this,
because
five
seconds
will
execute
first,
it
will
go
into
the
flow
join
and
this
will
clear
the
bookmark
created
by
the
background
activity
scheduler.
So
the
nice
thing
about
this
eight-speed
request
is
it's
internally.
A
It
doesn't
know
that
it's
executing
it
in
from
a
background
thread
or
a
background
job,
but
that's
handled
by
the
Elsa
workflow
middleware
pipeline.
So
there's
a
middleware
component
that
will
see
that
this
is
checked.
So
it's
it's
configured
to
execute
asynchronously,
so
what
it
will
do,
instead
of
scheduling
the
activity
for
execution
in
the
foreground,
if
you
will
it's
gonna,
create
a
bookmark
and
then
create
a
or
qh
you
up
on
the
on
some
queue
in
the
background
and
then
in
the
background,
it
will
pick
up
that
job.
A
It
will
execute
this
activity
in
isolation
and
then,
after
that's
done,
it
will
then
resume
the
suspended
workflow
and-
and
that's
very
neat,
because
you
can
enable
this.
This
ability
this
task
ability
to
any
custom
activity
without
having
to
do
any
coding
for
that,
and
just
to
remind
you
how
that
works.
A
If
we
go
to
PHP
request
activity
here,
so
this
is
the
class
of
the
activity
and
it's
annotated
with
an
activity
attribute
which
allows
you
to
provide
all
sorts
of
metadata
like
description
and
namespace
Etc,
but
also
a
kind
and
the
kind
is
what
controls
the
behavior.
So
if
it's
set
to
task
by
default,
it
will
execute
like,
if,
like
it
would
be,
just
an
action
which
means
it
will
just
execute
synchronously
or
in
the
foreground.
A
But
if
you
set
it
to
task,
it
will
still
do
that
unless
the
user
checks
this
checkbox
so
setting
it
to
task
will
make
this
UI
visible
to
the
user.
If
you
set
it
to
job,
you
will
not
see
this
UI,
but
it
will
always
execute
in
the
background.
So
that's
something
you
might
find
useful
as
well
trigger
I,
don't
think
it's
currently
implemented
an
action
is
the
default
so
anyway.
A
So
the
send
HP
request
activity
invokes
the
request,
but
it
also
includes
the
the
cancellation
token
and
that
cancellation
token
is
being
canceled,
so
that
will
cause
this
error
on
your
endpoint
and
then
we
see
timeout
completed,
and
so
that
is
this
right
line,
timeout
completed
and
and
ends
that's
this
one
and
because
it
went
through
this
flow
join
it
cancels
this
request
so
yeah.
That's
that's
a
quick
update
on
the
on
the
also
progress
so
far.
A
Yeah-
and
this
is
yeah-
that's
correct
and
that,
but
it
also
depends
on
your
scheduler
implementation.
So,
for
example,
let's
take
a
look
at
the
default
one,
so
the
default
one
lives
in
the
runtime
module
and
then
we
have
the
default
backgrounds.
No,
not
this
one,
the
local
background
activity
scheduler.
So
this
implements
a
thing
called
I
background
activity
scheduler.
This
is
what
is
used
for
running
activities
in
the
background
and
the
default
implementation
uses
channels.
So
it's
abstracted
in
an
IG
op
queue,
but
internally
it's
just.
A
It
just
creates
a
a
channel
here
here
we
have
a
job
channel,
so
I'm
sorry,
look
I'm!
Looking
at
the
wrong
class.
It's
this
one!
This
job
Channel
creates
a
unbounded
channel
to
which
these
details
this
dto
and
queue
job,
which
contains
some
information
about
the
job.
Buddy
the
action
to
perform
a
cancellation
token
Source
callback
when
the
job
completed.
So
it's
like
a
poor
man's
Hang
Fire
implementation,
just
in
memory.
A
So
this
so
when
this
implementation
is
requested
to
cancel
the
job
in
it
will
trigger
the
cancellation
token
that
is
passed
into
the
job
but
Hang
Fire.
As
once
the
the
background
job
is
executing,
you
cannot
cancel
it,
it's
it
it.
You
will
have
to
do
it
yourself.
It's
my
understanding
by
invoking
or
making
sure
that
you
provide
a
cancellation
token
that
you
control
through
cancellation,
token
source,
so
that
you
can
request
a
cancellation
which
is
not
implemented
here.
So
if,
once
it
started
running,
it
will
run
until
it's.
A
It's
finished,
there's
no
canceling
and
that's
I,
don't
think
it's
necessary.
The
point
here
for
canceling
activities
is,
let's
say
they
are
scheduled
for
Execution,
and
you
want
to
cancel
that
schedule
that
scheduling
so
there's
two
two
things
that
you
could
cancel
right.
So
that's
the
the
plan
to
to
execute
it.
So
you
want
to
cancel
that.
That's
like
a
timer
schedule
and
if,
but
if
the
job
is
running,
maybe
you
want
to
cancel
it.
A
B
Think,
generally,
it's
okay!
Unless
the
activity
has
some
side
effects
like
it's
updating
some
variables
or
writing
some
files
updating
database,
then
only
it
becomes
a
concern
what
the
cancellation
means.
So
it
depends
on
the
activity
if
it's
just
sending
a
request
waiting
for
response
and
this
request
doesn't
have
any
side
effects.
This
is
just
fine.
We
can
wait.
It's.
A
A
So
there
will
be
some
default
stuff
happening
like
clearing
bookmarks,
and
in
this
case
this
is
a
this
is
executed
in
the
background,
so
the
HD
HP
descent,
HP
activity
they
sent
HP
request
activity
could
be
implemented
to
also
handle
this
cancellation
event.
If
you
will
in
this
case
it
wouldn't
do
anything
special.
But
if
you
have
a
custom
activity,
then
you
can
do
some
cleanup
if
you
want,
and
also
maybe
depending
on
the
source
or
who,
what
what
the
reason
the
job
was
canceled.
A
Maybe
if
the
reason
is
because
of
a
joint
construct
Maybe,
you
want
the
cancellation
to
have
to
do
something
else.
I,
don't
know
we
need
to
think
about
those
scenarios,
but
in
general
I
think
you're
right.
It
would
be
good.
It
will
be
up
to
the
activity
to
determine
what
what
cleanup
to
do.
If,
if
any
yeah,
so
let's
take
a
look
at
the
task
list,
if
I
manage
to
find
my
tabs,
so
so
there's
always
a
battle
with
this
floating
tool
window
from
teams
when
I
share
screens
all
right
now
it
looks
good.
A
So,
let's
see
we
have
a
bunch
of
items
that
durkan
is
working
on:
let's
go
over
them
quickly,
bro
competition
and
definition
instance
browsers.
So
if
we
look
at
an
example
here,
let's
say
we
want
to:
let's
say
we
have
many
records.
Oh
this
UI
is
a
little
bit
broken
on
a
small
screen.
It
seems
let
me
go
back
to
work
for
definitions,
so
here
we
have
a
pager
right
now.
We
just
have
three
word
for
definitions,
but
let's
say
we
have
10
and
the
page
size
is
five.
Then
the
vaccination
just
doesn't
work.
A
I
mean
the
the
current
page.
Selection
does
change,
but
the
list
of
items
being
displayed
stays
the
same.
So
that's
that
needs
to
be
fixed.
We
want
an
API
endpoint
to
return
the
package
version
so
that
we
can
show
it
in
the
UI
like
what
we
have
in
Alpha
2,
which
currently
is
broken.
As
you
mentioned
in
Elsa
too,
but
we
need
to
fix
that
or
broken
or
is
out
of
date.
We
need
to
see
what's
going
on
there,
but
we
want
the
same
approaches
for
also
three
filters
in
the
word.
A
For
definition,
browser
and
instance,
browser
should
be
persistent
because
right
now,
if
you
make
a
selection,
for
example
on
your
page
size,
close
the
window
and
then
go
back,
it's
reset
so
might
be
more
convenient
for
this
to
be
maintained
same
floor,
maybe
because
for
the
this
sort
of
sorting
settings
and
filters
all
right.
So
this
this
is
going
to
be
very
important
when
you
work
with
composite
activities
created
in
the
designer
and
I.
A
A
So
now,
when
we
create
a
new
workflow,
we
can
use
it
right
like
this,
but
at
at
this
moment,
when
we
add
it
to
the
to
the
cat
to
the
designer
it
is
set
to
version
one
which
is
the
is
the
the
only
version
at
this
moment
and
I
I've
got
to
publish
it,
but
let's
say
I
publish
it
to
version
one
and
now
let's
say
we've
identified
a
missing
feature
or
maybe
there's
an
issue,
or
we
just
want
to
make
a
change.
Then
we
make
that
change.
A
Let's
say
we
add
some
activity
like
this
and
then
when
I
do
publish.
So
now
we
are
at
version
2.,
but
when
we
go
back
to
the
work
workflow
here
that
uses
it,
this
is
the
consuming
workflow.
It's
still
pointing
at
version
one,
but
we
have
version
two.
So
we
can
manually
upgrade
if
we
want
to
same
goes
for
this
one-
and
this
is
done
on
purpose,
because
it's
technically
possible
to
have
these
activities
always
use
the
latest
published
version.
A
A
So
to
fix
that
we
want
to
do
it
like
this,
so
we
want
to.
We
want
to
do
it
in
two
iterations,
so
the
first
iteration
would
be
a
very
simple
approach
where
we
just
add
a
checkbox
to
the
settings.
Tab
and
we'll
call
it
auto
update
consuming
workflow.
So
that
would
look
something
like
if
we
go
back
to
the
sum
activity
here
and
we
go
to
settings.
So
the
idea
is
that
we
just
add
a
checkbox
here
that
you
can
check
and
if
it's
checked
anytime
you
hit,
publish
all
of
the
consuming
workflows.
A
Will
be
updated
automatically,
so
this
is
the
quote:
dangerous
behavior
that
we
could
have
implemented
by
default,
but
we
don't
want
to.
But
if
you
think
you
know
what
you're
doing
you
should
be
able
to
make
it
easy
for
yourself
and
just
update
the
sub,
the
consuming
workflows
potentially
breaking
them.
But
you
know
that's
a
conscious
decision
you
can
make.
A
A
A
So
let's
say
let's
say
this
one
here
we
have
a
draft
latest
version
is
one
but
it's
not
published,
and
then
we
could
have
Block
action
where
we
say
publish
well,
we
already
have
a
bulk
actually
called
publisher.
You
could
still
do
it
so
then,
but
there
will
be
two
steps
so
but
yeah.
It
might
be
a
good
idea
to
have
this
option
enabled
as
well
on
the
composite
activity
here.
So
we
would
have
a
checkbox
automatically
update
and
then
also
the
checkbox
automatically
publish
those
updated,
consuming,
workflows.
B
Because
if
you
want
to
review
the
history
later
on,
it
should
not
be
the
case
that
the
same
version
of
the
workflow
has
two
definitions:
that
it
will
be
confusing.
So
definitely
the
version
has
to
be
incremented,
but
the
question
is
whether
to
publish
immediately
or
take
a
decision.
That
is
something
maybe
the
user
has
designed.
A
Exactly
yeah
exactly
all
right,
somewhat
related
handling
deletion
of
versions
of
composite
activities.
So
imagine
you
have
the
sum
composite
activity.
So
it's
like
your
reusable
activity
here
and
it
has
its
own
version
and
let's
say
you
have
many
versions,
and
you
want
to
do
some
some
cleanup,
but
now,
let's
say
I
I
I'm
gonna
delete
version
three,
but
if
it's
referenced
by
consuming
workflow
that
will
break
that
workflow.
So
we
should
either
just
prevent
it.
A
Maybe
when
you
try
to
delete
it
should
display
a
message
that
you
know:
there's
this
number
of
consuming
workflows,
so
first
remove
the
activity
from
there
or
maybe
it
will
allow
you
to
remove
it
from
the
activities
or
just
go
ahead,
because
then
it
will
create
a
draft.
Then
it
will
not
be
published
and
then
you
can
fix
it
up
manually.
A
A
A
Yeah
good
point
yeah,
so
we
also
want
to
be
able
to
see
the
workflow
variables
and
their
values
in
the
workflow
instasphere
right
now.
It's
just
then
empty
lists.
Fortunately,
I
can't
show
the
browser,
because
my
window
is
too
small.
Oh
there
you
go
so
let's
say
I
open
this
one,
so
we're
now
looking
at
the
workflow
instance.
So
we
have
the
journal
here.
A
Oh
and
then
here
we
have
variables,
but
it's
completely
empty
yeah,
although
well,
this
workflow
definition
doesn't
even
even
have
variables,
but
if
it
had
variables
we
wouldn't
see
it
here.
So
we
need
to
fix
that.
We
want
to
see
the
name,
the
type
where
it's
stored
is
it
stored
in
the
workflow
instance
itself,
or
maybe
on
blob
storage
and
the
value.
B
A
B
A
B
B
A
A
Yep,
nice,
all
right,
so
that's
this
one
being
able
to
navigate
between
workflow
definitions
using
composite
activities.
So
what
I
want
for
the
dashboard
application?
So
this
is
not
the
dashboard.
This
is
just
the
designer,
so
I'm
not
I'm
not
going
to
update
it
for
this
component,
because
we
wanted
to
redo
it
in
Blazer
and
the
designer
plus
the
dashboard.
We
want
to
redo
it
where
we
will
also
have
a
tabbed
view
so
like
in
writer
or
in
Visual
Studio.
We
have
dabs,
can
I
remove
this.
A
A
A
And
now,
let's
say:
I
want
to
change
the
implementation
of
this
sum
activity.
Now.
What
I
have
to
do
right
now
is
I.
Go
to
the
board
for
definitions,
model
click
sum
you
can
make
a
change
now,
like
I,
don't
know,
maybe
add
some
activity
make
a
publish
and
then
I
need
to
go
back
to
the
consuming
workflow
right.
So
it's
a
little
bit
of
a
hassle.
What
would
be
nice
if
we
can
just
go
directly
to
this
thing,
maybe
by
double
clicking
and
then
double
clicking
will
open
the
word
for
definition,
editor.
A
Then
the
question
is:
how
do
you
get
back
to
this
workflow?
The
idea
here
is
that
we
will
just
add
breadcrumbs
so,
for
example,
what
we
have
here
with
this
activity,
which
has
a
embedded
ports
if
we
click
into
this
one,
yeah
notice
that
we
have
a
breadcrumbs
so
similarly,
we
would
also
show
breadcrumbs
so
we
can
quickly
go
up
one
level.
A
A
These
were
just
nice
to
halves
as
part
of
the
RC,
but
it's
not
going
to
be
blocking
and
then
speaking
of
the
release
candidates,
we
are
planning
on
end
of
May
begin
afternoon,
but
we
try
to
do
it
before
the
end
of
May.
So
just
because,
right
now
it's
in
a
in
a
very
stable
State.
There
are
still
some
some
improvements.
Some
new
features
being
added
some
some
missing
functionality
that
you
know.
We
realized
that
we
still
need
to
add
like
the
ability
to
modify
activity,
descriptors,
canceling
activities.
A
You
know
that
is
pretty
important,
so
it
might
happen
that
we
come
across
into
those
kind
of
missing
features,
but
other
than
that
it
seems
very
a
more
and
more
conflict
so
and
and
useful.
So
we
don't
want
to
wait
too
long
for
for
the
RC
release
yeah,
so
on
publish
button
doesn't
work.
Currently,
that's,
of
course,
very
simple
to
do
but
low
hanging
fruit,
but
it
needs
to
be
done
right
now.
It
does
nothing.
So
we
need
to
fix
that
and
that
this
one
by
the
way
is
important
for
release
candidates.
A
A
It
has
to
do
with
with
the
what
was
it
with
with
the
there's
this
there's
the
CSS
attribute
to
control
the
Overflow,
whether
it's
hidden
or
not,
and
it
you
can
set
it
for
vertical
and
horizontal,
but
right
now
the
this.
This
fills
up
the
entire
vertical
space,
which
is
what
what
you
want,
but,
but
when
you,
when
you
do
when
you
set
it
up
like
that
or
the
way
I
set
it
up
book,
will
then
clip
these
these.
These
two
tips.
A
If
I
don't
auto,
fill
this
this
vertically,
then
it
the
overlay
is
okay,
then
the
tooltip
will
flow
over.
But
then,
of
course,
if
you
have
just
a
few
items
here,
then
here
this
this
this
panel
will
just
stop
here,
something
along
those
lines.
It's
I
didn't
want
to
bother.
I
figured,
let's
ask
a
front-end
developer
to
see
if
they
can
restructure
the
HTML.
Probably
that's
what's
necessary.
B
Sometimes
it
can
be
fixed
by
moving
the
tooltip
component
itself
outside
of
the
component.
Just
make
it
part
of
the
body,
then
it
will
not
be
affected
with
the
overtake
I'm,
not
sure
which
plugin
you
are
using,
but
it
could
help
to
move
the
tooltip
object
itself,
the
component
outside
of
the
panel
and
keep
it
part
of
the
main
body.
A
He
maintaining
this
because
the
implementation
right
I
was
very
simple:
there's
no
plugin
use
it's
just
Tailwind
CSS
and
that's
it
so
so
I
prefer
to
keep
it
that
way.
But
if
that
turns
out
to
be
impossible,
then
we
should
do
what
you
suggested
and
move
these.
These
two
tip
elements
out
outside
of
this
component
at
least,
but
then
we
need
to
figure
out.
B
B
Yeah,
of
course,
and
one
thing
I
noticed
that
and
if
you
search
in
Google
for
the
documentation,
you
might
reach
the
old
documentation
instead
of
the
new
documentation
that
you
created
so
I,
don't
know.
Maybe
it
depends
on
the
user,
but
yeah
GitHub
Pages
comes
first.
So
probably
you
can
redirect
or
take
this
down
or
something
so
that,
because
some
users
still
refer
to
this
rather
than
the
new
documentation.