@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(); }
@Override public String retrieveOrderAttributeFromOrder(Long orderId, String orderAttributeKey) { Order currentCart = CartState.getCart(); Long currentCartId = currentCart.getId(); if (orderId != null && !currentCartId.equals(orderId)) { logWarningIfCartMismatch(currentCartId, orderId); currentCart = orderService.findOrderById(orderId); } if (currentCart.getOrderAttributes().containsKey(orderAttributeKey)) { return currentCart.getOrderAttributes().get(orderAttributeKey).getValue(); } return null; }
@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; }
public String displayOrderConfirmationByOrderId(Long orderId, Model model, HttpServletRequest request, HttpServletResponse response) { Customer customer = CustomerState.getCustomer(); if (customer != null) { Order order = orderService.findOrderById(orderId); if (order != null && customer.equals(order.getCustomer())) { extensionManager.getProxy().processAdditionalConfirmationActions(order); model.addAttribute("order", order); return getOrderConfirmationView(); } } return "redirect:/"; }
@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(); }
@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 = { "addPaymentToOrder" }, dataProvider = "basicPaymentInfo", dataProviderClass = PaymentInfoDataProvider.class, dependsOnGroups = { "checkOrderItems" }) @Rollback(false) @Transactional public void addPaymentToOrder(OrderPayment paymentInfo) { Order order = orderService.findOrderById(orderId); orderService.addPaymentToOrder(order, paymentInfo, null); order = orderService.findOrderById(orderId); OrderPayment payment = order.getPayments().get(order.getPayments().indexOf(paymentInfo)); assert payment != null; assert payment.getOrder() != null; assert payment.getOrder().equals(order); }
public Order getOverrideCart(WebRequest request) { Long orderId = null; if (BLCRequestUtils.isOKtoUseSession(request)) { orderId = (Long) request.getAttribute(OVERRIDE_CART_ATTR_NAME, WebRequest.SCOPE_GLOBAL_SESSION); } Order cart = null; if (orderId != null) { cart = orderService.findOrderById(orderId); if (cart == null || cart.getStatus().equals(OrderStatus.SUBMITTED) || cart.getStatus().equals(OrderStatus.CANCELLED)) { return null; } } return cart; }
@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); } }
@Test(groups = { "testNamedOrderForCustomer" }, dependsOnGroups = { "testOrderProperties" }) public void testNamedOrderForCustomer() throws PricingException { Customer customer = customerService.createCustomerFromId(null); customer = customerService.saveCustomer(customer); Order order = orderService.createNamedOrderForCustomer("Birthday Order", customer); Long orderId = order.getId(); assert order != null; assert order.getName().equals("Birthday Order"); assert order.getCustomer().equals(customer); orderService.cancelOrder(order); assert orderService.findOrderById(orderId) == null; }
@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 = { "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; }
@Test(groups = { "removeBundleFromOrder" }, dependsOnGroups = { "addBundleToOrder" }) @Rollback(false) @Transactional public void removeBundleFromOrder() throws RemoveFromCartException { Order order = orderService.findOrderById(orderId); List<OrderItem> orderItems = order.getOrderItems(); assert orderItems.size() == numOrderItems; int startingSize = orderItems.size(); BundleOrderItem bundleOrderItem = (BundleOrderItem) orderItemService.readOrderItemById(bundleOrderItemId); assert bundleOrderItem != null; assert bundleOrderItem.getDiscreteOrderItems() != null; assert bundleOrderItem.getDiscreteOrderItems().size() == 1; order = orderService.removeItem(order.getId(), bundleOrderItem.getId(), true); List<OrderItem> items = order.getOrderItems(); assert items != null; assert items.size() == startingSize - 1; }
@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); }
Order order = orderService.findOrderById(orderId); assert order != null; assert sku.getId() != null;
@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 = { "addBundleToOrder" }, dependsOnGroups = { "addAnotherItemToOrder" }) @Rollback(false) @Transactional public void addBundleToOrder() throws AddToCartException { numOrderItems++; Sku sku = skuDao.readFirstSku(); Order order = orderService.findOrderById(orderId); assert order != null; assert sku.getId() != null; ProductBundle bundleItem = addProductBundle(); OrderItemRequestDTO orderItemRequestDTO = new OrderItemRequestDTO(); orderItemRequestDTO.setProductId(bundleItem.getId()); orderItemRequestDTO.setSkuId(bundleItem.getDefaultSku().getId()); orderItemRequestDTO.setQuantity(1); order = orderService.addItem(order.getId(), orderItemRequestDTO, true); BundleOrderItem item = (BundleOrderItem) orderService.findLastMatchingItem(order, bundleItem.getDefaultSku().getId(), null); bundleOrderItemId = item.getId(); assert item != null; assert item.getQuantity() == 1; assert item.getDiscreteOrderItems().size() == 1; }
EasyMock.expect(orderServiceMock.findOrderById(EasyMock.isA(Long.class))).andAnswer(new IAnswer<Order>() { @Override public Order answer() throws Throwable {
@Test(groups = { "testIllegalUpdateScenarios" }, dependsOnGroups = { "addItemToOrder" }) @Transactional public void testIllegalUpdateScenarios() throws UpdateCartException, AddToCartException, RemoveFromCartException { Order order = orderService.findOrderById(orderId); assert order != null;
@Test(groups = { "testIllegalAddScenarios" }, dependsOnGroups = { "addItemToOrder" }) @Transactional public void testIllegalAddScenarios() throws AddToCartException { Order order = orderService.findOrderById(orderId); assert order != null;