/*******************************************************************************
* 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.payment;
import java.math.BigDecimal;
import java.math.MathContext;
import java.util.HashMap;
import java.util.LinkedList;
import java.util.List;
import java.util.Map;
import javax.servlet.ServletRequest;
import org.apache.ofbiz.base.util.Debug;
import org.apache.ofbiz.base.util.UtilFormatOut;
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.EntityExpr;
import org.apache.ofbiz.entity.condition.EntityOperator;
import org.apache.ofbiz.entity.util.EntityQuery;
import org.apache.ofbiz.entity.util.EntityUtil;
/**
* Worker methods for Payments
*/
public final class PaymentWorker {
public static final String module = PaymentWorker.class.getName();
private static final int decimals = UtilNumber.getBigDecimalScale("invoice.decimals");
private static final int rounding = UtilNumber.getBigDecimalRoundingMode("invoice.rounding");
private PaymentWorker() {}
// to be able to use in minilanguage where Boolean cannot be used
public static List<Map<String, GenericValue>> getPartyPaymentMethodValueMaps(Delegator delegator, String partyId) {
return(getPartyPaymentMethodValueMaps(delegator, partyId, false));
}
public static List<Map<String, GenericValue>> getPartyPaymentMethodValueMaps(Delegator delegator, String partyId, Boolean showOld) {
List<Map<String, GenericValue>> paymentMethodValueMaps = new LinkedList<Map<String,GenericValue>>();
try {
List<GenericValue> paymentMethods = EntityQuery.use(delegator).from("PaymentMethod").where("partyId", partyId).queryList();
if (!showOld) paymentMethods = EntityUtil.filterByDate(paymentMethods, true);
for (GenericValue paymentMethod : paymentMethods) {
Map<String, GenericValue> valueMap = new HashMap<String, GenericValue>();
paymentMethodValueMaps.add(valueMap);
valueMap.put("paymentMethod", paymentMethod);
if ("CREDIT_CARD".equals(paymentMethod.getString("paymentMethodTypeId"))) {
GenericValue creditCard = paymentMethod.getRelatedOne("CreditCard", false);
if (creditCard != null) valueMap.put("creditCard", creditCard);
} else if ("GIFT_CARD".equals(paymentMethod.getString("paymentMethodTypeId"))) {
GenericValue giftCard = paymentMethod.getRelatedOne("GiftCard", false);
if (giftCard != null) valueMap.put("giftCard", giftCard);
} else if ("EFT_ACCOUNT".equals(paymentMethod.getString("paymentMethodTypeId"))) {
GenericValue eftAccount = paymentMethod.getRelatedOne("EftAccount", false);
if (eftAccount != null) valueMap.put("eftAccount", eftAccount);
} else if ("COMPANY_CHECK".equals(paymentMethod.getString("paymentMethodTypeId"))) {
GenericValue companyCheckAccount = paymentMethod.getRelatedOne("CheckAccount", false);
if (companyCheckAccount != null) valueMap.put("companyCheckAccount", companyCheckAccount);
} else if ("PERSONAL_CHECK".equals(paymentMethod.getString("paymentMethodTypeId"))) {
GenericValue personalCheckAccount = paymentMethod.getRelatedOne("CheckAccount", false);
if (personalCheckAccount != null) valueMap.put("personalCheckAccount", personalCheckAccount);
} else if ("CERTIFIED_CHECK".equals(paymentMethod.getString("paymentMethodTypeId"))) {
GenericValue certifiedCheckAccount = paymentMethod.getRelatedOne("CheckAccount", false);
if (certifiedCheckAccount != null) valueMap.put("certifiedCheckAccount", certifiedCheckAccount);
}
}
} catch (GenericEntityException e) {
Debug.logWarning(e, module);
}
return paymentMethodValueMaps;
}
public static Map<String, Object> getPaymentMethodAndRelated(ServletRequest request, String partyId) {
Delegator delegator = (Delegator) request.getAttribute("delegator");
Map<String, Object> results = new HashMap<String, Object>();
Boolean tryEntity = true;
if (request.getAttribute("_ERROR_MESSAGE_") != null) tryEntity = false;
String donePage = request.getParameter("DONE_PAGE");
if (UtilValidate.isEmpty(donePage))
donePage = "viewprofile";
results.put("donePage", donePage);
String paymentMethodId = request.getParameter("paymentMethodId");
// check for a create
if (request.getAttribute("paymentMethodId") != null) {
paymentMethodId = (String) request.getAttribute("paymentMethodId");
}
results.put("paymentMethodId", paymentMethodId);
GenericValue paymentMethod = null;
GenericValue creditCard = null;
GenericValue giftCard = null;
GenericValue eftAccount = null;
GenericValue checkAccount = null;
if (UtilValidate.isNotEmpty(paymentMethodId)) {
try {
paymentMethod = EntityQuery.use(delegator).from("PaymentMethod").where("paymentMethodId", paymentMethodId).queryOne();
creditCard = EntityQuery.use(delegator).from("CreditCard").where("paymentMethodId", paymentMethodId).queryOne();
giftCard = EntityQuery.use(delegator).from("GiftCard").where("paymentMethodId", paymentMethodId).queryOne();
eftAccount = EntityQuery.use(delegator).from("EftAccount").where("paymentMethodId", paymentMethodId).queryOne();
checkAccount = EntityQuery.use(delegator).from("CheckAccount").where("paymentMethodId", paymentMethodId).queryOne();
} catch (GenericEntityException e) {
Debug.logWarning(e, module);
}
}
if (paymentMethod != null) {
results.put("paymentMethod", paymentMethod);
} else {
tryEntity = false;
}
if (creditCard != null) {
results.put("creditCard", creditCard);
}
if (giftCard != null) {
results.put("giftCard", giftCard);
}
if (eftAccount != null) {
results.put("eftAccount", eftAccount);
}
if (checkAccount != null) {
results.put("checkAccount", checkAccount);
}
String curContactMechId = null;
if (creditCard != null) {
curContactMechId = UtilFormatOut.checkNull(tryEntity ? creditCard.getString("contactMechId") : request.getParameter("contactMechId"));
} else if (giftCard != null) {
curContactMechId = UtilFormatOut.checkNull(tryEntity ? giftCard.getString("contactMechId") : request.getParameter("contactMechId"));
} else if (eftAccount != null) {
curContactMechId = UtilFormatOut.checkNull(tryEntity ? eftAccount.getString("contactMechId") : request.getParameter("contactMechId"));
} else if (checkAccount != null) {
curContactMechId = UtilFormatOut.checkNull(tryEntity ? checkAccount.getString("contactMechId") : request.getParameter("contactMechId"));
}
if (curContactMechId != null) {
results.put("curContactMechId", curContactMechId);
}
results.put("tryEntity", tryEntity);
return results;
}
public static GenericValue getPaymentAddress(Delegator delegator, String partyId) {
GenericValue purpose = null;
try {
purpose = EntityQuery.use(delegator).from("PartyContactWithPurpose")
.where("partyId", partyId, "contactMechPurposeTypeId", "PAYMENT_LOCATION")
.orderBy("-purposeFromDate").filterByDate("contactFromDate", "contactThruDate", "purposeFromDate", "purposeThruDate")
.queryFirst();
} catch (GenericEntityException e) {
Debug.logError(e, "Trouble getting PartyContactWithPurpose view entity list", module);
}
// get the address for the primary contact mech
GenericValue postalAddress = null;
if (purpose != null) {
try {
postalAddress = EntityQuery.use(delegator).from("PostalAddress").where("contactMechId", purpose.getString("contactMechId")).queryOne();
} catch (GenericEntityException e) {
Debug.logError(e, "Trouble getting PostalAddress record for contactMechId: " + purpose.getString("contactMechId"), module);
}
}
return postalAddress;
}
/**
* Returns the total from a list of Payment entities
*
* @param payments List of Payment GenericValue items
* @return total payments as BigDecimal
*/
public static BigDecimal getPaymentsTotal(List<GenericValue> payments) {
if (payments == null) {
throw new IllegalArgumentException("Payment list cannot be null");
}
BigDecimal paymentsTotal = BigDecimal.ZERO;
for (GenericValue payment : payments) {
paymentsTotal = paymentsTotal.add(payment.getBigDecimal("amount")).setScale(decimals, rounding);
}
return paymentsTotal;
}
/**
* Method to return the total amount of an payment which is applied to a payment
* @param delegator the delegator
* @param paymentId paymentId of the Payment
* @return the applied total as BigDecimal
*/
public static BigDecimal getPaymentApplied(Delegator delegator, String paymentId) {
return getPaymentApplied(delegator, paymentId, false);
}
public static BigDecimal getPaymentApplied(Delegator delegator, String paymentId, Boolean actual) {
if (delegator == null) {
throw new IllegalArgumentException("Null delegator is not allowed in this method");
}
GenericValue payment = null;
try {
payment = EntityQuery.use(delegator).from("Payment").where("paymentId", paymentId).queryOne();
} catch (GenericEntityException e) {
Debug.logError(e, "Problem getting Payment", module);
}
if (payment == null) {
throw new IllegalArgumentException("The paymentId passed does not match an existing payment");
}
return getPaymentApplied(payment, actual);
}
/**
* Method to return the amount applied converted to the currency of payment
* @param paymentApplicationId the payment application id
* @return appliedAmount the applied amount as BigDecimal
*/
public static BigDecimal getPaymentAppliedAmount(Delegator delegator, String paymentApplicationId) {
GenericValue paymentApplication = null;
BigDecimal appliedAmount = BigDecimal.ZERO;
try {
paymentApplication = EntityQuery.use(delegator).from("PaymentApplication").where("paymentApplicationId", paymentApplicationId).queryOne();
appliedAmount = paymentApplication.getBigDecimal("amountApplied");
if (paymentApplication.get("paymentId") != null) {
GenericValue payment = paymentApplication.getRelatedOne("Payment", false);
if (paymentApplication.get("invoiceId") != null && payment.get("actualCurrencyAmount") != null && payment.get("actualCurrencyUomId") != null) {
GenericValue invoice = paymentApplication.getRelatedOne("Invoice", false);
if (payment.getString("actualCurrencyUomId").equals(invoice.getString("currencyUomId"))) {
appliedAmount = appliedAmount.multiply(payment.getBigDecimal("amount")).divide(payment.getBigDecimal("actualCurrencyAmount"),new MathContext(100));
}
}
}
} catch (GenericEntityException e) {
Debug.logError(e, "Problem getting Payment", module);
}
return appliedAmount;
}
/**
* Method to return the total amount of an payment which is applied to a payment
* @param payment GenericValue object of the Payment
* @return the applied total as BigDecimal in the currency of the payment
*/
public static BigDecimal getPaymentApplied(GenericValue payment) {
return getPaymentApplied(payment, false);
}
/**
* Method to return the total amount of a payment which is applied to a payment
* @param payment GenericValue object of the Payment
* @param actual false for currency of the payment, true for the actual currency
* @return the applied total as BigDecimal in the currency of the payment
*/
public static BigDecimal getPaymentApplied(GenericValue payment, Boolean actual) {
BigDecimal paymentApplied = BigDecimal.ZERO;
List<GenericValue> paymentApplications = null;
try {
List<EntityExpr> cond = UtilMisc.toList(
EntityCondition.makeCondition("paymentId", EntityOperator.EQUALS, payment.getString("paymentId")),
EntityCondition.makeCondition("toPaymentId", EntityOperator.EQUALS, payment.getString("paymentId"))
);
EntityCondition partyCond = EntityCondition.makeCondition(cond, EntityOperator.OR);
paymentApplications = payment.getDelegator().findList("PaymentApplication", partyCond, null, UtilMisc.toList("invoiceId", "billingAccountId"), null, false);
if (UtilValidate.isNotEmpty(paymentApplications)) {
for (GenericValue paymentApplication : paymentApplications) {
BigDecimal amountApplied = paymentApplication.getBigDecimal("amountApplied");
// check currency invoice and if different convert amount applied for display
if (actual.equals(Boolean.FALSE) && paymentApplication.get("invoiceId") != null && payment.get("actualCurrencyAmount") != null && payment.get("actualCurrencyUomId") != null) {
GenericValue invoice = paymentApplication.getRelatedOne("Invoice", false);
if (payment.getString("actualCurrencyUomId").equals(invoice.getString("currencyUomId"))) {
amountApplied = amountApplied.multiply(payment.getBigDecimal("amount")).divide(payment.getBigDecimal("actualCurrencyAmount"),new MathContext(100));
}
}
paymentApplied = paymentApplied.add(amountApplied).setScale(decimals,rounding);
}
}
} catch (GenericEntityException e) {
Debug.logError(e, "Trouble getting entities", module);
}
return paymentApplied;
}
public static BigDecimal getPaymentNotApplied(GenericValue payment) {
if (payment != null) {
return payment.getBigDecimal("amount").subtract(getPaymentApplied(payment)).setScale(decimals,rounding);
}
return BigDecimal.ZERO;
}
public static BigDecimal getPaymentNotApplied(GenericValue payment, Boolean actual) {
if (actual.equals(Boolean.TRUE) && UtilValidate.isNotEmpty(payment.getBigDecimal("actualCurrencyAmount"))) {
return payment.getBigDecimal("actualCurrencyAmount").subtract(getPaymentApplied(payment, actual)).setScale(decimals,rounding);
}
return payment.getBigDecimal("amount").subtract(getPaymentApplied(payment)).setScale(decimals,rounding);
}
public static BigDecimal getPaymentNotApplied(Delegator delegator, String paymentId) {
return getPaymentNotApplied(delegator,paymentId, false);
}
public static BigDecimal getPaymentNotApplied(Delegator delegator, String paymentId, Boolean actual) {
if (delegator == null) {
throw new IllegalArgumentException("Null delegator is not allowed in this method");
}
GenericValue payment = null;
try {
payment = EntityQuery.use(delegator).from("Payment").where("paymentId", paymentId).queryOne();
} catch (GenericEntityException e) {
Debug.logError(e, "Problem getting Payment", module);
}
if (payment == null) {
throw new IllegalArgumentException("The paymentId passed does not match an existing payment");
}
return payment.getBigDecimal("amount").subtract(getPaymentApplied(delegator,paymentId, actual)).setScale(decimals,rounding);
}
}