@Override @Transactional("blTransactionManager") public Order removeAllFulfillmentGroupsFromOrder(Order order, boolean priceOrder) throws PricingException { if (order.getFulfillmentGroups() != null) { for (Iterator<FulfillmentGroup> iterator = order.getFulfillmentGroups().iterator(); iterator.hasNext();) { FulfillmentGroup fulfillmentGroup = iterator.next(); iterator.remove(); fulfillmentGroupDao.delete(fulfillmentGroup); } 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; }
public String moveListToCart(HttpServletRequest request, HttpServletResponse response, Model model, String wishlistName) throws RemoveFromCartException, AddToCartException, PricingException { Order wishlist = orderService.findNamedOrderForCustomer(wishlistName, CustomerState.getCustomer()); Order cartOrder = orderService.addAllItemsFromNamedOrder(wishlist, false); cartOrder = orderService.save(cartOrder, true); model.addAttribute("wishlist", wishlist); return getAccountWishlistRedirect(); }
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; }
public String updateQuantityInWishlist(HttpServletRequest request, HttpServletResponse response, Model model, String wishlistName, OrderItemRequestDTO itemRequest) throws IOException, UpdateCartException, PricingException, RemoveFromCartException { Order wishlist = orderService.findNamedOrderForCustomer(wishlistName, CustomerState.getCustomer()); wishlist = orderService.updateItemQuantity(wishlist.getId(), itemRequest, true); wishlist = orderService.save(wishlist, false); model.addAttribute("wishlist", wishlist); return getAccountWishlistView(); }
public String moveItemToCart(HttpServletRequest request, HttpServletResponse response, Model model, String wishlistName, Long orderItemId) throws RemoveFromCartException, AddToCartException, PricingException { Order wishlist = orderService.findNamedOrderForCustomer(wishlistName, CustomerState.getCustomer()); List<OrderItem> orderItems = wishlist.getOrderItems(); OrderItem orderItem = null; for (OrderItem item : orderItems) { if (orderItemId.equals(item.getId())) { orderItem = item; break; } } if (orderItem != null) { Order cartOrder = orderService.addItemFromNamedOrder(wishlist, orderItem, false); cartOrder = orderService.save(cartOrder, true); } else { throw new IllegalArgumentException("The item id provided was not found in the wishlist"); } model.addAttribute("wishlist", wishlist); return getAccountWishlistRedirect(); }
@Override public void addOrderAttributeToOrder(Long orderId, String orderAttributeKey, String orderAttributeValue) throws PaymentException { Order currentCart = CartState.getCart(); Long currentCartId = currentCart.getId(); if (orderId != null && !currentCartId.equals(orderId)) { logWarningIfCartMismatch(currentCartId, orderId); currentCart = orderService.findOrderById(orderId); } OrderAttribute orderAttribute = new OrderAttributeImpl(); orderAttribute.setName(orderAttributeKey); orderAttribute.setValue(orderAttributeValue); orderAttribute.setOrder(currentCart); currentCart.getOrderAttributes().put(orderAttributeKey, orderAttribute); try { orderService.save(currentCart, false); } catch (PricingException e) { throw new PaymentException(e); } }
public String add(HttpServletRequest request, HttpServletResponse response, Model model, AddToCartItem itemRequest, String wishlistName) throws IOException, AddToCartException, PricingException { Order wishlist = orderService.findNamedOrderForCustomer(wishlistName, CustomerState.getCustomer(request)); if (wishlist == null) { wishlist = orderService.createNamedOrderForCustomer(wishlistName, CustomerState.getCustomer(request)); } wishlist = orderService.addItem(wishlist.getId(), itemRequest, false); wishlist = orderService.save(wishlist, true); return getAccountWishlistRedirect(); }
@Override public ProcessContext<CartOperationRequest> execute(ProcessContext<CartOperationRequest> context) throws Exception { CartOperationRequest request = context.getSeedData(); OrderItemRequestDTO orderItemRequestDTO = request.getItemRequest(); Order order = request.getOrder(); if (orderItemService.readOrderItemById(Long.valueOf(orderItemRequestDTO.getOrderItemId())) != null) { DiscreteOrderItemRequest itemRequest = new DiscreteOrderItemRequest(); itemRequest.setItemAttributes(orderItemRequestDTO.getItemAttributes()); orderItemService.updateDiscreteOrderItem(orderItemService.readOrderItemById(Long.valueOf(orderItemRequestDTO.getOrderItemId())), itemRequest); } order = orderService.save(order, false); request.setOrder(order); return context; }
@Test(groups = { "testReadOrdersForCustomer" }, dependsOnGroups = { "findNamedOrderForCustomer" }) @Transactional public void testReadOrdersForCustomer() throws PricingException { Customer customer = customerService.createCustomerFromId(null); Order order = orderService.createNewCartForCustomer(customer); order.setStatus(OrderStatus.IN_PROCESS); order = orderService.save(order, false); List<Order> newOrders = orderService.findOrdersForCustomer(customer, OrderStatus.IN_PROCESS); boolean containsOrder = false; if (newOrders.contains(order)) { containsOrder = true; } assert containsOrder == true; containsOrder = false; newOrders = orderService.findOrdersForCustomer(customer, null); if (newOrders.contains(order)) { containsOrder = true; } assert containsOrder == true; }
@Test(groups = { "findNamedOrderForCustomer" }, dependsOnGroups = { "findOrderByOrderNumber" }) @Transactional public void findNamedOrderForCustomer() throws PricingException { Customer customer = customerService.createCustomerFromId(null); Order order = orderService.createNewCartForCustomer(customer); order.setStatus(OrderStatus.NAMED); order.setName("COOL ORDER"); order = orderService.save(order, false); Long orderId = order.getId(); Order newOrder = orderService.findNamedOrderForCustomer("COOL ORDER", customer); assert newOrder.getId().equals(orderId); }
@Test(groups = { "findOrderByOrderNumber" }, dependsOnGroups = { "findCartForAnonymousCustomer" }) @Transactional public void findOrderByOrderNumber() throws PricingException { Customer customer = customerService.createCustomerFromId(null); Order order = orderService.createNewCartForCustomer(customer); order.setOrderNumber("3456"); order = orderService.save(order, false); Long orderId = order.getId(); Order newOrder = orderService.findOrderByOrderNumber("3456"); assert newOrder.getId().equals(orderId); Order nullOrder = orderService.findOrderByOrderNumber(null); assert nullOrder == null; nullOrder = orderService.findOrderByOrderNumber(""); assert nullOrder == null; }
@Test(groups = { "testSubmitOrder" }, dependsOnGroups = { "findNamedOrderForCustomer" }) public void testSubmitOrder() throws PricingException { Customer customer = customerService.createCustomerFromId(null); Order order = orderService.createNewCartForCustomer(customer); order.setStatus(OrderStatus.IN_PROCESS); order = orderService.save(order, false); Long orderId = order.getId(); Order confirmedOrder = orderService.confirmOrder(order); confirmedOrder = orderService.findOrderById(confirmedOrder.getId()); Long confirmedOrderId = confirmedOrder.getId(); assert orderId.equals(confirmedOrderId); assert confirmedOrder.getStatus().equals(OrderStatus.SUBMITTED); }
@Test(groups = {"testOfferLowerSalePriceWithNotCombinableOfferAndInformation"}, dependsOnGroups = { "testOfferLowerSalePriceWithNotCombinableOffer"}) @Transactional public void testOfferLowerSalePriceWithNotCombinableOfferAndInformation() throws Exception { Order order = orderService.createNewCartForCustomer(createCustomer()); order.addOrderItem(createDiscreteOrderItem(sku1, 100D, 50D, true, 2, order)); order.addOrderItem(createDiscreteOrderItem(sku2, 100D, null, true, 2, order)); OfferCode offerCode1 = createOfferUtility.createOfferCode("20 Percent Off Item Offer", OfferType.ORDER_ITEM, OfferDiscountType.PERCENT_OFF, 20, null, true, true, 1); OfferCode offerCode2 = createOfferUtility.createOfferCode("30 Dollars Off Item Offer", OfferType.ORDER_ITEM, OfferDiscountType.AMOUNT_OFF, 30, null, true, false, 1); order.addOfferCode(offerCode1); order.addOfferCode(offerCode2); OfferInfo info1 = offerDao.createOfferInfo(); info1.getFieldValues().put("key1", "value1"); order.getAdditionalOfferInformation().put(offerCode1.getOffer(), info1); OfferInfo info2 = offerDao.createOfferInfo(); info2.getFieldValues().put("key2", "value2"); order.getAdditionalOfferInformation().put(offerCode2.getOffer(), info2); order = orderService.save(order, true); assert (order.getSubTotal().equals(new Money(180D))); order = orderService.findOrderById(order.getId()); assert(order.getAdditionalOfferInformation().get(offerCode1.getOffer()).equals(info1)); }
@Test(groups = {"testPercentageOffOffer"}, dependsOnGroups = { "offerCreateSku1", "offerCreateSku2" }) @Transactional public void testBOGOCombination() throws Exception { Order order = orderService.createNewCartForCustomer(createCustomer()); FixedPriceFulfillmentOption option = new FixedPriceFulfillmentOptionImpl(); option.setPrice(new Money(0)); orderService.save(order, false); order.addOrderItem(createDiscreteOrderItem(sku1, 1000D, null, true, 1, order)); order.addOrderItem(createDiscreteOrderItem(sku2, 100D, null, true, 2, order)); order.addOfferCode(createOfferUtility.createOfferCode("10 Percent Off All Item Offer", OfferType.ORDER_ITEM, OfferDiscountType.PERCENT_OFF, 10, null, false, true, 10)); order.addOfferCode(createOfferUtility.createOfferCode("NONAME", "30 Percent Off Second Item Sku2 Offer", OfferType.ORDER_ITEM, OfferDiscountType.PERCENT_OFF, 30, "discreteOrderItem.sku.id == " + sku2, false, true, 10, "discreteOrderItem.sku.id == " + sku2)); List<Offer> offers = offerService.buildOfferListForOrder(order); offerService.applyAndSaveOffersToOrder(offers, order); assert ( order.getSubTotal().equals(new Money(1070D) )); }
@Test(groups = {"testPercentageOffOffer"}, dependsOnGroups = { "offerCreateSku1", "offerCreateSku2" }) @Transactional public void testBOGOAmountOffCombination() throws Exception { Order order = orderService.createNewCartForCustomer(createCustomer()); FixedPriceFulfillmentOption option = new FixedPriceFulfillmentOptionImpl(); option.setPrice(new Money(0)); orderService.save(order, false); order.addOrderItem(createDiscreteOrderItem(sku1, 1000D, null, true, 1, order)); order.addOrderItem(createDiscreteOrderItem(sku2, 100D, null, true, 2, order)); order.addOfferCode(createOfferUtility.createOfferCode("10 Percent Off All Item Offer", OfferType.ORDER_ITEM, OfferDiscountType.PERCENT_OFF, 10, null, false, true, 10)); order.addOfferCode(createOfferUtility.createOfferCode("NONAME", "30 Amount Off Second Item Sku2 Offer", OfferType.ORDER_ITEM, OfferDiscountType.AMOUNT_OFF, 30, "discreteOrderItem.sku.id == " + sku2, false, true, 10, "discreteOrderItem.sku.id == " + sku2)); List<Offer> offers = offerService.buildOfferListForOrder(order); offerService.applyAndSaveOffersToOrder(offers, order); assert ( order.getSubTotal().equals(new Money(1070D) )); }
@Test(groups = {"testPercentageOffOffer"}, dependsOnGroups = { "offerCreateSku1", "offerCreateSku2" }) @Transactional public void testTwoPercentOffOffers() throws Exception { Order order = orderService.createNewCartForCustomer(createCustomer()); FixedPriceFulfillmentOption option = new FixedPriceFulfillmentOptionImpl(); option.setPrice(new Money(0)); orderService.save(order, false); order.addOrderItem(createDiscreteOrderItem(sku1, 1000D, null, true, 1, order)); order.addOrderItem(createDiscreteOrderItem(sku2, 100D, null, true, 1, order)); order.addOfferCode(createOfferUtility.createOfferCode("10 Percent Off All Item Offer", OfferType.ORDER_ITEM, OfferDiscountType.PERCENT_OFF, 10, null, false, true, 10)); order.addOfferCode(createOfferUtility.createOfferCode("15 Percent Off Item Sku2 Offer", OfferType.ORDER_ITEM, OfferDiscountType.PERCENT_OFF, 15, "discreteOrderItem.sku.id == " + sku2, false, true, 10)); List<Offer> offers = offerService.buildOfferListForOrder(order); offerService.applyAndSaveOffersToOrder(offers, order); assert ( order.getSubTotal().equals(new Money(985D) )); }
@Test(groups = {"testPercentageOffOffer"}, dependsOnGroups = { "offerCreateSku1", "offerCreateSku2" }) @Transactional public void testPercentOffOfferWithScaleGreaterThanTwo() throws Exception { Order order = orderService.createNewCartForCustomer(createCustomer()); FixedPriceFulfillmentOption option = new FixedPriceFulfillmentOptionImpl(); option.setPrice(new Money(0)); option.setFulfillmentType(FulfillmentType.PHYSICAL_SHIP); order.setFulfillmentGroups(createFulfillmentGroups(option, 5D, order)); orderService.save(order, false); order.addOrderItem(createDiscreteOrderItem(sku1, 100D, null, true, 2, order)); order.addOrderItem(createDiscreteOrderItem(sku2, 100D, null, true, 1, order)); order.addOfferCode(createOfferUtility.createOfferCode("20.5 Percent Off Item Offer", OfferType.ORDER_ITEM, OfferDiscountType.PERCENT_OFF, 20.5, null, true, true, 10)); List<Offer> offers = offerService.buildOfferListForOrder(order); offerService.applyAndSaveOffersToOrder(offers, order); // 20% results in $240. 20.5% off results in $238.50 assert ( order.getSubTotal().equals(new Money(238.50D) )); }
@Test(groups = {"testFulfillmentGroupOffers"}, dependsOnGroups = { "testCustomerAssociatedOffers2"}) @Transactional public void testFulfillmentGroupOffers() throws Exception { Order order = orderService.createNewCartForCustomer(createCustomer()); FixedPriceFulfillmentOption option = new FixedPriceFulfillmentOptionImpl(); option.setPrice(new Money(0)); option.setFulfillmentType(FulfillmentType.PHYSICAL_SHIP); order.setFulfillmentGroups(createFulfillmentGroups(option, 5D, order)); orderService.save(order, false); order.addOrderItem(createDiscreteOrderItem(sku1, 10D, null, true, 2, order)); order.addOrderItem(createDiscreteOrderItem(sku2, 20D, null, true, 1, order)); order.addOfferCode(createOfferUtility.createOfferCode("20 Percent Off Item Offer", OfferType.FULFILLMENT_GROUP, OfferDiscountType.PERCENT_OFF, 20, null, true, true, 10)); order.addOfferCode(createOfferUtility.createOfferCode("3 Dollars Off Item Offer", OfferType.FULFILLMENT_GROUP, OfferDiscountType.AMOUNT_OFF, 3, null, true, true, 10)); List<Offer> offers = offerService.buildOfferListForOrder(order); offerService.applyAndSaveOffersToOrder(offers, order); offerService.applyAndSaveFulfillmentGroupOffersToOrder(offers, order); assert (order.getFulfillmentGroups().get(0).getShippingPrice().equals(new Money(1.6D))); }
@Test(groups = {"testPercentageOffOffer"}, dependsOnGroups = { "offerCreateSku1", "offerCreateSku2" }) @Transactional public void testThreePercentOffOffers() throws Exception { Order order = orderService.createNewCartForCustomer(createCustomer()); FixedPriceFulfillmentOption option = new FixedPriceFulfillmentOptionImpl(); option.setPrice(new Money(0)); orderService.save(order, false); order.addOrderItem(createDiscreteOrderItem(sku1, 4.99D, null, true, 1, order)); order.addOrderItem(createDiscreteOrderItem(sku2, 9.99D, null, true, 1, order)); order.addOfferCode(createOfferUtility.createOfferCode("60 Percent Off Item Sku1 Offer", OfferType.ORDER_ITEM, OfferDiscountType.PERCENT_OFF, 60, "discreteOrderItem.sku.id == " + sku1, false, true, 10)); order.addOfferCode(createOfferUtility.createOfferCode("60 Percent Off Item Sku2 Offer", OfferType.ORDER_ITEM, OfferDiscountType.PERCENT_OFF, 60, "discreteOrderItem.sku.id == " + sku2, false, true, 10)); order.addOfferCode(createOfferUtility.createOfferCode("40 Percent Off All Item Offer", OfferType.ORDER_ITEM, OfferDiscountType.PERCENT_OFF, 40, null, false, true, 10)); List<Offer> offers = offerService.buildOfferListForOrder(order); offerService.applyAndSaveOffersToOrder(offers, order); assert ( order.getSubTotal().equals(new Money(6D) )); }