org.broadleafcommerce.core.order.service
Class OrderServiceImpl

java.lang.Object
  org.broadleafcommerce.core.order.service.OrderServiceImpl

All Implemented Interfaces:

OrderService

Direct Known Subclasses:

LegacyOrderServiceImpl

@Service(value="blOrderService")
@ManagedResource(objectName="org.broadleafcommerce:name=OrderService",
                 description="Order Service",
                 currencyTimeLimit=15)
public class OrderServiceImpl
extends Object
implements OrderService

Author:

apazzolini

Field Summary

protected SequenceProcessor	addItemWorkflow
protected boolean	automaticallyMergeLikeItems
protected boolean	deleteEmptyNamedOrders
protected OrderServiceExtensionListener	extensionManager
protected FulfillmentGroupService	fulfillmentGroupService
protected MergeCartService	mergeCartService
protected boolean	moveNamedOrderItems
protected NullOrderFactory	nullOrderFactory
protected OfferDao	offerDao
protected OfferService	offerService
protected OrderDao	orderDao
protected OrderItemService	orderItemService
protected PaymentInfoDao	paymentInfoDao
protected int	pricingRetryCountForLockFailure
protected long	pricingRetryWaitIntervalForLockFailure
protected PricingService	pricingService
protected SequenceProcessor	removeItemWorkflow
protected SecurePaymentInfoService	securePaymentInfoService
protected org.springframework.transaction.PlatformTransactionManager	transactionManager
protected SequenceProcessor	updateItemWorkflow

Constructor Summary

OrderServiceImpl()

Method Summary

