Examples with FulfillmentGroup org.broadleafcommerce.core.order.domain.FulfillmentGroup used on opensource projects

Example 61 with FulfillmentGroup

use of org.broadleafcommerce.core.order.domain.FulfillmentGroup in project BroadleafCommerce by BroadleafCommerce.

the class LegacyOrderServiceImpl method addFulfillmentGroupToOrder.

@Override
public FulfillmentGroup addFulfillmentGroupToOrder(Order order, FulfillmentGroup fulfillmentGroup, boolean priceOrder) throws PricingException {
    FulfillmentGroup dfg = findDefaultFulfillmentGroupForOrder(order);
    if (dfg == null) {
        fulfillmentGroup.setPrimary(true);
    } else if (dfg.equals(fulfillmentGroup)) {
        // API user is trying to re-add the default fulfillment group to the
        // same order
        fulfillmentGroup.setPrimary(true);
        order.getFulfillmentGroups().remove(dfg);
    // fulfillmentGroupDao.delete(dfg);
    }
    fulfillmentGroup.setOrder(order);
    // 1) For each item in the new fulfillment group
    for (FulfillmentGroupItem fgItem : fulfillmentGroup.getFulfillmentGroupItems()) {
        // 2) Find the item's existing fulfillment group
        for (FulfillmentGroup fg : order.getFulfillmentGroups()) {
            // fulfillment group
            if (!fg.equals(fulfillmentGroup)) {
                // 3) remove item from it's existing fulfillment
                // group
                fg.getFulfillmentGroupItems().remove(fgItem);
            }
        }
    }
    fulfillmentGroup = fulfillmentGroupDao.save(fulfillmentGroup);
    order.getFulfillmentGroups().add(fulfillmentGroup);
    int fulfillmentGroupIndex = order.getFulfillmentGroups().size() - 1;
    order = updateOrder(order, priceOrder);
    return order.getFulfillmentGroups().get(fulfillmentGroupIndex);
}

Example 62 with FulfillmentGroup

use of org.broadleafcommerce.core.order.domain.FulfillmentGroup in project BroadleafCommerce by BroadleafCommerce.

the class LegacyOrderServiceImpl method removeOrderItemFromFullfillmentGroup.

protected void removeOrderItemFromFullfillmentGroup(Order order, OrderItem orderItem) {
    List<FulfillmentGroup> fulfillmentGroups = order.getFulfillmentGroups();
    for (FulfillmentGroup fulfillmentGroup : fulfillmentGroups) {
        Iterator<FulfillmentGroupItem> itr = fulfillmentGroup.getFulfillmentGroupItems().iterator();
        while (itr.hasNext()) {
            FulfillmentGroupItem fulfillmentGroupItem = itr.next();
            if (fulfillmentGroupItem.getOrderItem().equals(orderItem)) {
                itr.remove();
                fulfillmentGroupItemDao.delete(fulfillmentGroupItem);
            } else if (orderItem instanceof BundleOrderItem) {
                BundleOrderItem bundleOrderItem = (BundleOrderItem) orderItem;
                for (DiscreteOrderItem discreteOrderItem : bundleOrderItem.getDiscreteOrderItems()) {
                    if (fulfillmentGroupItem.getOrderItem().equals(discreteOrderItem)) {
                        itr.remove();
                        fulfillmentGroupItemDao.delete(fulfillmentGroupItem);
                        break;
                    }
                }
            }
        }
    }
}

Example 63 with FulfillmentGroup

use of org.broadleafcommerce.core.order.domain.FulfillmentGroup in project BroadleafCommerce by BroadleafCommerce.

the class AddWorkflowPriceOrderIfNecessaryActivity method execute.

