Package com.broadleafcommerce.inventory.service

Class DefaultSkuInventoryAdjustmentService<I extends SkuInventory>

java.lang.Object

com.broadleafcommerce.inventory.service.DefaultSkuInventoryAdjustmentService<I>

All Implemented Interfaces:

SkuInventoryAdjustmentService<I>

@Transactional(transactionManager="inventoryTransactionManager",
               rollbackFor={InventoryUnavailableException.class,InventoryNotReservedException.class},
               propagation=REQUIRES_NEW)
public class DefaultSkuInventoryAdjustmentService<I extends SkuInventory>
extends Object
implements SkuInventoryAdjustmentService<I>

This component is responsible for reading, locking, and adjusting SkuInventory records, as well as for creating hard and soft inventory reservations. This component is also responsible for other types of InventoryTransactionTypes and for the adjustment of SkuInventory records for those as well.

Author:

Kelly Tisdell (ktisdell)

Constructor Summary

Constructors

Constructor

Description

DefaultSkuInventoryAdjustmentService(SkuInventoryRepository<com.broadleafcommerce.data.tracking.core.Trackable> skuInventoryRepository, InventoryTransactionService<InventoryTransaction> inventoryTransactionService, com.broadleafcommerce.data.tracking.core.mapping.DomainMapperManager domainMapperManager, com.broadleafcommerce.data.tracking.core.mapping.validation.EntityValidatorManager validator, com.broadleafcommerce.common.extension.TypeFactory typeFactory, StockChangeNotificationService stockChangeNotificationService)

Method Summary

