/*******************************************************************************
* 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.math.BigDecimal;
import java.math.MathContext;
import java.sql.Timestamp;
import java.util.HashMap;
import java.util.HashSet;
import java.util.LinkedList;
import java.util.List;
import java.util.Map;
import java.util.Set;
import org.apache.ofbiz.base.util.Debug;
import org.apache.ofbiz.base.util.UtilDateTime;
import org.apache.ofbiz.base.util.UtilMisc;
import org.apache.ofbiz.base.util.UtilNumber;
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.EntityConditionList;
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.EntityUtil;
import org.apache.ofbiz.entity.util.EntityUtilProperties;
/**
* InvoiceWorker - Worker methods of invoices
*/
public final class InvoiceWorker {
public static final String module = InvoiceWorker.class.getName();
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 taxDecimals = UtilNumber.getBigDecimalScale("salestax.calc.decimals");
private static final int taxRounding = UtilNumber.getBigDecimalRoundingMode("salestax.rounding");
private InvoiceWorker () {}
/**
* Return the total amount of the invoice (including tax) using the the invoiceId as input.
* @param delegator the delegator
* @param invoiceId the invoice id
* @return Return the total amount of the invoice
*/
public static BigDecimal getInvoiceTotal(Delegator delegator, String invoiceId) {
return getInvoiceTotal(delegator, invoiceId, Boolean.TRUE);
}
/**
* Return the total amount of the invoice (including tax) using the the invoiceId as input.
* with the ability to specify if the actual currency is required.
* @param delegator the delegator
* @param invoiceId the invoice Id
* @param actualCurrency true: provide the actual currency of the invoice (could be different from the system currency)
* false: if required convert the actual currency into the system currency.
* @return Return the total amount of the invoice
*/
public static BigDecimal getInvoiceTotal(Delegator delegator, String invoiceId, Boolean actualCurrency) {
if (delegator == null) {
throw new IllegalArgumentException("Null delegator is not allowed in this method");
}
GenericValue invoice = null;
try {
invoice = EntityQuery.use(delegator).from("Invoice").where("invoiceId", invoiceId).queryOne();
} catch (GenericEntityException e) {
Debug.logError(e, "Problem getting Invoice", module);
}
if (invoice == null) {
throw new IllegalArgumentException("The passed invoiceId [" +invoiceId + "] does not match an existing invoice");
}
return getInvoiceTotal(invoice, actualCurrency);
}
/**
* Method to return the total amount of an invoice item i.e. quantity * amount
* @param invoiceItem GenericValue object of the invoice item
* @return the invoice total as BigDecimal
*/
public static BigDecimal getInvoiceItemTotal(GenericValue invoiceItem) {
BigDecimal quantity = invoiceItem.getBigDecimal("quantity");
if (quantity == null) {
quantity = BigDecimal.ONE;
}
BigDecimal amount = invoiceItem.getBigDecimal("amount");
if (amount == null) {
amount = ZERO;
}
return quantity.multiply(amount).setScale(decimals, rounding);
}
/** Method to get the taxable invoice item types as a List of invoiceItemTypeIds. These are identified in Enumeration with enumTypeId TAXABLE_INV_ITM_TY. */
public static List<String> getTaxableInvoiceItemTypeIds(Delegator delegator) throws GenericEntityException {
List<String> typeIds = new LinkedList<String>();
List<GenericValue> invoiceItemTaxTypes = EntityQuery.use(delegator).from("Enumeration").where("enumTypeId", "TAXABLE_INV_ITM_TY")
.cache().queryList();
for (GenericValue invoiceItemTaxType : invoiceItemTaxTypes) {
typeIds.add(invoiceItemTaxType.getString("enumId"));
}
return typeIds;
}
public static BigDecimal getInvoiceTaxTotal(GenericValue invoice) {
BigDecimal taxTotal = ZERO;
Map<String, Set<String>> taxAuthPartyAndGeos = InvoiceWorker.getInvoiceTaxAuthPartyAndGeos(invoice);
for (Map.Entry<String, Set<String>> taxAuthPartyGeos : taxAuthPartyAndGeos.entrySet()) {
String taxAuthPartyId = taxAuthPartyGeos.getKey();
for (String taxAuthGeoId : taxAuthPartyGeos.getValue()) {
taxTotal = taxTotal.add(InvoiceWorker.getInvoiceTaxTotalForTaxAuthPartyAndGeo(invoice, taxAuthPartyId, taxAuthGeoId));
}
}
taxTotal = taxTotal.add(InvoiceWorker.getInvoiceUnattributedTaxTotal(invoice));
return taxTotal;
}
public static BigDecimal getInvoiceNoTaxTotal(GenericValue invoice) {
return getInvoiceTotal(invoice, Boolean.TRUE).subtract(getInvoiceTaxTotal(invoice));
}
/**
* Method to return the total amount of an invoice
* @param invoice GenericValue object of the Invoice
* @return the invoice total as BigDecimal
*/
public static BigDecimal getInvoiceTotal(GenericValue invoice) {
return getInvoiceTotal(invoice, Boolean.TRUE);
}
/**
*
* Return the total amount of the invoice (including tax) using the the invoice GenericValue as input.
* with the ability to specify if the actual currency is required.
* @param invoice GenericValue object of the Invoice
* @param actualCurrency true: provide the actual currency of the invoice (could be different from the system currency)
* false: if required convert the actual currency into the system currency.
* @return Return the total amount of the invoice
*/
public static BigDecimal getInvoiceTotal(GenericValue invoice, Boolean actualCurrency) {
BigDecimal invoiceTotal = ZERO;
BigDecimal invoiceTaxTotal = ZERO;
invoiceTaxTotal = InvoiceWorker.getInvoiceTaxTotal(invoice);
List<GenericValue> invoiceItems = null;
try {
invoiceItems = invoice.getRelated("InvoiceItem", null, null, false);
invoiceItems = EntityUtil.filterByAnd(
invoiceItems, UtilMisc.toList(
EntityCondition.makeCondition("invoiceItemTypeId", EntityOperator.NOT_IN, getTaxableInvoiceItemTypeIds(invoice.getDelegator()))
));
} catch (GenericEntityException e) {
Debug.logError(e, "Trouble getting InvoiceItem list", module);
}
if (invoiceItems != null) {
for (GenericValue invoiceItem : invoiceItems) {
invoiceTotal = invoiceTotal.add(getInvoiceItemTotal(invoiceItem)).setScale(decimals,rounding);
}
}
invoiceTotal = invoiceTotal.add(invoiceTaxTotal).setScale(decimals, rounding);
if (UtilValidate.isNotEmpty(invoiceTotal) && !actualCurrency) {
invoiceTotal = invoiceTotal.multiply(getInvoiceCurrencyConversionRate(invoice)).setScale(decimals,rounding);
}
return invoiceTotal;
}
/**
* Method to obtain the bill to party for an invoice. Note that invoice.partyId is the bill to party.
* @param invoice GenericValue object of the Invoice
* @return GenericValue object of the Party
*/
public static GenericValue getBillToParty(GenericValue invoice) {
try {
GenericValue billToParty = invoice.getRelatedOne("Party", false);
if (billToParty != null) {
return billToParty;
}
} catch (GenericEntityException e) {
Debug.logError(e, "Trouble getting Party from Invoice", module);
}
// remaining code is the old method, which we leave here for compatibility purposes
List<GenericValue> billToRoles = null;
try {
billToRoles = invoice.getRelated("InvoiceRole", UtilMisc.toMap("roleTypeId", "BILL_TO_CUSTOMER"), UtilMisc.toList("-datetimePerformed"), false);
} catch (GenericEntityException e) {
Debug.logError(e, "Trouble getting InvoiceRole list", module);
}
if (billToRoles != null) {
GenericValue role = EntityUtil.getFirst(billToRoles);
GenericValue party = null;
try {
party = role.getRelatedOne("Party", false);
} catch (GenericEntityException e) {
Debug.logError(e, "Trouble getting Party from InvoiceRole", module);
}
if (party != null)
return party;
}
return null;
}
/** Convenience method to obtain the bill from party for an invoice. Note that invoice.partyIdFrom is the bill from party. */
public static GenericValue getBillFromParty(GenericValue invoice) {
try {
return invoice.getRelatedOne("FromParty", false);
} catch (GenericEntityException e) {
Debug.logError(e, "Trouble getting FromParty from Invoice", module);
}
return null;
}
/**
* Method to obtain the send from party for an invoice
* @param invoice GenericValue object of the Invoice
* @return GenericValue object of the Party
*/
public static GenericValue getSendFromParty(GenericValue invoice) {
GenericValue billFromParty = getBillFromParty(invoice);
if (billFromParty != null) {
return billFromParty;
}
// remaining code is the old method, which we leave here for compatibility purposes
List<GenericValue> sendFromRoles = null;
try {
sendFromRoles = invoice.getRelated("InvoiceRole", UtilMisc.toMap("roleTypeId", "BILL_FROM_VENDOR"), UtilMisc.toList("-datetimePerformed"), false);
} catch (GenericEntityException e) {
Debug.logError(e, "Trouble getting InvoiceRole list", module);
}
if (sendFromRoles != null) {
GenericValue role = EntityUtil.getFirst(sendFromRoles);
GenericValue party = null;
try {
party = role.getRelatedOne("Party", false);
} catch (GenericEntityException e) {
Debug.logError(e, "Trouble getting Party from InvoiceRole", module);
}
if (party != null)
return party;
}
return null;
}
/**
* Method to obtain the billing address for an invoice
* @param invoice GenericValue object of the Invoice
* @return GenericValue object of the PostalAddress
*/
public static GenericValue getBillToAddress(GenericValue invoice) {
return getInvoiceAddressByType(invoice, "BILLING_LOCATION");
}
/**
* Method to obtain the sending address for an invoice
* @param invoice GenericValue object of the Invoice
* @return GenericValue object of the PostalAddress
*/
public static GenericValue getSendFromAddress(GenericValue invoice) {
return getInvoiceAddressByType(invoice, "PAYMENT_LOCATION");
}
public static GenericValue getInvoiceAddressByType(GenericValue invoice, String contactMechPurposeTypeId) {
return getInvoiceAddressByType(invoice, contactMechPurposeTypeId, true);
}
public static GenericValue getInvoiceAddressByType(GenericValue invoice, String contactMechPurposeTypeId, boolean fetchPartyAddress) {
Delegator delegator = invoice.getDelegator();
List<GenericValue> locations = null;
// first try InvoiceContactMech to see if we can find the address needed
try {
locations = invoice.getRelated("InvoiceContactMech", UtilMisc.toMap("contactMechPurposeTypeId", contactMechPurposeTypeId), null, false);
} catch (GenericEntityException e) {
Debug.logError("Touble getting InvoiceContactMech entity list", module);
}
if (UtilValidate.isEmpty(locations) && fetchPartyAddress) {
// if no locations found get it from the PartyAndContactMech using the from and to party on the invoice
String destinationPartyId = null;
Timestamp now = UtilDateTime.nowTimestamp();
if (invoice.getString("invoiceTypeId").equals("SALES_INVOICE"))
destinationPartyId = invoice.getString("partyId");
if (invoice.getString("invoiceTypeId").equals("PURCHASE_INVOICE"))
destinationPartyId = invoice.getString("partyId");
try {
locations = EntityQuery.use(delegator).from("PartyContactWithPurpose")
.where("partyId", destinationPartyId, "contactMechPurposeTypeId", contactMechPurposeTypeId).queryList();
locations = EntityUtil.filterByDate(locations, now, "contactFromDate", "contactThruDate", true);
locations = EntityUtil.filterByDate(locations, now, "purposeFromDate", "purposeThruDate", true);
} catch (GenericEntityException e) {
Debug.logError("Trouble getting contact party purpose list", module);
}
//if still not found get it from the general location
if (UtilValidate.isEmpty(locations)) {
try {
locations = EntityQuery.use(delegator).from("PartyContactWithPurpose")
.where("partyId", destinationPartyId, "contactMechPurposeTypeId", "GENERAL_LOCATION").queryList();
locations = EntityUtil.filterByDate(locations, now, "contactFromDate", "contactThruDate", true);
locations = EntityUtil.filterByDate(locations, now, "purposeFromDate", "purposeThruDate", true);
} catch (GenericEntityException e) {
Debug.logError("Trouble getting contact party purpose list", module);
}
}
}
// now return the first PostalAddress from the locations
GenericValue postalAddress = null;
GenericValue contactMech = null;
if (UtilValidate.isNotEmpty(locations)) {
try {
contactMech = locations.get(0).getRelatedOne("ContactMech", false);
} catch (GenericEntityException e) {
Debug.logError(e, "Trouble getting Contact for contactMechId: " + locations.get(0).getString("contactMechId"), module);
}
if (contactMech != null && contactMech.getString("contactMechTypeId").equals("POSTAL_ADDRESS")) {
try {
postalAddress = contactMech.getRelatedOne("PostalAddress", false);
return postalAddress;
} catch (GenericEntityException e) {
Debug.logError(e, "Trouble getting PostalAddress for contactMechId: " + contactMech.getString("contactMechId"), module);
}
}
}
return contactMech;
}
/**
* Method to return the total amount of an invoice which is not yet applied to a payment
* @param delegator the delegator
* @param invoiceId the invoice id
* @param actualCurrency the currency
* @return the invoice total as BigDecimal
*/
public static BigDecimal getInvoiceNotApplied(Delegator delegator, String invoiceId, Boolean actualCurrency) {
return InvoiceWorker.getInvoiceTotal(delegator, invoiceId, actualCurrency).subtract(getInvoiceApplied(delegator, invoiceId, UtilDateTime.nowTimestamp(), actualCurrency));
}
public static BigDecimal getInvoiceNotApplied(Delegator delegator, String invoiceId) {
return InvoiceWorker.getInvoiceTotal(delegator, invoiceId).subtract(getInvoiceApplied(delegator, invoiceId));
}
public static BigDecimal getInvoiceNotApplied(GenericValue invoice) {
return InvoiceWorker.getInvoiceTotal(invoice, Boolean.TRUE).subtract(getInvoiceApplied(invoice));
}
public static BigDecimal getInvoiceNotApplied(GenericValue invoice, Boolean actualCurrency) {
return InvoiceWorker.getInvoiceTotal(invoice, actualCurrency).subtract(getInvoiceApplied(invoice, actualCurrency));
}
/**
* Returns amount not applied (i.e., still outstanding) of an invoice at an asOfDate, based on Payment.effectiveDate <= asOfDateTime
*
* @param invoice GenericValue object of the invoice
* @param asOfDateTime the date to use
* @return Returns amount not applied of the invoice
*/
public static BigDecimal getInvoiceNotApplied(GenericValue invoice, Timestamp asOfDateTime) {
return InvoiceWorker.getInvoiceTotal(invoice, Boolean.TRUE).subtract(getInvoiceApplied(invoice, asOfDateTime));
}
/**
* Method to return the total amount of an invoice which is applied to a payment
* @param delegator the delegator
* @param invoiceId the invoice id
* @return the invoice total as BigDecimal
*/
public static BigDecimal getInvoiceApplied(Delegator delegator, String invoiceId) {
return getInvoiceApplied(delegator, invoiceId, UtilDateTime.nowTimestamp(), Boolean.TRUE);
}
/**
* Returns amount applied to invoice before an asOfDateTime, based on Payment.effectiveDate <= asOfDateTime
*
* @param delegator the delegator
* @param invoiceId the invoice id
* @param asOfDateTime - a Timestamp
* @return returns amount applied to invoice before an asOfDateTime
*/
public static BigDecimal getInvoiceApplied(Delegator delegator, String invoiceId, Timestamp asOfDateTime, Boolean actualCurrency) {
if (delegator == null) {
throw new IllegalArgumentException("Null delegator is not allowed in this method");
}
BigDecimal invoiceApplied = ZERO;
List<GenericValue> paymentApplications = null;
// lookup payment applications which took place before the asOfDateTime for this invoice
EntityConditionList<EntityExpr> dateCondition = EntityCondition.makeCondition(UtilMisc.toList(
EntityCondition.makeCondition("effectiveDate", EntityOperator.EQUALS, null),
EntityCondition.makeCondition("effectiveDate", EntityOperator.LESS_THAN_EQUAL_TO, asOfDateTime)), EntityOperator.OR);
EntityConditionList<EntityCondition> conditions = EntityCondition.makeCondition(UtilMisc.toList(
dateCondition,
EntityCondition.makeCondition("invoiceId", EntityOperator.EQUALS, invoiceId)),
EntityOperator.AND);
try {
paymentApplications = EntityQuery.use(delegator).from("PaymentAndApplication")
.where(conditions).orderBy("effectiveDate").queryList();
} catch (GenericEntityException e) {
Debug.logError(e, "Trouble getting paymentApplicationlist", module);
}
if (paymentApplications != null) {
for (GenericValue paymentApplication : paymentApplications) {
invoiceApplied = invoiceApplied.add(paymentApplication.getBigDecimal("amountApplied")).setScale(decimals,rounding);
}
}
if (UtilValidate.isNotEmpty(invoiceApplied) && !actualCurrency) {
invoiceApplied = invoiceApplied.multiply(getInvoiceCurrencyConversionRate(delegator, invoiceId)).setScale(decimals,rounding);
}
return invoiceApplied;
}
/**
* Method to return the total amount of an invoice which is applied to a payment
* @param invoice GenericValue object of the invoice
* @return the applied total as BigDecimal
*/
public static BigDecimal getInvoiceApplied(GenericValue invoice) {
return getInvoiceApplied(invoice, UtilDateTime.nowTimestamp());
}
/**
* Return the amount applied to the invoice
* @param invoice GenericValue object of the invoice
* @param actualCurrency the currency of the invoice
* @return returns the amount applied to the invoice
*/
public static BigDecimal getInvoiceApplied(GenericValue invoice, Boolean actualCurrency) {
return getInvoiceApplied(invoice.getDelegator(), invoice.getString("invoiceId"), UtilDateTime.nowTimestamp(), actualCurrency);
}
public static BigDecimal getInvoiceApplied(GenericValue invoice, Timestamp asOfDateTime) {
return getInvoiceApplied(invoice.getDelegator(), invoice.getString("invoiceId"), asOfDateTime, Boolean.TRUE);
}
/**
* Method to return the amount of an invoiceItem which is applied to a payment
* @param delegator the delegator
* @param invoiceId the invoice id
* @param invoiceItemSeqId the invoice item id
* @return the invoice total as BigDecimal
*/
public static BigDecimal getInvoiceItemApplied(Delegator delegator, String invoiceId, String invoiceItemSeqId) {
if (delegator == null) {
throw new IllegalArgumentException("Null delegator is not allowed in this method");
}
GenericValue invoiceItem = null;
try {
invoiceItem = EntityQuery.use(delegator).from("Invoice").where("invoiceId", invoiceId,"invoiceItemSeqId", invoiceItemSeqId).queryOne();
} catch (GenericEntityException e) {
Debug.logError(e, "Problem getting InvoiceItem", module);
}
if (invoiceItem == null) {
throw new IllegalArgumentException("The invoiceId/itemSeqId passed does not match an existing invoiceItem");
}
return getInvoiceItemApplied(invoiceItem);
}
/**
* Method to return the total amount of an invoiceItem which is applied to a payment
* @param invoiceItem GenericValue object of the invoice item
* @return the applied total as BigDecimal
*/
public static BigDecimal getInvoiceItemApplied(GenericValue invoiceItem) {
BigDecimal invoiceItemApplied = ZERO;
List<GenericValue> paymentApplications = null;
try {
paymentApplications = invoiceItem.getRelated("PaymentApplication", null, null, false);
} catch (GenericEntityException e) {
Debug.logError(e, "Trouble getting paymentApplicationlist", module);
}
if (paymentApplications != null) {
for (GenericValue paymentApplication : paymentApplications) {
invoiceItemApplied = invoiceItemApplied.add(paymentApplication.getBigDecimal("amountApplied")).setScale(decimals,rounding);
}
}
return invoiceItemApplied;
}
public static BigDecimal getInvoiceCurrencyConversionRate(GenericValue invoice) {
BigDecimal conversionRate = null;
Delegator delegator = invoice.getDelegator();
String otherCurrencyUomId = null;
// find the organization party currencyUomId which different from the invoice currency
try {
GenericValue party = EntityQuery.use(delegator).from("PartyAcctgPreference").where("partyId", invoice.get("partyIdFrom")).queryOne();
if (UtilValidate.isEmpty(party) || party.getString("baseCurrencyUomId").equals(invoice.getString("currencyUomId"))) {
party = EntityQuery.use(delegator).from("PartyAcctgPreference").where("partyId", invoice.get("partyId")).queryOne();
}
if (UtilValidate.isNotEmpty(party) && party.getString("baseCurrencyUomId") != null) {
otherCurrencyUomId = party.getString("baseCurrencyUomId");
} else {
otherCurrencyUomId = EntityUtilProperties.getPropertyValue("general", "currency.uom.id.default", delegator);
}
if (otherCurrencyUomId == null) {
otherCurrencyUomId = "USD"; // final default
}
} catch (GenericEntityException e) {
Debug.logError(e, "Trouble getting database records....", module);
}
if (invoice.getString("currencyUomId").equals(otherCurrencyUomId)) {
return BigDecimal.ONE; // organization party has the same currency so conversion not required.
}
try {
// check if the invoice is posted and get the conversion from there
List<GenericValue> acctgTransEntries = invoice.getRelated("AcctgTrans", null, null, false);
if (UtilValidate.isNotEmpty(acctgTransEntries)) {
GenericValue acctgTransEntry = (acctgTransEntries.get(0)).getRelated("AcctgTransEntry", null, null, false).get(0);
BigDecimal origAmount = acctgTransEntry.getBigDecimal("origAmount");
if (origAmount.compareTo(ZERO) == 1) {
conversionRate = acctgTransEntry.getBigDecimal("amount").divide(acctgTransEntry.getBigDecimal("origAmount"), new MathContext(100)).setScale(decimals,rounding);
}
}
// check if a payment is applied and use the currency conversion from there
if (UtilValidate.isEmpty(conversionRate)) {
List<GenericValue> paymentAppls = invoice.getRelated("PaymentApplication", null, null, false);
for (GenericValue paymentAppl : paymentAppls) {
GenericValue payment = paymentAppl.getRelatedOne("Payment", false);
if (UtilValidate.isNotEmpty(payment.getBigDecimal("actualCurrencyAmount"))) {
if (UtilValidate.isEmpty(conversionRate)) {
conversionRate = payment.getBigDecimal("amount").divide(payment.getBigDecimal("actualCurrencyAmount"),new MathContext(100)).setScale(decimals,rounding);
} else {
conversionRate = conversionRate.add(payment.getBigDecimal("amount").divide(payment.getBigDecimal("actualCurrencyAmount"),new MathContext(100))).divide(new BigDecimal("2"),new MathContext(100)).setScale(decimals,rounding);
}
}
}
}
// use the dated conversion entity
if (UtilValidate.isEmpty(conversionRate)) {
GenericValue rate = EntityQuery.use(delegator).from("UomConversionDated").where("uomIdTo", invoice.get("currencyUomId"), "uomId", otherCurrencyUomId).filterByDate(invoice.getTimestamp("invoiceDate")).queryFirst();
if (rate != null) {
conversionRate = BigDecimal.ONE.divide(rate.getBigDecimal("conversionFactor"), new MathContext(100)).setScale(decimals,rounding);
} else {
Debug.logError("Could not find conversionrate for invoice: " + invoice.getString("invoiceId"), module);
return new BigDecimal("1");
}
}
} catch (GenericEntityException e) {
Debug.logError(e, "Trouble getting database records....", module);
}
return(conversionRate);
}
public static BigDecimal getInvoiceCurrencyConversionRate(Delegator delegator, String invoiceId) {
if (delegator == null) {
throw new IllegalArgumentException("Null delegator is not allowed in this method");
}
GenericValue invoice = null;
try {
invoice = EntityQuery.use(delegator).from("Invoice").where("invoiceId", invoiceId).queryOne();
} catch (GenericEntityException e) {
Debug.logError(e, "Problem getting Invoice", module);
}
if (invoice == null) {
throw new IllegalArgumentException("The invoiceId passed does not match an existing invoice");
}
return getInvoiceCurrencyConversionRate(invoice);
}
/**
* Return a list of taxes separated by Geo and party and return the tax grand total
* @param invoice Generic Value
* @return Map: taxByTaxAuthGeoAndPartyList(List) and taxGrandTotal(BigDecimal)
*/
@Deprecated
public static Map<String, Object> getInvoiceTaxByTaxAuthGeoAndParty(GenericValue invoice) {
BigDecimal taxGrandTotal = ZERO;
List<Map<String, Object>> taxByTaxAuthGeoAndPartyList = new LinkedList<Map<String,Object>>();
List<GenericValue> invoiceItems = null;
if (invoice != null) {
try {
invoiceItems = invoice.getRelated("InvoiceItem", null, null, false);
} catch (GenericEntityException e) {
Debug.logError(e, "Trouble getting InvoiceItem list", module);
}
if ("SALES_INVOICE".equals(invoice.getString("invoiceTypeId"))) {
invoiceItems = EntityUtil.filterByOr(
invoiceItems, UtilMisc.toList(
EntityCondition.makeCondition("invoiceItemTypeId", EntityOperator.EQUALS, "INV_SALES_TAX"),
EntityCondition.makeCondition("invoiceItemTypeId", EntityOperator.EQUALS, "ITM_SALES_TAX")));
} else if (("PURCHASE_INVOICE".equals(invoice.getString("invoiceTypeId")))) {
invoiceItems = EntityUtil.filterByOr(
invoiceItems, UtilMisc.toList(
EntityCondition.makeCondition("invoiceItemTypeId", EntityOperator.EQUALS, "PINV_SALES_TAX"),
EntityCondition.makeCondition("invoiceItemTypeId", EntityOperator.EQUALS, "PITM_SALES_TAX")));
} else {
invoiceItems = null;
}
if (UtilValidate.isNotEmpty(invoiceItems)) {
invoiceItems = EntityUtil.orderBy(invoiceItems, UtilMisc.toList("taxAuthGeoId","taxAuthPartyId"));
// get the list of all distinct taxAuthGeoId and taxAuthPartyId. It is for getting the number of taxAuthGeoId and taxAuthPartyId in invoiceItems.
List<String> distinctTaxAuthGeoIdList = EntityUtil.getFieldListFromEntityList(invoiceItems, "taxAuthGeoId", true);
List<String> distinctTaxAuthPartyIdList = EntityUtil.getFieldListFromEntityList(invoiceItems, "taxAuthPartyId", true);
for (String taxAuthGeoId : distinctTaxAuthGeoIdList ) {
for (String taxAuthPartyId : distinctTaxAuthPartyIdList) {
//get all records for invoices filtered by taxAuthGeoId and taxAurhPartyId
List<GenericValue> invoiceItemsByTaxAuthGeoAndPartyIds = EntityUtil.filterByAnd(invoiceItems, UtilMisc.toMap("taxAuthGeoId", taxAuthGeoId, "taxAuthPartyId", taxAuthPartyId));
if (UtilValidate.isNotEmpty(invoiceItemsByTaxAuthGeoAndPartyIds)) {
BigDecimal totalAmount = ZERO;
//Now for each invoiceItem record get and add amount.
for (GenericValue invoiceItem : invoiceItemsByTaxAuthGeoAndPartyIds) {
BigDecimal amount = invoiceItem.getBigDecimal("amount");
if (amount == null) {
amount = ZERO;
}
totalAmount = totalAmount.add(amount).setScale(taxDecimals, taxRounding);
}
totalAmount = totalAmount.setScale(UtilNumber.getBigDecimalScale("salestax.calc.decimals"), UtilNumber.getBigDecimalRoundingMode("salestax.rounding"));
taxByTaxAuthGeoAndPartyList.add(UtilMisc.<String, Object>toMap("taxAuthPartyId", taxAuthPartyId, "taxAuthGeoId", taxAuthGeoId, "totalAmount", totalAmount));
taxGrandTotal = taxGrandTotal.add(totalAmount);
}
}
}
}
}
Map<String, Object> result = new HashMap<String, Object>();
result.put("taxByTaxAuthGeoAndPartyList", taxByTaxAuthGeoAndPartyList);
result.put("taxGrandTotal", taxGrandTotal);
return result;
}
/**
* Returns a List of the TaxAuthority Party and Geos for the given Invoice.
* @param invoice GenericValue object representing the Invoice
* @return A Map containing the each taxAuthPartyId as a key and a Set of taxAuthGeoIds for that taxAuthPartyId as the values. Note this method
* will not account for tax lines that do not contain a taxAuthPartyId
*/
public static Map<String, Set<String>> getInvoiceTaxAuthPartyAndGeos (GenericValue invoice) {
Map<String, Set<String>> result = new HashMap<String, Set<String>>();
if (invoice == null)
throw new IllegalArgumentException("Invoice cannot be null.");
List<GenericValue> invoiceTaxItems = null;
try {
Delegator delegator = invoice.getDelegator();
invoiceTaxItems = EntityQuery.use(delegator).from("InvoiceItem")
.where(EntityCondition.makeCondition("invoiceId", invoice.getString("invoiceId")),
EntityCondition.makeCondition("invoiceItemTypeId", EntityOperator.IN, getTaxableInvoiceItemTypeIds(delegator))
).queryList();
} catch (GenericEntityException e) {
Debug.logError(e, "Trouble getting InvoiceItem list", module);
return null;
}
if (invoiceTaxItems != null) {
for (GenericValue invoiceItem : invoiceTaxItems) {
String taxAuthPartyId = invoiceItem.getString("taxAuthPartyId");
String taxAuthGeoId = invoiceItem.getString("taxAuthGeoId");
if (UtilValidate.isNotEmpty(taxAuthPartyId)) {
if (!result.containsKey(taxAuthPartyId)) {
Set<String> taxAuthGeos = new HashSet<String>();
taxAuthGeos.add(taxAuthGeoId);
result.put(taxAuthPartyId, taxAuthGeos);
} else {
Set<String> taxAuthGeos = result.get(taxAuthPartyId);
taxAuthGeos.add(taxAuthGeoId);
}
}
}
}
return result;
}
/**
* @param invoice GenericValue object representing the invoice
* @param taxAuthPartyId
* @param taxAuthGeoId
* @return The invoice tax total for a given tax authority and geo location
*/
public static BigDecimal getInvoiceTaxTotalForTaxAuthPartyAndGeo(GenericValue invoice, String taxAuthPartyId, String taxAuthGeoId) {
List<GenericValue> invoiceTaxItems = null;
try {
Delegator delegator = invoice.getDelegator();
invoiceTaxItems = EntityQuery.use(delegator).from("InvoiceItem")
.where(EntityCondition.makeCondition("invoiceId", invoice.getString("invoiceId")),
EntityCondition.makeCondition("invoiceItemTypeId", EntityOperator.IN, getTaxableInvoiceItemTypeIds(delegator)),
EntityCondition.makeCondition("taxAuthPartyId", taxAuthPartyId),
EntityCondition.makeCondition("taxAuthGeoId", taxAuthGeoId)
).queryList();
} catch (GenericEntityException e) {
Debug.logError(e, "Trouble getting InvoiceItem list", module);
return null;
}
return getTaxTotalForInvoiceItems(invoiceTaxItems);
}
/** Returns the invoice tax total for unattributed tax items, that is items which have no taxAuthPartyId value
* @param invoice GenericValue object representing the invoice
* @return Returns the invoice tax total for unattributed tax items
*/
public static BigDecimal getInvoiceUnattributedTaxTotal(GenericValue invoice) {
List<GenericValue> invoiceTaxItems = null;
try {
Delegator delegator = invoice.getDelegator();
invoiceTaxItems = EntityQuery.use(delegator).from("InvoiceItem")
.where(EntityCondition.makeCondition("invoiceId", invoice.get("invoiceId")),
EntityCondition.makeCondition("invoiceItemTypeId", EntityOperator.IN, getTaxableInvoiceItemTypeIds(delegator)),
EntityCondition.makeCondition("taxAuthPartyId", null)
).queryList();
} catch (GenericEntityException e) {
Debug.logError(e, "Trouble getting InvoiceItem list", module);
return null;
}
return getTaxTotalForInvoiceItems(invoiceTaxItems);
}
/** Returns the tax total for a given list of tax typed InvoiceItem records
* @param taxInvoiceItems
* @return
*/
private static BigDecimal getTaxTotalForInvoiceItems(List<GenericValue> taxInvoiceItems) {
if (taxInvoiceItems == null) {
return ZERO;
}
BigDecimal taxTotal = ZERO;
for (GenericValue taxInvoiceItem : taxInvoiceItems) {
BigDecimal amount = taxInvoiceItem.getBigDecimal("amount");
if (amount == null) {
amount = ZERO;
}
BigDecimal quantity = taxInvoiceItem.getBigDecimal("quantity");
if (quantity == null) {
quantity = BigDecimal.ONE;
}
amount = amount.multiply(quantity);
amount = amount.setScale(taxDecimals, taxRounding);
taxTotal = taxTotal.add(amount);
}
return taxTotal.setScale(decimals, rounding);
}
}