►
From YouTube: MSI Open Demo. September 15, 2017
Description
Multi Source Inventory (MSI) Open demo - https://github.com/magento-engcom/msi/wiki
During the demo was discussed Magento Testing and how different kinds of testing (Unit, Integration, Static, Integrity, functional, Web API) applied for different tasks.
https://github.com/magento-engcom/magento2/wiki/How-to-create-Web-API-and-How-To-cover-them-with-Functional-Testing
Project Roadmap - https://github.com/magento-engcom/msi/wiki/MSI-Roadmap
A
A
Yeah,
so
during
the
current
week
we
were
walking
on
the
next
stories.
We
were
walking
on
an
implementing
right,
run
time,
calculation
of
stock
quantity,
taking
into
account
the
reservation
and
the
reservation
story
was
implemented
in
a
previous
print
and
another
activity
we
were
working
on
was
covering
with
Web
API
tests
already
existing
functionality
for
the
sources
and
stocks.
A
So
I
believe
that
our
today's
meeting,
we
will
spend
some
time
discussing
the
test
coverage
and
what
actually
functionality
in
the
scope
of
MSI
cover
it
with
automated
tests,
and
we
already
have
three
different
kind
of
tests
on
a
project.
You
need
integration
and
the
Web
API
test.
So
we
will
talk
what
kind
of
functionality
we
actually
cover
with
what
kind
of
testing,
and
why
do
we
do
it?
A
And
after
that,
we
we
discuss
our
progress
on
a
next
story
regarding
the
stock
quantity
in
population
and
if
there
would
be
any
open
question,
so
we
will
discuss
them.
So
don't
hesitate
to
to
ask
the
question,
or
maybe
have
some
general
question
not
related
to
to
the
current
meeting
agenda.
So
anything
regarding
the
multi-source
inventory
is
welcome.
So,
let's
go
to
the
to
the
source
code.
A
As
you
see
like,
maybe
you
remember
so
just
this
small
introduction
use
the
previous
sprint.
We
may
actually
fix
it
virtually
closed,
a
story
which
introduced
a
new
indication
mechanism
for
the
inventory
where
we
created
the
will
show
stock
items
based
on
a
linkage
rule.
So
we
have
the
physical
sources
and
we
have
a
will
shall
stop
and
we
provide
an
ability
of
assignment
of
the
physical
sources
to
this
mutual
stock.
A
So
we
created
a,
we
actually
implemented
that
story.
This
story
was
implemented
by
Lars
and
we
accepted
it,
but,
working
with
during
this
week,
working
with
that
code
and
making
some
kind
of
testing,
we
found
out
that
there
are
some
scenarios
which
need
to
be
covered
additionally
with
integration
tests.
So,
as
you
probably
know
in
Magento,
we
have
several
kind
of
testing.
Like
unit
testing,
and
we
ever
did
gates
folders
that,
where
all
the
unit
tests
allocate
this
integration
test.
A
A
So
actually
is
the
best
way
to
cover
the
initiation
process
is
integrational
testing
where
we
don't
mock
all
the
objects
which
he
used
for
some
particular
scenario,
but
all
real
objects
are
used,
so
it
was
pretty
interesting
bug.
I
can
find
it
whatever.
Maybe
you
can
record
me
in
the
scope
of
people
request
with
you?
We
deliver
it's
the
part
which
fixes
my
cycle.
Shuttle
error.
A
Yeah,
so
we
we
had
the
bug
and
actually
pretty
that
was
pretty
interesting
because
we
had
the
test.
The
test
was
called.
We
had
a
code
of
business
project,
the
code
of
business
logic
was
covered
this
test,
but
sometimes
we
we
actually
throw
a
fatal
error
and
actually
the
our
tests
were
green,
but
actually
the
cuddle
error
happened
and
this
kind
of
problems
could
be
76.
So
well.
Error
just
reminded
me
that
the
yeah
76.
A
So
I
wanted
to
show
you
this
particular
case.
It's
pretty
interesting
because
we
had
a
pretty
straightforward
error,
like
our
expression
here,
except
that
the
source
ID
should
be
provided,
but
we
actually
passed
a
list
of
ID's
and
because
we
you
know
unit
tests,
for
example,
we
mock
everything.
We
mock
this
situation
as
well,
so
we
can
find
as
a
real
problem
and
the
real
problem
could
be
revealed,
for
example,
pretty
easily
when
we
launch
this
particular
use
case
and
all
the
objects
would
be
real,
but
not
mocked
and
in
magenta.
A
You
can
accuse
this
with
the
integration
testing.
So
actually
these
code
should
be
rewritten
as
this
one
and
the
the
error
would
be
fixed
pretty
easily
so
returning
to
the
code.
So
what
we
did,
we
cover
it.
The
color
indexation
process
with
with
the
integration
test
and
actually
the
integration
test,
is
very
good
for
this
particular
situation
for
covering
indexation
because,
as
I
already
said
before,
there
are
no
explicit
ways
to
access
in
the
facial
mechanism
calling
the
API
services.
A
A
We
already
have
up
to
this
moment
with
the
integration
testing
and
now
I
am
stop
sharing
the
screen
and
the
gallery
will
run
all
the
testing,
all
the
integration
testing
and
after
that,
we
can
go
on
to
the
Web
API
testing,
which
provide
the
test
coverage
for
the
for
the
public
API
which,
which
is
a
part
of
our
service
layer.
So
so
I
am
stop
sharing
and
giving
a
word
to.
A
So
here,
at
the
beginning
of
the
test,
were
Larry's
showing
you
that
what
precise
case
is
covered
with
the
test.
So
here
we
have
the
some
particular
SQ
which
exists
in
european
source.
So
the
source,
as
you
already
know,
is
the
physical
physical
warehouse.
So
we
have
two
physical
warehouses
in
europe,
no,
not
even
two
but
for
physical
warehouses.
Heaven
names
like
EU
source,
well,
you
source
two
years
or
three
and
ile
source
for
and
we
have
covering
all
possible
situation.
A
So,
in
the
first
two
warehouses
we
have
the
quantity
like
five
five
and
a
half
like
if
it's
it's
several
years,
decimal
on
a
second
source.
We
have
the
integer
quantity
like
three
pieces
of
this
particular
item
in
the
short
source.
We
have
ten
items
of
this,
this
particular
item,
but
actually
they're
the
status
is
out
of
stock.
So
you
can't
actually
just
include
this
to
the
to
the
aggregation
and
the
force.
The
force
warehouse
has
also
ten
items
of
this
particular
product,
but
this
the
source
is
disabled.
B
A
So,
in
the
situation
of
the
global
stock,
we're
supposed
to
get
quantity
like
three
plus
five
and
a
half
and
end
up
with
eight
and
a
half,
and
we
should
cover
the
situations
that
we
no
need
to
take
into
account
out
of
stock
out
of
stock
product
and
disable
source.
So
this
is
this
is
made
in
the
scope
of
this
test.
So
you
can.
Could
you
please
scroll
a
little
bit
lower
because
integration
test
work
and
with
the
real
environment
we
need
to
reconfigure
our
environment?
A
That's
why
we
provide
the
data
features
and
each
of
the
data
feature
fools
to
reconfigure
and
pre
create
some
particular
entity.
For
example,
current
current
fixture
create
sources.
So,
as
you
already
heard,
we
have
that
for
physical
sources,
which
need
to
be
pre
created
to
test
out
our
business
logic,
and
actually
this
this
feature
create
these
physical
sources.
A
Yes,
you
can
return
to
the
integration
test
modularity
and
here
in
the
scope
of
the
integration
test.
So
each
of
the
feature
creates
some
particular
entities
and
we
make
that
separated
into
different
files
to
make
it
reusable.
So,
for
example,
as
you
can
see,
the
test
tree
index
row
uses
the
source
feature
and
the
same
feature
is
reused
in
the
text
tree
index
list.
So
potentially
this
fixture
could
be
used
in
other
integration.
Test
is
valid.
C
A
It's
it's
really
important
to
mention,
as
Lars
said
that,
because
we
are
actually
affecting
the
real
database
of
magenta
after
the
test
run,
we
need
to
clean
up
the
environment
after
our
changes
and
that's
why
we
actually
use
the
rollback
fixtures
so
as
well.
Error
now
open
a
listing
of
their
own
back
feature.
The
current
feature
actually
make
it
clean
up
of
all
the
of
all
this
talks,
which
will
pre-created
for
this
particular
test,
run.
B
B
A
So
it's
pretty
interesting
and
the
integration
test
is
really
it's
really
appropriate
mechanism
to
cover
the
indexation
logic.
Now
we
will
show
you
the
Web
API
test
because,
as
you
probably
know,
most
of
the
module
is
used
in
Magento
provide
the
service
interfaces
and
we
have
a
dedicated
module
to
improve
the
modularity
inventory
API
and
in
the
scope
of
that
API.
We
declare
there
in
DI
interfaces
and
here
in
the
left
side
of
the
screen,
you
see
all
the
possible
Web
API
test
and
validate
test
supposed
to
cover
these.
A
This
public
API
is-
and
this
is
very
important-
because
more
and
more
application
start
using
magenta
as
a
headless
magenta
and
in
the
case
of
using
headless
magenta
magenta
would
be
called
using
the
web
api
and
the
web
a
pair
would
be
used
as
a
transport
and
after
that
the
cool
will
come
up
to
some
particular
interface
from
the
service
contract.
So
each
of
these
public
interfaces
supposed
to
be
covered
with
with
the
Web
API
test.
B
A
A
So
we
have
two
modules:
the
first
one
provides
the
implementation
inventory
module
and
another
module
which
is
here
provides
the
API,
so
the
service
contract
for
the
inventory
module.
So
we
are
doing
that
to
improve
the
modularity.
That's
why
test
which
supposed
to
cover
the
public
interface,
a
storage
in
the
inventory
Bay
as
well,
so
you
can
see
a
test
folder
in
the
inventory
guy
and
this
folder,
we
placed
all
the
Web
API
test.
A
A
B
A
D
Just
got
thinking
about
it:
I
asked
roll
area
some
help
to
get
started
because
I
had
some
issues
with
my
with
this.
With
the
stock
index,
I
have
a
couple
of
questions
just
to
be
sure
that
I
took
the
right
path.
I,
don't
know.
If
you
want
me
to
ask
right
now,
or
we
can
can
talk
about
that
later.
Okay,.
D
So
we
have
this
aggregation.
That's
our
stock
index,
which
represents
the
number
of
items
that
can
that
are
available,
considering
all
the
sources
and
the
links
between
sources
and
stock,
but
actually
that's
not
the
real,
saleable
quantity,
because
we
also
have
to
take
into
consideration
the
reservations.
So
you
can
fill
me
that
the
index
will
only
want
to
contain
the
reservation
data,
but
the
reservation
data
will
be
calculated
at
from
time
through
CV
service.
D
A
D
This
service
I
have
two
to
use
the
index
table.
I
have
to
read
the
given
as
an
S
key
you
that
identifies
a
product
and
given
a
stock,
ID
I
have
to
read
from
the
corresponding
stock
index
the
quantity
of
44
the
debt
product,
which
already
is
the
sum
of
all
the
quantities
available.
Considering
all
the
linkage
sources
and
subtract
or
add
the
appended
reservation
for
that's
Q.
B
D
Basically,
and
I
also
will
try
to
cover
this
service
with
tests,
but
I
will
I
will
I
won't
do
it
test
driven
for
now,
because
I
need
to
be
more
in
comfort
zone
and
I
will
try
to
implement
it
and
then
in
case
cover
it
with
tests
and
in
case
of
need.
I
will
I
will
ask
for
some
help
to
you.
Okay,
yes,
I
will
work.
I
will
work
on
these
services
next
week.
Hope
and
I
hope
to
have
some
updates
for
next
meeting.
Okay.
D
A
So
it's
not
a
pretty
common
to
magenta,
because
we
decided
to
split
indexes
by
some
dimension
and,
in
our
case,
dimension,
increased
Oh
baby.
So
we
will
create
this
new
index
table
dynamically.
So
because,
particularly
we
can
create
some
additional
stock
in
an
admin
panel
and
for
that
stock
will
dynamically
create
index
table
for
most
of
other
indexes.
We
already
he'll
like
catalog
rule.
It's
like
product
syndicate,
cetera.
A
We
already
have
the
index
structure
is
pre
created,
but
what
we
want
to
achieve
is
this
dynamic
structure
that
we
want
to
improve
the
scalability
of
the
index,
so
that
would
be
an
ability
to
scale
our
data
among
several
tables
or
not
to
increase
a
lot
of
the
data
and
part
of
the
request
to
this
particular
table
and
have
a
patent
yeah
and
that's
why?
Because
we
have
a
dynamic
structure.
A
We
have
two
different
processes
like
creation,
the
table
and
the
chileans
the
table
with
data,
and
because
we
want
to
follow
the
CRS
and
the
single
responsibility.
We
actually
separate
these
processes
and
after
some
changes
in
your
code,
for
example,
after
you
created
some
assignment
between
the
source
and
the
stocks
actually
interesting
task,
and
the
Lars
was
working
on
the
task
at
the
beginning
of
this
week,
because
we
need
to
invalidate
several
several
index
dimensions
like
all.
A
The
stocks
should
be
invalidated
to
which
this
particular
source
is
assigned
to,
and
that's
why
actually
we
need
to
and
because
we
don't
want
to
introduce
the
performance
degradation
in
admin
panel,
because
in
admin
panel,
if
some
assignment
happened,
admin
just
need
to
get
this
like
this
is
assignments,
happen
and
and
defecate.
So
we
need
to
make
a
lot
of
calculation
make
there
his.
A
He
screamed.
Freeze.
Several
me
nerves
like
while
will
be
on
processing
its
request.
While
we
making
several
several
index
table,
recalculate
it
and
recreate
it.
So
we
don't
need
to
do
it.
We
need
to
segregate
our
responsibilities.
That's
why
all
we
do
is
just
invalidate
the
index
and
another
process
will
actually
make
all
the
invalidation.
That's
why
we
have
like
well,
you're,
probably
told
you
that
we
have
a
dedicated
process
which
will
create
tables
and
another
process
which
we,
which
will
peel
data
for
this
indexes,
so
it
yeah
it
could
be.
A
C
See
a
second
problem
on
on
this
course.
It's
could
be
happen
that
I
use
temporarily
table
if
food
index
is
required
for
it,
and
you
must
also
think
about
it
to
use
temporary
tables,
sometimes
for
some
products,
because
we
build
at
ember
temp
table
for
some
for
for
big
merchants.
You
have
many
products
of
many
source
language
and
many
quantity.
It
can
be
possible
that
in
the
old
table
it's
the
data
are
not
correct
and
the
new
data
is
already
written
in
the
new
indexing
table.
B
A
So
what
so?
What
Lars
mentioned
that
we
need
to
make
like
all
the
indexation
process
should
happen
in
a
temporary
table
to
make
it
sure
that
we
have
the
correct
data
and,
at
the
end
of
the
index
process,
just
to
make
a
switch
of
the
temp
from
the
temporary
table
to
the
real
one,
to
make
sure
that
we
didn't
build
the
incorrect
index
and
not
substitute
the
correct
but
outdated
index
with
incorrect
or
inconsistent
data.
Am
I
correct.
Worse.
C
A
Yeah,
so
the
solutions
for
actually
this
is
what
we
do.
Actually
that's
what
we
do,
because
we
we
are
support
in
the
zero
downtime.
That's
why
we
create
a
new
index
in
a
new
table
and
after
the
after
the
indexation
is
finished,
we
just
dropped
all
index
and
renames
a
newly
created
index
into
the
into
the
names
of
the
previous
one,
so
we
always
have
the
name
which
should
be
reachable
from
the
code
of
the
business
project.
A
For
example,
we
have
the
stock
item
underscore
one,
and
the
wall
is
the
idea
of
this
dot,
so
the
stock
eye
them
underscore.
One
is
the
name
of
the
index
we
have
in
our
database
and
if
we
have
an
invalidation,
we
create
a
temple
table.
Temporary
table
which
is
called
like
stock
item
underscore
one
underscore
TMP
and
after
we
finish
the
indexation,
we
actually
draw
stock
item
underscore
one
and
make
a
renaming
of
the
stock
item
underscore
one
underscore
team
P
into
stock
item
underscore
one,
so
everything
happened
in
the
Greek
operation.
A
A
Good
question-
and
we
need
to
this
is
possible,
but
we
need
to
try
to
escape
from
such
situation,
because
that
this
situation
could
happen
if
we
have
cross
dependent
data.
If
we
have
like
circular
dependencies
between,
like
one
dimension,
is
relied
on
on
another
dimension.
So
when
we
have
a
calculation
of
quantity
and
that
quantity
depends
on
another
index,
for
example,
that
something
like
that,
so
we
need
to
try
to
escape
the
situation
and
if
we
will
get
it,
it
will
say
about
the
architectural
problems.
A
So
something
like
that
we
already
have
with
with
the
full-text
search
ended,
because
our
full-text
search
ended
actually
dependent
on
several
other
indexes,
for
example,
full-text
search
index
supposed
to
be
stored
in
elastic
search
and
because,
for
example,
for
the
layered
navigation,
we
need
price.
We
have
a
dependency
on
a
price
index,
so
we
already
need
a
price
data.
Pre
calculated
before
this
full
text
index
would
be
would
be
run.
Also.
A
We
have
dependency
on
a
on
a
stock
status
so
on
the
inventory
index,
because
out
of
out
of
stock
products
should
be
removed
from
the
search
result
list.
So
the
full
text
search
index
has
a
dependency
on
several
other
indexes
and
this
actually
introduced
some
problems
there.
So
what
we
are,
what
we
are
trying
to
do
in
our
you
know
approach
for
the
MSI
indexation.
All
the
dimensions
are
not
crossed
related
to
each
other,
so
we
don't
don't
have
these
dependencies
amongst
the
dimensions.
D
Just
another
question:
if
I
can
yeah,
of
course,
I
have
to
I
have
to
result
index
table
name
and
run.
Error
should
meet
that
I
have
to
use
a
resolver
that
even
the
index
name
gives
gives
me
back
the
table,
the
corresponding
table.
Name.
Yes,
but
since
we
have
dimensions,
I'm
I
wonder
once
I
have
the
table
name
of
stroke
item
index
to
me,
that's
some
sort
of
prefix
I
have
to
I
have
to
obtain
the
suffix
of
the
dimension.
That's
the
stock
ID
I'm,
I'm
searching
for
so.
D
I,
don't
think
that
this
is
done
by
the
index
resolver,
because
I,
don't
I,
don't
see
that
the
industrious
overtakes,
also
the
stock
ideas
parameter.
So
it's
something
that
has
to
be
done
after
this
and
I'm
wondering
if
we
maybe
should
have
to
implement
a
specific
resolver
for
the
stock
item
index
tables
that
maybe
even
given
the
stock
ID
gives
us
back
the
correct
table
name
or
maybe.
A
A
A
A
Yeah,
it
should
be
here
so
what
we
already
implement
it.
So
here
on
this
diagram,
we
have
the
main
entities
both
for
the
new
inventory
and
we
already
implemented
source
source
item
stock
stock
item
and
the
linkage
of
the
sources
which
provide
an
ability
to
assign
sources
to
stops.
But
what
we
did
not
implement.
A
We
did
not
implement
an
ability
to
assign
stops
to
sales
channel,
so
we
will
have
some
some
resolver,
which
would
be
introduced
at
the
level
of
the
service
contract
and
the
level
of
the
API,
which
will
provide
an
ability
to
resolve
the
current
current
current
stock
by
the
sales
channel,
for
example,
providing
the
website
ID.
We
will
need
to
get
the
stock
assigned
to
this
to
this
sales
channel
so
because
we
are
going
to
provide
an
ability
to
assign
stocks
to
to
websites.
A
So
we
will
have
this
particular
resolver,
which
will
resolve
the
stop
by
sales
channel
and
also
will
have
another
another
resolver
at
the
another
level
of
abstraction.
So
it
would
be
more
more
technical
base.
It
would
not
be
part
of
the
API.
It
would
be
implemented
pretty
deep
in
the
code
where
actually
we
need
to
retrieve
the
table,
we
want
to
access
so
and
that
resolver
we
will
retrieve
the
table
name
by
by
stock.
A
As
you
see
the
resolver
stored
in
it
under
the
indexer
names,
namespace,
actually
I
believe
we
need
to
put
it
into
another
namespace,
because
I
believe
Alessandra
need
to
use
this
result
itself.
So
probably
it
would
be
wrong
for
him
to
access
the
indexer
mechanism,
because
this
is
older,
has
nothing
so
indexation
is.
One
is
just
one
of
the
possibility
where
this
resolver
could
be
used.
So
probably
we
need
to
move
it
under
another
name
space,
but
the
implementation
of
this
is
over
yeah.
D
A
B
D
D
Do
you
see
me,
do
you
see
my
screen?
Yes,
okay
after
this
is
the
concrete
implementation
that
that
actually
has
still
to
be
done
of
the
execute
method
of
the
get
product
quantities
of
service
I
have
the
as
parameter
of
the
this
method:
I've
this
SKU
and
the
stock
ID,
and
now
what
I
have
to
do.
It
is
probably
to
retrieve
first
of
all
how
many
I
have
to
retreat
the
quantity
of
this
product
or
the
product
identified
by
the
SKU
in
the
given
stock.
D
So
here
what
what
I
need
is
to
retrieve
the
correct
name
to
resolve
the
index
name
for
the
correct
dimension
that
corresponds
to
the
stock
ID
as
far
as
I
understood
mm-hmm.
So
this
is
my
this
is.
This
is
where
I'm
I
need
to
understand
how
to
unit
the
correct
name
for
the
table,
provided
her
I
have
the
stock
ID
I
I
noted
today
the
index
name,
the
the
index
name
is
inventory
stock
item,
so
I
index
name
is
in.
D
Stock
item
and
if
we
ask
to
the
resolver
to
give
me
that
the
corresponding
table
name
of
inventory
stock
item
index
shouldn't
I,
provide
also
a
stock
ID
in
order
for
the
resolver
to
give
me
the
right
table-
or
maybe
this
is
too
low,
level
and
I
have
to
work
on
a
higher
level
with
other
kind
of
result.
This
is
basically
my
Congress,
so
yeah
I.
A
D
D
Because
the
stock,
this
is,
is
really
a
question.
I,
don't
know
the
stock
is
something
that's
really
it's
low
level.
What
we
will
have
in
the
future
will
be
the
sales
channel
that
will
be
linked
to
the
stock,
so
I
wonder
if
a
proper
API
should
should
be
get
product
quantity
in
channel
rather
than
in
stock
yeah.
A
B
A
We
it's
kind
of
a
leaky
abstraction
that
we
show
that
we
get
for
all
a
quantity
from
stock,
because
you
know
more
absolutely
correct
that
API
during
the
checkout
process
and
at
the
time
of
checkout
process,
we
will
work
in
some
part
in
the
scope
of
some
particular
sales
channel.
So
we
are
interested.
How
many
of
particular
s
q
would
be
could
be
sold
in
the
scope
of
this
particular
sales
channel,
but
not
in
the
scope
of
particular
stock.
D
B
D
Given
a
channel
I
can
derive
the
right
stock
and
I
can
I
can
from
the
stock
again
I
can
get
the
right
index
table
and
so
on.
Okay,
this
was
only
just
the
confirmation
that
there
is
no
problem
at
the
moment
for
me,
since
we
don't
have
the
the
sales
channel
part
implemented.
For
me,
it's
okay
to
go
on
with
this
stock
abstraction.
Then
we
will.
We
will
probably
change
that
in
the
future,
but
actually.
A
A
A
So
you
as
so
your
function,
receives
the
stock
ID
and
okay,
so
I
have
to
use
the
index
name
builder.
Okay,
you
can
use
the
index
name
builder.
Your
nutrition
is
pretty
pretty
valid.
Whether
this
is
if
this
level
abstraction
is
good
enough
to
use
in
there
in
the
API
implementation,
or
is
it
really
low
level?
As
for
me,
it
is
probably
good
enough,
so
we
are
not
not
accessing
the
some
particular
stable
level,
so
we're
relying
on
on
interface
provided
a
little
bit
lower
level.
C
C
They
have
one
one
parameter:
stock,
ID
and
the
second
parameter
can
be
the
IES,
and
this
return
the
name.
It's
only
modern
rapper,
but
it's
easier
to
change,
because
now
we
have
different
different
yeah
classes
that
used
in
DEXA
and
hopefully
it
will
be
changed
in
the
future.
But
if
it
didn't
change,
we
must
reflect
the
every
name
builder
and
it
can
be-
and
it's
not
so
much
logic
in
this
disrepair
class,
but
it
can
be
helpful
for
the
future.
A
The
biggest
the
biggest
concern
I
have
that,
actually
you
know
we
are
contributing
to
the
magenta
core,
so
all
the
indexation
logic
should
be
aligned
with
the
naming
convention
with
help
in
our
core
and
for
now
currently
we
can
change
the
name
in
further
indexes,
because
in
our
case
in
this
table
in
the
table
index
name
represents
the
api's,
so
short
party
developers
could
use
them
for
joining
mechanisms.
For
example,
that's
why
we
can
just
change
the
name
of
the
index
table
and
in
our
case
and
actually
imagined
magenta
to
do
to
release.
A
It
was
agreed
that
we,
this
one
erican,
can
open
alia
phileas
main
so
the
naming
convention
introduced
was
used,
name,
replica
and
the
main
and
what
we
actually
have.
We
have
the
replica
prefix
for
for
for
index
table.
That's
why
we
need
to
keep
this
name
in
conversion
in
how
our
indexes
as
well
so,
for
example,
like
if
they
have
a
particular
index,
which
is
called
stock
item,
underscore
one
where
one
represents
the
stock
ID.
A
So
this
is
this:
is
the
index
table
for
the
stock
one?
The
indexation
mechanism?
We
will
create
a
table
temporary
table,
which
name
would
be
stock
item
underscore
one
underscore
replica,
and
actually
this
naming
convention
is
dictated
by
the
magenta
to
code
practices
and
agreement.
So
we
are
not
allowed
to
change
the
name
in
conversion
for
some
particular
index.
We
should
be
consistent
to
with
existing
approaches
and
with
existing
name
in
conversion.
We
have
four
other
indexes
in
magenta.
A
C
There
easily
yeah,
but
you
don't
understand
my
point
or
my
my
what
I
mean
I
mean
a
rack
last,
the
only
one
parameter
that
returned
the
correct
name
for
API
for
the
index
s
out
it's
it's
only.
A
wrapper
in
in
this
class
is
only
read.
This
return
function
and
the
AES
wrapped
and
then
Alexandro
can
be
used
easier,
but
actually.
A
C
It's
it's
only
my
main
point
in
this
class
is
we
have
a
resolver
a
resolved
stock
index
ax
or
resource
stock
index,
our
name
and
this
index
name.
Resolver
has
one
parameter
in
the
execute
function,
stock,
ID
and
learn
the
correct
name
for
for
this?
It's
not
many
logic.
It's
only
a
wrapper,
it's
easier
and
then
Alexander
doesn't
need
to
have
own
index
name
builder
and
mass.
A
D
Think
suggesting
is
to
create
a
service
class
that
takes
as
parameter
the
next
name
and
the
stock
ID
and
basically
water
between
rows,
82
and
86
can
be
that
basically,
the
Builder
wrapper.
Yes,
we
can.
We
can
postpone
this
this
this
decision.
We
can
think
about
it
more
careful
at
the
moment.
I
can
use
this
example
into
a
my
to
have
my
index
name
properly
built.
Then
we
can
consider,
if
builder
is
it's
too
low
level
or,
and
we
create
something
more.
D
B
C
Me
also
fun
I,
starting
with
my
mind
task.
Hopefully,
I
think
you
stay
and
I'm.
Also
thinking
about
written,
more
tests
at
its
required
I
will
ask
you
and
which
test
cases
can
be
helpful
to
cover
it
or
its.
But
first
I
must
start
with
implementation
and
then
I
can
thinking
about
which
problems
can
we
have
or
how
ok.
A
So
if
you
will
work
on
any
contribution
for
in
the
side
during
the
during
the
sunday,
you
can
you
can
pink
me
over
Larry,
so
whatever
it
would
be
at
that
event,
I
would
be
in
queue,
but
I
be
online,
so
you
can
participate
and
we
would
be
reachable
during
the
cool
Sunday.
We
can
provide
your
assistance
to
you.
So
thank
you.
A
A
So
in
our
project
we
had
we
had
a
problem.
We
start
with
when
when
Alessandra
was
working
on
a
previous
story
devoted
for
the
reservation
mechanism-
and
we
found
out
that
current
implementation
of
the
validation
exception
introduce
some
errors
and
actually
it
violates
the
design
principle.
We
have
a
March
enter.
So
it's
a
violated
for
main
principle
behave
because
there
was
a
business
logic
in
the
constructor
and
our
constructor
should
be
free
of
business
logic.
A
A
C
A
Exception
looks
like
this
one,
so
we
have
just
a
family-owned
constructor
and
we
still
have
gatherers
methods.
So
what
we
did
to
a
complete
this.
We
introduced
the
aggregate
exception
interface
and
because
a
problem
was
that
we
had
to
inherit
from
the
aggregate
abstract
aggregate
exception.
So
we
solved
our
problems,
eliminating
that
inheritance
and
to
to
make
it
in
a
backward
compatible
way.
We
introduced
aggregate
exception
interface.
We
had
to
do
it
to
not
break
our
big
guys.
A
So
actually
the
main
problems
for
us
was
the
Web
API
framework,
which
gets
the
errors
and
brought
them
into
the
response
which
should
be
returned
to
the
client.
So
we
did
it
introducing
this
interface.
So
if
you
are
interested
me,
you
can
see
the
details
of
the
9200
request
in
the
scope
of
which
is
in
scope
of
which
actually,
the
issue
has
been
fixed.
D
A
Okay,
guys
so
looks
like
if
nobody
that's
other
question.
We
can
probably
finish
this
meeting
as
for
me
it
was
pretty
productive.
We
discussed
quite
a
lot
of
things
and
I
will
upload
recording
to
the
YouTube
channel
and
provide
you
leave
as
soon
as
as
I
can
and
the
sense
for
attendance
hope
to
see
you
soon
and
if
you
have
any
other
question,
you
are
free
to
ping
me
over
there
or
anybody
else
in
chat
and
by
the
way,
maybe
actually
for
the
upcoming
contribution
day.