OrderServiceImpl (BroadleafCommerce Framework 3.1.3-GA API)

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

Fields
Modifier and Type	Field and Description
`protected Processor`	`addItemWorkflow`
`protected boolean`	`automaticallyMergeLikeItems`
`protected boolean`	`deleteEmptyNamedOrders`
`protected OrderServiceExtensionManager`	`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 OrderMultishipOptionService`	`orderMultishipOptionService`
`protected OrderPaymentDao`	`paymentDao`
`protected int`	`pricingRetryCountForLockFailure`
`protected long`	`pricingRetryWaitIntervalForLockFailure`
`protected PricingService`	`pricingService`
`protected Processor`	`removeItemWorkflow`
`protected SecureOrderPaymentService`	`securePaymentInfoService`
`protected org.springframework.transaction.PlatformTransactionManager`	`transactionManager`
`protected Processor`	`updateItemWorkflow`

Constructor Summary

Constructors
Constructor and Description

OrderServiceImpl()

Constructors
Constructor and Description
`OrderServiceImpl()`

Method Summary

Methods
Modifier and Type	Method and Description
`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.
`OrderPayment`	`addPaymentToOrder(Order order, OrderPayment payment, Referenced securePaymentInfo)` Associates a given OrderPayment with an Order and then saves the 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)`
`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`	`findOrderById(Long orderId, boolean refresh)` Looks up an Order by its database id and optionally calls refresh to ensure that the entity manager pulls the instance from the DB and not from cache
`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<OrderPayment>`	`findPaymentsForOrder(Order order)` Returns all OrderPayment 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)`
`void`	`preValidateCartOperation(Order cart)` Invokes the extension handler of the same name to provide the ability for a module to throw an exception and interrupt a cart operation.
`void`	`printOrder(Order order, org.apache.commons.logging.Log log)` This debugging method will print out a console-suitable representation of the current state of the order, including the items in the order and all pricing related information for the order.
`Order`	`removeAllOfferCodes(Order order, boolean priceOrder)` Removes all offer codes for the given order.
`void`	`removeAllPaymentsFromOrder(Order order)` Deletes all the OrderPayment Info's on the order.
`Order`	`removeInactiveItems(Long orderId, boolean priceOrder)`
`Order`	`removeItem(Long orderId, Long orderItemId, boolean priceOrder)` Initiates the removeItem workflow that will attempt to remove the specified OrderItem from the given Order
`protected Order`	`removeItemInternal(Long orderId, Long orderItemId, boolean priceOrder)`
`Order`	`removeOfferCode(Order order, OfferCode offerCode, boolean priceOrder)` Remove the given OfferCode for the order.
`void`	`removePaymentFromOrder(Order order, OrderPayment payment)` Deletes the OrderPayment Info from the order.
`void`	`removePaymentsFromOrder(Order order, PaymentType paymentInfoType)` Deletes the OrderPayment Info of the passed in type from the order Note that this method will also delete any associated Secure OrderPayment 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.
`Order`	`updateProductOptionsForItem(Long orderId, OrderItemRequestDTO orderItemRequestDTO, boolean priceOrder)` Since required product option can be added after the item is in the cart, we use this method to apply product option on an existing item in the cart.

Methods inherited from class java.lang.Object
clone, equals, finalize, getClass, hashCode, notify, notifyAll, toString, wait, wait, wait

- Field Detail
  - paymentDao
```
protected OrderPaymentDao paymentDao
```
  - 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 SecureOrderPaymentService securePaymentInfoService
```
  - mergeCartService
```
protected MergeCartService mergeCartService
```
  - extensionManager
```
protected OrderServiceExtensionManager extensionManager
```
  - addItemWorkflow
```
protected Processor addItemWorkflow
```
  - updateItemWorkflow
```
protected Processor updateItemWorkflow
```
  - removeItemWorkflow
```
protected Processor 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
```
@Value(value="${automatically.merge.like.items}")
protected boolean automaticallyMergeLikeItems
```
  - orderMultishipOptionService
```
protected OrderMultishipOptionService orderMultishipOptionService
```
- 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
  - findOrderById
```
public Order findOrderById(Long orderId,
                  boolean refresh)
```
    Description copied from interface: OrderService
    
    Looks up an Order by its database id and optionally calls refresh to ensure that the entity manager pulls the instance from the DB and not from cache
    
    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
  - findPaymentsForOrder
```
public List<OrderPayment> findPaymentsForOrder(Order order)
```
    Description copied from interface: OrderService
    
    Returns all OrderPayment objects that are associated with the given order
    
    Specified by:
    
    findPaymentsForOrder in interface OrderService
    
    Returns:
    the list of all OrderPayment objects
  - addPaymentToOrder
```
@Transactional(value="blTransactionManager")
public OrderPayment addPaymentToOrder(Order order,
                                           OrderPayment payment,
                                           Referenced securePaymentInfo)