Order	addAllItemsFromNamedOrder(Order namedOrder, boolean priceOrder) Adds all orderItems to the current cart from the same Customer that owns the named order.
OrderItem	addGiftWrapItemToOrder(Order order, GiftWrapOrderItemRequest itemRequest, boolean priceOrder) Adds a GiftWrapItem to the order based on the itemRequest.
Order	addItem(Long orderId, OrderItemRequestDTO orderItemRequestDTO, boolean priceOrder) Initiates the addItem workflow that will attempt to add the given quantity of the specified item to the Order.
Order	addItemFromNamedOrder(Order namedOrder, OrderItem item, boolean priceOrder) Adds the passed in orderItem to the current cart for the same Customer that owns the named order.
Order	addItemFromNamedOrder(Order namedOrder, OrderItem item, int quantity, boolean priceOrder) This method performs the same function as addItemFromNamedOrder(Order, OrderItem, boolean) except that instead of adding all of the quantity from the named order to the cart, it will only add/move the specific quantity requested.
Order	addItemWithPriceOverrides(Long orderId, OrderItemRequestDTO orderItemRequestDTO, boolean priceOrder) Initiates the addItem workflow that will attempt to add the given quantity of the specified item to the Order.
Order	addOfferCode(Order order, OfferCode offerCode, boolean priceOrder) Adds the given OfferCode to the order.
PaymentInfo	addPaymentToOrder(Order order, PaymentInfo payment, Referenced securePaymentInfo) Associates a given PaymentInfo with an Order.
void	cancelOrder(Order order) Deletes the given order.
protected boolean	compareAttributes(Map<String,OrderItemAttribute> item1Attributes, OrderItemRequestDTO item2) Returns true if the two items attributes exactly match.
Order	confirmOrder(Order order) Changes the OrderStatus to SUBMITTED
Order	createNamedOrderForCustomer(String name, Customer customer) Creates a new Order for the given customer with the given name.
Order	createNewCartForCustomer(Customer customer) Creates a new Order for the given customer.
void	deleteOrder(Order order)
protected void	finalizeTransaction(org.springframework.transaction.TransactionStatus status, boolean isError)
Order	findCartForCustomer(Customer customer) Looks up the current shopping cart for the customer.
OrderItem	findLastMatchingItem(Order order, Long skuId, Long productId) Looks through the given order and returns the latest added OrderItem that matches on the skuId and productId.
protected OrderItem	findMatchingItem(Order order, OrderItemRequestDTO itemToFind)
Order	findNamedOrderForCustomer(String name, Customer customer) Looks up an Order by the given customer and a specified order name.
Order	findOrderById(Long orderId) Looks up an Order by its database id
Order	findOrderByOrderNumber(String orderNumber) Looks up Orders and returns the order matching the given orderNumber
List<Order>	findOrdersForCustomer(Customer customer) Looks up all Orders for the specified customer, regardless of current OrderStatus
List<Order>	findOrdersForCustomer(Customer customer, OrderStatus status) Looks up all Orders for the specified customer that are in the specified OrderStatus.
List<PaymentInfo>	findPaymentInfosForOrder(Order order) Returns all PaymentInfo objects that are associated with the given order
boolean	getAutomaticallyMergeLikeItems()
protected Throwable	getCartOperationExceptionRootCause(WorkflowException e) This method will return the exception that is immediately below the deepest WorkflowException in the current stack trace.
Order	getNullOrder() The null order is the default order for all customers when they initially enter the site.
boolean	isDeleteEmptyNamedOrders()
boolean	isMoveNamedOrderItems()
protected boolean	itemMatches(Sku item1Sku, Product item1Product, Map<String,OrderItemAttribute> item1Attributes, OrderItemRequestDTO item2)
protected Order	persist(Order order)
Order	removeAllOfferCodes(Order order, boolean priceOrder) Removes all offer codes for the given order.
void	removeAllPaymentsFromOrder(Order order) Deletes all the Payment Info's on the order.
Order	removeItem(Long orderId, Long orderItemId, boolean priceOrder) Initiates the removeItem workflow that will attempt to remove the specified OrderItem from the given Order
Order	removeOfferCode(Order order, OfferCode offerCode, boolean priceOrder) Remove the given OfferCode for the order.
void	removePaymentFromOrder(Order order, PaymentInfo paymentInfo) Deletes the Payment Info from the order.
void	removePaymentsFromOrder(Order order, PaymentInfoType paymentInfoType) Deletes the Payment Info of the passed in type from the order Note that this method will also delete any associated Secure Payment Infos if necessary.
Order	save(Order order, Boolean priceOrder) Persists the given order to the database.
void	setAutomaticallyMergeLikeItems(boolean automaticallyMergeLikeItems) When set to true, the system when items are added to the cart, they will automatically be merged.
void	setDeleteEmptyNamedOrders(boolean deleteEmptyNamedOrders) Sets whether or not to delete named orders once all items have been removed.
void	setMoveNamedOrderItems(boolean moveNamedOrderItems) Determines whether or not items will be removed from the named order (wishlist) when they are moved to the Customer's current cart.
Order	updateItemQuantity(Long orderId, OrderItemRequestDTO orderItemRequestDTO, boolean priceOrder) Initiates the updateItem workflow that will attempt to update the item quantity for the specified OrderItem in the given Order.

Methods inherited from class java.lang.Object

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

Field Detail

paymentInfoDao

protected PaymentInfoDao paymentInfoDao

orderDao

protected OrderDao orderDao

offerDao

protected OfferDao offerDao

nullOrderFactory

protected NullOrderFactory nullOrderFactory

pricingService

protected PricingService pricingService

orderItemService

protected OrderItemService orderItemService

fulfillmentGroupService

protected FulfillmentGroupService fulfillmentGroupService

offerService

protected OfferService offerService

securePaymentInfoService

protected SecurePaymentInfoService securePaymentInfoService

mergeCartService

protected MergeCartService mergeCartService

extensionManager

protected OrderServiceExtensionListener extensionManager

addItemWorkflow

protected SequenceProcessor addItemWorkflow

updateItemWorkflow

protected SequenceProcessor updateItemWorkflow

removeItemWorkflow

protected SequenceProcessor removeItemWorkflow

transactionManager

protected org.springframework.transaction.PlatformTransactionManager transactionManager

pricingRetryCountForLockFailure

