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)	Deprecated. in favor of SkuInventory.updateQuantityAvailable()
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	createOrUpdateInventoryTransaction(InventoryTransaction inventoryTransaction, InventoryTransaction existingSoftReservation, com.broadleafcommerce.data.tracking.core.context.ContextInfo contextInfo)	Create an inventory transaction, or update an existing transaction if a previous soft transaction exists
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 boolean	hasExistingReservations(List<InventoryTransaction> transactions)
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(@NonNull List<InventoryTransaction> inventoryTransactions, @NonNull Map<String,I> refreshedInventories, @NonNull SkuInventoryAdjustmentRequestItem item)
protected List<com.broadleafcommerce.data.tracking.core.service.Update<InventoryTransaction>>	updateSoftReservationTransactionAndInventory(List<InventoryTransaction> inventoryTransactions, SkuInventory refreshedInventory, SkuInventoryAdjustmentRequestItem item)	Deprecated. in favor of updateSoftReservationTransactionAndInventory(List, Map, SkuInventoryAdjustmentRequestItem)
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	validateExistingHardReservations(@NonNull SkuInventoryAdjustmentRequestItem item, @NonNull List<InventoryTransaction> existingTransactions)	Validates that there is not an existing InventoryTransactions that is DefaultInventoryTransactionType.HARD_RESERVED for the given SkuInventoryAdjustmentRequestItem.
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 Details

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 Details

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

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

Deprecated.

in favor of updateSoftReservationTransactionAndInventory(List, Map, SkuInventoryAdjustmentRequestItem)

Throws:

InventoryUnavailableException

updateSoftReservationTransactionAndInventory

protected List<com.broadleafcommerce.data.tracking.core.service.Update<InventoryTransaction>> updateSoftReservationTransactionAndInventory(@NonNull
 @NonNull List<InventoryTransaction> inventoryTransactions,
 @NonNull
 @NonNull Map<String,I> refreshedInventories,
 @NonNull
 @NonNull 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

hasExistingReservations

protected boolean hasExistingReservations(List<InventoryTransaction> transactions)

validateExistingHardReservations

protected void validateExistingHardReservations(@NonNull
 @NonNull SkuInventoryAdjustmentRequestItem item,
 @NonNull
 @NonNull List<InventoryTransaction> existingTransactions)

Validates that there is not an existing InventoryTransactions that is DefaultInventoryTransactionType.HARD_RESERVED for the given SkuInventoryAdjustmentRequestItem.

Parameters:

item - the SkuInventoryAdjustmentRequestItem to validate for

existingTransactions - the existing InventoryTransactions

Throws:

IllegalArgumentException - if there is already a DefaultInventoryTransactionType.HARD_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

createOrUpdateInventoryTransaction

protected InventoryTransaction createOrUpdateInventoryTransaction(InventoryTransaction inventoryTransaction,
 @Nullable
 InventoryTransaction existingSoftReservation,
 com.broadleafcommerce.data.tracking.core.context.ContextInfo contextInfo)

Create an inventory transaction, or update an existing transaction if a previous soft transaction exists

Parameters:

inventoryTransaction - inventory transaction to be created or updated

existingSoftReservation - existing soft inventory reservation to be converted to a hard reservation

contextInfo - context info

Returns:

the created or updated inventory transaction

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

@Deprecated
protected int calculateQuantityAvailable(SkuInventory inventory)

Deprecated.

in favor of SkuInventory.updateQuantityAvailable()

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()