Modifier and Type	Method	Description
protected InventoryTransaction	buildInventoryTransaction(int quantity, InventoryTransactionType type, String reference, String skuInventoryId, String batchId, Instant dateProcessed)
protected int	calculateQuantityAvailable(SkuInventory inventory)
List<InventoryTransaction>	cancelInventory(Map<I,List<SkuInventoryAdjustmentRequestItem>> skuInventoryAdjustmentRequestItems, String batchId, com.broadleafcommerce.data.tracking.core.context.ContextInfo contextInfo)	Perform the cancel of inventory to remove reserved quantity.
protected Stream<I>	convertSkuInventoryFromPersistentDomain(Iterable<com.broadleafcommerce.data.tracking.core.Trackable> iterable, com.broadleafcommerce.data.tracking.core.context.ContextInfo contextInfo)
protected InventoryTransaction	createCancelledTransaction(@NonNull SkuInventory inventory, int quantity, @NonNull String referenceNumber, @NonNull String batchId)	Builds a cancelled InventoryTransaction and adjusts the SkuInventory quantities.
protected InventoryTransaction	createFulfilledTransaction(@NonNull SkuInventory inventory, int quantity, @NonNull String referenceNumber, @NonNull String batchId)	Builds a fulfilled InventoryTransaction and adjusts the SkuInventory quantities.
protected InventoryTransaction	createHardReservation(@NonNull SkuInventory inventory, InventoryTransaction softTransaction, @NonNull Integer quantityRequested, @NonNull String referenceNumber, @NonNull String batchId, com.broadleafcommerce.data.tracking.core.context.ContextInfo contextInfo)	Hard inventory reservation.
List<InventoryTransaction>	createHardReservations(Map<I,List<SkuInventoryAdjustmentRequestItem>> skuInventoryReservationRequestItems, String batchId, com.broadleafcommerce.data.tracking.core.context.ContextInfo contextInfo)	Hard reservations that represent final inventory reservations.
protected InventoryTransaction	createReturnedTransaction(@NonNull SkuInventory inventory, int quantity, @NonNull String referenceNumber, @NonNull String batchId)	Builds a returned InventoryTransaction and adjusts the SkuInventory quantities.
protected InventoryTransaction	createSoftReservation(@NonNull SkuInventory inventory, @NonNull Integer quantityRequested, @NonNull String referenceNumber, @NonNull String batchId, com.broadleafcommerce.data.tracking.core.context.ContextInfo contextInfo)	Soft inventory reservation.
List<InventoryTransaction>	createSoftReservations(Map<I,List<SkuInventoryAdjustmentRequestItem>> skuInventoryReservationRequestItems, String batchId, com.broadleafcommerce.data.tracking.core.context.ContextInfo contextInfo)	Soft reservations that represent temporary inventory reservations.
List<InventoryTransaction>	createSoftReservations(Map<I,List<SkuInventoryAdjustmentRequestItem>> skuInventoryReservationRequestItems, Map<String,List<InventoryTransaction>> existingSoftReservationsByReference, String batchId, com.broadleafcommerce.data.tracking.core.context.ContextInfo contextInfo)	Soft reservations that represent temporary inventory reservations.
protected void	deleteInventoryTransaction(InventoryTransaction transaction, com.broadleafcommerce.data.tracking.core.context.ContextInfo contextInfo)	Convenience method for deleting (archiving) an inventory transaction.
protected InventoryTransaction	freeSoftReservationQuantity(InventoryTransaction softReservation, SkuInventory skuInventory)	Adjusts the SKU inventory quantities to reflect a soft inventory reservation being released (back to the available pool).
void	freeSoftReservations(List<InventoryTransaction> softReservations, com.broadleafcommerce.data.tracking.core.context.ContextInfo contextInfo)	Release soft reservations and add back to on-hand quantity.
List<InventoryTransaction>	fulfillInventory(@NonNull Map<I,List<SkuInventoryAdjustmentRequestItem>> skuInventoryAdjustmentRequestItems, @NonNull String batchId, com.broadleafcommerce.data.tracking.core.context.ContextInfo contextInfo)	Perform the fulfillment of inventory to remove reserved quantity and decrement on-hand quantity.
protected com.broadleafcommerce.data.tracking.core.mapping.DomainMapperManager	getDomainMapperManager()
protected Map<String,List<InventoryTransaction>>	getExistingReservationsByReferences(List<String> referenceNumbers, Set<String> transactionTypesToRead, com.broadleafcommerce.data.tracking.core.context.ContextInfo contextInfo)
protected Set<String>	getInventoryReservationTypes()
protected InventoryTransactionService<InventoryTransaction>	getInventoryTransactionService()
protected Comparator<SkuInventory>	getSkuInventoryComparator()
protected SkuInventoryRepository<com.broadleafcommerce.data.tracking.core.Trackable>	getSkuInventoryRepository()
protected StockChangeNotificationService	getStockChangeNotificationService()
protected com.broadleafcommerce.common.extension.TypeFactory	getTypeFactory()
protected com.broadleafcommerce.data.tracking.core.mapping.validation.EntityValidatorManager	getValidator()
protected InventoryUnavailableException	inventoryUnavailableException(SkuInventory inventory, SkuInventoryAdjustmentRequestItem item, InventoryTransactionType transactionType, String reason)
protected Map<String,List<InventoryTransaction>>	readExistingTransactionsForItemByType(SkuInventoryAdjustmentRequestItem item, com.broadleafcommerce.data.tracking.core.context.ContextInfo contextInfo)
protected Optional<I>	readOptionalSkuInventory(@NonNull String id, com.broadleafcommerce.data.tracking.core.context.ContextInfo contextInfo)
protected I	readSkuInventory(@NonNull String id, com.broadleafcommerce.data.tracking.core.context.ContextInfo contextInfo)
List<InventoryTransaction>	returnInventory(Map<I,List<SkuInventoryAdjustmentRequestItem>> skuInventoryAdjustmentRequestItems, String batchId, com.broadleafcommerce.data.tracking.core.context.ContextInfo contextInfo)	Perform the return of inventory to add back on-hand quantity.
protected List<InventoryTransaction>	saveInventoryTransactions(List<InventoryTransaction> transactions, com.broadleafcommerce.data.tracking.core.context.ContextInfo contextInfo)
protected List<I>	saveSkuInventories(Collection<I> inventories, com.broadleafcommerce.data.tracking.core.context.ContextInfo contextInfo)
protected int	sumQuantityForTransactionType(Map<String,List<InventoryTransaction>> transactionsByType, InventoryTransactionType type)
protected List<InventoryTransaction>	updateInventoryTransactions(List<com.broadleafcommerce.data.tracking.core.service.Update<InventoryTransaction>> transactions, com.broadleafcommerce.data.tracking.core.context.ContextInfo contextInfo)
protected void	updateSkuInventoryQuantityReservation(@NonNull SkuInventory inventory, @NonNull Integer quantityRequested)
protected List<com.broadleafcommerce.data.tracking.core.service.Update<InventoryTransaction>>	updateSoftReservationTransactionAndInventory(List<InventoryTransaction> inventoryTransactions, SkuInventory refreshedInventory, SkuInventoryAdjustmentRequestItem item)
protected void	validateCanCancelInventory(SkuInventory inventory, SkuInventoryAdjustmentRequestItem item, com.broadleafcommerce.data.tracking.core.context.ContextInfo contextInfo)
protected void	validateCanFulfillInventory(SkuInventory inventory, SkuInventoryAdjustmentRequestItem item, com.broadleafcommerce.data.tracking.core.context.ContextInfo contextInfo)
protected void	validateSufficientQuantityReservedForItemAdjustment(SkuInventory inventory, SkuInventoryAdjustmentRequestItem item, Map<String,List<InventoryTransaction>> existingTransactionsByType, InventoryTransactionType transactionType)

