public int getQuantity() { return orderItem.getQuantity(); }
@Override public FulfillmentGroup addItemToFulfillmentGroup(OrderItem item, FulfillmentGroup fulfillmentGroup, boolean priceOrder) throws PricingException { return addItemToFulfillmentGroup(item, fulfillmentGroup, item.getQuantity(), priceOrder); }
protected FulfillmentGroup addItemToFulfillmentGroup(Order order, OrderItem orderItem, FulfillmentGroup fulfillmentGroup) throws PricingException { return this.addItemToFulfillmentGroup(order, orderItem, orderItem.getQuantity(), fulfillmentGroup); }
public class OrderService { public BigDecimal calculateTotal(Order order) { if (order == null) { throw new IllegalArgumentException("order must not be null"); } BigDecimal total = BigDecimal.ZERO; List<OrderItem> items = order.getItems(); for (OrderItem orderItem : items) { int quantity = orderItem.getQuantity(); BigDecimal price = orderItem.getPrice(); BigDecimal itemTotal = price.multiply(new BigDecimal(quantity)); total = total.add(itemTotal); } return total; } }
protected boolean checkItemCriteria(ItemCriteriaDTO itemCriteria, List<OrderItem> orderItems) { Map<String,Object> vars = new HashMap<String, Object>(); int foundCount = 0; Iterator<OrderItem> items = orderItems.iterator(); while (foundCount < itemCriteria.getQty() && items.hasNext()) { OrderItem currentItem = items.next(); vars.put("discreteOrderItem", currentItem); vars.put("orderItem", currentItem); boolean match = executeExpression(itemCriteria.getMatchRule(), vars); if (match) { foundCount = foundCount + currentItem.getQuantity(); } } return (foundCount >= itemCriteria.getQty().intValue()); }
public class OrderService { public void calculateTotal(Order order) { if (order == null) { throw new IllegalArgumentException("order must not be null"); } BigDecimal total = BigDecimal.ZERO; List<OrderItem> items = order.getItems(); for (OrderItem orderItem : items) { int quantity = orderItem.getQuantity(); BigDecimal price = orderItem.getPrice(); BigDecimal itemTotal = price.multiply(new BigDecimal(quantity)); total = total.add(itemTotal); } order.setTotal(total); } }
@Override public Money calculateTotalWithoutAdjustments() { return getCurrentBasePrice().multiply(orderItem.getQuantity()); }
protected void updateAddRequestQuantities(OrderItemRequestDTO itemRequest, Long originalOrderItemId) { // Update the request to match the quantity of the order item it's replacing OrderItem orderItem = orderItemService.readOrderItemById(originalOrderItemId); // Make sure there is actually an order item to process if (orderItem == null) { return; } itemRequest.setQuantity(orderItem.getQuantity()); for (OrderItemRequestDTO childDTO : itemRequest.getChildOrderItems()) { childDTO.setQuantity(childDTO.getQuantity() * orderItem.getQuantity()); } }
@Override public void updateItemQuantity(Order order, OrderItem item, boolean priceOrder) throws ItemNotFoundException, PricingException { if (!order.getOrderItems().contains(item)) { throw new ItemNotFoundException("Order Item (" + item.getId() + ") not found in Order (" + order.getId() + ")"); } if (item.getQuantity() == 0) { removeItemFromOrder(order, item); } else if (item.getQuantity() < 0) { throw new IllegalArgumentException("Quantity cannot be negative"); } else { OrderItem itemFromOrder = order.getOrderItems().get(order.getOrderItems().indexOf(item)); itemFromOrder.setQuantity(item.getQuantity()); order = updateOrder(order, priceOrder); } }
protected String getItemJs(Order order, String trackerPrefix) { StringBuffer sb = new StringBuffer(); for (FulfillmentGroup fulfillmentGroup : order.getFulfillmentGroups()) { for (FulfillmentGroupItem fulfillmentGroupItem : fulfillmentGroup.getFulfillmentGroupItems()) { OrderItem orderItem = fulfillmentGroupItem.getOrderItem(); if (orderItem instanceof DiscreteOrderItem) { if (SkuAccessor.class.isAssignableFrom(orderItem.getClass())) { Sku sku = ((SkuAccessor) orderItem).getSku(); sb.append("ga('" + trackerPrefix + "ecommerce:addItem', {"); sb.append("'id': '" + order.getOrderNumber() + "'"); sb.append(",'name': '" + sku.getName() + "'"); sb.append(",'sku': '" + sku.getId() + "'"); sb.append(",'category': '" + getVariation(orderItem) + "'"); sb.append(",'price': '" + orderItem.getAveragePrice() + "'"); sb.append(",'quantity': '" + orderItem.getQuantity() + "'"); sb.append("});"); } } } } return sb.toString(); }
List<OrderItem> itemsToUpdate = new ArrayList<OrderItem>(((BundleOrderItem) orderItem).getDiscreteOrderItems()); for (OrderItem oi : itemsToUpdate) { int quantityPer = oi.getQuantity(); fgisToDelete.addAll(updateItemQuantity(order, oi, (quantityPer * orderItemQuantityDelta))); int quantityPer = oi.getQuantity() / orderItem.getQuantity(); fgisToDelete.addAll(updateItemQuantity(order, oi, (quantityPer * orderItemQuantityDelta)));
@Override @Deprecated public OrderItem addOrderItemToOrder(Order order, OrderItem newOrderItem, boolean priceOrder) throws PricingException { if (automaticallyMergeLikeItems) { OrderItem item = findMatchingItem(order, newOrderItem); if (item != null) { item.setQuantity(item.getQuantity() + newOrderItem.getQuantity()); try { updateItemQuantity(order, item, priceOrder); } catch (ItemNotFoundException e) { LOG.error(e); } return findMatchingItem(order, newOrderItem); } } List<OrderItem> orderItems = order.getOrderItems(); orderItems.add(newOrderItem); newOrderItem.setOrder(order); order = updateOrder(order, priceOrder); return findMatchingItem(order, newOrderItem); }
@Override public OrderItemPriceDetail initializeOrderItemPriceDetails(OrderItem item) { OrderItemPriceDetail detail = createOrderItemPriceDetail(); detail.setOrderItem(item); detail.setQuantity(item.getQuantity()); detail.setUseSalePrice(item.getIsOnSale()); item.getOrderItemPriceDetails().add(detail); return detail; }
@Override public int getItemCount() { int count = 0; for (DiscreteOrderItem doi : getDiscreteOrderItems()) { if (doi.getParentOrderItem() == null) { count += doi.getQuantity(); } } for (OrderItem oi : getNonDiscreteOrderItems()) { count += oi.getQuantity(); } return count; }
/** * Sets the fulfillment amount which includes the relative portion of the total price for * the corresponding order item. * * @param order * @param partialOrderItemMap */ protected void populateItemTotalAmount(Order order, Map<OrderItem, List<FulfillmentGroupItem>> partialOrderItemMap) { for (FulfillmentGroup fulfillmentGroup : order.getFulfillmentGroups()) { for (FulfillmentGroupItem fgItem : fulfillmentGroup.getFulfillmentGroupItems()) { OrderItem orderItem = fgItem.getOrderItem(); int fgItemQty = fgItem.getQuantity(); int orderItemQty = orderItem.getQuantity(); Money totalItemAmount = orderItem.getTotalPrice(); if (fgItemQty != orderItemQty) { // We need to keep track of all of these items in case we need to distribute a remainder // to one or more of the items. List<FulfillmentGroupItem> fgItemList = partialOrderItemMap.get(orderItem); if (fgItemList == null) { fgItemList = new ArrayList<>(); partialOrderItemMap.put(orderItem, fgItemList); } fgItemList.add(fgItem); fgItem.setTotalItemAmount(totalItemAmount.multiply(fgItemQty).divide(orderItemQty)); } else { fgItem.setTotalItemAmount(totalItemAmount); } } } }
@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; }
@Override public FulfillmentGroup createDefaultFulfillmentGroup(Order order, Address address) { for (FulfillmentGroup fulfillmentGroup : order.getFulfillmentGroups()) { if (fulfillmentGroup.isPrimary()) { return fulfillmentGroup; } } FulfillmentGroup newFg = fulfillmentGroupService.createEmptyFulfillmentGroup(); newFg.setOrder(order); newFg.setPrimary(true); newFg.setAddress(address); for (OrderItem orderItem : order.getOrderItems()) { newFg.addFulfillmentGroupItem(createFulfillmentGroupItemFromOrderItem(orderItem, newFg, orderItem.getQuantity())); } return newFg; }
tc.addRow(new String[] { oi.getName(), String.valueOf(oi.getQuantity()), String.valueOf(oi.getPriceBeforeAdjustments(true)), String.valueOf(oi.getAverageAdjustmentValue()),
int quantity = orderItems.get(0).getOrderItem().getQuantity(); orderItems.get(0).getOrderItem().setQuantity(quantity + 1);
@Override public Money getPriceBeforeAdjustments(boolean allowSalesPrice, boolean includeChildren) { boolean retailPriceOverride = false; for (OrderItemPriceDetail oipd : getOrderItemPriceDetails()) { if (oipd.getUseSalePrice() == false) { retailPriceOverride = true; break; } } Money returnPrice = Money.ZERO; if (includeChildren) { for (OrderItem child : getChildOrderItems()) { Money childPrice = child.getPriceBeforeAdjustments(allowSalesPrice, true); returnPrice = returnPrice.add(childPrice.multiply(child.getQuantity()).divide(quantity)); } } if (allowSalesPrice && !retailPriceOverride) { return getSalePrice().add(returnPrice); } else { return getRetailPrice().add(returnPrice); } }