}

    public static Map<String, Object> ccRelease(DispatchContext ctx, Map<String, Object> context) {

        Locale locale = (Locale) context.get("locale");

        GenericValue orderPaymentPreference = (GenericValue) context.get("orderPaymentPreference");

        GenericValue authTransaction = PaymentGatewayServices.getAuthTransaction(orderPaymentPreference);

        if (authTransaction == null) {

            return ServiceUtil.returnError(UtilProperties.getMessage(resource,

                    "AccountingPaymentTransactionAuthorizationNotFoundCannotRelease", locale));

        return results;

    }

    public static Map<String, Object> ccAuthCapture(DispatchContext ctx, Map<String, Object> context) {

        Locale locale = (Locale) context.get("locale");

        Map<String, Object> results = ServiceUtil.returnSuccess();

        Map<String, Object> request = FastMap.newInstance();

        Properties props = buildAIMProperties(context, delegator);

        buildMerchantInfo(context, props, request);

    }

    // Service for creating commission invoices

    public static Map<String, Object> createCommissionInvoices(DispatchContext dctx, Map<String, Object> context) {

        LocalDispatcher dispatcher = dctx.getDispatcher();

        GenericValue userLogin = (GenericValue) context.get("userLogin");

        Locale locale = (Locale) context.get("locale");

        List<String> salesInvoiceIds = UtilGenerics.checkList(context.get("invoiceIds"));

        List<Map<String, String>> invoicesCreated = FastList.newInstance();

        Map<String, List<Map<String, Object>>> commissionParties = FastMap.newInstance();

        for (String salesInvoiceId : salesInvoiceIds) {

            List<String> salesRepPartyIds = UtilGenerics.checkList(context.get("partyIds"));

            BigDecimal amountTotal =  InvoiceWorker.getInvoiceTotal(delegator, salesInvoiceId);

            if (amountTotal.signum() == 0) {

                Debug.logWarning("Invoice [" + salesInvoiceId + "] has an amount total of [" + amountTotal + "], so no commission invoice will be created", module);

                return ServiceUtil.returnError(UtilProperties.getMessage(resource,

                        "AccountingInvoiceCommissionZeroInvoiceAmount", locale));

            }

            BigDecimal appliedFraction = amountTotal.divide(amountTotal, 12, ROUNDING);

            GenericValue invoice = null;

            boolean isReturn = false;

            List<String> billFromVendorInvoiceRoles = new ArrayList<String>();

            List<GenericValue> invoiceItems = new ArrayList<GenericValue>();

            try {

                List<EntityExpr> invoiceRoleConds = UtilMisc.toList(

                        EntityCondition.makeCondition("invoiceId", EntityOperator.EQUALS, salesInvoiceId),

                        EntityCondition.makeCondition("roleTypeId", EntityOperator.EQUALS, "BILL_FROM_VENDOR"));

                invoiceRoleConds = UtilMisc.toList(

                        EntityCondition.makeCondition("invoiceId", EntityOperator.EQUALS, salesInvoiceId),

                        EntityCondition.makeCondition("roleTypeId", EntityOperator.EQUALS, "SALES_REP"));

                // if the receiving parties is empty then we will create commission invoices for all sales agent associated to sales invoice.

                if (UtilValidate.isEmpty(salesRepPartyIds)) {

                    if (UtilValidate.isEmpty(salesRepPartyIds)) {

                        return ServiceUtil.returnError(UtilProperties.getMessage(resource,

                        "No party found with role sales representative for sales invoice "+ salesInvoiceId, locale));

                    }

                } else {

                    if (UtilValidate.isNotEmpty(salesInvoiceRolePartyIds)) {

                        salesRepPartyIds = UtilGenerics.checkList(CollectionUtils.intersection(salesRepPartyIds, salesInvoiceRolePartyIds));

                    }

                }

                String invoiceTypeId = invoice.getString("invoiceTypeId");

                if ("CUST_RTN_INVOICE".equals(invoiceTypeId)) {

                    isReturn = true;

                } else if (!"SALES_INVOICE".equals(invoiceTypeId)) {

                    Debug.logWarning("This type of invoice has no commission; returning success", module);

                    return ServiceUtil.returnError(UtilProperties.getMessage(resource,

                            "AccountingInvoiceCommissionInvalid", locale));

                }

            } catch (GenericEntityException e) {

                return ServiceUtil.returnError(e.getMessage());

            }

            // Map of commission Lists (of Maps) for each party.

            // Determine commissions for various parties.

            for (GenericValue invoiceItem : invoiceItems) {

                BigDecimal amount = ZERO;

                BigDecimal quantity = ZERO;

                quantity = invoiceItem.getBigDecimal("quantity");

                amount = invoiceItem.getBigDecimal("amount");

                amount = isReturn ? amount.negate() : amount;

                String productId = invoiceItem.getString("productId");

                String invoiceItemSeqId = invoiceItem.getString("invoiceItemSeqId");

                String invoiceId = invoiceItem.getString("invoiceId");

                // Determine commission parties for this invoiceItem

                if (UtilValidate.isNotEmpty(productId)) {

                    Map<String, Object> resultMap = null;

                    try {

                        resultMap = dispatcher.runSync("getCommissionForProduct", UtilMisc.<String, Object>toMap(

                                "productId", productId,

                                "invoiceId", invoiceId,

                                "invoiceItemSeqId", invoiceItemSeqId,

                                "invoiceItemTypeId", invoiceItem.getString("invoiceItemTypeId"),

                                "amount", amount,

                                "quantity", quantity,

                                "userLogin", userLogin));

                    } catch (GenericServiceException e) {

                        return ServiceUtil.returnError(e.getMessage());

                    }

                    // build a Map of partyIds (both to and from) in a commission and the amounts

                    // Note that getCommissionForProduct returns a List of Maps with a lot values.  See services.xml definition for reference.

                    List<Map<String, Object>> itemCommissions = UtilGenerics.checkList(resultMap.get("commissions"));

                    if (UtilValidate.isNotEmpty(itemCommissions)) {

                        for (Map<String, Object> commissionMap : itemCommissions) {

                            commissionMap.put("invoice", invoice);

                            commissionMap.put("appliedFraction", appliedFraction);

                            if (!billFromVendorInvoiceRoles.contains(commissionMap.get("partyIdFrom")) || !salesRepPartyIds.contains(commissionMap.get("partyIdTo"))) {

                                continue;

                            }

                            String partyIdFromTo = (String) commissionMap.get("partyIdFrom") + (String) commissionMap.get("partyIdTo");

                            if (!commissionParties.containsKey(partyIdFromTo)) {

                                commissionParties.put(partyIdFromTo, UtilMisc.toList(commissionMap));

                            } else {

                                (commissionParties.get(partyIdFromTo)).add(commissionMap);

                            }

                        }

                    }

                }

            }

        }

        Timestamp now = UtilDateTime.nowTimestamp();

        // Create invoice for each commission receiving party

        for (Map.Entry<String, List<Map<String, Object>>> commissionParty : commissionParties.entrySet()) {

            List<GenericValue> toStore = FastList.newInstance();

            List<Map<String, Object>> commList = commissionParty.getValue();

            // get the billing parties

            if (UtilValidate.isEmpty(commList)) {

                continue;

            }

            // From and To are reversed between commission and invoice

            String partyIdBillTo = (String) (commList.get(0)).get("partyIdFrom");

            String partyIdBillFrom = (String) (commList.get(0)).get("partyIdTo");

            GenericValue invoice = (GenericValue) (commList.get(0)).get("invoice");

            BigDecimal appliedFraction = (BigDecimal) (commList.get(0)).get("appliedFraction");

            Long days = (Long) (commList.get(0)).get("days");

            // create the invoice record

            // To and From are in commission's sense, opposite for invoice

            Map<String, Object> createInvoiceMap = FastMap.newInstance();

            createInvoiceMap.put("partyId", partyIdBillTo);

            createInvoiceMap.put("partyIdFrom", partyIdBillFrom);

            createInvoiceMap.put("invoiceDate", now);

            // if there were days associated with the commission agreement, then set a dueDate for the invoice.

            if (days != null) {

                createInvoiceMap.put("dueDate", UtilDateTime.getDayEnd(now, days));

            }

            createInvoiceMap.put("invoiceTypeId", "COMMISSION_INVOICE");

            // start with INVOICE_IN_PROCESS, in the INVOICE_READY we can't change the invoice (or shouldn't be able to...)

            createInvoiceMap.put("statusId", "INVOICE_IN_PROCESS");

            createInvoiceMap.put("currencyUomId", invoice.getString("currencyUomId"));

            createInvoiceMap.put("userLogin", userLogin);

            // store the invoice first

            Map<String, Object> createInvoiceResult = null;

            try {

                createInvoiceResult = dispatcher.runSync("createInvoice", createInvoiceMap);

            } catch (GenericServiceException e) {

                return ServiceUtil.returnError(UtilProperties.getMessage(resource,

                        "AccountingInvoiceCommissionError", locale), null, null, createInvoiceResult);

            }

            String invoiceId = (String) createInvoiceResult.get("invoiceId");

            // create the bill-from (or pay-to) contact mech as the primary PAYMENT_LOCATION of the party from the store

            List<EntityExpr> partyContactMechPurposeConds = UtilMisc.toList(

                    EntityCondition.makeCondition("partyId", EntityOperator.EQUALS, partyIdBillTo),

                    EntityCondition.makeCondition("contactMechPurposeTypeId", EntityOperator.EQUALS, "BILLING_LOCATION"));

            List<GenericValue> partyContactMechPurposes = new ArrayList<GenericValue>();

            try {

                        EntityCondition.makeCondition(partyContactMechPurposeConds, EntityOperator.AND), null, null, null, false);

            } catch (GenericEntityException e) {

                return ServiceUtil.returnError(e.getMessage());

            }

            if (partyContactMechPurposes.size() > 0) {

                GenericValue address = partyContactMechPurposes.get(0);

                        "invoiceId", invoiceId,

                        "contactMechId", address.getString("contactMechId"),

                        "contactMechPurposeTypeId", "BILLING_LOCATION"));

                toStore.add(invoiceContactMech);

            }

            partyContactMechPurposeConds = UtilMisc.toList(

                    EntityCondition.makeCondition("partyId", EntityOperator.EQUALS, partyIdBillTo),

                    EntityCondition.makeCondition("contactMechPurposeTypeId", EntityOperator.EQUALS, "PAYMENT_LOCATION"));

            try {

                        EntityCondition.makeCondition(partyContactMechPurposeConds, EntityOperator.AND), null, null, null, false);

            } catch (GenericEntityException e) {

                return ServiceUtil.returnError(e.getMessage());

            }

            if (partyContactMechPurposes.size() > 0) {

                GenericValue address = partyContactMechPurposes.get(0);

                        "invoiceId", invoiceId,

                        "contactMechId", address.getString("contactMechId"),

                        "contactMechPurposeTypeId", "PAYMENT_LOCATION"));

                toStore.add(invoiceContactMech);

            }

            // create the item records

            for (Map<String, Object> commissionMap : commList) {

                BigDecimal elemAmount = ((BigDecimal)commissionMap.get("commission")).multiply(appliedFraction);

                BigDecimal quantity = (BigDecimal)commissionMap.get("quantity");

                String invoiceIdFrom = (String)commissionMap.get("invoiceId");

                String invoiceItemSeqIdFrom = (String)commissionMap.get("invoiceItemSeqId");

                elemAmount = elemAmount.setScale(DECIMALS, ROUNDING);

                Map<String, Object> resMap = null;

                try {

                    resMap = dispatcher.runSync("createInvoiceItem", UtilMisc.toMap("invoiceId", invoiceId,

                            "productId", commissionMap.get("productId"),

                            "invoiceItemTypeId", "COMM_INV_ITEM",

                            "quantity",quantity,

                            "amount", elemAmount,

                            "userLogin", userLogin));

                    dispatcher.runSync("createInvoiceItemAssoc", UtilMisc.toMap("invoiceIdFrom", invoiceIdFrom,

                            "invoiceItemSeqIdFrom", invoiceItemSeqIdFrom,

                            "invoiceIdTo", invoiceId,

                            "invoiceItemSeqIdTo", resMap.get("invoiceItemSeqId"),

                            "invoiceItemAssocTypeId", "COMMISSION_INVOICE",

                            "partyIdFrom", partyIdBillFrom,

                            "partyIdTo", partyIdBillTo,

                            "quantity", quantity,

                            "amount", elemAmount,

                            "userLogin", userLogin));

                } catch (GenericServiceException e) {

                    return ServiceUtil.returnError(e.getMessage());

                }

                if (ServiceUtil.isError(resMap)) {

                    return ServiceUtil.returnError(UtilProperties.getMessage(resource,

                            "AccountingInvoiceCommissionErrorItem", locale), null, null, resMap);

                }

            }

            // store value objects

            try {

            } catch (GenericEntityException e) {

                Debug.logError(e, "Entity/data problem creating commission invoice: " + e.toString(), module);

                return ServiceUtil.returnError(UtilProperties.getMessage(resource,

                        "AccountingInvoiceCommissionEntityDataProblem",

                        UtilMisc.toMap("reason", e.toString()), locale));

        return response;

    }

    public static Map<String, Object> setInvoicesToReadyFromShipment(DispatchContext dctx, Map<String, Object> context) {

        LocalDispatcher dispatcher = dctx.getDispatcher();

        String shipmentId = (String) context.get("shipmentId");

        Locale locale = (Locale) context.get("locale");

        GenericValue userLogin = (GenericValue) context.get("userLogin");

        // 1. Find all the orders for this shipment

        // 2. For every order check the invoice

        // 2.a If the invoice is in In-Process status, then move its status to ready and capture the payment.

        // 2.b If the invoice is in status other then IN-Process, skip this. These would be already paid and captured.

        try {

        } catch (GenericEntityException e) {

            Debug.logError(e, "Trouble getting Shipment entity for shipment " + shipmentId, module);

            return ServiceUtil.returnError(UtilProperties.getMessage(resource,

                    "AccountingTroubleGettingShipmentEntity",

                    UtilMisc.toMap("shipmentId", shipmentId), locale));

        }

        List<GenericValue> itemIssuances = FastList.newInstance();

        try {

            EntityFindOptions findOptions = new EntityFindOptions();

            findOptions.setDistinct(true);

            Set<String> fieldsToSelect = UtilMisc.toSet("orderId", "shipmentId");

        } catch (GenericEntityException e) {

            Debug.logError(e, "Problem getting issued items from shipments", module);

            return ServiceUtil.returnError(UtilProperties.getMessage(resource,

                    "AccountingProblemGettingItemsFromShipments", locale));

        }

        if (itemIssuances.size() == 0) {

            Debug.logInfo("No items issued for shipments", module);

            return ServiceUtil.returnSuccess();

        }

        // The orders can now be placed in separate groups, each for

        // 1. The group of orders for which payment is already captured. No grouping and action required.

        // 2. The group of orders for which invoice is IN-Process status.

        Map<String, Object> ordersWithInProcessInvoice = FastMap.newInstance();

        for (GenericValue itemIssuance : itemIssuances) {

            String orderId = itemIssuance.getString("orderId");

            Map<String, Object> billFields = FastMap.newInstance();

            billFields.put("orderId", orderId);

            List<GenericValue> orderItemBillings = FastList.newInstance();

            try {

            } catch (GenericEntityException e) {

                Debug.logError(e, "Problem looking up OrderItemBilling records for " + billFields, module);

                return ServiceUtil.returnError(UtilProperties.getMessage(resource,

                        "AccountingProblemLookingUpOrderItemBilling",

                        UtilMisc.toMap("billFields", billFields), locale));

        return serviceResult;

    }

    public static Map<String, Object> createInvoicesFromShipments(DispatchContext dctx, Map<String, ? extends Object> context) {

        LocalDispatcher dispatcher = dctx.getDispatcher();

        List<String> shipmentIds = UtilGenerics.checkList(context.get("shipmentIds"));

        Locale locale = (Locale) context.get("locale");

        Boolean createSalesInvoicesForDropShipments = (Boolean) context.get("createSalesInvoicesForDropShipments");

        if (UtilValidate.isEmpty(createSalesInvoicesForDropShipments)) createSalesInvoicesForDropShipments = Boolean.FALSE;

        boolean salesShipmentFound = false;

        boolean purchaseShipmentFound = false;

        boolean dropShipmentFound = false;

        List<String> invoicesCreated = FastList.newInstance();

        //DEJ20060520: not used? planned to be used? List shipmentIdList = new LinkedList();

        for (String tmpShipmentId : shipmentIds) {

            try {

                if ((shipment.getString("shipmentTypeId") != null) && (shipment.getString("shipmentTypeId").equals("PURCHASE_SHIPMENT"))) {

                    purchaseShipmentFound = true;

                } else if ((shipment.getString("shipmentTypeId") != null) && (shipment.getString("shipmentTypeId").equals("DROP_SHIPMENT"))) {

                    dropShipmentFound = true;

                } else {

                    salesShipmentFound = true;

                }

                if (purchaseShipmentFound && salesShipmentFound && dropShipmentFound) {

                    return ServiceUtil.returnError(UtilProperties.getMessage(resource,

                            "AccountingShipmentsOfDifferentTypes",

                            UtilMisc.toMap("tmpShipmentId", tmpShipmentId, "shipmentTypeId", shipment.getString("shipmentTypeId")),

                            locale));

                }

            } catch (GenericEntityException e) {

                Debug.logError(e, "Trouble getting Shipment entity for shipment " + tmpShipmentId, module);

                return ServiceUtil.returnError(UtilProperties.getMessage(resource,

                        "AccountingTroubleGettingShipmentEntity",

                        UtilMisc.toMap("tmpShipmentId", tmpShipmentId), locale));

            }

        }

        EntityCondition shipmentIdsCond = EntityCondition.makeCondition("shipmentId", EntityOperator.IN, shipmentIds);

        // check the status of the shipment

        // get the items of the shipment.  They can come from ItemIssuance if the shipment were from a sales order, ShipmentReceipt

        // if it were a purchase order or from the order items of the (possibly linked) orders if the shipment is a drop shipment

        List<GenericValue> items = null;

        List<GenericValue> orderItemAssocs = null;

        try {

            if (purchaseShipmentFound) {

                // filter out items which have been received but are not actually owned by an internal organization, so they should not be on a purchase invoice

                Iterator<GenericValue> itemsIter = items.iterator();

                while (itemsIter.hasNext()) {

                    GenericValue item = itemsIter.next();

                    GenericValue inventoryItem = item.getRelatedOne("InventoryItem");

                    if (UtilValidate.isEmpty(ownerPartyRole)) {

                        itemsIter.remove();

                    }

                }

            } else if (dropShipmentFound) {

                // Get the list of purchase order IDs related to the shipments

                List<String> purchaseOrderIds = EntityUtil.getFieldListFromEntityList(shipments, "primaryOrderId", true);

                if (createSalesInvoicesForDropShipments) {

                    // If a sales invoice is being created for a drop shipment, we have to reference the original sales order items

                    // Get the list of the linked orderIds (original sales orders)

                    // Get only the order items which are indirectly related to the purchase order - this limits the list to the drop ship group(s)

                    items = EntityUtil.getRelated("FromOrderItem", orderItemAssocs);

                } else {

                    // If it's a purchase invoice being created, the order items for that purchase orders can be used directly

                }

            } else {

            }

        } catch (GenericEntityException e) {

            Debug.logError(e, "Problem getting issued items from shipments", module);

            return ServiceUtil.returnError(UtilProperties.getMessage(resource,

                    "AccountingProblemGettingItemsFromShipments", locale));   

        }

        if (items.size() == 0) {

            Debug.logInfo("No items issued for shipments", module);

            return ServiceUtil.returnSuccess();

        }

        // group items by order

        Map<String, List<GenericValue>> shippedOrderItems = FastMap.newInstance();

        for (GenericValue item : items) {

            String orderId = item.getString("orderId");

            String orderItemSeqId = item.getString("orderItemSeqId");

            List<GenericValue> itemsByOrder = shippedOrderItems.get(orderId);

            if (itemsByOrder == null) {

                itemsByOrder = FastList.newInstance();

            }

            // check and make sure we haven't already billed for this issuance or shipment receipt

            List<EntityCondition> billFields = FastList.newInstance();

            billFields.add(EntityCondition.makeCondition("orderId", orderId));

            billFields.add(EntityCondition.makeCondition("orderItemSeqId", orderItemSeqId));

            billFields.add(EntityCondition.makeCondition("statusId", EntityOperator.NOT_EQUAL, "INVOICE_CANCELLED"));

            if (dropShipmentFound) {

                // Drop shipments have neither issuances nor receipts, so this check is meaningless

                itemsByOrder.add(item);

                shippedOrderItems.put(orderId, itemsByOrder);

                continue;

            } else if (item.getEntityName().equals("ItemIssuance")) {

                billFields.add(EntityCondition.makeCondition("itemIssuanceId", item.get("itemIssuanceId")));

            } else if (item.getEntityName().equals("ShipmentReceipt")) {

                billFields.add(EntityCondition.makeCondition("shipmentReceiptId", item.getString("receiptId")));

            }

            List<GenericValue> itemBillings = null;

            try {

            } catch (GenericEntityException e) {

                Debug.logError(e, "Problem looking up OrderItemBilling records for " + billFields, module);

                return ServiceUtil.returnError(UtilProperties.getMessage(resource,

                        "AccountingProblemLookingUpOrderItemBilling",

                        UtilMisc.toMap("billFields", billFields), locale));

            }

            // if none found, then okay to bill

            if (itemBillings.size() == 0) {

                itemsByOrder.add(item);

            }

            // update the map with modified list

            shippedOrderItems.put(orderId, itemsByOrder);

        }

        // make sure we aren't billing items already invoiced i.e. items billed as digital (FINDIG)

        Set<String> orders = shippedOrderItems.keySet();

        for (String orderId : orders) {

            // we'll only use this list to figure out which ones to send

            List<GenericValue> billItems = shippedOrderItems.get(orderId);

            // a new list to be used to pass to the create invoice service

            List<GenericValue> toBillItems = FastList.newInstance();

            // map of available quantities so we only have to calc once

            Map<String, BigDecimal> itemQtyAvail = FastMap.newInstance();

            // now we will check each issuance and make sure it hasn't already been billed

            for (GenericValue issue : billItems) {

                BigDecimal issueQty = ZERO;

                if (issue.getEntityName().equals("ShipmentReceipt")) {

                    issueQty = issue.getBigDecimal("quantityAccepted");

                } else {

                    issueQty = issue.getBigDecimal("quantity");

                }

                BigDecimal billAvail = itemQtyAvail.get(issue.getString("orderItemSeqId"));

                if (billAvail == null) {

                    List<EntityCondition> lookup = FastList.newInstance();

                    lookup.add(EntityCondition.makeCondition("orderId", orderId));

                    lookup.add(EntityCondition.makeCondition("orderItemSeqId", issue.get("orderItemSeqId")));

                    lookup.add(EntityCondition.makeCondition("statusId", EntityOperator.NOT_EQUAL, "INVOICE_CANCELLED"));

                    GenericValue orderItem = null;

                    List<GenericValue> billed = null;

                    BigDecimal orderedQty = null;

                    try {

                        orderItem = issue.getEntityName().equals("OrderItem") ? issue : issue.getRelatedOne("OrderItem");

                        // total ordered

                        orderedQty = orderItem.getBigDecimal("quantity");

                        if (dropShipmentFound && createSalesInvoicesForDropShipments.booleanValue()) {

                            // Override the issueQty with the quantity from the purchase order item

                            GenericValue orderItemAssoc = EntityUtil.getFirst(EntityUtil.filterByAnd(orderItemAssocs, UtilMisc.toMap("orderId", issue.getString("orderId"), "orderItemSeqId", issue.getString("orderItemSeqId"))));

                            GenericValue purchaseOrderItem = orderItemAssoc.getRelatedOne("ToOrderItem");

                            orderItem.set("quantity", purchaseOrderItem.getBigDecimal("quantity"));

                            issueQty = purchaseOrderItem.getBigDecimal("quantity");

                        }

                    } catch (GenericEntityException e) {

                        Debug.logError(e, "Problem getting OrderItem/OrderItemBilling records " + lookup, module);

                        return ServiceUtil.returnError(UtilProperties.getMessage(resource,

                                "AccountingProblemGettingOrderItemOrderItemBilling",

                                UtilMisc.toMap("lookup", lookup), locale));

                    }

                    // add up the already billed total

                    if (billed.size() > 0) {

                        BigDecimal billedQuantity = ZERO;

                        for (GenericValue oib : billed) {

                            BigDecimal qty = oib.getBigDecimal("quantity");

                            if (qty != null) {

                                billedQuantity = billedQuantity.add(qty).setScale(DECIMALS, ROUNDING);

                            }

                        }

                        BigDecimal leftToBill = orderedQty.subtract(billedQuantity).setScale(DECIMALS, ROUNDING);

                        billAvail = leftToBill;

                    } else {

                        billAvail = orderedQty;

                    }

                }

                // no available means we cannot bill anymore

                if (billAvail != null && billAvail.signum() == 1) { // this checks if billAvail is a positive non-zero number

                    if (issueQty != null && issueQty.compareTo(billAvail) > 0) {

                        // can only bill some of the issuance; others have been billed already

                        if ("ShipmentReceipt".equals(issue.getEntityName())) {

                            issue.set("quantityAccepted", billAvail);

                        } else {

                            issue.set("quantity", billAvail);

                        }

                        billAvail = ZERO;

                    } else {

                        // now have been billed

                        billAvail = billAvail.subtract(issueQty).setScale(DECIMALS, ROUNDING);

                    }

                    // okay to bill these items; but none else

                    toBillItems.add(issue);

                }

                // update the available to bill quantity for the next pass

                itemQtyAvail.put(issue.getString("orderItemSeqId"), billAvail);

            }

            OrderReadHelper orh = new OrderReadHelper(delegator, orderId);

            GenericValue productStore = orh.getProductStore();

            String prorateShipping = productStore != null ? productStore.getString("prorateShipping") : "N";

            // If shipping charges are not prorated, the shipments need to be examined for additional shipping charges

            if ("N".equalsIgnoreCase(prorateShipping)) {

                // Get the set of filtered shipments

                List<GenericValue> invoiceableShipments = null;

                try {

                    if (dropShipmentFound) {

                        List<String> invoiceablePrimaryOrderIds = null;

                        if (createSalesInvoicesForDropShipments) {

                            // If a sales invoice is being created for the drop shipment, we need to reference back to the original purchase order IDs

                            // Get the IDs for orders which have billable items

                            List<String> invoiceableLinkedOrderIds = EntityUtil.getFieldListFromEntityList(toBillItems, "orderId", true);

                            // Get back the IDs of the purchase orders - this will be a list of the purchase order items which are billable by virtue of not having been

                            //  invoiced in a previous sales invoice

                            List<GenericValue> reverseOrderItemAssocs = EntityUtil.filterByCondition(orderItemAssocs, EntityCondition.makeCondition("orderId", EntityOperator.IN, invoiceableLinkedOrderIds));

                            invoiceablePrimaryOrderIds = EntityUtil.getFieldListFromEntityList(reverseOrderItemAssocs, "toOrderId", true);

                        } else {

                            // If a purchase order is being created for a drop shipment, the purchase order IDs can be used directly

                            invoiceablePrimaryOrderIds = EntityUtil.getFieldListFromEntityList(toBillItems, "orderId", true);

                        }

                        // Get the list of shipments which are associated with the filtered purchase orders

                        if (! UtilValidate.isEmpty(invoiceablePrimaryOrderIds)) {

                            List<EntityExpr> invoiceableShipmentConds = UtilMisc.toList(

                                    EntityCondition.makeCondition("primaryOrderId", EntityOperator.IN, invoiceablePrimaryOrderIds),

                                    EntityCondition.makeCondition("shipmentId", EntityOperator.IN, shipmentIds));

                        }

                    } else {

                        List<String> invoiceableShipmentIds = EntityUtil.getFieldListFromEntityList(toBillItems, "shipmentId", true);

                        if (UtilValidate.isNotEmpty(invoiceableShipmentIds)) {

                        }

                    }

                } catch (GenericEntityException e) {

                    Debug.logError(e, "Trouble calling createInvoicesFromShipments service", module);

                    return ServiceUtil.returnError(UtilProperties.getMessage(resource,

                            "AccountingTroubleCallingCreateInvoicesFromShipmentsService", locale));

                }

                // Total the additional shipping charges for the shipments

                Map<GenericValue, BigDecimal> additionalShippingCharges = FastMap.newInstance();

                BigDecimal totalAdditionalShippingCharges = ZERO;

                if (UtilValidate.isNotEmpty(invoiceableShipments)) {

                    for (GenericValue shipment : invoiceableShipments) {

                        if (shipment.get("additionalShippingCharge") == null) continue;

                        BigDecimal shipmentAdditionalShippingCharges = shipment.getBigDecimal("additionalShippingCharge").setScale(DECIMALS, ROUNDING);

                        additionalShippingCharges.put(shipment, shipmentAdditionalShippingCharges);

                        totalAdditionalShippingCharges = totalAdditionalShippingCharges.add(shipmentAdditionalShippingCharges);

                    }

                }

                // If the additional shipping charges are greater than zero, process them

                if (totalAdditionalShippingCharges.signum() == 1) {

                    // Add an OrderAdjustment to the order for each additional shipping charge

                    for (GenericValue shipment : additionalShippingCharges.keySet()) {

                        String shipmentId = shipment.getString("shipmentId");

                        BigDecimal additionalShippingCharge = additionalShippingCharges.get(shipment);

                        Map<String, Object> createOrderAdjustmentContext = FastMap.newInstance();

                        createOrderAdjustmentContext.put("orderId", orderId);

                        createOrderAdjustmentContext.put("orderAdjustmentTypeId", "SHIPPING_CHARGES");

                        String addtlChargeDescription = shipment.getString("addtlShippingChargeDesc");

                        if (UtilValidate.isEmpty(addtlChargeDescription)) {

                            addtlChargeDescription = UtilProperties.getMessage(resource, "AccountingAdditionalShippingChargeForShipment", UtilMisc.toMap("shipmentId", shipmentId), locale);

                        }

                        createOrderAdjustmentContext.put("description", addtlChargeDescription);

                        createOrderAdjustmentContext.put("sourceReferenceId", shipmentId);

                        createOrderAdjustmentContext.put("amount", additionalShippingCharge);

                        createOrderAdjustmentContext.put("userLogin", context.get("userLogin"));

                        String shippingOrderAdjustmentId = null;

                        try {

                            Map<String, Object> createOrderAdjustmentResult = dispatcher.runSync("createOrderAdjustment", createOrderAdjustmentContext);

                            shippingOrderAdjustmentId = (String) createOrderAdjustmentResult.get("orderAdjustmentId");

                        } catch (GenericServiceException e) {

                            Debug.logError(e, "Trouble calling createOrderAdjustment service", module);

                            return ServiceUtil.returnError(UtilProperties.getMessage(resource,

                                    "AccountingTroubleCallingCreateOrderAdjustmentService", locale));

                        }

                        // Obtain a list of OrderAdjustments due to tax on the shipping charges, if any

                        GenericValue billToParty = orh.getBillToParty();

                        GenericValue payToParty = orh.getBillFromParty();

                        GenericValue destinationContactMech = null;

                        try {

                            destinationContactMech = shipment.getRelatedOne("DestinationPostalAddress");

                        } catch (GenericEntityException e) {

                            Debug.logError(e, "Trouble calling createInvoicesFromShipment service; invoice not created for shipment " + shipmentId, module);

                            return ServiceUtil.returnError(UtilProperties.getMessage(resource,

                                    "AccountingTroubleCallingCreateInvoicesFromShipmentService", locale));

                        }

                        List<Object> emptyList = FastList.newInstance();

                        Map<String, Object> calcTaxContext = FastMap.newInstance();

                        calcTaxContext.put("productStoreId", orh.getProductStoreId());

                        calcTaxContext.put("payToPartyId", payToParty.getString("partyId"));

                        calcTaxContext.put("billToPartyId", billToParty.getString("partyId"));

                        calcTaxContext.put("orderShippingAmount", totalAdditionalShippingCharges);

                        calcTaxContext.put("shippingAddress", destinationContactMech);

                        // These parameters don't matter if we're only worried about adjustments on the shipping charges

                        calcTaxContext.put("itemProductList", emptyList);

                        calcTaxContext.put("itemAmountList", emptyList);

                        calcTaxContext.put("itemPriceList", emptyList);

                        calcTaxContext.put("itemQuantityList", emptyList);

                        calcTaxContext.put("itemShippingList", emptyList);

                        Map<String, Object> calcTaxResult = null;

                        try {

                            calcTaxResult = dispatcher.runSync("calcTax", calcTaxContext);

                        } catch (GenericServiceException e) {

                            Debug.logError(e, "Trouble calling calcTaxService", module);

                            return ServiceUtil.returnError(UtilProperties.getMessage(resource,

                                    "AccountingTroubleCallingCalcTaxService", locale));

                        }

                        List<GenericValue> orderAdjustments = UtilGenerics.checkList(calcTaxResult.get("orderAdjustments"));

                        // If we have any OrderAdjustments due to tax on shipping, store them and add them to the total

                        if (orderAdjustments != null) {

                            for (GenericValue orderAdjustment : orderAdjustments) {

                                totalAdditionalShippingCharges = totalAdditionalShippingCharges.add(orderAdjustment.getBigDecimal("amount").setScale(DECIMALS, ROUNDING));

                                orderAdjustment.set("orderId", orderId);

                                orderAdjustment.set("orderItemSeqId", "_NA_");

                                orderAdjustment.set("shipGroupSeqId", shipment.getString("primaryShipGroupSeqId"));

                                orderAdjustment.set("originalAdjustmentId", shippingOrderAdjustmentId);

                            }

                            try {

                            } catch (GenericEntityException e) {

                                Debug.logError(e, "Problem storing OrderAdjustments: " + orderAdjustments, module);

                                return ServiceUtil.returnError(UtilProperties.getMessage(resource,

                                        "AccountingProblemStoringOrderAdjustments",

                                        UtilMisc.toMap("orderAdjustments", orderAdjustments), locale));

                            }

                        }

                        // If part of the order was paid via credit card, try to charge it for the additional shipping

                        List<GenericValue> orderPaymentPreferences = null;

                        try {

                        } catch (GenericEntityException e) {

                            Debug.logError(e, "Problem getting OrderPaymentPreference records", module);

                            return ServiceUtil.returnError(UtilProperties.getMessage(resource,

                                    "AccountingProblemGettingOrderPaymentPreferences", locale));

                        }

                        //  Use the first credit card we find, for the sake of simplicity

                        String paymentMethodId = null;

                        GenericValue cardOrderPaymentPref = EntityUtil.getFirst(orderPaymentPreferences);

                        if (cardOrderPaymentPref != null) {

                            paymentMethodId = cardOrderPaymentPref.getString("paymentMethodId");

                        }

                        if (paymentMethodId != null) {

                            // Release all outstanding (not settled or cancelled) authorizations, while keeping a running

                            //  total of their amounts so that the total plus the additional shipping charges can be authorized again

                            //  all at once.

                            BigDecimal totalNewAuthAmount = totalAdditionalShippingCharges.setScale(DECIMALS, ROUNDING);

                            for (GenericValue orderPaymentPreference : orderPaymentPreferences) {

                                if (! (orderPaymentPreference.getString("statusId").equals("PAYMENT_SETTLED") || orderPaymentPreference.getString("statusId").equals("PAYMENT_CANCELLED"))) {

                                    GenericValue authTransaction = PaymentGatewayServices.getAuthTransaction(orderPaymentPreference);

                                    if (authTransaction != null && authTransaction.get("amount") != null) {

                                        // Update the total authorized amount

                                        totalNewAuthAmount = totalNewAuthAmount.add(authTransaction.getBigDecimal("amount").setScale(DECIMALS, ROUNDING));

                                        // Release the authorization for the OrderPaymentPreference

                                        Map<String, Object> prefReleaseResult = null;

                                        try {

                                            prefReleaseResult = dispatcher.runSync("releaseOrderPaymentPreference", UtilMisc.toMap("orderPaymentPreferenceId", orderPaymentPreference.getString("orderPaymentPreferenceId"), "userLogin", context.get("userLogin")));

                                        } catch (GenericServiceException e) {

                                            Debug.logError(e, "Trouble calling releaseOrderPaymentPreference service", module);

                                            return ServiceUtil.returnError(UtilProperties.getMessage(resource,

                                                    "AccountingTroubleCallingReleaseOrderPaymentPreferenceService", locale));

                                        }

                                        if (ServiceUtil.isError(prefReleaseResult) || ServiceUtil.isFailure(prefReleaseResult)) {

                                            String errMsg = ServiceUtil.getErrorMessage(prefReleaseResult);

                                            Debug.logError(errMsg, module);

                                            return ServiceUtil.returnError(errMsg);

                                        }

                                    }

                                }

                            }

                            // Create a new OrderPaymentPreference for the order to handle the new (totalled) charge. Don't

                            //  set the maxAmount so that it doesn't interfere with other authorizations

                            Map<String, Object> serviceContext = UtilMisc.toMap("orderId", orderId, "paymentMethodId", paymentMethodId, "paymentMethodTypeId", "CREDIT_CARD", "userLogin", context.get("userLogin"));

                            String orderPaymentPreferenceId = null;

                            try {

                                Map<String, Object> result = dispatcher.runSync("createOrderPaymentPreference", serviceContext);

                                orderPaymentPreferenceId = (String) result.get("orderPaymentPreferenceId");

                            } catch (GenericServiceException e) {

                                Debug.logError(e, "Trouble calling createOrderPaymentPreference service", module);

                                return ServiceUtil.returnError(UtilProperties.getMessage(resource,

                                        "AccountingTroubleCallingCreateOrderPaymentPreferenceService", locale));

                            }

                            // Attempt to authorize the new orderPaymentPreference

                            Map<String, Object> authResult = null;

                            try {

                                // Use an overrideAmount because the maxAmount wasn't set on the OrderPaymentPreference

                                authResult = dispatcher.runSync("authOrderPaymentPreference", UtilMisc.toMap("orderPaymentPreferenceId", orderPaymentPreferenceId, "overrideAmount", totalNewAuthAmount, "userLogin", context.get("userLogin")));

                            } catch (GenericServiceException e) {

                                Debug.logError(e, "Trouble calling authOrderPaymentPreference service", module);

                                return ServiceUtil.returnError(UtilProperties.getMessage(resource,

                                        "AccountingTroubleCallingAuthOrderPaymentPreferenceService", locale));

                            }

                            // If the authorization fails, create the invoice anyway, but make a note of it

                            boolean authFinished = ((Boolean) authResult.get("finished")).booleanValue();

                            boolean authErrors = ((Boolean) authResult.get("errors")).booleanValue();

                            if (authErrors || ! authFinished) {

                                String errMsg = UtilProperties.getMessage(resource, "AccountingUnableToAuthAdditionalShipCharges", UtilMisc.toMap("shipmentId", shipmentId, "paymentMethodId", paymentMethodId, "orderPaymentPreferenceId", orderPaymentPreferenceId), locale);

                                Debug.logError(errMsg, module);

                            }

                        }

                    }

                }

            } else {

                Debug.logInfo(UtilProperties.getMessage(resource, "AccountingIgnoringAdditionalShipCharges", UtilMisc.toMap("productStoreId", orh.getProductStoreId()), locale), module);

            }

            String invoiceId = null;

            List<GenericValue> shipmentItemBillings = null;

            String shipmentId = shipmentIds.get(0);

            try {

            } catch (GenericEntityException e) {

                return ServiceUtil.returnError(UtilProperties.getMessage(resource,

                        "AccountingProblemGettingShipmentItemBilling", locale));

            }

            if (UtilValidate.isNotEmpty(shipmentItemBillings)) {

    /** Initiate PayPal Request */

    public static String callPayPal(HttpServletRequest request, HttpServletResponse response) {

        Locale locale = UtilHttp.getLocale(request);

        GenericValue userLogin = (GenericValue) request.getSession().getAttribute("userLogin");

        // get the orderId

        String orderId = (String) request.getAttribute("orderId");

        // get the order header

        GenericValue orderHeader = null;

        try {

        } catch (GenericEntityException e) {

            Debug.logError(e, "Cannot get the order header for order: " + orderId, module);

            request.setAttribute("_ERROR_MESSAGE_", UtilProperties.getMessage(resourceErr, "payPalEvents.problemsGettingOrderHeader", locale));

            return "error";

        }

        String expandedContentId = content.getContentId(context);

        String expandedDataResourceId = content.getDataResourceId(context);

        String renderedContent = null;

        LocalDispatcher dispatcher = (LocalDispatcher) context.get("dispatcher");

        // make a new map for content rendering; so our current map does not get clobbered

        Map<String, Object> contentContext = FastMap.newInstance();

        contentContext.putAll(context);

        String dataResourceId = (String)contentContext.get("dataResourceId");

    /** PayPal Call-Back Event */

    public static String payPalIPN(HttpServletRequest request, HttpServletResponse response) {

        Locale locale = UtilHttp.getLocale(request);

        LocalDispatcher dispatcher = (LocalDispatcher) request.getAttribute("dispatcher");

        // get the product store

        GenericValue productStore = ProductStoreWorker.getProductStore(request);

        if (productStore == null) {

            Debug.logError("ProductStore is null", module);

            request.setAttribute("_ERROR_MESSAGE_", UtilProperties.getMessage(resourceErr, "payPalEvents.problemsGettingMerchantConfiguration", locale));

            return "error";

        }

        // get the payment properties file

        GenericValue paymentConfig = ProductStoreWorker.getProductStorePaymentSetting(delegator, productStore.getString("productStoreId"), "EXT_PAYPAL", null, true);

        String configString = null;

        String paymentGatewayConfigId = null;

        if (paymentConfig != null) {

            paymentGatewayConfigId = paymentConfig.getString("paymentGatewayConfigId");

            configString = paymentConfig.getString("paymentPropertiesPath");

        }

        if (configString == null) {

            configString = "payment.properties";

        }

        // get the confirm URL

        String confirmUrl = getPaymentGatewayConfigValue(delegator, paymentGatewayConfigId, "confirmUrl", configString, "payment.paypal.confirm");

        // get the redirect URL

        String redirectUrl = getPaymentGatewayConfigValue(delegator, paymentGatewayConfigId, "redirectUrl", configString, "payment.paypal.redirect");

        if (UtilValidate.isEmpty(confirmUrl) || UtilValidate.isEmpty(redirectUrl)) {

            Debug.logError("Payment properties is not configured properly, no confirm URL defined!", module);

            request.setAttribute("_ERROR_MESSAGE_", UtilProperties.getMessage(resourceErr, "payPalEvents.problemsGettingMerchantConfiguration", locale));

            return "error";

        }

        // first verify this is valid from PayPal

        Map <String, Object> parametersMap = UtilHttp.getParameterMap(request);

        parametersMap.put("cmd", "_notify-validate");

        // send off the confirm request

        String confirmResp = null;

        try {

            String str = UtilHttp.urlEncodeArgs(parametersMap);

            URL u = new URL(redirectUrl);

            URLConnection uc = u.openConnection();

            uc.setDoOutput(true);

            uc.setRequestProperty("Content-Type", "application/x-www-form-urlencoded");

            PrintWriter pw = new PrintWriter(uc.getOutputStream());

            pw.println(str);

            pw.close();

            BufferedReader in = new BufferedReader(new InputStreamReader(uc.getInputStream()));

            confirmResp = in.readLine();

            in.close();

            Debug.logError("PayPal Verification Response: " + confirmResp, module);

        } catch (IOException e) {

            Debug.logError(e, "Problems sending verification message", module);

        }

        Debug.logInfo("Got verification from PayPal, processing..", module);

        boolean verified = false;

        Set <String> keySet = parametersMap.keySet();

        Iterator <String> i = keySet.iterator();

        while (i.hasNext()) {

            String name = i.next();

            String value = request.getParameter(name);

            Debug.logError("### Param: " + name + " => " + value, module);

            if (UtilValidate.isNotEmpty(name) && "payer_status".equalsIgnoreCase(name) &&

                UtilValidate.isNotEmpty(value) && "verified".equalsIgnoreCase(value)) {

                verified = true;

            }

        }

        if (!verified) {

            Debug.logError("###### PayPal did not verify this request, need investigation!", module);

        }

        // get the system user

        GenericValue userLogin = null;

        try {

        } catch (GenericEntityException e) {

            Debug.logError(e, "Cannot get UserLogin for: system; cannot continue", module);

            request.setAttribute("_ERROR_MESSAGE_", UtilProperties.getMessage(resourceErr, "payPalEvents.problemsGettingAuthenticationUser", locale));

            return "error";

        }

        // get the orderId

        String orderId = request.getParameter("invoice");

        // get the order header

        GenericValue orderHeader = null;

        if (UtilValidate.isNotEmpty(orderId)) {

            try {

            } catch (GenericEntityException e) {

                Debug.logError(e, "Cannot get the order header for order: " + orderId, module);

                request.setAttribute("_ERROR_MESSAGE_", UtilProperties.getMessage(resourceErr, "payPalEvents.problemsGettingOrderHeader", locale));

                return "error";

            }

    /**

     * This is a generic service for traversing a Content tree, typical of a blog response tree. It calls the ContentWorker.traverse method.

     */

    public static Map<String, Object> traverseContent(DispatchContext dctx, Map<String, ? extends Object> context) {

        Map<String, Object> results = FastMap.newInstance();

        Locale locale = (Locale) context.get("locale");

        String contentId = (String) context.get("contentId");

        String direction = (String) context.get("direction");

        if (direction != null && direction.equalsIgnoreCase("From")) {

            direction = "From";

        } else {

            direction = "To";

        }

        if (contentId == null) {

            contentId = "PUBLISH_ROOT";

        }

        GenericValue content = null;

        try {

        } catch (GenericEntityException e) {

            Debug.logError(e, "Entity Error:" + e.getMessage(), module);

            return ServiceUtil.returnError(UtilProperties.getMessage(resource, "ContentNoContentFound", UtilMisc.toMap("contentId", contentId), locale));

        }

            String expandedContentId = content.getContentId(context);

            String expandedMapKey = content.getMapKey(context);

            String renderedContent = null;

            LocalDispatcher dispatcher = (LocalDispatcher) context.get("dispatcher");

            // create a new map for the content rendering; so our current context does not get overwritten!

            Map<String, Object> contentContext = FastMap.newInstance();

            contentContext.putAll(context);