Methods inherited from class java.lang.Object

clone, equals, finalize, getClass, hashCode, notify, notifyAll, toString, wait, wait, wait

Constructor Detail

DefaultSkuInventoryAdjustmentService

public DefaultSkuInventoryAdjustmentService(SkuInventoryRepository<com.broadleafcommerce.data.tracking.core.Trackable> skuInventoryRepository,
                                            InventoryTransactionService<InventoryTransaction> inventoryTransactionService,
                                            com.broadleafcommerce.data.tracking.core.mapping.DomainMapperManager domainMapperManager,
                                            com.broadleafcommerce.data.tracking.core.mapping.validation.EntityValidatorManager validator,
                                            com.broadleafcommerce.common.extension.TypeFactory typeFactory,
                                            StockChangeNotificationService stockChangeNotificationService)

Method Detail

createSoftReservations

public List<InventoryTransaction> createSoftReservations(@NonNull
                                                         Map<I,List<SkuInventoryAdjustmentRequestItem>> skuInventoryReservationRequestItems,
                                                         @NonNull
                                                         String batchId,
                                                         @Nullable
                                                         com.broadleafcommerce.data.tracking.core.context.ContextInfo contextInfo)
                                                  throws InventoryUnavailableException

Description copied from interface: SkuInventoryAdjustmentService

Soft reservations that represent temporary inventory reservations.

Specified by:

createSoftReservations in interface SkuInventoryAdjustmentService<I extends SkuInventory>

Parameters:

skuInventoryReservationRequestItems - - the key to the map is the SkuInventory that needs to be updated (pre-determined outside of this method).

batchId - identifier for the current batch of items updating inventory

contextInfo - the context around sandboxing and multitenant state

Returns:

the created inventory transactions

Throws:

InventoryUnavailableException - if there was insufficient inventory to be reserved

getExistingReservationsByReferences

protected Map<String,List<InventoryTransaction>> getExistingReservationsByReferences(List<String> referenceNumbers,
                                                                                           Set<String> transactionTypesToRead,
                                                                                           @Nullable
                                                                                           com.broadleafcommerce.data.tracking.core.context.ContextInfo contextInfo)

createSoftReservations

public List<InventoryTransaction> createSoftReservations(@NonNull
                                                         Map<I,List<SkuInventoryAdjustmentRequestItem>> skuInventoryReservationRequestItems,
                                                         Map<String,List<InventoryTransaction>> existingSoftReservationsByReference,
                                                         @NonNull
                                                         String batchId,
                                                         @Nullable
                                                         com.broadleafcommerce.data.tracking.core.context.ContextInfo contextInfo)
                                                  throws InventoryUnavailableException

Description copied from interface: SkuInventoryAdjustmentService

Soft reservations that represent temporary inventory reservations.

Specified by:

createSoftReservations in interface SkuInventoryAdjustmentService<I extends SkuInventory>

Parameters:

skuInventoryReservationRequestItems - - the key to the map is the SkuInventory that needs to be updated (pre-determined outside of this method).

existingSoftReservationsByReference - the existing soft reservations grouped by reference number