@Value(value="${pricing.retry.count.for.lock.failure}")
protected int pricingRetryCountForLockFailure

pricingRetryWaitIntervalForLockFailure

@Value(value="${pricing.retry.wait.interval.for.lock.failure}")
protected long pricingRetryWaitIntervalForLockFailure

moveNamedOrderItems

protected boolean moveNamedOrderItems

deleteEmptyNamedOrders

protected boolean deleteEmptyNamedOrders

automaticallyMergeLikeItems

protected boolean automaticallyMergeLikeItems

Constructor Detail

OrderServiceImpl

public OrderServiceImpl()

Method Detail

createNewCartForCustomer

@Transactional(value="blTransactionManager")
public Order createNewCartForCustomer(Customer customer)

Description copied from interface: OrderService

Creates a new Order for the given customer. Generally, you will want to use the customer that is on the current request, which can be grabbed by utilizing the CustomerState utility class. The default Broadleaf implementation of this method will provision a new Order in the database and set the current customer as the owner of the order. If the customer has an email address associated with their profile, that will be copied as well. If the customer is a new, anonymous customer, his username will be set to his database id.

Specified by:

createNewCartForCustomer in interface OrderService

Returns:

the newly created order

See Also:

CustomerState

createNamedOrderForCustomer

@Transactional(value="blTransactionManager")
public Order createNamedOrderForCustomer(String name,
                                                       Customer customer)

Description copied from interface: OrderService

Creates a new Order for the given customer with the given name. Typically, this represents a "wishlist" order that the customer can save but not check out with.

Specified by:

createNamedOrderForCustomer in interface OrderService

Parameters:

name - the wishlist name

Returns:

the newly created named order

findNamedOrderForCustomer

public Order findNamedOrderForCustomer(String name,
                                       Customer customer)

Description copied from interface: OrderService

Looks up an Order by the given customer and a specified order name. This is typically used to retrieve a "wishlist" order.

Specified by:

findNamedOrderForCustomer in interface OrderService

Returns:

the named order requested

See Also:

OrderService.createNamedOrderForCustomer(String name, Customer customer)

findOrderById

public Order findOrderById(Long orderId)

Description copied from interface: OrderService

Looks up an Order by its database id

Specified by:

findOrderById in interface OrderService

Returns:

the requested Order

getNullOrder

public Order getNullOrder()

Description copied from interface: OrderService

The null order is the default order for all customers when they initially enter the site. Upon the first addition of a product to a cart, a non-null order will be provisioned for the user.

Specified by:

getNullOrder in interface OrderService

Returns:

a shared, static, unmodifiable NullOrder

See Also:

for more information

findCartForCustomer

public Order findCartForCustomer(Customer customer)

Description copied from interface: OrderService

Looks up the current shopping cart for the customer. Note that a shopping cart is simply an Order with OrderStatus = IN_PROCESS. If for some reason the given customer has more than one current IN_PROCESS Order, the default Broadleaf implementation will return the first match found. Furthermore, also note that the current shopping cart for a customer must never be named -- an Order with a non-null "name" property indicates that it is a wishlist and not a shopping cart.

Specified by:

findCartForCustomer in interface OrderService

Returns:

the current shopping cart for the customer

findOrdersForCustomer

public List<Order> findOrdersForCustomer(Customer customer)

Description copied from interface: OrderService

Looks up all Orders for the specified customer, regardless of current OrderStatus

Specified by:

findOrdersForCustomer in interface OrderService

Returns:

the requested Orders

findOrdersForCustomer

public List<Order> findOrdersForCustomer(Customer customer,
                                         OrderStatus status)

Description copied from interface: OrderService

Looks up all Orders for the specified customer that are in the specified OrderStatus.

Specified by:

findOrdersForCustomer in interface OrderService

Returns:

the requested Orders

findOrderByOrderNumber

public Order findOrderByOrderNumber(String orderNumber)

Description copied from interface: OrderService

Looks up Orders and returns the order matching the given orderNumber

