@Override public Order removeItemFromOrder(Long orderId, Long itemId, boolean priceOrder) throws PricingException { Order order = findOrderById(orderId); OrderItem orderItem = orderItemService.readOrderItemById(itemId); return removeItemFromOrder(order, orderItem, priceOrder); }
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 public ProcessContext<CartOperationRequest> execute(ProcessContext<CartOperationRequest> context) throws Exception { CartOperationRequest request = context.getSeedData(); OrderItemRequestDTO orderItemRequestDTO = request.getItemRequest(); // Order has been verified in a previous activity -- the values in the request can be trusted Order order = request.getOrder(); // Build the order item OrderItem item = orderItemService.buildOrderItemFromDTO(order, orderItemRequestDTO); // Check for special pricing orderItemService.priceOrderItem(item); order.getOrderItems().add(item); request.setOrderItem(item); genericEntityDao.persist(item); return context; }
@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; }
/** * Takes an order item id and rebuilds the dependant order item tree with the current quantities and options set. * * If the method was invoked via an AJAX call, it will render the "ajax/configure" template. * Otherwise, it will perform a 302 redirect to "/cart/configure" * * @param request * @param response * @param model * @param orderItemId * @throws IOException * @throws AddToCartException * @throws PricingException */ public String reconfigure(HttpServletRequest request, HttpServletResponse response, Model model, Long orderItemId) throws IOException, AddToCartException, PricingException, Exception { DiscreteOrderItem orderItem = (DiscreteOrderItem) orderItemService.readOrderItemById(orderItemId); Long productId = orderItem.getProduct().getId(); Product product = catalogService.findProductById(productId); ConfigurableOrderItemRequest itemRequest = orderItemService.createConfigurableOrderItemRequestFromProduct(product); orderItemService.modifyOrderItemRequest(itemRequest); orderItemService.mergeOrderItemRequest(itemRequest, orderItem); // update quantities and product options itemRequest.setQuantity(orderItem.getQuantity()); model.addAttribute("baseItem", itemRequest); model.addAttribute("isUpdateRequest", Boolean.TRUE); model.addAttribute("originalOrderItem", orderItemId); model.addAttribute(ALL_PRODUCTS_ATTRIBUTE_NAME, orderItemService.findAllProductsInRequest(itemRequest)); return isAjaxRequest(request) ? getConfigureView() : getConfigurePageRedirect(); }
@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; }
orderItemService.delete(oi); DiscreteOrderItem doi = li.next(); getOiFgiMap(order, oiFgiMap, doi); DiscreteOrderItem savedDoi = (DiscreteOrderItem) orderItemService.saveOrderItem(doi); savedOrderItems.put(doi, savedDoi); li.remove(); BundleOrderItem savedBoi = (BundleOrderItem) orderItemService.saveOrderItem(oi); savedOrderItems.put(oi, savedBoi); savedOrderItems.put(oi, orderItemService.saveOrderItem(oi));
ConfigurableOrderItemRequest itemRequest = orderItemService.createConfigurableOrderItemRequestFromProduct(product); orderItemService.modifyOrderItemRequest(itemRequest); model.addAttribute(ALL_PRODUCTS_ATTRIBUTE_NAME, orderItemService.findAllProductsInRequest(itemRequest));
@Override @Transactional("blTransactionManager") public Order addItemFromNamedOrder(Order namedOrder, OrderItem item, boolean priceOrder) throws RemoveFromCartException, AddToCartException { Order cartOrder = orderDao.readCartForCustomer(namedOrder.getCustomer()); if (cartOrder == null) { cartOrder = createNewCartForCustomer(namedOrder.getCustomer()); } OrderItemRequestDTO orderItemRequest = orderItemService.buildOrderItemRequestDTOFromOrderItem(item); cartOrder = addItem(cartOrder.getId(), orderItemRequest, priceOrder); if (moveNamedOrderItems) { removeItem(namedOrder.getId(), item.getId(), false); } if (namedOrder.getOrderItems().size() == 0 && deleteEmptyNamedOrders) { cancelOrder(namedOrder); } return cartOrder; }
@Override @Deprecated public OrderItem addDiscreteItemToOrder(Order order, DiscreteOrderItemRequest itemRequest, boolean priceOrder) throws PricingException { itemRequest.setOrder(order); DiscreteOrderItem item = orderItemService.createDiscreteOrderItem(itemRequest); return addOrderItemToOrder(order, item, priceOrder); }
@Override public OrderItem addBundleItemToOrder(Order order, BundleOrderItemRequest itemRequest, boolean priceOrder) throws PricingException { itemRequest.setOrder(order); BundleOrderItem item = orderItemService.createBundleOrderItem(itemRequest); return addOrderItemToOrder(order, item, priceOrder); }
ConfigurableOrderItemRequest itemRequest = orderItemService.createConfigurableOrderItemRequestFromProduct(product); orderItemService.modifyOrderItemRequest(itemRequest); model.addObject(CONFIGURATION_ATTRIBUTE_NAME, itemRequest); model.addObject(ALL_PRODUCTS_ATTRIBUTE_NAME, orderItemService.findAllProductsInRequest(itemRequest)); if (StringUtils.isNotEmpty(isEditRequest) && StringUtils.isNotEmpty(oidParam)) { Long oid = Long.parseLong(oidParam); OrderItem orderItem = orderItemService.readOrderItemById(oid); if (orderItemBelongsToCurrentCustomer(orderItem)) { orderItemService.mergeOrderItemRequest(itemRequest, orderItem);
@Override @Transactional("blTransactionManager") public Order addAllItemsFromNamedOrder(Order namedOrder, boolean priceOrder) throws RemoveFromCartException, AddToCartException { Order cartOrder = orderDao.readCartForCustomer(namedOrder.getCustomer()); if (cartOrder == null) { cartOrder = createNewCartForCustomer(namedOrder.getCustomer()); } List<OrderItem> items = new ArrayList<OrderItem>(namedOrder.getOrderItems()); // Remove any order items that are children CollectionUtils.filter(items, new TypedPredicate<OrderItem>() { @Override public boolean eval(OrderItem orderItem) { return orderItem.getParentOrderItem() == null; } }); for (OrderItem item : items) { OrderItemRequestDTO orderItemRequest = orderItemService.buildOrderItemRequestDTOFromOrderItem(item); cartOrder = addItem(cartOrder.getId(), orderItemRequest, priceOrder); if (moveNamedOrderItems) { removeItem(namedOrder.getId(), item.getId(), false); } } if (deleteEmptyNamedOrders) { cancelOrder(namedOrder); } return cartOrder; }
DiscreteOrderItem item = orderItemService.createDiscreteOrderItem(createDiscreteOrderItemRequest(order, null, sku, product, category, orderItemRequestDTO.getQuantity(), orderItemRequestDTO.getItemAttributes())); item.setOrder(order); List<OrderItem> orderItems = order.getOrderItems(); DiscreteOrderItem bundleDiscreteItem = orderItemService.createDiscreteOrderItem(createDiscreteOrderItemRequest(null, bundleOrderItem, bundleSku, bundleProduct, bundleCategory, skuBundleItem.getQuantity(), orderItemRequestDTO.getItemAttributes())); bundleDiscreteItem.setBundleOrderItem(bundleOrderItem); bundleDiscreteItem.setSkuBundleItem(skuBundleItem);
protected void validateIfParentOrderItemExists(OrderItemRequestDTO orderItemRequestDTO) { // If the user has specified a parent order item to attach this to, it must exist in this cart if (orderItemRequestDTO.getParentOrderItemId() != null) { OrderItem parent = orderItemService.readOrderItemById(orderItemRequestDTO.getParentOrderItemId()); if (parent == null) { throw new IllegalArgumentException("Could not find parent order item by the given id (" + orderItemRequestDTO.getParentOrderItemId() + ")"); } } } }
protected void updateOrderItemCartMessages(OrderItem orderItem) { List<String> cartMessages = gatherOrderItemCartMessages(orderItem); if (CollectionUtils.isEmpty(cartMessages)) { cartMessages = gatherProductCartMessages(orderItem); } orderItem.setCartMessages(cartMessages); orderItemService.saveOrderItem(orderItem); }
@Override @Transactional("blTransactionManager") public Order addItemFromNamedOrder(Order namedOrder, OrderItem item, int quantity, boolean priceOrder) throws RemoveFromCartException, AddToCartException, UpdateCartException { // Validate that the quantity requested makes sense if (quantity < 1 || quantity > item.getQuantity()) { throw new IllegalArgumentException("Cannot move 0 or less quantity"); } else if (quantity == item.getQuantity()) { return addItemFromNamedOrder(namedOrder, item, priceOrder); } Order cartOrder = orderDao.readCartForCustomer(namedOrder.getCustomer()); if (cartOrder == null) { cartOrder = createNewCartForCustomer(namedOrder.getCustomer()); } OrderItemRequestDTO orderItemRequest = orderItemService.buildOrderItemRequestDTOFromOrderItem(item); orderItemRequest.setQuantity(quantity); cartOrder = addItem(cartOrder.getId(), orderItemRequest, priceOrder); if (moveNamedOrderItems) { // Update the old item to its new quantity only if we're moving items OrderItemRequestDTO orderItemRequestDTO = new OrderItemRequestDTO(); orderItemRequestDTO.setOrderItemId(item.getId()); orderItemRequestDTO.setQuantity(item.getQuantity() - quantity); updateItemQuantity(namedOrder.getId(), orderItemRequestDTO, false); } return cartOrder; }
@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; }
EasyMock.expect(orderItemServiceMock.saveOrderItem(EasyMock.isA(OrderItem.class))).andAnswer(OfferDataItemProvider.getSaveOrderItemAnswer()).anyTimes(); EasyMock.expect(fgItemDaoMock.save(EasyMock.isA(FulfillmentGroupItem.class))).andAnswer(OfferDataItemProvider.getSaveFulfillmentGroupItemAnswer()).anyTimes();
public OrderItem moveItemToCartFromNamedOrder(Long customerId, String orderName, Long orderItemId, Integer quantity, boolean priceOrder) throws PricingException { Order wishlistOrder = findNamedOrderForCustomer(orderName, customerService.createCustomerFromId(customerId)); OrderItem orderItem = orderItemService.readOrderItemById(orderItemId); orderItem.setQuantity(quantity); return moveItemToCartFromNamedOrder(wishlistOrder, orderItem, priceOrder); }