/*******************************************************************************
* 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.sql.Timestamp;
import java.util.HashMap;
import java.util.LinkedList;
import java.util.List;
import java.util.Locale;
import java.util.Map;
import org.apache.ofbiz.base.util.Debug;
import org.apache.ofbiz.base.util.StringUtil;
import org.apache.ofbiz.base.util.UtilDateTime;
import org.apache.ofbiz.base.util.UtilMisc;
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.util.EntityQuery;
import org.apache.ofbiz.entity.util.EntityUtil;
import org.apache.ofbiz.security.Security;
import org.apache.ofbiz.service.DispatchContext;
import org.apache.ofbiz.service.GenericServiceException;
import org.apache.ofbiz.service.LocalDispatcher;
import org.apache.ofbiz.service.ModelService;
import org.apache.ofbiz.service.ServiceUtil;
/**
* Services for Payment maintenance
*/
public class PaymentMethodServices {
public final static String module = PaymentMethodServices.class.getName();
public final static String resource = "AccountingUiLabels";
public static final String resourceError = "AccountingUiLabels";
/**
* Deletes a PaymentMethod entity according to the parameters passed in the context
* <b>security check</b>: userLogin partyId must equal paymentMethod partyId, or must have PAY_INFO_DELETE permission
* @param ctx The DispatchContext that this service is operating in
* @param context Map containing the input parameters
* @return Map with the result of the service, the output parameters
*/
public static Map<String, Object> deletePaymentMethod(DispatchContext ctx, Map<String, ? extends Object> context) {
Map<String, Object> result = new HashMap<String, Object>();
Delegator delegator = ctx.getDelegator();
Security security = ctx.getSecurity();
GenericValue userLogin = (GenericValue) context.get("userLogin");
Locale locale = (Locale) context.get("locale");
Timestamp now = UtilDateTime.nowTimestamp();
// never delete a PaymentMethod, just put a to date on the link to the party
String paymentMethodId = (String) context.get("paymentMethodId");
GenericValue paymentMethod = null;
try {
paymentMethod = EntityQuery.use(delegator).from("PaymentMethod").where("paymentMethodId", paymentMethodId).queryOne();
} catch (GenericEntityException e) {
Debug.logWarning(e.toString(), module);
return ServiceUtil.returnError(UtilProperties.getMessage(resourceError,
"AccountingPaymentMethodCannotBeDeleted",
UtilMisc.toMap("errorString", e.getMessage()), locale));
}
if (paymentMethod == null) {
return ServiceUtil.returnError(UtilProperties.getMessage(resourceError,
"AccountingPaymentMethodCannotBeDeleted",
UtilMisc.toMap("errorString", ""), locale));
}
// <b>security check</b>: userLogin partyId must equal paymentMethod partyId, or must have PAY_INFO_DELETE permission
if (paymentMethod.get("partyId") == null || !paymentMethod.getString("partyId").equals(userLogin.getString("partyId"))) {
if (!security.hasEntityPermission("PAY_INFO", "_DELETE", userLogin) && !security.hasEntityPermission("ACCOUNTING", "_DELETE", userLogin)) {
return ServiceUtil.returnError(UtilProperties.getMessage(resourceError,
"AccountingPaymentMethodNoPermissionToDelete", locale));
}
}
paymentMethod.set("thruDate", now);
try {
paymentMethod.store();
} catch (GenericEntityException e) {
Debug.logWarning(e.toString(), module);
return ServiceUtil.returnError(UtilProperties.getMessage(resourceError,
"AccountingPaymentMethodCannotBeDeletedWriteFailure",
UtilMisc.toMap("errorString", e.getMessage()), locale));
}
result.put(ModelService.RESPONSE_MESSAGE, ModelService.RESPOND_SUCCESS);
return result;
}
public static Map<String, Object> makeExpireDate(DispatchContext ctx, Map<String, ? extends Object> context) {
Map<String, Object> result = new HashMap<String, Object>();
String expMonth = (String) context.get("expMonth");
String expYear = (String) context.get("expYear");
StringBuilder expDate = new StringBuilder();
expDate.append(expMonth);
expDate.append("/");
expDate.append(expYear);
result.put("expireDate", expDate.toString());
result.put(ModelService.RESPONSE_MESSAGE, ModelService.RESPOND_SUCCESS);
return result;
}
/**
* Creates CreditCard and PaymentMethod entities according to the parameters passed in the context
* <b>security check</b>: userLogin partyId must equal partyId, or must have PAY_INFO_CREATE permission
* @param ctx The DispatchContext that this service is operating in
* @param context Map containing the input parameters
* @return Map with the result of the service, the output parameters
*/
public static Map<String, Object> createCreditCard(DispatchContext ctx, Map<String, Object> context) {
Map<String, Object> result = new HashMap<String, Object>();
Delegator delegator = ctx.getDelegator();
Security security = ctx.getSecurity();
GenericValue userLogin = (GenericValue) context.get("userLogin");
Locale locale = (Locale) context.get("locale");
Timestamp now = UtilDateTime.nowTimestamp();
String partyId = ServiceUtil.getPartyIdCheckSecurity(userLogin, security, context, result, "PAY_INFO", "_CREATE", "ACCOUNTING", "_CREATE");
if (result.size() > 0) return result;
// do some more complicated/critical validation...
List<String> messages = new LinkedList<String>();
// first remove all spaces from the credit card number
context.put("cardNumber", StringUtil.removeSpaces((String) context.get("cardNumber")));
if (!UtilValidate.isCardMatch((String) context.get("cardType"), (String) context.get("cardNumber"))) {
messages.add(
UtilProperties.getMessage(resource, "AccountingCreditCardNumberInvalid",
UtilMisc.toMap("cardType", (String) context.get("cardType"),
"validCardType", UtilValidate.getCardType((String) context.get("cardNumber"))), locale));
}
if (!UtilValidate.isDateAfterToday((String) context.get("expireDate"))) {
messages.add(
UtilProperties.getMessage(resource, "AccountingCreditCardExpireDateBeforeToday",
UtilMisc.toMap("expireDate", (String) context.get("expireDate")), locale));
}
if (messages.size() > 0) {
return ServiceUtil.returnError(messages);
}
List<GenericValue> toBeStored = new LinkedList<GenericValue>();
GenericValue newPm = delegator.makeValue("PaymentMethod");
toBeStored.add(newPm);
GenericValue newCc = delegator.makeValue("CreditCard");
toBeStored.add(newCc);
String newPmId = (String) context.get("paymentMethodId");
if (UtilValidate.isEmpty(newPmId)) {
try {
newPmId = delegator.getNextSeqId("PaymentMethod");
} catch (IllegalArgumentException e) {
return ServiceUtil.returnError(UtilProperties.getMessage(resource,
"AccountingCreditCardCreateIdGenerationFailure", locale));
}
}
newPm.set("partyId", partyId);
newPm.set("description",context.get("description"));
newPm.set("fromDate", (context.get("fromDate") != null ? context.get("fromDate") : now));
newPm.set("thruDate", context.get("thruDate"));
newCc.set("companyNameOnCard", context.get("companyNameOnCard"));
newCc.set("titleOnCard", context.get("titleOnCard"));
newCc.set("firstNameOnCard", context.get("firstNameOnCard"));
newCc.set("middleNameOnCard", context.get("middleNameOnCard"));
newCc.set("lastNameOnCard", context.get("lastNameOnCard"));
newCc.set("suffixOnCard", context.get("suffixOnCard"));
newCc.set("cardType", context.get("cardType"));
newCc.set("cardNumber", context.get("cardNumber"));
newCc.set("expireDate", context.get("expireDate"));
newPm.set("paymentMethodId", newPmId);
newPm.set("paymentMethodTypeId", "CREDIT_CARD");
newCc.set("paymentMethodId", newPmId);
GenericValue newPartyContactMechPurpose = null;
String contactMechId = (String) context.get("contactMechId");
if (UtilValidate.isNotEmpty(contactMechId) && !contactMechId.equals("_NEW_")) {
// set the contactMechId on the credit card
newCc.set("contactMechId", context.get("contactMechId"));
// add a PartyContactMechPurpose of BILLING_LOCATION if necessary
String contactMechPurposeTypeId = "BILLING_LOCATION";
GenericValue tempVal = null;
try {
List<GenericValue> allPCWPs = EntityQuery.use(delegator).from("PartyContactWithPurpose")
.where("partyId", partyId, "contactMechId", contactMechId, "contactMechPurposeTypeId", contactMechPurposeTypeId).queryList();
allPCWPs = EntityUtil.filterByDate(allPCWPs, now, "contactFromDate", "contactThruDate", true);
allPCWPs = EntityUtil.filterByDate(allPCWPs, now, "purposeFromDate", "purposeThruDate", true);
tempVal = EntityUtil.getFirst(allPCWPs);
} catch (GenericEntityException e) {
Debug.logWarning(e.getMessage(), module);
tempVal = null;
}
if (tempVal == null) {
// no value found, create a new one
newPartyContactMechPurpose = delegator.makeValue("PartyContactMechPurpose",
UtilMisc.toMap("partyId", partyId, "contactMechId", contactMechId, "contactMechPurposeTypeId", contactMechPurposeTypeId, "fromDate", now));
}
}
if (newPartyContactMechPurpose != null) toBeStored.add(newPartyContactMechPurpose);
try {
delegator.storeAll(toBeStored);
} catch (GenericEntityException e) {
Debug.logWarning(e.getMessage(), module);
return ServiceUtil.returnError(UtilProperties.getMessage(resource,
"AccountingCreditCardCreateWriteFailure", locale) + e.getMessage());
}
result.put("paymentMethodId", newCc.getString("paymentMethodId"));
result.put(ModelService.RESPONSE_MESSAGE, ModelService.RESPOND_SUCCESS);
return result;
}
/**
* Updates CreditCard and PaymentMethod entities according to the parameters passed in the context
* <b>security check</b>: userLogin partyId must equal partyId, or must have PAY_INFO_UPDATE permission
* @param ctx The DispatchContext that this service is operating in
* @param context Map containing the input parameters
* @return Map with the result of the service, the output parameters
*/
public static Map<String, Object> updateCreditCard(DispatchContext ctx, Map<String, Object> context) {
Map<String, Object> result = new HashMap<String, Object>();
Delegator delegator = ctx.getDelegator();
Security security = ctx.getSecurity();
GenericValue userLogin = (GenericValue) context.get("userLogin");
Locale locale = (Locale) context.get("locale");
Timestamp now = UtilDateTime.nowTimestamp();
String partyId = ServiceUtil.getPartyIdCheckSecurity(userLogin, security, context, result, "PAY_INFO", "_UPDATE", "ACCOUNTING", "_UPDATE");
if (result.size() > 0) return result;
List<GenericValue> toBeStored = new LinkedList<GenericValue>();
boolean isModified = false;
GenericValue paymentMethod = null;
GenericValue newPm = null;
GenericValue creditCard = null;
GenericValue newCc = null;
String paymentMethodId = (String) context.get("paymentMethodId");
try {
creditCard = EntityQuery.use(delegator).from("CreditCard").where("paymentMethodId", paymentMethodId).queryOne();
paymentMethod = EntityQuery.use(delegator).from("PaymentMethod").where("paymentMethodId", paymentMethodId).queryOne();
} catch (GenericEntityException e) {
Debug.logWarning(e.getMessage(), module);
return ServiceUtil.returnError(UtilProperties.getMessage(resource,
"AccountingCreditCardUpdateReadFailure", locale) + e.getMessage());
}
if (creditCard == null || paymentMethod == null) {
return ServiceUtil.returnError(UtilProperties.getMessage(resource,
"AccountingCreditCardUpdateWithPaymentMethodId", locale) + paymentMethodId);
}
if (!paymentMethod.getString("partyId").equals(partyId) && !security.hasEntityPermission("PAY_INFO", "_UPDATE", userLogin) && !security.hasEntityPermission("ACCOUNTING", "_UPDATE", userLogin)) {
return ServiceUtil.returnError(UtilProperties.getMessage(resource,
"AccountingCreditCardUpdateWithoutPermission", UtilMisc.toMap("partyId", partyId,
"paymentMethodId", paymentMethodId), locale));
}
// do some more complicated/critical validation...
List<String> messages = new LinkedList<String>();
// first remove all spaces from the credit card number
String updatedCardNumber = StringUtil.removeSpaces((String) context.get("cardNumber"));
if (updatedCardNumber.startsWith("*")) {
// get the masked card number from the db
String origCardNumber = creditCard.getString("cardNumber");
String origMaskedNumber = "";
int cardLength = origCardNumber.length() - 4;
for (int i = 0; i < cardLength; i++) {
origMaskedNumber = origMaskedNumber + "*";
}
origMaskedNumber = origMaskedNumber + origCardNumber.substring(cardLength);
// compare the two masked numbers
if (updatedCardNumber.equals(origMaskedNumber)) {
updatedCardNumber = origCardNumber;
}
}
context.put("cardNumber", updatedCardNumber);
if (!UtilValidate.isCardMatch((String) context.get("cardType"), (String) context.get("cardNumber"))) {
messages.add(
UtilProperties.getMessage(resource, "AccountingCreditCardNumberInvalid",
UtilMisc.toMap("cardType", (String) context.get("cardType"),
"validCardType", UtilValidate.getCardType((String) context.get("cardNumber"))), locale));
}
if (!UtilValidate.isDateAfterToday((String) context.get("expireDate"))) {
messages.add(
UtilProperties.getMessage(resource, "AccountingCreditCardExpireDateBeforeToday",
UtilMisc.toMap("expireDate", (String) context.get("expireDate")), locale));
}
if (messages.size() > 0) {
return ServiceUtil.returnError(messages);
}
newPm = GenericValue.create(paymentMethod);
toBeStored.add(newPm);
newCc = GenericValue.create(creditCard);
toBeStored.add(newCc);
String newPmId = null;
try {
newPmId = delegator.getNextSeqId("PaymentMethod");
} catch (IllegalArgumentException e) {
return ServiceUtil.returnError(UtilProperties.getMessage(resource,
"AccountingCreditCardUpdateIdGenerationFailure", locale));
}
newPm.set("partyId", partyId);
newPm.set("fromDate", context.get("fromDate"), false);
newPm.set("description",context.get("description"));
// The following check is needed to avoid to reactivate an expired pm
if (newPm.get("thruDate") == null) {
newPm.set("thruDate", context.get("thruDate"));
}
newCc.set("companyNameOnCard", context.get("companyNameOnCard"));
newCc.set("titleOnCard", context.get("titleOnCard"));
newCc.set("firstNameOnCard", context.get("firstNameOnCard"));
newCc.set("middleNameOnCard", context.get("middleNameOnCard"));
newCc.set("lastNameOnCard", context.get("lastNameOnCard"));
newCc.set("suffixOnCard", context.get("suffixOnCard"));
newCc.set("cardType", context.get("cardType"));
newCc.set("cardNumber", context.get("cardNumber"));
newCc.set("expireDate", context.get("expireDate"));
GenericValue newPartyContactMechPurpose = null;
String contactMechId = (String) context.get("contactMechId");
if (UtilValidate.isNotEmpty(contactMechId) && !contactMechId.equals("_NEW_")) {
// set the contactMechId on the credit card
newCc.set("contactMechId", contactMechId);
}
if (!newCc.equals(creditCard) || !newPm.equals(paymentMethod)) {
newPm.set("paymentMethodId", newPmId);
newCc.set("paymentMethodId", newPmId);
newPm.set("fromDate", (context.get("fromDate") != null ? context.get("fromDate") : now));
isModified = true;
}
if (UtilValidate.isNotEmpty(contactMechId) && !contactMechId.equals("_NEW_")) {
// add a PartyContactMechPurpose of BILLING_LOCATION if necessary
String contactMechPurposeTypeId = "BILLING_LOCATION";
GenericValue tempVal = null;
try {
List<GenericValue> allPCWPs = EntityQuery.use(delegator).from("PartyContactWithPurpose")
.where("partyId", partyId, "contactMechId", contactMechId, "contactMechPurposeTypeId", contactMechPurposeTypeId).queryList();
allPCWPs = EntityUtil.filterByDate(allPCWPs, now, "contactFromDate", "contactThruDate", true);
allPCWPs = EntityUtil.filterByDate(allPCWPs, now, "purposeFromDate", "purposeThruDate", true);
tempVal = EntityUtil.getFirst(allPCWPs);
} catch (GenericEntityException e) {
Debug.logWarning(e.getMessage(), module);
tempVal = null;
}
if (tempVal == null) {
// no value found, create a new one
newPartyContactMechPurpose = delegator.makeValue("PartyContactMechPurpose",
UtilMisc.toMap("partyId", partyId, "contactMechId", contactMechId, "contactMechPurposeTypeId", contactMechPurposeTypeId, "fromDate", now));
}
}
if (isModified) {
if (newPartyContactMechPurpose != null) toBeStored.add(newPartyContactMechPurpose);
// set thru date on old paymentMethod
paymentMethod.set("thruDate", now);
toBeStored.add(paymentMethod);
try {
delegator.storeAll(toBeStored);
} catch (GenericEntityException e) {
Debug.logWarning(e.getMessage(), module);
return ServiceUtil.returnError(UtilProperties.getMessage(resource,
"AccountingCreditCardUpdateWriteFailure", locale) + e.getMessage());
}
} else {
result.put("paymentMethodId", paymentMethodId);
result.put("oldPaymentMethodId", paymentMethodId);
result.put(ModelService.RESPONSE_MESSAGE, ModelService.RESPOND_SUCCESS);
if (contactMechId == null || !contactMechId.equals("_NEW_")) {
result.put(ModelService.SUCCESS_MESSAGE, UtilProperties.getMessage(resource,
"AccountingNoChangesMadeNotUpdatingCreditCard", locale));
}
return result;
}
result.put("oldPaymentMethodId", paymentMethodId);
result.put("paymentMethodId", newCc.getString("paymentMethodId"));
result.put(ModelService.RESPONSE_MESSAGE, ModelService.RESPOND_SUCCESS);
return result;
}
public static Map<String, Object> clearCreditCardData(DispatchContext dctx, Map<String, ? extends Object> context) {
GenericValue userLogin = (GenericValue) context.get("userLogin");
String paymentMethodId = (String) context.get("paymentMethodId");
// get the cc object
Delegator delegator = dctx.getDelegator();
GenericValue creditCard;
try {
creditCard = EntityQuery.use(delegator).from("CreditCard").where("paymentMethodId", paymentMethodId).queryOne();
} catch (GenericEntityException e) {
Debug.logError(e, module);
return ServiceUtil.returnError(e.getMessage());
}
// clear the info and store it
creditCard.set("cardNumber", "0000000000000000"); // set so it doesn't blow up in UIs
creditCard.set("expireDate", "01/1970"); // same here
try {
delegator.store(creditCard);
} catch (GenericEntityException e) {
Debug.logError(e, module);
return ServiceUtil.returnError(e.getMessage());
}
// expire the payment method
LocalDispatcher dispatcher = dctx.getDispatcher();
Map<String, Object> expireCtx = UtilMisc.<String, Object>toMap("userLogin", userLogin,
"paymentMethodId", paymentMethodId);
Map<String, Object> expireResp;
try {
expireResp = dispatcher.runSync("deletePaymentMethod", expireCtx);
} catch (GenericServiceException e) {
Debug.logError(e, module);
return ServiceUtil.returnError(e.getMessage());
}
if (ServiceUtil.isError(expireResp)) {
return ServiceUtil.returnError(ServiceUtil.getErrorMessage(expireResp));
}
return ServiceUtil.returnSuccess();
}
public static Map<String, Object> createGiftCard(DispatchContext ctx, Map<String, ? extends Object> context) {
Map<String, Object> result = new HashMap<String, Object>();
Delegator delegator = ctx.getDelegator();
Security security = ctx.getSecurity();
GenericValue userLogin = (GenericValue) context.get("userLogin");
Locale locale = (Locale) context.get("locale");
Timestamp now = UtilDateTime.nowTimestamp();
String partyId = ServiceUtil.getPartyIdCheckSecurity(userLogin, security, context, result, "PAY_INFO", "_CREATE", "ACCOUNTING", "_CREATE");
if (result.size() > 0)
return result;
List<GenericValue> toBeStored = new LinkedList<GenericValue>();
GenericValue newPm = delegator.makeValue("PaymentMethod");
toBeStored.add(newPm);
GenericValue newGc = delegator.makeValue("GiftCard");
toBeStored.add(newGc);
String newPmId = (String) context.get("paymentMethodId");
if (UtilValidate.isEmpty(newPmId)) {
try {
newPmId = delegator.getNextSeqId("PaymentMethod");
} catch (IllegalArgumentException e) {
return ServiceUtil.returnError(UtilProperties.getMessage(resourceError,
"AccountingGiftCardCannotBeCreated", locale));
}
}
newPm.set("partyId", partyId);
newPm.set("fromDate", (context.get("fromDate") != null ? context.get("fromDate") : now));
newPm.set("thruDate", context.get("thruDate"));
newPm.set("description",context.get("description"));
newGc.set("cardNumber", context.get("cardNumber"));
newGc.set("pinNumber", context.get("pinNumber"));
newGc.set("expireDate", context.get("expireDate"));
newPm.set("paymentMethodId", newPmId);
newPm.set("paymentMethodTypeId", "GIFT_CARD");
newGc.set("paymentMethodId", newPmId);
try {
delegator.storeAll(toBeStored);
} catch (GenericEntityException e) {
Debug.logWarning(e.getMessage(), module);
return ServiceUtil.returnError(UtilProperties.getMessage(resourceError,
"AccountingGiftCardCannotBeCreatedWriteFailure",
UtilMisc.toMap("errorString", e.getMessage()), locale));
}
result.put("paymentMethodId", newGc.getString("paymentMethodId"));
result.put(ModelService.RESPONSE_MESSAGE, ModelService.RESPOND_SUCCESS);
return result;
}
public static Map<String, Object> updateGiftCard(DispatchContext ctx, Map<String, Object> context) {
Map<String, Object> result = new HashMap<String, Object>();
Delegator delegator = ctx.getDelegator();
Security security = ctx.getSecurity();
GenericValue userLogin = (GenericValue) context.get("userLogin");
Locale locale = (Locale) context.get("locale");
Timestamp now = UtilDateTime.nowTimestamp();
String partyId = ServiceUtil.getPartyIdCheckSecurity(userLogin, security, context, result, "PAY_INFO", "_UPDATE", "ACCOUNTING", "_UPDATE");
if (result.size() > 0)
return result;
List<GenericValue> toBeStored = new LinkedList<GenericValue>();
boolean isModified = false;
GenericValue paymentMethod = null;
GenericValue newPm = null;
GenericValue giftCard = null;
GenericValue newGc = null;
String paymentMethodId = (String) context.get("paymentMethodId");
try {
giftCard = EntityQuery.use(delegator).from("GiftCard").where("paymentMethodId", paymentMethodId).queryOne();
paymentMethod = EntityQuery.use(delegator).from("PaymentMethod").where("paymentMethodId", paymentMethodId).queryOne();
} catch (GenericEntityException e) {
Debug.logWarning(e.getMessage(), module);
return ServiceUtil.returnError(UtilProperties.getMessage(resourceError,
"AccountingGiftCardCannotBeUpdated",
UtilMisc.toMap("errorString", e.getMessage()), locale));
}
if (giftCard == null || paymentMethod == null) {
return ServiceUtil.returnError(UtilProperties.getMessage(resourceError,
"AccountingGiftCardCannotBeUpdated",
UtilMisc.toMap("errorString", paymentMethodId), locale));
}
if (!paymentMethod.getString("partyId").equals(partyId) && !security.hasEntityPermission("PAY_INFO", "_UPDATE", userLogin) && !security.hasEntityPermission("ACCOUNTING", "_UPDATE", userLogin)) {
return ServiceUtil.returnError(UtilProperties.getMessage(resourceError,
"AccountingGiftCardPartyNotAuthorized",
UtilMisc.toMap("partyId", partyId, "paymentMethodId", paymentMethodId), locale));
}
// card number (masked)
String cardNumber = StringUtil.removeSpaces((String) context.get("cardNumber"));
if (cardNumber.startsWith("*")) {
// get the masked card number from the db
String origCardNumber = giftCard.getString("cardNumber");
StringBuilder origMaskedNumber = new StringBuilder("");
int cardLength = origCardNumber.length() - 4;
if (cardLength > 0) {
for (int i = 0; i < cardLength; i++) {
origMaskedNumber.append("*");
}
origMaskedNumber.append(origCardNumber.substring(cardLength));
} else {
origMaskedNumber.append(origCardNumber);
}
// compare the two masked numbers
if (cardNumber.equals(origMaskedNumber.toString())) {
cardNumber = origCardNumber;
}
}
context.put("cardNumber", cardNumber);
newPm = GenericValue.create(paymentMethod);
toBeStored.add(newPm);
newGc = GenericValue.create(giftCard);
toBeStored.add(newGc);
String newPmId = null;
try {
newPmId = delegator.getNextSeqId("PaymentMethod");
} catch (IllegalArgumentException e) {
return ServiceUtil.returnError(UtilProperties.getMessage(resourceError,
"AccountingGiftCardCannotBeCreated", locale));
}
newPm.set("partyId", partyId);
newPm.set("fromDate", context.get("fromDate"), false);
newPm.set("thruDate", context.get("thruDate"));
newPm.set("description",context.get("description"));
newGc.set("cardNumber", context.get("cardNumber"));
newGc.set("pinNumber", context.get("pinNumber"));
newGc.set("expireDate", context.get("expireDate"));
if (!newGc.equals(giftCard) || !newPm.equals(paymentMethod)) {
newPm.set("paymentMethodId", newPmId);
newGc.set("paymentMethodId", newPmId);
newPm.set("fromDate", (context.get("fromDate") != null ? context.get("fromDate") : now));
isModified = true;
}
if (isModified) {
// set thru date on old paymentMethod
paymentMethod.set("thruDate", now);
toBeStored.add(paymentMethod);
try {
delegator.storeAll(toBeStored);
} catch (GenericEntityException e) {
Debug.logWarning(e.getMessage(), module);
return ServiceUtil.returnError(UtilProperties.getMessage(resourceError,
"AccountingEftAccountCannotBeUpdated",
UtilMisc.toMap("errorString", e.getMessage()), locale));
}
} else {
result.put("paymentMethodId", paymentMethodId);
result.put("oldPaymentMethodId", paymentMethodId);
result.put(ModelService.RESPONSE_MESSAGE, ModelService.RESPOND_SUCCESS);
result.put(ModelService.SUCCESS_MESSAGE, UtilProperties.getMessage(resource,
"AccountingNoChangesMadeNotUpdatingEftAccount", locale));
return result;
}
result.put("paymentMethodId", newGc.getString("paymentMethodId"));
result.put("oldPaymentMethodId", paymentMethodId);
result.put(ModelService.RESPONSE_MESSAGE, ModelService.RESPOND_SUCCESS);
return result;
}
/**
* Creates EftAccount and PaymentMethod entities according to the parameters passed in the context
* <b>security check</b>: userLogin partyId must equal partyId, or must have PAY_INFO_CREATE permission
* @param ctx The DispatchContext that this service is operating in
* @param context Map containing the input parameters
* @return Map with the result of the service, the output parameters
*/
public static Map<String, Object> createEftAccount(DispatchContext ctx, Map<String, ? extends Object> context) {
Map<String, Object> result = new HashMap<String, Object>();
Delegator delegator = ctx.getDelegator();
Security security = ctx.getSecurity();
GenericValue userLogin = (GenericValue) context.get("userLogin");
Locale locale = (Locale) context.get("locale");
Timestamp now = UtilDateTime.nowTimestamp();
String partyId = ServiceUtil.getPartyIdCheckSecurity(userLogin, security, context, result, "PAY_INFO", "_CREATE", "ACCOUNTING", "_CREATE");
if (result.size() > 0) return result;
List<GenericValue> toBeStored = new LinkedList<GenericValue>();
GenericValue newPm = delegator.makeValue("PaymentMethod");
toBeStored.add(newPm);
GenericValue newEa = delegator.makeValue("EftAccount");
toBeStored.add(newEa);
String newPmId = (String) context.get("paymentMethodId");
if (UtilValidate.isEmpty(newPmId)) {
try {
newPmId = delegator.getNextSeqId("PaymentMethod");
} catch (IllegalArgumentException e) {
return ServiceUtil.returnError(UtilProperties.getMessage(resourceError,
"AccountingEftAccountCannotBeCreated", locale));
}
}
newPm.set("partyId", partyId);
newPm.set("fromDate", (context.get("fromDate") != null ? context.get("fromDate") : now));
newPm.set("thruDate", context.get("thruDate"));
newPm.set("description",context.get("description"));
newEa.set("bankName", context.get("bankName"));
newEa.set("routingNumber", context.get("routingNumber"));
newEa.set("accountType", context.get("accountType"));
newEa.set("accountNumber", context.get("accountNumber"));
newEa.set("nameOnAccount", context.get("nameOnAccount"));
newEa.set("companyNameOnAccount", context.get("companyNameOnAccount"));
newEa.set("contactMechId", context.get("contactMechId"));
newPm.set("paymentMethodId", newPmId);
newPm.set("paymentMethodTypeId", "EFT_ACCOUNT");
newEa.set("paymentMethodId", newPmId);
GenericValue newPartyContactMechPurpose = null;
String contactMechId = (String) context.get("contactMechId");
if (UtilValidate.isNotEmpty(contactMechId)) {
// add a PartyContactMechPurpose of BILLING_LOCATION if necessary
String contactMechPurposeTypeId = "BILLING_LOCATION";
GenericValue tempVal = null;
try {
List<GenericValue> allPCWPs = EntityQuery.use(delegator).from("PartyContactWithPurpose")
.where("partyId", partyId, "contactMechId", contactMechId, "contactMechPurposeTypeId", contactMechPurposeTypeId).queryList();
allPCWPs = EntityUtil.filterByDate(allPCWPs, now, "contactFromDate", "contactThruDate", true);
allPCWPs = EntityUtil.filterByDate(allPCWPs, now, "purposeFromDate", "purposeThruDate", true);
tempVal = EntityUtil.getFirst(allPCWPs);
} catch (GenericEntityException e) {
Debug.logWarning(e.getMessage(), module);
tempVal = null;
}
if (tempVal == null) {
// no value found, create a new one
newPartyContactMechPurpose = delegator.makeValue("PartyContactMechPurpose",
UtilMisc.toMap("partyId", partyId, "contactMechId", contactMechId,
"contactMechPurposeTypeId", contactMechPurposeTypeId, "fromDate", now));
}
}
if (newPartyContactMechPurpose != null)
toBeStored.add(newPartyContactMechPurpose);
try {
delegator.storeAll(toBeStored);
} catch (GenericEntityException e) {
Debug.logWarning(e.getMessage(), module);
return ServiceUtil.returnError(UtilProperties.getMessage(resourceError,
"AccountingEftAccountCannotBeCreatedWriteFailure",
UtilMisc.toMap("errorString", e.getMessage()), locale));
}
result.put("paymentMethodId", newEa.getString("paymentMethodId"));
result.put(ModelService.RESPONSE_MESSAGE, ModelService.RESPOND_SUCCESS);
return result;
}
/**
* Updates EftAccount and PaymentMethod entities according to the parameters passed in the context
* <b>security check</b>: userLogin partyId must equal partyId, or must have PAY_INFO_UPDATE permission
* @param ctx The DispatchContext that this service is operating in
* @param context Map containing the input parameters
* @return Map with the result of the service, the output parameters
*/
public static Map<String, Object> updateEftAccount(DispatchContext ctx, Map<String, ? extends Object> context) {
Map<String, Object> result = new HashMap<String, Object>();
Delegator delegator = ctx.getDelegator();
Security security = ctx.getSecurity();
GenericValue userLogin = (GenericValue) context.get("userLogin");
Locale locale = (Locale) context.get("locale");
Timestamp now = UtilDateTime.nowTimestamp();
String partyId = ServiceUtil.getPartyIdCheckSecurity(userLogin, security, context, result, "PAY_INFO", "_UPDATE", "ACCOUNTING", "_UPDATE");
if (result.size() > 0) return result;
List<GenericValue> toBeStored = new LinkedList<GenericValue>();
boolean isModified = false;
GenericValue paymentMethod = null;
GenericValue newPm = null;
GenericValue eftAccount = null;
GenericValue newEa = null;
String paymentMethodId = (String) context.get("paymentMethodId");
try {
eftAccount = EntityQuery.use(delegator).from("EftAccount").where("paymentMethodId", paymentMethodId).queryOne();
paymentMethod =
EntityQuery.use(delegator).from("PaymentMethod").where("paymentMethodId", paymentMethodId).queryOne();
} catch (GenericEntityException e) {
Debug.logWarning(e.getMessage(), module);
return ServiceUtil.returnError(UtilProperties.getMessage(resourceError,
"AccountingEftAccountCannotBeUpdatedReadFailure",
UtilMisc.toMap("errorString", e.getMessage()), locale));
}
if (eftAccount == null || paymentMethod == null) {
return ServiceUtil.returnError(UtilProperties.getMessage(resourceError,
"AccountingEftAccountCannotBeUpdated",
UtilMisc.toMap("errorString", paymentMethodId), locale));
}
if (!paymentMethod.getString("partyId").equals(partyId) && !security.hasEntityPermission("PAY_INFO", "_UPDATE", userLogin) && !security.hasEntityPermission("ACCOUNTING", "_UPDATE", userLogin)) {
return ServiceUtil.returnError(UtilProperties.getMessage(resourceError,
"AccountingEftAccountCannotBeUpdated",
UtilMisc.toMap("partyId", partyId, "paymentMethodId", paymentMethodId), locale));
}
newPm = GenericValue.create(paymentMethod);
toBeStored.add(newPm);
newEa = GenericValue.create(eftAccount);
toBeStored.add(newEa);
String newPmId = null;
try {
newPmId = delegator.getNextSeqId("PaymentMethod");
} catch (IllegalArgumentException e) {
return ServiceUtil.returnError(UtilProperties.getMessage(resourceError,
"AccountingEftAccountCannotBeCreated", locale));
}
newPm.set("partyId", partyId);
newPm.set("fromDate", context.get("fromDate"), false);
newPm.set("thruDate", context.get("thruDate"));
newPm.set("description",context.get("description"));
newEa.set("bankName", context.get("bankName"));
newEa.set("routingNumber", context.get("routingNumber"));
newEa.set("accountType", context.get("accountType"));
newEa.set("accountNumber", context.get("accountNumber"));
newEa.set("nameOnAccount", context.get("nameOnAccount"));
newEa.set("companyNameOnAccount", context.get("companyNameOnAccount"));
newEa.set("contactMechId", context.get("contactMechId"));
if (!newEa.equals(eftAccount) || !newPm.equals(paymentMethod)) {
newPm.set("paymentMethodId", newPmId);
newEa.set("paymentMethodId", newPmId);
newPm.set("fromDate", (context.get("fromDate") != null ? context.get("fromDate") : now));
isModified = true;
}
GenericValue newPartyContactMechPurpose = null;
String contactMechId = (String) context.get("contactMechId");
if (UtilValidate.isNotEmpty(contactMechId)) {
// add a PartyContactMechPurpose of BILLING_LOCATION if necessary
String contactMechPurposeTypeId = "BILLING_LOCATION";
GenericValue tempVal = null;
try {
List<GenericValue> allPCWPs = EntityQuery.use(delegator).from("PartyContactWithPurpose")
.where("partyId", partyId, "contactMechId", contactMechId, "contactMechPurposeTypeId", contactMechPurposeTypeId).queryList();
allPCWPs = EntityUtil.filterByDate(allPCWPs, now, "contactFromDate", "contactThruDate", true);
allPCWPs = EntityUtil.filterByDate(allPCWPs, now, "purposeFromDate", "purposeThruDate", true);
tempVal = EntityUtil.getFirst(allPCWPs);
} catch (GenericEntityException e) {
Debug.logWarning(e.getMessage(), module);
tempVal = null;
}
if (tempVal == null) {
// no value found, create a new one
newPartyContactMechPurpose = delegator.makeValue("PartyContactMechPurpose",
UtilMisc.toMap("partyId", partyId, "contactMechId", contactMechId,
"contactMechPurposeTypeId", contactMechPurposeTypeId, "fromDate", now));
}
}
if (isModified) {
// Debug.logInfo("yes, is modified", module);
if (newPartyContactMechPurpose != null)
toBeStored.add(newPartyContactMechPurpose);
// set thru date on old paymentMethod
paymentMethod.set("thruDate", now);
toBeStored.add(paymentMethod);
try {
delegator.storeAll(toBeStored);
} catch (GenericEntityException e) {
Debug.logWarning(e.getMessage(), module);
return ServiceUtil.returnError(UtilProperties.getMessage(resourceError,
"AccountingEftAccountCannotBeUpdated",
UtilMisc.toMap("errorString", e.getMessage()), locale));
}
} else {
result.put("paymentMethodId", paymentMethodId);
result.put("oldPaymentMethodId", paymentMethodId);
result.put(ModelService.RESPONSE_MESSAGE, ModelService.RESPOND_SUCCESS);
result.put(ModelService.SUCCESS_MESSAGE, UtilProperties.getMessage(resource,
"AccountingNoChangesMadeNotUpdatingEftAccount", locale));
return result;
}
result.put("paymentMethodId", newEa.getString("paymentMethodId"));
result.put("oldPaymentMethodId", paymentMethodId);
result.put(ModelService.RESPONSE_MESSAGE, ModelService.RESPOND_SUCCESS);
return result;
}
public static Map<String, Object> createCheckAccount(DispatchContext ctx, Map<String, ? extends Object> context) {
Map<String, Object> result = new HashMap<String, Object>();
Delegator delegator = ctx.getDelegator();
Security security = ctx.getSecurity();
GenericValue userLogin = (GenericValue) context.get("userLogin");
Locale locale = (Locale) context.get("locale");
Timestamp now = UtilDateTime.nowTimestamp();
String partyId = ServiceUtil.getPartyIdCheckSecurity(userLogin, security, context, result, "PAY_INFO", "_CREATE", "ACCOUNTING", "_CREATE");
if (result.size() > 0) return result;
List<GenericValue> toBeStored = new LinkedList<GenericValue>();
GenericValue newPm = delegator.makeValue("PaymentMethod");
toBeStored.add(newPm);
GenericValue newCa = delegator.makeValue("CheckAccount");
toBeStored.add(newCa);
String newPmId = (String) context.get("paymentMethodId");
if (UtilValidate.isEmpty(newPmId)) {
try {
newPmId = delegator.getNextSeqId("PaymentMethod");
} catch (IllegalArgumentException e) {
return ServiceUtil.returnError(UtilProperties.getMessage(resourceError, "AccountingCheckNotAdded", locale));
}
}
newPm.set("partyId", partyId);
newPm.set("description",context.get("description"));
newPm.set("paymentMethodTypeId", context.get("paymentMethodTypeId"));
newPm.set("fromDate", now);
newPm.set("paymentMethodId", newPmId);
newCa.set("bankName", context.get("bankName"));
newCa.set("routingNumber", context.get("routingNumber"));
newCa.set("accountType", context.get("accountType"));
newCa.set("accountNumber", context.get("accountNumber"));
newCa.set("nameOnAccount", context.get("nameOnAccount"));
newCa.set("companyNameOnAccount", context.get("companyNameOnAccount"));
newCa.set("contactMechId", context.get("contactMechId"));
newCa.set("paymentMethodId", newPmId);
GenericValue newPartyContactMechPurpose = null;
String contactMechId = (String) context.get("contactMechId");
if (UtilValidate.isNotEmpty(contactMechId)) {
// add a PartyContactMechPurpose of BILLING_LOCATION if necessary
String contactMechPurposeTypeId = "BILLING_LOCATION";
GenericValue tempVal = null;
try {
List<GenericValue> allPCWPs = EntityQuery.use(delegator).from("PartyContactWithPurpose")
.where("partyId", partyId, "contactMechId", contactMechId, "contactMechPurposeTypeId", contactMechPurposeTypeId).queryList();
allPCWPs = EntityUtil.filterByDate(allPCWPs, now, "contactFromDate", "contactThruDate", true);
allPCWPs = EntityUtil.filterByDate(allPCWPs, now, "purposeFromDate", "purposeThruDate", true);
tempVal = EntityUtil.getFirst(allPCWPs);
} catch (GenericEntityException e) {
Debug.logWarning(e.getMessage(), module);
tempVal = null;
}
if (tempVal == null) {
// no value found, create a new one
newPartyContactMechPurpose = delegator.makeValue("PartyContactMechPurpose",
UtilMisc.toMap("partyId", partyId, "contactMechId", contactMechId,
"contactMechPurposeTypeId", contactMechPurposeTypeId, "fromDate", now));
}
}
if (newPartyContactMechPurpose != null)
toBeStored.add(newPartyContactMechPurpose);
try {
delegator.storeAll(toBeStored);
} catch (GenericEntityException e) {
Debug.logWarning(e.getMessage(), module);
return ServiceUtil.returnError(UtilProperties.getMessage(resourceError, "AccountingCheckNotAdded", UtilMisc.toMap("errorString", e.getMessage()), locale));
}
result.put("paymentMethodId", newPm.getString("paymentMethodId"));
result.put(ModelService.RESPONSE_MESSAGE, ModelService.RESPOND_SUCCESS);
return result;
}
public static Map<String, Object> updateCheckAccount(DispatchContext ctx, Map<String, ? extends Object> context) {
Map<String, Object> result = new HashMap<String, Object>();
Delegator delegator = ctx.getDelegator();
Security security = ctx.getSecurity();
GenericValue userLogin = (GenericValue) context.get("userLogin");
Locale locale = (Locale) context.get("locale");
Timestamp now = UtilDateTime.nowTimestamp();
String partyId = ServiceUtil.getPartyIdCheckSecurity(userLogin, security, context, result, "PAY_INFO", "_UPDATE", "ACCOUNTING", "_UPDATE");
if (result.size() > 0) return result;
List<GenericValue> toBeStored = new LinkedList<GenericValue>();
boolean isModified = false;
GenericValue paymentMethod = null;
GenericValue newPm = null;
GenericValue checkAccount = null;
GenericValue newCa = null;
String paymentMethodId = (String) context.get("paymentMethodId");
try {
checkAccount = EntityQuery.use(delegator).from("CheckAccount").where("paymentMethodId", paymentMethodId).queryOne();
paymentMethod =
EntityQuery.use(delegator).from("PaymentMethod").where("paymentMethodId", paymentMethodId).queryOne();
} catch (GenericEntityException e) {
Debug.logWarning(e.getMessage(), module);
return ServiceUtil.returnError(UtilProperties.getMessage(resourceError,
"AccountingCheckAccountCannotBeUpdated",
UtilMisc.toMap("errorString", e.getMessage()), locale));
}
if (checkAccount == null || paymentMethod == null) {
return ServiceUtil.returnError(UtilProperties.getMessage(resourceError,
"AccountingCheckAccountCannotBeUpdated",
UtilMisc.toMap("errorString", paymentMethodId), locale));
}
if (!paymentMethod.getString("partyId").equals(partyId) && !security.hasEntityPermission("PAY_INFO", "_UPDATE", userLogin) && !security.hasEntityPermission("ACCOUNTING", "_UPDATE", userLogin)) {
return ServiceUtil.returnError(UtilProperties.getMessage(resourceError,
"AccountingCheckAccountCannotBeUpdated",
UtilMisc.toMap("partyId", partyId, "paymentMethodId", paymentMethodId), locale));
}
newPm = GenericValue.create(paymentMethod);
toBeStored.add(newPm);
newCa = GenericValue.create(checkAccount);
toBeStored.add(newCa);
String newPmId = null;
try {
newPmId = delegator.getNextSeqId("PaymentMethod");
} catch (IllegalArgumentException e) {
return ServiceUtil.returnError(UtilProperties.getMessage(resourceError,
"AccountingCheckAccountCannotBeUpdated", locale));
}
newPm.set("partyId", partyId);
newPm.set("paymentMethodTypeId", context.get("paymentMethodTypeId"));
newPm.set("fromDate", context.get("fromDate"), false);
newPm.set("description",context.get("description"));
newCa.set("bankName", context.get("bankName"));
newCa.set("routingNumber", context.get("routingNumber"));
newCa.set("accountType", context.get("accountType"));
newCa.set("accountNumber", context.get("accountNumber"));
newCa.set("nameOnAccount", context.get("nameOnAccount"));
newCa.set("companyNameOnAccount", context.get("companyNameOnAccount"));
newCa.set("contactMechId", context.get("contactMechId"));
if (!newCa.equals(checkAccount) || !newPm.equals(paymentMethod)) {
newPm.set("paymentMethodId", newPmId);
newCa.set("paymentMethodId", newPmId);
newPm.set("fromDate", (context.get("fromDate") != null ? context.get("fromDate") : now));
isModified = true;
}
GenericValue newPartyContactMechPurpose = null;
String contactMechId = (String) context.get("contactMechId");
if (UtilValidate.isNotEmpty(contactMechId)) {
// add a PartyContactMechPurpose of BILLING_LOCATION if necessary
String contactMechPurposeTypeId = "BILLING_LOCATION";
GenericValue tempVal = null;
try {
List<GenericValue> allPCWPs = EntityQuery.use(delegator).from("PartyContactWithPurpose")
.where("partyId", partyId, "contactMechId", contactMechId, "contactMechPurposeTypeId", contactMechPurposeTypeId).queryList();
allPCWPs = EntityUtil.filterByDate(allPCWPs, now, "contactFromDate", "contactThruDate", true);
allPCWPs = EntityUtil.filterByDate(allPCWPs, now, "purposeFromDate", "purposeThruDate", true);
tempVal = EntityUtil.getFirst(allPCWPs);
} catch (GenericEntityException e) {
Debug.logWarning(e.getMessage(), module);
tempVal = null;
}
if (tempVal == null) {
// no value found, create a new one
newPartyContactMechPurpose = delegator.makeValue("PartyContactMechPurpose",
UtilMisc.toMap("partyId", partyId, "contactMechId", contactMechId,
"contactMechPurposeTypeId", contactMechPurposeTypeId, "fromDate", now));
}
}
if (isModified) {
// Debug.logInfo("yes, is modified", module);
if (newPartyContactMechPurpose != null)
toBeStored.add(newPartyContactMechPurpose);
// set thru date on old paymentMethod
paymentMethod.set("thruDate", now);
toBeStored.add(paymentMethod);
try {
delegator.storeAll(toBeStored);
} catch (GenericEntityException e) {
Debug.logWarning(e.getMessage(), module);
return ServiceUtil.returnError(UtilProperties.getMessage(resourceError,
"AccountingCheckAccountCannotBeUpdated",
UtilMisc.toMap("errorString", e.getMessage()), locale));
}
} else {
result.put("paymentMethodId", paymentMethodId);
result.put("oldPaymentMethodId", paymentMethodId);
result.put(ModelService.RESPONSE_MESSAGE, ModelService.RESPOND_SUCCESS);
result.put(ModelService.SUCCESS_MESSAGE, UtilProperties.getMessage(resource,
"AccountingCheckAccountCannotBeUpdated", locale));
return result;
}
result.put("paymentMethodId", newCa.getString("paymentMethodId"));
result.put("oldPaymentMethodId", paymentMethodId);
result.put(ModelService.RESPONSE_MESSAGE, ModelService.RESPOND_SUCCESS);
return result;
}
}