Specified by:

findOrderByOrderNumber in interface OrderService

Returns:

the requested Order

findPaymentInfosForOrder

public List<PaymentInfo> findPaymentInfosForOrder(Order order)

Description copied from interface: OrderService

Returns all PaymentInfo objects that are associated with the given order

Specified by:

findPaymentInfosForOrder in interface OrderService

Returns:

the list of all PaymentInfo objects

addPaymentToOrder

@Transactional(value="blTransactionManager")
public PaymentInfo addPaymentToOrder(Order order,
                                                   PaymentInfo payment,
                                                   Referenced securePaymentInfo)

Description copied from interface: OrderService

Associates a given PaymentInfo with an Order. Note that it is acceptable for the securePaymentInfo to be null. For example, if the secure credit card details are handled by a third party, a given application may never have associated securePaymentInfos

Specified by:

addPaymentToOrder in interface OrderService

securePaymentInfo - - null if it doesn't exist

Returns:

the persisted version of the PaymentInfo

save

public Order save(Order order,
                  Boolean priceOrder)
           throws PricingException

Description copied from interface: OrderService

Persists the given order to the database. If the priceOrder flag is set to true, the pricing workflow will execute before the order is written to the database. Generally, you will want to price the order in every request scope once, and preferrably on the last call to save() for performance reasons. However, if you have logic that depends on the Order being priced, there are no issues with saving as many times as necessary.

Specified by:

save in interface OrderService

Returns:

the persisted Order, which will be a different instance than the Order passed in

Throws:

PricingException

finalizeTransaction

protected void finalizeTransaction(org.springframework.transaction.TransactionStatus status,
                                   boolean isError)

persist

protected Order persist(Order order)

cancelOrder

@Transactional(value="blTransactionManager")
public void cancelOrder(Order order)

Description copied from interface: OrderService

Deletes the given order. Note that the default Broadleaf implementation in OrderServiceImpl will actually remove the Order instance from the database.

Specified by:

cancelOrder in interface OrderService

deleteOrder

@Transactional(value="blTransactionManager")
public void deleteOrder(Order order)

Specified by:

deleteOrder in interface OrderService

addOfferCode

@Transactional(value="blTransactionManager")
public Order addOfferCode(Order order,
                                        OfferCode offerCode,
                                        boolean priceOrder)
                   throws PricingException,
                          OfferMaxUseExceededException

Description copied from interface: OrderService

Adds the given OfferCode to the order. Optionally prices the order as well

Specified by:

addOfferCode in interface OrderService

Returns:

the modified Order

Throws:

PricingException

OfferMaxUseExceededException

removeOfferCode

@Transactional(value="blTransactionManager")
public Order removeOfferCode(Order order,
                                           OfferCode offerCode,
                                           boolean priceOrder)
                      throws PricingException

Description copied from interface: OrderService

Remove the given OfferCode for the order. Optionally prices the order as well.

Specified by:

removeOfferCode in interface OrderService

Returns:

the modified Order

Throws:

PricingException

removeAllOfferCodes

@Transactional(value="blTransactionManager")
public Order removeAllOfferCodes(Order order,
                                               boolean priceOrder)
                          throws PricingException

Description copied from interface: OrderService

Removes all offer codes for the given order. Optionally prices the order as well.

Specified by:

removeAllOfferCodes in interface OrderService

Returns:

the modified Order

Throws:

PricingException

setDeleteEmptyNamedOrders

@ManagedAttribute(description="The delete empty named order after adding items to cart attribute",
                  currencyTimeLimit=15)
public void setDeleteEmptyNamedOrders(boolean deleteEmptyNamedOrders)

Description copied from interface: OrderService

Sets whether or not to delete named orders once all items have been removed.

Specified by:

setDeleteEmptyNamedOrders in interface OrderService

findLastMatchingItem

public OrderItem findLastMatchingItem(Order order,
                                      Long skuId,
                                      Long productId)

Description copied from interface: OrderService