```
    Description copied from interface: OrderService
    
    Associates a given OrderPayment with an Order and then saves the 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 OrderPayment
  - 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
  - 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
  - removeItemInternal
```
protected Order removeItemInternal(Long orderId,
                       Long orderItemId,
                       boolean priceOrder)
                            throws WorkflowException
```
    Throws:
    
    WorkflowException
  - removeInactiveItems
```
@Transactional(value="blTransactionManager",
               rollbackFor=RemoveFromCartException.class)
public Order removeInactiveItems(Long orderId,
                                                                   boolean priceOrder)
                          throws RemoveFromCartException
```
    Specified by:
    
    removeInactiveItems in interface OrderService
    
    Throws:
    
    RemoveFromCartException
  - 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 OrderPayment Info's on the order.
    
    Specified by:
    
    removeAllPaymentsFromOrder in interface OrderService
  - removePaymentsFromOrder
```
@Transactional(value="blTransactionManager")
public void removePaymentsFromOrder(Order order,
                                         PaymentType paymentInfoType)
```
    Description copied from interface: OrderService
    
    Deletes the OrderPayment Info of the passed in type from the order Note that this method will also delete any associated Secure OrderPayment Infos if necessary.
    
    Specified by:
    
    removePaymentsFromOrder in interface OrderService
  - removePaymentFromOrder
```
@Transactional(value="blTransactionManager")
public void removePaymentFromOrder(Order order,
                                        OrderPayment payment)
```
    Description copied from interface: OrderService
    
    Deletes the OrderPayment Info from the order. Note that this method will also delete any associated Secure OrderPayment 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)
```
  - updateProductOptionsForItem
```
@Transactional(value="blTransactionManager",
               rollbackFor=UpdateCartException.class)
public Order updateProductOptionsForItem(Long orderId,
                                                                       OrderItemRequestDTO orderItemRequestDTO,
                                                                       boolean priceOrder)
                                  throws UpdateCartException
```
    Description copied from interface: OrderService
    
    Since required product option can be added after the item is in the cart, we use this method to apply product option on an existing item in the cart. No validation will happen at this time, as the validation at checkout will take care of any missing product options.
    
    Specified by:
    
    updateProductOptionsForItem in interface OrderService
    
    Returns:
    Order
    
    Throws:
    
    UpdateCartException
  - printOrder
```
public void printOrder(Order order,
              org.apache.commons.logging.Log log)
```
    Description copied from interface: OrderService
    
    This debugging method will print out a console-suitable representation of the current state of the order, including the items in the order and all pricing related information for the order.
    
    Specified by:
    
    printOrder in interface OrderService
    
    Parameters:
    order - the order to debug
    log - the Log to use to print a debug-level message
  - preValidateCartOperation
```
public void preValidateCartOperation(Order cart)
```
    Description copied from interface: OrderService
    
    Invokes the extension handler of the same name to provide the ability for a module to throw an exception and interrupt a cart operation.
    
    Specified by:
    
    preValidateCartOperation in interface OrderService

Class OrderServiceImpl

Field Summary

Constructor Summary

Method Summary

Methods inherited from class java.lang.Object

Field Detail

paymentDao

orderDao

offerDao

nullOrderFactory

pricingService

orderItemService

fulfillmentGroupService

offerService

securePaymentInfoService

mergeCartService

extensionManager

addItemWorkflow

updateItemWorkflow

removeItemWorkflow

transactionManager

pricingRetryCountForLockFailure

pricingRetryWaitIntervalForLockFailure

moveNamedOrderItems

deleteEmptyNamedOrders

automaticallyMergeLikeItems

orderMultishipOptionService

Constructor Detail

OrderServiceImpl

Method Detail

createNewCartForCustomer

createNamedOrderForCustomer

findNamedOrderForCustomer

findOrderById

findOrderById

getNullOrder

findCartForCustomer

findOrdersForCustomer

findOrdersForCustomer

findOrderByOrderNumber

findPaymentsForOrder

addPaymentToOrder

save

persist

cancelOrder

deleteOrder

addOfferCode

removeOfferCode

removeAllOfferCodes

setDeleteEmptyNamedOrders

findLastMatchingItem

confirmOrder

addAllItemsFromNamedOrder

addItemFromNamedOrder

addItemFromNamedOrder

addGiftWrapItemToOrder

addItem

addItemWithPriceOverrides

updateItemQuantity

removeItem

removeItemInternal

removeInactiveItems

getAutomaticallyMergeLikeItems

setAutomaticallyMergeLikeItems

isMoveNamedOrderItems

setMoveNamedOrderItems

isDeleteEmptyNamedOrders

removeAllPaymentsFromOrder

removePaymentsFromOrder

removePaymentFromOrder

getCartOperationExceptionRootCause

compareAttributes

itemMatches

findMatchingItem

updateProductOptionsForItem

printOrder

preValidateCartOperation