batchId - identifier for the current batch of items updating inventory

contextInfo - the context around sandboxing and multitenant state

Returns:

the created inventory transactions

Throws:

InventoryUnavailableException - if there was insufficient inventory to be reserved

updateSoftReservationTransactionAndInventory

protected List<com.broadleafcommerce.data.tracking.core.service.Update<InventoryTransaction>> updateSoftReservationTransactionAndInventory(List<InventoryTransaction> inventoryTransactions,
                                                                                                                                           SkuInventory refreshedInventory,
                                                                                                                                           SkuInventoryAdjustmentRequestItem item)
                                                                                                                                    throws InventoryUnavailableException

Throws:

InventoryUnavailableException

createHardReservations

public List<InventoryTransaction> createHardReservations(@NonNull
                                                         Map<I,List<SkuInventoryAdjustmentRequestItem>> skuInventoryReservationRequestItems,
                                                         @NonNull
                                                         String batchId,
                                                         @Nullable
                                                         com.broadleafcommerce.data.tracking.core.context.ContextInfo contextInfo)
                                                  throws InventoryUnavailableException

Description copied from interface: SkuInventoryAdjustmentService

Hard reservations that represent final inventory reservations.

Specified by:

createHardReservations in interface SkuInventoryAdjustmentService<I extends SkuInventory>

Parameters:

skuInventoryReservationRequestItems - - the key to the map is the SkuInventory that needs to be updated (pre-determined outside of this method).

batchId - identifier for the current batch of items updating inventory

contextInfo - the context around sandboxing and multitenant state

Returns:

the created inventory transactions

Throws:

InventoryUnavailableException - if there was insufficient inventory to be reserved

createSoftReservation

protected InventoryTransaction createSoftReservation(@NonNull
                                                     @NonNull SkuInventory inventory,
                                                     @NonNull
                                                     @NonNull Integer quantityRequested,
                                                     @NonNull
                                                     @NonNull String referenceNumber,
                                                     @NonNull
                                                     @NonNull String batchId,
                                                     @Nullable
                                                     com.broadleafcommerce.data.tracking.core.context.ContextInfo contextInfo)
                                              throws InventoryUnavailableException

Soft inventory reservation. This also appropriately adjusts the inventory record passed in. This method, by default, does not save anything. Rather, it allows the calling method to handle that to allow for situations where a single SkuInventory may be adjusted more than once in a single call. That can happen, for example, when a PICKUP and a SHIP reservation for the same item are being requested for the same inventory. As a result, this method does the adjustment to the SkuInventory record and persists the associated InventoryTransaction.

Parameters:

inventory -

quantityRequested -

referenceNumber -

batchId -

contextInfo -

Returns:

Throws:

InventoryUnavailableException

updateSkuInventoryQuantityReservation

protected void updateSkuInventoryQuantityReservation(@NonNull
                                                     @NonNull SkuInventory inventory,
                                                     @NonNull
                                                     @NonNull Integer quantityRequested)
                                              throws InventoryUnavailableException

Throws:

InventoryUnavailableException

buildInventoryTransaction

protected InventoryTransaction buildInventoryTransaction(int quantity,
                                                         InventoryTransactionType type,
                                                         String reference,
                                                         String skuInventoryId,
                                                         String batchId,
                                                         Instant dateProcessed)

createHardReservation

protected InventoryTransaction createHardReservation(@NonNull
                                                     @NonNull SkuInventory inventory,
                                                     @Nullable
                                                     InventoryTransaction softTransaction,
                                                     @NonNull
                                                     @NonNull Integer quantityRequested,
                                                     @NonNull
                                                     @NonNull String referenceNumber,
                                                     @NonNull
                                                     @NonNull String batchId,
                                                     @Nullable
                                                     com.broadleafcommerce.data.tracking.core.context.ContextInfo contextInfo)
                                              throws InventoryUnavailableException

Hard inventory reservation. If an associated soft reservation is found, this method converts it to a hard reservation. Otherwise, this method decrements quantity available and increments quantity reserved and creates a new InventoryTransaction with a transaction type of "HARD_RESERVED".

In this case, the provided SkuInventory argument is a hint or an option in case a SOFT reservation was not completed or in case it expired and has been rolled back. The logic is as follows:

