►
From YouTube: Magento MSI Open Demo. March 16, 2018
Description
This time we would like to show you working:
- Shopping Cart adapted for Multi-Source
- Front-end checkout on non-Default Stock (Custom Stock Europe)
- All the Shopping cart/checkout validations
A
A
Alessandra
will
also
describe
some
describe
what
we've
done
from
the
technical
perspective
and
from
the
architectural
point
of
view,
but
I
will
initially
I
will
show
you
what
exactly
we've
done
and
how
it
could
be
reproduced
and
in
front-
and
probably
you
remember
the
previous
time,
we'll
show
you
the
Ford
replacement
on
a
on
a
back
end
and
the
ability
to
make
a
sort
deduction
from
different
sources.
So,
in
the
scope
of
today's
demo
session,
we'll
show
you
how
we
adopted
the
shopping
cart,
it
was
done
in
the
scope
of
the
epoch.
A
You
you
you're
able
to
see
on
my
screen
and
also
we
after
the
adaptation
of
the
shopping
cart.
We
make
it
possible
to
make
a
checkout
on
the
front,
end
ether,
so
now
it's
possible
to
place
both
on
back
end
and
on
a
front
end
and
a
long
visit.
We
added
a
lot
of
additional
checks
which
introduced
by
the
shopping,
cart
and
checkout.
So
let
me
start
the
demonstration
so,
first
of
all,
first
of
all,
it's
a
fresh
page
I
believe
my
session
already
expired.
A
No,
so
we
you
know
precondition,
we
have
a
test.
Simple
product
testing
book
product
has
has
next
quantities
from
different
sources,
the
most
interesting
for
us,
the
Poland
and
the
Ukrainian
sources.
These
sources
are
assigned
to
European
stock,
so
you
can
see
that
on
both
of
their
warehouses,
Ukrainian,
either
Ukrainian
or
Poland.
We
have
100
items
of
particular
sq
and
the
totally
all
together
we
have
200
items
available
for
sell.
A
We
can
see
that
product
on
a
front
end.
It
will
refresh
that
page.
You
see
that
it
would
be
in
stock,
and
now
we
can
start,
we
can
place
an
order.
So,
let's
edit
the
cart,
let's
see
that
we
currently
we
have
one
item
of
that
product
in
the
cart
and
we
can
update
the
quantity
to
5.
For
example,
it's
not
a
problem
and
the
quantity
is
updated.
Now,
let's
add
some
tricky
stuff.
A
Let's
open
advanced
inventory
and
update,
for
example,
for
example,
minimal
quantity,
a
lot
in
shopping
cart,
so
let's
say
that
we
allow
to
sell
no
less
than
10
items
of
particular
particular
product
by
the
way,
it's
very
important
to
say
here
that
we
are
showing
the
demo
not
on
a
default
stock
but
but
on
a
European
stock,
so
it
so
it's
already
multi
stock
system.
I
can
I
can.
B
A
A
Let's
save
less
per
see
this
change
and
and
the
returned
to
to
all
a
mini
shopping,
cart
and,
for
example,
let's
update
5
to
7
update
and
we
see
here
the
attention
the
requested
quantity
Islam
is
less
than
the
minimum
quantity
about
in
shopping
cart.
If
you
try
to
update
it
to
11,
for
example,
we
can
do
so.
A
Let's
let's
proceed
further
and
see
what
other
limitation
of
shopping
cart
has
been
implemented.
For
example,
there
is
a
possibility
to
to
establish
the
out
of
stock
threshold,
so
this
option
actually
responsible
for
so
this
is
the
threshold
below
which
we
can.
We
can
sell
so
heaven
this
option
merchant
will
be
guaranteed
that
will
preserve
this
amount
of
products
on
his
warehouse.
So
let's
say
that
our
out
of
stock
threshold
is
100.
So
remember,
currently
you
know
stop.
We
have
200
items
available
for
sell.
A
A
A
A
And
here
it's
pretty
interesting
stuff
that
at
the
time
of
order
placement
we
also
have
validation,
but
this
validation
is
little
bit
different
because
we
have
two
different
two
different
chains
of
or
pipelines.
You
can
even
call
it
that
way
either
and,
for
example-
and
we
have
a
different
way,
so
you
will
see,
for
example,
in
our
code
base,
we
see
one
validation
mechanism
for
add-to-cart
processing
and
another
validation
mechanism
for
our
code,
for
example.
A
Actually,
the
main
difference
here
that
we
don't
have
this
particular
step,
and
this
particular
step
responsible
for
quote
validation,
for
example,
for
mean
saleable
quantity,
from
a
saleable
quantity
and
the
other
stuff.
So
we
don't
have
this
validation
for
checkout,
but
we
have
the
same
validation
for
adding
products
and
manipulation
with
a
shopping,
cart.
A
So,
let's
go
straight
to
the
shipment,
launch
the
priority
based
algorithm,
and
currently
we
see
that
we
have
Poland,
Ukraine
and
because
Poland
is
more
pollen.
Warehouse
has
more
priority
than
Ukrainian
one
we're
going
to
make
a
deduction
from
Poland.
Only
of
course
we
can
make
the
Czech.
We
can
change
that
and
apply
changes
to
both
of
warehouses
and
make
a
deduction
from
Ukrainian
one
either
and.
A
A
A
B
A
A
So
now
it's
better
now
it's
better
and
let's
try
again
to
put
188
items
into
the
basket.
Yet
now
it
works.
So
we
need
to
discover
when
we
have
that
failure
with
compensation
reservation
at
the
time
when
we
have
failure
on
what
validation.
So
now
we
put
all
the
available
items
into
the
basket
and
now,
let's
proceed
to
checkout.
A
A
B
A
A
B
B
A
A
D
A
Yeah
the
problem
was
in
cash.
So
still
we
have
this
item.
It
was
not
part
of
this
story,
cache
invalidation,
so
the
product
was
out
of
store.
Now
after
we
purchase
all
the
items.
So
now,
let's
return
to
the
product
configuration
and
let's
switch
the
book
holders
so
switch
on
the
quarters
and
say
that
we
allow
quantity
below
zero.
B
A
B
B
A
A
So,
just
just
to
save
the
time
and
actually
we'll
use
the
time
while
the
page
is
rewarding
because
of
the
cache
invalidation
and
we
didn't
have
an
ability
to
make
a
cache
form
up
so
actually
like
we
implemented
most
of
the
most
of
the
check
we
have
so
you
see
that
product
return
to
stop,
because
currently
we
have
the
backorder
in
this
product.
So
what
we've
actually
done?
We
were
implemented
most
of
the
advanced
inventory
configuration,
so
we
currently
will
follow
to
manage
stock.
We
support
the
out
of
stock
stress
called
in
shorting
cards.
A
We
support
minimal
minimum
quantity
about
in
shopping,
cart,
maximum
quantity,
evolving
shopping
cart.
Also,
we
use
will
support
back
orders.
We
and
also
we
enable
quantity
increments,
so
the
quantity
increment
functionality
is
also
supported.
So
and
this
all
works
for
shopping
cart
and
for
checkout
we
actually
we
have.
We
don't
have
this
particular
checks,
but
we
have
checked
it.
We
have
enough
products
in
our
stock
to
fulfill
that
order.
So
we
have
like
a
two
different
two
different
validation
chains,
but
all
of
them
are
combined
in
one
service.
E
We
realized
that
we
missed
something,
because
until
now
we
we
used
the
legacy
stock
configuration
and
we
all.
We
only
read
the
legacy
store
configuration
through
a
dedicated
service
which
is
called
get
stock
item
configuration.
But
during
writing
the
test
realized
that
we
need
also
the
ability
to
change
this
configuration
to
test
all
possible
combinations.
So
we
introduced
this
new
service
that
is
safe,
so
item
configuration
and
through
this,
through
this
service,
we
are
able
to
change
to
save
utterly
the
stock
configuration
for
a
specific
stock
ID.
B
A
Ok,
I
can
share
my
screen
and
so
pretty
interesting
stuff,
which
I
would
like
to
attract
attention
to.
So.
First
of
all,
I
would
like
to
show
you
that
we've
finally
implemented
this
in
which
we
wanted
to
implement
for
quite
a
long
time.
So
we
probably
know
that
you
know
legacy
stock
item
interface,
actually
legacy
stock
item
interface
contains
both
stock
data,
so
it
has
quantity
and
the
stock
availability
as
well
as
all
the
configuration
we
have.
So
in
MSI
we
finally
decouple
the
stock
configuration
out
of
stock
availability
and
quantity.
A
That's
why
in
MSI
we
have
dedicated
interfaith
for
configuration
and
dedicated
interface
for
for
stock
availability.
Now
you
can,
you
have
an
urgent,
have
an
ability,
trust
to
import
and
export
just
took
data
and
the
changed
configuration
via
dedicated
interface
presented
by
alessandra,
so
the
configuration
interface.
A
Currently,
we
have
here
and
also
it's
very
interesting,
to
see
that,
for
example,
in
our
legacy
system,
we
have
some
like
dogs,
state
interface,
and
we
had
two
different
method:
the
one
which
was
used
for
shopping,
cart,
check
and
another
one
which
was
used
for
for
making
a
check
whether
we
have
enough
product
at
the
time
of
order,
placement
and
the
time
of
check
out
so
two
different
methods
for
a
pretty
pretty
similar
scene
and
actually
what
we've
done.
In
MSI,
we
introduced
the
only
service
which
is
used
in
both
cases.
A
The
name
of
the
service
is
product
saleable
for
requested
quantity,
and
it's
pretty
interesting
how
we
configure
it
it.
So
we
have
two
different
configuration
for
shopping,
cart
and
another
configuration
for
checkout,
so,
instead
of
instead
of
heaven
to
services
which
are
pretty
pretty
close
or
guardians
of
functionality,
which
would
be
done
regarding
the
check
which
would
be
which
would
be
applied
because
some
most
of
the
checks,
as
you
can
see
like
backorder,
was
whether
stock
management
is
applied
so
they're
pretty
similar.
So
we
don't
duplicate
that
functionality.
D
Would
like
one
request
from
me,
I
think
developers
should
be
in
Shh.
You
should
back
that
request.
This
interfaces
are
fairly
important
to
understand
how
Magento
processes
order
it's
right
now
or
how
you
add
items.
Have
you
buy
items
and
keep
them
individual
types?
It
might
be
inconvenient
as
special
for
people
who
are
new
to
magenta.
A
D
D
D
Figure
types
and
and
are
very
flexible,
but
the
problem
with
each
cell
type
see
that
they
are
stored
in
XML
and
you
have
to
find
them.
And
if
you
just
look
at
the
code
and
most
PHP
developers
when
the
open
code,
they
look
at
the
code
and
even
experience
be
Magento
developers
often
forget
about
virtual
pipes
in
XML,
and
virtual
paths
can
be
a
surprising
thing,
often
for
them.
A
D
Times,
instead
of
creating
a
virtual
pipe,
create
two
physical
types,
physical
process,
you
can
extend
them
from
that
implementation.
It's
not
a
big
deal
because
it
will
not
be
inheriting
behavior.
You
will
be
only
overriding
in
decoration
right,
so
you
can
even
keep
the
absolutely
same
configuration
in
XML
files
for
configuring
those
classes,
but
those
classes
will
be
present
on
present
on
the
system
and
it
will
be
easier
to
navigate
and
see.
It
will
be
clearly
like
developer.
Who
will
navigate
the
code.
D
They
will
clearly
see
that
those
are
two
different
interfaces
because
their
behavior
and
they
implement
a
behavior
of
those
two
instances
in
two
different
clients
is
different
right,
but
they
are
presented
by
single
interface,
but
in
code-
and
it's
this
is
a
simple
problem
with
semantics
of
PHP
that
it
doesn't.
It
gives
you
very
little
mechanisms
to
to
express
behavioral
difference
between
instances
of
same
interface
right.
D
So
the
only
thing
you
can
do
is
have
two
separate
sub
classes,
marking
interfaces
or
virtual
types
in
magenta
and
usual
parts
for
that
I
hope,
I'm,
arguing,
yes,
virtual
types
of
a
power,
powerful
mechanism,
but
I
see
that
a
lot
of
developers
are
not
very
comfortable
with
them
and
yeah
most
of
developers
are
not
very
comfortable
with
them.
Especially
there
is
a
lot
of
virtual
types,
so
we
can
use
virtual
types,
but
it's
better
not
to
use
them
for
very
important
object.
D
A
A
Currently
we
need
I
can
I
can
say
it
for
sure
I
believe
it
would
be
next.
Our
presentation
where
we
will
show
how
we
place
an
order
for
a
configurable
product
and
how
we
make
the
duction
for
them.
But
currently
we
we
unblock
functionality
of
shopping
cart.
Our
shopping
cart,
support
most
of
the
validation
we
have
and
we
have
an
ability
to
place
order,
button
front
end
and
on
a
back
end.