Looks through the given order and returns the latest added OrderItem that matches on the skuId and productId. Generally, this is used to retrieve the OrderItem that was just added to the cart. The default Broadleaf implementation will attempt to match on skuId first, and failing that, it will look at the productId. Note that the behavior is slightly undeterministic in the case that setAutomaticallyMergeLikeItems is set to true and the last added sku matches on a previously added sku. In this case, the sku that has the merged items would be returned, so the total quantity of the OrderItem might not match exactly what was just added.

Specified by:

findLastMatchingItem in interface OrderService

Returns:

the best matching OrderItem with highest index in the list of OrderItems in the order

confirmOrder

@Transactional(value="blTransactionManager")
public Order confirmOrder(Order order)

Description copied from interface: OrderService

Changes the OrderStatus to SUBMITTED

Specified by:

confirmOrder in interface OrderService

Parameters:

order - to confirm

Returns:

the order that was confirmed

addAllItemsFromNamedOrder

@Transactional(value="blTransactionManager")
public Order addAllItemsFromNamedOrder(Order namedOrder,
                                                     boolean priceOrder)
                                throws RemoveFromCartException,
                                       AddToCartException

Description copied from interface: OrderService

Adds all orderItems to the current cart from the same Customer that owns the named order. This method will remove the item from the wishlist based on whether the setMoveNamedOrderItems flag is set. Note that any items that are in the wishlist but are no longer able to be added to a cart will still be removed from the wishlist. Note that this method does not change the association of the OrderItems to the new order -- instead, those OrderItems is completely removed and a new OrderItem that mirrors it is created.

Specified by:

addAllItemsFromNamedOrder in interface OrderService

Returns:

Throws:

RemoveFromCartException

AddToCartException

addItemFromNamedOrder

@Transactional(value="blTransactionManager")
public Order addItemFromNamedOrder(Order namedOrder,
                                                 OrderItem item,
                                                 boolean priceOrder)
                            throws RemoveFromCartException,
                                   AddToCartException

Description copied from interface: OrderService

Adds the passed in orderItem to the current cart for the same Customer that owns the named order. This method will remove the item from the wishlist based on whether the setMoveNamedOrderItems flag is set. Note that if an item was in a wishlist and is no longer able to be added to the cart, the item will still be removed from the wishlist. Note that this method does not change the association of the OrderItems to the new order -- instead, those OrderItems is completely removed and a new OrderItem that mirrors it is created.

Specified by:

addItemFromNamedOrder in interface OrderService

Returns:

the cart with the requested orderItem added to it

Throws:

RemoveFromCartException

AddToCartException

addItemFromNamedOrder

@Transactional(value="blTransactionManager")
public Order addItemFromNamedOrder(Order namedOrder,
                                                 OrderItem item,
                                                 int quantity,
                                                 boolean priceOrder)
                            throws RemoveFromCartException,
                                   AddToCartException,
                                   UpdateCartException

Description copied from interface: OrderService

This method performs the same function as addItemFromNamedOrder(Order, OrderItem, boolean) except that instead of adding all of the quantity from the named order to the cart, it will only add/move the specific quantity requested.

Specified by:

addItemFromNamedOrder in interface OrderService

Returns:

the cart with the requested orderItem added to it

Throws:

RemoveFromCartException

AddToCartException

UpdateCartException

See Also:

OrderService.addItemFromNamedOrder(Order, OrderItem, boolean)

addGiftWrapItemToOrder

@Transactional(value="blTransactionManager")
public OrderItem addGiftWrapItemToOrder(Order order,
                                                      GiftWrapOrderItemRequest itemRequest,
                                                      boolean priceOrder)
                                 throws PricingException

Description copied from interface: OrderService

Adds a GiftWrapItem to the order based on the itemRequest. A GiftWrapItem is a product (for example, a "Gift Box with Red Ribbon") that contains a list of OrderItems that should be wrapped by this GiftWrapItem. The OrderItems must already exist and belong to an order before they are able to be wrapped by the GiftWrapItem