1. Look up InventoryTransactions based on the referenceNumber and InventoryTransactionType.
2. If a HARD reservation exists, throw an exception
3. If a SOFT reservation exists, then look up the SkuInventory record associated with the SOFT transaction, decrement inventory, and create a HARD reservation.
4. If a SOFT reservation does not exist, then decrement inventory as if it was a soft reservation, and create a HARD reservation
The SkuInventory record provided as an argument is a hint. If a SOFT reservation exists, then we want to use the SkuInventory that is already soft reserved (which may be the same). However, if a soft record does not exist, then we try to use the provided SkuInventory record.

Parameters:

inventory - - The inventory that should be adjusted

softTransaction - - existing soft inventory reservation that will be converted to a hard reservation

quantityRequested - - Quantity to reserve - Must be greater than 0

referenceNumber - - Arbitrary, unique reference number - usually Fulfillment Group Item Reference

batchId - - arbitrary batch ID (typically to identify a logical transaction)

contextInfo -

Returns:

A single entry Map keyed by the SkuInventory that should be persisted and the associated InventoryTransaction

Throws:

InventoryUnavailableException

fulfillInventory

public List<InventoryTransaction> fulfillInventory(@NonNull @NonNull
                                                   @NonNull Map<I,List<SkuInventoryAdjustmentRequestItem>> skuInventoryAdjustmentRequestItems,
                                                   @NonNull @NonNull
                                                   @NonNull String batchId,
                                                   @Nullable
                                                   com.broadleafcommerce.data.tracking.core.context.ContextInfo contextInfo)
                                            throws InventoryUnavailableException,
                                                   InventoryNotReservedException

Description copied from interface: SkuInventoryAdjustmentService

Perform the fulfillment of inventory to remove reserved quantity and decrement on-hand quantity.

Specified by:

fulfillInventory in interface SkuInventoryAdjustmentService<I extends SkuInventory>

Parameters:

skuInventoryAdjustmentRequestItems - - the key to the map is the SkuInventory that needs to be updated (pre-determined outside of this method).

batchId - identifier for the current batch of items updating inventory

contextInfo - the context around sandboxing and multitenant state

Returns:

the created inventory transactions

Throws:

InventoryUnavailableException - if there was insufficient inventory reserved or on hand

InventoryNotReservedException - if there were not already hard reservations for these inventory items

validateCanFulfillInventory

protected void validateCanFulfillInventory(SkuInventory inventory,
                                           SkuInventoryAdjustmentRequestItem item,
                                           @Nullable
                                           com.broadleafcommerce.data.tracking.core.context.ContextInfo contextInfo)
                                    throws InventoryUnavailableException,
                                           InventoryNotReservedException

Throws:

InventoryUnavailableException

InventoryNotReservedException

createFulfilledTransaction

protected InventoryTransaction createFulfilledTransaction(@NonNull
                                                          @NonNull SkuInventory inventory,
                                                          int quantity,
                                                          @NonNull
                                                          @NonNull String referenceNumber,
                                                          @NonNull
                                                          @NonNull String batchId)

Builds a fulfilled InventoryTransaction and adjusts the SkuInventory quantities.

Parameters:

inventory - the inventory being fulfilled

quantity - the quantity being fulfilled

referenceNumber - the reference number of the item fulfilling inventory

batchId - identifier for the current batch of items updating inventory

Returns:

the inventory transaction for this fulfilled item quantity

cancelInventory

public List<InventoryTransaction> cancelInventory(@NonNull
                                                  Map<I,List<SkuInventoryAdjustmentRequestItem>> skuInventoryAdjustmentRequestItems,
                                                  @NonNull
                                                  String batchId,
                                                  @Nullable
                                                  com.broadleafcommerce.data.tracking.core.context.ContextInfo contextInfo)
                                           throws InventoryUnavailableException,
                                                  InventoryNotReservedException

Description copied from interface: SkuInventoryAdjustmentService

Perform the cancel of inventory to remove reserved quantity.

Specified by:

cancelInventory in interface SkuInventoryAdjustmentService<I extends SkuInventory>

Parameters:

