* Licensed to the Apache Software Foundation (ASF) under one

* or more contributor license agreements.  See the NOTICE file

* distributed with this work for additional information

* regarding copyright ownership.  The ASF licenses this file

* to you under the Apache License, Version 2.0 (the

* "License"); you may not use this file except in compliance

* with the License.  You may obtain a copy of the License at

*

* http://www.apache.org/licenses/LICENSE-2.0

*

* Unless required by applicable law or agreed to in writing,

* software distributed under the License is distributed on an

* "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY

* KIND, either express or implied.  See the License for the

* specific language governing permissions and limitations

* under the License.

*******************************************************************************/

* InvoiceServices - Services for creating invoices

*

* Note that throughout this file we use BigDecimal to do arithmetic. It is

* critical to understand the way BigDecimal works if you wish to modify the

* computations in this file. The most important things to keep in mind:

*

* Critically important: BigDecimal arithmetic methods like add(),

* multiply(), divide() do not modify the BigDecimal itself. Instead, they

* return a new BigDecimal. For example, to keep a running total of an

* amount, make sure you do this:

*

*      amount = amount.add(subAmount);

*

* and not this,

*

*      amount.add(subAmount);

*

* Use .setScale(scale, roundingMode) after every computation to scale and

* round off the decimals. Check the code to see how the scale and

* roundingMode are obtained and how the function is used.

*

* use .compareTo() to compare big decimals

*

*      ex.  (amountOne.compareTo(amountTwo) == 1)

*           checks if amountOne is greater than amountTwo

*

* Use .signum() to test if value is negative, zero, or positive

*

*      ex.  (amountOne.signum() == 1)

*           checks if the amount is a positive non-zero number

*

* Never use the .equals() function becaues it considers 2.0 not equal to 2.00 (the scale is different)

* Instead, use .compareTo() or .signum(), which handles scale correctly.

*

* For reference, check the official Sun Javadoc on java.math.BigDecimal.

