/*******************************************************************************
* 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.
*******************************************************************************/
package org.apache.ofbiz.accounting.invoice;
import java.io.BufferedReader;
import java.io.IOException;
import java.io.StringReader;
import java.math.BigDecimal;
import java.nio.ByteBuffer;
import java.nio.charset.Charset;
import java.sql.Timestamp;
import java.util.ArrayList;
import java.util.HashMap;
import java.util.Iterator;
import java.util.LinkedList;
import java.util.List;
import java.util.Locale;
import java.util.Map;
import java.util.Set;
import org.apache.commons.collections4.CollectionUtils;
import org.apache.commons.csv.CSVFormat;
import org.apache.commons.csv.CSVRecord;
import org.apache.ofbiz.accounting.payment.PaymentGatewayServices;
import org.apache.ofbiz.accounting.payment.PaymentWorker;
import org.apache.ofbiz.accounting.util.UtilAccounting;
import org.apache.ofbiz.base.util.Debug;
import org.apache.ofbiz.base.util.UtilDateTime;
import org.apache.ofbiz.base.util.UtilFormatOut;
import org.apache.ofbiz.base.util.UtilGenerics;
import org.apache.ofbiz.base.util.UtilMisc;
import org.apache.ofbiz.base.util.UtilNumber;
import org.apache.ofbiz.base.util.UtilProperties;
import org.apache.ofbiz.base.util.UtilValidate;
import org.apache.ofbiz.entity.Delegator;
import org.apache.ofbiz.entity.GenericEntityException;
import org.apache.ofbiz.entity.GenericValue;
import org.apache.ofbiz.entity.condition.EntityCondition;
import org.apache.ofbiz.entity.condition.EntityExpr;
import org.apache.ofbiz.entity.condition.EntityOperator;
import org.apache.ofbiz.entity.util.EntityQuery;
import org.apache.ofbiz.entity.util.EntityTypeUtil;
import org.apache.ofbiz.entity.util.EntityUtil;
import org.apache.ofbiz.entity.util.EntityUtilProperties;
import org.apache.ofbiz.order.order.OrderReadHelper;
import org.apache.ofbiz.product.product.ProductWorker;
import org.apache.ofbiz.service.DispatchContext;
import org.apache.ofbiz.service.GenericServiceException;
import org.apache.ofbiz.service.LocalDispatcher;
import org.apache.ofbiz.service.ServiceUtil;
/**
* 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 class InvoiceServices {
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");
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 = EntityQuery.use(delegator).from("OrderItem")
.where("orderId", context.get("orderId")).orderBy("orderItemSeqId").queryList();
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 = EntityQuery.use(delegator).from("UserLogin").where("userLoginId", "system").queryOne();
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 = EntityQuery.use(delegator).from("OrderHeader").where("orderId", orderId).queryOne();
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 shippableQuantity = orh.getShippableQuantity(null);
BigDecimal orderSubTotal = orh.getOrderItemsSubTotal();
BigDecimal orderQuantity = orh.getTotalOrderItemsQuantity();
// these variables are for pro-rating order amounts across invoices, so they should not be rounded off for maximum accuracy
BigDecimal invoiceShipProRateAmount = ZERO;
BigDecimal invoiceShippableQuantity = ZERO;
BigDecimal invoiceSubTotal = ZERO;
BigDecimal invoiceQuantity = ZERO;
GenericValue billingAccount = orderHeader.getRelatedOne("BillingAccount", false);
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 = new HashMap<String, Object>();
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", null, null, false);
Map<String, Object> createInvoiceRoleContext = new HashMap<String, Object>();
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", null, null, false);
// 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, false);
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", null, null, false);
// 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", false).getRelated("PartyContactMechPurpose", UtilMisc.toMap("contactMechPurposeTypeId", "BILLING_LOCATION"), null, false);
if (UtilValidate.isNotEmpty(billingContactMechs)) {
payToAddress = EntityUtil.getFirst(billingContactMechs);
}
}
} else {
// for sales orders, it is the payment address on file for the store
payToAddress = PaymentWorker.getPaymentAddress(delegator, productStore.getString("payToPartyId"));
}
if (payToAddress != null) {
Map<String, Object> createPayToContactMechContext = UtilMisc.toMap("invoiceId", invoiceId, "contactMechId", payToAddress.getString("contactMechId"),
"contactMechPurposeTypeId", "PAYMENT_LOCATION", "userLogin", userLogin);
Map<String, Object> createPayToContactMechResult = dispatcher.runSync("createInvoiceContactMech", createPayToContactMechContext);
if (ServiceUtil.isError(createPayToContactMechResult)) {
return ServiceUtil.returnError(UtilProperties.getMessage(resource,
"AccountingErrorCreatingInvoiceContactMechFromOrder", locale), null, null, createPayToContactMechResult);
}
}
// sequence for items - all OrderItems or InventoryReservations + all Adjustments
int invoiceItemSeqNum = 1;
String invoiceItemSeqId = UtilFormatOut.formatPaddedNumber(invoiceItemSeqNum, INVOICE_ITEM_SEQUENCE_ID_DIGITS);
// create the item records
for (GenericValue currentValue : billItems) {
GenericValue itemIssuance = null;
GenericValue orderItem = null;
GenericValue shipmentReceipt = null;
if ("ItemIssuance".equals(currentValue.getEntityName())) {
itemIssuance = currentValue;
} else if ("OrderItem".equals(currentValue.getEntityName())) {
orderItem = currentValue;
} else if ("ShipmentReceipt".equals(currentValue.getEntityName())) {
shipmentReceipt = currentValue;
} else {
Debug.logError("Unexpected entity " + currentValue + " of type " + currentValue.getEntityName(), module);
}
if (orderItem == null && itemIssuance != null) {
orderItem = itemIssuance.getRelatedOne("OrderItem", false);
} else if ((orderItem == null) && (shipmentReceipt != null)) {
orderItem = shipmentReceipt.getRelatedOne("OrderItem", false);
} else if ((orderItem == null) && (itemIssuance == null) && (shipmentReceipt == null)) {
Debug.logError("Cannot create invoice when orderItem, itemIssuance, and shipmentReceipt are all null", module);
return ServiceUtil.returnError(UtilProperties.getMessage(resource,
"AccountingIllegalValuesPassedToCreateInvoiceService", locale));
}
GenericValue product = null;
if (orderItem.get("productId") != null) {
product = orderItem.getRelatedOne("Product", false);
}
// get some quantities
BigDecimal billingQuantity = null;
if (itemIssuance != null) {
billingQuantity = itemIssuance.getBigDecimal("quantity");
BigDecimal cancelQty = itemIssuance.getBigDecimal("cancelQuantity");
if (cancelQty == null) {
cancelQty = ZERO;
}
billingQuantity = billingQuantity.subtract(cancelQty).setScale(DECIMALS, ROUNDING);
} else if (shipmentReceipt != null) {
billingQuantity = shipmentReceipt.getBigDecimal("quantityAccepted");
} else {
BigDecimal orderedQuantity = OrderReadHelper.getOrderItemQuantity(orderItem);
BigDecimal invoicedQuantity = OrderReadHelper.getOrderItemInvoicedQuantity(orderItem);
billingQuantity = orderedQuantity.subtract(invoicedQuantity);
if (billingQuantity.compareTo(ZERO) < 0) {
billingQuantity = ZERO;
}
}
if (billingQuantity == null) billingQuantity = ZERO;
// check if shipping applies to this item. Shipping is calculated for sales invoices, not purchase invoices.
boolean shippingApplies = false;
if ((product != null) && (ProductWorker.shippingApplies(product)) && (invoiceType.equals("SALES_INVOICE"))) {
shippingApplies = true;
}
BigDecimal billingAmount = BigDecimal.ZERO;
GenericValue OrderAdjustment = EntityUtil.getFirst(orderItem.getRelated("OrderAdjustment", UtilMisc.toMap("orderAdjustmentTypeId", "VAT_TAX"), null, false));
/* Apply formula to get actual product price to set amount in invoice item
Formula is: productPrice = (productPriceWithTax.multiply(100)) / (orderAdj sourcePercentage + 100))
product price = (43*100) / (20+100) = 35.83 (Here product price is 43 with VAT)
*/
if (UtilValidate.isNotEmpty(OrderAdjustment) && (OrderAdjustment.getBigDecimal("amount").signum() == 0) && UtilValidate.isNotEmpty(OrderAdjustment.getBigDecimal("amountAlreadyIncluded")) && OrderAdjustment.getBigDecimal("amountAlreadyIncluded").signum() != 0) {
BigDecimal sourcePercentageTotal = OrderAdjustment.getBigDecimal("sourcePercentage").add(new BigDecimal(100));
billingAmount = orderItem.getBigDecimal("unitPrice").divide(sourcePercentageTotal, 100, ROUNDING).multiply(new BigDecimal(100)).setScale(invoiceTypeDecimals, ROUNDING);
} else {
billingAmount = orderItem.getBigDecimal("unitPrice").setScale(invoiceTypeDecimals, ROUNDING);
}
Map<String, Object> createInvoiceItemContext = new HashMap<String, Object>();
createInvoiceItemContext.put("invoiceId", invoiceId);
createInvoiceItemContext.put("invoiceItemSeqId", invoiceItemSeqId);
createInvoiceItemContext.put("invoiceItemTypeId", getInvoiceItemType(delegator, (orderItem.getString("orderItemTypeId")), (product == null ? null : product.getString("productTypeId")), invoiceType, "INV_FPROD_ITEM"));
createInvoiceItemContext.put("description", orderItem.get("itemDescription"));
createInvoiceItemContext.put("quantity", billingQuantity);
createInvoiceItemContext.put("amount", billingAmount);
createInvoiceItemContext.put("productId", orderItem.get("productId"));
createInvoiceItemContext.put("productFeatureId", orderItem.get("productFeatureId"));
createInvoiceItemContext.put("overrideGlAccountId", orderItem.get("overrideGlAccountId"));
createInvoiceItemContext.put("userLogin", userLogin);
String itemIssuanceId = null;
if (itemIssuance != null && itemIssuance.get("inventoryItemId") != null) {
itemIssuanceId = itemIssuance.getString("itemIssuanceId");
createInvoiceItemContext.put("inventoryItemId", itemIssuance.get("inventoryItemId"));
}
// similarly, tax only for purchase invoices
if ((product != null) && (invoiceType.equals("SALES_INVOICE"))) {
createInvoiceItemContext.put("taxableFlag", product.get("taxable"));
}
Map<String, Object> createInvoiceItemResult = dispatcher.runSync("createInvoiceItem", createInvoiceItemContext);
if (ServiceUtil.isError(createInvoiceItemResult)) {
return ServiceUtil.returnError(UtilProperties.getMessage(resource,
"AccountingErrorCreatingInvoiceItemFromOrder", locale), null, null, createInvoiceItemResult);
}
// this item total
BigDecimal thisAmount = billingAmount.multiply(billingQuantity).setScale(invoiceTypeDecimals, ROUNDING);
// add to the ship amount only if it applies to this item
if (shippingApplies) {
invoiceShipProRateAmount = invoiceShipProRateAmount.add(thisAmount).setScale(invoiceTypeDecimals, ROUNDING);
invoiceShippableQuantity = invoiceQuantity.add(billingQuantity).setScale(invoiceTypeDecimals, ROUNDING);
}
// increment the invoice subtotal
invoiceSubTotal = invoiceSubTotal.add(thisAmount).setScale(100, ROUNDING);
// increment the invoice quantity
invoiceQuantity = invoiceQuantity.add(billingQuantity).setScale(invoiceTypeDecimals, ROUNDING);
// create the OrderItemBilling record
Map<String, Object> createOrderItemBillingContext = new HashMap<String, Object>();
createOrderItemBillingContext.put("invoiceId", invoiceId);
createOrderItemBillingContext.put("invoiceItemSeqId", invoiceItemSeqId);
createOrderItemBillingContext.put("orderId", orderItem.get("orderId"));
createOrderItemBillingContext.put("orderItemSeqId", orderItem.get("orderItemSeqId"));
createOrderItemBillingContext.put("itemIssuanceId", itemIssuanceId);
createOrderItemBillingContext.put("quantity", billingQuantity);
createOrderItemBillingContext.put("amount", billingAmount);
createOrderItemBillingContext.put("userLogin", userLogin);
if ((shipmentReceipt != null) && (shipmentReceipt.getString("receiptId") != null)) {
createOrderItemBillingContext.put("shipmentReceiptId", shipmentReceipt.getString("receiptId"));
}
Map<String, Object> createOrderItemBillingResult = dispatcher.runSync("createOrderItemBilling", createOrderItemBillingContext);
if (ServiceUtil.isError(createOrderItemBillingResult)) {
return ServiceUtil.returnError(UtilProperties.getMessage(resource,
"AccountingErrorCreatingOrderItemBillingFromOrder", locale), null, null, createOrderItemBillingResult);
}
if ("ItemIssuance".equals(currentValue.getEntityName())) {
/* Find ShipmentItemBilling based on shipmentId, shipmentItemSeqId, invoiceId, invoiceItemSeqId as
because if any order item has multiple quantity and reserved by multiple inventories then there will be multiple invoice items.
In that case ShipmentItemBilling was creating only for one invoice item. Fixed under OFBIZ-6806.
*/
List<GenericValue> shipmentItemBillings = EntityQuery.use(delegator).from("ShipmentItemBilling")
.where("shipmentId", currentValue.get("shipmentId"), "shipmentItemSeqId", currentValue.get("shipmentItemSeqId"), "invoiceId", invoiceId, "invoiceItemSeqId", invoiceItemSeqId)
.queryList();
if (UtilValidate.isEmpty(shipmentItemBillings)) {
// create the ShipmentItemBilling record
GenericValue shipmentItemBilling = delegator.makeValue("ShipmentItemBilling", UtilMisc.toMap("invoiceId", invoiceId, "invoiceItemSeqId", invoiceItemSeqId));
shipmentItemBilling.put("shipmentId", currentValue.get("shipmentId"));
shipmentItemBilling.put("shipmentItemSeqId", currentValue.get("shipmentItemSeqId"));
shipmentItemBilling.create();
}
}
String parentInvoiceItemSeqId = invoiceItemSeqId;
// increment the counter
invoiceItemSeqNum++;
invoiceItemSeqId = UtilFormatOut.formatPaddedNumber(invoiceItemSeqNum, INVOICE_ITEM_SEQUENCE_ID_DIGITS);
// Get the original order item from the DB, in case the quantity has been overridden
GenericValue originalOrderItem = EntityQuery.use(delegator).from("OrderItem").where("orderId", orderId, "orderItemSeqId", orderItem.get("orderItemSeqId")).queryOne();
// create the item adjustment as line items
List<GenericValue> itemAdjustments = OrderReadHelper.getOrderItemAdjustmentList(orderItem, orh.getAdjustments());
for (GenericValue adj : itemAdjustments) {
// Check against OrderAdjustmentBilling to see how much of this adjustment has already been invoiced
BigDecimal adjAlreadyInvoicedAmount = null;
try {
Map<String, Object> checkResult = dispatcher.runSync("calculateInvoicedAdjustmentTotal", UtilMisc.toMap("orderAdjustment", adj));
adjAlreadyInvoicedAmount = (BigDecimal) checkResult.get("invoicedTotal");
} catch (GenericServiceException e) {
Debug.logError(e, "Accounting trouble calling calculateInvoicedAdjustmentTotal service", module);
return ServiceUtil.returnError(UtilProperties.getMessage(resource,
"AccountingTroubleCallingCalculateInvoicedAdjustmentTotalService", locale));
}
// if (adj.get("amount") == null) { TODO check usage with webPos. Was: fix a bug coming from POS in case of use of a discount (on item(s) or sale, item(s) here) and a cash amount higher than total (hence issuing change)
// continue;
// }
// Set adjustment amount as amountAlreadyIncluded to continue invoice item creation process
Boolean isTaxIncludedInPrice = adj.getString("orderAdjustmentTypeId").equals("VAT_TAX") && UtilValidate.isNotEmpty(adj.getBigDecimal("amountAlreadyIncluded")) && adj.getBigDecimal("amountAlreadyIncluded").signum() != 0;
if ((adj.getBigDecimal("amount").signum() == 0) && isTaxIncludedInPrice) {
adj.set("amount", adj.getBigDecimal("amountAlreadyIncluded"));
}
// If the absolute invoiced amount >= the abs of the adjustment amount, the full amount has already been invoiced, so skip this adjustment
if (adjAlreadyInvoicedAmount.abs().compareTo(adj.getBigDecimal("amount").setScale(invoiceTypeDecimals, ROUNDING).abs()) > 0) {
continue;
}
BigDecimal originalOrderItemQuantity = OrderReadHelper.getOrderItemQuantity(originalOrderItem);
BigDecimal amount = ZERO;
if (originalOrderItemQuantity.signum() != 0) {
if (adj.get("amount") != null) {
if("PROMOTION_ADJUSTMENT".equals(adj.getString("orderAdjustmentTypeId")) && adj.get("productPromoId") != null) {
/* Find negative amountAlreadyIncluded in OrderAdjustment to subtract it from discounted amount.
As we stored negative sales tax amount in order adjustment for discounted item.
*/
List<EntityExpr> exprs = UtilMisc.toList(EntityCondition.makeCondition("orderId", EntityOperator.EQUALS, orderItem.getString("orderId")),
EntityCondition.makeCondition("orderItemSeqId", EntityOperator.EQUALS, orderItem.getString("orderItemSeqId")),
EntityCondition.makeCondition("orderAdjustmentTypeId", EntityOperator.EQUALS, "VAT_TAX"),
EntityCondition.makeCondition("amountAlreadyIncluded", EntityOperator.LESS_THAN, BigDecimal.ZERO));
EntityCondition andCondition = EntityCondition.makeCondition(exprs, EntityOperator.AND);
GenericValue orderAdjustment = EntityUtil.getFirst(delegator.findList("OrderAdjustment", andCondition, null, null, null, false));
if (UtilValidate.isNotEmpty(orderAdjustment)) {
amount = adj.getBigDecimal("amount").subtract(orderAdjustment.getBigDecimal("amountAlreadyIncluded")).setScale(100, ROUNDING);
} else {
amount = adj.getBigDecimal("amount");
}
} else {
// pro-rate the amount
// set decimals = 100 means we don't round this intermediate value, which is very important
if (isTaxIncludedInPrice) {
BigDecimal priceWithTax = originalOrderItem.getBigDecimal("unitPrice");
// Get tax included in item price
amount = priceWithTax.subtract(billingAmount);
amount = amount.multiply(billingQuantity);
// get adjustment amount
/* Get tax amount of other invoice and calculate remaining amount need to store in invoice item(Handle case of of partial shipment and promotional item)
to adjust tax amount in invoice item.
*/
BigDecimal otherInvoiceTaxAmount = BigDecimal.ZERO;
GenericValue orderAdjBilling = EntityUtil.getFirst(delegator.findByAnd("OrderAdjustmentBilling", UtilMisc.toMap("orderAdjustmentId", adj.getString("orderAdjustmentId")), null, false));
if (UtilValidate.isNotEmpty(orderAdjBilling)) {
List<GenericValue> invoiceItems = delegator.findByAnd("InvoiceItem",
UtilMisc.toMap("invoiceId", orderAdjBilling.getString("invoiceId"), "invoiceItemTypeId", "ITM_SALES_TAX", "productId", originalOrderItem.getString("productId")), null, isTaxIncludedInPrice);
for (GenericValue invoiceItem : invoiceItems) {
otherInvoiceTaxAmount = otherInvoiceTaxAmount.add(invoiceItem.getBigDecimal("amount"));
}
if (otherInvoiceTaxAmount.compareTo(BigDecimal.ZERO) > 0) {
BigDecimal remainingAmount = adj.getBigDecimal("amountAlreadyIncluded").subtract(otherInvoiceTaxAmount);
amount = amount.min(remainingAmount);
}
}
amount = amount.min(adj.getBigDecimal("amountAlreadyIncluded")).setScale(100, ROUNDING);
} else {
amount = adj.getBigDecimal("amount").divide(originalOrderItemQuantity, 100, ROUNDING);
amount = amount.multiply(billingQuantity);
}
}
// Tax needs to be rounded differently from other order adjustments
if (adj.getString("orderAdjustmentTypeId").equals("SALES_TAX")) {
amount = amount.setScale(TAX_DECIMALS, TAX_ROUNDING);
} else {
amount = amount.setScale(invoiceTypeDecimals, ROUNDING);
}
} else if (adj.get("sourcePercentage") != null) {
// pro-rate the amount
// set decimals = 100 means we don't round this intermediate value, which is very important
BigDecimal percent = adj.getBigDecimal("sourcePercentage");
percent = percent.divide(new BigDecimal(100), 100, ROUNDING);
amount = billingAmount.multiply(percent);
amount = amount.divide(originalOrderItemQuantity, 100, ROUNDING);
amount = amount.multiply(billingQuantity);
amount = amount.setScale(invoiceTypeDecimals, ROUNDING);
}
}
if (amount.signum() != 0) {
Map<String, Object> createInvoiceItemAdjContext = new HashMap<String, Object>();
createInvoiceItemAdjContext.put("invoiceId", invoiceId);
createInvoiceItemAdjContext.put("invoiceItemSeqId", invoiceItemSeqId);
createInvoiceItemAdjContext.put("invoiceItemTypeId", getInvoiceItemType(delegator, adj.getString("orderAdjustmentTypeId"), null, invoiceType, "INVOICE_ITM_ADJ"));
createInvoiceItemAdjContext.put("quantity", BigDecimal.ONE);
createInvoiceItemAdjContext.put("amount", amount);
createInvoiceItemAdjContext.put("productId", orderItem.get("productId"));
createInvoiceItemAdjContext.put("productFeatureId", orderItem.get("productFeatureId"));
createInvoiceItemAdjContext.put("overrideGlAccountId", adj.get("overrideGlAccountId"));
createInvoiceItemAdjContext.put("parentInvoiceId", invoiceId);
createInvoiceItemAdjContext.put("parentInvoiceItemSeqId", parentInvoiceItemSeqId);
createInvoiceItemAdjContext.put("userLogin", userLogin);
createInvoiceItemAdjContext.put("taxAuthPartyId", adj.get("taxAuthPartyId"));
createInvoiceItemAdjContext.put("taxAuthGeoId", adj.get("taxAuthGeoId"));
createInvoiceItemAdjContext.put("taxAuthorityRateSeqId", adj.get("taxAuthorityRateSeqId"));
// some adjustments fill out the comments field instead
String description = (UtilValidate.isEmpty(adj.getString("description")) ? adj.getString("comments") : adj.getString("description"));
createInvoiceItemAdjContext.put("description", description);
// invoice items for sales tax are not taxable themselves
// TODO: This is not an ideal solution. Instead, we need to use OrderAdjustment.includeInTax when it is implemented
if (!(adj.getString("orderAdjustmentTypeId").equals("SALES_TAX"))) {
createInvoiceItemAdjContext.put("taxableFlag", product.get("taxable"));
}
// If the OrderAdjustment is associated to a ProductPromo,
// and the field ProductPromo.overrideOrgPartyId is set,
// copy the value to InvoiceItem.overrideOrgPartyId: this
// represent an organization override for the payToPartyId
if (UtilValidate.isNotEmpty(adj.getString("productPromoId"))) {
try {
GenericValue productPromo = adj.getRelatedOne("ProductPromo", false);
if (UtilValidate.isNotEmpty(productPromo.getString("overrideOrgPartyId"))) {
createInvoiceItemAdjContext.put("overrideOrgPartyId", productPromo.getString("overrideOrgPartyId"));
}
} catch (GenericEntityException e) {
Debug.logError(e, "Error looking up ProductPromo with id [" + adj.getString("productPromoId") + "]", module);
}
}
Map<String, Object> createInvoiceItemAdjResult = dispatcher.runSync("createInvoiceItem", createInvoiceItemAdjContext);
if (ServiceUtil.isError(createInvoiceItemAdjResult)) {
return ServiceUtil.returnError(UtilProperties.getMessage(resource,
"AccountingErrorCreatingInvoiceItemFromOrder", locale), null, null, createInvoiceItemAdjResult);
}
// Create the OrderAdjustmentBilling record
Map<String, Object> createOrderAdjustmentBillingContext = new HashMap<String, Object>();
createOrderAdjustmentBillingContext.put("orderAdjustmentId", adj.getString("orderAdjustmentId"));
createOrderAdjustmentBillingContext.put("invoiceId", invoiceId);
createOrderAdjustmentBillingContext.put("invoiceItemSeqId", invoiceItemSeqId);
createOrderAdjustmentBillingContext.put("amount", amount);
createOrderAdjustmentBillingContext.put("userLogin", userLogin);
Map<String, Object> createOrderAdjustmentBillingResult = dispatcher.runSync("createOrderAdjustmentBilling", createOrderAdjustmentBillingContext);
if (ServiceUtil.isError(createOrderAdjustmentBillingResult)) {
return ServiceUtil.returnError(UtilProperties.getMessage(resource,
"AccountingErrorCreatingOrderAdjustmentBillingFromOrder", locale), null, null, createOrderAdjustmentBillingContext);
}
// this adjustment amount
BigDecimal thisAdjAmount = amount;
// adjustments only apply to totals when they are not tax or shipping adjustments
if (!"SALES_TAX".equals(adj.getString("orderAdjustmentTypeId")) &&
!"SHIPPING_ADJUSTMENT".equals(adj.getString("orderAdjustmentTypeId"))) {
// increment the invoice subtotal
invoiceSubTotal = invoiceSubTotal.add(thisAdjAmount).setScale(100, ROUNDING);
// add to the ship amount only if it applies to this item
if (shippingApplies) {
invoiceShipProRateAmount = invoiceShipProRateAmount.add(thisAdjAmount).setScale(invoiceTypeDecimals, ROUNDING);
}
}
// increment the counter
invoiceItemSeqNum++;
invoiceItemSeqId = UtilFormatOut.formatPaddedNumber(invoiceItemSeqNum, INVOICE_ITEM_SEQUENCE_ID_DIGITS);
}
}
}
// create header adjustments as line items -- always to tax/shipping last
Map<GenericValue, BigDecimal> shipAdjustments = new HashMap<GenericValue, BigDecimal>();
Map<GenericValue, BigDecimal> taxAdjustments = new HashMap<GenericValue, BigDecimal>();
List<GenericValue> headerAdjustments = orh.getOrderHeaderAdjustments();
for (GenericValue adj : headerAdjustments) {
// Check against OrderAdjustmentBilling to see how much of this adjustment has already been invoiced
BigDecimal adjAlreadyInvoicedAmount = null;
try {
Map<String, Object> checkResult = dispatcher.runSync("calculateInvoicedAdjustmentTotal", UtilMisc.toMap("orderAdjustment", adj));
adjAlreadyInvoicedAmount = ((BigDecimal) checkResult.get("invoicedTotal")).setScale(invoiceTypeDecimals, ROUNDING);
} catch (GenericServiceException e) {
Debug.logError(e, "Accounting trouble calling calculateInvoicedAdjustmentTotal service", module);
return ServiceUtil.returnError(UtilProperties.getMessage(resource,
"AccountingTroubleCallingCalculateInvoicedAdjustmentTotalService", locale));
}
// if (null == adj.get("amount")) { TODO check usage with webPos. Was: fix a bug coming from POS in case of use of a discount (on item(s) or sale, sale here) and a cash amount higher than total (hence issuing change)
// continue;
// }
// If the absolute invoiced amount >= the abs of the adjustment amount, the full amount has already been invoiced, so skip this adjustment
if (adjAlreadyInvoicedAmount.abs().compareTo(adj.getBigDecimal("amount").setScale(invoiceTypeDecimals, ROUNDING).abs()) >= 0) {
continue;
}
if ("SHIPPING_CHARGES".equals(adj.getString("orderAdjustmentTypeId"))) {
shipAdjustments.put(adj, adjAlreadyInvoicedAmount);
} else if ("SALES_TAX".equals(adj.getString("orderAdjustmentTypeId"))) {
taxAdjustments.put(adj, adjAlreadyInvoicedAmount);
} else {
// these will effect the shipping pro-rate (unless commented)
// other adjustment type
BigDecimal divisor = orderSubTotal;
BigDecimal multiplier = invoiceSubTotal;
if (BigDecimal.ZERO.compareTo(multiplier) == 0 && BigDecimal.ZERO.compareTo(divisor) == 0) {
// if multiplier and divisor are equal to zero then use the quantities instead of the amounts
// this is useful when the order has free items and misc charges
divisor = orderQuantity;
multiplier = invoiceQuantity;
}
calcHeaderAdj(delegator, adj, invoiceType, invoiceId, invoiceItemSeqId, divisor, multiplier,
adj.getBigDecimal("amount").setScale(invoiceTypeDecimals, ROUNDING), invoiceTypeDecimals, ROUNDING, userLogin, dispatcher, locale);
// invoiceShipProRateAmount += adjAmount;
// do adjustments compound or are they based off subtotal? Here we will (unless commented)
// invoiceSubTotal += adjAmount;
// increment the counter
invoiceItemSeqNum++;
invoiceItemSeqId = UtilFormatOut.formatPaddedNumber(invoiceItemSeqNum, INVOICE_ITEM_SEQUENCE_ID_DIGITS);
}
}
// next do the shipping adjustments. Note that we do not want to add these to the invoiceSubTotal or orderSubTotal for pro-rating tax later, as that would cause
// numerator/denominator problems when the shipping is not pro-rated but rather charged all on the first invoice
for (GenericValue adj : shipAdjustments.keySet()) {
BigDecimal adjAlreadyInvoicedAmount = shipAdjustments.get(adj);
if ("N".equalsIgnoreCase(prorateShipping)) {
// Set the divisor and multiplier to 1 to avoid prorating
BigDecimal divisor = BigDecimal.ONE;
BigDecimal multiplier = BigDecimal.ONE;
// The base amount in this case is the adjustment amount minus the total already invoiced for that adjustment, since
// it won't be prorated
BigDecimal baseAmount = adj.getBigDecimal("amount").setScale(invoiceTypeDecimals, ROUNDING).subtract(adjAlreadyInvoicedAmount);
calcHeaderAdj(delegator, adj, invoiceType, invoiceId, invoiceItemSeqId, divisor, multiplier, baseAmount,
invoiceTypeDecimals, ROUNDING, userLogin, dispatcher, locale);
} else {
// Pro-rate the shipping amount based on shippable information
BigDecimal divisor = shippableAmount;
BigDecimal multiplier = invoiceShipProRateAmount;
if (BigDecimal.ZERO.compareTo(multiplier) == 0 && BigDecimal.ZERO.compareTo(divisor) == 0) {
// if multiplier and divisor are equal to zero then use the quantities instead of the amounts
// this is useful when the order has free items and shipping charges
divisor = shippableQuantity;
multiplier = invoiceShippableQuantity;
}
// The base amount in this case is the adjustment amount, since we want to prorate based on the full amount
BigDecimal baseAmount = adj.getBigDecimal("amount").setScale(invoiceTypeDecimals, ROUNDING);
calcHeaderAdj(delegator, adj, invoiceType, invoiceId, invoiceItemSeqId, divisor, multiplier,
baseAmount, invoiceTypeDecimals, ROUNDING, userLogin, dispatcher, locale);
}
// Increment the counter
invoiceItemSeqNum++;
invoiceItemSeqId = UtilFormatOut.formatPaddedNumber(invoiceItemSeqNum, INVOICE_ITEM_SEQUENCE_ID_DIGITS);
}
// last do the tax adjustments
String prorateTaxes = productStore != null ? productStore.getString("prorateTaxes") : "Y";
if (prorateTaxes == null) {
prorateTaxes = "Y";
}
for (Map.Entry<GenericValue, BigDecimal> entry : taxAdjustments.entrySet()) {
GenericValue adj = entry.getKey();
BigDecimal adjAlreadyInvoicedAmount = entry.getValue();
BigDecimal adjAmount = null;
if ("N".equalsIgnoreCase(prorateTaxes)) {
// Set the divisor and multiplier to 1 to avoid prorating
BigDecimal divisor = BigDecimal.ONE;
BigDecimal multiplier = BigDecimal.ONE;
// The base amount in this case is the adjustment amount minus the total already invoiced for that adjustment, since
// it won't be prorated
BigDecimal baseAmount = adj.getBigDecimal("amount").setScale(TAX_DECIMALS, TAX_ROUNDING).subtract(adjAlreadyInvoicedAmount);
adjAmount = calcHeaderAdj(delegator, adj, invoiceType, invoiceId, invoiceItemSeqId,
divisor, multiplier, baseAmount, TAX_DECIMALS, TAX_ROUNDING, userLogin, dispatcher, locale);
} else {
// Pro-rate the tax amount based on shippable information
BigDecimal divisor = orderSubTotal;
BigDecimal multiplier = invoiceSubTotal;
// The base amount in this case is the adjustment amount, since we want to prorate based on the full amount
BigDecimal baseAmount = adj.getBigDecimal("amount");
adjAmount = calcHeaderAdj(delegator, adj, invoiceType, invoiceId, invoiceItemSeqId,
divisor, multiplier, baseAmount, TAX_DECIMALS, TAX_ROUNDING, userLogin, dispatcher, locale);
}
invoiceSubTotal = invoiceSubTotal.add(adjAmount).setScale(invoiceTypeDecimals, ROUNDING);
// Increment the counter
invoiceItemSeqNum++;
invoiceItemSeqId = UtilFormatOut.formatPaddedNumber(invoiceItemSeqNum, INVOICE_ITEM_SEQUENCE_ID_DIGITS);
}
// check for previous order payments
List<GenericValue> orderPaymentPrefs = EntityQuery.use(delegator).from("OrderPaymentPreference")
.where(EntityCondition.makeCondition("orderId", EntityOperator.EQUALS, orderId),
EntityCondition.makeCondition("statusId", EntityOperator.NOT_EQUAL, "PAYMENT_CANCELLED")
).queryList();
List<GenericValue> currentPayments = new LinkedList<GenericValue>();
for (GenericValue paymentPref : orderPaymentPrefs) {
List<GenericValue> payments = paymentPref.getRelated("Payment", null, null, false);
currentPayments.addAll(payments);
}
// apply these payments to the invoice if they have any remaining amount to apply
for (GenericValue payment : currentPayments) {
if ("PMNT_VOID".equals(payment.getString("statusId")) || "PMNT_CANCELLED".equals(payment.getString("statusId"))) {
continue;
}
BigDecimal notApplied = PaymentWorker.getPaymentNotApplied(payment);
if (notApplied.signum() > 0) {
Map<String, Object> appl = new HashMap<String, Object>();
appl.put("paymentId", payment.get("paymentId"));
appl.put("invoiceId", invoiceId);
appl.put("billingAccountId", billingAccountId);
appl.put("amountApplied", notApplied);
appl.put("userLogin", userLogin);
Map<String, Object> createPayApplResult = dispatcher.runSync("createPaymentApplication", appl);
if (ServiceUtil.isError(createPayApplResult)) {
return ServiceUtil.returnError(UtilProperties.getMessage(resource,
"AccountingErrorCreatingInvoiceFromOrder", locale), null, null, createPayApplResult);
}
}
}
// Should all be in place now. Depending on the ProductStore.autoApproveInvoice setting, set status to INVOICE_READY (unless it's a purchase invoice, which we set to INVOICE_IN_PROCESS)
String autoApproveInvoice = productStore != null ? productStore.getString("autoApproveInvoice") : "Y";
if (!"N".equals(autoApproveInvoice)) {
String nextStatusId = "PURCHASE_INVOICE".equals(invoiceType) ? "INVOICE_IN_PROCESS" : "INVOICE_READY";
Map<String, Object> setInvoiceStatusResult = dispatcher.runSync("setInvoiceStatus", UtilMisc.<String, Object>toMap("invoiceId", invoiceId, "statusId", nextStatusId, "userLogin", userLogin));
if (ServiceUtil.isError(setInvoiceStatusResult)) {
return ServiceUtil.returnError(UtilProperties.getMessage(resource,
"AccountingErrorCreatingInvoiceFromOrder", locale), null, null, setInvoiceStatusResult);
}
}
Map<String, Object> resp = ServiceUtil.returnSuccess();
resp.put("invoiceId", invoiceId);
resp.put("invoiceTypeId", invoiceType);
return resp;
} 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));
} catch (GenericServiceException e) {
Debug.logError(e, "Service/other problem creating invoice from order items: " + e.toString(), module);
return ServiceUtil.returnError(UtilProperties.getMessage(resource,
"AccountingServiceOtherProblemCreatingInvoiceFromOrderItems",
UtilMisc.toMap("reason", e.toString()), locale));
}
}
// Service for creating commission invoices
public static Map<String, Object> createCommissionInvoices(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");
List<String> salesInvoiceIds = UtilGenerics.checkList(context.get("invoiceIds"));
List<Map<String, String>> invoicesCreated = new LinkedList<Map<String,String>>();
Map<String, List<Map<String, Object>>> commissionParties = new HashMap<String, List<Map<String,Object>>>();
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"));
EntityQuery roleQuery = EntityQuery.use(delegator).select("partyId").from("InvoiceRole").where(invoiceRoleConds);
billFromVendorInvoiceRoles = EntityUtil.getFieldListFromEntityList(roleQuery.queryList(), "partyId", true);
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)) {
salesRepPartyIds = EntityUtil.getFieldListFromEntityList(roleQuery.where(invoiceRoleConds).queryList(), "partyId", true);
if (UtilValidate.isEmpty(salesRepPartyIds)) {
return ServiceUtil.returnError(UtilProperties.getMessage(resource,
"No party found with role sales representative for sales invoice "+ salesInvoiceId, locale));
}
} else {
List<String> salesInvoiceRolePartyIds = EntityUtil.getFieldListFromEntityList(roleQuery.where(invoiceRoleConds).queryList(), "partyId", true);
if (UtilValidate.isNotEmpty(salesInvoiceRolePartyIds)) {
salesRepPartyIds = UtilGenerics.checkList(CollectionUtils.intersection(salesRepPartyIds, salesInvoiceRolePartyIds));
}
}
invoice = EntityQuery.use(delegator).from("Invoice").where("invoiceId", salesInvoiceId).queryOne();
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));
}
invoiceItems = EntityQuery.use(delegator).from("InvoiceItem").where("invoiceId", salesInvoiceId).queryList();
} 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 = new LinkedList<GenericValue>();
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 = new HashMap<String, Object>();
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
GenericValue partyContactMechPurpose = null;
try {
partyContactMechPurpose = EntityQuery.use(delegator).from("PartyContactMechPurpose")
.where("partyId", partyIdBillTo, "contactMechPurposeTypeId", "BILLING_LOCATION").queryFirst();
} catch (GenericEntityException e) {
return ServiceUtil.returnError(e.getMessage());
}
if (partyContactMechPurpose != null) {
GenericValue invoiceContactMech = delegator.makeValue("InvoiceContactMech", UtilMisc.toMap(
"invoiceId", invoiceId,
"contactMechId", partyContactMechPurpose.getString("contactMechId"),
"contactMechPurposeTypeId", "BILLING_LOCATION"));
toStore.add(invoiceContactMech);
}
try {
partyContactMechPurpose = EntityQuery.use(delegator).from("PartyContactMechPurpose")
.where("partyId", partyIdBillTo, "contactMechPurposeTypeId", "PAYMENT_LOCATION").queryFirst();
} catch (GenericEntityException e) {
return ServiceUtil.returnError(e.getMessage());
}
if (partyContactMechPurpose != null) {
GenericValue invoiceContactMech = delegator.makeValue("InvoiceContactMech", UtilMisc.toMap(
"invoiceId", invoiceId,
"contactMechId", partyContactMechPurpose.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 {
delegator.storeAll(toStore);
} 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));
}
invoicesCreated.add(UtilMisc.<String, String>toMap("commissionInvoiceId",invoiceId, "salesRepresentative ",partyIdBillFrom));
}
String invCreated = Integer.toString(invoicesCreated.size());
Map<String, Object> result = ServiceUtil.returnSuccess(UtilProperties.getMessage(resource,
"AccountingCommissionInvoicesCreated",
UtilMisc.toMap("invoicesCreated", invCreated), locale));
Debug.logInfo("Created Commission invoices for each commission receiving parties " +
invCreated, module);
result.put("invoicesCreated", invoicesCreated);
return result;
}
public static Map<String, Object> readyInvoices(DispatchContext dctx, Map<String, Object> context) {
LocalDispatcher dispatcher = dctx.getDispatcher();
GenericValue userLogin = (GenericValue) context.get("userLogin");
Locale locale = (Locale) context.get("locale");
// Get invoices to make ready
List<String> invoicesCreated = UtilGenerics.checkList(context.get("invoicesCreated"));
String nextStatusId = "INVOICE_READY";
try {
for (String invoiceId : invoicesCreated) {
Map<String, Object> setInvoiceStatusResult = dispatcher.runSync("setInvoiceStatus", UtilMisc.<String, Object>toMap("invoiceId", invoiceId, "statusId", nextStatusId, "userLogin", userLogin));
if (ServiceUtil.isError(setInvoiceStatusResult)) {
return ServiceUtil.returnError(UtilProperties.getMessage(resource,
"AccountingInvoiceCommissionError", locale), null, null, setInvoiceStatusResult);
}
}
} catch (GenericServiceException e) {
Debug.logError(e, "Entity/data problem creating commission invoice: " + e.toString(), module);
return ServiceUtil.returnError(UtilProperties.getMessage(resource,
"AccountingInvoiceCommissionError",
UtilMisc.toMap("reason", e.toString()), locale));
}
return ServiceUtil.returnSuccess();
}
public static Map<String, Object> createInvoicesFromShipment(DispatchContext dctx, Map<String, Object> context) {
//Delegator delegator = dctx.getDelegator();
Delegator delegator = dctx.getDelegator();
LocalDispatcher dispatcher = dctx.getDispatcher();
String shipmentId = (String) context.get("shipmentId");
Locale locale = (Locale) context.get("locale");
List<String> invoicesCreated = new LinkedList<String>();
Map<String, Object> response = ServiceUtil.returnSuccess();
GenericValue orderShipment = null;
String invoicePerShipment = null;
try {
orderShipment = EntityQuery.use(delegator).from("OrderShipment").where("shipmentId", shipmentId).queryFirst();
} catch (GenericEntityException e) {
return ServiceUtil.returnError(e.getMessage());
}
if (orderShipment != null) {
String orderId = orderShipment.getString("orderId");
try {
GenericValue orderHeader = EntityQuery.use(delegator).from("OrderHeader").where("orderId", orderId).queryOne();
invoicePerShipment = orderHeader.getString("invoicePerShipment");
} catch (GenericEntityException e) {
return ServiceUtil.returnError(e.getMessage());
}
}
// Either no orderShipment exists, or there's a null invoicePerShipment in the OrderHeader.
// In either case, use the default value from the properties
if (invoicePerShipment == null) {
invoicePerShipment = EntityUtilProperties.getPropertyValue("accounting","create.invoice.per.shipment", delegator);
}
if ("Y".equals(invoicePerShipment)) {
Map<String, Object> serviceContext = UtilMisc.toMap("shipmentIds", UtilMisc.toList(shipmentId), "eventDate", context.get("eventDate"), "userLogin", context.get("userLogin"));
try {
Map<String, Object> result = dispatcher.runSync("createInvoicesFromShipments", serviceContext);
invoicesCreated = UtilGenerics.checkList(result.get("invoicesCreated"));
} catch (GenericServiceException e) {
Debug.logError(e, "Trouble calling createInvoicesFromShipment service; invoice not created for shipment [" + shipmentId + "]", module);
return ServiceUtil.returnError(UtilProperties.getMessage(resource,
"AccountingTroubleCallingCreateInvoicesFromShipmentService",
UtilMisc.toMap("shipmentId", shipmentId), locale));
}
response.put("invoicesCreated", invoicesCreated);
}
return response;
}
public static Map<String, Object> setInvoicesToReadyFromShipment(DispatchContext dctx, Map<String, Object> context) {
Delegator delegator = dctx.getDelegator();
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.
GenericValue shipment = null;
try {
shipment = EntityQuery.use(delegator).from("Shipment").where("shipmentId", shipmentId).queryOne();
} 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));
}
if (shipment == null) {
Debug.logError(UtilProperties.getMessage(resource, "AccountingShipmentNotFound", locale), module);
return ServiceUtil.returnError(UtilProperties.getMessage(resource, "AccountingShipmentNotFound", locale));
}
List<GenericValue> itemIssuances = new LinkedList<GenericValue>();
try {
itemIssuances = EntityQuery.use(delegator).select("orderId", "shipmentId")
.from("ItemIssuance").where("shipmentId", shipmentId).orderBy("orderId").distinct().queryList();
} 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, GenericValue> ordersWithInProcessInvoice = new HashMap<String, GenericValue>();
for (GenericValue itemIssuance : itemIssuances) {
String orderId = itemIssuance.getString("orderId");
Map<String, Object> billFields = new HashMap<String, Object>();
billFields.put("orderId", orderId);
GenericValue orderItemBilling = null;
try {
orderItemBilling = EntityQuery.use(delegator).from("OrderItemBilling").where(billFields).queryFirst();
} 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, the order does not have any invoice
if (orderItemBilling != null) {
// orders already have an invoice
GenericValue invoice = null;
try {
invoice = orderItemBilling.getRelatedOne("Invoice", false);
} catch (GenericEntityException e) {
Debug.logError(e, module);
return ServiceUtil.returnError(e.getMessage());
}
if (invoice != null) {
if ("INVOICE_IN_PROCESS".equals(invoice.getString("statusId"))) {
ordersWithInProcessInvoice.put(orderId, invoice);
}
}
}
}
// For In-Process invoice, move the status to ready and capture the payment
for (GenericValue invoice : ordersWithInProcessInvoice.values()) {
String invoiceId = invoice.getString("invoiceId");
Map<String, Object> setInvoiceStatusResult = new HashMap<String, Object>();
try {
setInvoiceStatusResult = dispatcher.runSync("setInvoiceStatus", UtilMisc.<String, Object>toMap("invoiceId", invoiceId, "statusId", "INVOICE_READY", "userLogin", userLogin));
} catch (GenericServiceException e) {
Debug.logError(e, module);
return ServiceUtil.returnError(e.getMessage());
}
if (ServiceUtil.isError(setInvoiceStatusResult)) {
return ServiceUtil.returnError(UtilProperties.getMessage(resource,
"AccountingErrorCreatingInvoiceFromOrder", locale), null, null, setInvoiceStatusResult);
}
}
return ServiceUtil.returnSuccess();
}
public static Map<String, Object> createSalesInvoicesFromDropShipment(DispatchContext dctx, Map<String, Object> context) {
LocalDispatcher dispatcher = dctx.getDispatcher();
String shipmentId = (String) context.get("shipmentId");
Locale locale = (Locale) context.get("locale");
Map<String, Object> serviceContext = UtilMisc.toMap("shipmentIds", UtilMisc.toList(shipmentId), "createSalesInvoicesForDropShipments", Boolean.TRUE, "userLogin", context.get("userLogin"));
Map<String, Object> serviceResult;
try {
serviceResult = dispatcher.runSync("createInvoicesFromShipments", serviceContext);
} catch (GenericServiceException e) {
Debug.logError(e, "Trouble calling createInvoicesFromShipment service; invoice not created for shipment " + shipmentId, module);
return ServiceUtil.returnError(UtilProperties.getMessage(resource,
"AccountingTroubleCallingCreateInvoicesFromShipmentService",
UtilMisc.toMap("shipmentId", shipmentId), locale));
}
return serviceResult;
}
public static Map<String, Object> createInvoicesFromShipments(DispatchContext dctx, Map<String, ? extends Object> context) {
Delegator delegator = dctx.getDelegator();
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 = new LinkedList<String>();
//DEJ20060520: not used? planned to be used? List shipmentIdList = new LinkedList();
for (String tmpShipmentId : shipmentIds) {
try {
GenericValue shipment = EntityQuery.use(delegator).from("Shipment").where("shipmentId", tmpShipmentId).queryOne();
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));
}
}
EntityQuery shipmentQuery = EntityQuery.use(delegator).where(EntityCondition.makeCondition("shipmentId", EntityOperator.IN, shipmentIds)).orderBy("shipmentId");
// 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) {
items = shipmentQuery.from("ShipmentReceipt").queryList();
// 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", false);
GenericValue ownerPartyRole = EntityQuery.use(delegator).from("PartyRole")
.where("partyId", inventoryItem.get("ownerPartyId"), "roleTypeId", "INTERNAL_ORGANIZATIO").cache().queryOne();
if (UtilValidate.isEmpty(ownerPartyRole)) {
itemsIter.remove();
}
}
} else if (dropShipmentFound) {
List<GenericValue> shipments = shipmentQuery.from("Shipment").queryList();
// 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)
orderItemAssocs = EntityQuery.use(delegator).from("OrderItemAssoc")
.where(EntityCondition.makeCondition("toOrderId", EntityOperator.IN, purchaseOrderIds)).queryList();
// 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", null, orderItemAssocs, false);
} else {
// If it's a purchase invoice being created, the order items for that purchase orders can be used directly
items = EntityQuery.use(delegator).from("OrderItem")
.where(EntityCondition.makeCondition("orderId", EntityOperator.IN, purchaseOrderIds)).queryList();
}
} else {
items = shipmentQuery.from("ItemIssuance").queryList();
}
} 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 = new HashMap<String, List<GenericValue>>();
for (GenericValue item : items) {
String orderId = item.getString("orderId");
String orderItemSeqId = item.getString("orderItemSeqId");
List<GenericValue> itemsByOrder = shippedOrderItems.get(orderId);
if (itemsByOrder == null) {
itemsByOrder = new LinkedList<GenericValue>();
}
// check and make sure we haven't already billed for this issuance or shipment receipt
List<EntityCondition> billFields = new LinkedList<EntityCondition>();
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 {
itemBillings = EntityQuery.use(delegator).from("OrderItemBillingAndInvoiceAndItem").where(billFields).queryList();
} 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 = new LinkedList<GenericValue>();
// map of available quantities so we only have to calc once
Map<String, BigDecimal> itemQtyAvail = new HashMap<String, BigDecimal>();
// 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 = new LinkedList<EntityCondition>();
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", false);
// 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", false);
orderItem.set("quantity", purchaseOrderItem.getBigDecimal("quantity"));
issueQty = purchaseOrderItem.getBigDecimal("quantity");
}
billed = EntityQuery.use(delegator).from("OrderItemBillingAndInvoiceAndItem").where(lookup).queryList();
} 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)) {
invoiceableShipments = EntityQuery.use(delegator).from("Shipment").where(
UtilMisc.toList(
EntityCondition.makeCondition("primaryOrderId", EntityOperator.IN, invoiceablePrimaryOrderIds),
EntityCondition.makeCondition("shipmentId", EntityOperator.IN, shipmentIds))
).queryList();
}
} else {
List<String> invoiceableShipmentIds = EntityUtil.getFieldListFromEntityList(toBillItems, "shipmentId", true);
if (UtilValidate.isNotEmpty(invoiceableShipmentIds)) {
invoiceableShipments = EntityQuery.use(delegator).from("Shipment").where(EntityCondition.makeCondition("shipmentId", EntityOperator.IN, invoiceableShipmentIds)).queryList();
}
}
} 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 = new HashMap<GenericValue, BigDecimal>();
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 (Map.Entry<GenericValue, BigDecimal> entry : additionalShippingCharges.entrySet()) {
GenericValue shipment = entry.getKey();
BigDecimal additionalShippingCharge = entry.getValue();
String shipmentId = shipment.getString("shipmentId");
Map<String, Object> createOrderAdjustmentContext = new HashMap<String, Object>();
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", false);
} 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 = new LinkedList<Object>();
Map<String, Object> calcTaxContext = new HashMap<String, Object>();
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("orderAdjustmentId", delegator.getNextSeqId("OrderAdjustment"));
orderAdjustment.set("orderId", orderId);
orderAdjustment.set("orderItemSeqId", "_NA_");
orderAdjustment.set("shipGroupSeqId", shipment.getString("primaryShipGroupSeqId"));
orderAdjustment.set("originalAdjustmentId", shippingOrderAdjustmentId);
}
try {
delegator.storeAll(orderAdjustments);
} 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 {
orderPaymentPreferences = EntityQuery.use(delegator).from("OrderPaymentPreference")
.where("orderId", orderId, "paymentMethodTypeId", "CREDIT_CARD").queryList();
} 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;
GenericValue shipmentItemBilling = null;
String shipmentId = shipmentIds.get(0);
try {
shipmentItemBilling = EntityQuery.use(delegator).from("ShipmentItemBilling").where("shipmentId", shipmentId).queryFirst();
} catch (GenericEntityException e) {
return ServiceUtil.returnError(UtilProperties.getMessage(resource,
"AccountingProblemGettingShipmentItemBilling", locale));
}
if (shipmentItemBilling != null) {
invoiceId = shipmentItemBilling.getString("invoiceId");
}
// call the createInvoiceForOrder service for each order
Map<String, Object> serviceContext = UtilMisc.toMap("orderId", orderId, "billItems", toBillItems, "invoiceId", invoiceId, "eventDate", context.get("eventDate"), "userLogin", context.get("userLogin"));
try {
Map<String, Object> result = dispatcher.runSync("createInvoiceForOrder", serviceContext);
invoicesCreated.add((String) result.get("invoiceId"));
} catch (GenericServiceException e) {
Debug.logError(e, "Trouble calling createInvoiceForOrder service; invoice not created for shipment", module);
return ServiceUtil.returnError(UtilProperties.getMessage(resource,
"AccountingTroubleCallingCreateInvoiceForOrderService", locale));
}
}
Map<String, Object> response = ServiceUtil.returnSuccess();
response.put("invoicesCreated", invoicesCreated);
return response;
}
private static String getInvoiceItemType(Delegator delegator, String key1, String key2, String invoiceTypeId, String defaultValue) {
GenericValue itemMap = null;
try {
if (UtilValidate.isNotEmpty(key1)) {
itemMap = EntityQuery.use(delegator).from("InvoiceItemTypeMap").where("invoiceItemMapKey", key1, "invoiceTypeId", invoiceTypeId).cache().queryOne();
}
if (itemMap == null && UtilValidate.isNotEmpty(key2)) {
itemMap = EntityQuery.use(delegator).from("InvoiceItemTypeMap").where("invoiceItemMapKey", key2, "invoiceTypeId", invoiceTypeId).cache().queryOne();
}
} catch (GenericEntityException e) {
Debug.logError(e, "Trouble getting InvoiceItemTypeMap entity record", module);
return defaultValue;
}
if (itemMap != null) {
return itemMap.getString("invoiceItemTypeId");
} else {
return defaultValue;
}
}
public static Map<String, Object> createInvoicesFromReturnShipment(DispatchContext dctx, Map<String, Object> context) {
Delegator delegator = dctx.getDelegator();
LocalDispatcher dispatcher = dctx.getDispatcher();
Locale locale = (Locale) context.get("locale");
String shipmentId = (String) context.get("shipmentId");
String errorMsg = UtilProperties.getMessage(resource, "AccountingErrorCreatingInvoiceForShipment",
UtilMisc.toMap("shipmentId", shipmentId), locale);
boolean salesReturnFound = false;
boolean purchaseReturnFound = false;
List<String> invoicesCreated = new LinkedList<String>();
try {
// get the shipment and validate that it is a sales return
GenericValue shipment = EntityQuery.use(delegator).from("Shipment").where("shipmentId", shipmentId).queryOne();
if (shipment == null) {
return ServiceUtil.returnError(errorMsg + UtilProperties.getMessage(resource,
"AccountingShipmentNotFound", locale));
}
if (shipment.getString("shipmentTypeId").equals("SALES_RETURN")) {
salesReturnFound = true;
} else if ("PURCHASE_RETURN".equals(shipment.getString("shipmentTypeId"))) {
purchaseReturnFound = true;
}
if (!(salesReturnFound || purchaseReturnFound)) {
return ServiceUtil.returnError(errorMsg + UtilProperties.getMessage(resource,
"AccountingShipmentNotSalesReturnAndPurchaseReturn", locale));
}
// get the items of the shipment. They can come from ItemIssuance if the shipment were from a purchase return, ShipmentReceipt if it were from a sales return
List<GenericValue> shippedItems = null;
if (salesReturnFound) {
shippedItems = shipment.getRelated("ShipmentReceipt", null, null, false);
} else if (purchaseReturnFound) {
shippedItems = shipment.getRelated("ItemIssuance", null, null, false);
}
if (shippedItems == null) {
Debug.logInfo("No items issued for shipments", module);
return ServiceUtil.returnSuccess();
}
// group the shipments by returnId (because we want a seperate itemized invoice for each return)
Map<String, List<GenericValue>> itemsShippedGroupedByReturn = new HashMap<String, List<GenericValue>>();
for (GenericValue item : shippedItems) {
String returnId = null;
String returnItemSeqId = null;
if (item.getEntityName().equals("ShipmentReceipt")) {
returnId = item.getString("returnId");
} else if (item.getEntityName().equals("ItemIssuance")) {
GenericValue returnItemShipment = EntityQuery.use(delegator).from("ReturnItemShipment")
.where("shipmentId", item.get("shipmentId"), "shipmentItemSeqId", item.get("shipmentItemSeqId"))
.queryFirst();
returnId = returnItemShipment.getString("returnId");
returnItemSeqId = returnItemShipment.getString("returnItemSeqId");
}
// see if there are ReturnItemBillings for this item
Long billingCount = 0L;
if (item.getEntityName().equals("ShipmentReceipt")) {
billingCount = EntityQuery.use(delegator).from("ReturnItemBilling")
.where("shipmentReceiptId", item.get("receiptId"),
"returnId", returnId,
"returnItemSeqId", item.get("returnItemSeqId"))
.queryCount();
} else if (item.getEntityName().equals("ItemIssuance")) {
billingCount = EntityQuery.use(delegator).from("ReturnItemBilling").where("returnId", returnId, "returnItemSeqId", returnItemSeqId).queryCount();
}
// if there are billings, we have already billed the item, so skip it
if (billingCount > 0) continue;
// get the List of items shipped to/from this returnId
List<GenericValue> billItems = itemsShippedGroupedByReturn.get(returnId);
if (billItems == null) {
billItems = new LinkedList<GenericValue>();
}
// add our item to the group and put it back in the map
billItems.add(item);
itemsShippedGroupedByReturn.put(returnId, billItems);
}
// loop through the returnId keys in the map and invoke the createInvoiceFromReturn service for each
for (Map.Entry<String, List<GenericValue>> entry : itemsShippedGroupedByReturn.entrySet()) {
String returnId = entry.getKey();
List<GenericValue> billItems = entry.getValue();
if (Debug.verboseOn()) {
Debug.logVerbose("Creating invoice for return [" + returnId + "] with items: " + billItems.toString(), module);
}
Map<String, Object> input = UtilMisc.toMap("returnId", returnId, "billItems", billItems, "userLogin", context.get("userLogin"));
Map<String, Object> serviceResults = dispatcher.runSync("createInvoiceFromReturn", input);
if (ServiceUtil.isError(serviceResults)) {
return ServiceUtil.returnError(errorMsg, null, null, serviceResults);
}
// put the resulting invoiceId in the return list
invoicesCreated.add((String) serviceResults.get("invoiceId"));
}
} catch (GenericServiceException e) {
Debug.logError(e, errorMsg + e.getMessage(), module);
return ServiceUtil.returnError(errorMsg + e.getMessage());
} catch (GenericEntityException e) {
Debug.logError(e, errorMsg + e.getMessage(), module);
return ServiceUtil.returnError(errorMsg + e.getMessage());
}
Map<String, Object> result = ServiceUtil.returnSuccess();
result.put("invoicesCreated", invoicesCreated);
return result;
}
public static Map<String, Object> createInvoiceFromReturn(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");
String returnId= (String) context.get("returnId");
List<GenericValue> billItems = UtilGenerics.checkList(context.get("billItems"));
String errorMsg = UtilProperties.getMessage(resource, "AccountingErrorCreatingInvoiceForReturn",UtilMisc.toMap("returnId",returnId),locale);
// List invoicesCreated = new ArrayList();
try {
String invoiceTypeId;
String description;
// get the return header
GenericValue returnHeader = EntityQuery.use(delegator).from("ReturnHeader").where("returnId", returnId).queryOne();
if (returnHeader == null || returnHeader.get("returnHeaderTypeId") == null) {
return ServiceUtil.returnError(UtilProperties.getMessage(resource, "AccountingReturnTypeCannotBeNull", locale));
}
if (returnHeader.getString("returnHeaderTypeId").startsWith("CUSTOMER_")) {
invoiceTypeId = "CUST_RTN_INVOICE";
description = "Return Invoice for Customer Return #" + returnId;
} else {
invoiceTypeId = "PURC_RTN_INVOICE";
description = "Return Invoice for Vendor Return #" + returnId;
}
List<GenericValue> returnItems = returnHeader.getRelated("ReturnItem", null, null, false);
if (!returnItems.isEmpty()) {
for (GenericValue returnItem : returnItems) {
if ("RETURN_COMPLETED".equals(returnItem.getString("statusId"))) {
GenericValue product = returnItem.getRelatedOne("Product", false);
if (!ProductWorker.isPhysical(product)) {
boolean isNonPhysicalItemToReturn = false;
List<GenericValue> returnItemBillings = returnItem.getRelated("ReturnItemBilling", null, null, false);
if (!returnItemBillings.isEmpty()) {
GenericValue invoice = EntityUtil.getFirst(returnItemBillings).getRelatedOne("Invoice", false);
if ("INVOICE_CANCELLED".equals(invoice.getString("statusId"))) {
isNonPhysicalItemToReturn = true;
}
} else {
isNonPhysicalItemToReturn = true;
}
if (isNonPhysicalItemToReturn) {
if (UtilValidate.isEmpty(billItems)) {
billItems = new ArrayList<GenericValue>();
}
billItems.add(returnItem);
}
}
}
}
}
Map<String, Object> results = ServiceUtil.returnSuccess();
if (UtilValidate.isNotEmpty(billItems)) {
// set the invoice data
Map<String, Object> input = UtilMisc.<String, Object>toMap("invoiceTypeId", invoiceTypeId, "statusId", "INVOICE_IN_PROCESS");
input.put("partyId", returnHeader.get("toPartyId"));
input.put("partyIdFrom", returnHeader.get("fromPartyId"));
input.put("currencyUomId", returnHeader.get("currencyUomId"));
input.put("invoiceDate", UtilDateTime.nowTimestamp());
input.put("description", description);
input.put("billingAccountId", returnHeader.get("billingAccountId"));
input.put("userLogin", userLogin);
// call the service to create the invoice
Map<String, Object> serviceResults = dispatcher.runSync("createInvoice", input);
if (ServiceUtil.isError(serviceResults)) {
return ServiceUtil.returnError(errorMsg, null, null, serviceResults);
}
String invoiceId = (String) serviceResults.get("invoiceId");
// keep track of the invoice total vs the promised return total (how much the customer promised to return)
BigDecimal invoiceTotal = ZERO;
BigDecimal promisedTotal = ZERO;
// loop through shipment receipts to create invoice items and return item billings for each item and adjustment
int invoiceItemSeqNum = 1;
String invoiceItemSeqId = UtilFormatOut.formatPaddedNumber(invoiceItemSeqNum, INVOICE_ITEM_SEQUENCE_ID_DIGITS);
for (GenericValue item : billItems) {
boolean shipmentReceiptFound = false;
boolean itemIssuanceFound = false;
GenericValue returnItem = null;
BigDecimal quantity = BigDecimal.ZERO;
if ("ShipmentReceipt".equals(item.getEntityName())) {
shipmentReceiptFound = true;
} else if ("ItemIssuance".equals(item.getEntityName())) {
itemIssuanceFound = true;
} else if ("ReturnItem".equals(item.getEntityName())) {
quantity = item.getBigDecimal("returnQuantity");
returnItem = item;
} else {
Debug.logError("Unexpected entity " + item + " of type " + item.getEntityName(), module);
}
// we need the related return item and product
if (shipmentReceiptFound) {
returnItem = item.getRelatedOne("ReturnItem", true);
} else if (itemIssuanceFound) {
GenericValue shipmentItem = item.getRelatedOne("ShipmentItem", true);
GenericValue returnItemShipment = EntityUtil.getFirst(shipmentItem.getRelated("ReturnItemShipment", null, null, false));
returnItem = returnItemShipment.getRelatedOne("ReturnItem", true);
}
if (returnItem == null) continue; // Just to prevent NPE
GenericValue product = returnItem.getRelatedOne("Product", true);
// extract the return price as a big decimal for convenience
BigDecimal returnPrice = returnItem.getBigDecimal("returnPrice");
// determine invoice item type from the return item type
String invoiceItemTypeId = getInvoiceItemType(delegator, returnItem.getString("returnItemTypeId"), null, invoiceTypeId, null);
if (invoiceItemTypeId == null) {
return ServiceUtil.returnError(errorMsg + UtilProperties.getMessage(resource,
"AccountingNoKnownInvoiceItemTypeReturnItemType",
UtilMisc.toMap("returnItemTypeId", returnItem.getString("returnItemTypeId")), locale));
}
if (shipmentReceiptFound) {
quantity = item.getBigDecimal("quantityAccepted");
} else if (itemIssuanceFound) {
quantity = item.getBigDecimal("quantity");
}
// create the invoice item for this shipment receipt
input = UtilMisc.toMap("invoiceId", invoiceId, "invoiceItemTypeId", invoiceItemTypeId, "quantity", quantity);
input.put("invoiceItemSeqId", "" + invoiceItemSeqId); // turn the int into a string with ("" + int) hack
input.put("amount", returnItem.get("returnPrice"));
input.put("productId", returnItem.get("productId"));
input.put("taxableFlag", product.get("taxable"));
input.put("description", returnItem.get("description"));
// TODO: what about the productFeatureId?
input.put("userLogin", userLogin);
serviceResults = dispatcher.runSync("createInvoiceItem", input);
if (ServiceUtil.isError(serviceResults)) {
return ServiceUtil.returnError(errorMsg, null, null, serviceResults);
}
// copy the return item information into ReturnItemBilling
input = UtilMisc.toMap("returnId", returnId, "returnItemSeqId", returnItem.get("returnItemSeqId"),
"invoiceId", invoiceId);
input.put("invoiceItemSeqId", "" + invoiceItemSeqId); // turn the int into a string with ("" + int) hack
input.put("quantity", quantity);
input.put("amount", returnItem.get("returnPrice"));
input.put("userLogin", userLogin);
if (shipmentReceiptFound) {
input.put("shipmentReceiptId", item.get("receiptId"));
}
serviceResults = dispatcher.runSync("createReturnItemBilling", input);
if (ServiceUtil.isError(serviceResults)) {
return ServiceUtil.returnError(errorMsg, null, null, serviceResults);
}
if (Debug.verboseOn()) {
Debug.logVerbose("Creating Invoice Item with amount " + returnPrice + " and quantity " + quantity
+ " for shipment [" + item.getString("shipmentId") + ":" + item.getString("shipmentItemSeqId") + "]", module);
}
String parentInvoiceItemSeqId = invoiceItemSeqId;
// increment the seqId counter after creating the invoice item and return item billing
invoiceItemSeqNum += 1;
invoiceItemSeqId = UtilFormatOut.formatPaddedNumber(invoiceItemSeqNum, INVOICE_ITEM_SEQUENCE_ID_DIGITS);
// keep a running total (note: a returnItem may have many receipts. hence, the promised total quantity is the receipt quantityAccepted + quantityRejected)
BigDecimal cancelQuantity = ZERO;
if (shipmentReceiptFound) {
cancelQuantity = item.getBigDecimal("quantityRejected");
} else if (itemIssuanceFound) {
cancelQuantity = item.getBigDecimal("cancelQuantity");
}
if (cancelQuantity == null) cancelQuantity = ZERO;
BigDecimal actualAmount = returnPrice.multiply(quantity).setScale(DECIMALS, ROUNDING);
BigDecimal promisedAmount = returnPrice.multiply(quantity.add(cancelQuantity)).setScale(DECIMALS, ROUNDING);
invoiceTotal = invoiceTotal.add(actualAmount).setScale(DECIMALS, ROUNDING);
promisedTotal = promisedTotal.add(promisedAmount).setScale(DECIMALS, ROUNDING);
// for each adjustment related to this ReturnItem, create a separate invoice item
List<GenericValue> adjustments = returnItem.getRelated("ReturnAdjustment", null, null, true);
for (GenericValue adjustment : adjustments) {
if (adjustment.get("amount") == null) {
Debug.logWarning("Return adjustment [" + adjustment.get("returnAdjustmentId") + "] has null amount and will be skipped", module);
continue;
}
// determine invoice item type from the return item type
invoiceItemTypeId = getInvoiceItemType(delegator, adjustment.getString("returnAdjustmentTypeId"), null, invoiceTypeId, null);
if (invoiceItemTypeId == null) {
return ServiceUtil.returnError(errorMsg + UtilProperties.getMessage(resource,
"AccountingNoKnownInvoiceItemTypeReturnAdjustmentType",
UtilMisc.toMap("returnAdjustmentTypeId", adjustment.getString("returnAdjustmentTypeId")), locale));
}
// prorate the adjustment amount by the returned amount; do not round ratio
BigDecimal ratio = quantity.divide(returnItem.getBigDecimal("returnQuantity"), 100, ROUNDING);
BigDecimal amount = adjustment.getBigDecimal("amount");
amount = amount.multiply(ratio).setScale(DECIMALS, ROUNDING);
if (Debug.verboseOn()) {
Debug.logVerbose("Creating Invoice Item with amount " + adjustment.getBigDecimal("amount") + " prorated to " + amount
+ " for return adjustment [" + adjustment.getString("returnAdjustmentId") + "]", module);
}
// prepare invoice item data for this adjustment
input = UtilMisc.toMap("invoiceId", invoiceId, "invoiceItemTypeId", invoiceItemTypeId, "quantity", BigDecimal.ONE);
input.put("amount", amount);
input.put("invoiceItemSeqId", "" + invoiceItemSeqId); // turn the int into a string with ("" + int) hack
input.put("productId", returnItem.get("productId"));
input.put("description", adjustment.get("description"));
input.put("overrideGlAccountId", adjustment.get("overrideGlAccountId"));
input.put("parentInvoiceId", invoiceId);
input.put("parentInvoiceItemSeqId", parentInvoiceItemSeqId);
input.put("taxAuthPartyId", adjustment.get("taxAuthPartyId"));
input.put("taxAuthGeoId", adjustment.get("taxAuthGeoId"));
input.put("userLogin", userLogin);
// only set taxable flag when the adjustment is not a tax
// TODO: Note that we use the value of Product.taxable here. This is not an ideal solution. Instead, use returnAdjustment.includeInTax
if (adjustment.get("returnAdjustmentTypeId").equals("RET_SALES_TAX_ADJ")) {
input.put("taxableFlag", "N");
}
// create the invoice item
serviceResults = dispatcher.runSync("createInvoiceItem", input);
if (ServiceUtil.isError(serviceResults)) {
return ServiceUtil.returnError(errorMsg, null, null, serviceResults);
}
// increment the seqId counter
invoiceItemSeqNum += 1;
invoiceItemSeqId = UtilFormatOut.formatPaddedNumber(invoiceItemSeqNum, INVOICE_ITEM_SEQUENCE_ID_DIGITS);
// keep a running total (promised adjustment in this case is the same as the invoice adjustment)
invoiceTotal = invoiceTotal.add(amount).setScale(DECIMALS, ROUNDING);
promisedTotal = promisedTotal.add(amount).setScale(DECIMALS, ROUNDING);
}
}
// ratio of the invoice total to the promised total so far or zero if the amounts were zero
BigDecimal actualToPromisedRatio = ZERO;
if (invoiceTotal.signum() != 0) {
actualToPromisedRatio = invoiceTotal.divide(promisedTotal, 100, ROUNDING); // do not round ratio
}
// loop through return-wide adjustments and create invoice items for each
List<GenericValue> adjustments = returnHeader.getRelated("ReturnAdjustment", UtilMisc.toMap("returnItemSeqId", "_NA_"), null, true);
for (GenericValue adjustment : adjustments) {
// determine invoice item type from the return item type
String invoiceItemTypeId = getInvoiceItemType(delegator, adjustment.getString("returnAdjustmentTypeId"), null, invoiceTypeId, null);
if (invoiceItemTypeId == null) {
return ServiceUtil.returnError(errorMsg + UtilProperties.getMessage(resource,
"AccountingNoKnownInvoiceItemTypeReturnAdjustmentType",
UtilMisc.toMap("returnAdjustmentTypeId", adjustment.getString("returnAdjustmentTypeId")), locale));
}
// prorate the adjustment amount by the actual to promised ratio
BigDecimal amount = adjustment.getBigDecimal("amount").multiply(actualToPromisedRatio).setScale(DECIMALS, ROUNDING);
if (Debug.verboseOn()) {
Debug.logVerbose("Creating Invoice Item with amount " + adjustment.getBigDecimal("amount") + " prorated to " + amount
+ " for return adjustment [" + adjustment.getString("returnAdjustmentId") + "]", module);
}
// prepare the invoice item for the return-wide adjustment
input = UtilMisc.toMap("invoiceId", invoiceId, "invoiceItemTypeId", invoiceItemTypeId, "quantity", BigDecimal.ONE);
input.put("amount", amount);
input.put("invoiceItemSeqId", "" + invoiceItemSeqId); // turn the int into a string with ("" + int) hack
input.put("description", adjustment.get("description"));
input.put("overrideGlAccountId", adjustment.get("overrideGlAccountId"));
input.put("taxAuthPartyId", adjustment.get("taxAuthPartyId"));
input.put("taxAuthGeoId", adjustment.get("taxAuthGeoId"));
input.put("userLogin", userLogin);
// XXX TODO Note: we need to implement ReturnAdjustment.includeInTax for this to work properly
input.put("taxableFlag", adjustment.get("includeInTax"));
// create the invoice item
serviceResults = dispatcher.runSync("createInvoiceItem", input);
if (ServiceUtil.isError(serviceResults)) {
return ServiceUtil.returnError(errorMsg, null, null, serviceResults);
}
// increment the seqId counter
invoiceItemSeqNum += 1;
invoiceItemSeqId = UtilFormatOut.formatPaddedNumber(invoiceItemSeqNum, INVOICE_ITEM_SEQUENCE_ID_DIGITS);
}
// Set the invoice to READY
serviceResults = dispatcher.runSync("setInvoiceStatus", UtilMisc.<String, Object>toMap("invoiceId", invoiceId, "statusId", "INVOICE_READY", "userLogin", userLogin));
if (ServiceUtil.isError(serviceResults)) {
return ServiceUtil.returnError(errorMsg, null, null, serviceResults);
}
// return the invoiceId
results.put("invoiceId", invoiceId);
}
return results;
} catch (GenericServiceException e) {
Debug.logError(e, errorMsg + e.getMessage(), module);
return ServiceUtil.returnError(errorMsg + e.getMessage());
} catch (GenericEntityException e) {
Debug.logError(e, errorMsg + e.getMessage(), module);
return ServiceUtil.returnError(errorMsg + e.getMessage());
}
}
public static Map<String, Object> checkInvoicePaymentApplications(DispatchContext ctx, Map<String, Object> context) {
Delegator delegator = ctx.getDelegator();
LocalDispatcher dispatcher = ctx.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 invoiceId = (String) context.get("invoiceId");
GenericValue invoice = null ;
try {
invoice = EntityQuery.use(delegator).from("Invoice").where("invoiceId", invoiceId).queryOne();
} catch (GenericEntityException e) {
Debug.logError(e, "Problem getting Invoice for Invoice ID" + invoiceId, module);
return ServiceUtil.returnError(UtilProperties.getMessage(resource,
"AccountingInvoiceNotFound", UtilMisc.toMap("invoiceId", invoiceId), locale));
}
// Ignore invoices that aren't ready yet
if (! invoice.getString("statusId").equals("INVOICE_READY")) {
return ServiceUtil.returnSuccess();
}
// Get the payment applications that can be used to pay the invoice
List<GenericValue> paymentAppl = null;
try {
paymentAppl = EntityQuery.use(delegator).from("PaymentAndApplication").where("invoiceId", invoiceId).queryList();
// For each payment application, select only those that are RECEIVED or SENT based on whether the payment is a RECEIPT or DISBURSEMENT respectively
for (Iterator<GenericValue> iter = paymentAppl.iterator(); iter.hasNext();) {
GenericValue payment = iter.next();
if ("PMNT_RECEIVED".equals(payment.get("statusId")) && UtilAccounting.isReceipt(payment)) {
continue; // keep
}
if ("PMNT_SENT".equals(payment.get("statusId")) && UtilAccounting.isDisbursement(payment)) {
continue; // keep
}
// all other cases, remove the payment application
iter.remove();
}
} catch (GenericEntityException e) {
Debug.logError(e, "Problem getting PaymentApplication(s) for Invoice ID " + invoiceId, module);
return ServiceUtil.returnError(UtilProperties.getMessage(resource,
"AccountingProblemGettingPaymentApplication",
UtilMisc.toMap("invoiceId", invoiceId), locale));
}
Map<String, BigDecimal> payments = new HashMap<String, BigDecimal>();
Timestamp paidDate = null;
for (GenericValue payAppl : paymentAppl) {
payments.put(payAppl.getString("paymentId"), payAppl.getBigDecimal("amountApplied"));
// paidDate will be the last date (chronologically) of all the Payments applied to this invoice
Timestamp paymentDate = payAppl.getTimestamp("effectiveDate");
if (paymentDate != null) {
if ((paidDate == null) || (paidDate.before(paymentDate))) {
paidDate = paymentDate;
}
}
}
BigDecimal totalPayments = ZERO;
for (BigDecimal amount : payments.values()) {
if (amount == null) amount = ZERO;
totalPayments = totalPayments.add(amount).setScale(DECIMALS, ROUNDING);
}
if (totalPayments.signum() == 1) {
BigDecimal invoiceTotal = InvoiceWorker.getInvoiceTotal(delegator, invoiceId);
if (Debug.verboseOn()) {
Debug.logVerbose("Invoice #" + invoiceId + " total: " + invoiceTotal, module);
Debug.logVerbose("Total payments : " + totalPayments, module);
}
if (totalPayments.compareTo(invoiceTotal) >= 0) { // this checks that totalPayments is greater than or equal to invoiceTotal
// this invoice is paid
Map<String, Object> svcCtx = UtilMisc.toMap("statusId", "INVOICE_PAID", "invoiceId", invoiceId,
"paidDate", paidDate, "userLogin", userLogin);
try {
dispatcher.runSync("setInvoiceStatus", svcCtx);
} catch (GenericServiceException e) {
Debug.logError(e, "Problem changing invoice status to INVOICE_PAID" + svcCtx, module);
return ServiceUtil.returnError(UtilProperties.getMessage(resource,
"AccountingProblemChangingInvoiceStatusTo",
UtilMisc.toMap("newStatus", "INVOICE_PAID"), locale));
}
}
} else {
Debug.logInfo("No payments found for Invoice #" + invoiceId, module);
}
return ServiceUtil.returnSuccess();
}
private static BigDecimal calcHeaderAdj(Delegator delegator, GenericValue adj, String invoiceTypeId, String invoiceId, String invoiceItemSeqId,
BigDecimal divisor, BigDecimal multiplier, BigDecimal baseAmount, int decimals, int rounding, GenericValue userLogin, LocalDispatcher dispatcher, Locale locale) {
BigDecimal adjAmount = ZERO;
if (adj.get("amount") != null) {
// pro-rate the amount
BigDecimal amount = ZERO;
if("DONATION_ADJUSTMENT".equals(adj.getString("orderAdjustmentTypeId"))) {
amount=baseAmount;
} else if (divisor.signum() != 0) { // make sure the divisor is not 0 to avoid NaN problems; just leave the amount as 0 and skip it in essense
// multiply first then divide to avoid rounding errors
amount = baseAmount.multiply(multiplier).divide(divisor, decimals, rounding);
}
if (amount.signum() != 0) {
Map<String, Object> createInvoiceItemContext = new HashMap<String, Object>();
createInvoiceItemContext.put("invoiceId", invoiceId);
createInvoiceItemContext.put("invoiceItemSeqId", invoiceItemSeqId);
createInvoiceItemContext.put("invoiceItemTypeId", getInvoiceItemType(delegator, adj.getString("orderAdjustmentTypeId"), null, invoiceTypeId, "INVOICE_ADJ"));
createInvoiceItemContext.put("description", adj.get("description"));
createInvoiceItemContext.put("quantity", BigDecimal.ONE);
createInvoiceItemContext.put("amount", amount);
createInvoiceItemContext.put("overrideGlAccountId", adj.get("overrideGlAccountId"));
createInvoiceItemContext.put("taxAuthPartyId", adj.get("taxAuthPartyId"));
createInvoiceItemContext.put("taxAuthGeoId", adj.get("taxAuthGeoId"));
createInvoiceItemContext.put("taxAuthorityRateSeqId", adj.get("taxAuthorityRateSeqId"));
createInvoiceItemContext.put("userLogin", userLogin);
Map<String, Object> createInvoiceItemResult = null;
try {
createInvoiceItemResult = dispatcher.runSync("createInvoiceItem", createInvoiceItemContext);
} catch (GenericServiceException e) {
Debug.logError(e, "Service/other problem creating InvoiceItem from order header adjustment", module);
return adjAmount;
}
if (ServiceUtil.isError(createInvoiceItemResult)) {
return adjAmount;
}
// Create the OrderAdjustmentBilling record
Map<String, Object> createOrderAdjustmentBillingContext = new HashMap<String, Object>();
createOrderAdjustmentBillingContext.put("orderAdjustmentId", adj.getString("orderAdjustmentId"));
createOrderAdjustmentBillingContext.put("invoiceId", invoiceId);
createOrderAdjustmentBillingContext.put("invoiceItemSeqId", invoiceItemSeqId);
createOrderAdjustmentBillingContext.put("amount", amount);
createOrderAdjustmentBillingContext.put("userLogin", userLogin);
try {
dispatcher.runSync("createOrderAdjustmentBilling", createOrderAdjustmentBillingContext);
} catch (GenericServiceException e) {
return adjAmount; }
}
amount = amount.setScale(decimals, rounding);
adjAmount = amount;
}
else if (adj.get("sourcePercentage") != null) {
// pro-rate the amount
BigDecimal percent = adj.getBigDecimal("sourcePercentage");
percent = percent.divide(new BigDecimal(100), 100, rounding);
BigDecimal amount = ZERO;
// make sure the divisor is not 0 to avoid NaN problems; just leave the amount as 0 and skip it in essense
if (divisor.signum() != 0) {
// multiply first then divide to avoid rounding errors
amount = percent.multiply(divisor);
}
if (amount.signum() != 0) {
Map<String, Object> createInvoiceItemContext = new HashMap<String, Object>();
createInvoiceItemContext.put("invoiceId", invoiceId);
createInvoiceItemContext.put("invoiceItemSeqId", invoiceItemSeqId);
createInvoiceItemContext.put("invoiceItemTypeId", getInvoiceItemType(delegator, adj.getString("orderAdjustmentTypeId"), null, invoiceTypeId, "INVOICE_ADJ"));
createInvoiceItemContext.put("description", adj.get("description"));
createInvoiceItemContext.put("quantity", BigDecimal.ONE);
createInvoiceItemContext.put("amount", amount);
createInvoiceItemContext.put("overrideGlAccountId", adj.get("overrideGlAccountId"));
createInvoiceItemContext.put("taxAuthPartyId", adj.get("taxAuthPartyId"));
createInvoiceItemContext.put("taxAuthGeoId", adj.get("taxAuthGeoId"));
createInvoiceItemContext.put("taxAuthorityRateSeqId", adj.get("taxAuthorityRateSeqId"));
createInvoiceItemContext.put("userLogin", userLogin);
Map<String, Object> createInvoiceItemResult = null;
try {
createInvoiceItemResult = dispatcher.runSync("createInvoiceItem", createInvoiceItemContext);
} catch (GenericServiceException e) {
Debug.logError(e, "Service/other problem creating InvoiceItem from order header adjustment", module);
return adjAmount;
}
if (ServiceUtil.isError(createInvoiceItemResult)) {
return adjAmount;
}
// Create the OrderAdjustmentBilling record
Map<String, Object> createOrderAdjustmentBillingContext = new HashMap<String, Object>();
createOrderAdjustmentBillingContext.put("orderAdjustmentId", adj.getString("orderAdjustmentId"));
createOrderAdjustmentBillingContext.put("invoiceId", invoiceId);
createOrderAdjustmentBillingContext.put("invoiceItemSeqId", invoiceItemSeqId);
createOrderAdjustmentBillingContext.put("amount", amount);
createOrderAdjustmentBillingContext.put("userLogin", userLogin);
try {
dispatcher.runSync("createOrderAdjustmentBilling", createOrderAdjustmentBillingContext);
} catch (GenericServiceException e) {
return adjAmount;
}
}
amount = amount.setScale(decimals, rounding);
adjAmount = amount;
}
Debug.logInfo("adjAmount: " + adjAmount + ", divisor: " + divisor + ", multiplier: " + multiplier +
", invoiceTypeId: " + invoiceTypeId + ", invoiceId: " + invoiceId + ", itemSeqId: " + invoiceItemSeqId +
", decimals: " + decimals + ", rounding: " + rounding + ", adj: " + adj, module);
return adjAmount;
}
/* Creates InvoiceTerm entries for a list of terms, which can be BillingAccountTerms, OrderTerms, etc. */
private static void createInvoiceTerms(Delegator delegator, LocalDispatcher dispatcher, String invoiceId, List<GenericValue> terms, GenericValue userLogin, Locale locale) {
if (terms != null) {
for (GenericValue term : terms) {
Map<String, Object> createInvoiceTermContext = new HashMap<String, Object>();
createInvoiceTermContext.put("invoiceId", invoiceId);
createInvoiceTermContext.put("invoiceItemSeqId", "_NA_");
createInvoiceTermContext.put("termTypeId", term.get("termTypeId"));
createInvoiceTermContext.put("termValue", term.get("termValue"));
createInvoiceTermContext.put("termDays", term.get("termDays"));
if (!"BillingAccountTerm".equals(term.getEntityName())) {
createInvoiceTermContext.put("textValue", term.get("textValue"));
createInvoiceTermContext.put("description", term.get("description"));
}
createInvoiceTermContext.put("uomId", term.get("uomId"));
createInvoiceTermContext.put("userLogin", userLogin);
Map<String, Object> createInvoiceTermResult = null;
try {
createInvoiceTermResult = dispatcher.runSync("createInvoiceTerm", createInvoiceTermContext);
} catch (GenericServiceException e) {
Debug.logError(e, "Service/other problem creating InvoiceItem from order header adjustment", module);
}
if (ServiceUtil.isError(createInvoiceTermResult)) {
Debug.logError("Service/other problem creating InvoiceItem from order header adjustment", module);
}
}
}
}
/**
* Service to add payment application records to indicate which invoices
* have been paid/received. For invoice processing, this service works on
* the invoice level when 'invoiceProcessing' parameter is set to "Y" else
* it works on the invoice item level.
*/
public static Map<String, Object> updatePaymentApplication(DispatchContext dctx, Map<String, Object> context) {
if (!context.containsKey("useHighestAmount")) {
context.put("useHighestAmount","N");
}
BigDecimal amountApplied = (BigDecimal) context.get("amountApplied");
if (amountApplied != null) {
context.put("amountApplied", amountApplied);
} else {
context.put("amountApplied", ZERO);
}
return updatePaymentApplicationDefBd(dctx, context);
}
/**
* Service to add payment application records to indicate which invoices
* have been paid/received. For invoice processing, this service works on
* the invoice level when 'invoiceProcessing' parameter is set to "Y" else
* it works on the invoice item level.
*
* This version will apply as much as possible when no amountApplied is provided.
*/
public static Map<String, Object> updatePaymentApplicationDef(DispatchContext dctx, Map<String, Object> context) {
if (!context.containsKey("useHighestAmount")) {
context.put("useHighestAmount","Y");
}
return updatePaymentApplication(dctx, context);
}
public static Map<String, Object> updatePaymentApplicationDefBd(DispatchContext dctx, Map<String, Object> context) {
Delegator delegator = dctx.getDelegator();
Locale locale = (Locale) context.get("locale");
if (DECIMALS == -1 || ROUNDING == -1) {
return ServiceUtil.returnError(UtilProperties.getMessage(resource,
"AccountingAritmeticPropertiesNotConfigured", locale));
}
if (!context.containsKey("useHighestAmount")) {
context.put("useHighestAmount","Y");
}
String defaultInvoiceProcessing = EntityUtilProperties.getPropertyValue("accounting","invoiceProcessing", delegator);
boolean debug = true; // show processing messages in the log..or not....
// a 'y' in invoiceProssesing will reverse the default processing
String changeProcessing = (String) context.get("invoiceProcessing");
String invoiceId = (String) context.get("invoiceId");
String invoiceItemSeqId = (String) context.get("invoiceItemSeqId");
String paymentId = (String) context.get("paymentId");
String toPaymentId = (String) context.get("toPaymentId");
String paymentApplicationId = (String) context.get("paymentApplicationId");
BigDecimal amountApplied = (BigDecimal) context.get("amountApplied");
String billingAccountId = (String) context.get("billingAccountId");
String taxAuthGeoId = (String) context.get("taxAuthGeoId");
String useHighestAmount = (String) context.get("useHighestAmount");
List<String> errorMessageList = new LinkedList<String>();
if (debug) Debug.logInfo("updatePaymentApplicationDefBd input parameters..." +
" defaultInvoiceProcessing: " + defaultInvoiceProcessing +
" changeDefaultInvoiceProcessing: " + changeProcessing +
" useHighestAmount: " + useHighestAmount +
" paymentApplicationId: " + paymentApplicationId +
" PaymentId: " + paymentId +
" InvoiceId: " + invoiceId +
" InvoiceItemSeqId: " + invoiceItemSeqId +
" BillingAccountId: " + billingAccountId +
" toPaymentId: " + toPaymentId +
" amountApplied: " + amountApplied +
" TaxAuthGeoId: " + taxAuthGeoId, module);
if (changeProcessing == null) {
changeProcessing = "N"; // not provided, so no change
}
boolean invoiceProcessing = true;
if (defaultInvoiceProcessing.equals("YY")) {
invoiceProcessing = true;
} else if (defaultInvoiceProcessing.equals("NN")) {
invoiceProcessing = false;
} else if (defaultInvoiceProcessing.equals("Y")) {
invoiceProcessing = !"Y".equals(changeProcessing);
} else if (defaultInvoiceProcessing.equals("N")) {
invoiceProcessing = "Y".equals(changeProcessing);
}
// on a new paymentApplication check if only billing or invoice or tax
// id is provided not 2,3... BUT a combination of billingAccountId and invoiceId is permitted - that's how you use a
// Billing Account to pay for an Invoice
if (paymentApplicationId == null) {
int count = 0;
if (invoiceId != null) count++;
if (toPaymentId != null) count++;
if (billingAccountId != null) count++;
if (taxAuthGeoId != null) count++;
if ((billingAccountId != null) && (invoiceId != null)) count--;
if (count != 1) {
errorMessageList.add(UtilProperties.getMessage(resource, "AccountingSpecifyInvoiceToPaymentBillingAccountTaxGeoId", locale));
}
}
// avoid null pointer exceptions.
if (amountApplied == null) amountApplied = ZERO;
// makes no sense to have an item numer without an invoice number
if (invoiceId == null) invoiceItemSeqId = null;
// retrieve all information and perform checking on the retrieved info.....
// Payment.....
BigDecimal paymentApplyAvailable = ZERO;
// amount available on the payment reduced by the already applied amounts
BigDecimal amountAppliedMax = ZERO;
// the maximum that can be applied taking payment,invoice,invoiceitem,billing account in concideration
// if maxApplied is missing, this value can be used,
// Payment this should be checked after the invoice checking because it is possible the currency is changed
GenericValue payment = null;
String currencyUomId = null;
if (paymentId == null || paymentId.equals("")) {
errorMessageList.add(UtilProperties.getMessage(resource, "AccountingPaymentIdBlankNotSupplied", locale));
} else {
try {
payment = EntityQuery.use(delegator).from("Payment").where("paymentId", paymentId).queryOne();
} catch (GenericEntityException e) {
return ServiceUtil.returnError(e.getMessage());
}
if (payment == null) {
errorMessageList.add(UtilProperties.getMessage(resource,
"AccountingPaymentRecordNotFound", UtilMisc.toMap("paymentId", paymentId), locale));
}
paymentApplyAvailable = payment.getBigDecimal("amount").subtract(PaymentWorker.getPaymentApplied(payment)).setScale(DECIMALS,ROUNDING);
if (payment.getString("statusId").equals("PMNT_CANCELLED")) {
errorMessageList.add(UtilProperties.getMessage(resource,
"AccountingPaymentCancelled", UtilMisc.toMap("paymentId", paymentId), locale));
}
if (payment.getString("statusId").equals("PMNT_CONFIRMED")) {
errorMessageList.add(UtilProperties.getMessage(resource,
"AccountingPaymentConfirmed", UtilMisc.toMap("paymentId", paymentId), locale));
}
currencyUomId = payment.getString("currencyUomId");
// if the amount to apply is 0 give it amount the payment still need
// to apply
if (amountApplied.signum() == 0) {
amountAppliedMax = paymentApplyAvailable;
}
}
// the "TO" Payment.....
BigDecimal toPaymentApplyAvailable = ZERO;
GenericValue toPayment = null;
if (toPaymentId != null && !toPaymentId.equals("")) {
try {
toPayment = EntityQuery.use(delegator).from("Payment").where("paymentId", toPaymentId).queryOne();
} catch (GenericEntityException e) {
return ServiceUtil.returnError(e.getMessage());
}
if (toPayment == null) {
errorMessageList.add(UtilProperties.getMessage(resource,
"AccountingPaymentRecordNotFound", UtilMisc.toMap("paymentId", toPaymentId), locale));
}
toPaymentApplyAvailable = toPayment.getBigDecimal("amount").subtract(PaymentWorker.getPaymentApplied(toPayment)).setScale(DECIMALS,ROUNDING);
if (toPayment.getString("statusId").equals("PMNT_CANCELLED")) {
errorMessageList.add(UtilProperties.getMessage(resource,
"AccountingPaymentCancelled", UtilMisc.toMap("paymentId", paymentId), locale));
}
if (toPayment.getString("statusId").equals("PMNT_CONFIRMED")) {
errorMessageList.add(UtilProperties.getMessage(resource,
"AccountingPaymentConfirmed", UtilMisc.toMap("paymentId", paymentId), locale));
}
// if the amount to apply is less then required by the payment reduce it
if (amountAppliedMax.compareTo(toPaymentApplyAvailable) > 0) {
amountAppliedMax = toPaymentApplyAvailable;
}
if (paymentApplicationId == null) {
// only check for new application records, update on existing records is checked in the paymentApplication section
if (toPaymentApplyAvailable.signum() == 0) {
errorMessageList.add(UtilProperties.getMessage(resource,
"AccountingPaymentAlreadyApplied", UtilMisc.toMap("paymentId", toPaymentId), locale));
} else {
// check here for too much application if a new record is
// added (paymentApplicationId == null)
if (amountApplied.compareTo(toPaymentApplyAvailable) > 0) {
errorMessageList.add(UtilProperties.getMessage(resource,
"AccountingPaymentLessRequested",
UtilMisc.<String, Object>toMap("paymentId",toPaymentId,
"paymentApplyAvailable", toPaymentApplyAvailable,
"amountApplied", amountApplied, "isoCode", currencyUomId), locale));
}
}
}
// check if at least one send is the same as one receiver on the other payment
if (!payment.getString("partyIdFrom").equals(toPayment.getString("partyIdTo")) &&
!payment.getString("partyIdTo").equals(toPayment.getString("partyIdFrom"))) {
errorMessageList.add(UtilProperties.getMessage(resource,
"AccountingFromPartySameToParty", locale));
}
if (debug) Debug.logInfo("toPayment info retrieved and checked...", module);
}
// assign payment to billing account if the invoice is assigned to this billing account
if (invoiceId != null) {
GenericValue invoice = null;
try {
invoice = EntityQuery.use(delegator).from("Invoice").where("invoiceId", invoiceId).queryOne();
} catch (GenericEntityException e) {
return ServiceUtil.returnError(e.getMessage());
}
if (invoice == null) {
errorMessageList.add(UtilProperties.getMessage(resource,
"AccountingInvoiceNotFound", UtilMisc.toMap("invoiceId", invoiceId), locale));
} else {
if (invoice.getString("billingAccountId") != null) {
billingAccountId = invoice.getString("billingAccountId");
}
}
}
// billing account
GenericValue billingAccount = null;
if (billingAccountId != null && !billingAccountId.equals("")) {
try {
billingAccount = EntityQuery.use(delegator).from("BillingAccount").where("billingAccountId", billingAccountId).queryOne();
} catch (GenericEntityException e) {
return ServiceUtil.returnError(e.getMessage());
}
if (billingAccount == null) {
errorMessageList.add(UtilProperties.getMessage(resource,
"AccountingBillingAccountNotFound", UtilMisc.toMap("billingAccountId", billingAccountId), locale));
}
// check the currency
if (billingAccount.get("accountCurrencyUomId") != null && currencyUomId != null &&
!billingAccount.getString("accountCurrencyUomId").equals(currencyUomId)) {
errorMessageList.add(UtilProperties.getMessage(resource, "AccountingBillingAccountCurrencyProblem",
UtilMisc.toMap("billingAccountId", billingAccountId,
"accountCurrencyUomId", billingAccount.getString("accountCurrencyUomId"),
"paymentId", paymentId, "paymentCurrencyUomId", currencyUomId), locale));
}
if (debug) Debug.logInfo("Billing Account info retrieved and checked...", module);
}
// get the invoice (item) information
BigDecimal invoiceApplyAvailable = ZERO;
// amount available on the invoice reduced by the already applied amounts
BigDecimal invoiceItemApplyAvailable = ZERO;
// amount available on the invoiceItem reduced by the already applied amounts
GenericValue invoice = null;
GenericValue invoiceItem = null;
if (invoiceId != null) {
try {
invoice = EntityQuery.use(delegator).from("Invoice").where("invoiceId", invoiceId).queryOne();
} catch (GenericEntityException e) {
return ServiceUtil.returnError(e.getMessage());
}
if (invoice == null) {
errorMessageList.add(UtilProperties.getMessage(resource,
"AccountingInvoiceNotFound", UtilMisc.toMap("invoiceId", invoiceId), locale));
} else { // check the invoice and when supplied the invoice item...
if (invoice.getString("statusId").equals("INVOICE_CANCELLED")) {
errorMessageList.add(UtilProperties.getMessage(resource,
"AccountingInvoiceCancelledCannotApplyTo", UtilMisc.toMap("invoiceId", invoiceId), locale));
}
// check the currency
if (currencyUomId != null && invoice.get("currencyUomId") != null &&
!currencyUomId.equals(invoice.getString("currencyUomId"))) {
Debug.logInfo(UtilProperties.getMessage(resource, "AccountingInvoicePaymentCurrencyProblem",
UtilMisc.toMap("invoiceCurrency", invoice.getString("currencyUomId"), "paymentCurrency", payment.getString("currencyUomId")),locale), module);
Debug.logInfo("will try to apply payment on the actualCurrency amount on payment", module);
if (payment.get("actualCurrencyAmount") == null || payment.get("actualCurrencyUomId") == null) {
errorMessageList.add("Actual amounts are required in the currency of the invoice to make this work....");
} else {
currencyUomId = payment.getString("actualCurrencyUomId");
if (!currencyUomId.equals(invoice.getString("currencyUomId"))) {
errorMessageList.add("actual currency on payment (" + currencyUomId + ") not the same as original invoice currency (" + invoice.getString("currencyUomId") + ")");
}
}
paymentApplyAvailable = payment.getBigDecimal("actualCurrencyAmount").subtract(PaymentWorker.getPaymentApplied(payment)).setScale(DECIMALS,ROUNDING);
if (amountApplied.signum() == 0) {
amountAppliedMax = paymentApplyAvailable;
}
}
// check if the invoice already covered by payments
BigDecimal invoiceTotal = InvoiceWorker.getInvoiceTotal(invoice);
invoiceApplyAvailable = InvoiceWorker.getInvoiceNotApplied(invoice);
// adjust the amountAppliedMax value if required....
if (invoiceApplyAvailable.compareTo(amountAppliedMax) < 0) {
amountAppliedMax = invoiceApplyAvailable;
}
if (invoiceTotal.signum() == 0) {
errorMessageList.add(UtilProperties.getMessage(resource,
"AccountingInvoiceTotalZero", UtilMisc.toMap("invoiceId", invoiceId), locale));
} else if (paymentApplicationId == null) {
// only check for new records here...updates are checked in the paymentApplication section
if (invoiceApplyAvailable.signum() == 0) {
errorMessageList.add(UtilProperties.getMessage(resource,
"AccountingInvoiceCompletelyApplied", UtilMisc.toMap("invoiceId", invoiceId), locale));
}
// check here for too much application if a new record(s) are
// added (paymentApplicationId == null)
else if (amountApplied.compareTo(invoiceApplyAvailable) > 0) {
errorMessageList.add(UtilProperties.getMessage(resource, "AccountingInvoiceLessRequested",
UtilMisc.<String, Object>toMap("invoiceId", invoiceId,
"invoiceApplyAvailable", invoiceApplyAvailable,
"amountApplied", amountApplied,
"isoCode", invoice.getString("currencyUomId")), locale));
}
}
// check if at least one sender is the same as one receiver on the invoice
if (!payment.getString("partyIdFrom").equals(invoice.getString("partyId")) &&
!payment.getString("partyIdTo").equals(invoice.getString("partyIdFrom"))) {
errorMessageList.add(UtilProperties.getMessage(resource,
"AccountingFromPartySameToParty", locale));
}
if (debug) Debug.logInfo("Invoice info retrieved and checked ...", module);
}
// if provided check the invoice item.
if (invoiceItemSeqId != null) {
// when itemSeqNr not provided delay checking on invoiceItemSeqId
try {
invoiceItem = EntityQuery.use(delegator).from("InvoiceItem").where("invoiceId", invoiceId, "invoiceItemSeqId", invoiceItemSeqId).queryOne();
} catch (GenericEntityException e) {
return ServiceUtil.returnError(e.getMessage());
}
if (invoiceItem == null) {
errorMessageList.add(UtilProperties.getMessage(resource,
"AccountingInvoiceItemNotFound",
UtilMisc.toMap("invoiceId", invoiceId, "invoiceItemSeqId", invoiceItemSeqId), locale));
} else {
if (invoice.get("currencyUomId") != null && currencyUomId != null && !invoice.getString("currencyUomId").equals(currencyUomId)) {
errorMessageList.add(UtilProperties.getMessage(resource,
"AccountingInvoicePaymentCurrencyProblem",
UtilMisc.toMap("paymentCurrencyId", currencyUomId,
"itemCurrency", invoice.getString("currencyUomId")), locale));
}
// get the invoice item applied value
BigDecimal quantity = null;
if (invoiceItem.get("quantity") == null) {
quantity = BigDecimal.ONE;
} else {
quantity = invoiceItem.getBigDecimal("quantity").setScale(DECIMALS,ROUNDING);
}
invoiceItemApplyAvailable = invoiceItem.getBigDecimal("amount").multiply(quantity).setScale(DECIMALS,ROUNDING).subtract(InvoiceWorker.getInvoiceItemApplied(invoiceItem));
// check here for too much application if a new record is added
if (paymentApplicationId == null && amountApplied.compareTo(invoiceItemApplyAvailable) > 0) {
// new record
errorMessageList.add("Invoice(" + invoiceId + ") item(" + invoiceItemSeqId + ") has " + invoiceItemApplyAvailable + " to apply but " + amountApplied + " is requested\n");
String uomId = invoice.getString("currencyUomId");
errorMessageList.add(UtilProperties.getMessage(resource, "AccountingInvoiceItemLessRequested",
UtilMisc.<String, Object>toMap("invoiceId", invoiceId, "invoiceItemSeqId", invoiceItemSeqId,
"invoiceItemApplyAvailable", invoiceItemApplyAvailable,
"amountApplied", amountApplied, "isoCode", uomId), locale));
}
}
if (debug) Debug.logInfo("InvoiceItem info retrieved and checked against the Invoice (currency and amounts) ...", module);
}
}
// check this at the end because the invoice can change the currency.......
if (paymentApplicationId == null) {
// only check for new application records, update on existing records is checked in the paymentApplication section
if (paymentApplyAvailable.signum() == 0) {
errorMessageList.add(UtilProperties.getMessage(resource,
"AccountingPaymentAlreadyApplied", UtilMisc.toMap("paymentId", paymentId), locale));
} else {
// check here for too much application if a new record is
// added (paymentApplicationId == null)
if (amountApplied.compareTo(paymentApplyAvailable) > 0) {
errorMessageList.add(UtilProperties.getMessage(resource, "AccountingPaymentLessRequested",
UtilMisc.<String, Object>toMap("paymentId", paymentId,
"paymentApplyAvailable", paymentApplyAvailable,
"amountApplied", amountApplied,"isoCode", currencyUomId), locale));
}
}
}
// get the application record if the applicationId is supplied if not
// create empty record.
BigDecimal newInvoiceApplyAvailable = invoiceApplyAvailable;
// amount available on the invoice taking into account if the invoiceItemnumber has changed
BigDecimal newInvoiceItemApplyAvailable = invoiceItemApplyAvailable;
// amount available on the invoiceItem taking into account if the itemnumber has changed
BigDecimal newToPaymentApplyAvailable = toPaymentApplyAvailable;
BigDecimal newPaymentApplyAvailable = paymentApplyAvailable;
GenericValue paymentApplication = null;
if (paymentApplicationId == null) {
paymentApplication = delegator.makeValue("PaymentApplication");
// prepare for creation
} else { // retrieve existing paymentApplication
try {
paymentApplication = EntityQuery.use(delegator).from("PaymentApplication").where("paymentApplicationId", paymentApplicationId).queryOne();
} catch (GenericEntityException e) {
return ServiceUtil.returnError(e.getMessage());
}
if (paymentApplication == null) {
errorMessageList.add(UtilProperties.getMessage(resource,
"AccountingPaymentApplicationNotFound",
UtilMisc.toMap("paymentApplicationId", paymentApplicationId), locale));
paymentApplicationId = null;
} else {
// if both invoiceId and BillingId is entered there was
// obviously a change
// only take the newly entered item, same for tax authority and toPayment
if (paymentApplication.get("invoiceId") == null && invoiceId != null) {
billingAccountId = null;
taxAuthGeoId = null;
toPaymentId = null;
} else if (paymentApplication.get("toPaymentId") == null && toPaymentId != null) {
invoiceId = null;
invoiceItemSeqId = null;
taxAuthGeoId = null;
billingAccountId = null;
} else if (paymentApplication.get("billingAccountId") == null && billingAccountId != null) {
invoiceId = null;
invoiceItemSeqId = null;
toPaymentId = null;
taxAuthGeoId = null;
} else if (paymentApplication.get("taxAuthGeoId") == null && taxAuthGeoId != null) {
invoiceId = null;
invoiceItemSeqId = null;
toPaymentId = null;
billingAccountId = null;
}
// check if the payment for too much application if an existing
// application record is changed
if (paymentApplyAvailable.compareTo(ZERO) == 0) {
newPaymentApplyAvailable = paymentApplyAvailable.add(paymentApplication.getBigDecimal("amountApplied")).subtract(amountApplied).setScale(DECIMALS, ROUNDING);
} else {
newPaymentApplyAvailable = paymentApplyAvailable.add(paymentApplyAvailable).subtract(amountApplied).setScale(DECIMALS, ROUNDING);
}
if (newPaymentApplyAvailable.compareTo(ZERO) < 0) {
errorMessageList.add(UtilProperties.getMessage(resource,
"AccountingPaymentNotEnough",
UtilMisc.<String, Object>toMap("paymentId", paymentId,
"paymentApplyAvailable", paymentApplyAvailable.add(paymentApplication.getBigDecimal("amountApplied")),
"amountApplied", amountApplied), locale));
}
if (invoiceId != null) {
// only when we are processing an invoice on existing paymentApplication check invoice item for to much application if the invoice
// number did not change
if (invoiceId.equals(paymentApplication .getString("invoiceId"))) {
// check if both the itemNumbers are null then this is a
// record for the whole invoice
if (invoiceItemSeqId == null && paymentApplication.get("invoiceItemSeqId") == null) {
newInvoiceApplyAvailable = invoiceApplyAvailable.add(paymentApplication.getBigDecimal("amountApplied")).subtract(amountApplied).setScale(DECIMALS, ROUNDING);
if (invoiceApplyAvailable.compareTo(ZERO) < 0) {
errorMessageList.add(UtilProperties.getMessage(resource,
"AccountingInvoiceNotEnough",
UtilMisc.<String, Object>toMap("tooMuch", newInvoiceApplyAvailable.negate(),
"invoiceId", invoiceId), locale));
}
} else if (invoiceItemSeqId == null && paymentApplication.get("invoiceItemSeqId") != null) {
// check if the item number changed from a real Item number to a null value
newInvoiceApplyAvailable = invoiceApplyAvailable.add(paymentApplication.getBigDecimal("amountApplied")).subtract(amountApplied).setScale(DECIMALS, ROUNDING);
if (invoiceApplyAvailable.compareTo(ZERO) < 0) {
errorMessageList.add(UtilProperties.getMessage(resource,
"AccountingInvoiceNotEnough",
UtilMisc.<String, Object>toMap("tooMuch", newInvoiceApplyAvailable.negate(),
"invoiceId", invoiceId), locale));
}
} else if (invoiceItemSeqId != null && paymentApplication.get("invoiceItemSeqId") == null) {
// check if the item number changed from a null value to
// a real Item number
newInvoiceItemApplyAvailable = invoiceItemApplyAvailable.subtract(amountApplied).setScale(DECIMALS, ROUNDING);
if (newInvoiceItemApplyAvailable.compareTo(ZERO) < 0) {
errorMessageList.add(UtilProperties.getMessage(resource,
"AccountingItemInvoiceNotEnough",
UtilMisc.<String, Object>toMap("tooMuch", newInvoiceItemApplyAvailable.negate(),
"invoiceId", invoiceId,
"invoiceItemSeqId", invoiceItemSeqId), locale));
}
} else if (invoiceItemSeqId.equals(paymentApplication.getString("invoiceItemSeqId"))) {
// check if the real item numbers the same
// item number the same numeric value
newInvoiceItemApplyAvailable = invoiceItemApplyAvailable.add(paymentApplication.getBigDecimal("amountApplied")).subtract(amountApplied).setScale(DECIMALS, ROUNDING);
if (newInvoiceItemApplyAvailable.compareTo(ZERO) < 0) {
errorMessageList.add(UtilProperties.getMessage(resource,
"AccountingItemInvoiceNotEnough",
UtilMisc.<String, Object>toMap("tooMuch", newInvoiceItemApplyAvailable.negate(),
"invoiceId", invoiceId,
"invoiceItemSeqId", invoiceItemSeqId), locale));
}
} else {
// item number changed only check new item
newInvoiceItemApplyAvailable = invoiceItemApplyAvailable.add(amountApplied).setScale(DECIMALS, ROUNDING);
if (newInvoiceItemApplyAvailable.compareTo(ZERO) < 0) {
errorMessageList.add(UtilProperties.getMessage(resource,
"AccountingItemInvoiceNotEnough",
UtilMisc.<String, Object>toMap("tooMuch", newInvoiceItemApplyAvailable.negate(),
"invoiceId", invoiceId,
"invoiceItemSeqId", invoiceItemSeqId), locale));
}
}
// if the amountApplied = 0 give it the higest possible
// value
if (amountApplied.signum() == 0) {
if (newInvoiceItemApplyAvailable.compareTo(newPaymentApplyAvailable) < 0) {
amountApplied = newInvoiceItemApplyAvailable;
// from the item number
} else {
amountApplied = newPaymentApplyAvailable;
// from the payment
}
}
// check the invoice
newInvoiceApplyAvailable = invoiceApplyAvailable.add(paymentApplication.getBigDecimal("amountApplied").subtract(amountApplied)).setScale(DECIMALS, ROUNDING);
if (newInvoiceApplyAvailable.compareTo(ZERO) < 0) {
errorMessageList.add(UtilProperties.getMessage(resource,
"AccountingInvoiceNotEnough",
UtilMisc.<String, Object>toMap("tooMuch", invoiceApplyAvailable.add(paymentApplication.getBigDecimal("amountApplied")).subtract(amountApplied),
"invoiceId", invoiceId), locale));
}
}
}
// check the toPayment account when only the amountApplied has
// changed,
if (toPaymentId != null && toPaymentId.equals(paymentApplication.getString("toPaymentId"))) {
newToPaymentApplyAvailable = toPaymentApplyAvailable.subtract(paymentApplication.getBigDecimal("amountApplied")).add(amountApplied).setScale(DECIMALS, ROUNDING);
if (newToPaymentApplyAvailable.compareTo(ZERO) < 0) {
errorMessageList.add(UtilProperties.getMessage(resource,
"AccountingPaymentNotEnough",
UtilMisc.<String, Object>toMap("paymentId", toPaymentId,
"paymentApplyAvailable", newToPaymentApplyAvailable,
"amountApplied", amountApplied), locale));
}
} else if (toPaymentId != null) {
// billing account entered number has changed so we have to
// check the new billing account number.
newToPaymentApplyAvailable = toPaymentApplyAvailable.add(amountApplied).setScale(DECIMALS, ROUNDING);
if (newToPaymentApplyAvailable.compareTo(ZERO) < 0) {
errorMessageList.add(UtilProperties.getMessage(resource,
"AccountingPaymentNotEnough",
UtilMisc.<String, Object>toMap("paymentId", toPaymentId,
"paymentApplyAvailable", newToPaymentApplyAvailable,
"amountApplied", amountApplied), locale));
}
}
}
if (debug) Debug.logInfo("paymentApplication record info retrieved and checked...", module);
}
// show the maximumus what can be added in the payment application file.
String toMessage = null; // prepare for success message
if (debug) {
String extra = "";
if (invoiceItemSeqId != null) {
extra = " Invoice item(" + invoiceItemSeqId + ") amount not yet applied: " + newInvoiceItemApplyAvailable;
}
Debug.logInfo("checking finished, start processing with the following data... ", module);
if (invoiceId != null) {
Debug.logInfo(" Invoice(" + invoiceId + ") amount not yet applied: " + newInvoiceApplyAvailable + extra + " Payment(" + paymentId + ") amount not yet applied: " + newPaymentApplyAvailable + " Requested amount to apply:" + amountApplied, module);
toMessage = UtilProperties.getMessage(resource,
"AccountingApplicationToInvoice",
UtilMisc.toMap("invoiceId", invoiceId), locale);
if (extra.length() > 0) toMessage = UtilProperties.getMessage(resource,
"AccountingApplicationToInvoiceItem",
UtilMisc.toMap("invoiceId", invoiceId, "invoiceItemSeqId", invoiceItemSeqId), locale);
}
if (toPaymentId != null) {
Debug.logInfo(" toPayment(" + toPaymentId + ") amount not yet applied: " + newToPaymentApplyAvailable + " Payment(" + paymentId + ") amount not yet applied: " + newPaymentApplyAvailable + " Requested amount to apply:" + amountApplied, module);
toMessage = UtilProperties.getMessage(resource,
"AccountingApplicationToPayment",
UtilMisc.toMap("paymentId", toPaymentId), locale);
}
if (taxAuthGeoId != null) {
Debug.logInfo(" taxAuthGeoId(" + taxAuthGeoId + ") Payment(" + paymentId + ") amount not yet applied: " + newPaymentApplyAvailable + " Requested amount to apply:" + amountApplied, module);
toMessage = UtilProperties.getMessage(resource,
"AccountingApplicationToTax",
UtilMisc.toMap("taxAuthGeoId", taxAuthGeoId), locale);
}
}
// if the amount to apply was not provided or was zero fill it with the maximum possible and provide information to the user
if (amountApplied.signum() == 0 && useHighestAmount.equals("Y")) {
amountApplied = newPaymentApplyAvailable;
if (invoiceId != null && newInvoiceApplyAvailable.compareTo(amountApplied) < 0) {
amountApplied = newInvoiceApplyAvailable;
toMessage = UtilProperties.getMessage(resource,
"AccountingApplicationToInvoice",
UtilMisc.toMap("invoiceId", invoiceId), locale);
}
if (toPaymentId != null && newToPaymentApplyAvailable.compareTo(amountApplied) < 0) {
amountApplied = newToPaymentApplyAvailable;
toMessage = UtilProperties.getMessage(resource,
"AccountingApplicationToPayment",
UtilMisc.toMap("paymentId", toPaymentId), locale);
}
}
String successMessage = null;
if (amountApplied.signum() == 0) {
errorMessageList.add(UtilProperties.getMessage(resource, "AccountingNoAmount", locale));
} else {
successMessage = UtilProperties.getMessage(resource,
"AccountingApplicationSuccess",
UtilMisc.<String, Object>toMap("amountApplied", amountApplied,
"paymentId", paymentId,
"isoCode", currencyUomId,
"toMessage", toMessage), locale);
}
// report error messages if any
if (errorMessageList.size() > 0) {
return ServiceUtil.returnError(errorMessageList);
}
// ============ start processing ======================
// if the application is specified it is easy, update the existing record only
if (paymentApplicationId != null) {
// record is already retrieved previously
if (debug) Debug.logInfo("Process an existing paymentApplication record: " + paymentApplicationId, module);
// update the current record
paymentApplication.set("invoiceId", invoiceId);
paymentApplication.set("invoiceItemSeqId", invoiceItemSeqId);
paymentApplication.set("paymentId", paymentId);
paymentApplication.set("toPaymentId", toPaymentId);
paymentApplication.set("amountApplied", amountApplied);
paymentApplication.set("billingAccountId", billingAccountId);
paymentApplication.set("taxAuthGeoId", taxAuthGeoId);
return storePaymentApplication(delegator, paymentApplication,locale);
}
// if no invoice sequence number is provided it assumed the requested paymentAmount will be
// spread over the invoice starting with the lowest sequence number if
// itemprocessing is on otherwise create one record
if (invoiceId != null && paymentId != null && (invoiceItemSeqId == null)) {
if (invoiceProcessing) {
// create only a single record with a null seqId
if (debug) Debug.logInfo("Try to allocate the payment to the invoice as a whole", module);
paymentApplication.set("paymentId", paymentId);
paymentApplication.set("toPaymentId",null);
paymentApplication.set("invoiceId", invoiceId);
paymentApplication.set("invoiceItemSeqId", null);
paymentApplication.set("toPaymentId", null);
paymentApplication.set("amountApplied", amountApplied);
paymentApplication.set("billingAccountId", billingAccountId);
paymentApplication.set("taxAuthGeoId", null);
if (debug) Debug.logInfo("creating new paymentapplication", module);
return storePaymentApplication(delegator, paymentApplication,locale);
} else { // spread the amount over every single item number
if (debug) Debug.logInfo("Try to allocate the payment to the itemnumbers of the invoice", module);
// get the invoice items
List<GenericValue> invoiceItems = null;
try {
invoiceItems = EntityQuery.use(delegator).from("InvoiceItem").where("invoiceId", invoiceId).queryList();
} catch (GenericEntityException e) {
return ServiceUtil.returnError(e.getMessage());
}
if (invoiceItems.size() == 0) {
errorMessageList.add(UtilProperties.getMessage(resource, "AccountingNoInvoiceItemsFoundForInvoice", UtilMisc.toMap("invoiceId", invoiceId), locale));
return ServiceUtil.returnError(errorMessageList);
} else { // we found some invoice items, start processing....
// check if the user want to apply a smaller amount than the maximum possible on the payment
if (amountApplied.signum() != 0 && amountApplied.compareTo(paymentApplyAvailable) < 0) {
paymentApplyAvailable = amountApplied;
}
for (GenericValue currentInvoiceItem : invoiceItems) {
if (paymentApplyAvailable.compareTo(ZERO) > 0) {
break;
}
if (debug) Debug.logInfo("Start processing item: " + currentInvoiceItem.getString("invoiceItemSeqId"), module);
BigDecimal itemQuantity = BigDecimal.ONE;
if (currentInvoiceItem.get("quantity") != null && currentInvoiceItem.getBigDecimal("quantity").signum() != 0) {
itemQuantity = new BigDecimal(currentInvoiceItem.getString("quantity")).setScale(DECIMALS,ROUNDING);
}
BigDecimal itemAmount = currentInvoiceItem.getBigDecimal("amount").setScale(DECIMALS,ROUNDING);
BigDecimal itemTotal = itemAmount.multiply(itemQuantity).setScale(DECIMALS,ROUNDING);
// get the application(s) already allocated to this
// item, if available
List<GenericValue> paymentApplications = null;
try {
paymentApplications = currentInvoiceItem.getRelated("PaymentApplication", null, null, false);
} catch (GenericEntityException e) {
return ServiceUtil.returnError(e.getMessage());
}
BigDecimal tobeApplied = ZERO;
// item total amount - already applied (if any)
BigDecimal alreadyApplied = ZERO;
if (UtilValidate.isNotEmpty(paymentApplications)) {
// application(s) found, add them all together
Iterator<GenericValue> p = paymentApplications.iterator();
while (p.hasNext()) {
paymentApplication = p.next();
alreadyApplied = alreadyApplied.add(paymentApplication.getBigDecimal("amountApplied").setScale(DECIMALS,ROUNDING));
}
tobeApplied = itemTotal.subtract(alreadyApplied).setScale(DECIMALS,ROUNDING);
} else {
// no application connected yet
tobeApplied = itemTotal;
}
if (debug) Debug.logInfo("tobeApplied:(" + tobeApplied + ") = " + "itemTotal(" + itemTotal + ") - alreadyApplied(" + alreadyApplied + ") but not more then (nonapplied) paymentAmount(" + paymentApplyAvailable + ")", module);
if (tobeApplied.signum() == 0) {
// invoiceItem already fully applied so look at the next one....
continue;
}
if (paymentApplyAvailable.compareTo(tobeApplied) > 0) {
paymentApplyAvailable = paymentApplyAvailable.subtract(tobeApplied);
} else {
tobeApplied = paymentApplyAvailable;
paymentApplyAvailable = ZERO;
}
// create application payment record but check currency
// first if supplied
if (invoice.get("currencyUomId") != null && currencyUomId != null && !invoice.getString("currencyUomId").equals(currencyUomId)) {
errorMessageList.add("Payment currency (" + currencyUomId + ") and invoice currency(" + invoice.getString("currencyUomId") + ") not the same\n");
} else {
paymentApplication.set("paymentApplicationId", null);
// make sure we get a new record
paymentApplication.set("invoiceId", invoiceId);
paymentApplication.set("invoiceItemSeqId", currentInvoiceItem.getString("invoiceItemSeqId"));
paymentApplication.set("paymentId", paymentId);
paymentApplication.set("toPaymentId", toPaymentId);
paymentApplication.set("amountApplied", tobeApplied);
paymentApplication.set("billingAccountId", billingAccountId);
paymentApplication.set("taxAuthGeoId", taxAuthGeoId);
storePaymentApplication(delegator, paymentApplication,locale);
}
}
if (errorMessageList.size() > 0) {
return ServiceUtil.returnError(errorMessageList);
} else {
if (successMessage != null) {
return ServiceUtil.returnSuccess(successMessage);
}
else {
return ServiceUtil.returnSuccess();
}
}
}
}
}
// if no paymentApplicationId supplied create a new record with the data
// supplied...
if (paymentApplicationId == null && amountApplied != null) {
paymentApplication.set("paymentApplicationId", paymentApplicationId);
paymentApplication.set("invoiceId", invoiceId);
paymentApplication.set("invoiceItemSeqId", invoiceItemSeqId);
paymentApplication.set("paymentId", paymentId);
paymentApplication.set("toPaymentId", toPaymentId);
paymentApplication.set("amountApplied", amountApplied);
paymentApplication.set("billingAccountId", billingAccountId);
paymentApplication.set("taxAuthGeoId", taxAuthGeoId);
return storePaymentApplication(delegator, paymentApplication,locale);
}
// should never come here...
errorMessageList.add(UtilProperties.getMessage(resource, "AccountingPaymentApplicationParameterUnsuitable", locale));
errorMessageList.add(UtilProperties.getMessage(resource, "AccountingPaymentApplicationParameterListUnsuitable", UtilMisc.toMap("invoiceId", invoiceId, "invoiceItemSeqId", invoiceItemSeqId, "paymentId", paymentId, "toPaymentId", toPaymentId, "paymentApplicationId", paymentApplicationId, "amountApplied", amountApplied), locale));
return ServiceUtil.returnError(errorMessageList);
}
public static Map<String, Object> calculateInvoicedAdjustmentTotal(DispatchContext dctx, Map<String, Object> context) {
Delegator delegator = dctx.getDelegator();
Locale locale = (Locale) context.get("locale");
GenericValue orderAdjustment = (GenericValue) context.get("orderAdjustment");
Map<String, Object> result = ServiceUtil.returnSuccess();
BigDecimal invoicedTotal = ZERO;
List<GenericValue> invoicedAdjustments = null;
try {
invoicedAdjustments = EntityQuery.use(delegator).from("OrderAdjustmentBilling").where("orderAdjustmentId", orderAdjustment.get("orderAdjustmentId")).queryList();
} catch (GenericEntityException e) {
Debug.logError(e, "Accounting trouble calling calculateInvoicedAdjustmentTotal service", module);
return ServiceUtil.returnError(UtilProperties.getMessage(resource,
"AccountingTroubleCallingCalculateInvoicedAdjustmentTotalService" + ": " + e.getMessage(), locale));
}
for (GenericValue invoicedAdjustment : invoicedAdjustments) {
invoicedTotal = invoicedTotal.add(invoicedAdjustment.getBigDecimal("amount").setScale(DECIMALS, ROUNDING));
}
result.put("invoicedTotal", invoicedTotal);
return result;
}
/**
* Update/add to the paymentApplication table and making sure no duplicate
* record exist
*
* @param delegator
* @param paymentApplication
* @return map results
*/
private static Map<String, Object> storePaymentApplication(Delegator delegator, GenericValue paymentApplication,Locale locale) {
Map<String, Object> results = ServiceUtil.returnSuccess(UtilProperties.getMessage(resource,
"AccountingSuccessful", locale));
boolean debug = true;
if (debug) Debug.logInfo("Start updating the paymentApplication table ", module);
if (DECIMALS == -1 || ROUNDING == -1) {
return ServiceUtil.returnError(UtilProperties.getMessage(resource,
"AccountingAritmeticPropertiesNotConfigured", locale));
}
// check if a record already exists with this data
List<GenericValue> checkAppls = null;
try {
checkAppls = EntityQuery.use(delegator).from("PaymentApplication")
.where("invoiceId", paymentApplication.get("invoiceId"),
"invoiceItemSeqId", paymentApplication.get("invoiceItemSeqId"),
"billingAccountId", paymentApplication.get("billingAccountId"),
"paymentId", paymentApplication.get("paymentId"),
"toPaymentId", paymentApplication.get("toPaymentId"),
"taxAuthGeoId", paymentApplication.get("taxAuthGeoId"))
.queryList();
} catch (GenericEntityException e) {
return ServiceUtil.returnError(e.getMessage());
}
if (checkAppls.size() > 0) {
if (debug) Debug.logInfo(checkAppls.size() + " records already exist", module);
// 1 record exists just update and if different ID delete other record and add together.
GenericValue checkAppl = checkAppls.get(0);
// if new record add to the already existing one.
if (paymentApplication.get("paymentApplicationId") == null) {
// add 2 amounts together
checkAppl.set("amountApplied", paymentApplication.getBigDecimal("amountApplied").
add(checkAppl.getBigDecimal("amountApplied")).setScale(DECIMALS,ROUNDING));
if (debug) Debug.logInfo("Update paymentApplication record: " + checkAppl.getString("paymentApplicationId") + " with appliedAmount:" + checkAppl.getBigDecimal("amountApplied"), module);
try {
checkAppl.store();
} catch (GenericEntityException e) {
return ServiceUtil.returnError(e.getMessage());
}
} else if (paymentApplication.getString("paymentApplicationId").equals(checkAppl.getString("paymentApplicationId"))) {
// update existing record in-place
checkAppl.set("amountApplied", paymentApplication.getBigDecimal("amountApplied"));
if (debug) Debug.logInfo("Update paymentApplication record: " + checkAppl.getString("paymentApplicationId") + " with appliedAmount:" + checkAppl.getBigDecimal("amountApplied"), module);
try {
checkAppl.store();
} catch (GenericEntityException e) {
return ServiceUtil.returnError(e.getMessage());
}
} else { // two existing records, an updated one added to the existing one
// add 2 amounts together
checkAppl.set("amountApplied", paymentApplication.getBigDecimal("amountApplied").
add(checkAppl.getBigDecimal("amountApplied")).setScale(DECIMALS,ROUNDING));
// delete paymentApplication record and update the checkAppls one.
if (debug) Debug.logInfo("Delete paymentApplication record: " + paymentApplication.getString("paymentApplicationId") + " with appliedAmount:" + paymentApplication.getBigDecimal("amountApplied"), module);
try {
paymentApplication.remove();
} catch (GenericEntityException e) {
return ServiceUtil.returnError(e.getMessage());
}
// update amount existing record
if (debug) Debug.logInfo("Update paymentApplication record: " + checkAppl.getString("paymentApplicationId") + " with appliedAmount:" + checkAppl.getBigDecimal("amountApplied"), module);
try {
checkAppl.store();
} catch (GenericEntityException e) {
return ServiceUtil.returnError(e.getMessage());
}
}
} else {
if (debug) Debug.logInfo("No records found with paymentId,invoiceid..etc probaly changed one of them...", module);
// create record if ID null;
if (paymentApplication.get("paymentApplicationId") == null) {
paymentApplication.set("paymentApplicationId", delegator.getNextSeqId("PaymentApplication"));
if (debug) Debug.logInfo("Create new paymentAppication record: " + paymentApplication.getString("paymentApplicationId") + " with appliedAmount:" + paymentApplication.getBigDecimal("amountApplied"), module);
try {
paymentApplication.create();
} catch (GenericEntityException e) {
return ServiceUtil.returnError(e.getMessage());
}
} else {
// update existing record (could not be found because a non existing combination of paymentId/invoiceId/invoiceSeqId/ etc... was provided
if (debug) Debug.logInfo("Update existing paymentApplication record: " + paymentApplication.getString("paymentApplicationId") + " with appliedAmount:" + paymentApplication.getBigDecimal("amountApplied"), module);
try {
paymentApplication.store();
} catch (GenericEntityException e) {
return ServiceUtil.returnError(e.getMessage());
}
}
}
return results;
}
public static Map<String, Object> checkPaymentInvoices(DispatchContext dctx, Map<String, Object> context) {
Delegator delegator = dctx.getDelegator();
LocalDispatcher dispatcher = dctx.getDispatcher();
GenericValue userLogin = (GenericValue) context.get("userLogin");
String paymentId = (String) context.get("paymentId");
try {
GenericValue payment = EntityQuery.use(delegator).from("Payment").where("paymentId", paymentId).queryOne();
if (payment == null) throw new GenericServiceException("Payment with ID [" + paymentId + "] not found!");
List<GenericValue> paymentApplications = payment.getRelated("PaymentApplication", null, null, false);
if (UtilValidate.isEmpty(paymentApplications)) return ServiceUtil.returnSuccess();
// TODO: this is inefficient -- instead use HashSet to construct a distinct Set of invoiceIds, then iterate over it and call checkInvoicePaymentAppls
for (GenericValue paymentApplication : paymentApplications) {
String invoiceId = paymentApplication.getString("invoiceId");
if (invoiceId != null) {
Map<String, Object> serviceResult = dispatcher.runSync("checkInvoicePaymentApplications", UtilMisc.<String, Object>toMap("invoiceId", invoiceId, "userLogin", userLogin));
if (ServiceUtil.isError(serviceResult)) return serviceResult;
}
}
return ServiceUtil.returnSuccess();
} catch (GenericServiceException se) {
Debug.logError(se, se.getMessage(), module);
return ServiceUtil.returnError(se.getMessage());
} catch (GenericEntityException ee) {
Debug.logError(ee, ee.getMessage(), module);
return ServiceUtil.returnError(ee.getMessage());
}
}
public static Map<String, Object> importInvoice(DispatchContext dctx, Map<String, Object> context) {
Locale locale = (Locale) context.get("locale");
Delegator delegator = dctx.getDelegator();
LocalDispatcher dispatcher = dctx.getDispatcher();
GenericValue userLogin = (GenericValue) context.get("userLogin");
ByteBuffer fileBytes = (ByteBuffer) context.get("uploadedFile");
String organizationPartyId = (String) context.get("organizationPartyId");
String encoding = System.getProperty("file.encoding");
String csvString = Charset.forName(encoding).decode(fileBytes).toString();
final BufferedReader csvReader = new BufferedReader(new StringReader(csvString));
CSVFormat fmt = CSVFormat.DEFAULT.withHeader();
List<String> errMsgs = new LinkedList<String>();
List<String> newErrMsgs = new LinkedList<String>();
String lastInvoiceId = null;
String currentInvoiceId = null;
String newInvoiceId = null;
int invoicesCreated = 0;
if (fileBytes == null) {
return ServiceUtil.returnError(UtilProperties.getMessage(resource, "AccountingUploadedFileDataNotFound", locale));
}
try {
for (final CSVRecord rec : fmt.parse(csvReader)) {
currentInvoiceId = rec.get("invoiceId");
if (lastInvoiceId == null || !currentInvoiceId.equals(lastInvoiceId)) {
newInvoiceId = null;
Map<String, Object> invoice = UtilMisc.toMap(
"invoiceTypeId", rec.get("invoiceTypeId"),
"partyIdFrom", rec.get("partyIdFrom"),
"partyId", rec.get("partyId"),
"invoiceDate", rec.get("invoiceDate"),
"dueDate", rec.get("dueDate"),
"currencyUomId", rec.get("currencyUomId"),
"description", rec.get("description"),
"referenceNumber", rec.get("referenceNumber") + " Imported: orginal InvoiceId: " + currentInvoiceId,
"userLogin", userLogin
);
// replace values if required
if (UtilValidate.isNotEmpty(rec.get("partyIdFromTrans"))) {
invoice.put("partyIdFrom", rec.get("partyIdFromTrans"));
}
if (UtilValidate.isNotEmpty(rec.get("partyIdTrans"))) {
invoice.put("partyId", rec.get("partyIdTrans"));
}
// invoice validation
try {
newErrMsgs = new LinkedList<String>();
if (UtilValidate.isEmpty(invoice.get("partyIdFrom"))) {
newErrMsgs.add("Line number " + rec.getRecordNumber() + ": Mandatory Party Id From and Party Id From Trans missing for invoice: " + currentInvoiceId);
} else if (EntityQuery.use(delegator).from("Party").where("partyId", invoice.get("partyIdFrom")).queryOne() == null) {
newErrMsgs.add("Line number " + rec.getRecordNumber() + ": partyIdFrom: " + invoice.get("partyIdFrom") + " not found for invoice: " + currentInvoiceId);
}
if (UtilValidate.isEmpty(invoice.get("partyId"))) {
newErrMsgs.add("Line number " + rec.getRecordNumber() + ": Mandatory Party Id and Party Id Trans missing for invoice: " + currentInvoiceId);
} else if (EntityQuery.use(delegator).from("Party").where("partyId", invoice.get("partyId")).queryOne() == null) {
newErrMsgs.add("Line number " + rec.getRecordNumber() + ": partyId: " + invoice.get("partyId") + " not found for invoice: " + currentInvoiceId);
}
if (UtilValidate.isEmpty(invoice.get("invoiceTypeId"))) {
newErrMsgs.add("Line number " + rec.getRecordNumber() + ": Mandatory Invoice Type missing for invoice: " + currentInvoiceId);
} else if (EntityQuery.use(delegator).from("InvoiceType").where("invoiceTypeId", invoice.get("invoiceTypeId")).queryOne() == null) {
newErrMsgs.add("Line number " + rec.getRecordNumber() + ": InvoiceItem type id: " + invoice.get("invoiceTypeId") + " not found for invoice: " + currentInvoiceId);
}
Boolean isPurchaseInvoice = EntityTypeUtil.hasParentType(delegator, "InvoiceType", "invoiceTypeId", (String) invoice.get("invoiceTypeId"), "parentTypeId", "PURCHASE_INVOICE");
Boolean isSalesInvoice = EntityTypeUtil.hasParentType(delegator, "InvoiceType", "invoiceTypeId", (String) invoice.get("invoiceTypeId"), "parentTypeId", "SALES_INVOICE");
if (isPurchaseInvoice && !invoice.get("partyId").equals(organizationPartyId)) {
newErrMsgs.add("Line number " + rec.getRecordNumber() + ": A purchase type invoice should have the partyId 'To' being the organizationPartyId(=" + organizationPartyId + ")! however is " + invoice.get("partyId") +"! invoice: " + currentInvoiceId);
}
if (isSalesInvoice && !invoice.get("partyIdFrom").equals(organizationPartyId)) {
newErrMsgs.add("Line number " + rec.getRecordNumber() + ": A sales type invoice should have the partyId 'from' being the organizationPartyId(=" + organizationPartyId + ")! however is " + invoice.get("partyIdFrom") +"! invoice: " + currentInvoiceId);
}
} catch (GenericEntityException e) {
Debug.logError("Valication checking problem against database. due to " + e.getMessage(), module);
}
if (newErrMsgs.size() > 0) {
errMsgs.addAll(newErrMsgs);
} else {
Map<String, Object> invoiceResult = null;
try {
invoiceResult = dispatcher.runSync("createInvoice", invoice);
} catch (GenericServiceException e) {
csvReader.close();
Debug.logError(e, module);
return ServiceUtil.returnError(e.getMessage());
}
newInvoiceId = (String) invoiceResult.get("invoiceId");
invoicesCreated++;
}
lastInvoiceId = currentInvoiceId;
}
if (newInvoiceId != null) {
Map<String, Object> invoiceItem = UtilMisc.toMap(
"invoiceId", newInvoiceId,
"invoiceItemSeqId", rec.get("invoiceItemSeqId"),
"invoiceItemTypeId", rec.get("invoiceItemTypeId"),
"productId", rec.get("productId"),
"description", rec.get("itemDescription"),
"amount", rec.get("amount"),
"quantity", rec.get("quantity"),
"userLogin", userLogin
);
if (UtilValidate.isNotEmpty(rec.get("productIdTrans"))) {
invoiceItem.put("productId", rec.get("productIdTrans"));
}
// invoice item validation
try {
newErrMsgs = new LinkedList<String>();
if (UtilValidate.isEmpty(invoiceItem.get("invoiceItemSeqId"))) {
newErrMsgs.add("Line number " + rec.getRecordNumber() + ": Mandatory item sequence Id missing for invoice: " + currentInvoiceId);
}
if (UtilValidate.isEmpty(invoiceItem.get("invoiceItemTypeId"))) {
newErrMsgs.add("Line number " + rec.getRecordNumber() + ": Mandatory invoice item type missing for invoice: " + currentInvoiceId);
} else if (EntityQuery.use(delegator).from("InvoiceItemType").where("invoiceItemTypeId", invoiceItem.get("invoiceItemTypeId")).queryOne() == null) {
newErrMsgs.add("Line number " + rec.getRecordNumber() + ": InvoiceItem Item type id: " + invoiceItem.get("invoiceItemTypeId") + " not found for invoice: " + currentInvoiceId + " Item seqId:" + invoiceItem.get("invoiceItemSeqId"));
}
if (UtilValidate.isEmpty(invoiceItem.get("productId")) && UtilValidate.isEmpty(invoiceItem.get("description"))) {
}
if (UtilValidate.isNotEmpty(invoiceItem.get("productId")) && EntityQuery.use(delegator).from("Product").where("productId", invoiceItem.get("productId")).queryOne() == null) {
newErrMsgs.add("Line number " + rec.getRecordNumber() + ": Product Id: " + invoiceItem.get("productId") + " not found for invoice: " + currentInvoiceId + " Item seqId:" + invoiceItem.get("invoiceItemSeqId"));
}
if (UtilValidate.isEmpty(invoiceItem.get("amount")) && UtilValidate.isEmpty(invoiceItem.get("quantity"))) {
newErrMsgs.add("Line number " + rec.getRecordNumber() + ": Either or both quantity and amount is required for invoice: " + currentInvoiceId + " Item seqId:" + invoiceItem.get("invoiceItemSeqId"));
}
} catch (GenericEntityException e) {
Debug.logError("Validation checking problem against database. due to " + e.getMessage(), module);
}
if (newErrMsgs.size() > 0) {
errMsgs.addAll(newErrMsgs);
} else {
try {
dispatcher.runSync("createInvoiceItem", invoiceItem);
} catch (GenericServiceException e) {
csvReader.close();
Debug.logError(e, module);
return ServiceUtil.returnError(e.getMessage());
}
}
}
}
} catch (IOException e) {
Debug.logError(e, module);
return ServiceUtil.returnError(e.getMessage());
}
if (errMsgs.size() > 0) {
return ServiceUtil.returnError(errMsgs);
}
Map<String, Object> result = ServiceUtil.returnSuccess(UtilProperties.getMessage(resource, "AccountingNewInvoicesCreated", UtilMisc.toMap("invoicesCreated", invoicesCreated), locale));
result.put("organizationPartyId", organizationPartyId);
return result;
}
}