Specified by:

addGiftWrapItemToOrder in interface OrderService

Returns:

the GiftWrapItem instance that was created and attached to the order

Throws:

PricingException

addItem

@Transactional(value="blTransactionManager",
               rollbackFor=AddToCartException.class)
public Order addItem(Long orderId,
                                                           OrderItemRequestDTO orderItemRequestDTO,
                                                           boolean priceOrder)
              throws AddToCartException

Description copied from interface: OrderService

Initiates the addItem workflow that will attempt to add the given quantity of the specified item to the Order. The item to be added can be determined in a few different ways. For example, the SKU can be specified directly or it can be determine based on a Product and potentially some specified ProductOptions for that given product. The minimum required parameters for OrderItemRequest are: productId and quantity or alternatively, skuId and quantity When priceOrder is false, the system will not reprice the order. This is more performant in cases such as bulk adds where the repricing could be done for the last item only. This method differs from the OrderService.addItemWithPriceOverrides(Long, OrderItemRequestDTO, boolean) in that it will clear any values set on the OrderItemRequestDTO for the overrideSalePrice or overrideRetailPrice. This design is intended to ensure that override pricing is not called by mistake. Implementors should use this method when no manual price overrides are allowed.

Specified by:

addItem in interface OrderService

Returns:

the order the item was added to

Throws:

AddToCartException

See Also:

OrderItemRequestDTO

addItemWithPriceOverrides

@Transactional(value="blTransactionManager",
               rollbackFor=AddToCartException.class)
public Order addItemWithPriceOverrides(Long orderId,
                                                                             OrderItemRequestDTO orderItemRequestDTO,
                                                                             boolean priceOrder)
                                throws AddToCartException

Description copied from interface: OrderService

Initiates the addItem workflow that will attempt to add the given quantity of the specified item to the Order. The item to be added can be determined in a few different ways. For example, the SKU can be specified directly or it can be determine based on a Product and potentially some specified ProductOptions for that given product. The minimum required parameters for OrderItemRequest are: productId and quantity or alternatively, skuId and quantity When priceOrder is false, the system will not reprice the order. This is more performant in cases such as bulk adds where the repricing could be done for the last item only. As opposed to the OrderService.addItem(Long, OrderItemRequestDTO, boolean) method, this method allows the passed in OrderItemRequestDTO to contain values for the overrideSale or overrideRetail price fields. This design is intended to ensure that override pricing is not called by mistake. Implementors should use this method when manual price overrides are allowed.

Specified by:

addItemWithPriceOverrides in interface OrderService

Returns:

the order the item was added to

Throws:

AddToCartException

See Also:

OrderItemRequestDTO

updateItemQuantity

@Transactional(value="blTransactionManager",
               rollbackFor={UpdateCartException.class,RemoveFromCartException.class})
public Order updateItemQuantity(Long orderId,
                                                                                                    OrderItemRequestDTO orderItemRequestDTO,
                                                                                                    boolean priceOrder)
                         throws UpdateCartException,
                                RemoveFromCartException

Description copied from interface: OrderService

Initiates the updateItem workflow that will attempt to update the item quantity for the specified OrderItem in the given Order. The new quantity is specified in the OrderItemRequestDTO Minimum required parameters for OrderItemRequest: orderItemId, quantity

Specified by:

updateItemQuantity in interface OrderService

Returns:

the order the item was added to

Throws:

UpdateCartException

RemoveFromCartException

See Also:

OrderItemRequestDTO

removeItem

@Transactional(value="blTransactionManager",
               rollbackFor=RemoveFromCartException.class)
public Order removeItem(Long orderId,
                                                                   Long orderItemId,
                                                                   boolean priceOrder)
                 throws RemoveFromCartException

Description copied from interface: OrderService

Initiates the removeItem workflow that will attempt to remove the specified OrderItem from the given Order

Specified by:

removeItem in interface OrderService

Returns:

the order the item was added to

Throws:

RemoveFromCartException

See Also:

OrderItemRequestDTO

