►
From YouTube: Elsa Workflows Community Meeting 30
Description
Topics:
A
A
A
A
And
it's
because
also
I
have
some
technical
depth.
I
have
to
rewrite
some.
Some
element:
transform
all
my
code
to
dotnet
core
to
be
sure
that
I
can
scale
on
the
the
on
the
rks
cluster,
because
I
have
a
lot
of
container
in
a
Windows
container
and
Windows
computer
are
just
hell
because,
just
as
startups
the
the
they
use
a
lot
of
memory
and
CPU
so
yeah,
we
have
to
move
everything,
but
it
takes.
It
takes
time.
Yeah.
B
B
So
that's
a
new
function,
functionality
of
the
identity,
module
which
in
itself
has
seen
a
few
new
enhancements,
allowing
you
to
Define
users
through
app
settings
or
from
a
store,
and
the
same
goes
for
rules,
and
it
allows
you
to
create
applications
which
are
the
same
similar
to
users,
but
instead
of
using
a
username
password,
they
it
allows
you
to
store
a
client,
ID
and
secret
plus
an
API
key
that
you
then
can
use
from
from
your
own
application
to
invoke
else.
Api,
endpoints,
so
I
thought
might
be
cool
to
go
through
that.
A
B
A
small
update
stability
improvements
for
else
overall,
so
the
past
two
weeks,
I've
been
trying
to
get
a
workflow
for
a
customer,
fully
functioning
in
Elsa
3
and
it's
a
very,
very
complicated
workflow,
with
lots
of
Eventing
and
web
hooks.
So
it's
it's
a
very
interesting
use
case
because
it
touches
so
many
points
of
the
framework.
B
So
there's
a
lot
of
scenarios
that
I
get
to
try
out
and
as
you
go
through
these
scenarios,
you
run
into
all
sorts
of
things
that
have
been
missed
or
that
didn't
work
out
so
well,
so
it's
been
very
good
exercise
to
to
I,
identify
those
issues
and
then
fix
them.
So
at
this
point
it's
in
a
pretty
good
State
I
was
able
to
run
the
entire
workflow
from
start
to
end,
which
also
includes
composite
workflows
and
sub
workflows.
So
so
it's
a
good
use
case.
B
There's
one
issue
that
I
identified
today
and
since
we're
looking
at
it,
let's
let
me
show
you
and
that's
the
following.
So
maybe
you
remember
at
some
point:
we
were
testing
the
the
implicit
joints
yeah.
So
this
this
works
nicely,
but
there's
another
kind
of
construct
that
doesn't
work
nice
at
all,
or
it
has
an
issue,
and
let
me
let
me
share,
let
me
start
the
server
first
all
right,
so
let
me
open
that
workflow
again
all
right.
So
what
we
should
expect
to
see
here
is,
of
course,
right
line,
one
prints.
First,
then,.
A
B
One
this
one
this
one,
this
one,
this
one
and
then
this
one
like
this
well
not
like
this.
This
is
here
because
my
debugger
or
my
build
uses
an
older
build.
Let
me
try
again
yeah.
Oh
yeah,
you
see
at
the
bottom
The
Source
blah
blah
blah
may
have
changed,
so
it
didn't
build
correctly.
So
let
me
build
again
all
right
second
to
go
right,
so
this
is
okay,
one
four
Etc,
so
this
works.
But
let
me
show
you
the
issue:
if
we
go
to
another
workflow
here,
so
this
is
a
little
bit
different.
A
B
The
issue
here
is
that
when
this
starts
so
it
goes
like
this,
so
it
goes
through
the
increment
counter,
which
is
a
simple
set
variable
which
will
increment
a
variable
called
counter
by
one,
and
this
is
a
flow
decision.
So
it's
like
an
if
else,
and
initially
it
will
evaluate
two
files
because
counter
is
not
created
in
one.
It
will
be
one
so
not
greater
than
so.
It
goes
through
false.
Then
it's
going
to
print
retry,
which
is
connecting
to
do
something
which
is
just
the
right
line
and
then
increment
the
counter
again.
B
This
time
the
counter
is
two,
so
that's
greater
than
one.
So
it
evaluates
true
and
then
this
one
gets
executed.
However,
this
all
these
activities-
they
are
part
of
this
of
this
flowchart
that
we
don't
see,
but
it's
the
root
activities
of
this
workflow,
so
these
execute
within
a
flowchart,
but
this
flow
chart
now
in
this
construct
never
completes,
and
that
has
to
do
with
the
the
logic
of
counting
which
one
have
executed
to
implement
the
implicit
join,
and
what
happens
is
that
the
using
the
current
implementation
is
that
this
execution
counter
is
one.
B
A
B
A
B
And
so
my
initial
attempt
was
where
I
thought
well,
if
we
notice
that
we
are
at
a
a
joint
like
activity.
So
if,
if
it's
you
know
it
may
not
be
it
your
embody
as
soon
as
it
has
more
than
one
inbound
paths,
then
we
consider
it
to
join,
but
if
it's
not
a
joint
well,
this
is
considered
the
implicit
joint
and
maybe
I
figured
let's
just
clear
the
scope
and
if
I
do
that,
then
I'm
going
to
execute
this
workflow
okay.
This
is
something
very
tricky.
A
B
B
B
It's
probably
Rider
all
right,
so
here
I
executed
this
workflow
and
the
issue
was:
if
we
look
at
the
so
it
executes
Chrome
correctly.
That
wasn't
the
issue,
but
the
issue
is
that
it
wouldn't
finish
the
workflow,
but
with
this
change
it
finishes
the
workflow,
but
because
of
that
change,
if
I
now
go
to
the
other
workflow
in
the
workflow
to
execute
this
one
no
result
will
happen.
It's
just
writes
line
one
and
line
four,
and
then
it
stops
and.
A
B
Makes
sense
given
this
this
chain,
so
it
it
needs
some
more
tinkering
to
get
right
for
both
scenarios.
But
that's
the
thing
I'm
currently
facing
lots
of
other
fixes
have
gone
in
so
pretty
cool.
One
of
the
UI
developers
made
a
little
change
here
notice.
The
notifications,
it's
it's
a
little
bit
fast,
so
it's
hard
to
see,
but
when
it
publish
it
briefly,
shows
a
spinner
and
then
updates
notification
and
all
those
notifications
can
be
seen
here,
which
is
pretty
cool.
A
I
think
that
there
is
a
good,
very
good
hook
on
the
privilege
event
when
I
work
on
the
angular
wrapper.
I
fix
it
to
to
to
attach
to
the
to
the
event
and
the
event
is
developed
with
a
two
hook,
start
privilege
and
privileged,
and
so
we
can
in
in
other
and
create
a
different
interaction
during
the
publish.
B
Let's
see
I
think
at
the
time
the
workflow
execution
context
starts
or
not,
activity
execution,
but
workflow
context
execution.
Let's
see
here,
I
think
when
this
one
is
constructed,
we
already
get
a
graph
call
from
the
factory,
so
I
think
yeah.
So
whatever
you
construct
a
word
for
execution
context
using
the
workflow
execution
context
Factory,
it
builds
a
graph
based
on
your
root
activity,
which
is
typically
the
workflow
okay
and
then
it's
yeah.
It
goes
into
all
of
the
activity
properties
of
your
activity.
A
B
Actually
that
that
logic
lives
entirely
in
flowchart,
so
the
workflow
engine
doesn't
know
about
any
of
this.
It's
it's
completely
scoped
to
the
float
chart
and
the
way
it
works.
It
internally
stores
a
flow
scope
instance,
which
is
also
specific
to
flowchart,
so
it
stores
it
as
part
of
the
its
own
activity
execution
context.
So
it's
it's
very
locally
scoped,
which
is
good
because
it
means
it's
isolated
and
it
also
is
a
good
example
of
different
kinds
of
diagrams
that
you
may
Implement,
like
bpmn,
for
example,
would
be
completely
different.
B
It
would
just
be
an
activity,
but
all
of
the
BPM
and
stuff
will
be
isolated
to
its
own
activity.
Okay,
yeah
yeah
and
here
I'm,
just
storing
in
the
flow
scope,
I'm,
storing
a
dictionary
of
activities
keyed
by
the
owner
activity,
which
I
think
is
just
the
flowchart
and
then
some
state
which
includes
the
just
an
execution
count
and
then
I'm
doing
some
some
operations
to
determine.
B
If
we,
if
the
implied
joining
activity,
should
continue
or
should
be
scheduled
or
nothing
at
all,
lives
lives
here:
okay,
yeah,
all
right,
let's
see
what
we
have
here.
So
that's
a
quick
notes
and
stability
improvements,
so
we
haven't
actually
looked
at
the
ones,
but
there
so
detailed
I,
don't
think
it's
worth
going
through
them
other
than
the
one
that
I
was
looking
at
right
now:
API
key
authentication.
So,
let's
yeah,
let
me
show
you
that
all
right,
let's
see
how
to
start,
maybe
just
let's
consider
one
of
the
API
endpoints.
B
Let's
say
we
want
to
execute
some
some
work
for
definition.
So,
let's
see
what
we
have
say,
we
have
workflow
one.
This
is
just
an
HP
response
and
it
writes
test,
that's
good.
So
let's
take
this
definition,
ID
and
then
use
so
we
put
it
in
here
and
then
we
can
execute,
but
we
need
authorization
and
right
now
it's
set
to
API
key,
but
before
this
change,
what
you
have
to
do
is
set
it
to
Bearer
token
and
get
an
access
token.
B
So
here
with
this
setup,
it
will
use
that
token
and
we
get
indeed
a
successful
execution.
But
of
course,
maybe
if
you
are
building
your
own
applications
that
integrate
with
Elsa
server
through
rest
apis,
it
would
be
inconvenient
to
have
I
mean
it's
possible,
but
it
would
be
inconvenient
to
have
to
first
use
this
login
API,
where
you
need
to
provide
the
username
and
password.
So
you
would
have
to
create
a
user
for
your
application
and
also
take
into
account
that
the
access
token
will
expire
at
some
point.
B
Depending
on
how
you
configured
the
token
issuance.
It
could,
of
course,
generate
tokens
that
are
that
expire
hundreds
of
years
from
now,
but
it
doesn't
feel
as
good
as
as
just
having
a
API
key
that
you
can
can
use
right.
So
it's
just
different
approach
and
I
think
makes
more
sense
for
application.
Application
also
depends
on
your
tolerance
for
risk
because
having
an
API
key
that
never
expires
automatically
could
pose
a
risk.
B
But
then
again,
if
you
know
that
your
API
key
is
leaked,
you
can
always
revoke
your
API
key
centrally,
so
so
yeah
to
that
end,
I
created
support
for
API
keys,
and
that
way,
the
way
that
works
you
need
to.
Instead
of
creating
a
user
or
in
addition
to
creating
user,
you
just
create
an
application.
So
here
we
could
create
an
application
called
Postman
to
represent
this
client
with
a
set
of
rows,
and
each
row
is
associated
with
permissions
and
the
admin
role
that
I
created
somewhere
I,
don't
see.
A
B
Don't
see
an
API
endpoint
here,
but
in
any
case
the
system
has
a
role
called
admin
and
it
has
the
asterisk
permission,
which
means
it
has
all
the
permissions
of
the
entire
system.
So
it's
a
very
powerful
user,
so
you
can
create
one
and
what
it
will
create
is,
of
course,
a
primary
key,
the
name
and
the
rules.
It
creates
a
client,
ID
and
secrets
which
you
could
use
similar
to
logging
in
with
a
user
name
and
password.
B
You
can
then
also
use
this
to
log
in
if,
if
you
prefer
this
kind
of
authentication-
and
this
will,
if
you
do-
that,
you
will
get
an
access
token,
but
probably
you'll
just
want
to
store
this
one
encrypt
it
or
yeah,
probably
at
least
encrypt
or
in
a
location-
that's
not
stored
in
clear
text
in
your
source
code,
for
you
would
that
you
wouldn't
want
that
maybe
stored
in
a
Hast
fashion.
That's
really
that
doesn't
work.
You
have
to
encrypt
it
or
store
it
securely,
like
in
a
kubernetes
secret,
for
example.
B
Internally,
the
application
stores
the
Hast
version,
so
so
Elsa
doesn't
store
this.
It
just
sends
it
now
because
it
created
it,
but
it's
not
stored
anywhere,
it's
just
for
you
to
to
grab
and
it
will
never
be
shown
anywhere
again.
It's
not
recoverable.
Okay,
but
yeah.
So
here
I
think
I've
copied
this
one
into
an
API
key
environment
variable.
So
now
we
can
execute.
Instead
of
using
pair
tokens,
we
can
use
Now
API
keys.
B
What
I
did
I
installed?
Let's
see,
I
I
installed
a
configuration
based
user
provider,
application
provider
and
role
provider,
and
what
that
means
is
that
it's
reading
it
from
configuration
so,
for
example,
app
settings
or
your
environment
variables
or
whatever
configuration
sources
you
have
installed.
It
will
consider
those
sources
in
this
case
I
use
app
settings
here.
So
here,
I've
hard-coded,
my
admin
row.
A
B
This
permission
right
and
then
an
admin
user
and
and
just
this,
this
application-
I,
don't
know
what
the
API
key
is.
So
I
will
have
to
update
these
settings
with
what
I
just
generated.
Yes,
so
let
me
just
copy
this
over
and,
of
course,
I
will
remove
this,
because
this
is
not
this
shouldn't
be
stored
and
it's
it
won't
be
stored.
If
you
use
the
persistence
provider,
of
course,
you
can
still
or
whatever
you
want
in
app
settings,
not
recommended.
B
B
Okay,
right
and
now,
when
I
run
this
one,
it
works
using
API
Keys,
which
won't
expire
until
you
remove
it,
and
this
is
an
interesting
part,
because
the
API
key
or
when
you
use
an
access
token,
all
of
your
permissions
or
roles
at
least
are
actually
permissions
there
encoded
and
stored
in
your
access
token,
so
the
server
doesn't
have
to
fetch
your.
It
doesn't
have
to
compute
your
roles
because
it's
not
associated
with
rules.
It
just
already
carries
the
permission
names,
but
when
you
use
an
API
key,
it
does
have
to
do
a
lookup.
B
A
B
B
Yeah,
if
I
change
the
API
key,
so
let's
say
let's
say:
I
try
to
Tamper
the
API
key.
Let's
let's
say
let
me
copy
this
and
I
will
do
it
like
this,
so
This
should
work.
This
is
the
correct
API
key.
But
now,
if
I
make
a
change,
let's
say:
let's
change
this
one
to
two.
Then
we
get
an
unauthorized.
Okay
and.
B
A
B
Just
for
example,
this
this
API
key
at
authorization
is,
it
actually
uses
a
third-party
Library
called
asp.net
core
authentication
API
key,
so
it
implements
its
own
authorization
Handler
and
and
and
provides
an
API
key
scheme
Etc.
We
could
do
it
ourselves,
but
I
figured
it's.
It's
all
general
purpose
be
easier
to
to
use
what
they
have,
because
it's
still
significant
amount
of
code
that
you
would
have
to
maintain.
Okay,.
A
B
So
if
you
use
HP
endpoints,
that's
a
slightly
different
story,
because
this
is
not
implemented
as
an
API
as
a
fast
endpoint
or
control,
or
anything
like
that.
This
is
done
using
middleware
yeah.
So
it
requires
a
bit
of
a
custom
code
to
actually
invoke
authentication.
But
this
to
that
too,
relies
on
by
default
on
the
asp.net
core
authorization
API.
B
Let
me
find
the
code
here
so
here
we
have
the
middleware,
so
it
relies.
It
relies
or
depends
on
ihp
endpoint
authorization
Handler.
So
that's
a
custom
interface
provided
by
Elsa
and
let's
follow
see
where
this
one
is
used.
So
here
we
have
a
private
method,
called
authorize
async.
This
will
only
be
invoked
if
authorized
was
checked.
So
if
it's
checked
it
will
call
into
this
this
service.
But
it's
like
a
like
a
strategy
pattern,
so
you
can
provide
your
own
implementation
if
you
want
to,
but
there's
a
default
implementation
out
of
the
box.
B
That
looks
like
this,
so
it's
either
allow
Anonymous
or
authentication
based
and
if
you
use
authentication
based,
it
depends
on
the
asp.net
core
eye
authorization
service.
So
that's
Microsoft,
ASP
Network
authorization
and
that
and
it
will
pass
along
your
policy
that
you
configured.
So
if
you
in
your
program
file
or
in
your
startup
file,
you
can
configure,
you
know,
do
services
that
add
authorization
and
then
you
can
add
policies,
names,
policies
and
configure
its
requirements.
A
A
B
All
right
so,
yes,
I
briefly
touched
upon.
You
have
now
the
ability
to
create
users,
roles
and
applications,
and
you
can
you
configure
it
from
like
this
using
app
settings,
but
there's
also
persistence
providers
here.
So
we
have
a
EF
core
implementation
for
all
of
these
stores.
So
we
have
an
application,
store,
roll
store
and
user
store,
but
we
don't
have
any
UI
yet
so
so
that's
that
will
will
come
so
probably
we'll
have
users
or
security,
something
like
that
here
and
then
it
will
take
you
to
a
screen
where
you
can
manage
it.
B
A
Right,
yeah,
I,
I,
I
I
am
currently
doing
the
same
thing
on
my
on
my
site
with
angular
shell
different
module,
a
UI
module
and
API
module
hosting
things
differently
and
there's
a
shared
query:
what
module
I
use
and
load
the
UI
module
if
needed,
and
the
UI
module
is
bind
to
a
specific
API,
so
everything
can
work
correctly
and
separately.
It's.
B
Interesting,
so
that
so
so
that's
just
a
different
name
for
a
modular
extensible,
UI
framework,
yeah
cool
yeah
yeah.
So
so
that
sounds
very
similar,
if
not
exactly
the
same
as
what
what
I
want
to
do
for
the
for
the
dashboard
but
then
using
Blazer
instead
of
stencil
or
react
and
I
think
the
nice
well
Placer
is
is
great
for
the
net
developers
and
I
also
want
to
do
the
the
designer
itself
this
this
entire
portion
using
blazer,
because
these
days
it's
it's.
B
It's
very
illicitly
very
strange,
straightforward
to
wrap
it
in
a
web
component
so
that
you
can
use
it
as
a
custom
element.
I
haven't
tried
it
so
we'll
see
how
how
easy
it's
going
to
be
yeah
but
yeah,
all
right!
That's
all
I
have,
for
you
know
the
show
and
tell
do
you
have
any
any
topics
you
want
to
go
over.
First.
A
No,
no
specific
topic,
just
maybe
a
one
question,
because
one
or
two
weeks
ago
we
talked
about
the
server
sample
with
the
persistence
module
and
you
told
me
that,
because
it
used
the
actor,
the
actor
module,
there
is
no
Persistence
of
the
of
the
instance
workflow,
and
so
we
have
to
add
some
some
use
workflow
and
time
to
be
sure
to
to
use
the
Persistence
of
the
workflow
instance
in
the
sqlite,
for
example,
am
I
am
I
wrong
or
not?
No.
B
A
B
The
history
yeah
exactly
yeah.
If
you
don't
install
this
feature,
then
you
will
not
have
a
history
of
the
execution
log
record
and,
and
the
same
goes
for
workflow
instances.
If
you
want
to
see
it
persisted
somewhere,
yeah
you,
you
have
to
use
a
thing
called
workflow,
State
exporter.
That's
this
one
is
an
async
implementation
that
will
grab
all
of
the
updated
workflow
states
that
happen
in
protoactor
and
then
store
it
in
a
workflow
instances
table
in
SQL
Lite,
for
example.
B
But
if
you
don't
use
this
and
you
don't
use
this
and
you
use
protoacter,
then
all
of
these
things
will
remain
in
memory.
Of
course,
as
you
already
mentioned,
it's
actor
can
can
create
snapshots,
so
so
protoactive
supports
event
driven
Concepts.
So
so,
if
you
have
events
that
you
these
messages
that
it
receives,
you
could
send
it
or
treat
them
as
events
and
then
they
can
be
stored
and
then
played
back.
So
if
then,
your
cluster
goes
down
and
you
you
can
play
back
from
this
from
the
beginning.
A
A
A
I
suppose
the
difference
will
be
about
the
clustering.
If
we
use
the
clustering
in
a
sqlite
persistence,
we
have
to
add
some
other
module.
For
example,
a
vacuum
sphere
service
boost
back
end
to
pass
as
a
different
event
control,
but
if
we
use
a
protractor,
everything
is
already
done
by
the
actual
stuff
yeah.
B
For
example,
indeed
you
you
don't
need
as
much
communication
mechanisms
like
which
you
would
have
said
with
the
default
runtime,
because
indeed
the
protractor
supports
all
different
kind
of
communication
mechanisms.
Yeah,
and
another
thing,
of
course,
is:
if
you
use
the
default
runtime,
it
will
rely
on
a
on
the
database
to
store
its
state.
So
as
an
example,
this
workflow
States
is
what
is
used
internally
by
the
default
workflow
runtime
and
it
might
at
First
Look.
It
might
seem
to
be
redundant
to
have
workflow,
States
and
workflow
instances,
but
the
workflow
instance
table
is
optional.
B
You
you
only
need
it
if
you
want
to
actually
look
at
the
instances
which
is
probably
the
case
if
you're
using
the
designer
the
designer
depends
on
this
table.
Currently
so
workflow
States,
it's
it's
intended
to
be
internal.
Only
and
it
does
this
table
doesn't
get
created.
If
you
use
protoacter
because
then
protoactor
itself,
the
the
Clusters
itself,
the
store
for
States
every
every
grain
will
be
will
be
storing
the
state.
B
For
example,
here
we
have
the
workflow
grain,
which
represents
a
workflow
in
distance
and
just
a
quick
note,
both
runtime
the
the
default
runtime
and
the
project
runtime.
They
they
try
and
share
as
much
logic
as
possible
through
workflow
hosts.
So
workflow
host
is
agnostic
in
terms
of
the
runtime
provided
that
you
use,
but
it
contains
a
bit
of
shared
logic
to
instantiate.
B
A
Yeah,
and
so
if
we
want
to
to
to
use
the
snapshot,
write
all
data
in,
for
example,
SQL
database
or
a
file
now
in
the
in
a
instance
store
we
have
to
use
the
state
exporter,
as
you
mentioned,
yeah,
and,
and
then
the
the
management
API
with
the
designer
will
allow
me
to
access
this
data
or
I
have
to
customize,
also
something
for
the
to
for
the
instant
store.
No.
B
So
that's
exactly
right!
So
if
the
the
current
implementation
of
the
state
exporter
will
write
to
workflow
instances
and
internally,
it
uses
I
workflow
instance
store
and
that's
the
same
abstraction
that's
used
by
the
management
apis,
so
so
you'll
be
able
to
achieve
that
then,
what's
nice
is
that
if
you
have
installed
elasticsearch,
as
your
workflow
instance
store
both
the
the
management
apis
and
therefore
also
the
designer
will
be
reading
it
from
elasticsearchs
and
of
course
the
state
exporter
will
be
exporting
to
elasticsearch.
Okay,.
A
Okay,
I
will
I
will
look
at
this
because
for
me,
it's
very
important
to
to
use
this
kind
of
runtime
to
to
be
sure
that
we
are
able
to
to
scale
very,
very
light
and
to
to
then
to
to
be
able
to
use
different
kind
of
pattern.
For
example,
if
we
want
to
implement
a
Singleton
pattern
for
for
one
workflow
or
a
fun
infinite
or
any.
A
B
A
B
A
B
B
B
B
So
yeah
so
yeah
coming
soon
I
also
three
and
let's
also
take
a
small
look
at
what
should
be
the
next
Focus.
Once
we
are
once
we
have
to
release
3.0
officially
on
nougat,
I'm
thinking,
mother
tenancy
would
be
a
big
one
to
tackle
and
bpmn
I
think
that's
really
gonna
put
Elsa
on
the
on
the
map,
because
once
you
have
bpmn
a
support,
many
people
who
are
familiar
with
that
they
can
use
familiar
designer
tools
to
to
you
know
to
create
those
diagrams
and
execute
them
in
in.net
applications
easily
plus
speaking
of
AI.
B
It
won't
be
long
until
they
can
also-
and
maybe
that's
already
possible
when
they
can
just
based
on
a
natural
language
inputs
and
create
bpmn
process
diagrams
right.
So
you
can
just
describe
the
process
that
you
want.
In
fact,
I
don't
know
if
you,
if
you
have
seen
a
co-pilot
from
Office
365
they
they
also
did
a
demo
with
power
tools
and
they
demoed
somebody
typing
in
some
requirements
for
a
process
and
it
created
a
power
tool.
Workflow.
It
looked
like
logic,
apps
I
think
it's
it's
the
same
underlying
engine.
B
B
Yeah
and
so
that
will
be
there,
but
creating
the
bpmn,
that's
going
to
be
easier
and
easier
and
then
the
next
step.
Of
course,
we
would
be
for
this
modular
dashboard
to
have
a
UI
in
addition
to
a
designer
or
maybe
on
inside
the
designer,
where
you
have
a
little
chat
window,
where
you
can
start
typing
in
very
similar
to
Office
365
co-pilot,
which
integrates
with
Excel
PowerPoint,
word
Outlook
all
of
their
tools,
and
so
it's
like
clippy
but
I,
don't
know
what
kind
of
steroids
those
are,
but.