Package org.broadleafcommerce.core.order.service

Class OrderServiceImpl

java.lang.Object
org.broadleafcommerce.core.order.service.OrderServiceImpl
All Implemented Interfaces:
OrderService
@Service("blOrderService") @ManagedResource(objectName="org.broadleafcommerce:name=OrderService", description="Order Service", currencyTimeLimit=15) public class OrderServiceImpl extends Object implements OrderService
Author:
apazzolini

  • Field Details

    • paymentDao

      protected OrderPaymentDao paymentDao

    • orderDao

      protected OrderDao orderDao

    • offerDao

      protected OfferDao offerDao

    • nullOrderFactory

      protected NullOrderFactory nullOrderFactory

    • customerService

      protected CustomerService customerService

    • 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("${pricing.retry.count.for.lock.failure}") protected int pricingRetryCountForLockFailure

    • pricingRetryWaitIntervalForLockFailure

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

    • autoFlushAddToCart

      @Value("${auto.flush.on.query.during.add.to.cart:false}") protected boolean autoFlushAddToCart
      Advanced setting. Should Hibernate auto flush before queries during an add-to-cart workflow. This should generally be able to be left false. This is a performance measure and add-to-cart operations will be more efficient when this is false.

    • autoFlushUpdateCart

      @Value("${auto.flush.on.query.during.update.cart:false}") protected boolean autoFlushUpdateCart
      Advanced setting. Should Hibernate auto flush before queries during an update-cart workflow. This should generally be able to be left false. This is a performance measure and update-cart operations will be more efficient when this is false.

    • autoFlushRemoveFromCart

      @Value("${auto.flush.on.query.during.remove.from.cart:false}") protected boolean autoFlushRemoveFromCart
      Advanced setting. Should Hibernate auto flush before queries during an remove-from-cart workflow. This should generally be able to be left false. This is a performance measure and remove-from-cart operations will be more efficient when this is false.

    • autoFlushSaveCart

      @Value("${auto.flush.on.query.during.cart.pricing.save:false}") protected boolean autoFlushSaveCart
      Advanced setting. Should Hibernate auto flush before queries during an order save pricing flow. This should generally be able to be left false. This is a performance measure and save operations will be more efficient when this is false.

    • em

      protected jakarta.persistence.EntityManager em

    • moveNamedOrderItems

      protected boolean moveNamedOrderItems

    • deleteEmptyNamedOrders

      protected boolean deleteEmptyNamedOrders

    • automaticallyMergeLikeItems

      protected Boolean automaticallyMergeLikeItems

    • orderMultishipOptionService

      protected OrderMultishipOptionService orderMultishipOptionService

    • offerServiceExtensionManager

      protected OfferServiceExtensionManager offerServiceExtensionManager

  • Constructor Details

    • OrderServiceImpl

      public OrderServiceImpl()

  • Method Details

    • createNewCartForCustomer

      @Transactional("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:
      • org.broadleafcommerce.profile.web.core.CustomerState#getCustomer()

    • createNamedOrderForCustomer

      @Transactional("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:

    • 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

    • findOrdersByIds

      public List<Order> findOrdersByIds(List<Long> orderIds)
      Description copied from interface: OrderService
      Looks up a list of Orders by their database ids
      Specified by:
      findOrdersByIds in interface OrderService
      Returns:
      a list of Orders

    • 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:

    • 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

    • findOrdersByDateRange

      public List<Order> findOrdersByDateRange(Date startDate, Date endDate)
      Specified by:
      findOrdersByDateRange in interface OrderService

    • findOrdersByDaysCount

      public List<Order> findOrdersByDaysCount(Integer daysCount, Integer batchSize)
      Specified by:
      findOrdersByDaysCount in interface OrderService

    • findOrdersForCustomersInDateRange

      public List<Order> findOrdersForCustomersInDateRange(List<Long> customerIds, Date startDate, Date endDate)
      Specified by:
      findOrdersForCustomersInDateRange in interface OrderService

    • 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("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, boolean repriceItems) throws PricingException
      Description copied from interface: OrderService
      Saves the given order while optionally repricing the order (meaning, going through the pricing workflow) along with updating the prices of individual items in the order, as opposed to just pricing taxes/shipping/etc.
      Specified by:
      save in interface OrderService
      repriceItems - whether or not to reprice the items inside of the order via Order.updatePrices()
      Returns:
      the persisted Order, which will be a different instance than the Order passed in
      Throws:
      PricingException

    • 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("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("blTransactionManager") public void deleteOrder(Order order)
      Specified by:
      deleteOrder in interface OrderService

    • addOfferCode

      @Transactional("blTransactionManager") public Order addOfferCode(Order order, OfferCode offerCode, boolean priceOrder) throws PricingException, OfferException
      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
      OfferException

    • addOfferCodes

      @Transactional("blTransactionManager") public Order addOfferCodes(Order order, List<OfferCode> offerCodes, boolean priceOrder) throws PricingException, OfferException
      Description copied from interface: OrderService
      Adds the given OfferCodes to the order. Optionally prices the order as well.
      Specified by:
      addOfferCodes in interface OrderService
      Returns:
      Throws:
      PricingException
      OfferMaxUseExceededException
      OfferException

    • removeOfferCode

      @Transactional("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("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

    • 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 OrderService.setAutomaticallyMergeLikeItems(boolean) 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("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("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 OrderService.setMoveNamedOrderItems(boolean) 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("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 OrderService.setMoveNamedOrderItems(boolean) 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("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:

    • addGiftWrapItemToOrder

      @Transactional("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:

    • 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:

    • getTotalChildOrderItems

      public int getTotalChildOrderItems(OrderItemRequestDTO orderItemRequestDTO)
      Specified by:
      getTotalChildOrderItems in interface OrderService

    • addChildItems

      public void addChildItems(OrderItemRequestDTO orderItemRequestDTO, int numAdditionRequests, int currentAddition, ProcessContext<CartOperationRequest> context, List<ActivityMessageDTO> orderMessages) throws WorkflowException
      Specified by:
      addChildItems in interface OrderService
      Throws:
      WorkflowException

    • addDependentOrderItem

      public void addDependentOrderItem(OrderItemRequestDTO parentOrderItemRequest, OrderItemRequestDTO dependentOrderItem)
      Specified by:
      addDependentOrderItem in interface OrderService

    • 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:

    • 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:

    • findAllChildrenToRemove

      protected void findAllChildrenToRemove(List<Long> childrenToRemove, OrderItem orderItem)

    • removeItemInternal

      protected Order removeItemInternal(Long orderId, Long orderItemId, boolean priceOrder) throws WorkflowException
      Throws:
      WorkflowException

    • findOrderByIdOrByOrderItemId

      protected Order findOrderByIdOrByOrderItemId(Long orderId, Long orderItemId)

    • 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:

    • 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:

    • 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:

    • 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

    • removeAllPaymentsFromOrder

      @Transactional("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("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

    • removeCreditCardPaymentsFromOrder

      @Transactional("blTransactionManager") public void removeCreditCardPaymentsFromOrder(Order order)
      Specified by:
      removeCreditCardPaymentsFromOrder in interface OrderService

    • removePaymentFromOrder

      @Transactional("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:
      item1Attributes -
      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

    • reloadOrder

      public Order reloadOrder(Order order)
      Description copied from interface: OrderService
      Detaches the given order from the current entity manager and then reloads a fresh version from the database.
      Specified by:
      reloadOrder in interface OrderService
      Returns:
      the newly read order

    • acquireLock

      @Transactional("blTransactionManager") public boolean acquireLock(Order order)
      Specified by:
      acquireLock in interface OrderService
      Returns:
      whether or not the lock was acquired
      See Also:

    • releaseLock

      public boolean releaseLock(Order order)
      Specified by:
      releaseLock in interface OrderService
      Returns:
      whether or not the lock was released
      See Also:

    • 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

    • preValidateUpdateQuantityOperation

      public void preValidateUpdateQuantityOperation(Order cart, OrderItemRequestDTO dto)
      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 an update quantity operation.
      Specified by:
      preValidateUpdateQuantityOperation in interface OrderService

    • refresh

      public void refresh(Order order)
      Specified by:
      refresh in interface OrderService

    • findCartForCustomerWithEnhancements

      public Order findCartForCustomerWithEnhancements(Customer customer)
      Description copied from interface: OrderService
      Retrieve an enhanced version of the cart for the customer. Enhanced carts are generally provided by commercial Broadleaf modules.
      Specified by:
      findCartForCustomerWithEnhancements in interface OrderService
      Parameters:
      customer - the user for whom the enhanced cart is retrieved
      Returns:
      the enhanced cart, or the basic cart if no enhancement is available

    • findCartForCustomerWithEnhancements

      public Order findCartForCustomerWithEnhancements(Customer customer, Order candidateOrder)
      Description copied from interface: OrderService
      For the customer, use the candidateOrder as the source of enhancement for generating an enhanced cart. Enhanced carts are generally provided by commercial Broadleaf modules.
      Specified by:
      findCartForCustomerWithEnhancements in interface OrderService
      Parameters:
      customer - the user for whom the enhanced cart is generated
      candidateOrder - the source of enhancement
      Returns:
      the enhanced cart, or the untouched candidateOrder if no enhancement is available

    • findOrdersByEmail

      public List<Order> findOrdersByEmail(String email)
      Description copied from interface: OrderService
      Looks up all Orders for the specified email, regardless of current OrderStatus
      Specified by:
      findOrdersByEmail in interface OrderService
      Returns:
      the requested Orders

    • readBatchOrders

      public List<Order> readBatchOrders(int start, int pageSize, List<OrderStatus> orderStatusList)
      Specified by:
      readBatchOrders in interface OrderService

    • readNumberOfOrders

      public Long readNumberOfOrders()
      Specified by:
      readNumberOfOrders in interface OrderService