@Override
public ProcessContext<CartOperationRequest> execute(ProcessContext<CartOperationRequest> context) throws Exception {
    CartOperationRequest request = context.getSeedData();
    Order order = request.getOrder();
    // go ahead and carry out that delete here.
    if (CollectionUtils.isNotEmpty(request.getMultishipOptionsToDelete())) {
        for (Long[] pack : request.getMultishipOptionsToDelete()) {
            if (pack[1] == null) {
                orderMultishipOptionService.deleteOrderItemOrderMultishipOptions(pack[0]);
            } else {
                orderMultishipOptionService.deleteOrderItemOrderMultishipOptions(pack[0], pack[1].intValue());
            }
        }
    }
    // ones that should be deleted. Delete them here.
    if (CollectionUtils.isNotEmpty(request.getFgisToDelete())) {
        for (FulfillmentGroupItem fgi : request.getFgisToDelete()) {
            for (FulfillmentGroup fg : order.getFulfillmentGroups()) {
                ListIterator<FulfillmentGroupItem> fgItemIter = fg.getFulfillmentGroupItems().listIterator();
                while (fgItemIter.hasNext()) {
                    FulfillmentGroupItem fgi2 = fgItemIter.next();
                    if (fgi2 == fgi) {
                        fgItemIter.remove();
                        fgItemDao.delete(fgi2);
                    }
                }
            }
        }
    }
    // We now need to delete any OrderItems that were marked as such, including their children, if any
    for (OrderItem oi : request.getOisToDelete()) {
        order.getOrderItems().remove(oi);
        orderItemService.delete(oi);
        if (oi.getParentOrderItem() != null) {
            OrderItem parentItem = oi.getParentOrderItem();
            parentItem.getChildOrderItems().remove(oi);
        }
    }
    // We need to build up a map of OrderItem to which FulfillmentGroupItems reference that particular OrderItem.
    // We'll also save the order item and build up a map of the unsaved items to their saved counterparts.
    Map<OrderItem, List<FulfillmentGroupItem>> oiFgiMap = new HashMap<>();
    Map<OrderItem, OrderItem> savedOrderItems = new HashMap<>();
    for (OrderItem oi : order.getOrderItems()) {
        if (oi instanceof BundleOrderItem) {
            // We first need to save the discrete order items that are part of this bundle. Once they're saved, we'll
            // mark them and remove them from this bundle.
            List<DiscreteOrderItem> doisToAdd = new ArrayList<>();
            ListIterator<DiscreteOrderItem> li = ((BundleOrderItem) oi).getDiscreteOrderItems().listIterator();
            while (li.hasNext()) {
                DiscreteOrderItem doi = li.next();
                getOiFgiMap(order, oiFgiMap, doi);
                DiscreteOrderItem savedDoi = (DiscreteOrderItem) orderItemService.saveOrderItem(doi);
                savedOrderItems.put(doi, savedDoi);
                li.remove();
                doisToAdd.add(savedDoi);
            }
            // After the discrete order items are saved, we can re-add the saved versions to our bundle and then
            // save the bundle as well.
            ((BundleOrderItem) oi).getDiscreteOrderItems().addAll(doisToAdd);
            BundleOrderItem savedBoi = (BundleOrderItem) orderItemService.saveOrderItem(oi);
            savedOrderItems.put(oi, savedBoi);
            // to to the saved version of the bundle.
            for (DiscreteOrderItem doi : savedBoi.getDiscreteOrderItems()) {
                doi.setBundleOrderItem(savedBoi);
            }
        } else {
            getOiFgiMap(order, oiFgiMap, oi);
            savedOrderItems.put(oi, orderItemService.saveOrderItem(oi));
        }
    }
    // Now, we'll update the orderitems in the order to their saved counterparts
    ListIterator<OrderItem> li = order.getOrderItems().listIterator();
    List<OrderItem> oisToAdd = new ArrayList<>();
    while (li.hasNext()) {
        OrderItem oi = li.next();
        OrderItem savedOi = savedOrderItems.get(oi);
        oisToAdd.add(savedOi);
        li.remove();
    }
    order.getOrderItems().addAll(oisToAdd);
    for (Entry<OrderItem, List<FulfillmentGroupItem>> entry : oiFgiMap.entrySet()) {
        // Update any FulfillmentGroupItems that reference order items
        for (FulfillmentGroupItem fgi : entry.getValue()) {
            fgi.setOrderItem(savedOrderItems.get(entry.getKey()));
        }
        // We also need to update the orderItem on the request in case it's used by the caller of this workflow
        if (entry.getKey() == request.getOrderItem()) {
            request.setOrderItem(savedOrderItems.get(entry.getKey()));
        }
    }
    // We need to add the new item to the parent's child order items as well.
    updateChildOrderItem(request, order);
    // If a custom implementation needs to handle additional saves before the parent Order is saved, this method
    // can be overridden to provide that functionality.
    preSaveOperation(request);
    // Now that our collection items in our Order have been saved and the state of our Order is in a place where we
    // won't get a transient save exception, we are able to go ahead and save the order with optional pricing.
    order = orderService.save(order, request.isPriceOrder());
    request.setOrder(order);
    return context;
}

Example 64 with FulfillmentGroup

use of org.broadleafcommerce.core.order.domain.FulfillmentGroup in project BroadleafCommerce by BroadleafCommerce.

the class FulfillmentGroupMerchandiseTotalActivity method execute.

@Override
public ProcessContext<Order> execute(ProcessContext<Order> context) throws Exception {
    Order order = context.getSeedData();
    for (FulfillmentGroup fulfillmentGroup : order.getFulfillmentGroups()) {
        Money merchandiseTotal = BroadleafCurrencyUtils.getMoney(BigDecimal.ZERO, fulfillmentGroup.getOrder().getCurrency());
        for (FulfillmentGroupItem fulfillmentGroupItem : fulfillmentGroup.getFulfillmentGroupItems()) {
            OrderItem item = fulfillmentGroupItem.getOrderItem();
            merchandiseTotal = merchandiseTotal.add(item.getTotalPrice());
        }
        fulfillmentGroup.setMerchandiseTotal(merchandiseTotal);
    }
    context.setSeedData(order);
    return context;
}

Example 65 with FulfillmentGroup

use of org.broadleafcommerce.core.order.domain.FulfillmentGroup in project BroadleafCommerce by BroadleafCommerce.

the class FulfillmentGroupPricingActivity method execute.

@Override
public ProcessContext<Order> execute(ProcessContext<Order> context) throws Exception {
    Order order = context.getSeedData();
    /*
         * 1. Get FGs from Order
         * 2. take each FG and call shipping module with the shipping svc
         * 3. add FG back to order
         */
    Money totalFulfillmentCharges = BroadleafCurrencyUtils.getMoney(BigDecimal.ZERO, order.getCurrency());
    for (FulfillmentGroup fulfillmentGroup : order.getFulfillmentGroups()) {
        if (fulfillmentGroup != null) {
            if (!fulfillmentGroup.getShippingOverride()) {
                fulfillmentGroup = fulfillmentPricingService.calculateCostForFulfillmentGroup(fulfillmentGroup);
            }
            if (fulfillmentGroup.getFulfillmentPrice() != null) {
                totalFulfillmentCharges = totalFulfillmentCharges.add(fulfillmentGroup.getFulfillmentPrice());
            }
        }
    }
    order.setTotalFulfillmentCharges(totalFulfillmentCharges);
    context.setSeedData(order);
    return context;
}