*/

    public static String module = InvoiceServices.class.getName();

    // set some BigDecimal properties

    private static final BigDecimal ZERO = BigDecimal.ZERO;

    private static final int DECIMALS = UtilNumber.getBigDecimalScale("invoice.decimals");

    private static final int ROUNDING = UtilNumber.getBigDecimalRoundingMode("invoice.rounding");

    private static final int TAX_DECIMALS = UtilNumber.getBigDecimalScale("salestax.calc.decimals");

    private static final int TAX_ROUNDING = UtilNumber.getBigDecimalRoundingMode("salestax.rounding");

    public static final int TAX_CALC_SCALE = UtilNumber.getBigDecimalScale("salestax.calc.decimals");

    private static final int INVOICE_ITEM_SEQUENCE_ID_DIGITS = 5; // this is the number of digits used for invoiceItemSeqId: 00001, 00002...

    public static final String resource = "AccountingUiLabels";

    // service to create an invoice for a complete order by the system userid

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

        Delegator delegator = dctx.getDelegator();

        LocalDispatcher dispatcher = dctx.getDispatcher();

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

        try {

            List<GenericValue> orderItems = delegator.findByAnd("OrderItem", UtilMisc.toMap("orderId", (String) context.get("orderId")), UtilMisc.toList("orderItemSeqId"));

            if (orderItems.size() > 0) {

                context.put("billItems", orderItems);

            }

            // get the system userid and store in context otherwise the invoice add service does not work

            GenericValue userLogin = delegator.findByPrimaryKey("UserLogin", UtilMisc.toMap("userLoginId", "system"));

            if (userLogin != null) {

                context.put("userLogin", userLogin);

            }

            Map<String, Object> result = dispatcher.runSync("createInvoiceForOrder", context);

            result.remove("invoiceTypeId");  //remove extra parameter

            return result;

        }

        catch (GenericServiceException e) {

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

            return ServiceUtil.returnError(UtilProperties.getMessage(resource,

                    "AccountingEntityDataProblemCreatingInvoiceFromOrderItems",

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

        } catch (GenericEntityException e) {

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

            return ServiceUtil.returnError(UtilProperties.getMessage(resource,

                    "AccountingEntityDataProblemCreatingInvoiceFromOrderItems",

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

        }

    }

    /* Service to create an invoice for an order */

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

        Delegator delegator = dctx.getDelegator();

        LocalDispatcher dispatcher = dctx.getDispatcher();

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

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

        if (DECIMALS == -1 || ROUNDING == -1) {

            return ServiceUtil.returnError(UtilProperties.getMessage(resource,

                    "AccountingAritmeticPropertiesNotConfigured", locale));

        }

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

        List<GenericValue> billItems = UtilGenerics.checkList(context.get("billItems"));

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

        if (UtilValidate.isEmpty(billItems)) {

            Debug.logVerbose("No order items to invoice; not creating invoice; returning success", module);

            return ServiceUtil.returnSuccess(UtilProperties.getMessage(resource,

                    "AccountingNoOrderItemsToInvoice", locale));

        }

        try {

            GenericValue orderHeader = delegator.findByPrimaryKey("OrderHeader", UtilMisc.toMap("orderId", orderId));

            if (orderHeader == null) {

                return ServiceUtil.returnError(UtilProperties.getMessage(resource,

                        "AccountingNoOrderHeader", locale));

            }

            // figure out the invoice type

            String invoiceType = null;

            String orderType = orderHeader.getString("orderTypeId");

            if (orderType.equals("SALES_ORDER")) {

                invoiceType = "SALES_INVOICE";

            } else if (orderType.equals("PURCHASE_ORDER")) {

                invoiceType = "PURCHASE_INVOICE";

            }

            // Set the precision depending on the type of invoice

            int invoiceTypeDecimals = UtilNumber.getBigDecimalScale("invoice." + invoiceType + ".decimals");

            if (invoiceTypeDecimals == -1) invoiceTypeDecimals = DECIMALS;

            // Make an order read helper from the order

            OrderReadHelper orh = new OrderReadHelper(orderHeader);

            // get the product store

            GenericValue productStore = orh.getProductStore();

            // get the shipping adjustment mode (Y = Pro-Rate; N = First-Invoice)

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

            if (prorateShipping == null) {

                prorateShipping = "Y";

            }

            // get the billing parties

            String billToCustomerPartyId = orh.getBillToParty().getString("partyId");

            String billFromVendorPartyId = orh.getBillFromParty().getString("partyId");

            // get some price totals

            BigDecimal shippableAmount = orh.getShippableTotal(null);

            BigDecimal orderSubTotal = orh.getOrderItemsSubTotal();

            // these variables are for pro-rating order amounts across invoices, so they should not be rounded off for maximum accuracy

            BigDecimal invoiceShipProRateAmount = ZERO;

            BigDecimal invoiceSubTotal = ZERO;

            BigDecimal invoiceQuantity = ZERO;

            GenericValue billingAccount = orderHeader.getRelatedOne("BillingAccount");

            String billingAccountId = billingAccount != null ? billingAccount.getString("billingAccountId") : null;

            Timestamp invoiceDate = (Timestamp)context.get("eventDate");

            if (UtilValidate.isEmpty(invoiceDate)) {

                // TODO: ideally this should be the same time as when a shipment is sent and be passed in as a parameter

                invoiceDate = UtilDateTime.nowTimestamp();

            }

            // TODO: perhaps consider billing account net days term as well?

            Long orderTermNetDays = orh.getOrderTermNetDays();

            Timestamp dueDate = null;

            if (orderTermNetDays != null) {

                dueDate = UtilDateTime.getDayEnd(invoiceDate, orderTermNetDays);

            }

            // create the invoice record

            if (UtilValidate.isEmpty(invoiceId)) {

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

                createInvoiceContext.put("partyId", billToCustomerPartyId);

                createInvoiceContext.put("partyIdFrom", billFromVendorPartyId);

                createInvoiceContext.put("billingAccountId", billingAccountId);

                createInvoiceContext.put("invoiceDate", invoiceDate);

                createInvoiceContext.put("dueDate", dueDate);

                createInvoiceContext.put("invoiceTypeId", invoiceType);

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

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

                createInvoiceContext.put("currencyUomId", orderHeader.getString("currencyUom"));

                createInvoiceContext.put("userLogin", userLogin);

                // store the invoice first

                Map<String, Object> createInvoiceResult = dispatcher.runSync("createInvoice", createInvoiceContext);

                if (ServiceUtil.isError(createInvoiceResult)) {

                    return ServiceUtil.returnError(UtilProperties.getMessage(resource,

                            "AccountingErrorCreatingInvoiceFromOrder", locale), null, null, createInvoiceResult);

                }

                // call service, not direct entity op: delegator.create(invoice);

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

            }

            // order roles to invoice roles

            List<GenericValue> orderRoles = orderHeader.getRelated("OrderRole");

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

            createInvoiceRoleContext.put("invoiceId", invoiceId);

            createInvoiceRoleContext.put("userLogin", userLogin);

            for (GenericValue orderRole : orderRoles) {

                createInvoiceRoleContext.put("partyId", orderRole.getString("partyId"));

                createInvoiceRoleContext.put("roleTypeId", orderRole.getString("roleTypeId"));

                Map<String, Object> createInvoiceRoleResult = dispatcher.runSync("createInvoiceRole", createInvoiceRoleContext);

                if (ServiceUtil.isError(createInvoiceRoleResult)) {

                    return ServiceUtil.returnError(UtilProperties.getMessage(resource,

                            "AccountingErrorCreatingInvoiceFromOrder", locale), null, null, createInvoiceRoleResult);

                }

            }

            // order terms to invoice terms.

            // TODO: it might be nice to filter OrderTerms to only copy over financial terms.

            List<GenericValue> orderTerms = orh.getOrderTerms();

            createInvoiceTerms(delegator, dispatcher, invoiceId, orderTerms, userLogin, locale);

            // billing accounts

            // List billingAccountTerms = null;

            // for billing accounts we will use related information

            if (billingAccount != null) {

                /*

                 * jacopoc: billing account terms were already copied as order terms

                 *          when the order was created.

                // get the billing account terms

                billingAccountTerms = billingAccount.getRelated("BillingAccountTerm");

                // set the invoice terms as defined for the billing account

                createInvoiceTerms(delegator, dispatcher, invoiceId, billingAccountTerms, userLogin, locale);

                */

                // set the invoice bill_to_customer from the billing account

                List<GenericValue> billToRoles = billingAccount.getRelated("BillingAccountRole", UtilMisc.toMap("roleTypeId", "BILL_TO_CUSTOMER"), null);

                for (GenericValue billToRole : billToRoles) {

                    if (!(billToRole.getString("partyId").equals(billToCustomerPartyId))) {

                        createInvoiceRoleContext = UtilMisc.toMap("invoiceId", invoiceId, "partyId", billToRole.get("partyId"),

                                                                           "roleTypeId", "BILL_TO_CUSTOMER", "userLogin", userLogin);

                        Map<String, Object> createInvoiceRoleResult = dispatcher.runSync("createInvoiceRole", createInvoiceRoleContext);

                        if (ServiceUtil.isError(createInvoiceRoleResult)) {

                            return ServiceUtil.returnError(UtilProperties.getMessage(resource,

                                    "AccountingErrorCreatingInvoiceRoleFromOrder", locale), null, null, createInvoiceRoleResult);

                        }

                    }

                }

                // set the bill-to contact mech as the contact mech of the billing account

                if (UtilValidate.isNotEmpty(billingAccount.getString("contactMechId"))) {

                    Map<String, Object> createBillToContactMechContext = UtilMisc.toMap("invoiceId", invoiceId, "contactMechId", billingAccount.getString("contactMechId"),

                                                                       "contactMechPurposeTypeId", "BILLING_LOCATION", "userLogin", userLogin);

                    Map<String, Object> createBillToContactMechResult = dispatcher.runSync("createInvoiceContactMech", createBillToContactMechContext);

                    if (ServiceUtil.isError(createBillToContactMechResult)) {

                        return ServiceUtil.returnError(UtilProperties.getMessage(resource,

                                "AccountingErrorCreatingInvoiceContactMechFromOrder", locale), null, null, createBillToContactMechResult);

                    }

                }

            } else {

                List<GenericValue> billingLocations = orh.getBillingLocations();

                if (UtilValidate.isNotEmpty(billingLocations)) {

                    for (GenericValue ocm : billingLocations) {

                        Map<String, Object> createBillToContactMechContext = UtilMisc.toMap("invoiceId", invoiceId, "contactMechId", ocm.getString("contactMechId"),

                                                                           "contactMechPurposeTypeId", "BILLING_LOCATION", "userLogin", userLogin);

                        Map<String, Object> createBillToContactMechResult = dispatcher.runSync("createInvoiceContactMech", createBillToContactMechContext);

                        if (ServiceUtil.isError(createBillToContactMechResult)) {

                            return ServiceUtil.returnError(UtilProperties.getMessage(resource,

                                    "AccountingErrorCreatingInvoiceContactMechFromOrder", locale), null, null, createBillToContactMechResult);

                        }

                    }

                } else {

                    Debug.logWarning("No billing locations found for order [" + orderId +"] and none were created for Invoice [" + invoiceId + "]", module);

                }

            }

            // get a list of the payment method types

            //DEJ20050705 doesn't appear to be used: List paymentPreferences = orderHeader.getRelated("OrderPaymentPreference");

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

            GenericValue payToAddress = null;

            if (invoiceType.equals("PURCHASE_INVOICE")) {

                // for purchase orders, the pay to address is the BILLING_LOCATION of the vendor

                GenericValue billFromVendor = orh.getPartyFromRole("BILL_FROM_VENDOR");

                if (billFromVendor != null) {

                    List<GenericValue> billingContactMechs = billFromVendor.getRelatedOne("Party").getRelatedByAnd("PartyContactMechPurpose",

                            UtilMisc.toMap("contactMechPurposeTypeId", "BILLING_LOCATION"));

                    if (UtilValidate.isNotEmpty(billingContactMechs)) {

                        payToAddress = EntityUtil.getFirst(billingContactMechs);

                    }

                }