getAutomaticallyMergeLikeItems

public boolean getAutomaticallyMergeLikeItems()

Specified by:

getAutomaticallyMergeLikeItems in interface OrderService

Returns:

whether or not like-items will be automatically merged

See Also:

OrderService.setAutomaticallyMergeLikeItems(boolean)

setAutomaticallyMergeLikeItems

public void setAutomaticallyMergeLikeItems(boolean automaticallyMergeLikeItems)

Description copied from interface: OrderService

When set to true, the system when items are added to the cart, they will automatically be merged. For example, when a user adds an item to the cart and then adds the item again, the item will have its quantity changed to 2 instead of the cart containing two separate items. If this logic needs to be more complex, it is possible to extend the behavior by overriding OrderOfferProcessor.buildIdentifier().

Specified by:

setAutomaticallyMergeLikeItems in interface OrderService

isMoveNamedOrderItems

@ManagedAttribute(description="The move item from named order when adding to the cart attribute",
                  currencyTimeLimit=15)
public boolean isMoveNamedOrderItems()

Specified by:

isMoveNamedOrderItems in interface OrderService

Returns:

whether items will be removed from the wishlist when added to the cart

See Also:

OrderService.setMoveNamedOrderItems(boolean)

setMoveNamedOrderItems

@ManagedAttribute(description="The move item from named order when adding to the cart attribute",
                  currencyTimeLimit=15)
public void setMoveNamedOrderItems(boolean moveNamedOrderItems)

Description copied from interface: OrderService

Determines whether or not items will be removed from the named order (wishlist) when they are moved to the Customer's current cart.

Specified by:

setMoveNamedOrderItems in interface OrderService

isDeleteEmptyNamedOrders

@ManagedAttribute(description="The delete empty named order after adding items to cart attribute",
                  currencyTimeLimit=15)
public boolean isDeleteEmptyNamedOrders()

Specified by:

isDeleteEmptyNamedOrders in interface OrderService

Returns:

whether empty wishlists will be deleted automatically

See Also:

OrderService.setDeleteEmptyNamedOrders(boolean)

removeAllPaymentsFromOrder

@Transactional(value="blTransactionManager")
public void removeAllPaymentsFromOrder(Order order)

Description copied from interface: OrderService

Deletes all the Payment Info's on the order.

Specified by:

removeAllPaymentsFromOrder in interface OrderService

removePaymentsFromOrder

@Transactional(value="blTransactionManager")
public void removePaymentsFromOrder(Order order,
                                                  PaymentInfoType paymentInfoType)

Description copied from interface: OrderService

Deletes the Payment Info of the passed in type from the order Note that this method will also delete any associated Secure Payment Infos if necessary.

Specified by:

removePaymentsFromOrder in interface OrderService

removePaymentFromOrder

@Transactional(value="blTransactionManager")
public void removePaymentFromOrder(Order order,
                                                 PaymentInfo paymentInfo)

Description copied from interface: OrderService

Deletes the Payment Info from the order. Note that this method will also delete any associated Secure Payment Infos if necessary.

Specified by:

removePaymentFromOrder in interface OrderService

getCartOperationExceptionRootCause

protected Throwable getCartOperationExceptionRootCause(WorkflowException e)

This method will return the exception that is immediately below the deepest WorkflowException in the current stack trace.

Parameters:

e - the workflow exception that contains the requested root cause

Returns:

the root cause of the workflow exception

compareAttributes

protected boolean compareAttributes(Map<String,OrderItemAttribute> item1Attributes,
                                    OrderItemRequestDTO item2)

Returns true if the two items attributes exactly match.

Parameters:

item1 -

item2 -

Returns:

itemMatches

protected boolean itemMatches(Sku item1Sku,
                              Product item1Product,
                              Map<String,OrderItemAttribute> item1Attributes,
                              OrderItemRequestDTO item2)

findMatchingItem

protected OrderItem findMatchingItem(Order order,
                                     OrderItemRequestDTO itemToFind)