protected OrderItem findMatchingBundleItem(Order order, BundleOrderItem itemToFind) { for (int i=(order.getOrderItems().size()-1); i >= 0; i--) { OrderItem currentItem = (order.getOrderItems().get(i)); if (currentItem instanceof BundleOrderItem) { if (bundleItemMatches((BundleOrderItem) currentItem, itemToFind)) { return currentItem; } } } return null; }
protected List<DiscreteOrderItem> getOrderItems(Order order) { List<DiscreteOrderItem> orderItems = new ArrayList<>(); for (OrderItem oi : order.getOrderItems()) { if (oi instanceof DiscreteOrderItem) { orderItems.add((DiscreteOrderItem) oi); } else if (oi instanceof BundleOrderItem) { orderItems.addAll(((BundleOrderItem) oi).getDiscreteOrderItems()); } } return orderItems; }
@Override public ExtensionResultStatusType attachAdditionalDataToOrder(Order order, boolean priceOrder) { for (OrderItem orderItem : order.getOrderItems()) { updateOrderItemCartMessages(orderItem); } return ExtensionResultStatusType.HANDLED_CONTINUE; }
@Override public Order removeItemFromOrder(Order order, OrderItem item, boolean priceOrder) throws PricingException { fulfillmentGroupService.removeOrderItemFromFullfillmentGroups(order, item); OrderItem itemFromOrder = order.getOrderItems().remove(order.getOrderItems().indexOf(item)); itemFromOrder.setOrder(null); orderItemService.delete(itemFromOrder); order = updateOrder(order, priceOrder); return order; }
public Order moveItemToOrder(Order originalOrder, Order destinationOrder, OrderItem item, boolean priceOrder) throws PricingException { fulfillmentGroupService.removeOrderItemFromFullfillmentGroups(originalOrder, item); OrderItem itemFromOrder = originalOrder.getOrderItems().remove(originalOrder.getOrderItems().indexOf(item)); itemFromOrder.setOrder(null); originalOrder = updateOrder(originalOrder, priceOrder); addOrderItemToOrder(destinationOrder, item, priceOrder); return destinationOrder; }
protected Order removeItemFromOrder(Order order, OrderItem item, boolean priceOrder) throws PricingException { fulfillmentGroupService.removeOrderItemFromFullfillmentGroups(order, item); OrderItem itemFromOrder = order.getOrderItems().remove(order.getOrderItems().indexOf(item)); itemFromOrder.setOrder(null); orderItemService.delete(itemFromOrder); order = orderService.save(order, priceOrder); return order; }
protected OrderItem addOrderItemToOrder(Order order, OrderItem newOrderItem, Boolean priceOrder) throws PricingException { List<OrderItem> orderItems = order.getOrderItems(); newOrderItem.setOrder(order); newOrderItem = orderItemService.saveOrderItem(newOrderItem); orderItems.add(newOrderItem); order = orderService.save(order, priceOrder); return newOrderItem; }
@Override @Transactional("blTransactionManager") public OrderItem addGiftWrapItemToOrder(Order order, GiftWrapOrderItemRequest itemRequest, boolean priceOrder) throws PricingException { GiftWrapOrderItem item = orderItemService.createGiftWrapOrderItem(itemRequest); item.setOrder(order); item = (GiftWrapOrderItem) orderItemService.saveOrderItem(item); order.getOrderItems().add(item); order = save(order, priceOrder); return item; }
private int countPriceDetails(Order order) { int count = 0; for (OrderItem item : order.getOrderItems()) { count = count + item.getOrderItemPriceDetails().size(); } return count; }
@Test(groups = { "getItemsForOrder" }, dependsOnGroups = { "removeBundleFromOrder" }) @Transactional public void getItemsForOrder() { Order order = orderService.findOrderById(orderId); List<OrderItem> orderItems = order.getOrderItems(); assert orderItems != null; assert orderItems.size() == numOrderItems - 1; }
@Test(groups = { "checkOrderItems" }, dependsOnGroups = { "removeItemFromOrder" }) @Transactional public void checkOrderItems() throws PricingException { Order order = orderService.findOrderById(orderId); // The removal from the removeBundleFromOrder() has actually persisted. // However, the previous two transactions were rolled back and thus the items still exist. assert order.getOrderItems().size() == 1; // As mentioned, the bundleOrderItem however has gone away BundleOrderItem bundleOrderItem = (BundleOrderItem) orderItemService.readOrderItemById(bundleOrderItemId); assert bundleOrderItem == null; }
@Test(groups = { "testCartAndNamedOrder" }) @Transactional public void testMoveAllItemsToCartFromNamedOrder() throws RemoveFromCartException, AddToCartException { Order namedOrder = setUpNamedOrder(); List<OrderItem> namedOrderItems = new ArrayList<>(); namedOrderItems.addAll(namedOrder.getOrderItems()); Order cart = orderService.createNewCartForCustomer(namedOrder.getCustomer()); cart = orderService.addAllItemsFromNamedOrder(namedOrder, true); assert cartContainsOnlyTheseItems(cart, namedOrderItems); assert namedOrder.getOrderItems().size() == 0; }
private int countItemQualifiers(Order order) { int qualifierCount = 0; for (OrderItem item : order.getOrderItems()) { for (OrderItemQualifier qualifier : item.getOrderItemQualifiers()) { qualifierCount = qualifierCount += qualifier.getQuantity(); } } return qualifierCount; }
@Test(groups = { "testCartAndNamedOrder" }) @Transactional public void testAddAllItemsToCartFromNamedOrderWithoutExistingCart() throws RemoveFromCartException, AddToCartException { Order namedOrder = setUpNamedOrder(); List<OrderItem> namedOrderItems = new ArrayList<>(); namedOrderItems.addAll(namedOrder.getOrderItems()); orderService.setMoveNamedOrderItems(false); Order cart = orderService.addAllItemsFromNamedOrder(namedOrder, true); orderService.setMoveNamedOrderItems(true); assert cartContainsOnlyTheseItems(cart, namedOrderItems); }
private int checkOrderItemOfferAppliedCount(Order order) { int count = 0; for (OrderItem item : order.getOrderItems()) { for (OrderItemPriceDetail detail : item.getOrderItemPriceDetails()) { count = count + (detail.getOrderItemPriceDetailAdjustments().size() * detail.getQuantity()); } } return count; }
@Test(groups = { "testCartAndNamedOrder" }) @Transactional public void testAddAllItemsToCartFromNamedOrder() throws RemoveFromCartException, AddToCartException { Order namedOrder = setUpNamedOrder(); List<OrderItem> namedOrderItems = new ArrayList<>(); namedOrderItems.addAll(namedOrder.getOrderItems()); Order cart = orderService.createNewCartForCustomer(namedOrder.getCustomer()); orderService.setMoveNamedOrderItems(false); cart = orderService.addAllItemsFromNamedOrder(namedOrder, true); orderService.setMoveNamedOrderItems(true); assert cartContainsOnlyTheseItems(cart, namedOrderItems); }
@Transactional @Test(groups = { "testMergeCart" }) public void testMergeWithInactiveAnonymousCart() throws PricingException, RemoveFromCartException, AddToCartException { Order anonymousCart = null; Order customerCart = setUpCartWithInactiveSku(); Customer customer = customerCart.getCustomer(); MergeCartResponse response = mergeCartService.mergeCart(customer, anonymousCart); assert response.getOrder().getOrderItems().size() == 0; assert response.getOrder().getId().equals(customerCart.getId()); assert response.isMerged() == false; }
@Transactional @Test(groups = { "testMergeCart" }) public void testMergeWithBothCarts() throws PricingException, RemoveFromCartException, AddToCartException { Order anonymousCart = setUpCartWithActiveSku(); Order customerCart = setUpCartWithActiveSku(); Customer customer = customerCart.getCustomer(); MergeCartResponse response = mergeCartService.mergeCart(customer, anonymousCart); assert response.getOrder().getOrderItems().size() == 1; assert response.getOrder().getId().equals(anonymousCart.getId()); assert response.isMerged() == false; }
@Transactional @Test(groups = { "testMergeCart" }) public void testMergeWithNoCustomerCart() throws PricingException, RemoveFromCartException, AddToCartException { Order anonymousCart = setUpCartWithActiveSku(); Order customerCart = null; Customer customer = customerService.saveCustomer(createNamedCustomer()); MergeCartResponse response = mergeCartService.mergeCart(customer, anonymousCart); assert response.getOrder().getOrderItems().size() == 1; assert response.getOrder().getId().equals(anonymousCart.getId()); assert response.isMerged() == false; }
@Override public OrderItem answer() throws Throwable { Order order = (Order) EasyMock.getCurrentArguments()[0]; order.getOrderItems().add((OrderItem) EasyMock.getCurrentArguments()[1]); if (((OrderItem) EasyMock.getCurrentArguments()[1]).getId() == null) { ((OrderItem) EasyMock.getCurrentArguments()[1]).setId(OfferDataItemProvider.getOrderItemId()); } return (OrderItem) EasyMock.getCurrentArguments()[1]; } };