Refine search
@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; }
/** * Distributes the order adjustments (if any) to the individual fulfillment group items. * @param order * @param totalAllItems * @return */ protected Money distributeOrderSavingsToItems(Order order, BigDecimal totalAllItems) { Money returnAmount = new Money(order.getCurrency()); BigDecimal orderAdjAmt = order.getOrderAdjustmentsValue().getAmount(); for (FulfillmentGroup fulfillmentGroup : order.getFulfillmentGroups()) { for (FulfillmentGroupItem fgItem : fulfillmentGroup.getFulfillmentGroupItems()) { BigDecimal fgItemAmount = fgItem.getTotalItemAmount().getAmount(); BigDecimal proratedAdjAmt = totalAllItems.compareTo(BigDecimal.ZERO) == 0 ? totalAllItems : orderAdjAmt.multiply(fgItemAmount).divide(totalAllItems, RoundingMode.FLOOR); fgItem.setProratedOrderAdjustmentAmount(new Money(proratedAdjAmt, order.getCurrency())); returnAmount = returnAmount.add(fgItem.getProratedOrderAdjustmentAmount()); } } return returnAmount; }
@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); }
@Override public void populateCustomerInfo(Order order, PaymentRequestDTO requestDTO) { Customer customer = order.getCustomer(); paymentRequestDTOService.populateCustomerInfo(requestDTO, customer, order.getEmailAddress()); }
/** * Builds the transaction analytics for the given tracker name. Invokes {@link #getItemJs(Order, String) for each item * in the given <b>order</b>. */ protected String getTransactionJs(Order order, String trackerPrefix) { StringBuffer sb = new StringBuffer(); sb.append("ga('" + trackerPrefix + "require', 'ecommerce', 'ecommerce.js');"); sb.append("ga('" + trackerPrefix + "ecommerce:addTransaction', {"); sb.append("'id': '" + order.getOrderNumber() + "'"); if (StringUtils.isNotBlank(getAffiliation())) { sb.append(",'affiliation': '" + getAffiliation() + "'"); } sb.append(",'revenue': '" + order.getTotal() + "'"); sb.append(",'shipping':'" + order.getTotalShipping() + "'"); sb.append(",'tax': '" + order.getTotalTax() + "'"); if (order.getCurrency() != null) { sb.append(",'currency': '" + order.getCurrency().getCurrencyCode() + "'"); } sb.append("});"); sb.append(getItemJs(order, trackerPrefix)); sb.append("ga('" + trackerPrefix + "ecommerce:send');"); return sb.toString(); }
@Override public String initiateCheckout(Long orderId) throws Exception{ Order order = orderService.findOrderById(orderId, true); if (order == null || order instanceof NullOrderImpl) { throw new IllegalArgumentException("Could not order with id " + orderId); } CheckoutResponse response; try { response = checkoutService.performCheckout(order); } catch (CheckoutException e) { throw new Exception(e); } if (response.getOrder().getOrderNumber() == null) { LOG.error("Order Number for Order ID: " + order.getId() + " is null."); } return response.getOrder().getOrderNumber(); }
@Override public Money getRetailPrice() { if (shouldSumItems()) { Money bundleRetailPrice = BroadleafCurrencyUtils.getMoney(getOrder().getCurrency()); for (DiscreteOrderItem discreteOrderItem : discreteOrderItems) { BigDecimal itemRetailPrice = discreteOrderItem.getRetailPrice().getAmount(); BigDecimal quantityPrice = itemRetailPrice.multiply(new BigDecimal(discreteOrderItem.getQuantity())); bundleRetailPrice = bundleRetailPrice.add(BroadleafCurrencyUtils.getMoney(quantityPrice, getOrder().getCurrency())); } for (BundleOrderItemFeePrice fee : getBundleOrderItemFeePrices()) { bundleRetailPrice = bundleRetailPrice.add(fee.getAmount()); } return bundleRetailPrice; } else { return super.getRetailPrice(); } }
public void testBundleDistribution() throws Exception { Order order = dataProvider.createOrderWithBundle(); Money subTotal = new Money(order.getCurrency()); for (OrderItem orderItem : order.getOrderItems()) { subTotal = subTotal.add(orderItem.getTotalPrice()); } order.setSubTotal(subTotal); OrderAdjustment adjustment = new OrderAdjustmentImpl(); adjustment.setValue(new Money(new BigDecimal("1"), order.getCurrency())); adjustment.setOrder(order); order.getOrderAdjustments().add(adjustment); ProcessContext<Order> context = new DefaultProcessContextImpl<Order>(); context.setSeedData(order); fulfillmentItemPricingActivity.execute(context); assertTrue(sumProratedOfferAdjustments(order).equals( new Money(new BigDecimal("1"), order.getCurrency()))); }
@Override public Money computeDiscountedAmount() { Money discountedAmount = new Money(0); Money priceToUse = getBasePrice(); if (priceToUse != null) { if (offer.getDiscountType().equals(OfferDiscountType.AMOUNT_OFF)) { discountedAmount = BroadleafCurrencyUtils.getMoney(offer.getValue(), promotableFulfillmentGroup.getFulfillmentGroup().getOrder().getCurrency()); } else if (offer.getDiscountType().equals(OfferDiscountType.FIX_PRICE)) { discountedAmount = priceToUse.subtract(BroadleafCurrencyUtils.getMoney(offer.getValue(), promotableFulfillmentGroup.getFulfillmentGroup().getOrder().getCurrency())); } else if (offer.getDiscountType().equals(OfferDiscountType.PERCENT_OFF)) { discountedAmount = priceToUse.multiply(offer.getValue().divide(new BigDecimal("100"))); } if (discountedAmount.greaterThan(priceToUse)) { discountedAmount = priceToUse; } } return discountedAmount; }
@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 = { "createCartForCustomer" }, dependsOnGroups = { "readCustomer", "createPhone" }) @Transactional @Rollback(false) public void createCartForCustomer() { String userName = "customer1"; Customer customer = customerService.readCustomerByUsername(userName); Order order = orderService.createNewCartForCustomer(customer); assert order != null; assert order.getId() != null; this.orderId = order.getId(); }
public void testDistributeOneDollarAcrossFiveItems() throws Exception { Order order = dataProvider.createBasicOrder(); OrderAdjustment adjustment = new OrderAdjustmentImpl(); adjustment.setValue(new Money(new BigDecimal("1"), order.getCurrency())); adjustment.setOrder(order); order.getOrderAdjustments().add(adjustment); ProcessContext<Order> context = new DefaultProcessContextImpl<Order>(); context.setSeedData(order); fulfillmentItemPricingActivity.execute(context); Money adj1 = new Money(".31"); Money adj2 = new Money(".69"); for (FulfillmentGroup fulfillmentGroup : order.getFulfillmentGroups()) { for (FulfillmentGroupItem fulfillmentGroupItem : fulfillmentGroup.getFulfillmentGroupItems()) { if (fulfillmentGroupItem.getSalePrice().equals(new Money("19.99"))) { assertTrue(fulfillmentGroupItem.getProratedOrderAdjustmentAmount().equals(adj1)); } else { assertTrue(fulfillmentGroupItem.getProratedOrderAdjustmentAmount().equals(adj2)); } } } }
@Test(groups = { "createOrder" }, dataProvider = "basicOrder", dataProviderClass = OrderDataProvider.class, dependsOnGroups = { "readCustomer", "createPhone" }) @Rollback(false) @Transactional public void createOrder(Order order) { userName = "customer1"; Customer customer = customerService.readCustomerByUsername(userName); assert order.getId() == null; order.setCustomer(customer); order = orderDao.save(order); assert order.getId() != null; orderId = order.getId(); }
@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 = { "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())); }
@Test(groups = {"testOffersWithGiftWrap"}, dependsOnGroups = { "testShippingInsert"}) @Transactional public void testOrderItemOfferWithGiftWrap() throws PricingException { Order order = createTestOrderWithOfferAndGiftWrap(); for (FulfillmentGroup fg : order.getFulfillmentGroups()) { Address address = fg.getAddress(); for (FulfillmentGroupItem fgItem : fg.getFulfillmentGroupItems()) { assert order.getOrderItems().size() == 3; assert order.getTotalTax().equals(new Money("2.00")); assert order.getTotalShipping().equals(new Money("8.50")); assert order.getSubTotal().equals(new Money("40.00")); assert order.getTotal().equals(new Money("50.50")); for (OrderItem orderItem : order.getOrderItems()) { if (orderItem instanceof GiftWrapOrderItem && ((GiftWrapOrderItem) orderItem).getWrappedItems().size() == 1) { foundGiftItemAndCorrectQuantity = true;
@Test(groups = {"testCustomerOffers"}, dependsOnGroups = { "testOfferCodeDao"}) @Transactional public void testCustomerOffers() throws Exception { Order order = orderService.createNewCartForCustomer(createCustomer()); Offer offer = createOfferUtility.createOffer("1.20 Dollars Off Order Offer", OfferType.ORDER, OfferDiscountType.AMOUNT_OFF, 1.20, null, true, true, 10, null); CustomerOffer customerOffer = new CustomerOfferImpl(); customerOffer.setCustomer(order.getCustomer()); customerOffer.setOffer(offer); customerOffer = customerOfferDao.save(customerOffer); CustomerOffer customerOfferTest = customerOfferDao.readCustomerOfferById(customerOffer.getId()); assert (customerOffer.getId().equals(customerOfferTest.getId())); }
@Test(groups = { "testShipping" }, dependsOnGroups = { "testShippingInsert", "createCustomerIdGeneration"}) @Transactional public void testShipping() throws Exception { Order order = orderService.createNewCartForCustomer(createCustomer()); customerService.saveCustomer(order.getCustomer()); groups.add(group1); order.setFulfillmentGroups(groups); Money total = new Money(8.5D); group1.setShippingPrice(total); order.setSubTotal(total); order.setTotal(total); order.setOrderItems(items); for (OrderItem orderItem : items) { FulfillmentGroupItem fgi = new FulfillmentGroupItemImpl(); order.setTotalShipping(new Money(0D)); assert (order.getTotal().greaterThan(order.getSubTotal())); assert (order.getTotalTax().equals(order.getSubTotal().multiply(0.05D))); // Shipping price is not taxable assert (order.getTotal().equals(order.getSubTotal().add(order.getTotalTax().add(order.getTotalShipping()))));
customerService.saveCustomer(order.getCustomer()); group.setOrder(order); groups.add(group); order.setFulfillmentGroups(groups); Money total = new Money(8.5D); group.setShippingPrice(total); order.addOrderItem(item); FulfillmentGroupItem fgItem = new FulfillmentGroupItemImpl(); fgItem.setFulfillmentGroup(group); order.addOrderItem(item); order.addOfferCode(createOfferCode("20 Percent Off Item Offer", OfferType.ORDER_ITEM, OfferDiscountType.PERCENT_OFF, 20, null, "discreteOrderItem.sku.name==\"Test Sku\"")); order.addOfferCode(createOfferCode("3 Dollars Off Item Offer", OfferType.ORDER_ITEM, OfferDiscountType.AMOUNT_OFF, 3, null, "discreteOrderItem.sku.name!=\"Test Sku\"")); order.addOfferCode(createOfferCode("1.20 Dollars Off Order Offer", OfferType.ORDER, OfferDiscountType.AMOUNT_OFF, 1.20, null, null)); order.setTotalShipping(new Money(0D)); assert order.getSubTotal().subtract(order.getOrderAdjustmentsValue()).equals(new Money(31.80D)); assert (order.getTotal().greaterThan(order.getSubTotal())); assert (order.getTotalTax().equals(order.getSubTotal().subtract(order.getOrderAdjustmentsValue()).multiply(0.05D))); // Shipping is not taxable assert (order.getTotal().equals(order.getSubTotal().add(order.getTotalTax()).add(order.getTotalShipping()).add(fulfillmentGroupFeeTotal).subtract(order.getOrderAdjustmentsValue())));
@Transactional @PreAuthorize("hasAnyRole('PERMISSION_ALL_ORDER', 'ROLE_USER')") @RequestMapping(value = "/{orderId}/items", method = RequestMethod.POST) final List<DiscreteOrderItem> currentDiscreteItems = cart.getDiscreteOrderItems(); orderService.addItem(cart.getId(), orderItemRequestDTO, true); cart.calculateSubTotal(); cart = orderService.save(cart, false); addedDiscreteOrderItem = cart.getDiscreteOrderItems().stream() .filter(x -> x.getSku().getId().longValue() == orderItemRequestDTO.getSkuId()) .findAny() .orElseThrow(ResourceNotFoundException::new); } else { final List<DiscreteOrderItem> newDiscreteItemsIds = cart.getDiscreteOrderItems().stream() .filter(item -> !currentDiscreteItems.contains(item)) .collect(Collectors.toList());