skuInventoryAdjustmentRequestItems - - the key to the map is the SkuInventory that needs to be updated (pre-determined outside of this method).

batchId - identifier for the current batch of items updating inventory

contextInfo - the context around sandboxing and multitenant state

Returns:

the created inventory transactions

Throws:

InventoryUnavailableException - if there was insufficient inventory reserved

InventoryNotReservedException - if there were not already hard reservations for these inventory items

freeSoftReservations

public void freeSoftReservations(@NonNull
                                 List<InventoryTransaction> softReservations,
                                 @Nullable
                                 com.broadleafcommerce.data.tracking.core.context.ContextInfo contextInfo)

Description copied from interface: SkuInventoryAdjustmentService

Release soft reservations and add back to on-hand quantity. Note that this archives the soft reservation in-place, no new inventory transactions are created.

Specified by:

freeSoftReservations in interface SkuInventoryAdjustmentService<I extends SkuInventory>

Parameters:

softReservations - the soft reservations to free

contextInfo - the context around sandboxing and multitenant state

freeSoftReservationQuantity

protected InventoryTransaction freeSoftReservationQuantity(@NonNull
                                                           InventoryTransaction softReservation,
                                                           @NonNull
                                                           SkuInventory skuInventory)

Adjusts the SKU inventory quantities to reflect a soft inventory reservation being released (back to the available pool).

Parameters:

softReservation - the soft reservation to release

skuInventory - the SKU inventory to adjust the quantities of (will be mutated)

Returns:

the soft reservation

validateCanCancelInventory

protected void validateCanCancelInventory(SkuInventory inventory,
                                          SkuInventoryAdjustmentRequestItem item,
                                          @Nullable
                                          com.broadleafcommerce.data.tracking.core.context.ContextInfo contextInfo)
                                   throws InventoryUnavailableException,
                                          InventoryNotReservedException

Throws:

InventoryUnavailableException

InventoryNotReservedException

createCancelledTransaction

protected InventoryTransaction createCancelledTransaction(@NonNull
                                                          @NonNull SkuInventory inventory,
                                                          int quantity,
                                                          @NonNull
                                                          @NonNull String referenceNumber,
                                                          @NonNull
                                                          @NonNull String batchId)

Builds a cancelled InventoryTransaction and adjusts the SkuInventory quantities.

Parameters:

inventory - the inventory being cancelled

quantity - the quantity being cancelled

referenceNumber - the reference number of the item cancelling inventory

batchId - identifier for the current batch of items updating inventory

Returns:

the inventory transaction for this cancelled item quantity

readExistingTransactionsForItemByType

protected Map<String,List<InventoryTransaction>> readExistingTransactionsForItemByType(SkuInventoryAdjustmentRequestItem item,
                                                                                             @Nullable
                                                                                             com.broadleafcommerce.data.tracking.core.context.ContextInfo contextInfo)

validateSufficientQuantityReservedForItemAdjustment

protected void validateSufficientQuantityReservedForItemAdjustment(SkuInventory inventory,
                                                                   SkuInventoryAdjustmentRequestItem item,
                                                                   Map<String,List<InventoryTransaction>> existingTransactionsByType,
                                                                   InventoryTransactionType transactionType)
                                                            throws InventoryUnavailableException,
                                                                   InventoryNotReservedException

Throws:

InventoryUnavailableException

InventoryNotReservedException

sumQuantityForTransactionType

protected int sumQuantityForTransactionType(Map<String,List<InventoryTransaction>> transactionsByType,
                                            InventoryTransactionType type)

inventoryUnavailableException

protected InventoryUnavailableException inventoryUnavailableException(SkuInventory inventory,
                                                                      SkuInventoryAdjustmentRequestItem item,
                                                                      InventoryTransactionType transactionType,
                                                                      String reason)

calculateQuantityAvailable

protected int calculateQuantityAvailable(SkuInventory inventory)

returnInventory

public List<InventoryTransaction> returnInventory(@NonNull
                                                  Map<I,List<SkuInventoryAdjustmentRequestItem>> skuInventoryAdjustmentRequestItems,
                                                  @NonNull
                                                  String batchId,
                                                  @Nullable
                                                  com.broadleafcommerce.data.tracking.core.context.ContextInfo contextInfo)

