►
From YouTube: Elsa Workflows Community Meeting 37
Description
In this session:
- A new API to access activity output directly
- A Dapper implementation of the persistence abstractions
- Elsa Studio progress updates
A
A
A
Right,
that's
great,
then
I
will
tell
you
all
about
what
I've
been
up
to
for
the
past
three
weeks
or
so
first
week
of
those
three
weeks,
I
Was
preparing
for
Orchard
Harvest,
which
is
a
it's
a
conference
about
the
orchard
project,
which
is
an
open
source
application
framework
and,
as
some
may
know,
also
workflows
well
originated
out
of
the
orchard
core
workflows
module.
So
it
was
a
great
opportunity
for
me
to
show
the
community
of
Orchard
the
current
state
of
Elsa,
so
I
demoed
Elsa
3,
which
was
a
lot
of
fun.
A
A
lot
of
time
went
into
preparing
this
talk
at
the
conference
for
the
conference,
including
bearing
a
little
Orchard
module
to
integrate
Elsa
with
with
Orchid
itself,
which
was
also
a
lot
of
fun,
but
it
also
exposed
some
of
the
limitations
at
a
time
to
you
know,
reuse,
the
designer,
for
example,
in
another
application.
So
as
a
result,
that's
now
a
much
better
story
and
I'm
going
to
continue
building
this.
This
Orchard
module
as
a
showcase,
but
also
as
an
actual
useful
volunteer
for
the
richest
Community
to
basically
bring
back
Elsa
workflows
into
Orchard.
A
A
Okay,
yeah
well,
not
too
much
has
changed
since
since
that
time,
since
I
was
only
able
to
resume
work
on
that
early
this
week.
So
but
there's
still
some
some
good
updates
there.
So
I'm
going
to
show
that
in
the
meantime,
I've
also
worked
on
documentation
and
as
in
order
to
explain
a
little
bit
about
the
extensibility
of
creating
or
creating
custom
persistence
providers.
I
created
the
new
persistence
provider
using
Dapper.
So
now
we
have
EF
core
that
we
can
use,
but
we
can
also
use
Dapper
and
theoretically,
that
should
be
faster
than
e.
A
Of
course,
so
I've
been
told,
but
I
haven't
done
any
measurements,
so
I
don't
know
for
sure.
But
it's
it's
it's
another
option
in
case
people
want
to
use
it
and-
and
it
serves
as
an
example
to
to
to
show
what
you
can
do
with
custom
providers
and
it's
also
now
possible
to
access
activity
outputs
directly.
A
So,
as
some
of
you
may
know,
in
elsa3,
when
you
want
to
capture
output
of
a
given
activity,
you
need
to
associate
it
with
the
workflow
variable,
and
then
you
can
use
that
variable
in
other
activities
and
the
the
reason
for
these
variables
is
to
allow
you
to
control
whether
or
not
you
want
to
persist
the
the
output
of
an
activity,
but
there's
also
many
scenarios
where
you
don't
want
to
persist
these
these
values.
You
just
want
to
use
it
in
subsequent
activities
within
the
same
burst
of
execution.
A
Actually,
let's
dig
into
that
right
right
away
and
of
course,
if
you
have
any
questions
at
any
time
just
interrupt
so
while
this
loads,
let
me
also
show
you
how
you
can
access
the
activity
output
directly
from
a
programmatic
workload
and
then
we'll
look
at
a
at
the
designer
example.
So
here
we
have
this
one.
So
this
is
a
console
application.
It's
a
very
simple
program.
It
shows
to
workflows
they
they
perform,
they
have
the
same
function,
but
they
use
two
different
methods
of
accessing
activity
output.
A
The
first
one
demonstrates
accessing
the
output
of
a
activity
directly.
So
when
you're
using
a
programmatic
workflow,
what
you
can
do
is
here,
for
example,
I
instantiate,
a
realign
activity
and
assign
it
a
C,
sharp
variable
and
then
so.
This
is
an
activity,
and
then
here
I
put
it
in
the
activities
array
of
the
sequence
activity.
A
So
it's
going
to
execute
after
these
activities
and
the
reason
I
put
this
this
activity
in
a
variable
is
so
that
I
can
access
its
results
from
well,
in
this
case,
the
next
activity,
but
it
doesn't
have
to
be
the
next
activity
I-
could
have
accessed
it
from
any
subsequent
activity
using
a
very
intuitive
syntax,
because
this
is
just
accessing
the
variable.
And
then
you
request
its
results
with
a
read
line.
Has
an
output
which
looks
like
this?
Actually,
let
me
show
you
so
this
is
the
readline
implementation.
A
It
inherits
from
code
activity,
result
type
of
string,
so
every
activity
that
inherits
from
an
activity
with
a
generic
type
arguments
such
as
code
activity
of
type
string.
These
activities
have
a
result,
property
that
they
inherit
I'll
show
you
that
as
well
here,
so
here's
the
results
property.
So
this
property
is
inherited
by
Redline,
which
I'm
using
here
using
a
an
extension
I
think
it's
an
extension.
Yeah
called
get
results
which
internally
gets
the
results,
properties,
value
and
I'm,
taking
advantage
of
automatic
conversion
value
conversion.
So
here
I
I
need
for
this
example.
A
A
But
here
I'm,
taking
advantage
of
the
get
last
result
extensive
method
to
get
the
output
of
the
last
executed
activity,
which
in
this
case
is
read
line
so
because
the
red
line
executed
before
this
activity,
I
I,
can
take
advantage
of
that.
Of
course,
if,
if
you
want
to
access
the
last
result
from
another
activity
that
executed
after,
if,
for
example,
in
that
case,
you
would
have
to
use
the
variable
approach
that
I've
shown
here
right.
A
So
in
any
case,
if
you
have
like
a
chain
of
activities
where
one
activity
I'll
put
something
that
you
want
to
use
as
an
input
into
the
next
one
and
so
forth,
then
then
the
last
result
might
be
very
convenient
for
you,
maybe
you're,
processing
files
or
whatever-
and
this
is
an
important
point-
this
this
value
exists
only
in
memory.
So
it's
not
being
persisted
anywhere.
A
If
you
did
want
to
persist
it,
you
need
to
capture
it
using
a
variable
and
then
configure
the
Persistence
of
that
variable,
which
could
be
workflow
storage,
which
means
it's
become
serialized
as
part
of
the
workflow
instance
document.
It
could
be
blob,
storage
or
a
custom
persistence
provider.
All
right,
so
this
is
the
programmatic
way
and
then
I
refresh
this.
B
A
B
A
Oh
yeah
exactly
yeah,
indeed,
okay,
so
so
the
output
value
will
be
gone.
But
if
the
variable
is
persistent,
then
you
will
access
the
variable
yeah
and
also
two
its
Works
differently,
where
you
can
configure
the
outputs
store
persistence.
Setting
directly
in
lc3
I
wanted
to
experiment
with
a
different
mechanic,
and
it's
it's
entirely
possible,
depending
on
feedback
from
users
to
reintroduce
that
possibility,
where
you
can
control
the
Persistence
of
output
and
in
that
case,
variables
are
optional.
A
A
Let's
say
we
have
an
HTTP
endpoint
that
can
trigger
this
workflow
listening
at
this
path
and
we're
going
to
post
some
Json
content
to
it.
So
before
this
change
you
had
to
assign
a
creative
declare
variable
and
then
assign
it
to
the
parse
content,
outputs.
If
you
wanted
to
use
the
parsed
Json
or
assigning
variable
to
Route
data
per
string
data
Etc,
whatever
you
want
to
access
right,
but
now
we
can
access
this
thing
directly
using
JavaScript.
A
So,
for
example,
that
would
look
like
this
I.
Could
say,
get
outputs
from
and
then
I
specify
the
activity
ID,
which
would
be
HTTP
endpoint
one.
That's
this
thing
here,
optionally.
You
need
to
provide
an
output
name
in
the
case
of
an
activity
that
produces
multiple
outputs
like
the
HTTP
endpoints,
then
this
is
necessary.
If
you
don't
specify
it,
it
will
default
to
the
named
output
called
result.
But
in
this
case
we
wanted
to
use
first
content.
A
I
think
is
the
name
bars
content,
yes,
and-
and
this
is
just
a
display
name,
so
maybe
we
should
also
somehow
display
the
the
technical
name,
because
you
need
the
technical
name
as
the
argument
here.
So
this
this
won't
work.
You
would
you
need
to
do
it
like
this.
So
that's
that's
one
way.
Another
way
is
it's
a
more
well,
it's
not
really
strongly
typed,
but
it
has
intelligent
support,
at
least
so
you
could
say,
get
bars
content
from
HTTP
endpoint
one.
A
So
this
is
a
generated
JavaScript
function
based
on
the
information
it
has
of
the
system,
so
it
has
information
about
the
ID
or
the
the
outputs
of
of
the
activities
in
the
workflow
and
their
outcome
and
their
identity
identifiers,
and
then
it
constructs
a
name
using
a
convention.
So
the
nice
thing
about
this
is
that
it's
easier
to
discover.
A
So
you
don't
have
to
click
back
and
forth
and
maybe
make
a
mistake
in
terms
of
I,
the
name
of
the
activity
or
the
idea
of
the
activity
and
the
name
of
the
outputs
and
also
it
it
has
the
potential
for
intellisense
to
this
to
display
the
actual
type
of
the
of
the
output
in
this
case.
I
didn't
implement
it,
so
it's
going
to
default
to
any
and
actually,
in
the
case
of
HP
endpoint
bars
content.
This
being
an
object
would
result
in
any.
A
But
but
if
I
chose
raw
data,
then
we
have
the
option
now
to
actually
display
object,
dictionary
and,
of
course,
for
custom
activities
with
specific
types.
That
would
work
as
well,
but
to
be
clear,
that's
not
currently
implemented,
but
we
will
I
will
Implement
that
at
some
point
so
yeah.
So
this
way
I
can
access
it
directly,
no
variables
necessary.
B
A
That's
right
exactly
that's
the
point
here.
This
will
cause
the
workflow
instance
to
be
persisted,
removed
from
memory
depending
on
the
workflow
runtime
and
then
after
the
delay
occurs,
the
work
license
will
be
resumed,
but
you
will
no
longer
have
access
to
this
HTTP
endpoints,
output
and
reasoning
of
that
is
because
these
objects
that
are
being
output
could
be
very
large
objects.
A
For
that
reason,
it's
it's
there
transiently.
If
you
did
want
to
persist
it,
then
you
need
to
either
use
a
set
variable
and
then
configure
the
variable
using
storage
providers
which
there
could
be
Memory.
If
you
don't
really
care,
you
just
want
to
reuse
the
variable
but
not
persist.
It
then
use
memory
by
default.
It
will
use
the
workflow
storage
provider,
which
means
it
will
be
serialized
as
part
of
your
workflow
instance.
A
B
A
B
B
A
Exactly
so,
and
at
least
you
don't
have
to
do
that
in
Elsa
3
in
here,
you
can
just
assign
the
variable
directly
to
this
thing
here
and,
as
you
say,
then
you
can
use
it
here.
As
is,
and
let's
let's
say,
there's
a
time-
a
delay
of
three
seconds
and
now
this
time.
Because
of
this
delay,
we
will
lose
the
HTTP
context.
So
therefore
I'm
using
a
right
line
to
try
it
out.
A
B
B
A
A
A
Yeah,
okay,
yeah!
So
let's
let's
shoot
like
this,
then
so,
let's
say
well:
root
line
is
not
well,
let's
do
it
for
now.
Let's
say
we
have
this.
Of
course,
the
root
line
will
actually
block
the
process
because
it's
gonna
wait
for
user
to
input
something
in
the
console,
but
just
for
talking
about
it.
So
here
it's
a
good
question
at
this
point.
You
don't
necessarily
know
what
the
which
output
you're
gonna
get.
B
A
Good
question
yeah:
if
right
line
had
an
output
and
yes
but
right
line,
doesn't
produce
an
output,
so
it
will
reuse
again
the
output
of
this
one,
because
it's
the
last
emitted
output.
If
after
right
line,
we
would
have
let's
say
another
read
line
and
let's
assume
for
a
second,
that
this
executes
first
and
this
one
and
then
this
one
yeah
and
then
this
one.
A
A
Oh
I
see
what
you're
saying
yeah
exactly
that's
how
it
currently
is
yeah,
but
to
be
fair.
Maybe
that
is
a
would
be
a
a
good
good
use
case
as
well,
where
you
say,
maybe
there's
there's
a
case
to
be
made
where
you
say
where
you
have
some
API,
where
you
say:
use
last
result
or
get
last
result
or
get
previous
result
or
something
like
that.
A
A
A
B
A
So
just
maybe
a
quick
look
at
the
Dapper
persistence.
I
have
an
example
project
that
shows
how
to
use
the
Dapper
provider.
I.
Think
it's
maybe
here
so
here,
there's
in
the
ASP
net
fold,
there's
Dapper
persistence
and
because
there's
different
modules
in
Elsa,
so
there's
a
workflow
management
module
a
runtime
module,
an
identity
they
each
can
have
their
own
persistence
providers
installed.
A
So
if
you
want
to
use
Dapper
for
all
three,
then
you
need
to
configure
those
all
three
of
them,
which
also
means
you
can
use
stepper
for
one
and
EF
core
for
another
and
mongodb
for
yet
another
module.
If
you
wanted
to
or
your
custom
provider
here,
I'm
showing
how
to
do
it
for
each
module
use
Dapper-
and
here
we
have
a
folder
called
persistence,
so
we
have
Dapper
and
migrations
for
Dapper.
A
So
that
just
helps
you
set
up
the
database
automatically
instead
of
having
to
execute
some
SQL
Scripts,
which
is
very
similar
to
EF
core,
but
not
the
same,
and
here
we
have
a
modules,
folder
and
yeah,
so
they
have
implementations
for
each
of
these
modules
yeah.
So
that's!
That's!
Actually
all
I
have
to
say
about.
A
I
think
so
yeah,
if
you
look
at
the
migrations
thing
itself,
so
this
by
the
way,
the
migrations
are
not
part
of
the
Dapper
library
but
of
fluence
migration
fluent
migrator,
which
is
unrelated
to
Dapper,
but
it
just
executes.
It
has
an
affluent
API
to
to
create
schemas
and
it
has
I
think
in
schema
yeah,
so
using
in
schema,
I
haven't
tried
it,
but
it
looks
like
this
would
allow
you
to
provide
some
some
schema.
I,
don't
know
if
it
supports
dependency
injection
by
the
way.
A
Let's
use
this
a
table
name
primary
key
name.
So
somewhere
it's
going
to
generate
a
query.
So
here,
I'm
gonna,
I
I
created
a
query
Builder.
Instead
of
string,
concatenating
yeah
SQL
strings
in
every
provider,
I
I
created
some
helper
methods.
So
here
we
have
a
parameter
as
query
object,
which
is
a
very
simple
Poco.
A
A
Let's
take
a
look
where
this
is
used,
so
here
there's
an
extension
method
to
build
a
select
star
from,
for
example,
from
some
table,
so
here
either
from
the
parameter
I
Square,
which
could
contain
the
schema
name
so
that
it
internally
can
be
used
here.
That
might
be
a
good
option
so
so
being
able
to
configure
the
schema
in
the
migrations
and
then
in
this
this
little
API
to
build
SQL
strings
I,
think
it's
much
easier
than
what
you
would
have
to
do:
an
EF
core
any,
of
course
also.
A
B
B
A
There's
lcdb
context,
options
and
there's:
let's
see
yeah
it's
being
used
in
these
extensions
use,
Elsa
my
SQL,
then
it's
being
passed
in
here.
I
haven't
tested
it,
but
it
does
require
you
to
create
your
own
migrations,
I,
think
so
that
you
can
specify
this
the
same
schema
name
because
the
defaults
migrations,
don't
include
it
because
once
these
migrations
are
generated,
you
see
it
becomes
a
hard-coded
string
and
I.
A
B
A
A
So
adapter
is
more
of
you
know
it's
a
set
of
extensions
around
ado.net
interfaces
and
contracts.
So
I
think
you
we
don't
need
any
wrappers
like
here
and
free.
Of
course,
we
only
need
sqlite,
SQL
Server
Etc
just
to
have
the
the
DB
context,
factories.
That's
the
only
only
reason
really
and-
and
it's
also
a
good
host
for
the
migrations
for
this
particular
provider
for
Dapper.
We
have
to
do
it
like
this.
So,
for
example,
bracelets
here
here,
I
need
to
make
a
distinction
between
sqlite
and
the
rest
because
of
I.
A
Think
let
me
let
me
see
if
I
remember
yeah.
The
here
you
see
I'm
using
as
daytime
2,
which
is
with
the
reason
for
that
being
is
that
sqlite
doesn't
support
data
daytime
offset,
so
we
need.
You
still
need
to
make
this
distinction,
but
at
the
very
least
it's
in
the
same
project.
We
don't
need
a
DB
context.
Vector
like
we
need
for
EF
chord,
so.
B
A
Yeah,
if
you
want
it's,
it's
there
for
you,
yeah
yeah,
so
that's
the
nice
thing
about
the
upper
and,
of
course
you
can
always
Implement
your
own
persistence
providers
well,
which
directly
targets
whatever
you
want,
because
the
let's
see
the
let's
take
a
look
at
the
word
for
definition
store.
It
just
implements
our
definition
store
and
it's
a
very
I
think
at
least
it's
a
straightforward
interface.
A
It's
it's
a
bit
of
work
because
well
specifically
here,
because
it
also
requires
you
to
implement,
find
summaries,
which
is
like
a
a
view
of
the
word
for
definition,
without
the
Big
Data
block
right,
which
is
better
for
listing
sets
of
workflows
but
yeah,
it's
not
complicated
and
we
have
implementations
for
Dapper
EF
core
memory
and
for
workflow
instance.
We
have
elastic
source,
as
you
know.
Yes,.
A
Yeah,
so
lots
of
options
there
and
last,
but
certainly
in
at
least
the
also
Studio
updates.
So
what
changed
is
we
already
had
this
loaded
from
the
database?
So
this
is
the
workflow
we
just
worked
on
and,
as
you
can
see,
we
have
the
right
lines,
Etc,
which
lines
for
each
yeah
so
that
that's
actually
one
of
the
changes,
so
it
now
actually
loads
in
the
workflow
definition
into
the
designer.
Last
time,
I
showed
this.
It
was
just
showing
some
pre-configured
hard-coded
Json
that
data
that
it
was
loading.
So
this
is
now
getting
from.
A
Database.
Same
goes
for
the
activities
here.
This
all
comes
from
yeah
from
from
the
back
end,
this
is
cool
and
you
can
drag
and
drop
them
onto
the
the
designer.
So
so
that's
been
been
implemented
as
well
and
currently
I'm
working
on
persistence,
so
that,
whenever
you
make
a
change
here,
it
gets
sent
to
the
back
end
asynchronously
in
the
background
yeah
what
I
really
like
about
working
with
mud
Blazer?
You
know
an
existing
component
Library.
A
It
saves
a
lot
of
time
compared
to
the
designer
here,
where
everything
is
all
the
components
are
basically
created
from
scratch,
which
can
take
a
lot
of
time.
Like
you
know
these
these
panels,
you
have
to
do
it
yourself,
these
things
here,
the
tabs,
even
even
though
you
know
the
UI
wise,
it's
easy
because
of
Tailwinds
the
behavior.
That's
still
a
significant
amount
of
work,
including
things
like
notifications,
all
of
those
things
you
get
for
free
with
mud
Blazer,
so
that
really
speeds
up
the
development
and
soon
there
will
also
be
UI
validation.
A
A
A
B
Yeah,
for
me,
it's
a
it's:
the
activity,
picker,
the
the
tab
with
the
designer
workflow
and
the
the
drawer
on
the
on
the
right.
Yes
on
the
right.
Yes,
this
is
this
one
and
after
maybe
I
will
need
some
module
like
a
security
secret
Etc,
but
I
will
pick
the
different
model
and
implement
or
just
use
it
in
other
parts
of
my
application.
I
see.
A
Yeah
so
I'll
be
up
front
right
now.
You
would
not
be
able
to
do
it
because
everything
is
intertwined,
so
so
so
some
of
these
components
they
rely
on
services
that
are
provided
by.
Well,
that's
not
true.
It's
not
like
a
UI
component
produces
services,
but
I
will
keep
it
in
mind
to
make
sure
that
things
are
decoupled,
with
keeping
in
mind
that
you
and
other
users
might
want
to
reuse
bits
or
bits
and
pieces
like
this
components,
including
this
one
as
where
you
can
assemble
it
together
or
do
you
think
pretty
much?
A
B
A
A
Allows
which
means
that
when
you
integrate
this
set
of
Blazer
libraries
into
your
own
aspin
core
Blazer
application,
you
can
customize
the
UI
easily
using
Blazer
component
library
with
your
own
UI.
If
you
want
to
okay
yeah
but
yeah.
Oh
thank
you
for
that
feedback.
I
will,
because
that
helps
me
understand,
use
cases
and
then
I
will
keep
in
mind.
You
know
to
make
sure
that
things
are
decoupled,
so
there
will
be
a
shared
set
of
services
so
that
it's
convenient
to
get
information
into
these
components,
but
the
components
themselves.
B
When
you
click
you,
you
have
a
publish
and
publisher,
save
or
publish,
revert
and
I
think
there
is
a
another
and
because
I
need
to
communicate
with
other
service
when
I
publish
if
it
would
be
very
great
to
be
able
to
add
some
action
on
this
published
when
you
are
to
to
manipulate
that
I,
don't
know
how
to
explain.
Maybe
a
launch
other
process
before
publish
so
hook,
the
publisher
action,
etc,
etc.
A
That
makes
a
lot
of
sense
and
definitely
that
should
be
made
extensible
or
you
know,
open
up
for
adding
more
sub
menus
or
maybe
even
replacing
the
entire
publish
button
with
your
own.
If
you
really
wanted
to
do
some
customization
and
and
if
you're
building
your
own
dashboard,
maybe
you
want
to
use
a
button
like
here,
just
to
save
or
maybe
publish,
maybe
you
don't
even
want
this,
so
that's
gonna
offer
a
lot
of
options.
One
question
I
have
is
that
this
is
using
mud
Blazer
which
implements
the
material
design
system.
A
What
is
your
opinion
on
FEMA
on
theming,
so
so,
basically
using
or
customizing
the
CSS
is
it?
Is
it
okay
to
be
able
to
use
mud,
Blazers,
theming
system
and,
of
course,
it's
CSS
classes
that
it
provides
or
because
it's
very
opinionated
right,
not
every
dashboard
will
want
to
use
material
design.
Maybe
they
want
to
completely
rethink
re-theme
the
well
these
components,
yeah.
B
I
I
I'm
not
very
good
on
CSS
and
design,
but
what
what
I'm
thinking
is,
because
it's
material
design,
it's
something
recognized,
and
there
is
some
standard
around
the
material
design.
So
if
we
write
correctly
a
site
using
material
design,
anyone
who
want
to
customize
the
theme
then
can
keep
the
material
design
concept.
So
I
think
it's
it's
good
and
if
they
want
to
really
customize
other
other
animation
or
other
other
things
like
and
not
a
color
or
these
players.
Something
like
that.
Okay,
it's
very
specific
CSS.
B
A
It
makes
a
lot
of
sense
and
I'm
also
thinking
it
would
be
quite
a
big
undertaking
to
create
a
custom
design
system.
That's
that's
a
very
big
project
in
its
own
right
and
probably
if
people
wanted
to
use
a
different
design
system
or
create
their
own,
probably
it
would
make
more
sense
for
them
to
create
their
own
uis
and
just
consume.
The
backend
apis
of
Elsa
in
that
case,
did
I.
Show
you
the
environment
drop
down
last
time.
B
But
that's
that's
good!
It's
it's
a
it's
another
example
of
component
that
for
me,
I
need
to
override
because
the
the
I
have
an
environment
system
and
when
I
use
it
I
switch
the
the
token
the
everything
on
the
identity
of
the
user
and
so
I
refresh
some
element
and
I
will
then
I
use
other
API,
maybe
because
the
back
end
is
different.
A
B
A
This
is
the
module
that
provides
this
component
called
environment
picker,
which
means
because
this
is
a
module,
it's
optional,
so
you
can
just
simply
not
reference
this
from
your
application,
but
it
does
serve
as
an
example
how
you
can
install
your
own
components,
which
works
like
things
like
this
yeah,
so
in
in
there's,
there's
some
module
class.
So
this
is
what
you
would
Implement
and
then
you
inject
the
app
bar
service,
which
is
a
analysis
Studio
service
which
is
used
somewhere
by
the
by
the
UI.
A
And
then
you
just
add
your
app
bar
item,
which
can
be
any
component
you
want.
So
in
this
case
it's
the
environment,
picker
and
you
can
replace
or
use
your
own
components
and
that's
basically
the
idea
what
I
want
to
replicate
for
many
of
these
UI
things
so
that
you
can,
if
you
wanted
to
reuse
this
dashboard
or
the
studio,
but
you
know
replace
certain
aspects
on
certain
screens,
for
example
on
the
security.
Maybe
you
want
to
use
your
own
user
components,
for
example,
then
this
will
be
one
way
to
do
it.