►
Description
In this webcast, we concentrate on how to call securely APIs hosted in Azure from your SharePoint Framework solutions. This capability was shipped as part of the SharePoint Framework 1.6 version and it provides you a capability to securely call any Azure AD secured APIs, like Azure Functions or your custom WebAPIs.
Exact details on covered topics from https://developer.microsoft.com/en-us/sharepoint/blogs/.
Related documentation from SharePoint Developer Docs
- https://docs.microsoft.com/en-us/sharepoint/dev/spfx/use-aadhttpclient
- https://docs.microsoft.com/en-us/sharepoint/dev/spfx/use-aadhttpclient-enterpriseapi
- https://docs.microsoft.com/en-us/sharepoint/dev/spfx/use-aadhttpclient-enterpriseapi-multitenant
A
B
Welcome
everybody:
this
is
Shep
I'm,
finessin
practices
webcast,
and
this
time
we
kind
of
talked
about
at
the
calling
action
ad
you
securit
api's
from
SharePoint
framework.
This
is
the
capability
which
was
released
as
part
of
the
SharePoint
framework
1.6
or
technically
it
went
to
GA
as
an
availability
in
1.6.
It
was
originally
released
in
the
one
point
four
point:
one
version
to
preview
earlier
in
2018,
so
the
capability
itself
is
now
in
production,
ready
and
status,
and
we
were
able
to
start
using
this
within
your
tenants
as
well.
B
B
Excellent,
so
before
the
kill
do
the
action,
steps
and
walks
in
walking
through
what
this
actually
means
so
just
quickly
clarifying.
This
is
really
so
to
say
the
holy
grail
of
the
sharepoint
online
development,
because
using
this
capability
you
are
able
to
call
as
securely
and
web
api,
which
is
hosted
in
microsoft,
azure
and
then
it's
up
to
you.
B
What
that
web
api
is
doing
so
you're
able
to,
for
example,
access
your
line
of
business
data
from
on-premises
or
you're
able
to
access
whatever
Siegel
or
database
data
in
Azure
or
you're
able
to
the
get
data
to
usher
for
processing
and
all
that
stuff.
So
this
is
really
around
being
able
to
delegate
the
business
logic
from
the
SharePoint
framework
web
part
or
a
component
and
directly
to
an
API
which
is
which
has
been
more
processing
power
in
Russia,
and
that
sounds
exciting.
Doesn't
it
Pollock
absolutely.
A
I
mean
that's
when
you
think
about
it:
it's
what
you
really
want
to
have
in
order
to
really
benefit
of
the
portal
that
should
be
built
right,
because
as
sure
you
will
have
some
of
the
data
directly
in
SharePoint,
but
you
will
still
have
some
of
the
data
in
your
lob
and
that's
one
point
two:
to
integrate
it
and
allow
the
users
to
have
a
central
location
to
access.
All
of
that,
you
will
need
to
bring
some
of
the
data
to
the
Aurel,
and
this
is
exactly
the
way
to
do
it
right.
A
B
Portal,
absolutely
absolutely
yeah,
so
maybe
in
it
potentially
in
the
latest,
a
or
previously
might
have
actually
done
something
like
replicating
the
relevant
data,
there's
a
shopping
list
and
then
surfacing
that's
a
European
one
way
of
doing
that.
This
way
you
can
actually
then
do
use
caching
and
all
that
capabilities,
also
in
our
show,
but
the
API
size.
So
really
this
sign
the
access
to
the
information
and
do
the
taking
advantage
of
our
capabilities
for
your
benefits
in
a
separate
grades.
B
Anyway,
a
lot
of
talking
a
lot
of
talking,
so
let's
actually
go
through
some
slides.
So
what
does
it
mean
in
practice
pretty
busy
slide,
but
what
it
actually
means
is
that
so,
let's
go
through
the
steps
of
using
the
azure
ad
HTTP
client,
so
ad
HTTP
client
is
the
rapper
or
abstraction
class
for
using
our
calling
a
third-party
web
api
in
the
security
way.
So
we
also
need
to
have
first,
the
third-party
web
api
hosted
in
Azure
ad
or
hosted
in
Azure
subscription
and
the
exact
setup
on
that.
B
One
slightly
depends
on
then,
if
the
API
is
a
multi-tenant
api,
or
is
it
pertinent
api
or
per
channel
installation?
So
are
you
using
a
third
multi-talent
api
exposed
by
somebody
else,
or
are
you
actually
exposing
the
api
only
for
you
within
your
town,
both
options
are
available
and
you
can
securely
call
both
api's
after
administrative
operations.
B
Hardness
traitor
has
approved
that
api
to
be
available
now.
The
second
step
is
obvious
were
needing
the
writing.
The
need
a
code
which
system
using
the
ad
it's
the
big
client
to
access
the
API
then
to
be
able
to
get
approvals
on
the
ship.
One
sign
you
will
need
to
request
the
need
of
scopes
or
needed
approvals
so
to
say
in
the
packaged
solutions
of
JSON
files,
so
in
the
solution
file
of
your
ship
and
framework
component.
B
After
this,
we
upload
this
with
Casey
founded
app
catalog,
both
focusable
packets,
the
solution
first
up
and
we
upload
test
fabricated,
app,
catalog
and
then
administrator
in
that
tenant
will
need
to
approve
the
additional
scopes
using
the
modern,
Acme
UI
or
sharepoint
online
management,
powershell
or
actually
office
365
as
well.
So
that's
definitely
an
option
as
well,
and
then
you
basically
are
able
to
use
the
SharePoint
framework
components
and
you
can
definitely
have
a
look
on
Tracy
they'd
be
pause
and
traffic,
how
the
scopes
and
permissions
are
actually
birth.
Now
anything
you
want
out
there.
A
B
For
because,
in
this
case,
we
we
call,
we
call
it
as
a
tenant,
but
it's
an
azure
ad
tenant.
Basically
well.
Every
single
tenant
has
an
hid
behind
of
them,
and
and
like
that,
you
might
have
a
multiple
subscriptions.
Multiple
subscriptions
means
then
multiple,
sorry,
potentially
multiple
channels
and
that
might
add
additional
comparable.
A
B
Absolutely
now,
let's
have
a
look
on
the
logical
architecture
of
this
one,
so
how
does
it
actually
work
in
practice?
And
so
technically,
what
we
have
is
a
encode
to
SharePoint
Online
client
in
Azure
ad,
so
the
actual
name
is
pretty
long.
We
didn't
update
the
slide
for
that
because
it
doesn't
actually
fit
on
the.
A
B
But
it
there
is
already
pre
provisioned
application
in
eurasia
ad,
which
you
should
never
ever
delete.
That's
like
deleting
the
permissions,
while
deleting
cause
significant
problems,
but
what
that
is
is
the
application
which
we
for
Microsoft
pre
provisioned
for
you,
where
you
then
current
the
permissions.
The
tenant
administrator
is
the
one
who
basically
approves
what
kind
of
scopes
and
what
kind
of
permissions
are
available
for
it
and
that's
then,
basically
used
for
cramping
or
defining
the
scopes
and
permissions
for
third
party
web
api.
B
The
same
application
is
used
by
the
much
of
crack
point
and
also
the
a
ADHD
they
decline
behind
of
the
sims.
Now
the
application
itself,
and
and
really
important
to
think
we've
kind
of
talked
about
this
one
in
the
upcoming
side
as
well.
But
it's
important
to
understand
that
this
is
a
one
application.
So,
even
though
you
might
have
multiple
solutions
and
components
in
SharePoint
framework,
we
do
not
provision
an
automatic
application
for
every
single
component
or
in
the
ad.
B
So
there's
only
one
application
which
we,
which
we
can't
those
permissions,
and
that
has
certain
implications
which
we
kind
of
talk
about
on
the
following
slide.
Now
what
it
also
means
is
that
the
abstraction
layer
is
taking
care
of
the
Scopes
and
permissions.
So
basically,
whenever
you
are
then
using
the
roger
ad/hd
client
and
we
will
take
care
of
the
access
tokens
and
all
of
that
for
you
and
then
when
you
call
a
web
api,
you
don't
have
to
worry
about
taking
care
of
the
Scopes
and
permissions
as
you
are
calling.
B
A
Know
what
the
money
we
could
go
more
in
death
and
we
probably
will,
when
we
go
to
the
next
slide,
where
we
talk
about
different
things
that
you
have
to
take
into
account:
I
guess!
For
this
part,
this
is
clear
right.
It
shows
you
where
permissions
live.
How
do
you
retrieve
that
from
the
page
and
how
they
are
being
used
when
you're
called
the
API
eventually,
so
I
would
say
that
for
now,
let's
keep
the
overview,
an
overview,
dance,
yes
and
then
go
go
into
more
depth
on
the
next
slide
on.
B
The
next
time
well,
this
isn't
that
really
going
super
daddy
ponder
on
the
table
a
fun
few
considerations
when
I'm
using
a
DHCP
client,
so
you
will
need
to
use
in
April
course,
so
the
cross-origin
resource
cross
origin
refers
c'mon,
sharing,
sharing
stories
of
sharing.
Thank
you,
mother
for
the
API.
So
basically
what
this
means
that
you're,
enabling
explicitly
that
API
to
be
available
in
SharePoint,
become
or
in
your
talents.
Otherwise
you
will
run
into
an
issue
because
it's
it's
a
cross.
Well,
it's
being.
B
B
So,
basically,
whenever
the
solution
is
getting
added
on
at
catalog,
there's
been
a
request
for
the
needed
permissions
before
the
operate
part
will
work
and
we
don't
need
to
have
a
tenant
that
missive
Commission's
to
be
able
to
do
that,
and
because
we
need
to
go
to
the
modern
UI
is
or
use
the
SharePoint,
Online
partial
or
the
CLI
it
to
make.
This
happen
right
mentioned
on
the
previous
slide.
B
All
of
these
kind
of
conditions
apply
to
all
JavaScript
components
running
in
a
tenon,
so
you
as
an
administrator,
you
need
to
be
aware
of
that,
so
those
permissions
on
then
available
for
all
of
the
SharePoint
framework
applications.
So
the
permissions
are
not
only
for
one
component
which
is
requesting
them.
Theoretically,
technically
they
are
available
for
any
component
in
the
tenant.
Who
can
access
that
information
now
in
future
scale
in
the
future?
B
There
will
be
a
few
different
cool
new
capabilities
available
in
SharePoint
framework,
where
you
can
isolate
the
components
and
all
that,
but
that's
a
different
topic,
and
we
cannot
talk
about
that
one
in
its
separate
webcast
and
then
this
capability
is
available
across
all
of
the
channels,
starting
from
early
September,
well
mid,
September
2018.
So
as
part
of
the
ship
one
framework
1.6
release,
this
capability
went
to
the
GA
availability
across
all
of
the
tops
anything.
What
I'm
missing
here
I
think.
A
B
It's
the
simplicity
of
things.
Absolutely
it's
it's
an
it's
an
abstraction
layer
for
simplifying
things,
for
you
to
really
call
the
Web
API
from
it
in
the
solution
level
in
the
web
part
level
or
an
extension
level.
The
needed
level
of
code
is
basically
nothing
as
long
as
the
permissions
have
been
managed
or
approved
everything
the
plumbing
is
taking
care
of
completely
under
the
hood
anything
else.
What
you
would
say.
A
Well,
I
think
that
that
that
wraps
it
up
and
and
also
affects
away
all
of
complexity,
like
with
the
return
URLs
handling
data,
handling
the
fact
that
multiple
things
on
a
page
can
call
out
the
same
or
excess
token
for
the
same
resource
at
the
same
time.
And
you
need
to
take
care
of
that.
They
can
be
multiple
web
person
and
multiple
things
on
the
page.
That
want
an
access
token,
and
so
there
are
quite
a
few
things
that
you
have
to
take
into
account.
A
A
B
Now
few
slides
and
let's
actually
jump
into
the
demo
a
solid
jump
on
wall
decks,
computer
and
let's
have
a
look
on
this
one
in
practice.
So
how
do
we
use
this?
What
is
the?
What
for?
How
do
we
enable
the
Web
API
naturally,
and
how
do
we
call
the
Web
API
from
our
components?
So
let's
keep
the
sample
relatively
simple
for
a
simplicity
perspective,
so
you
understand
the
basics,
but
then
we
will
definitely
record
more
complex
samples
around
this
scenario
in
the
future
as
well.
But
let's
jump
on
pallete
computer.
A
All
right,
so,
let's
have
a
look
in
practice:
how
you
would
call
to
an
API
and
lob
API
that
you
have
build,
which
is
secured
with
a
tea
from
your
SharePoint
in
work
web
part.
So
here
we
have
an
API
and
that
just
illustrates,
let's
say
a
system
that
gives
you
insights
into
orders.
So
we
can
call
that
and
that
doesn't
do
much
now,
but
it's
not
really
the
point
what
it
does.
A
Oh
yeah
always
well,
we
will
get
error,
so
this
is
by
design.
This
is
good.
This
is
actually
the
fact
that,
because
we
didn't
specify
the
headers,
the
output
is
in
XML,
but
because
the
objects
that
we
returned
back
on
things
like
dates
and
objects,
XML
kind
of
format
that
so
this
is
my
design.
This
is
nowhere
here,
but
the
fact
is
that
now,
if
we
call
the
same
API
anonymously,
we
will
get
a
prompt
to
authenticate
first,
and
this
is
good
right.
B
A
Here
we
have
a
function
app
which
we
use
to
build
this
API,
and
here,
if
you
go
to
authentication
here,
are
all
the
options
that
you
can
use
in
Azure
functions
to
secure
your
API
with
AAT.
So
here
in
we
go
that
we
say
the
awesome,
tenant
and
and
education
is
enabled
and
will
and
when
there
is
an
anonymous
call
to
it.
A
Let's
redirect
to
a
80
page
right-
and
here
we
have
the
ad
option
enabled
so
if
we
go
go
to
that
and
let
me
quickly
switch
to
express
mode
so
that
it's
easier
for
us
to
see
the
application
that
we
have
and
in
here
let
me
go
to
the
app
so
in
here.
We
can
see
the
underlying
azure
ad
app
that
we
use
to
actually
secure
this
API
with
AAT.
So.
B
A
Always
an
application
that,
by
step
through
the
same
blaze
going
in
in
here
first,
so
you
would
start
here
initially,
though
that
would
be
be
set
to
OFF.
You
would
enable
that
to
all
you
would
enable
a
ad
because
there
would
be
off,
and
you
just
goes
to
go
step
by
steps
through
all
of
them
and
if
your
a
ad,
if,
if
the
function
is
located
in
the
same
tenant
as
three
six
environment,
then
you
don't
need
to
worry
about
any
of
that.
You
will
just
click
next.
A
A
Right,
yep
and
here
in
here
are
a
few
important
bits
and
pieces
to
which
we
will
get
in
a
moment
as
we
will
build
the
the
web
part
and
register
all
the
different
parts
down
that
we
need
to
have
Evan
there
fold
the
whole
set
up
to
work.
So
this
is
our
API.
We
leave
it
for
now.
As
this
we
haven't
changed
anything
here.
So
this
is
exactly
what
you
would
say.
What
would
what
you
would
see
if
you
would
go
through
the
through
through
wizard?
A
So
now,
let's
go
to
the
code
and
in
here
I
have
a
SharePoint
framework,
11.6
a
project
with
a
web
part
and
and
I
build
all
that
so
that
you
don't
need
to
see
me
code,
but
we
will
talk
about
the
important
pieces
that
we
have.
So
we
start
with
granting
permissions
or
requesting
permissions
to
this
API,
because
by
default
we
are
not
allowed
to
access
that.
A
A
So
here
we
add
two
lines:
we
add
the
Web
API
permission
request
section
and
in
there
for
each
each
API
that
we
want
to
access
for
each
scope,
permission
scope
we
want
to
have
we
add
an
entry
which
you
see
here.
So
in
our
case
we
want
to
access
our
API,
which
is
secured
with
an
app
named
after
tennis,
which
is
like
n
3
is
5
x,
o3
v
/
o
api,
and
this
is
exactly
the
api
for
the
app
name
which
you
see
here.
So
we
go
to
this
little.
A
You
go
to
settings
properties,
and
here
you
have
the
name.
So
it
has
to
be
this
name
like
initially
in
preview.
You
had
the
option
to
either
use
a
gooood.
Then
this
one
here
or
the
name
and
they
would
work
both
with
GA.
You
can
only
use
the
name
if
you
will
use
a
good
when
trying
to
approve
the
permission
request,
you
will
get
error
so
always
use
application
name
so
that
that
is
1
and
then
2.
You
need
to
specify
which
permission
scope
you
want
to
have
access
it
right
off.
A
So,
for
example,
if
you
think
about
like
in
graph,
you
can
have
access
to
read
the
email,
read
calendar,
retask,
create
tasks
and
all
that
in
our
API.
It
depends
what
your
API
implements
permissions
that
are
available
for
your
API.
You
can
see
them
in
manifest,
so
here
we
click
to
manifest
and
when
you
scroll
down
there
is
a
property
named
all
of
the
two
permissions,
and
in
this
case
you
can
see
that
we
only
have
one
which
is
user
impersonation.
A
If
your
API
had
distinction
between,
for
example,
read
and
write,
create
order,
share
or
zone
that
you
that
would
be
available
here
and
you
would
be
able
to
request
them
in
your
package.
But
in
our
case
we
only
want
the
access
we
don't
authorize
to
API.
We
only
need
to
authenticate
so
as
such,
we
only
have
this
one
scope,
which
we
don't
include
in
package
in
here.
So
now
this
part
is
done
and
we
will
deploy
the
package
to
catalog.
We
will
issue
a
permission
request
which
the
tenant
admin
can
then
approve
or
reject.
A
So
this
part
is
done.
Next,
we
go
to
our
code
in
web
part.
We
want
to
be
able
to
call
the
API
using
the
ad
HTTP
client
and
the
first
step
towards
that
is
to
create
an
instance
of
client
that
is
tied
to
our
API,
because
when
you
think
of
it,
each
API.
The
way
it
works
is
that
it's
always
tied
to
a
resource
secured
with
a
ad
that
you
want
tax
right,
because
each
of
them
has
different.I
ID.
A
So
when
you
get
an
instance
of
a
ad
httpclient
use
specify
immediately
to
which
resource
it
is
tied
in
our
case
that
does
the
one
for
orders
and
when
you
repeat
the
instance
using
the
D
ad
HTTP
client
factory,
you
pass
in
the
ID
of
the
ad
app
for
which
you
want
to
have
access.
So
in
our
case,
the
zero
nine
see
a
before
good
matches
the
application
ID,
which
we
have
here-
zero
nine
cab4.
A
So
this
is
so
so
it's
not
the
object.
I
ID
is
the
app
I
I
ID,
which
we
see
here.
So
this
is
the
one
that
we
had
here
in
code
and
then,
when
we
obtain
the
instance,
we
started
in
variable
and
we
do
all
of
that
in
web
part
in
it,
so
that
everything
as
follows
already
has
the
access
to
the
a
client
and
then
eventually
when,
when
the
web
partlow's,
we
call
the
API
and
a
death
stage.
A
We
don't
need
to
worry
about
headers
redirect
URLs,
almost
all
the
almost
that
is
already
being
done
for
us.
So
at
this
stage
the
only
thing
that
we
have
to
do
is
to
call
to
issue
a
request
in
our
case,
get
to
the
endpoint
API
orders,
and
then
we
have
immediately
access
to
all
of
the
info
given
us
by
the
API.
A
A
A
No,
it
just
works
important
part
because
in
our
case
we
requested
an
API
permission
and
access.
We
see
the
warning
here,
yep
all
right,
so
this
makes
it
clear
to
the
admin
or
or
the
or
the
person
deploying
the
package
that
this
package
requests
access
to.
Ap
is,
and
they
should
at
least
review
it.
So
it
doesn't
say
you
need
to
approve
it,
no
review
it.
A
B
And
now
one
thing
to
notice
on
this
screen
is
also
stand
whenever
you
now
click
deploy
well,
let's
check
the
transcript
deployment
and
then
click
deploy.
This
webpart
is
immediately
available
in
Dimona
pages,
but
it's
not
yet
working
because
we
haven't
actually
granted
permissions.
So
from
a
timing
perspective,
whenever
you
are
deploying
this,
you
should
already
now
have
the
tenant
administrator
or
the
person
who
has
sufficient
amount
of
permission.
B
The
permissions
to
approve
the
permissions
already
waiting
for
you
so
or
you'll
be
the
same
person
and
you
will
give
an
approved
and
because
otherwise
infusers
might
be
highly
confused
on
hey.
What
is
this,
why
isn't
it
working
and
and
the
second
dimension
is
also
the
developers-
should
consider
the
fact
that
they
might
actually
not
have
two
permissions.
So
for
a
time
for
a
certain
time,
it
might
be
that
the
big
part
isn't
working
all.
B
A
Yeah
there
is
pending
approval
right,
so
here
we
can
see
that
that
matches
our
a
the
app
name,
permissions
that
we
included
as
well
and
in
here
it
says
pending
so
as
such,
we
can
either
approve
it
or
reject
that
and
for
the
sake
of
the
demo,
let's
approve
it,
because
otherwise
we're
gonna
be
able
to
show
how
it
works.
So
we
approve
it
and
then
the
interesting
part
here
is
that,
even
though
you
can
see
which
application
requested
it
once
it
is
approved
its
approved
to
every
single
script
running
in
your
tenant.
A
So
now
it
is
approved
and
I
guess.
The
last
step
left
is
to
add
the
web
part
to
the
page
and
see
that
it
actually
works,
and
then
we
can
actually
see
the
orders
coming
from
our
API.
So
here
I
am
on
order
page.
Let
me
edit
the
page
and
add
the
web
part.
Let
me
edit
here
there
should
be
a
web
part
named
orders
all
as
well.
It
is
here
and
it's
loading
orders.
It's
always
there
you
go.
These
are
orders.
A
Let
me
publish
the
page
and
let
me
show
you
the
network
tab
so
that
we
can
actually
see
their
requests
coming
through.
Let
me
refresh
the
page
and
now
when
we
will
filter
the
requests
URLs
like
API
orders,
there
you
go
right.
So
here
is
the
course
request,
because
this
is
a
cross
domain
call,
so
it
will
always
thought
first
with
course,
we
would
check
in
browser
whether
that
API
supports
cross
domain
calls.
If
you
didn't
enable
course,
it
would
fail
in
this
stage
and
you
wouldn't
be
able
to
call
anything.
A
B
A
So
here,
regarding
course,
if
you
go
to
functions
all
the
way
back,
all
the
way
back
here
is
additional.
So
if
you
go
to
platform
features,
my
settings
are
just
very,
very
good,
so
under
here
under
the
API
group,
there
is
course
Oh
option
and
in
here
in
our
case
we
allowed
all
origins,
meaning
any
domain
can
issue
a
client-side
call,
but
it
it
could
be
as
well
that
you
allow
only
your
domain
meaning
here
you
would
specify
entries,
5x,
Oh,
three,
five
or
forty
sure
point
calm,
yeah.
B
B
A
So
not
in
our
case,
what
you
can
see
here
is
a
get
request
to
our
API,
and
in
here
you
can
see
a
request,
headers
the
bearer
token
odd,
and
all
of
that,
if
you
think
about
it,
we
didn't
need
to
do
any
of
that
in
our
code.
The
only
thing
that
we
say
we
want
to
have
an
ad
HTTP
client
tied
to
this
aid
yep,
and
then
we
called
this
URL.
A
B
So
you
can
go
and
configure
the
settings
on
there,
but
this
really
opens
up
a
great
deal
of
additional
opportunities,
because
your
utter
api
could
use,
let's
say,
service,
bus
or
gateways
to
get
to
your
lob
data
in
on-premises.
If
needed,
then
there's
this
massive
amount
of
different
additional
opportunities
for
this
so
great
stuff.
Let's
move
back
on
the
slides
and
close
up
the
webcam
and
Thank
You
Moloch
for
that
one
cute
demo,
I'm
walking
through
the
different
scenarios
and
like
like
we
did
on
the
intro
to
them
as
a
relatively
simple
scenario.
B
A
A
Part
of
building
something
is
x5
on
its
every
single
time,
no
matter,
if
you
want
to
communicate
with
a
graph
or
SharePoint
or
anything
else,
you
first
need
to
authenticate
at
many,
and
many
people
find
that
a
challenging
part.
And
now
we
see
that
even
if
you
build
your
own
API,
you
want
to
secure
it
with
a
ad
and
it's
exactly
the
same
thing
before
you
can
use
an
API
and
everything
that
it
offers.
A
B
A
B
Can't
get
to
it,
I
need
to
do
doors,
so
this
is
really
an
abstracting.
The
complexity
of
the
classic,
a
doll
hunting,
a
dog
chase
hunting
and
everything
else
away
from
the
from
you.
So
you
can,
when
you're
writing
stuff
on
a
SharePoint
platform.
Well,
that's
typically
much
it
actually
does.
We
will
remove
the
complexity
on
underlying
plumbing.
That's
really
the
role
of
SharePoint
as
well.