orderreadhelper.java

国外的一套开源CRM

            while (oiIter.hasNext()) {
                orderItem = (GenericValue) oiIter.next();

                try {
                    oiInventoryRes = orderItem.getRelated("OrderItemInventoryRes");
                } catch (GenericEntityException e) {
                    Debug.logError(e, "Cannot locate OrderItemInventoryRes from OrderItem " + orderItem.getString("orderId") + " sequenceNum " + orderItem.getString("orderItemSeqId"), module);
                }

                if (UtilValidate.isNotEmpty(oiInventoryRes)) {
                    orderItemInventoryRes.addAll(oiInventoryRes);
                }
                if (oiInventoryRes.size() > 1) {
                    Debug.logWarning("Warning - Should not use quickShip with more than one orderItemInventoryRes for order " + orderHeader.getString("orderId") + " item sequenceNum " + orderItem.get("orderItemsSeqId"), module);
                }
            }
            if (UtilValidate.isNotEmpty(orderItemInventoryRes)) {
                Iterator orderItemInventoryResIter = orderItemInventoryRes.iterator();
                GenericValue anInventoryRes = null;

                while (orderItemInventoryResIter.hasNext()) {
                    anInventoryRes = (GenericValue) orderItemInventoryResIter.next();
                    GenericValue inventoryItem = null;

                    try {
                        inventoryItem = delegator.findByPrimaryKey("InventoryItem", UtilMisc.toMap("inventoryItemId", anInventoryRes.getString("inventoryItemId")));
                    } catch (GenericEntityException e) {
                        Debug.logError(e, "Cannot locate InventoryItem for ID " + anInventoryRes.getString("inventoryItemId"), module);
                    }
                    result.add(inventoryItem.getString("facilityId"));
                }
            }
        }
        return result;
    }    

    public List getOrderItemIssuances(GenericValue orderItem) {
        if (orderItem == null) return null;
        if (this.orderItemIssuances == null) {
            GenericDelegator delegator = orderItem.getDelegator();

            try {
                orderItemIssuances = delegator.findByAnd("ItemIssuance", UtilMisc.toMap("orderId", orderItem.get("orderId")));
            } catch (GenericEntityException e) {
                Debug.logWarning(e, "Trouble getting ItemIssuance(s)", module);
            }
        }
        return EntityUtil.filterByAnd(orderItemIssuances, UtilMisc.toMap("orderItemSeqId", orderItem.getString("orderItemSeqId")));
    }

    public double getOrderReturnedQuantity() {
        GenericDelegator delegator = orderHeader.getDelegator();
        List returnedItems = null;
        try {
            returnedItems = delegator.findByAnd("ReturnItem", UtilMisc.toMap("orderId", orderHeader.getString("orderId")));
        } catch (GenericEntityException e) {
            Debug.logError(e, "Problem getting ReturnItem from order", module);
            return -1;
        }

        double returnedQuantity = 0.00;
        if (returnedItems != null) {
            Iterator i = returnedItems.iterator();
            while (i.hasNext()) {
                GenericValue returnedItem = (GenericValue) i.next();
                if (returnedItem.get("returnQuantity") != null) {
                    returnedQuantity += returnedItem.getDouble("returnQuantity").doubleValue();
                }
            }
        }
        return returnedQuantity;
    }

    public double getItemShippedQuantity(GenericValue orderItem) {
        double quantityShipped = 0.00;
        List issuance = getOrderItemIssuances(orderItem);
        if (issuance != null) {
            Iterator i = issuance.iterator();
            while (i.hasNext()) {
                GenericValue issue = (GenericValue) i.next();
                Double issueQty = issue.getDouble("quantity");
                if (issueQty != null) {
                    quantityShipped += issueQty.doubleValue();
                }
            }
        }
        return quantityShipped;
    }

    public double getItemReservedQuantity(GenericValue orderItem) {
        double reserved = 0.00;

        List reses = getOrderItemInventoryReses(orderItem);
        if (reses != null) {
            Iterator i = reses.iterator();
            while (i.hasNext()) {
                GenericValue res = (GenericValue) i.next();
                Double quantity = res.getDouble("quantity");
                if (quantity != null) {
                    reserved += quantity.doubleValue();
                }
            }
        }
        return reserved;
    }

    public double getItemBackorderedQuantity(GenericValue orderItem) {
        double backOrdered = 0.00;

        Timestamp shipDate = orderItem.getTimestamp("estimatedShipDate");
        Timestamp autoCancel = orderItem.getTimestamp("autoCancelDate");

        List reses = getOrderItemInventoryReses(orderItem);
        if (reses != null) {
            Iterator i = reses.iterator();
            while (i.hasNext()) {
                GenericValue res = (GenericValue) i.next();
                Timestamp promised = res.getTimestamp("currentPromisedDate");
                if (promised == null) {
                    promised = res.getTimestamp("promisedDatetime");
                }
                if (autoCancel != null || (shipDate != null && shipDate.after(promised))) {
                    Double resQty = res.getDouble("quantity");
                    if (resQty != null) {
                        backOrdered += resQty.doubleValue();
                    }
                }
            }
        }
        return backOrdered;
    }

    public double getItemPendingShipmentQuantity(GenericValue orderItem) {
        double reservedQty = getItemReservedQuantity(orderItem);
        double backordered = getItemBackorderedQuantity(orderItem);
        return (reservedQty - backordered);
    }

    public double getItemCanceledQuantity(GenericValue orderItem) {
        Double cancelQty = orderItem.getDouble("cancelQuantity");
        if (cancelQty == null) cancelQty = new Double(0.0);
        return cancelQty.doubleValue();
    }

    public double getTotalOrderItemsQuantity() {
        List orderItems = getValidOrderItems();
        double totalItems = 0;

        for (int i = 0; i < orderItems.size(); i++) {
            GenericValue oi = (GenericValue) orderItems.get(i);

            totalItems += getOrderItemQuantity(oi).doubleValue();
        }
        return totalItems;
    }

    public double getTotalOrderItemsOrderedQuantity() {
        List orderItems = getValidOrderItems();
        double totalItems = 0;

        for (int i = 0; i < orderItems.size(); i++) {
            GenericValue oi = (GenericValue) orderItems.get(i);

            totalItems += oi.getDouble("quantity").doubleValue();
        }
        return totalItems;
    }

    public double getOrderItemsSubTotal() {
        return getOrderItemsSubTotal(getValidOrderItems(), getAdjustments());
    }

    public double getOrderItemSubTotal(GenericValue orderItem) {
        return getOrderItemSubTotal(orderItem, getAdjustments());
    }

    public double getOrderItemsTotal() {
        return getOrderItemsTotal(getValidOrderItems(), getAdjustments());
    }

    public double getOrderItemTotal(GenericValue orderItem) {
        return getOrderItemTotal(orderItem, getAdjustments());
    }

    public double getOrderItemTax(GenericValue orderItem) {
        return getOrderItemAdjustmentsTotal(orderItem, false, true, false);
    }

    public double getOrderItemShipping(GenericValue orderItem) {
        return getOrderItemAdjustmentsTotal(orderItem, false, false, true);
    }

    public double getOrderItemAdjustmentsTotal(GenericValue orderItem, boolean includeOther, boolean includeTax, boolean includeShipping) {
        return getOrderItemAdjustmentsTotal(orderItem, getAdjustments(), includeOther, includeTax, includeShipping);
    }

    public double getOrderItemAdjustmentsTotal(GenericValue orderItem) {
        return getOrderItemAdjustmentsTotal(orderItem, true, false, false);
    }

    public double getOrderItemAdjustmentTotal(GenericValue orderItem, GenericValue adjustment) {
        return calcItemAdjustment(adjustment, orderItem);
    }

    public String getAdjustmentType(GenericValue adjustment) {
        GenericValue adjustmentType = null;
        try {
            adjustmentType = adjustment.getRelatedOne("OrderAdjustmentType");
        } catch (GenericEntityException e) {
            Debug.logError(e, "Problems with order adjustment", module);
        }
        if (adjustmentType == null || adjustmentType.get("description") == null) {
            return "";
        } else {
            return adjustmentType.getString("description");
        }
    }

    public List getOrderItemStatuses(GenericValue orderItem) {
        return getOrderItemStatuses(orderItem, getOrderStatuses());
    }

    public String getCurrentItemStatusString(GenericValue orderItem) {
        GenericValue statusItem = null;
        try {
            statusItem = orderItem.getRelatedOneCache("StatusItem");
        } catch (GenericEntityException e) {
            Debug.logError(e, module);
        }
        if (statusItem != null) {
            return statusItem.getString("description");
        } else {
            return orderHeader.getString("statusId");
        }
    }

    /**
     * Checks to see if this user has read permission on this order
     * @param userLogin The UserLogin value object to check
     * @return boolean True if we have read permission
     */
    public boolean hasPermission(Security security, GenericValue userLogin) {
        return OrderReadHelper.hasPermission(security, userLogin, orderHeader);
    }

    /**
     * Getter for property orderHeader.
     * @return Value of property orderHeader.
     */
    public GenericValue getOrderHeader() {
        return orderHeader;
    }

    // ======================================================
    // =================== Static Methods ===================
    // ======================================================

    public static GenericValue getOrderHeader(GenericDelegator delegator, String orderId) {
        GenericValue orderHeader = null;
        if (orderId != null && delegator != null) {
            try {
                orderHeader = delegator.findByPrimaryKey("OrderHeader", UtilMisc.toMap("orderId", orderId));
            } catch (GenericEntityException e) {
                Debug.logError(e, "Cannot get order header", module);
            }
        }
        return orderHeader;
    }

    public static Double getOrderItemQuantity(GenericValue orderItem) {
        Double cancelQty = orderItem.getDouble("cancelQuantity");
        Double orderQty = orderItem.getDouble("quantity");

        if (cancelQty == null) cancelQty = new Double(0.0);
        if (orderQty == null) orderQty = new Double(0.0);
        return new Double(orderQty.doubleValue() - cancelQty.doubleValue());
    }