@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); }
cart = orderService.createNewCartForCustomer(CustomerState.getCustomer(request)); updateAddRequestQuantities(itemRequest, originalOrderItemId); cart = orderService.removeItem(cart.getId(), originalOrderItemId, false); cart = orderService.save(cart, true); cart = orderService.addItem(cart.getId(), itemRequest, false); cart = orderService.save(cart, true);
@Test(groups = { "findCartForAnonymousCustomer" }, dependsOnGroups = { "getOrdersForCustomer" }) public void findCartForAnonymousCustomer() { Customer customer = customerService.createCustomerFromId(null); Order order = orderService.findCartForCustomer(customer); assert order == null; order = orderService.createNewCartForCustomer(customer); Long orderId = order.getId(); Order newOrder = orderService.findOrderById(orderId); assert newOrder != null; assert newOrder.getCustomer() != null; }
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(); }
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(); }
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(); }
EasyMock.expect(orderItemDaoMock.createOrderItemQualifier()).andAnswer(orderItemQualifierAnswer).atLeastOnce(); EasyMock.expect(orderServiceMock.getAutomaticallyMergeLikeItems()).andReturn(true).anyTimes(); EasyMock.expect(orderServiceMock.save(EasyMock.isA(Order.class),EasyMock.isA(Boolean.class))).andAnswer(OfferDataItemProvider.getSaveOrderAnswer()).anyTimes(); EasyMock.expect(orderItemServiceMock.saveOrderItem(EasyMock.isA(OrderItem.class))).andAnswer(OfferDataItemProvider.getSaveOrderItemAnswer()).anyTimes(); EasyMock.expect(fgItemDaoMock.save(EasyMock.isA(FulfillmentGroupItem.class))).andAnswer(OfferDataItemProvider.getSaveFulfillmentGroupItemAnswer()).anyTimes(); EasyMock.expect(orderServiceMock.removeItem(EasyMock.isA(Long.class), EasyMock.isA(Long.class), EasyMock.eq(false))).andAnswer(OfferDataItemProvider.getRemoveItemFromOrderAnswer()).anyTimes(); EasyMock.expect(orderServiceMock.findOrderById(EasyMock.isA(Long.class))).andAnswer(new IAnswer<Order>() { @Override public Order answer() throws Throwable {
@Test(groups = { "checkout" }, dependsOnGroups = { "createCartForCustomer", "testShippingInsert" }, dataProvider = "USCurrency", dataProviderClass = BroadleafCurrencyProvider.class) @Transactional public void testCheckout(BroadleafCurrency usCurrency) throws Exception { HashMap currencyConsiderationContext = new HashMap(); currencyConsiderationContext.put("aa","bb"); CurrencyConversionContext.setCurrencyConversionContext(currencyConsiderationContext); CurrencyConversionContext.setCurrencyConversionService(new CurrencyConversionService() { @Override public Money convertCurrency(Money source, Currency destinationCurrency, int destinationScale) { return source; } }); String userName = "customer1"; Customer customer = customerService.readCustomerByUsername(userName); Order order = orderService.createNewCartForCustomer(customer); usCurrency = currencyService.save(usCurrency); order.setCurrency(usCurrency); Address address = buildAddress(); FulfillmentGroup group = buildFulfillmentGroup(order, address); addSampleItemToOrder(order, group); order.setTotalShipping(new Money(0D)); addPaymentToOrder(order, address); //execute pricing for this order orderService.save(order, true); CheckoutResponse response = checkoutService.performCheckout(order); assert (order.getTotal().greaterThan(order.getSubTotal())); }
Order order = orderService.findOrderById(orderId); assert order != null; assert sku.getId() != null; orderService.setAutomaticallyMergeLikeItems(true); order = orderService.addItem(orderId, itemRequest, true); DiscreteOrderItem item = (DiscreteOrderItem) orderService.findLastMatchingItem(order, sku.getId(), null); order = orderService.findOrderById(orderId); boolean currentVal = orderService.getAutomaticallyMergeLikeItems(); orderService.setAutomaticallyMergeLikeItems(false); itemRequest = new OrderItemRequestDTO(); itemRequest.setQuantity(1); itemRequest.setSkuId(sku.getId()); order = orderService.addItem(orderId, itemRequest, false); order = orderService.addItem(orderId, itemRequest, false); DiscreteOrderItem item2 = (DiscreteOrderItem) orderService.findLastMatchingItem(order, sku.getId(), null); assert item2.getSku() != null; assert item2.getSku().equals(sku); assert item2.getQuantity() == 1; // item-was not auto-merged with prior items. order = orderService.findOrderById(orderId); assert(order.getOrderItems().size()==3); order = orderService.removeItem(order.getId(), order.getOrderItems().get(1).getId(), true); order = orderService.removeItem(order.getId(), order.getOrderItems().get(1).getId(), true); orderService.setAutomaticallyMergeLikeItems(currentVal); assert(order.getOrderItems().size()==1); assert(order.getOrderItems().get(0).getQuantity()==2);
Order cart = CartState.getCart(); cart = orderService.removeItem(cart.getId(), itemRequest.getOrderItemId(), false); cart = orderService.save(cart, true);
@Override public void updateAndValidateCart(Order cart) { if (extensionManager != null) { ExtensionResultHolder erh = new ExtensionResultHolder(); extensionManager.getProxy().updateAndValidateCart(cart, erh); Boolean clearCart = (Boolean) erh.getContextMap().get("clearCart"); Boolean repriceCart = (Boolean) erh.getContextMap().get("repriceCart"); Boolean saveCart = (Boolean) erh.getContextMap().get("saveCart"); if (clearCart != null && clearCart.booleanValue()) { orderService.cancelOrder(cart); cart = orderService.createNewCartForCustomer(cart.getCustomer()); } else { try { if (repriceCart != null && repriceCart.booleanValue()) { orderService.save(cart, true, true); } else if (saveCart != null && saveCart.booleanValue()) { orderService.save(cart, false); } } catch (PricingException pe) { LOG.error("Pricing Exception while validating cart. Clearing cart.", pe); orderService.cancelOrder(cart); cart = orderService.createNewCartForCustomer(cart.getCustomer()); } } } }
@Override public String lookupOrderNumberFromOrderId(PaymentResponseDTO responseDTO) { Order order = orderService.findOrderById(Long.parseLong(responseDTO.getOrderId()), true); if (order == null) { throw new IllegalArgumentException("An order with ID " + responseDTO.getOrderId() + " cannot be found for the" + " given payment response."); } return order.getOrderNumber(); }
@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)); }
currentCart = orderService.removeItem(currentCart.getId(), orderItem.getId(), false); } catch (RemoveFromCartException e) { LOG.error("Could not remove from cart.", e); currentCart = orderService.addItem(currentCart.getId(), itemRequest, false); } catch (AddToCartException e) { LOG.error("Could not add to cart.", e); currentCart = orderService.save(currentCart, repriceOrder); } catch (PricingException e) { LOG.error("Could not save cart.", e);
@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; }
@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; }
@Test(groups = { "removeItemFromOrder" }, dependsOnGroups = { "getItemsForOrder" }) @Transactional public void removeItemFromOrder() throws RemoveFromCartException { // Grab the order and the first OrderItem Order order = orderService.findOrderById(orderId); List<OrderItem> orderItems = order.getOrderItems(); assert orderItems.size() > 0; int startingSize = orderItems.size(); OrderItem item = orderItems.get(0); Long itemId = item.getId(); assert item != null; // Remove the item order = orderService.removeItem(order.getId(), item.getId(), true); List<OrderItem> items = order.getOrderItems(); OrderItem updatedItem = orderItemService.readOrderItemById(item.getId()); // Assert that the item has been removed assert items != null; assert items.size() == startingSize - 1; assert updatedItem == null; }
@Test(groups = { "testOrderProperties" }, dependsOnGroups = { "testReadOrdersForCustomer" }) public void testOrderProperties() throws PricingException { Customer customer = customerService.createCustomerFromId(null); Order order = orderService.createNewCartForCustomer(customer); assert order.getSubTotal() == null; assert order.getTotal() == null; Calendar testCalendar = Calendar.getInstance(); order.setSubmitDate(testCalendar.getTime()); assert order.getSubmitDate().equals(testCalendar.getTime()); }
throws PricingException, RemoveFromCartException { ReconstructCartResponse reconstructCartResponse = new ReconstructCartResponse(); Order customerCart = orderService.findCartForCustomerWithEnhancements(customer); if (customerCart != null) { List<OrderItem> itemsToRemove = new ArrayList<OrderItem>(); orderService.removeItem(customerCart.getId(), item.getId(), false); customerCart = orderService.save(customerCart, priceOrder);
@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; }