| /******************************************************************************* |
| * 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.security.SecureRandom; |
| import java.sql.Timestamp; |
| import java.util.HashMap; |
| import java.util.List; |
| import java.util.Locale; |
| import java.util.Map; |
| import java.util.Random; |
| |
| import org.apache.ofbiz.base.util.Debug; |
| import org.apache.ofbiz.base.util.GeneralException; |
| 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.EntityUtilProperties; |
| import org.apache.ofbiz.order.finaccount.FinAccountHelper; |
| import org.apache.ofbiz.order.order.OrderReadHelper; |
| import org.apache.ofbiz.product.store.ProductStoreWorker; |
| import org.apache.ofbiz.service.DispatchContext; |
| import org.apache.ofbiz.service.GenericServiceException; |
| import org.apache.ofbiz.service.LocalDispatcher; |
| import org.apache.ofbiz.service.ServiceUtil; |
| |
| |
| public class GiftCertificateServices { |
| |
| public static final String module = GiftCertificateServices.class.getName(); |
| public static final String resourceError = "AccountingErrorUiLabels"; |
| public static final String resourceOrderError = "OrderErrorUiLabels"; |
| // These are default settings, in case ProductStoreFinActSetting does not have them |
| public static final int CARD_NUMBER_LENGTH = 14; |
| public static final int PIN_NUMBER_LENGTH = 6; |
| |
| public static BigDecimal ZERO = BigDecimal.ZERO; |
| |
| // Base Gift Certificate Services |
| public static Map<String, Object> createGiftCertificate(DispatchContext dctx, Map<String, ? extends Object> context) { |
| LocalDispatcher dispatcher = dctx.getDispatcher(); |
| Delegator delegator = dctx.getDelegator(); |
| Locale locale = (Locale) context.get("locale"); |
| GenericValue userLogin = (GenericValue) context.get("userLogin"); |
| String productStoreId = (String) context.get("productStoreId"); |
| BigDecimal initialAmount = (BigDecimal) context.get("initialAmount"); |
| |
| String partyId = (String) context.get("partyId"); |
| if (UtilValidate.isEmpty(partyId)) { |
| partyId = "_NA_"; |
| } |
| String currencyUom = (String) context.get("currency"); |
| if (UtilValidate.isEmpty(currencyUom)) { |
| currencyUom = EntityUtilProperties.getPropertyValue("general", "currency.uom.id.default", "USD", delegator); |
| } |
| |
| String cardNumber = null; |
| String pinNumber = null; |
| String refNum = null; |
| String finAccountId = null; |
| try { |
| final String accountName = "Gift Certificate Account"; |
| final String deposit = "DEPOSIT"; |
| |
| GenericValue giftCertSettings = EntityQuery.use(delegator).from("ProductStoreFinActSetting") |
| .where("productStoreId", productStoreId, "finAccountTypeId", FinAccountHelper.giftCertFinAccountTypeId) |
| .cache().queryOne(); |
| Map<String, Object> acctResult = null; |
| |
| if ("Y".equals(giftCertSettings.getString("requirePinCode"))) { |
| // TODO: move this code to createFinAccountForStore as well |
| int cardNumberLength = CARD_NUMBER_LENGTH; |
| int pinNumberLength = PIN_NUMBER_LENGTH; |
| if (giftCertSettings.getLong("accountCodeLength") != null) { |
| cardNumberLength = giftCertSettings.getLong("accountCodeLength").intValue(); |
| } |
| if (giftCertSettings.getLong("pinCodeLength") != null) { |
| pinNumberLength = giftCertSettings.getLong("pinCodeLength").intValue(); |
| } |
| cardNumber = generateNumber(delegator, cardNumberLength, true); |
| pinNumber = generateNumber(delegator, pinNumberLength, false); |
| |
| // in this case, the card number is the finAccountId |
| finAccountId = cardNumber; |
| |
| // create the FinAccount |
| Map<String, Object> acctCtx = UtilMisc.<String, Object>toMap("finAccountId", finAccountId); |
| acctCtx.put("finAccountTypeId", FinAccountHelper.giftCertFinAccountTypeId); |
| acctCtx.put("finAccountName", accountName); |
| acctCtx.put("finAccountCode", pinNumber); |
| acctCtx.put("userLogin", userLogin); |
| acctResult = dispatcher.runSync("createFinAccount", acctCtx); |
| } else { |
| acctResult = dispatcher.runSync("createFinAccountForStore", UtilMisc.<String, Object>toMap("productStoreId", productStoreId, "finAccountTypeId", FinAccountHelper.giftCertFinAccountTypeId, "userLogin", userLogin)); |
| if (acctResult.get("finAccountId") != null) { |
| finAccountId = cardNumber = (String) acctResult.get("finAccountId"); |
| } |
| if (acctResult.get("finAccountCode") != null) { |
| cardNumber = (String) acctResult.get("finAccountCode"); |
| } |
| } |
| |
| if (ServiceUtil.isError(acctResult)) { |
| String error = ServiceUtil.getErrorMessage(acctResult); |
| return ServiceUtil.returnError(error); |
| } |
| |
| // create the initial (deposit) transaction |
| // do something tricky here: run as the "system" user |
| // that can actually create a financial account transaction |
| GenericValue permUserLogin = EntityQuery.use(delegator).from("UserLogin").where("userLoginId", "system").cache().queryOne(); |
| refNum = createTransaction(delegator, dispatcher, permUserLogin, initialAmount, productStoreId, |
| partyId, currencyUom, deposit, finAccountId, locale); |
| |
| } catch (GenericEntityException e) { |
| Debug.logError(e, module); |
| return ServiceUtil.returnError(UtilProperties.getMessage(resourceError, |
| "AccountingGiftCerticateNumberCreationError", locale)); |
| } catch (GenericServiceException e) { |
| Debug.logError(e, module); |
| return ServiceUtil.returnError(UtilProperties.getMessage(resourceError, |
| "AccountingGiftCerticateNumberCreationError", locale)); |
| } catch (GeneralException e) { |
| Debug.logError(e, module); |
| return ServiceUtil.returnError(e.getMessage()); |
| } |
| |
| Map<String, Object> result = ServiceUtil.returnSuccess(); |
| result.put("cardNumber", cardNumber); |
| result.put("pinNumber", pinNumber); |
| result.put("initialAmount", initialAmount); |
| result.put("processResult", Boolean.TRUE); |
| result.put("responseCode", "1"); |
| result.put("referenceNum", refNum); |
| Debug.logInfo("Create GC Result - " + result, module); |
| return result; |
| } |
| |
| public static Map<String, Object> addFundsToGiftCertificate(DispatchContext dctx, Map<String, ? extends Object> context) { |
| LocalDispatcher dispatcher = dctx.getDispatcher(); |
| Delegator delegator = dctx.getDelegator(); |
| Locale locale = (Locale) context.get("locale"); |
| final String deposit = "DEPOSIT"; |
| |
| GenericValue userLogin = (GenericValue) context.get("userLogin"); |
| String productStoreId = (String) context.get("productStoreId"); |
| String cardNumber = (String) context.get("cardNumber"); |
| String pinNumber = (String) context.get("pinNumber"); |
| BigDecimal amount = (BigDecimal) context.get("amount"); |
| |
| String partyId = (String) context.get("partyId"); |
| if (UtilValidate.isEmpty(partyId)) { |
| partyId = "_NA_"; |
| } |
| String currencyUom = (String) context.get("currency"); |
| if (UtilValidate.isEmpty(currencyUom)) { |
| currencyUom = EntityUtilProperties.getPropertyValue("general", "currency.uom.id.default", "USD", delegator); |
| } |
| |
| String finAccountId = null; |
| GenericValue finAccount = null; |
| // validate the pin if the store requires it and figure out the finAccountId from card number |
| try { |
| GenericValue giftCertSettings = EntityQuery.use(delegator).from("ProductStoreFinActSetting") |
| .where("productStoreId", productStoreId, "finAccountTypeId", FinAccountHelper.giftCertFinAccountTypeId) |
| .cache().queryOne(); |
| if ("Y".equals(giftCertSettings.getString("requirePinCode"))) { |
| if (!validatePin(delegator, cardNumber, pinNumber)) { |
| return ServiceUtil.returnError(UtilProperties.getMessage(resourceError, |
| "AccountingGiftCerticateNumberPinNotValid", locale)); |
| } |
| finAccountId = cardNumber; |
| } else { |
| finAccount = FinAccountHelper.getFinAccountFromCode(cardNumber, delegator); |
| if (finAccount != null) { |
| finAccountId = finAccount.getString("finAccountId"); |
| } |
| } |
| } catch (GenericEntityException e) { |
| return ServiceUtil.returnError(UtilProperties.getMessage(resourceError, |
| "AccountingFinAccountSetting", |
| UtilMisc.toMap("productStoreId", productStoreId, |
| "finAccountTypeId", FinAccountHelper.giftCertFinAccountTypeId), locale)); |
| } |
| |
| if (finAccountId == null) { |
| return ServiceUtil.returnError(UtilProperties.getMessage(resourceError, |
| "AccountingFinAccountNotFound", UtilMisc.toMap("finAccountId", ""), locale)); |
| } |
| |
| if (finAccount == null) { |
| try { |
| finAccount = EntityQuery.use(delegator).from("FinAccount").where("finAccountId", finAccountId).queryOne(); |
| } catch (GenericEntityException e) { |
| return ServiceUtil.returnError(UtilProperties.getMessage(resourceError, |
| "AccountingFinAccountNotFound", UtilMisc.toMap("finAccountId", finAccountId), locale)); |
| } |
| } |
| |
| // get the previous balance |
| BigDecimal previousBalance = ZERO; |
| if (finAccount.get("availableBalance") != null) { |
| previousBalance = finAccount.getBigDecimal("availableBalance"); |
| } |
| |
| // create the transaction |
| BigDecimal balance = ZERO; |
| String refNum = null; |
| try { |
| refNum = GiftCertificateServices.createTransaction(delegator, dispatcher, userLogin, amount, productStoreId, partyId, |
| currencyUom, deposit, finAccountId, locale); |
| finAccount.refresh(); |
| balance = finAccount.getBigDecimal("availableBalance"); |
| } catch (GeneralException e) { |
| Debug.logError(e, module); |
| return ServiceUtil.returnError(e.getMessage()); |
| } |
| |
| Map<String, Object> result = ServiceUtil.returnSuccess(); |
| result.put("previousBalance", previousBalance); |
| result.put("balance", balance); |
| result.put("amount", amount); |
| result.put("processResult", Boolean.TRUE); |
| result.put("responseCode", "1"); |
| result.put("referenceNum", refNum); |
| Debug.logInfo("Add Funds GC Result - " + result, module); |
| return result; |
| } |
| |
| public static Map<String, Object> redeemGiftCertificate(DispatchContext dctx, Map<String, ? extends Object> context) { |
| LocalDispatcher dispatcher = dctx.getDispatcher(); |
| Delegator delegator = dctx.getDelegator(); |
| final String withdrawl = "WITHDRAWAL"; |
| Locale locale = (Locale) context.get("locale"); |
| GenericValue userLogin = (GenericValue) context.get("userLogin"); |
| String productStoreId = (String) context.get("productStoreId"); |
| String cardNumber = (String) context.get("cardNumber"); |
| String pinNumber = (String) context.get("pinNumber"); |
| BigDecimal amount = (BigDecimal) context.get("amount"); |
| |
| String partyId = (String) context.get("partyId"); |
| if (UtilValidate.isEmpty(partyId)) { |
| partyId = "_NA_"; |
| } |
| String currencyUom = (String) context.get("currency"); |
| if (UtilValidate.isEmpty(currencyUom)) { |
| currencyUom = EntityUtilProperties.getPropertyValue("general", "currency.uom.id.default", "USD", delegator); |
| } |
| |
| // validate the amount |
| if (amount.compareTo(BigDecimal.ZERO) < 0) { |
| return ServiceUtil.returnError(UtilProperties.getMessage(resourceError, |
| "AccountingFinAccountMustBePositive", locale)); |
| } |
| |
| // validate the pin if the store requires it |
| try { |
| GenericValue giftCertSettings = EntityQuery.use(delegator).from("ProductStoreFinActSetting") |
| .where("productStoreId", productStoreId, "finAccountTypeId", FinAccountHelper.giftCertFinAccountTypeId) |
| .cache().queryOne(); |
| if ("Y".equals(giftCertSettings.getString("requirePinCode")) && !validatePin(delegator, cardNumber, pinNumber)) { |
| return ServiceUtil.returnError(UtilProperties.getMessage(resourceError, |
| "AccountingGiftCerticateNumberPinNotValid", locale)); |
| } |
| } catch (GenericEntityException ex) { |
| return ServiceUtil.returnError(UtilProperties.getMessage(resourceError, |
| "AccountingFinAccountSetting", |
| UtilMisc.toMap("productStoreId", productStoreId, |
| "finAccountTypeId", FinAccountHelper.giftCertFinAccountTypeId), locale)); |
| } |
| Debug.logInfo("Attempting to redeem GC for " + amount, module); |
| |
| GenericValue finAccount = null; |
| try { |
| finAccount = EntityQuery.use(delegator).from("FinAccount").where("finAccountId", cardNumber).queryOne(); |
| } catch (GenericEntityException e) { |
| return ServiceUtil.returnError(UtilProperties.getMessage(resourceError, |
| "AccountingFinAccountNotFound", UtilMisc.toMap("finAccountId", cardNumber), locale)); |
| } |
| |
| // check the actual balance (excluding authorized amounts) and create the transaction if it is sufficient |
| BigDecimal previousBalance = finAccount.get("actualBalance") == null ? BigDecimal.ZERO : finAccount.getBigDecimal("actualBalance"); |
| |
| BigDecimal balance = BigDecimal.ZERO; |
| String refNum = null; |
| Boolean procResult; |
| if (previousBalance.compareTo(amount) >= 0) { |
| try { |
| refNum = GiftCertificateServices.createTransaction(delegator, dispatcher, userLogin, amount, productStoreId, |
| partyId, currencyUom, withdrawl, cardNumber, locale); |
| finAccount.refresh(); |
| balance = finAccount.get("availableBalance") == null ? BigDecimal.ZERO : finAccount.getBigDecimal("availableBalance"); |
| procResult = Boolean.TRUE; |
| } catch (GeneralException e) { |
| Debug.logError(e, module); |
| return ServiceUtil.returnError(e.getMessage()); |
| } |
| } else { |
| procResult = Boolean.FALSE; |
| balance = previousBalance; |
| refNum = "N/A"; |
| } |
| |
| Map<String, Object> result = ServiceUtil.returnSuccess(); |
| result.put("previousBalance", previousBalance); |
| result.put("balance", balance); |
| result.put("amount", amount); |
| result.put("processResult", procResult); |
| result.put("responseCode", "2"); |
| result.put("referenceNum", refNum); |
| Debug.logInfo("Redeem GC Result - " + result, module); |
| return result; |
| } |
| |
| public static Map<String, Object> checkGiftCertificateBalance(DispatchContext dctx, Map<String, ? extends Object> context) { |
| Delegator delegator = dctx.getDelegator(); |
| String cardNumber = (String) context.get("cardNumber"); |
| String pinNumber = (String) context.get("pinNumber"); |
| Locale locale = (Locale) context.get("locale"); |
| |
| // validate the pin |
| if (!validatePin(delegator, cardNumber, pinNumber)) { |
| return ServiceUtil.returnError(UtilProperties.getMessage(resourceError, |
| "AccountingGiftCerticateNumberPinNotValid", locale)); |
| } |
| |
| GenericValue finAccount = null; |
| try { |
| finAccount = EntityQuery.use(delegator).from("FinAccount").where("finAccountId", cardNumber).queryOne(); |
| } catch (GenericEntityException e) { |
| return ServiceUtil.returnError(UtilProperties.getMessage(resourceError, |
| "AccountingFinAccountNotFound", UtilMisc.toMap("finAccountId", cardNumber), locale)); |
| } |
| |
| // TODO: get the real currency from context |
| // get the balance |
| BigDecimal balance = finAccount.get("availableBalance") == null ? BigDecimal.ZERO : finAccount.getBigDecimal("availableBalance"); |
| |
| Map<String, Object> result = ServiceUtil.returnSuccess(); |
| result.put("balance", balance); |
| Debug.logInfo("GC Balance Result - " + result, module); |
| return result; |
| } |
| |
| // Fullfilment Services |
| public static Map<String, Object> giftCertificateProcessor(DispatchContext dctx, Map<String, ? extends Object> context) { |
| LocalDispatcher dispatcher = dctx.getDispatcher(); |
| Delegator delegator = dctx.getDelegator(); |
| GenericValue userLogin = (GenericValue) context.get("userLogin"); |
| Locale locale = (Locale) context.get("locale"); |
| BigDecimal amount = (BigDecimal) context.get("processAmount"); |
| String currency = (String) context.get("currency"); |
| // make sure we have a currency |
| if (currency == null) { |
| currency = EntityUtilProperties.getPropertyValue("general", "currency.uom.id.default", "USD", delegator); |
| } |
| |
| // get the authorizations |
| GenericValue orderPaymentPreference = (GenericValue) context.get("orderPaymentPreference"); |
| GenericValue authTransaction = (GenericValue) context.get("authTrans"); |
| if (authTransaction == null) { |
| authTransaction = PaymentGatewayServices.getAuthTransaction(orderPaymentPreference); |
| } |
| if (authTransaction == null) { |
| return ServiceUtil.returnError(UtilProperties.getMessage(resourceError, |
| "AccountingFinAccountCannotCapture", locale)); |
| } |
| |
| // get the gift certificate and its authorization from the authorization |
| String finAccountAuthId = authTransaction.getString("referenceNum"); |
| try { |
| GenericValue finAccountAuth = EntityQuery.use(delegator).from("FinAccountAuth").where("finAccountAuthId", finAccountAuthId).queryOne(); |
| GenericValue giftCard = finAccountAuth.getRelatedOne("FinAccount", false); |
| // make sure authorization has not expired |
| Timestamp authExpiration = finAccountAuth.getTimestamp("thruDate"); |
| if ((authExpiration != null) && (authExpiration.before(UtilDateTime.nowTimestamp()))) { |
| return ServiceUtil.returnError(UtilProperties.getMessage(resourceError, |
| "AccountingFinAccountAuthorizationExpired", |
| UtilMisc.toMap("paymentGatewayResponseId", authTransaction.getString("paymentGatewayResponseId"), |
| "authExpiration", authExpiration), locale)); |
| } |
| // make sure the fin account itself has not expired |
| if ((giftCard.getTimestamp("thruDate") != null) && (giftCard.getTimestamp("thruDate").before(UtilDateTime.nowTimestamp()))) { |
| return ServiceUtil.returnError(UtilProperties.getMessage(resourceError, |
| "AccountingGiftCerticateNumberExpired", |
| UtilMisc.toMap("thruDate", giftCard.getTimestamp("thruDate")), locale)); |
| } |
| |
| // obtain the order information |
| OrderReadHelper orh = new OrderReadHelper(delegator, orderPaymentPreference.getString("orderId")); |
| |
| Map<String, Object> redeemCtx = new HashMap<String, Object>(); |
| redeemCtx.put("userLogin", userLogin); |
| redeemCtx.put("productStoreId", orh.getProductStoreId()); |
| redeemCtx.put("cardNumber", giftCard.get("finAccountId")); |
| redeemCtx.put("pinNumber", giftCard.get("finAccountCode")); |
| redeemCtx.put("currency", currency); |
| if (orh.getBillToParty() != null) { |
| redeemCtx.put("partyId", orh.getBillToParty().get("partyId")); |
| } |
| redeemCtx.put("amount", amount); |
| |
| // invoke the redeem service |
| Map<String, Object> redeemResult = null; |
| redeemResult = dispatcher.runSync("redeemGiftCertificate", redeemCtx); |
| if (ServiceUtil.isError(redeemResult)) { |
| return redeemResult; |
| } |
| |
| // now release the authorization should this use the gift card release service? |
| Map<String, Object> releaseResult = dispatcher.runSync("expireFinAccountAuth", |
| UtilMisc.<String, Object>toMap("userLogin", userLogin, "finAccountAuthId", finAccountAuthId)); |
| if (ServiceUtil.isError(releaseResult)) { |
| return releaseResult; |
| } |
| |
| String authRefNum = authTransaction.getString("referenceNum"); |
| Map<String, Object> result = ServiceUtil.returnSuccess(); |
| if (redeemResult != null) { |
| Boolean processResult = (Boolean) redeemResult.get("processResult"); |
| result.put("processAmount", amount); |
| result.put("captureResult", processResult); |
| result.put("captureCode", "C"); |
| result.put("captureRefNum", redeemResult.get("referenceNum")); |
| result.put("authRefNum", authRefNum); |
| } |
| |
| return result; |
| |
| } catch (GenericEntityException ex) { |
| return ServiceUtil.returnError(UtilProperties.getMessage(resourceError, |
| "AccountingGiftCerticateNumberCannotProcess", |
| UtilMisc.toMap("errorString", ex.getMessage()), locale)); |
| } catch (GenericServiceException ex) { |
| return ServiceUtil.returnError(UtilProperties.getMessage(resourceError, |
| "AccountingGiftCerticateNumberCannotProcess", |
| UtilMisc.toMap("errorString", ex.getMessage()), locale)); |
| } |
| } |
| |
| |
| public static Map<String, Object> giftCertificateAuthorize(DispatchContext dctx, Map<String, ? extends Object> context) { |
| LocalDispatcher dispatcher = dctx.getDispatcher(); |
| Delegator delegator = dctx.getDelegator(); |
| GenericValue userLogin = (GenericValue) context.get("userLogin"); |
| Locale locale = (Locale) context.get("locale"); |
| GenericValue giftCard = (GenericValue) context.get("giftCard"); |
| String currency = (String) context.get("currency"); |
| String orderId = (String) context.get("orderId"); |
| BigDecimal amount = (BigDecimal) context.get("processAmount"); |
| |
| // make sure we have a currency |
| if (currency == null) { |
| currency = EntityUtilProperties.getPropertyValue("general", "currency.uom.id.default", "USD", delegator); |
| } |
| |
| // obtain the order information |
| OrderReadHelper orh = new OrderReadHelper(delegator, orderId); |
| String productStoreId = orh.getProductStoreId(); |
| try { |
| // if the store requires pin codes, then validate pin code against card number, and the gift certificate's finAccountId is the gift card's card number |
| // otherwise, the gift card's card number is an ecrypted string, which must be decoded to find the FinAccount |
| GenericValue giftCertSettings = EntityQuery.use(delegator).from("ProductStoreFinActSetting") |
| .where("productStoreId", productStoreId, "finAccountTypeId", FinAccountHelper.giftCertFinAccountTypeId) |
| .cache().queryOne(); |
| GenericValue finAccount = null; |
| String finAccountId = null; |
| if (UtilValidate.isNotEmpty(giftCertSettings)) { |
| if ("Y".equals(giftCertSettings.getString("requirePinCode"))) { |
| if (validatePin(delegator, giftCard.getString("cardNumber"), giftCard.getString("pinNumber"))) { |
| finAccountId = giftCard.getString("cardNumber"); |
| finAccount = EntityQuery.use(delegator).from("FinAccount").where("finAccountId", finAccountId).queryOne(); |
| } |
| } else { |
| finAccount = FinAccountHelper.getFinAccountFromCode(giftCard.getString("cardNumber"), delegator); |
| if (finAccount == null) { |
| return ServiceUtil.returnError(UtilProperties.getMessage(resourceError, |
| "AccountingGiftCerticateNumberNotFound", |
| UtilMisc.toMap("finAccountId", ""), locale)); |
| } |
| finAccountId = finAccount.getString("finAccountId"); |
| } |
| } else { |
| return ServiceUtil.returnError(UtilProperties.getMessage(resourceError, |
| "AccountingFinAccountSetting", |
| UtilMisc.toMap("productStoreId", productStoreId, |
| "finAccountTypeId", FinAccountHelper.giftCertFinAccountTypeId), locale)); |
| } |
| |
| if (finAccountId == null) { |
| return ServiceUtil.returnError(UtilProperties.getMessage(resourceError, |
| "AccountingGiftCerticateNumberPinNotValid", locale)); |
| } |
| |
| // check for expiration date |
| if ((finAccount.getTimestamp("thruDate") != null) && (finAccount.getTimestamp("thruDate").before(UtilDateTime.nowTimestamp()))) { |
| return ServiceUtil.returnError(UtilProperties.getMessage(resourceError, |
| "AccountingGiftCerticateNumberExpired", |
| UtilMisc.toMap("thruDate", finAccount.getTimestamp("thruDate")), locale)); |
| } |
| |
| // check the amount to authorize against the available balance of fin account, which includes active authorizations as well as transactions |
| BigDecimal availableBalance = finAccount.getBigDecimal("availableBalance"); |
| Boolean processResult = null; |
| String refNum = null; |
| Map<String, Object> result = ServiceUtil.returnSuccess(); |
| |
| // make sure to round and scale it to the same as availableBalance |
| amount = amount.setScale(FinAccountHelper.decimals, FinAccountHelper.rounding); |
| |
| // if availableBalance equal to or greater than amount, then auth |
| if (UtilValidate.isNotEmpty(availableBalance) && availableBalance.compareTo(amount) >= 0) { |
| Timestamp thruDate = null; |
| if (giftCertSettings.getLong("authValidDays") != null) { |
| thruDate = UtilDateTime.getDayEnd(UtilDateTime.nowTimestamp(), giftCertSettings.getLong("authValidDays")); |
| } |
| Map<String, Object> tmpResult = dispatcher.runSync("createFinAccountAuth", |
| UtilMisc.<String, Object>toMap("finAccountId", finAccountId, |
| "amount", amount, "currencyUomId", currency, |
| "thruDate", thruDate, "userLogin", userLogin)); |
| if (ServiceUtil.isError(tmpResult)) { |
| return tmpResult; |
| } else { |
| refNum = (String) tmpResult.get("finAccountAuthId"); |
| processResult = Boolean.TRUE; |
| } |
| } else { |
| Debug.logError("Attempted to authorize [" + amount + "] against a balance of only [" + availableBalance + "]", module); |
| refNum = "N/A"; // a refNum is always required from authorization |
| processResult = Boolean.FALSE; |
| } |
| |
| result.put("processAmount", amount); |
| result.put("authResult", processResult); |
| result.put("processAmount", amount); |
| result.put("authFlag", "2"); |
| result.put("authCode", "A"); |
| result.put("captureCode", "C"); |
| result.put("authRefNum", refNum); |
| |
| return result; |
| } catch (GenericEntityException ex) { |
| Debug.logError(ex, "Cannot authorize gift certificate", module); |
| return ServiceUtil.returnError(UtilProperties.getMessage(resourceError, |
| "AccountingGiftCerticateNumberCannotAuthorize", |
| UtilMisc.toMap("errorString", ex.getMessage()), locale)); |
| } catch (GenericServiceException ex) { |
| Debug.logError(ex, "Cannot authorize gift certificate", module); |
| return ServiceUtil.returnError(UtilProperties.getMessage(resourceError, |
| "AccountingGiftCerticateNumberCannotAuthorize", |
| UtilMisc.toMap("errorString", ex.getMessage()), locale)); |
| } |
| } |
| |
| public static Map<String, Object> giftCertificateRefund(DispatchContext dctx, Map<String, ? extends Object> context) { |
| GenericValue userLogin = (GenericValue) context.get("userLogin"); |
| GenericValue paymentPref = (GenericValue) context.get("orderPaymentPreference"); |
| String currency = (String) context.get("currency"); |
| BigDecimal amount = (BigDecimal) context.get("refundAmount"); |
| Locale locale = (Locale) context.get("locale"); |
| return giftCertificateRestore(dctx, userLogin, paymentPref, amount, currency, "refund", locale); |
| } |
| |
| public static Map<String, Object> giftCertificateRelease(DispatchContext dctx, Map<String, ? extends Object> context) { |
| LocalDispatcher dispatcher = dctx.getDispatcher(); |
| GenericValue userLogin = (GenericValue) context.get("userLogin"); |
| GenericValue paymentPref = (GenericValue) context.get("orderPaymentPreference"); |
| Locale locale = (Locale) context.get("locale"); |
| |
| String err = UtilProperties.getMessage(resourceError, |
| "AccountingGiftCerticateNumberCannotBeExpired", locale); |
| try { |
| // expire the related financial authorization transaction |
| GenericValue authTransaction = PaymentGatewayServices.getAuthTransaction(paymentPref); |
| if (authTransaction == null) { |
| return ServiceUtil.returnError(err + UtilProperties.getMessage(resourceError, |
| "AccountingFinAccountCannotFindAuthorization", locale)); |
| } |
| Map<String, Object> input = UtilMisc.<String, Object>toMap("userLogin", userLogin, |
| "finAccountAuthId", authTransaction.get("referenceNum")); |
| Map<String, Object> serviceResults = dispatcher.runSync("expireFinAccountAuth", input); |
| |
| Map<String, Object> result = ServiceUtil.returnSuccess(); |
| result.put("releaseRefNum", authTransaction.getString("referenceNum")); |
| result.put("releaseAmount", authTransaction.getBigDecimal("amount")); |
| result.put("releaseResult", Boolean.TRUE); |
| |
| // if there's an error, don't release |
| if (ServiceUtil.isError(serviceResults)) { |
| return ServiceUtil.returnError(err + ServiceUtil.getErrorMessage(serviceResults)); |
| } |
| |
| return result; |
| } catch (GenericServiceException e) { |
| Debug.logError(e, e.getMessage(), module); |
| return ServiceUtil.returnError(err + e.getMessage()); |
| } |
| } |
| |
| private static Map<String, Object> giftCertificateRestore(DispatchContext dctx, GenericValue userLogin, GenericValue paymentPref, |
| BigDecimal amount, String currency, String resultPrefix, Locale locale) { |
| LocalDispatcher dispatcher = dctx.getDispatcher(); |
| Delegator delegator = dctx.getDelegator(); |
| |
| // get the orderId for tracking |
| String orderId = paymentPref.getString("orderId"); |
| OrderReadHelper orh = new OrderReadHelper(delegator, orderId); |
| String productStoreId = orh.getProductStoreId(); |
| |
| // party ID for tracking |
| GenericValue placingParty = orh.getPlacingParty(); |
| String partyId = null; |
| if (placingParty != null) { |
| partyId = placingParty.getString("partyId"); |
| } |
| |
| // get the GiftCard VO |
| GenericValue giftCard = null; |
| try { |
| giftCard = paymentPref.getRelatedOne("GiftCard", false); |
| } catch (GenericEntityException e) { |
| Debug.logError(e, "Unable to get GiftCard from OrderPaymentPreference", module); |
| return ServiceUtil.returnError(UtilProperties.getMessage(resourceError, |
| "AccountingGiftCerticateNumberCannotLocateItFromOrderPaymentPreference", locale)); |
| } |
| |
| if (giftCard == null) { |
| return ServiceUtil.returnError(UtilProperties.getMessage(resourceError, |
| "AccountingGiftCerticateNumberCannotRelease", locale)); |
| } |
| |
| // make sure we have a currency |
| if (currency == null) { |
| currency = EntityUtilProperties.getPropertyValue("general", "currency.uom.id.default", "USD", delegator); |
| } |
| |
| Map<String, Object> refundCtx = new HashMap<String, Object>(); |
| refundCtx.put("productStoreId", productStoreId); |
| refundCtx.put("currency", currency); |
| refundCtx.put("partyId", partyId); |
| refundCtx.put("cardNumber", giftCard.get("cardNumber")); |
| refundCtx.put("pinNumber", giftCard.get("pinNumber")); |
| refundCtx.put("amount", amount); |
| refundCtx.put("userLogin", userLogin); |
| |
| Map<String, Object> restoreGcResult = null; |
| try { |
| restoreGcResult = dispatcher.runSync("addFundsToGiftCertificate", refundCtx); |
| } catch (GenericServiceException e) { |
| Debug.logError(e, module); |
| return ServiceUtil.returnError(UtilProperties.getMessage(resourceError, |
| "AccountingGiftCerticateNumberRefundCallError", locale)); |
| } |
| if (ServiceUtil.isError(restoreGcResult)) { |
| return ServiceUtil.returnError(ServiceUtil.getErrorMessage(restoreGcResult)); |
| } |
| |
| Map<String, Object> result = ServiceUtil.returnSuccess(); |
| if (restoreGcResult != null) { |
| Boolean processResult = (Boolean) restoreGcResult.get("processResult"); |
| result.put(resultPrefix + "Amount", amount); |
| result.put(resultPrefix + "Result", processResult); |
| result.put(resultPrefix + "Code", "R"); |
| result.put(resultPrefix + "Flag", restoreGcResult.get("responseCode")); |
| result.put(resultPrefix + "RefNum", restoreGcResult.get("referenceNum")); |
| } |
| |
| return result; |
| } |
| |
| public static Map<String, Object> giftCertificatePurchase(DispatchContext dctx, Map<String, ? extends Object> context) { |
| // this service should always be called via FULFILLMENT_EXTASYNC |
| LocalDispatcher dispatcher = dctx.getDispatcher(); |
| Delegator delegator = dctx.getDelegator(); |
| GenericValue userLogin = (GenericValue) context.get("userLogin"); |
| GenericValue orderItem = (GenericValue) context.get("orderItem"); |
| Locale locale = (Locale) context.get("locale"); |
| |
| // order ID for tracking |
| String orderId = orderItem.getString("orderId"); |
| |
| // the order header for store info |
| GenericValue orderHeader = null; |
| try { |
| orderHeader = orderItem.getRelatedOne("OrderHeader", false); |
| } catch (GenericEntityException e) { |
| Debug.logError(e, "Unable to get OrderHeader from OrderItem",module); |
| return ServiceUtil.returnError(UtilProperties.getMessage(resourceOrderError, |
| "OrderCannotGetOrderHeader", UtilMisc.toMap("orderId", orderId), locale)); |
| } |
| |
| // get the order read helper |
| OrderReadHelper orh = new OrderReadHelper(orderHeader); |
| |
| // get the currency |
| String currency = orh.getCurrency(); |
| |
| // make sure we have a currency |
| if (currency == null) { |
| currency = EntityUtilProperties.getPropertyValue("general", "currency.uom.id.default", "USD", delegator); |
| } |
| |
| // get the product store |
| String productStoreId = null; |
| if (orderHeader != null) { |
| productStoreId = orh.getProductStoreId(); |
| } |
| if (productStoreId == null) { |
| return ServiceUtil.returnError(UtilProperties.getMessage(resourceError, |
| "AccountingGiftCerticateNumberCannotProcess", |
| UtilMisc.toMap("orderId", orderId), locale)); |
| } |
| |
| // party ID for tracking |
| GenericValue placingParty = orh.getPlacingParty(); |
| String partyId = null; |
| if (placingParty != null) { |
| partyId = placingParty.getString("partyId"); |
| } |
| |
| // amount/quantity of the gift card(s) |
| BigDecimal amount = orderItem.getBigDecimal("unitPrice"); |
| BigDecimal quantity = orderItem.getBigDecimal("quantity"); |
| |
| // the product entity needed for information |
| GenericValue product = null; |
| try { |
| product = orderItem.getRelatedOne("Product", false); |
| } catch (GenericEntityException e) { |
| Debug.logError(e, "Unable to get Product from OrderItem", module); |
| } |
| if (product == null) { |
| return ServiceUtil.returnError(UtilProperties.getMessage(resourceError, |
| "AccountingGiftCerticateNumberCannotFulfill", locale)); |
| } |
| |
| // Gift certificate settings are per store in this entity |
| GenericValue giftCertSettings = null; |
| try { |
| giftCertSettings = EntityQuery.use(delegator).from("ProductStoreFinActSetting") |
| .where("productStoreId", productStoreId, "finAccountTypeId", FinAccountHelper.giftCertFinAccountTypeId) |
| .cache().queryOne(); |
| } catch (GenericEntityException e) { |
| Debug.logError(e, "Unable to get Product Store FinAccount settings for " + FinAccountHelper.giftCertFinAccountTypeId, module); |
| return ServiceUtil.returnError(UtilProperties.getMessage(resourceError, |
| "AccountingFinAccountSetting", |
| UtilMisc.toMap("productStoreId", productStoreId, |
| "finAccountTypeId", FinAccountHelper.giftCertFinAccountTypeId), locale) + ": " + e.getMessage()); |
| } |
| |
| // survey information |
| String surveyId = giftCertSettings.getString("purchaseSurveyId"); |
| |
| // get the survey response |
| GenericValue surveyResponse = null; |
| try { |
| // there should be only one |
| surveyResponse = EntityQuery.use(delegator).from("SurveyResponse") |
| .where("orderId", orderId, "orderItemSeqId", orderItem.get("orderItemSeqId"), "surveyId", surveyId) |
| .orderBy("-responseDate").queryFirst(); |
| } catch (GenericEntityException e) { |
| Debug.logError(e, module); |
| return ServiceUtil.returnError(UtilProperties.getMessage(resourceError, |
| "AccountingGiftCerticateNumberCannotFulfill", locale)); |
| } |
| if (surveyResponse == null) { |
| return ServiceUtil.returnError(UtilProperties.getMessage(resourceError, |
| "AccountingGiftCerticateNumberCannotFulfill", locale)); |
| } |
| |
| // get the response answers |
| List<GenericValue> responseAnswers = null; |
| try { |
| responseAnswers = surveyResponse.getRelated("SurveyResponseAnswer", null, null, false); |
| } catch (GenericEntityException e) { |
| Debug.logError(e, module); |
| return ServiceUtil.returnError(UtilProperties.getMessage(resourceError, |
| "AccountingGiftCerticateNumberCannotFulfillFromSurveyAnswers", locale)); |
| } |
| |
| // make a map of answer info |
| Map<String, Object> answerMap = new HashMap<String, Object>(); |
| if (responseAnswers != null) { |
| for (GenericValue answer : responseAnswers) { |
| GenericValue question = null; |
| try { |
| question = answer.getRelatedOne("SurveyQuestion", false); |
| } catch (GenericEntityException e) { |
| Debug.logError(e, module); |
| return ServiceUtil.returnError(UtilProperties.getMessage(resourceError, |
| "AccountingGiftCerticateNumberCannotFulfillFromSurveyAnswers", locale)); |
| } |
| if (question != null) { |
| String desc = question.getString("description"); |
| String ans = answer.getString("textResponse"); // only support text response types for now |
| answerMap.put(desc, ans); |
| } |
| } |
| } |
| |
| // get the send to email address - key defined in product store settings entity |
| String sendToKey = giftCertSettings.getString("purchSurveySendTo"); |
| String sendToEmail = (String) answerMap.get(sendToKey); |
| |
| // get the copyMe flag and set the order email address |
| String orderEmails = orh.getOrderEmailString(); |
| String copyMeField = giftCertSettings.getString("purchSurveyCopyMe"); |
| String copyMeResp = copyMeField != null ? (String) answerMap.get(copyMeField) : null; |
| boolean copyMe = (UtilValidate.isNotEmpty(copyMeField) |
| && UtilValidate.isNotEmpty(copyMeResp) && "true".equalsIgnoreCase(copyMeResp)) ? true : false; |
| |
| int qtyLoop = quantity.intValue(); |
| for (int i = 0; i < qtyLoop; i++) { |
| // create a gift certificate |
| Map<String, Object> createGcCtx = new HashMap<String, Object>(); |
| createGcCtx.put("productStoreId", productStoreId); |
| createGcCtx.put("currency", currency); |
| createGcCtx.put("partyId", partyId); |
| createGcCtx.put("initialAmount", amount); |
| createGcCtx.put("userLogin", userLogin); |
| |
| Map<String, Object> createGcResult = null; |
| try { |
| createGcResult = dispatcher.runSync("createGiftCertificate", createGcCtx); |
| } catch (GenericServiceException e) { |
| Debug.logError(e, module); |
| return ServiceUtil.returnError(UtilProperties.getMessage(resourceError, |
| "AccountingGiftCerticateNumberCreationError", locale) + e.getMessage()); |
| } |
| if (ServiceUtil.isError(createGcResult)) { |
| return ServiceUtil.returnError(UtilProperties.getMessage(resourceError, |
| "AccountingGiftCerticateNumberCreationError", locale) |
| + ServiceUtil.getErrorMessage(createGcResult)); |
| } |
| |
| // create the fulfillment record |
| Map<String, Object> gcFulFill = new HashMap<String, Object>(); |
| gcFulFill.put("typeEnumId", "GC_ACTIVATE"); |
| gcFulFill.put("partyId", partyId); |
| gcFulFill.put("orderId", orderId); |
| gcFulFill.put("orderItemSeqId", orderItem.get("orderItemSeqId")); |
| gcFulFill.put("surveyResponseId", surveyResponse.get("surveyResponseId")); |
| gcFulFill.put("cardNumber", createGcResult.get("cardNumber")); |
| gcFulFill.put("pinNumber", createGcResult.get("pinNumber")); |
| gcFulFill.put("amount", createGcResult.get("initialAmount")); |
| gcFulFill.put("responseCode", createGcResult.get("responseCode")); |
| gcFulFill.put("referenceNum", createGcResult.get("referenceNum")); |
| gcFulFill.put("userLogin", userLogin); |
| try { |
| dispatcher.runAsync("createGcFulFillmentRecord", gcFulFill, true); |
| } catch (GenericServiceException e) { |
| Debug.logError(e, module); |
| return ServiceUtil.returnError(UtilProperties.getMessage(resourceError, |
| "AccountingGiftCerticateNumberCannotStoreFulfillmentInfo", |
| UtilMisc.toMap("errorString", e.getMessage()), locale)); |
| } |
| |
| // add some information to the answerMap for the email |
| answerMap.put("cardNumber", createGcResult.get("cardNumber")); |
| answerMap.put("pinNumber", createGcResult.get("pinNumber")); |
| answerMap.put("amount", createGcResult.get("initialAmount")); |
| |
| // get the email setting for this email type |
| GenericValue productStoreEmail = null; |
| String emailType = "PRDS_GC_PURCHASE"; |
| try { |
| productStoreEmail = EntityQuery.use(delegator).from("ProductStoreEmailSetting").where("productStoreId", productStoreId, "emailType", emailType).queryOne(); |
| } catch (GenericEntityException e) { |
| Debug.logError(e, "Unable to get product store email setting for gift card purchase", module); |
| } |
| if (productStoreEmail == null) { |
| Debug.logError("No gift card purchase email setting found for this store; cannot send gift card information", module); |
| } else { |
| answerMap.put("locale", locale); |
| |
| // set the bcc address(s) |
| String bcc = productStoreEmail.getString("bccAddress"); |
| if (copyMe) { |
| if (UtilValidate.isNotEmpty(bcc)) { |
| bcc = bcc + "," + orderEmails; |
| } else { |
| bcc = orderEmails; |
| } |
| } |
| Map<String, Object> emailCtx = new HashMap<String, Object>(); |
| String bodyScreenLocation = productStoreEmail.getString("bodyScreenLocation"); |
| if (UtilValidate.isEmpty(bodyScreenLocation)) { |
| bodyScreenLocation = ProductStoreWorker.getDefaultProductStoreEmailScreenLocation(emailType); |
| } |
| emailCtx.put("bodyScreenUri", bodyScreenLocation); |
| emailCtx.put("bodyParameters", answerMap); |
| emailCtx.put("sendTo", sendToEmail); |
| emailCtx.put("contentType", productStoreEmail.get("contentType")); |
| emailCtx.put("sendFrom", productStoreEmail.get("fromAddress")); |
| emailCtx.put("sendCc", productStoreEmail.get("ccAddress")); |
| emailCtx.put("sendBcc", bcc); |
| emailCtx.put("subject", productStoreEmail.getString("subject")); |
| emailCtx.put("userLogin", userLogin); |
| |
| // send off the email async so we will retry on failed attempts |
| // SC 20060405: Changed to runSync because runAsync kept getting an error: |
| // Problem serializing service attributes (Cannot serialize object of class java.util.PropertyResourceBundle) |
| try { |
| dispatcher.runSync("sendMailFromScreen", emailCtx); |
| } catch (GenericServiceException e) { |
| Debug.logError(e, "Problem sending mail", module); |
| // this is fatal; we will rollback and try again later |
| return ServiceUtil.returnError(UtilProperties.getMessage(resourceError, |
| "AccountingGiftCerticateNumberCannotSendEmailNotice", |
| UtilMisc.toMap("errorString", e.toString()), locale)); |
| } |
| } |
| } |
| |
| return ServiceUtil.returnSuccess(); |
| } |
| |
| public static Map<String, Object> giftCertificateReload(DispatchContext dctx, Map<String, ? extends Object> context) { |
| // this service should always be called via FULFILLMENT_EXTSYNC |
| LocalDispatcher dispatcher = dctx.getDispatcher(); |
| Delegator delegator = dctx.getDelegator(); |
| GenericValue userLogin = (GenericValue) context.get("userLogin"); |
| GenericValue orderItem = (GenericValue) context.get("orderItem"); |
| Locale locale = (Locale) context.get("locale"); |
| |
| // order ID for tracking |
| String orderId = orderItem.getString("orderId"); |
| |
| // the order header for store info |
| GenericValue orderHeader = null; |
| try { |
| orderHeader = orderItem.getRelatedOne("OrderHeader", false); |
| } catch (GenericEntityException e) { |
| Debug.logError(e, "Unable to get OrderHeader from OrderItem",module); |
| return ServiceUtil.returnError(UtilProperties.getMessage(resourceOrderError, |
| "OrderCannotGetOrderHeader", UtilMisc.toMap("orderId", orderId), locale)); |
| } |
| |
| // get the order read helper |
| OrderReadHelper orh = new OrderReadHelper(orderHeader); |
| |
| // get the currency |
| String currency = orh.getCurrency(); |
| |
| // make sure we have a currency |
| if (currency == null) { |
| currency = EntityUtilProperties.getPropertyValue("general", "currency.uom.id.default", "USD", delegator); |
| } |
| |
| // get the product store |
| String productStoreId = null; |
| if (orderHeader != null) { |
| productStoreId = orh.getProductStoreId(); |
| } |
| if (productStoreId == null) { |
| return ServiceUtil.returnError(UtilProperties.getMessage(resourceOrderError, |
| "AccountingGiftCerticateNumberCannotReload", UtilMisc.toMap("orderId", orderId), locale)); |
| } |
| |
| // payment config |
| GenericValue paymentSetting = ProductStoreWorker.getProductStorePaymentSetting(delegator, productStoreId, "GIFT_CARD", null, true); |
| String paymentConfig = null; |
| if (paymentSetting != null) { |
| paymentConfig = paymentSetting.getString("paymentPropertiesPath"); |
| } |
| if (paymentConfig == null) { |
| return ServiceUtil.returnError(UtilProperties.getMessage(resourceOrderError, |
| "AccountingGiftCerticateNumberCannotGetPaymentConfiguration", locale)); |
| } |
| |
| // party ID for tracking |
| GenericValue placingParty = orh.getPlacingParty(); |
| String partyId = null; |
| if (placingParty != null) { |
| partyId = placingParty.getString("partyId"); |
| } |
| |
| // amount of the gift card reload |
| BigDecimal amount = orderItem.getBigDecimal("unitPrice"); |
| |
| // survey information |
| String surveyId = EntityUtilProperties.getPropertyValue(paymentConfig, "payment.giftcert.reload.surveyId", delegator); |
| |
| // get the survey response |
| GenericValue surveyResponse = null; |
| try { |
| // there should be only one |
| surveyResponse = EntityQuery.use(delegator).from("SurveyResponse") |
| .where("orderId", orderId, "orderItemSeqId", orderItem.get("orderItemSeqId"), "surveyId", surveyId) |
| .orderBy("-responseDate").queryFirst(); |
| } catch (GenericEntityException e) { |
| Debug.logError(e, module); |
| return ServiceUtil.returnError(UtilProperties.getMessage(resourceOrderError, |
| "AccountingGiftCerticateNumberCannotReload", locale)); |
| } |
| |
| // get the response answers |
| List<GenericValue> responseAnswers = null; |
| try { |
| responseAnswers = surveyResponse.getRelated("SurveyResponseAnswer", null, null, false); |
| } catch (GenericEntityException e) { |
| Debug.logError(e, module); |
| return ServiceUtil.returnError(UtilProperties.getMessage(resourceOrderError, |
| "AccountingGiftCerticateNumberCannotReloadFromSurveyAnswers", locale)); |
| } |
| |
| // make a map of answer info |
| Map<String, Object> answerMap = new HashMap<String, Object>(); |
| if (responseAnswers != null) { |
| for (GenericValue answer : responseAnswers) { |
| GenericValue question = null; |
| try { |
| question = answer.getRelatedOne("SurveyQuestion", false); |
| } catch (GenericEntityException e) { |
| Debug.logError(e, module); |
| return ServiceUtil.returnError(UtilProperties.getMessage(resourceOrderError, |
| "AccountingGiftCerticateNumberCannotReloadFromSurveyAnswers", locale)); |
| } |
| if (question != null) { |
| String desc = question.getString("description"); |
| String ans = answer.getString("textResponse"); // only support text response types for now |
| answerMap.put(desc, ans); |
| } |
| } |
| } |
| |
| String cardNumberKey = EntityUtilProperties.getPropertyValue(paymentConfig, "payment.giftcert.reload.survey.cardNumber", delegator); |
| String pinNumberKey = EntityUtilProperties.getPropertyValue(paymentConfig, "payment.giftcert.reload.survey.pinNumber", delegator); |
| String cardNumber = (String) answerMap.get(cardNumberKey); |
| String pinNumber = (String) answerMap.get(pinNumberKey); |
| |
| // reload the gift card |
| Map<String, Object> reloadCtx = new HashMap<String, Object>(); |
| reloadCtx.put("productStoreId", productStoreId); |
| reloadCtx.put("currency", currency); |
| reloadCtx.put("partyId", partyId); |
| reloadCtx.put("cardNumber", cardNumber); |
| reloadCtx.put("pinNumber", pinNumber); |
| reloadCtx.put("amount", amount); |
| reloadCtx.put("userLogin", userLogin); |
| |
| String errorMessage = null; |
| Map<String, Object> reloadGcResult = null; |
| try { |
| reloadGcResult = dispatcher.runSync("addFundsToGiftCertificate", reloadCtx); |
| } catch (GenericServiceException e) { |
| Debug.logError(e, module); |
| errorMessage = "Unable to call reload service!"; |
| } |
| if (ServiceUtil.isError(reloadGcResult)) { |
| errorMessage = ServiceUtil.getErrorMessage(reloadGcResult); |
| } |
| |
| // create the fulfillment record |
| Map<String, Object> gcFulFill = new HashMap<String, Object>(); |
| gcFulFill.put("typeEnumId", "GC_RELOAD"); |
| gcFulFill.put("userLogin", userLogin); |
| gcFulFill.put("partyId", partyId); |
| gcFulFill.put("orderId", orderId); |
| gcFulFill.put("orderItemSeqId", orderItem.get("orderItemSeqId")); |
| gcFulFill.put("surveyResponseId", surveyResponse.get("surveyResponseId")); |
| gcFulFill.put("cardNumber", cardNumber); |
| gcFulFill.put("pinNumber", pinNumber); |
| gcFulFill.put("amount", amount); |
| if (reloadGcResult != null) { |
| gcFulFill.put("responseCode", reloadGcResult.get("responseCode")); |
| gcFulFill.put("referenceNum", reloadGcResult.get("referenceNum")); |
| } |
| try { |
| dispatcher.runAsync("createGcFulFillmentRecord", gcFulFill, true); |
| } catch (GenericServiceException e) { |
| Debug.logError(e, module); |
| return ServiceUtil.returnError(UtilProperties.getMessage(resourceError, |
| "AccountingGiftCerticateNumberCannotStoreFulfillmentInfo", |
| UtilMisc.toMap("errorString", e.getMessage()), locale)); |
| } |
| |
| if (errorMessage != null) { |
| // there was a problem |
| Debug.logError("Reload Failed Need to Refund : " + reloadGcResult, module); |
| |
| // process the return |
| try { |
| Map<String, Object> refundCtx = UtilMisc.toMap("orderItem", orderItem, |
| "partyId", partyId, "userLogin", userLogin); |
| dispatcher.runAsync("refundGcPurchase", refundCtx, null, true, 300, true); |
| } catch (GenericServiceException e) { |
| Debug.logError(e, "ERROR! Unable to call create refund service; this failed reload will NOT be refunded", module); |
| } |
| |
| return ServiceUtil.returnError(errorMessage); |
| } |
| |
| // add some information to the answerMap for the email |
| answerMap.put("processResult", reloadGcResult.get("processResult")); |
| answerMap.put("responseCode", reloadGcResult.get("responseCode")); |
| answerMap.put("previousAmount", reloadGcResult.get("previousBalance")); |
| answerMap.put("amount", reloadGcResult.get("amount")); |
| |
| // get the email setting for this email type |
| GenericValue productStoreEmail = null; |
| String emailType = "PRDS_GC_RELOAD"; |
| try { |
| productStoreEmail = EntityQuery.use(delegator).from("ProductStoreEmailSetting").where("productStoreId", productStoreId, "emailType", emailType).queryOne(); |
| } catch (GenericEntityException e) { |
| Debug.logError(e, "Unable to get product store email setting for gift card purchase", module); |
| } |
| if (productStoreEmail == null) { |
| Debug.logError("No gift card purchase email setting found for this store; cannot send gift card information", module); |
| } else { |
| answerMap.put("locale", locale); |
| |
| Map<String, Object> emailCtx = new HashMap<String, Object>(); |
| String bodyScreenLocation = productStoreEmail.getString("bodyScreenLocation"); |
| if (UtilValidate.isEmpty(bodyScreenLocation)) { |
| bodyScreenLocation = ProductStoreWorker.getDefaultProductStoreEmailScreenLocation(emailType); |
| } |
| emailCtx.put("bodyScreenUri", bodyScreenLocation); |
| emailCtx.put("bodyParameters", answerMap); |
| emailCtx.put("sendTo", orh.getOrderEmailString()); |
| emailCtx.put("contentType", productStoreEmail.get("contentType")); |
| emailCtx.put("sendFrom", productStoreEmail.get("fromAddress")); |
| emailCtx.put("sendCc", productStoreEmail.get("ccAddress")); |
| emailCtx.put("sendBcc", productStoreEmail.get("bccAddress")); |
| emailCtx.put("subject", productStoreEmail.getString("subject")); |
| emailCtx.put("userLogin", userLogin); |
| |
| // send off the email async so we will retry on failed attempts |
| try { |
| dispatcher.runAsync("sendMailFromScreen", emailCtx); |
| } catch (GenericServiceException e) { |
| Debug.logError(e, "Problem sending mail", module); |
| // this is fatal; we will rollback and try again later |
| return ServiceUtil.returnError(UtilProperties.getMessage(resourceError, |
| "AccountingGiftCerticateNumberCannotSendEmailNotice", |
| UtilMisc.toMap("errorString", e.toString()), locale)); |
| } |
| } |
| |
| return ServiceUtil.returnSuccess(); |
| } |
| |
| // Tracking Service |
| public static Map<String, Object> createFulfillmentRecord(DispatchContext dctx, Map<String, ? extends Object> context) { |
| Delegator delegator = dctx.getDelegator(); |
| Locale locale = (Locale) context.get("locale"); |
| |
| // create the fulfillment record |
| GenericValue gcFulFill = delegator.makeValue("GiftCardFulfillment"); |
| gcFulFill.set("fulfillmentId", delegator.getNextSeqId("GiftCardFulfillment")); |
| gcFulFill.set("typeEnumId", context.get("typeEnumId")); |
| gcFulFill.set("merchantId", context.get("merchantId")); |
| gcFulFill.set("partyId", context.get("partyId")); |
| gcFulFill.set("orderId", context.get("orderId")); |
| gcFulFill.set("orderItemSeqId", context.get("orderItemSeqId")); |
| gcFulFill.set("surveyResponseId", context.get("surveyResponseId")); |
| gcFulFill.set("cardNumber", context.get("cardNumber")); |
| gcFulFill.set("pinNumber", context.get("pinNumber")); |
| gcFulFill.set("amount", context.get("amount")); |
| gcFulFill.set("responseCode", context.get("responseCode")); |
| gcFulFill.set("referenceNum", context.get("referenceNum")); |
| gcFulFill.set("authCode", context.get("authCode")); |
| gcFulFill.set("fulfillmentDate", UtilDateTime.nowTimestamp()); |
| try { |
| delegator.create(gcFulFill); |
| } catch (GenericEntityException e) { |
| Debug.logError(e, module); |
| return ServiceUtil.returnError(UtilProperties.getMessage(resourceError, |
| "AccountingGiftCerticateNumberCannotStoreFulfillmentInfo", |
| UtilMisc.toMap("errorString", e.toString()), locale)); |
| } |
| return ServiceUtil.returnSuccess(); |
| } |
| |
| // Refund Service |
| public static Map<String, Object> refundGcPurchase(DispatchContext dctx, Map<String, ? extends Object> context) { |
| LocalDispatcher dispatcher = dctx.getDispatcher(); |
| Delegator delegator = dctx.getDelegator(); |
| GenericValue userLogin = (GenericValue) context.get("userLogin"); |
| GenericValue orderItem = (GenericValue) context.get("orderItem"); |
| String partyId = (String) context.get("partyId"); |
| Locale locale = (Locale) context.get("locale"); |
| |
| // refresh the item object for status changes |
| try { |
| orderItem.refresh(); |
| } catch (GenericEntityException e) { |
| Debug.logError(e, module); |
| } |
| |
| Map<String, Object> returnableInfo = null; |
| try { |
| returnableInfo = dispatcher.runSync("getReturnableQuantity", UtilMisc.toMap("orderItem", orderItem, |
| "userLogin", userLogin)); |
| } catch (GenericServiceException e) { |
| Debug.logError(e, module); |
| return ServiceUtil.returnError(UtilProperties.getMessage(resourceOrderError, |
| "OrderErrorUnableToGetReturnItemInformation", locale)); |
| } |
| |
| if (returnableInfo != null) { |
| BigDecimal returnableQuantity = (BigDecimal) returnableInfo.get("returnableQuantity"); |
| BigDecimal returnablePrice = (BigDecimal) returnableInfo.get("returnablePrice"); |
| Debug.logInfo("Returnable INFO : " + returnableQuantity + " @ " + returnablePrice + " :: " + orderItem, module); |
| |
| // create the return header |
| Map<String, Object> returnHeaderInfo = new HashMap<String, Object>(); |
| returnHeaderInfo.put("fromPartyId", partyId); |
| returnHeaderInfo.put("userLogin", userLogin); |
| Map<String, Object> returnHeaderResp = null; |
| try { |
| returnHeaderResp = dispatcher.runSync("createReturnHeader", returnHeaderInfo); |
| } catch (GenericServiceException e) { |
| Debug.logError(e, module); |
| return ServiceUtil.returnError(UtilProperties.getMessage(resourceOrderError, |
| "OrderErrorUnableToCreateReturnHeader", locale)); |
| } |
| |
| if (returnHeaderResp != null) { |
| String errorMessage = ServiceUtil.getErrorMessage(returnHeaderResp); |
| if (errorMessage != null) { |
| return ServiceUtil.returnError(errorMessage); |
| } |
| } |
| |
| String returnId = null; |
| if (returnHeaderResp != null) { |
| returnId = (String) returnHeaderResp.get("returnId"); |
| } |
| |
| if (returnId == null) { |
| return ServiceUtil.returnError(UtilProperties.getMessage(resourceOrderError, |
| "OrderErrorCreateReturnHeaderWithoutId", locale)); |
| } |
| |
| // create the return item |
| Map<String, Object> returnItemInfo = new HashMap<String, Object>(); |
| returnItemInfo.put("returnId", returnId); |
| returnItemInfo.put("returnReasonId", "RTN_DIG_FILL_FAIL"); |
| returnItemInfo.put("returnTypeId", "RTN_REFUND"); |
| returnItemInfo.put("returnItemType", "ITEM"); |
| returnItemInfo.put("description", orderItem.get("itemDescription")); |
| returnItemInfo.put("orderId", orderItem.get("orderId")); |
| returnItemInfo.put("orderItemSeqId", orderItem.get("orderItemSeqId")); |
| returnItemInfo.put("returnQuantity", returnableQuantity); |
| returnItemInfo.put("returnPrice", returnablePrice); |
| returnItemInfo.put("userLogin", userLogin); |
| Map<String, Object> returnItemResp = null; |
| try { |
| returnItemResp = dispatcher.runSync("createReturnItem", returnItemInfo); |
| } catch (GenericServiceException e) { |
| Debug.logError(e, module); |
| return ServiceUtil.returnError(UtilProperties.getMessage(resourceOrderError, |
| "OrderErrorUnableToCreateReturnItem", locale)); |
| } |
| |
| if (returnItemResp != null) { |
| String errorMessage = ServiceUtil.getErrorMessage(returnItemResp); |
| if (errorMessage != null) { |
| return ServiceUtil.returnError(errorMessage); |
| } |
| } |
| |
| String returnItemSeqId = null; |
| if (returnItemResp != null) { |
| returnItemSeqId = (String) returnItemResp.get("returnItemSeqId"); |
| } |
| |
| if (returnItemSeqId == null) { |
| return ServiceUtil.returnError(UtilProperties.getMessage(resourceOrderError, |
| "OrderErrorCreateReturnItemWithoutId", locale)); |
| } else { |
| Debug.logVerbose("Created return item : " + returnId + " / " + returnItemSeqId, module); |
| } |
| |
| // need the system userLogin to "fake" out the update service |
| GenericValue admin = null; |
| try { |
| admin = EntityQuery.use(delegator).from("UserLogin").where("userLoginId", "system").queryOne(); |
| } catch (GenericEntityException e) { |
| Debug.logError(e, module); |
| return ServiceUtil.returnError(UtilProperties.getMessage(resourceOrderError, |
| "OrderErrorUnableToUpdateReturnHeaderStatusWithoutUserLogin", locale)); |
| } |
| |
| // update the status to received so it can process |
| Map<String, Object> updateReturnInfo = new HashMap<String, Object>(); |
| updateReturnInfo.put("returnId", returnId); |
| updateReturnInfo.put("statusId", "RETURN_RECEIVED"); |
| updateReturnInfo.put("currentStatusId", "RETURN_REQUESTED"); |
| updateReturnInfo.put("userLogin", admin); |
| Map<String, Object> updateReturnResp = null; |
| try { |
| updateReturnResp = dispatcher.runSync("updateReturnHeader", updateReturnInfo); |
| } catch (GenericServiceException e) { |
| Debug.logError(e, module); |
| return ServiceUtil.returnError(UtilProperties.getMessage(resourceOrderError, |
| "OrderErrorUnableToUpdateReturnHeaderStatus", locale)); |
| } |
| |
| if (updateReturnResp != null) { |
| String errorMessage = ServiceUtil.getErrorMessage(updateReturnResp); |
| if (errorMessage != null) { |
| return ServiceUtil.returnError(errorMessage); |
| } |
| } |
| } |
| |
| return ServiceUtil.returnSuccess(); |
| } |
| |
| // Private worker methods |
| private static boolean validatePin(Delegator delegator, String cardNumber, String pinNumber) { |
| GenericValue finAccount = null; |
| try { |
| finAccount = EntityQuery.use(delegator).from("FinAccount").where("finAccountId", cardNumber).queryOne(); |
| } catch (GenericEntityException e) { |
| Debug.logError(e, module); |
| } |
| if (finAccount != null) { |
| String dbPin = finAccount.getString("finAccountCode"); |
| Debug.logInfo("GC Pin Validation: [Sent: " + pinNumber + "] [Actual: " + dbPin + "]", module); |
| if (dbPin != null && dbPin.equals(pinNumber)) { |
| return true; |
| } |
| } else { |
| Debug.logInfo("GC FinAccount record not found (" + cardNumber + ")", module); |
| } |
| return false; |
| } |
| |
| private static String createTransaction(Delegator delegator, LocalDispatcher dispatcher, GenericValue userLogin, |
| BigDecimal amount, String productStoreId, String partyId, String currencyUom, String txType, |
| String finAccountId, Locale locale) throws GeneralException { |
| final String coParty = getPayToPartyId(delegator, productStoreId); |
| final String paymentMethodType = "GIFT_CERTIFICATE"; |
| |
| if (UtilValidate.isEmpty(partyId)) { |
| partyId = "_NA_"; |
| } |
| |
| String paymentType = null; |
| String partyIdFrom = null; |
| String partyIdTo = null; |
| if ("DEPOSIT".equals(txType)) { |
| paymentType = "GC_DEPOSIT"; |
| partyIdFrom = partyId; |
| partyIdTo = coParty; |
| } else if ("WITHDRAWAL".equals(txType)) { |
| paymentType = "GC_WITHDRAWAL"; |
| partyIdFrom = coParty; |
| partyIdTo = partyId; |
| } else { |
| throw new GeneralException(UtilProperties.getMessage(resourceError, |
| "AccountingFinAccountCannotCreateTransaction", locale)); |
| } |
| |
| // create the payment for the transaction |
| Map<String, Object> paymentCtx = UtilMisc.<String, Object>toMap("paymentTypeId", paymentType); |
| paymentCtx.put("paymentMethodTypeId", paymentMethodType); |
| paymentCtx.put("partyIdTo", partyIdTo); |
| paymentCtx.put("partyIdFrom", partyIdFrom); |
| paymentCtx.put("statusId", "PMNT_RECEIVED"); |
| paymentCtx.put("currencyUomId", currencyUom); |
| paymentCtx.put("amount", amount); |
| paymentCtx.put("userLogin", userLogin); |
| paymentCtx.put("paymentRefNum", "N/A"); |
| |
| String paymentId = null; |
| Map<String, Object> payResult = null; |
| try { |
| payResult = dispatcher.runSync("createPayment", paymentCtx); |
| } catch (GenericServiceException e) { |
| throw new GeneralException(e); |
| } |
| if (payResult == null) { |
| throw new GeneralException("Unknow error in creating financial account transaction!"); |
| } |
| if (ServiceUtil.isError(payResult)) { |
| throw new GeneralException(ServiceUtil.getErrorMessage(payResult)); |
| } else { |
| paymentId = (String) payResult.get("paymentId"); |
| } |
| |
| // create the initial transaction |
| Map<String, Object> transCtx = UtilMisc.<String, Object>toMap("finAccountTransTypeId", txType); |
| transCtx.put("finAccountId", finAccountId); |
| transCtx.put("partyId", userLogin.getString("partyId")); |
| transCtx.put("userLogin", userLogin); |
| transCtx.put("paymentId", paymentId); |
| transCtx.put("amount", amount); |
| |
| Map<String, Object> transResult = null; |
| String txId = null; |
| try { |
| transResult = dispatcher.runSync("createFinAccountTrans", transCtx); |
| } catch (GenericServiceException e) { |
| throw new GeneralException(e); |
| } |
| if (transResult == null) { |
| throw new GeneralException("Unknown error in creating financial account transaction!"); |
| } |
| if (ServiceUtil.isError(transResult)) { |
| throw new GeneralException(ServiceUtil.getErrorMessage(transResult)); |
| } else { |
| txId = (String) transResult.get("finAccountTransId"); |
| } |
| |
| return txId; |
| } |
| |
| private static String generateNumber(Delegator delegator, int length, boolean isId) throws GenericEntityException { |
| if (length > 19) { |
| length = 19; |
| } |
| |
| Random rand = new SecureRandom(); |
| boolean isValid = false; |
| StringBuilder number = null; |
| while (!isValid) { |
| number = new StringBuilder(""); |
| for (int i = 0; i < length; i++) { |
| int randInt = rand.nextInt(9); |
| number.append(randInt); |
| } |
| |
| if (isId) { |
| number.append(UtilValidate.getLuhnCheckDigit(number.toString())); |
| |
| // validate the number |
| if (checkCardNumber(number.toString())) { |
| // make sure this number doens't already exist |
| isValid = checkNumberInDatabase(delegator, number.toString()); |
| } |
| } else { |
| isValid = true; |
| } |
| } |
| return number.toString(); |
| } |
| |
| private static boolean checkNumberInDatabase(Delegator delegator, String number) throws GenericEntityException { |
| GenericValue finAccount = EntityQuery.use(delegator).from("FinAccount").where("finAccountId", number).queryOne(); |
| if (finAccount == null) { |
| return true; |
| } |
| return false; |
| } |
| |
| private static boolean checkCardNumber(String number) { |
| number = number.replaceAll("\\D", ""); |
| return UtilValidate.sumIsMod10(UtilValidate.getLuhnSum(number)); |
| } |
| |
| private static String getPayToPartyId(Delegator delegator, String productStoreId) { |
| String payToPartyId = "Company"; // default value |
| GenericValue productStore = null; |
| try { |
| productStore = EntityQuery.use(delegator).from("ProductStore").where("productStoreId", productStoreId).queryOne(); |
| } catch (GenericEntityException e) { |
| Debug.logError(e, "Unable to locate ProductStore (" + productStoreId + ")", module); |
| return null; |
| } |
| if (productStore != null && productStore.get("payToPartyId") != null) { |
| payToPartyId = productStore.getString("payToPartyId"); |
| } |
| return payToPartyId; |
| } |
| } |