Description copied from interface: SkuInventoryAdjustmentService

Perform the return of inventory to add back on-hand quantity.

Specified by:

returnInventory in interface SkuInventoryAdjustmentService<I extends SkuInventory>

Parameters:

skuInventoryAdjustmentRequestItems - - the key to the map is the SkuInventory that needs to be updated (pre-determined outside of this method).

batchId - identifier for the current batch of items updating inventory

contextInfo - the context around sandboxing and multitenant state

Returns:

the created inventory transactions

createReturnedTransaction

protected InventoryTransaction createReturnedTransaction(@NonNull
                                                         @NonNull SkuInventory inventory,
                                                         int quantity,
                                                         @NonNull
                                                         @NonNull String referenceNumber,
                                                         @NonNull
                                                         @NonNull String batchId)

Builds a returned InventoryTransaction and adjusts the SkuInventory quantities.

Parameters:

inventory - the inventory being returned

quantity - the quantity being returned

referenceNumber - the reference number of the item returning inventory

batchId - identifier for the current batch of items returning inventory

Returns:

the inventory transaction for this returned item quantity

readSkuInventory

@NonNull
protected I readSkuInventory(@NonNull
                             @NonNull String id,
                             @Nullable
                             com.broadleafcommerce.data.tracking.core.context.ContextInfo contextInfo)

readOptionalSkuInventory

@NonNull
protected Optional<I> readOptionalSkuInventory(@NonNull
                                               @NonNull String id,
                                               @Nullable
                                               com.broadleafcommerce.data.tracking.core.context.ContextInfo contextInfo)

saveSkuInventories

protected List<I> saveSkuInventories(@NonNull
                                     Collection<I> inventories,
                                     @Nullable
                                     com.broadleafcommerce.data.tracking.core.context.ContextInfo contextInfo)

saveInventoryTransactions

protected List<InventoryTransaction> saveInventoryTransactions(@NonNull
                                                               List<InventoryTransaction> transactions,
                                                               @Nullable
                                                               com.broadleafcommerce.data.tracking.core.context.ContextInfo contextInfo)

updateInventoryTransactions

protected List<InventoryTransaction> updateInventoryTransactions(@NonNull
                                                                 List<com.broadleafcommerce.data.tracking.core.service.Update<InventoryTransaction>> transactions,
                                                                 @Nullable
                                                                 com.broadleafcommerce.data.tracking.core.context.ContextInfo contextInfo)

deleteInventoryTransaction

protected void deleteInventoryTransaction(@NonNull
                                          InventoryTransaction transaction,
                                          @Nullable
                                          com.broadleafcommerce.data.tracking.core.context.ContextInfo contextInfo)

Convenience method for deleting (archiving) an inventory transaction.

Parameters:

transaction - the transaction to delete

contextInfo - the context in which to delete in

getSkuInventoryComparator

protected Comparator<SkuInventory> getSkuInventoryComparator()

convertSkuInventoryFromPersistentDomain

protected Stream<I> convertSkuInventoryFromPersistentDomain(@NonNull
                                                            Iterable<com.broadleafcommerce.data.tracking.core.Trackable> iterable,
                                                            @Nullable
                                                            com.broadleafcommerce.data.tracking.core.context.ContextInfo contextInfo)

getInventoryReservationTypes

protected Set<String> getInventoryReservationTypes()

getSkuInventoryRepository

@NonNull
protected SkuInventoryRepository<com.broadleafcommerce.data.tracking.core.Trackable> getSkuInventoryRepository()

getInventoryTransactionService

@NonNull
protected InventoryTransactionService<InventoryTransaction> getInventoryTransactionService()

getStockChangeNotificationService

@NonNull
protected StockChangeNotificationService getStockChangeNotificationService()

getDomainMapperManager

@NonNull
protected com.broadleafcommerce.data.tracking.core.mapping.DomainMapperManager getDomainMapperManager()

getValidator

@NonNull
protected com.broadleafcommerce.data.tracking.core.mapping.validation.EntityValidatorManager getValidator()

getTypeFactory

@NonNull
protected com.broadleafcommerce.common.extension.TypeFactory getTypeFactory()