/**
* Copies a user preference group. Call with fromUserLoginId, userPrefGroupTypeId and optional
* userPrefLoginId. If userPrefLoginId isn't specified, then the currently logged-in user's
* userLoginId will be used.
*
* @param ctx The DispatchContext that this service is operating in.
* @param context Map containing the input arguments.
* @return Map with the result of the service, the output parameters.
*/
public static Map<String, Object> copyUserPreferenceGroup(
DispatchContext ctx, Map<String, ?> context) {
Delegator delegator = ctx.getDelegator();
Locale locale = (Locale) context.get("locale");
String userLoginId = PreferenceWorker.getUserLoginId(context, false);
String fromUserLoginId = (String) context.get("fromUserLoginId");
String userPrefGroupTypeId = (String) context.get("userPrefGroupTypeId");
if (UtilValidate.isEmpty(userLoginId)
|| UtilValidate.isEmpty(userPrefGroupTypeId)
|| UtilValidate.isEmpty(fromUserLoginId)) {
return ServiceUtil.returnError(
UtilProperties.getMessage(resource, "copyPreference.invalidArgument", locale));
}
try {
Map<String, String> fieldMap =
UtilMisc.toMap(
"userLoginId", fromUserLoginId, "userPrefGroupTypeId", userPrefGroupTypeId);
List<GenericValue> resultList = delegator.findByAnd("UserPreference", fieldMap);
if (resultList != null) {
for (GenericValue preference : resultList) {
preference.set("userLoginId", userLoginId);
}
delegator.storeAll(resultList);
}
} catch (GenericEntityException e) {
Debug.logWarning(e.getMessage(), module);
return ServiceUtil.returnError(
UtilProperties.getMessage(
resource, "copyPreference.writeFailure", new Object[] {e.getMessage()}, locale));
}
return ServiceUtil.returnSuccess();
}
public static Map<String, Object> ping(DispatchContext dctx, Map<String, ?> context) {
Delegator delegator = dctx.getDelegator();
String message = (String) context.get("message");
Locale locale = (Locale) context.get("locale");
if (message == null) {
message = "PONG";
}
long count = -1;
try {
count = delegator.findCountByCondition("SequenceValueItem", null, null, null);
} catch (GenericEntityException e) {
Debug.logError(e.getMessage(), module);
return ServiceUtil.returnError(
UtilProperties.getMessage(resource, "CommonPingDatasourceCannotConnect", locale));
}
if (count > 0) {
Map<String, Object> result = ServiceUtil.returnSuccess();
result.put("message", message);
return result;
} else {
return ServiceUtil.returnError(
UtilProperties.getMessage(resource, "CommonPingDatasourceInvalidCount", locale));
}
}
public static Map<String, Object> doRefund(DispatchContext dctx, Map<String, Object> context) {
Locale locale = (Locale) context.get("locale");
GenericValue payPalConfig = getPaymentMethodGatewayPayPal(dctx, context, null);
if (payPalConfig == null) {
return ServiceUtil.returnError(
UtilProperties.getMessage(
resource, "AccountingPayPalPaymentGatewayConfigCannotFind", locale));
}
GenericValue orderPaymentPreference = (GenericValue) context.get("orderPaymentPreference");
GenericValue captureTrans =
PaymentGatewayServices.getCaptureTransaction(orderPaymentPreference);
BigDecimal refundAmount = (BigDecimal) context.get("refundAmount");
NVPEncoder encoder = new NVPEncoder();
encoder.add("METHOD", "RefundTransaction");
encoder.add("TRANSACTIONID", captureTrans.getString("referenceNum"));
encoder.add("REFUNDTYPE", "Partial");
encoder.add("CURRENCYCODE", captureTrans.getString("currencyUomId"));
encoder.add("AMT", refundAmount.setScale(2, BigDecimal.ROUND_HALF_UP).toPlainString());
encoder.add("NOTE", "Order #" + orderPaymentPreference.getString("orderId"));
NVPDecoder decoder = null;
try {
decoder = sendNVPRequest(payPalConfig, encoder);
} catch (PayPalException e) {
Debug.logError(e, module);
return ServiceUtil.returnError(e.getMessage());
}
if (decoder == null) {
return ServiceUtil.returnError(
UtilProperties.getMessage(resource, "AccountingPayPalUnknownError", locale));
}
Map<String, Object> result = ServiceUtil.returnSuccess();
Map<String, String> errors = getErrorMessageMap(decoder);
if (UtilValidate.isNotEmpty(errors)) {
result.put("refundResult", false);
result.put("refundRefNum", captureTrans.getString("referenceNum"));
result.put("refundAmount", BigDecimal.ZERO);
if (errors.size() == 1) {
Map.Entry<String, String> error = errors.entrySet().iterator().next();
result.put("refundCode", error.getKey());
result.put("refundMessage", error.getValue());
} else {
result.put(
"refundMessage",
"Multiple errors occurred, please refer to the gateway response messages");
result.put("internalRespMsgs", errors);
}
} else {
result.put("refundResult", true);
result.put("refundAmount", new BigDecimal(decoder.get("GROSSREFUNDAMT")));
result.put("refundRefNum", decoder.get("REFUNDTRANSACTIONID"));
}
return result;
}
public static Map<String, Object> doVoid(DispatchContext dctx, Map<String, Object> context) {
GenericValue payPalConfig = getPaymentMethodGatewayPayPal(dctx, context, null);
Locale locale = (Locale) context.get("locale");
if (payPalConfig == null) {
return ServiceUtil.returnError(
UtilProperties.getMessage(
resource, "AccountingPayPalPaymentGatewayConfigCannotFind", locale));
}
GenericValue orderPaymentPreference = (GenericValue) context.get("orderPaymentPreference");
GenericValue authTrans = PaymentGatewayServices.getAuthTransaction(orderPaymentPreference);
NVPEncoder encoder = new NVPEncoder();
encoder.add("METHOD", "DoVoid");
encoder.add("AUTHORIZATIONID", authTrans.getString("referenceNum"));
NVPDecoder decoder = null;
try {
decoder = sendNVPRequest(payPalConfig, encoder);
} catch (PayPalException e) {
Debug.logError(e, module);
return ServiceUtil.returnError(e.getMessage());
}
if (decoder == null) {
return ServiceUtil.returnError(
UtilProperties.getMessage(resource, "AccountingPayPalUnknownError", locale));
}
Map<String, Object> result = ServiceUtil.returnSuccess();
Map<String, String> errors = getErrorMessageMap(decoder);
if (UtilValidate.isNotEmpty(errors)) {
result.put("releaseResult", false);
result.put("releaseRefNum", authTrans.getString("referenceNum"));
result.put("releaseAmount", BigDecimal.ZERO);
if (errors.size() == 1) {
Map.Entry<String, String> error = errors.entrySet().iterator().next();
result.put("releaseCode", error.getKey());
result.put("releaseMessage", error.getValue());
} else {
result.put(
"releaseMessage",
"Multiple errors occurred, please refer to the gateway response messages");
result.put("internalRespMsgs", errors);
}
} else {
result.put("releaseResult", true);
// PayPal voids the entire order amount minus any captures, that's a little difficult to
// figure out here
// so until further testing proves we should do otherwise I'm just going to return requested
// void amount
result.put("releaseAmount", context.get("releaseAmount"));
result.put("releaseRefNum", decoder.get("AUTHORIZATIONID"));
}
return result;
}
/**
* Retrieves a group of user preferences from persistent storage. Call with userPrefGroupTypeId
* and optional userPrefLoginId. If userPrefLoginId isn't specified, then the currently logged-in
* user's userLoginId will be used. The retrieved preferences group is contained in the
* <b>userPrefMap</b> element.
*
* @param ctx The DispatchContext that this service is operating in.
* @param context Map containing the input arguments.
* @return Map with the result of the service, the output parameters.
*/
public static Map<String, Object> getUserPreferenceGroup(
DispatchContext ctx, Map<String, ?> context) {
Locale locale = (Locale) context.get("locale");
if (!PreferenceWorker.isValidGetId(ctx, context)) {
return ServiceUtil.returnError(
UtilProperties.getMessage(resource, "getPreference.permissionError", locale));
}
Delegator delegator = ctx.getDelegator();
String userPrefGroupTypeId = (String) context.get("userPrefGroupTypeId");
if (UtilValidate.isEmpty(userPrefGroupTypeId)) {
return ServiceUtil.returnError(
UtilProperties.getMessage(resource, "getPreference.invalidArgument", locale));
}
String userLoginId = PreferenceWorker.getUserLoginId(context, true);
Map<String, Object> userPrefMap = null;
try {
Map<String, String> fieldMap =
UtilMisc.toMap("userLoginId", "_NA_", "userPrefGroupTypeId", userPrefGroupTypeId);
userPrefMap =
PreferenceWorker.createUserPrefMap(delegator.findByAnd("UserPreference", fieldMap));
fieldMap.put("userLoginId", userLoginId);
userPrefMap.putAll(
PreferenceWorker.createUserPrefMap(delegator.findByAnd("UserPreference", fieldMap)));
} catch (GenericEntityException e) {
Debug.logWarning(e.getMessage(), module);
return ServiceUtil.returnError(
UtilProperties.getMessage(
resource, "getPreference.readFailure", new Object[] {e.getMessage()}, locale));
} catch (GeneralException e) {
Debug.logWarning(e.getMessage(), module);
return ServiceUtil.returnError(
UtilProperties.getMessage(
resource, "getPreference.readFailure", new Object[] {e.getMessage()}, locale));
}
// for the 'DEFAULT' values find the related values in general properties and if found use
// those.
Iterator it = userPrefMap.entrySet().iterator();
Map generalProperties = UtilProperties.getProperties("general");
while (it.hasNext()) {
Map.Entry pairs = (Map.Entry) it.next();
if ("DEFAULT".equals(pairs.getValue())) {
if (UtilValidate.isNotEmpty(generalProperties.get(pairs.getKey()))) {
userPrefMap.put((String) pairs.getKey(), generalProperties.get(pairs.getKey()));
}
}
}
Map<String, Object> result = ServiceUtil.returnSuccess();
result.put("userPrefMap", userPrefMap);
return result;
}
/**
* JavaMail Service that gets body content from a URL
*
* @param ctx The DispatchContext that this service is operating in
* @param rcontext Map containing the input parameters
* @return Map with the result of the service, the output parameters
*/
public static Map<String, Object> sendMailFromUrl(
DispatchContext ctx, Map<String, ? extends Object> rcontext) {
// pretty simple, get the content and then call the sendMail method below
Map<String, Object> sendMailContext = UtilMisc.makeMapWritable(rcontext);
String bodyUrl = (String) sendMailContext.remove("bodyUrl");
Map<String, Object> bodyUrlParameters =
UtilGenerics.checkMap(sendMailContext.remove("bodyUrlParameters"));
Locale locale = (Locale) rcontext.get("locale");
LocalDispatcher dispatcher = ctx.getDispatcher();
URL url = null;
try {
url = new URL(bodyUrl);
} catch (MalformedURLException e) {
Debug.logWarning(e, module);
return ServiceUtil.returnError(
UtilProperties.getMessage(
resource,
"CommonEmailSendMalformedUrl",
UtilMisc.toMap("bodyUrl", bodyUrl, "errorString", e.toString()),
locale));
}
HttpClient httpClient = new HttpClient(url, bodyUrlParameters);
String body = null;
try {
body = httpClient.post();
} catch (HttpClientException e) {
Debug.logWarning(e, module);
return ServiceUtil.returnError(
UtilProperties.getMessage(
resource,
"CommonEmailSendGettingError",
UtilMisc.toMap("errorString", e.toString()),
locale));
}
sendMailContext.put("body", body);
Map<String, Object> sendMailResult;
try {
sendMailResult = dispatcher.runSync("sendMail", sendMailContext);
} catch (GenericServiceException e) {
Debug.logError(e, module);
return ServiceUtil.returnError(e.getMessage());
}
// just return the same result; it contains all necessary information
return sendMailResult;
}
/**
* Retrieves a single user preference from persistent storage. Call with userPrefTypeId and
* optional userPrefLoginId. If userPrefLoginId isn't specified, then the currently logged-in
* user's userLoginId will be used. The retrieved preference is contained in the
* <b>userPrefMap</b> element.
*
* @param ctx The DispatchContext that this service is operating in.
* @param context Map containing the input arguments.
* @return Map with the result of the service, the output parameters.
*/
public static Map<String, Object> getUserPreference(DispatchContext ctx, Map<String, ?> context) {
Locale locale = (Locale) context.get("locale");
if (!PreferenceWorker.isValidGetId(ctx, context)) {
return ServiceUtil.returnError(
UtilProperties.getMessage(resource, "getPreference.permissionError", locale));
}
Delegator delegator = ctx.getDelegator();
String userPrefTypeId = (String) context.get("userPrefTypeId");
if (UtilValidate.isEmpty(userPrefTypeId)) {
return ServiceUtil.returnError(
UtilProperties.getMessage(resource, "getPreference.invalidArgument", locale));
}
String userLoginId = PreferenceWorker.getUserLoginId(context, true);
Map<String, String> fieldMap =
UtilMisc.toMap("userLoginId", userLoginId, "userPrefTypeId", userPrefTypeId);
String userPrefGroupTypeId = (String) context.get("userPrefGroupTypeId");
if (UtilValidate.isNotEmpty(userPrefGroupTypeId)) {
fieldMap.put("userPrefGroupTypeId", userPrefGroupTypeId);
}
Map<String, Object> userPrefMap = null;
try {
GenericValue preference =
EntityUtil.getFirst(delegator.findByAnd("UserPreference", fieldMap));
if (preference != null) {
userPrefMap = PreferenceWorker.createUserPrefMap(preference);
}
} catch (GenericEntityException e) {
Debug.logWarning(e.getMessage(), module);
return ServiceUtil.returnError(
UtilProperties.getMessage(
resource, "getPreference.readFailure", new Object[] {e.getMessage()}, locale));
} catch (GeneralException e) {
Debug.logWarning(e.getMessage(), module);
return ServiceUtil.returnError(
UtilProperties.getMessage(
resource, "getPreference.readFailure", new Object[] {e.getMessage()}, locale));
}
Map<String, Object> result = ServiceUtil.returnSuccess();
result.put("userPrefMap", userPrefMap);
if (userPrefMap != null) {
// Put the value in the result Map too, makes access easier for calling methods.
Object userPrefValue = userPrefMap.get(userPrefTypeId);
if (userPrefValue != null) {
result.put("userPrefValue", userPrefValue);
}
}
return result;
}
/** Cause a Referential Integrity Error */
public static Map<String, Object> entityFailTest(DispatchContext dctx, Map<String, ?> context) {
Delegator delegator = dctx.getDelegator();
Locale locale = (Locale) context.get("locale");
// attempt to create a DataSource entity w/ an invalid dataSourceTypeId
GenericValue newEntity = delegator.makeValue("DataSource");
newEntity.set("dataSourceId", "ENTITY_FAIL_TEST");
newEntity.set("dataSourceTypeId", "ENTITY_FAIL_TEST");
newEntity.set("description", "Entity Fail Test - Delete me if I am here");
try {
delegator.create(newEntity);
} catch (GenericEntityException e) {
Debug.logError(e, module);
return ServiceUtil.returnError(
UtilProperties.getMessage(resource, "CommonEntityTestFailure", locale));
}
/*
try {
newEntity.remove();
} catch (GenericEntityException e) {
Debug.logError(e, module);
}
*/
return ServiceUtil.returnSuccess();
}
public static Map<String, Object> doAuthorization(
DispatchContext dctx, Map<String, Object> context) {
Delegator delegator = dctx.getDelegator();
String orderId = (String) context.get("orderId");
BigDecimal processAmount = (BigDecimal) context.get("processAmount");
GenericValue payPalPaymentMethod = (GenericValue) context.get("payPalPaymentMethod");
OrderReadHelper orh = new OrderReadHelper(delegator, orderId);
GenericValue payPalConfig =
getPaymentMethodGatewayPayPal(dctx, context, PaymentGatewayServices.AUTH_SERVICE_TYPE);
Locale locale = (Locale) context.get("locale");
NVPEncoder encoder = new NVPEncoder();
encoder.add("METHOD", "DoAuthorization");
encoder.add("TRANSACTIONID", payPalPaymentMethod.getString("transactionId"));
encoder.add("AMT", processAmount.setScale(2, BigDecimal.ROUND_HALF_UP).toPlainString());
encoder.add("TRANSACTIONENTITY", "Order");
String currency = (String) context.get("currency");
if (currency == null) {
currency = orh.getCurrency();
}
encoder.add("CURRENCYCODE", currency);
NVPDecoder decoder = null;
try {
decoder = sendNVPRequest(payPalConfig, encoder);
} catch (PayPalException e) {
Debug.logError(e, module);
return ServiceUtil.returnError(e.getMessage());
}
if (decoder == null) {
return ServiceUtil.returnError(
UtilProperties.getMessage(resource, "AccountingPayPalUnknownError", locale));
}
Map<String, Object> result = ServiceUtil.returnSuccess();
Map<String, String> errors = getErrorMessageMap(decoder);
if (UtilValidate.isNotEmpty(errors)) {
result.put("authResult", false);
result.put("authRefNum", "N/A");
result.put("processAmount", BigDecimal.ZERO);
if (errors.size() == 1) {
Map.Entry<String, String> error = errors.entrySet().iterator().next();
result.put("authCode", error.getKey());
result.put("authMessage", error.getValue());
} else {
result.put(
"authMessage",
"Multiple errors occurred, please refer to the gateway response messages");
result.put("internalRespMsgs", errors);
}
} else {
result.put("authResult", true);
result.put("processAmount", new BigDecimal(decoder.get("AMT")));
result.put("authRefNum", decoder.get("TRANSACTIONID"));
}
// TODO: Look into possible PAYMENTSTATUS and PENDINGREASON return codes, it is unclear what
// should be checked for this type of transaction
return result;
}
public static Map<String, Object> doCapture(DispatchContext dctx, Map<String, Object> context) {
GenericValue paymentPref = (GenericValue) context.get("orderPaymentPreference");
BigDecimal captureAmount = (BigDecimal) context.get("captureAmount");
GenericValue payPalConfig =
getPaymentMethodGatewayPayPal(dctx, context, PaymentGatewayServices.AUTH_SERVICE_TYPE);
GenericValue authTrans = (GenericValue) context.get("authTrans");
Locale locale = (Locale) context.get("locale");
if (authTrans == null) {
authTrans = PaymentGatewayServices.getAuthTransaction(paymentPref);
}
NVPEncoder encoder = new NVPEncoder();
encoder.add("METHOD", "DoCapture");
encoder.add("AUTHORIZATIONID", authTrans.getString("referenceNum"));
encoder.add("AMT", captureAmount.setScale(2, BigDecimal.ROUND_HALF_UP).toPlainString());
encoder.add("CURRENCYCODE", authTrans.getString("currencyUomId"));
encoder.add("COMPLETETYPE", "NotComplete");
NVPDecoder decoder = null;
try {
decoder = sendNVPRequest(payPalConfig, encoder);
} catch (PayPalException e) {
Debug.logError(e, module);
return ServiceUtil.returnError(e.getMessage());
}
if (decoder == null) {
return ServiceUtil.returnError(
UtilProperties.getMessage(resource, "AccountingPayPalUnknownError", locale));
}
Map<String, Object> result = ServiceUtil.returnSuccess();
Map<String, String> errors = getErrorMessageMap(decoder);
if (UtilValidate.isNotEmpty(errors)) {
result.put("captureResult", false);
result.put("captureRefNum", "N/A");
result.put("captureAmount", BigDecimal.ZERO);
if (errors.size() == 1) {
Map.Entry<String, String> error = errors.entrySet().iterator().next();
result.put("captureCode", error.getKey());
result.put("captureMessage", error.getValue());
} else {
result.put(
"captureMessage",
"Multiple errors occurred, please refer to the gateway response messages");
result.put("internalRespMsgs", errors);
}
} else {
result.put("captureResult", true);
result.put("captureAmount", new BigDecimal(decoder.get("AMT")));
result.put("captureRefNum", decoder.get("TRANSACTIONID"));
}
// TODO: Look into possible PAYMENTSTATUS and PENDINGREASON return codes, it is unclear what
// should be checked for this type of transaction
return result;
}
/**
* Stores a user preference group in persistent storage. Call with userPrefMap,
* userPrefGroupTypeId and optional userPrefLoginId. If userPrefLoginId isn't specified, then the
* currently logged-in user's userLoginId will be used.
*
* @param ctx The DispatchContext that this service is operating in.
* @param context Map containing the input arguments.
* @return Map with the result of the service, the output parameters.
*/
public static Map<String, Object> setUserPreferenceGroup(
DispatchContext ctx, Map<String, ?> context) {
Delegator delegator = ctx.getDelegator();
Locale locale = (Locale) context.get("locale");
String userLoginId = PreferenceWorker.getUserLoginId(context, false);
Map<String, Object> userPrefMap =
checkMap(context.get("userPrefMap"), String.class, Object.class);
String userPrefGroupTypeId = (String) context.get("userPrefGroupTypeId");
if (UtilValidate.isEmpty(userLoginId)
|| UtilValidate.isEmpty(userPrefGroupTypeId)
|| userPrefMap == null) {
return ServiceUtil.returnError(
UtilProperties.getMessage(resource, "setPreference.invalidArgument", locale));
}
try {
for (Iterator i = userPrefMap.entrySet().iterator(); i.hasNext(); ) {
Map.Entry mapEntry = (Map.Entry) i.next();
GenericValue rec =
delegator.makeValidValue(
"UserPreference",
PreferenceWorker.toFieldMap(
userLoginId,
(String) mapEntry.getKey(),
userPrefGroupTypeId,
(String) mapEntry.getValue()));
delegator.createOrStore(rec);
}
} catch (GenericEntityException e) {
Debug.logWarning(e.getMessage(), module);
return ServiceUtil.returnError(
UtilProperties.getMessage(
resource, "setPreference.writeFailure", new Object[] {e.getMessage()}, locale));
} catch (GeneralException e) {
Debug.logWarning(e.getMessage(), module);
return ServiceUtil.returnError(
UtilProperties.getMessage(
resource, "setPreference.writeFailure", new Object[] {e.getMessage()}, locale));
}
return ServiceUtil.returnSuccess();
}
public static Map<String, Object> finAccountReleaseAuth(
DispatchContext dctx, Map<String, 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, "AccountingFinAccountCannotBeExpired", 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.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());
}
}
/**
* Stores a single user preference in persistent storage. Call with userPrefTypeId,
* userPrefGroupTypeId, userPrefValue and optional userPrefLoginId. If userPrefLoginId isn't
* specified, then the currently logged-in user's userLoginId will be used.
*
* @param ctx The DispatchContext that this service is operating in.
* @param context Map containing the input arguments.
* @return Map with the result of the service, the output parameters.
*/
public static Map<String, Object> setUserPreference(DispatchContext ctx, Map<String, ?> context) {
Delegator delegator = ctx.getDelegator();
Locale locale = (Locale) context.get("locale");
String userLoginId = PreferenceWorker.getUserLoginId(context, false);
String userPrefTypeId = (String) context.get("userPrefTypeId");
Object userPrefValue = (String) context.get("userPrefValue");
if (UtilValidate.isEmpty(userLoginId)
|| UtilValidate.isEmpty(userPrefTypeId)
|| userPrefValue == null) {
return ServiceUtil.returnError(
UtilProperties.getMessage(resource, "setPreference.invalidArgument", locale));
}
String userPrefGroupTypeId = (String) context.get("userPrefGroupTypeId");
String userPrefDataType = (String) context.get("userPrefDataType");
try {
if (UtilValidate.isNotEmpty(userPrefDataType)) {
userPrefValue =
ObjectType.simpleTypeConvert(userPrefValue, userPrefDataType, null, null, false);
}
GenericValue rec =
delegator.makeValidValue(
"UserPreference",
PreferenceWorker.toFieldMap(
userLoginId, userPrefTypeId, userPrefGroupTypeId, userPrefValue));
delegator.createOrStore(rec);
} catch (GenericEntityException e) {
Debug.logWarning(e.getMessage(), module);
return ServiceUtil.returnError(
UtilProperties.getMessage(
resource, "setPreference.writeFailure", new Object[] {e.getMessage()}, locale));
} catch (GeneralException e) {
Debug.logWarning(e.getMessage(), module);
return ServiceUtil.returnError(
UtilProperties.getMessage(
resource, "setPreference.writeFailure", new Object[] {e.getMessage()}, locale));
}
return ServiceUtil.returnSuccess();
}
/**
* Returns a complete category trail - can be used for exporting proper category trees. This is
* mostly useful when used in combination with bread-crumbs, for building a faceted index tree, or
* to export a category tree for migration to another system. Will create the tree from root point
* to categoryId.
*
* <p>This method is not meant to be run on every request. Its best use is to generate the trail
* every so often and store somewhere (a lucene/solr tree, entities, cache or so).
*
* @param productCategoryId id of category the trail should be generated for
* @returns List organized trail from root point to categoryId.
*/
public static Map getCategoryTrail(DispatchContext dctx, Map context) {
String productCategoryId = (String) context.get("productCategoryId");
Map<String, Object> results = ServiceUtil.returnSuccess();
GenericDelegator delegator = (GenericDelegator) dctx.getDelegator();
List<String> trailElements = FastList.newInstance();
trailElements.add(productCategoryId);
String parentProductCategoryId = productCategoryId;
while (UtilValidate.isNotEmpty(parentProductCategoryId)) {
// find product category rollup
try {
List<EntityCondition> rolllupConds = FastList.newInstance();
rolllupConds.add(
EntityCondition.makeCondition("productCategoryId", parentProductCategoryId));
rolllupConds.add(EntityUtil.getFilterByDateExpr());
List<GenericValue> productCategoryRollups =
delegator.findList(
"ProductCategoryRollup",
EntityCondition.makeCondition(rolllupConds),
null,
UtilMisc.toList("sequenceNum"),
null,
true);
if (UtilValidate.isNotEmpty(productCategoryRollups)) {
// add only categories that belong to the top category to trail
for (GenericValue productCategoryRollup : productCategoryRollups) {
String trailCategoryId = productCategoryRollup.getString("parentProductCategoryId");
parentProductCategoryId = trailCategoryId;
if (trailElements.contains(trailCategoryId)) {
break;
} else {
trailElements.add(trailCategoryId);
}
}
} else {
parentProductCategoryId = null;
}
} catch (GenericEntityException e) {
Map<String, String> messageMap =
UtilMisc.toMap("errMessage", ". Cannot generate trail from product category. ");
String errMsg =
UtilProperties.getMessage(
"CommonUiLabels",
"CommonDatabaseProblem",
messageMap,
(Locale) context.get("locale"));
Debug.logError(e, errMsg, module);
return ServiceUtil.returnError(errMsg);
}
}
Collections.reverse(trailElements);
results.put("trail", trailElements);
return results;
}
public static void sendFailureNotification(
DispatchContext dctx,
Map<String, ? extends Object> context,
MimeMessage message,
List<SMTPAddressFailedException> failures) {
Locale locale = (Locale) context.get("locale");
Map<String, Object> newContext = FastMap.newInstance();
newContext.put("userLogin", context.get("userLogin"));
newContext.put("sendFailureNotification", false);
newContext.put("sendFrom", context.get("sendFrom"));
newContext.put("sendTo", context.get("sendFrom"));
newContext.put(
"subject", UtilProperties.getMessage(resource, "CommonEmailSendUndeliveredMail", locale));
StringBuilder sb = new StringBuilder();
sb.append(UtilProperties.getMessage(resource, "CommonEmailDeliveryFailed", locale));
sb.append("/n/n");
for (SMTPAddressFailedException failure : failures) {
sb.append(failure.getAddress());
sb.append(": ");
sb.append(failure.getMessage());
sb.append("/n/n");
}
sb.append(UtilProperties.getMessage(resource, "CommonEmailDeliveryOriginalMessage", locale));
sb.append("/n/n");
List<Map<String, Object>> bodyParts = FastList.newInstance();
bodyParts.add(UtilMisc.<String, Object>toMap("content", sb.toString(), "type", "text/plain"));
Map<String, Object> bodyPart = FastMap.newInstance();
bodyPart.put("content", sb.toString());
bodyPart.put("type", "text/plain");
try {
bodyParts.add(UtilMisc.<String, Object>toMap("content", message.getDataHandler()));
} catch (MessagingException e) {
Debug.logError(e, module);
}
try {
dctx.getDispatcher().runSync("sendMailMultiPart", newContext);
} catch (GenericServiceException e) {
Debug.logError(e, module);
}
}
public static Map<String, Object> testRollbackListener(
DispatchContext dctx, Map<String, ?> context) {
Locale locale = (Locale) context.get("locale");
ServiceXaWrapper xar = new ServiceXaWrapper(dctx);
xar.setRollbackService("testScv", context);
try {
xar.enlist();
} catch (XAException e) {
Debug.logError(e, module);
}
return ServiceUtil.returnError(
UtilProperties.getMessage(resource, "CommonTestRollingBack", locale));
}
/**
* Create Note Record
*
* @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> createNote(DispatchContext ctx, Map<String, ?> context) {
Delegator delegator = ctx.getDelegator();
GenericValue userLogin = (GenericValue) context.get("userLogin");
Timestamp noteDate = (Timestamp) context.get("noteDate");
String partyId = (String) context.get("partyId");
String noteName = (String) context.get("noteName");
String note = (String) context.get("note");
String noteId = delegator.getNextSeqId("NoteData");
Locale locale = (Locale) context.get("locale");
if (noteDate == null) {
noteDate = UtilDateTime.nowTimestamp();
}
// check for a party id
if (partyId == null) {
if (userLogin != null && userLogin.get("partyId") != null)
partyId = userLogin.getString("partyId");
}
Map<String, Object> fields =
UtilMisc.toMap(
"noteId",
noteId,
"noteName",
noteName,
"noteInfo",
note,
"noteParty",
partyId,
"noteDateTime",
noteDate);
try {
GenericValue newValue = delegator.makeValue("NoteData", fields);
delegator.create(newValue);
} catch (GenericEntityException e) {
return ServiceUtil.returnError(
UtilProperties.getMessage(
resource,
"CommonNoteCannotBeUpdated",
UtilMisc.toMap("errorString", e.getMessage()),
locale));
}
Map<String, Object> result = ServiceUtil.returnSuccess();
result.put("noteId", noteId);
result.put("partyId", partyId);
return result;
}
/**
* getBufferedImage
*
* <p>Set a buffered image
*
* @param context
* @param fileLocation Full file Path or URL
* @return URL images for all different size types
* @throws IOException Error prevents the document from being fully parsed
* @throws JDOMException Errors occur in parsing
*/
public static Map<String, Object> getBufferedImage(String fileLocation, Locale locale)
throws IllegalArgumentException, IOException {
/* VARIABLES */
BufferedImage bufImg;
Map<String, Object> result = FastMap.newInstance();
/* BUFFERED IMAGE */
try {
bufImg = ImageIO.read(new File(fileLocation));
} catch (IllegalArgumentException e) {
String errMsg =
UtilProperties.getMessage(resource, "ImageTransform.input_is_null", locale)
+ " : "
+ fileLocation
+ " ; "
+ e.toString();
Debug.logError(errMsg, module);
result.put("errorMessage", errMsg);
return result;
} catch (IOException e) {
String errMsg =
UtilProperties.getMessage(resource, "ImageTransform.error_occurs_during_reading", locale)
+ " : "
+ fileLocation
+ " ; "
+ e.toString();
Debug.logError(errMsg, module);
result.put("errorMessage", errMsg);
return result;
}
result.put("responseMessage", "success");
result.put("bufferedImage", bufImg);
return result;
}
public static String replaceShoppingListItem(
HttpServletRequest request, HttpServletResponse response) {
String quantityStr = request.getParameter("quantity");
// just call the updateShoppingListItem service
LocalDispatcher dispatcher = (LocalDispatcher) request.getAttribute("dispatcher");
GenericValue userLogin = (GenericValue) request.getSession().getAttribute("userLogin");
Locale locale = UtilHttp.getLocale(request);
BigDecimal quantity = null;
try {
quantity = new BigDecimal(quantityStr);
} catch (Exception e) {
// do nothing, just won't pass to service if it is null
}
Map<String, Object> serviceInMap = FastMap.newInstance();
serviceInMap.put("shoppingListId", request.getParameter("shoppingListId"));
serviceInMap.put("shoppingListItemSeqId", request.getParameter("shoppingListItemSeqId"));
serviceInMap.put("productId", request.getParameter("add_product_id"));
serviceInMap.put("userLogin", userLogin);
if (quantity != null) serviceInMap.put("quantity", quantity);
Map<String, Object> result = null;
try {
result = dispatcher.runSync("updateShoppingListItem", serviceInMap);
} catch (GenericServiceException e) {
String errMsg =
UtilProperties.getMessage(
resource_error, "shoppingListEvents.error_calling_update", locale)
+ ": "
+ e.toString();
request.setAttribute("_ERROR_MESSAGE_", errMsg);
String errorMsg =
"Error calling the updateShoppingListItem in handleShoppingListItemVariant: "
+ e.toString();
Debug.logError(e, errorMsg, module);
return "error";
}
ServiceUtil.getMessages(request, result, "", "", "", "", "", "", "");
if ("error".equals(result.get(ModelService.RESPONSE_MESSAGE))) {
return "error";
} else {
return "success";
}
}
public static String getJSONuiLabel(HttpServletRequest request, HttpServletResponse response) {
String requiredLabels = request.getParameter("requiredLabel");
JSONObject uiLabelObject = null;
if (UtilValidate.isNotEmpty(requiredLabels)) {
// Transform JSON String to Object
uiLabelObject = (JSONObject) JSONSerializer.toJSON(requiredLabels);
}
JSONArray jsonUiLabel = new JSONArray();
Locale locale = request.getLocale();
if (!uiLabelObject.isEmpty()) {
Set<String> resourceSet = UtilGenerics.checkSet(uiLabelObject.keySet());
// Iterate over the resource set
// here we need a keySet because we don't now which label resource to load
// the key set should have the size one, if greater or empty error should returned
if (UtilValidate.isEmpty(resourceSet)) {
Debug.logError("No resource and labels found", module);
return "error";
} else if (resourceSet.size() > 1) {
Debug.logError(
"More than one resource found, please use the method: getJSONuiLabelArray", module);
return "error";
}
for (String resource : resourceSet) {
String label = uiLabelObject.getString(resource);
if (UtilValidate.isEmail(label)) {
continue;
}
String receivedLabel = UtilProperties.getMessage(resource, label, locale);
jsonUiLabel.add(receivedLabel);
}
}
writeJSONtoResponse(jsonUiLabel, response);
return "success";
}
public static String getJSONuiLabelArray(
HttpServletRequest request, HttpServletResponse response) {
String requiredLabels = request.getParameter("requiredLabels");
JSONObject uiLabelObject = null;
if (UtilValidate.isNotEmpty(requiredLabels)) {
// Transform JSON String to Object
uiLabelObject = (JSONObject) JSONSerializer.toJSON(requiredLabels);
}
JSONObject jsonUiLabel = new JSONObject();
Locale locale = request.getLocale();
if (!uiLabelObject.isEmpty()) {
Set<String> resourceSet = UtilGenerics.checkSet(uiLabelObject.keySet());
// Iterate over the resouce set
for (String resource : resourceSet) {
JSONArray labels = uiLabelObject.getJSONArray(resource);
if (labels.isEmpty() || labels == null) {
continue;
}
// Iterate over the uiLabel List
Iterator<String> jsonLabelIterator = UtilGenerics.cast(labels.iterator());
JSONArray resourceLabelList = new JSONArray();
while (jsonLabelIterator.hasNext()) {
String label = jsonLabelIterator.next();
String receivedLabel = UtilProperties.getMessage(resource, label, locale);
if (UtilValidate.isNotEmpty(receivedLabel)) {
resourceLabelList.add(receivedLabel);
}
}
jsonUiLabel.element(resource, resourceLabelList);
}
}
writeJSONtoResponse(jsonUiLabel, response);
return "success";
}
public static Map<String, Object> getExpressCheckout(
DispatchContext dctx, Map<String, Object> context) {
Locale locale = (Locale) context.get("locale");
LocalDispatcher dispatcher = dctx.getDispatcher();
Delegator delegator = dctx.getDelegator();
ShoppingCart cart = (ShoppingCart) context.get("cart");
GenericValue payPalConfig = getPaymentMethodGatewayPayPal(dctx, context, null);
if (payPalConfig == null) {
return ServiceUtil.returnError(
UtilProperties.getMessage(
resource, "AccountingPayPalPaymentGatewayConfigCannotFind", locale));
}
NVPEncoder encoder = new NVPEncoder();
encoder.add("METHOD", "GetExpressCheckoutDetails");
String token = (String) cart.getAttribute("payPalCheckoutToken");
if (UtilValidate.isNotEmpty(token)) {
encoder.add("TOKEN", token);
} else {
return ServiceUtil.returnError(
UtilProperties.getMessage(resource, "AccountingPayPalTokenNotFound", locale));
}
NVPDecoder decoder;
try {
decoder = sendNVPRequest(payPalConfig, encoder);
} catch (PayPalException e) {
Debug.logError(e, module);
return ServiceUtil.returnError(e.getMessage());
}
if (UtilValidate.isNotEmpty(decoder.get("NOTE"))) {
cart.addOrderNote(decoder.get("NOTE"));
}
if (cart.getUserLogin() == null) {
try {
GenericValue userLogin =
EntityQuery.use(delegator)
.from("UserLogin")
.where("userLoginId", "anonymous")
.queryOne();
try {
cart.setUserLogin(userLogin, dispatcher);
} catch (CartItemModifyException e) {
Debug.logError(e, module);
return ServiceUtil.returnError(e.getMessage());
}
} catch (GenericEntityException e) {
Debug.logError(e, module);
return ServiceUtil.returnError(e.getMessage());
}
}
boolean anon = "anonymous".equals(cart.getUserLogin().getString("userLoginId"));
// Even if anon, a party could already have been created
String partyId = cart.getOrderPartyId();
if (partyId == null && anon) {
// Check nothing has been set on the anon userLogin either
partyId = cart.getUserLogin() != null ? cart.getUserLogin().getString("partyId") : null;
cart.setOrderPartyId(partyId);
}
if (partyId != null) {
GenericValue party = null;
try {
party = EntityQuery.use(delegator).from("Party").where("partyId", partyId).queryOne();
} catch (GenericEntityException e) {
Debug.logError(e, module);
}
if (party == null) {
partyId = null;
}
}
Map<String, Object> inMap = FastMap.newInstance();
Map<String, Object> outMap = null;
// Create the person if necessary
boolean newParty = false;
if (partyId == null) {
newParty = true;
inMap.put("userLogin", cart.getUserLogin());
inMap.put("personalTitle", decoder.get("SALUTATION"));
inMap.put("firstName", decoder.get("FIRSTNAME"));
inMap.put("middleName", decoder.get("MIDDLENAME"));
inMap.put("lastName", decoder.get("LASTNAME"));
inMap.put("suffix", decoder.get("SUFFIX"));
try {
outMap = dispatcher.runSync("createPerson", inMap);
partyId = (String) outMap.get("partyId");
cart.setOrderPartyId(partyId);
cart.getUserLogin().setString("partyId", partyId);
inMap.clear();
inMap.put("userLogin", cart.getUserLogin());
inMap.put("partyId", partyId);
inMap.put("roleTypeId", "CUSTOMER");
dispatcher.runSync("createPartyRole", inMap);
} catch (GenericServiceException e) {
Debug.logError(e, module);
return ServiceUtil.returnError(e.getMessage());
}
}
// Create a new email address if necessary
String emailContactMechId = null;
String emailContactPurposeTypeId = "PRIMARY_EMAIL";
String emailAddress = decoder.get("EMAIL");
if (!newParty) {
EntityCondition cond =
EntityCondition.makeCondition(
UtilMisc.toList(
EntityCondition.makeCondition(
UtilMisc.toMap("partyId", partyId, "contactMechTypeId", "EMAIL_ADDRESS")),
EntityCondition.makeCondition(
EntityFunction.UPPER_FIELD("infoString"),
EntityComparisonOperator.EQUALS,
EntityFunction.UPPER(emailAddress))));
try {
GenericValue matchingEmail =
EntityQuery.use(delegator)
.from("PartyAndContactMech")
.where(cond)
.orderBy("fromDate")
.filterByDate()
.queryFirst();
if (matchingEmail != null) {
emailContactMechId = matchingEmail.getString("contactMechId");
} else {
// No email found so we'll need to create one but first check if it should be PRIMARY or
// just BILLING
long primaryEmails =
EntityQuery.use(delegator)
.from("PartyContactWithPurpose")
.where(
"partyId",
partyId,
"contactMechTypeId",
"EMAIL_ADDRESS",
"contactMechPurposeTypeId",
"PRIMARY_EMAIL")
.filterByDate(
"contactFromDate", "contactThruDate", "purposeFromDate", "purposeThruDate")
.queryCount();
if (primaryEmails > 0) emailContactPurposeTypeId = "BILLING_EMAIL";
}
} catch (GenericEntityException e) {
Debug.logError(e, module);
}
}
if (emailContactMechId == null) {
inMap.clear();
inMap.put("userLogin", cart.getUserLogin());
inMap.put("contactMechPurposeTypeId", emailContactPurposeTypeId);
inMap.put("emailAddress", emailAddress);
inMap.put("partyId", partyId);
inMap.put("roleTypeId", "CUSTOMER");
inMap.put("verified", "Y"); // Going to assume PayPal has taken care of this for us
inMap.put("fromDate", UtilDateTime.nowTimestamp());
try {
outMap = dispatcher.runSync("createPartyEmailAddress", inMap);
emailContactMechId = (String) outMap.get("contactMechId");
} catch (GenericServiceException e) {
Debug.logError(e, module);
return ServiceUtil.returnError(e.getMessage());
}
}
cart.addContactMech("ORDER_EMAIL", emailContactMechId);
// Phone number
String phoneNumber = decoder.get("PHONENUM");
String phoneContactId = null;
if (phoneNumber != null) {
inMap.clear();
if (phoneNumber.startsWith("+")) {
// International, format is +XXX XXXXXXXX which we'll split into countryCode + contactNumber
String[] phoneNumbers = phoneNumber.split(" ");
inMap.put("countryCode", StringUtil.removeNonNumeric(phoneNumbers[0]));
inMap.put("contactNumber", phoneNumbers[1]);
} else {
// U.S., format is XXX-XXX-XXXX which we'll split into areaCode + contactNumber
inMap.put("countryCode", "1");
String[] phoneNumbers = phoneNumber.split("-");
inMap.put("areaCode", phoneNumbers[0]);
inMap.put("contactNumber", phoneNumbers[1] + phoneNumbers[2]);
}
inMap.put("userLogin", cart.getUserLogin());
inMap.put("partyId", partyId);
try {
outMap = dispatcher.runSync("createUpdatePartyTelecomNumber", inMap);
phoneContactId = (String) outMap.get("contactMechId");
cart.addContactMech("PHONE_BILLING", phoneContactId);
} catch (GenericServiceException e) {
Debug.logError(e, module);
}
}
// Create a new Postal Address if necessary
String postalContactId = null;
boolean needsShippingPurpose = true;
// if the cart for some reason already has a billing address, we'll leave it be
boolean needsBillingPurpose = (cart.getContactMech("BILLING_LOCATION") == null);
Map<String, Object> postalMap = FastMap.newInstance();
postalMap.put("toName", decoder.get("SHIPTONAME"));
postalMap.put("address1", decoder.get("SHIPTOSTREET"));
postalMap.put("address2", decoder.get("SHIPTOSTREET2"));
postalMap.put("city", decoder.get("SHIPTOCITY"));
String countryGeoId =
PayPalServices.getCountryGeoIdFromGeoCode(decoder.get("SHIPTOCOUNTRYCODE"), delegator);
postalMap.put("countryGeoId", countryGeoId);
postalMap.put(
"stateProvinceGeoId",
parseStateProvinceGeoId(decoder.get("SHIPTOSTATE"), countryGeoId, delegator));
postalMap.put("postalCode", decoder.get("SHIPTOZIP"));
if (!newParty) {
// We want an exact match only
EntityCondition cond =
EntityCondition.makeCondition(
UtilMisc.toList(
EntityCondition.makeCondition(postalMap),
EntityCondition.makeCondition(
UtilMisc.toMap(
"attnName",
null,
"directions",
null,
"postalCodeExt",
null,
"postalCodeGeoId",
null)),
EntityCondition.makeCondition("partyId", partyId)));
try {
GenericValue postalMatch =
EntityQuery.use(delegator)
.from("PartyAndPostalAddress")
.where(cond)
.orderBy("fromDate")
.filterByDate()
.queryFirst();
if (postalMatch != null) {
postalContactId = postalMatch.getString("contactMechId");
List<GenericValue> postalPurposes =
EntityQuery.use(delegator)
.from("PartyContactMechPurpose")
.where("partyId", partyId, "contactMechId", postalContactId)
.filterByDate()
.queryList();
List<Object> purposeStrings =
EntityUtil.getFieldListFromEntityList(
postalPurposes, "contactMechPurposeTypeId", false);
if (UtilValidate.isNotEmpty(purposeStrings)
&& purposeStrings.contains("SHIPPING_LOCATION")) {
needsShippingPurpose = false;
}
if (needsBillingPurpose
&& UtilValidate.isNotEmpty(purposeStrings)
&& purposeStrings.contains("BILLING_LOCATION")) {
needsBillingPurpose = false;
}
}
} catch (GenericEntityException e) {
Debug.logError(e, module);
}
}
if (postalContactId == null) {
postalMap.put("userLogin", cart.getUserLogin());
postalMap.put("fromDate", UtilDateTime.nowTimestamp());
try {
outMap = dispatcher.runSync("createPartyPostalAddress", postalMap);
postalContactId = (String) outMap.get("contactMechId");
} catch (GenericServiceException e) {
Debug.logError(e, module);
return ServiceUtil.returnError(e.getMessage());
}
}
if (needsShippingPurpose || needsBillingPurpose) {
inMap.clear();
inMap.put("userLogin", cart.getUserLogin());
inMap.put("contactMechId", postalContactId);
inMap.put("partyId", partyId);
try {
if (needsShippingPurpose) {
inMap.put("contactMechPurposeTypeId", "SHIPPING_LOCATION");
dispatcher.runSync("createPartyContactMechPurpose", inMap);
}
if (needsBillingPurpose) {
inMap.put("contactMechPurposeTypeId", "BILLING_LOCATION");
dispatcher.runSync("createPartyContactMechPurpose", inMap);
}
} catch (GenericServiceException e) {
// Not the end of the world, we'll carry on
Debug.logInfo(e.getMessage(), module);
}
}
// Load the selected shipping method - thanks to PayPal's less than sane API all we've to work
// with is the shipping option label
// that was shown to the customer
String shipMethod = decoder.get("SHIPPINGOPTIONNAME");
if ("Calculated Offline".equals(shipMethod)) {
cart.setAllCarrierPartyId("_NA_");
cart.setAllShipmentMethodTypeId("NO_SHIPPING");
} else {
String[] shipMethodSplit = shipMethod.split(" - ");
cart.setAllCarrierPartyId(shipMethodSplit[0]);
String shippingMethodTypeDesc =
StringUtils.join(shipMethodSplit, " - ", 1, shipMethodSplit.length);
try {
GenericValue shipmentMethod =
EntityQuery.use(delegator)
.from("ProductStoreShipmentMethView")
.where(
"productStoreId",
cart.getProductStoreId(),
"partyId",
shipMethodSplit[0],
"roleTypeId",
"CARRIER",
"description",
shippingMethodTypeDesc)
.queryFirst();
cart.setAllShipmentMethodTypeId(shipmentMethod.getString("shipmentMethodTypeId"));
} catch (GenericEntityException e1) {
Debug.logError(e1, module);
}
}
// Get rid of any excess ship groups
List<CartShipInfo> shipGroups = cart.getShipGroups();
for (int i = 1; i < shipGroups.size(); i++) {
Map<ShoppingCartItem, BigDecimal> items = cart.getShipGroupItems(i);
for (Map.Entry<ShoppingCartItem, BigDecimal> entry : items.entrySet()) {
cart.positionItemToGroup(entry.getKey(), entry.getValue(), i, 0, false);
}
}
cart.cleanUpShipGroups();
cart.setAllShippingContactMechId(postalContactId);
Map<String, Object> result =
ShippingEvents.getShipGroupEstimate(dispatcher, delegator, cart, 0);
if (result.get(ModelService.RESPONSE_MESSAGE).equals(ModelService.RESPOND_ERROR)) {
return ServiceUtil.returnError((String) result.get(ModelService.ERROR_MESSAGE));
}
BigDecimal shippingTotal = (BigDecimal) result.get("shippingTotal");
if (shippingTotal == null) {
shippingTotal = BigDecimal.ZERO;
}
cart.setItemShipGroupEstimate(shippingTotal, 0);
CheckOutHelper cho = new CheckOutHelper(dispatcher, delegator, cart);
try {
cho.calcAndAddTax();
} catch (GeneralException e) {
Debug.logError(e, module);
return ServiceUtil.returnError(e.getMessage());
}
// Create the PayPal payment method
inMap.clear();
inMap.put("userLogin", cart.getUserLogin());
inMap.put("partyId", partyId);
inMap.put("contactMechId", postalContactId);
inMap.put("fromDate", UtilDateTime.nowTimestamp());
inMap.put("payerId", decoder.get("PAYERID"));
inMap.put("expressCheckoutToken", token);
inMap.put("payerStatus", decoder.get("PAYERSTATUS"));
try {
outMap = dispatcher.runSync("createPayPalPaymentMethod", inMap);
} catch (GenericServiceException e) {
Debug.logError(e, module);
return ServiceUtil.returnError(e.getMessage());
}
String paymentMethodId = (String) outMap.get("paymentMethodId");
cart.clearPayments();
BigDecimal maxAmount = cart.getGrandTotal().setScale(2, BigDecimal.ROUND_HALF_UP);
cart.addPaymentAmount(paymentMethodId, maxAmount, true);
return ServiceUtil.returnSuccess();
}
/**
* Basic JavaMail Service
*
* @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> sendMail(
DispatchContext ctx, Map<String, ? extends Object> context) {
String communicationEventId = (String) context.get("communicationEventId");
String orderId = (String) context.get("orderId");
Locale locale = (Locale) context.get("locale");
if (communicationEventId != null) {
Debug.logInfo("SendMail Running, for communicationEventId : " + communicationEventId, module);
}
Map<String, Object> results = ServiceUtil.returnSuccess();
String subject = (String) context.get("subject");
subject = FlexibleStringExpander.expandString(subject, context);
String partyId = (String) context.get("partyId");
String body = (String) context.get("body");
List<Map<String, Object>> bodyParts = UtilGenerics.checkList(context.get("bodyParts"));
GenericValue userLogin = (GenericValue) context.get("userLogin");
results.put("communicationEventId", communicationEventId);
results.put("partyId", partyId);
results.put("subject", subject);
if (UtilValidate.isNotEmpty(orderId)) {
results.put("orderId", orderId);
}
if (UtilValidate.isNotEmpty(body)) {
body = FlexibleStringExpander.expandString(body, context);
results.put("body", body);
}
if (UtilValidate.isNotEmpty(bodyParts)) {
results.put("bodyParts", bodyParts);
}
results.put("userLogin", userLogin);
String sendTo = (String) context.get("sendTo");
String sendCc = (String) context.get("sendCc");
String sendBcc = (String) context.get("sendBcc");
// check to see if we should redirect all mail for testing
String redirectAddress =
UtilProperties.getPropertyValue("general.properties", "mail.notifications.redirectTo");
if (UtilValidate.isNotEmpty(redirectAddress)) {
String originalRecipients = " [To: " + sendTo + ", Cc: " + sendCc + ", Bcc: " + sendBcc + "]";
subject += originalRecipients;
sendTo = redirectAddress;
sendCc = null;
sendBcc = null;
}
String sendFrom = (String) context.get("sendFrom");
String sendType = (String) context.get("sendType");
String port = (String) context.get("port");
String socketFactoryClass = (String) context.get("socketFactoryClass");
String socketFactoryPort = (String) context.get("socketFactoryPort");
String socketFactoryFallback = (String) context.get("socketFactoryFallback");
String sendVia = (String) context.get("sendVia");
String authUser = (String) context.get("authUser");
String authPass = (String) context.get("authPass");
String messageId = (String) context.get("messageId");
String contentType = (String) context.get("contentType");
Boolean sendPartial = (Boolean) context.get("sendPartial");
Boolean isStartTLSEnabled = (Boolean) context.get("startTLSEnabled");
boolean useSmtpAuth = false;
// define some default
if (sendType == null || sendType.equals("mail.smtp.host")) {
sendType = "mail.smtp.host";
if (UtilValidate.isEmpty(sendVia)) {
sendVia =
UtilProperties.getPropertyValue(
"general.properties", "mail.smtp.relay.host", "localhost");
}
if (UtilValidate.isEmpty(authUser)) {
authUser = UtilProperties.getPropertyValue("general.properties", "mail.smtp.auth.user");
}
if (UtilValidate.isEmpty(authPass)) {
authPass = UtilProperties.getPropertyValue("general.properties", "mail.smtp.auth.password");
}
if (UtilValidate.isNotEmpty(authUser)) {
useSmtpAuth = true;
}
if (UtilValidate.isEmpty(port)) {
port = UtilProperties.getPropertyValue("general.properties", "mail.smtp.port");
}
if (UtilValidate.isEmpty(socketFactoryPort)) {
socketFactoryPort =
UtilProperties.getPropertyValue("general.properties", "mail.smtp.socketFactory.port");
}
if (UtilValidate.isEmpty(socketFactoryClass)) {
socketFactoryClass =
UtilProperties.getPropertyValue("general.properties", "mail.smtp.socketFactory.class");
}
if (UtilValidate.isEmpty(socketFactoryFallback)) {
socketFactoryFallback =
UtilProperties.getPropertyValue(
"general.properties", "mail.smtp.socketFactory.fallback", "false");
}
if (sendPartial == null) {
sendPartial =
UtilProperties.propertyValueEqualsIgnoreCase(
"general.properties", "mail.smtp.sendpartial", "true")
? true
: false;
}
if (isStartTLSEnabled == null) {
isStartTLSEnabled =
UtilProperties.propertyValueEqualsIgnoreCase(
"general.properties", "mail.smtp.starttls.enable", "true");
}
} else if (sendVia == null) {
return ServiceUtil.returnError(
UtilProperties.getMessage(resource, "CommonEmailSendMissingParameterSendVia", locale));
}
if (contentType == null) {
contentType = "text/html";
}
if (UtilValidate.isNotEmpty(bodyParts)) {
contentType = "multipart/mixed";
}
results.put("contentType", contentType);
Session session;
MimeMessage mail;
try {
Properties props = System.getProperties();
props.put(sendType, sendVia);
if (UtilValidate.isNotEmpty(port)) {
props.put("mail.smtp.port", port);
}
if (UtilValidate.isNotEmpty(socketFactoryPort)) {
props.put("mail.smtp.socketFactory.port", socketFactoryPort);
}
if (UtilValidate.isNotEmpty(socketFactoryClass)) {
props.put("mail.smtp.socketFactory.class", socketFactoryClass);
Security.addProvider(new com.sun.net.ssl.internal.ssl.Provider());
}
if (UtilValidate.isNotEmpty(socketFactoryFallback)) {
props.put("mail.smtp.socketFactory.fallback", socketFactoryFallback);
}
if (useSmtpAuth) {
props.put("mail.smtp.auth", "true");
}
if (sendPartial != null) {
props.put("mail.smtp.sendpartial", sendPartial ? "true" : "false");
}
if (isStartTLSEnabled) {
props.put("mail.smtp.starttls.enable", "true");
}
session = Session.getInstance(props);
boolean debug =
UtilProperties.propertyValueEqualsIgnoreCase("general.properties", "mail.debug.on", "Y");
session.setDebug(debug);
mail = new MimeMessage(session);
if (messageId != null) {
mail.setHeader("In-Reply-To", messageId);
mail.setHeader("References", messageId);
}
mail.setFrom(new InternetAddress(sendFrom));
mail.setSubject(subject, "UTF-8");
mail.setHeader("X-Mailer", "Apache OFBiz, The Apache Open For Business Project");
mail.setSentDate(new Date());
mail.addRecipients(Message.RecipientType.TO, sendTo);
if (UtilValidate.isNotEmpty(sendCc)) {
mail.addRecipients(Message.RecipientType.CC, sendCc);
}
if (UtilValidate.isNotEmpty(sendBcc)) {
mail.addRecipients(Message.RecipientType.BCC, sendBcc);
}
if (UtilValidate.isNotEmpty(bodyParts)) {
// check for multipart message (with attachments)
// BodyParts contain a list of Maps items containing content(String) and type(String) of the
// attachement
MimeMultipart mp = new MimeMultipart();
Debug.logInfo(bodyParts.size() + " multiparts found", module);
for (Map<String, Object> bodyPart : bodyParts) {
Object bodyPartContent = bodyPart.get("content");
MimeBodyPart mbp = new MimeBodyPart();
if (bodyPartContent instanceof String) {
Debug.logInfo(
"part of type: "
+ bodyPart.get("type")
+ " and size: "
+ bodyPart.get("content").toString().length(),
module);
mbp.setText(
(String) bodyPartContent, "UTF-8", ((String) bodyPart.get("type")).substring(5));
} else if (bodyPartContent instanceof byte[]) {
ByteArrayDataSource bads =
new ByteArrayDataSource((byte[]) bodyPartContent, (String) bodyPart.get("type"));
Debug.logInfo(
"part of type: "
+ bodyPart.get("type")
+ " and size: "
+ ((byte[]) bodyPartContent).length,
module);
mbp.setDataHandler(new DataHandler(bads));
} else if (bodyPartContent instanceof DataHandler) {
mbp.setDataHandler((DataHandler) bodyPartContent);
} else {
mbp.setDataHandler(new DataHandler(bodyPartContent, (String) bodyPart.get("type")));
}
String fileName = (String) bodyPart.get("filename");
if (fileName != null) {
mbp.setFileName(fileName);
}
mp.addBodyPart(mbp);
}
mail.setContent(mp);
mail.saveChanges();
} else {
// create the singelpart message
if (contentType.startsWith("text")) {
mail.setText(body, "UTF-8", contentType.substring(5));
} else {
mail.setContent(body, contentType);
}
mail.saveChanges();
}
} catch (MessagingException e) {
Debug.logError(
e,
"MessagingException when creating message to ["
+ sendTo
+ "] from ["
+ sendFrom
+ "] cc ["
+ sendCc
+ "] bcc ["
+ sendBcc
+ "] subject ["
+ subject
+ "]",
module);
Debug.logError(
"Email message that could not be created to [" + sendTo + "] had context: " + context,
module);
return ServiceUtil.returnError(
UtilProperties.getMessage(
resource,
"CommonEmailSendMessagingException",
UtilMisc.toMap(
"sendTo",
sendTo,
"sendFrom",
sendFrom,
"sendCc",
sendCc,
"sendBcc",
sendBcc,
"subject",
subject),
locale));
} catch (IOException e) {
Debug.logError(
e,
"IOExcepton when creating message to ["
+ sendTo
+ "] from ["
+ sendFrom
+ "] cc ["
+ sendCc
+ "] bcc ["
+ sendBcc
+ "] subject ["
+ subject
+ "]",
module);
Debug.logError(
"Email message that could not be created to [" + sendTo + "] had context: " + context,
module);
return ServiceUtil.returnError(
UtilProperties.getMessage(
resource,
"CommonEmailSendIOException",
UtilMisc.toMap(
"sendTo",
sendTo,
"sendFrom",
sendFrom,
"sendCc",
sendCc,
"sendBcc",
sendBcc,
"subject",
subject),
locale));
}
// check to see if sending mail is enabled
String mailEnabled =
UtilProperties.getPropertyValue("general.properties", "mail.notifications.enabled", "N");
if (!"Y".equalsIgnoreCase(mailEnabled)) {
// no error; just return as if we already processed
Debug.logImportant(
"Mail notifications disabled in general.properties; mail with subject ["
+ subject
+ "] not sent to addressee ["
+ sendTo
+ "]",
module);
Debug.logVerbose(
"What would have been sent, the addressee: "
+ sendTo
+ " subject: "
+ subject
+ " context: "
+ context,
module);
results.put("messageWrapper", new MimeMessageWrapper(session, mail));
return results;
}
Transport trans = null;
try {
trans = session.getTransport("smtp");
if (!useSmtpAuth) {
trans.connect();
} else {
trans.connect(sendVia, authUser, authPass);
}
trans.sendMessage(mail, mail.getAllRecipients());
results.put("messageWrapper", new MimeMessageWrapper(session, mail));
results.put("messageId", mail.getMessageID());
trans.close();
} catch (SendFailedException e) {
// message code prefix may be used by calling services to determine the cause of the failure
Debug.logError(
e,
"[ADDRERR] Address error when sending message to ["
+ sendTo
+ "] from ["
+ sendFrom
+ "] cc ["
+ sendCc
+ "] bcc ["
+ sendBcc
+ "] subject ["
+ subject
+ "]",
module);
List<SMTPAddressFailedException> failedAddresses = FastList.newInstance();
Exception nestedException = null;
while ((nestedException = e.getNextException()) != null
&& nestedException instanceof MessagingException) {
if (nestedException instanceof SMTPAddressFailedException) {
SMTPAddressFailedException safe = (SMTPAddressFailedException) nestedException;
Debug.logError(
"Failed to send message to ["
+ safe.getAddress()
+ "], return code ["
+ safe.getReturnCode()
+ "], return message ["
+ safe.getMessage()
+ "]",
module);
failedAddresses.add(safe);
break;
}
}
Boolean sendFailureNotification = (Boolean) context.get("sendFailureNotification");
if (sendFailureNotification == null || sendFailureNotification) {
sendFailureNotification(ctx, context, mail, failedAddresses);
results.put("messageWrapper", new MimeMessageWrapper(session, mail));
try {
results.put("messageId", mail.getMessageID());
trans.close();
} catch (MessagingException e1) {
Debug.logError(e1, module);
}
} else {
return ServiceUtil.returnError(
UtilProperties.getMessage(
resource,
"CommonEmailSendAddressError",
UtilMisc.toMap(
"sendTo",
sendTo,
"sendFrom",
sendFrom,
"sendCc",
sendCc,
"sendBcc",
sendBcc,
"subject",
subject),
locale));
}
} catch (MessagingException e) {
// message code prefix may be used by calling services to determine the cause of the failure
Debug.logError(
e,
"[CON] Connection error when sending message to ["
+ sendTo
+ "] from ["
+ sendFrom
+ "] cc ["
+ sendCc
+ "] bcc ["
+ sendBcc
+ "] subject ["
+ subject
+ "]",
module);
Debug.logError(
"Email message that could not be sent to [" + sendTo + "] had context: " + context,
module);
return ServiceUtil.returnError(
UtilProperties.getMessage(
resource,
"CommonEmailSendConnectionError",
UtilMisc.toMap(
"sendTo",
sendTo,
"sendFrom",
sendFrom,
"sendCc",
sendCc,
"sendBcc",
sendBcc,
"subject",
subject),
locale));
}
return results;
}
/**
* JavaMail Service that gets body content from a Screen Widget defined in the product store
* record and if available as attachment also.
*
* @param dctx The DispatchContext that this service is operating in
* @param rServiceContext Map containing the input parameters
* @return Map with the result of the service, the output parameters
*/
public static Map<String, Object> sendMailFromScreen(
DispatchContext dctx, Map<String, ? extends Object> rServiceContext) {
Map<String, Object> serviceContext = UtilMisc.makeMapWritable(rServiceContext);
LocalDispatcher dispatcher = dctx.getDispatcher();
String webSiteId = (String) serviceContext.remove("webSiteId");
String bodyText = (String) serviceContext.remove("bodyText");
String bodyScreenUri = (String) serviceContext.remove("bodyScreenUri");
String xslfoAttachScreenLocationParam =
(String) serviceContext.remove("xslfoAttachScreenLocation");
String attachmentNameParam = (String) serviceContext.remove("attachmentName");
List<String> xslfoAttachScreenLocationListParam =
UtilGenerics.checkList(serviceContext.remove("xslfoAttachScreenLocationList"));
List<String> attachmentNameListParam =
UtilGenerics.checkList(serviceContext.remove("attachmentNameList"));
List<String> xslfoAttachScreenLocationList = FastList.newInstance();
List<String> attachmentNameList = FastList.newInstance();
if (UtilValidate.isNotEmpty(xslfoAttachScreenLocationParam))
xslfoAttachScreenLocationList.add(xslfoAttachScreenLocationParam);
if (UtilValidate.isNotEmpty(attachmentNameParam)) attachmentNameList.add(attachmentNameParam);
if (UtilValidate.isNotEmpty(xslfoAttachScreenLocationListParam))
xslfoAttachScreenLocationList.addAll(xslfoAttachScreenLocationListParam);
if (UtilValidate.isNotEmpty(attachmentNameListParam))
attachmentNameList.addAll(attachmentNameListParam);
Locale locale = (Locale) serviceContext.get("locale");
Map<String, Object> bodyParameters =
UtilGenerics.checkMap(serviceContext.remove("bodyParameters"));
if (bodyParameters == null) {
bodyParameters = MapStack.create();
}
if (!bodyParameters.containsKey("locale")) {
bodyParameters.put("locale", locale);
} else {
locale = (Locale) bodyParameters.get("locale");
}
String partyId = (String) serviceContext.get("partyId");
if (partyId == null) {
partyId = (String) bodyParameters.get("partyId");
}
String orderId = (String) bodyParameters.get("orderId");
String custRequestId = (String) bodyParameters.get("custRequestId");
bodyParameters.put("communicationEventId", serviceContext.get("communicationEventId"));
NotificationServices.setBaseUrl(dctx.getDelegator(), webSiteId, bodyParameters);
String contentType = (String) serviceContext.remove("contentType");
StringWriter bodyWriter = new StringWriter();
MapStack<String> screenContext = MapStack.create();
screenContext.put("locale", locale);
ScreenRenderer screens = new ScreenRenderer(bodyWriter, screenContext, htmlScreenRenderer);
screens.populateContextForService(dctx, bodyParameters);
screenContext.putAll(bodyParameters);
if (bodyScreenUri != null) {
try {
screens.render(bodyScreenUri);
} catch (GeneralException e) {
Debug.logError(e, "Error rendering screen for email: " + e.toString(), module);
return ServiceUtil.returnError(
UtilProperties.getMessage(
resource,
"CommonEmailSendRenderingScreenEmailError",
UtilMisc.toMap("errorString", e.toString()),
locale));
} catch (IOException e) {
Debug.logError(e, "Error rendering screen for email: " + e.toString(), module);
return ServiceUtil.returnError(
UtilProperties.getMessage(
resource,
"CommonEmailSendRenderingScreenEmailError",
UtilMisc.toMap("errorString", e.toString()),
locale));
} catch (SAXException e) {
Debug.logError(e, "Error rendering screen for email: " + e.toString(), module);
return ServiceUtil.returnError(
UtilProperties.getMessage(
resource,
"CommonEmailSendRenderingScreenEmailError",
UtilMisc.toMap("errorString", e.toString()),
locale));
} catch (ParserConfigurationException e) {
Debug.logError(e, "Error rendering screen for email: " + e.toString(), module);
return ServiceUtil.returnError(
UtilProperties.getMessage(
resource,
"CommonEmailSendRenderingScreenEmailError",
UtilMisc.toMap("errorString", e.toString()),
locale));
}
}
boolean isMultiPart = false;
// check if attachment screen location passed in
if (UtilValidate.isNotEmpty(xslfoAttachScreenLocationList)) {
List<Map<String, ? extends Object>> bodyParts = FastList.newInstance();
if (bodyText != null) {
bodyText = FlexibleStringExpander.expandString(bodyText, screenContext, locale);
bodyParts.add(UtilMisc.<String, Object>toMap("content", bodyText, "type", "text/html"));
} else {
bodyParts.add(
UtilMisc.<String, Object>toMap("content", bodyWriter.toString(), "type", "text/html"));
}
for (int i = 0; i < xslfoAttachScreenLocationList.size(); i++) {
String xslfoAttachScreenLocation = xslfoAttachScreenLocationList.get(i);
String attachmentName = "Details.pdf";
if (UtilValidate.isNotEmpty(attachmentNameList) && attachmentNameList.size() >= i) {
attachmentName = attachmentNameList.get(i);
}
isMultiPart = true;
// start processing fo pdf attachment
try {
Writer writer = new StringWriter();
MapStack<String> screenContextAtt = MapStack.create();
// substitute the freemarker variables...
ScreenRenderer screensAtt = new ScreenRenderer(writer, screenContext, foScreenRenderer);
screensAtt.populateContextForService(dctx, bodyParameters);
screenContextAtt.putAll(bodyParameters);
screensAtt.render(xslfoAttachScreenLocation);
/*
try { // save generated fo file for debugging
String buf = writer.toString();
java.io.FileWriter fw = new java.io.FileWriter(new java.io.File("/tmp/file1.xml"));
fw.write(buf.toString());
fw.close();
} catch (IOException e) {
Debug.logError(e, "Couldn't save xsl-fo xml debug file: " + e.toString(), module);
}
*/
// create the input stream for the generation
StreamSource src = new StreamSource(new StringReader(writer.toString()));
// create the output stream for the generation
ByteArrayOutputStream baos = new ByteArrayOutputStream();
Fop fop = ApacheFopWorker.createFopInstance(baos, MimeConstants.MIME_PDF);
ApacheFopWorker.transform(src, null, fop);
// and generate the PDF
baos.flush();
baos.close();
// store in the list of maps for sendmail....
bodyParts.add(
UtilMisc.<String, Object>toMap(
"content",
baos.toByteArray(),
"type",
"application/pdf",
"filename",
attachmentName));
} catch (GeneralException ge) {
Debug.logError(ge, "Error rendering PDF attachment for email: " + ge.toString(), module);
return ServiceUtil.returnError(
UtilProperties.getMessage(
resource,
"CommonEmailSendRenderingScreenPdfError",
UtilMisc.toMap("errorString", ge.toString()),
locale));
} catch (IOException ie) {
Debug.logError(ie, "Error rendering PDF attachment for email: " + ie.toString(), module);
return ServiceUtil.returnError(
UtilProperties.getMessage(
resource,
"CommonEmailSendRenderingScreenPdfError",
UtilMisc.toMap("errorString", ie.toString()),
locale));
} catch (FOPException fe) {
Debug.logError(fe, "Error rendering PDF attachment for email: " + fe.toString(), module);
return ServiceUtil.returnError(
UtilProperties.getMessage(
resource,
"CommonEmailSendRenderingScreenPdfError",
UtilMisc.toMap("errorString", fe.toString()),
locale));
} catch (SAXException se) {
Debug.logError(se, "Error rendering PDF attachment for email: " + se.toString(), module);
return ServiceUtil.returnError(
UtilProperties.getMessage(
resource,
"CommonEmailSendRenderingScreenPdfError",
UtilMisc.toMap("errorString", se.toString()),
locale));
} catch (ParserConfigurationException pe) {
Debug.logError(pe, "Error rendering PDF attachment for email: " + pe.toString(), module);
return ServiceUtil.returnError(
UtilProperties.getMessage(
resource,
"CommonEmailSendRenderingScreenPdfError",
UtilMisc.toMap("errorString", pe.toString()),
locale));
}
serviceContext.put("bodyParts", bodyParts);
}
} else {
isMultiPart = false;
// store body and type for single part message in the context.
if (bodyText != null) {
bodyText = FlexibleStringExpander.expandString(bodyText, screenContext, locale);
serviceContext.put("body", bodyText);
} else {
serviceContext.put("body", bodyWriter.toString());
}
// Only override the default contentType in case of plaintext, since other contentTypes may be
// multipart
// and would require specific handling.
if (contentType != null && contentType.equalsIgnoreCase("text/plain")) {
serviceContext.put("contentType", "text/plain");
} else {
serviceContext.put("contentType", "text/html");
}
}
// also expand the subject at this point, just in case it has the FlexibleStringExpander syntax
// in it...
String subject = (String) serviceContext.remove("subject");
subject = FlexibleStringExpander.expandString(subject, screenContext, locale);
Debug.logInfo("Expanded email subject to: " + subject, module);
serviceContext.put("subject", subject);
serviceContext.put("partyId", partyId);
if (UtilValidate.isNotEmpty(orderId)) {
serviceContext.put("orderId", orderId);
}
if (UtilValidate.isNotEmpty(custRequestId)) {
serviceContext.put("custRequestId", custRequestId);
}
if (Debug.verboseOn())
Debug.logVerbose("sendMailFromScreen sendMail context: " + serviceContext, module);
Map<String, Object> result = ServiceUtil.returnSuccess();
Map<String, Object> sendMailResult;
try {
if (isMultiPart) {
sendMailResult = dispatcher.runSync("sendMailMultiPart", serviceContext);
} else {
sendMailResult = dispatcher.runSync("sendMail", serviceContext);
}
} catch (Exception e) {
Debug.logError(e, "Error send email:" + e.toString(), module);
return ServiceUtil.returnError(
UtilProperties.getMessage(
resource,
"CommonEmailSendError",
UtilMisc.toMap("errorString", e.toString()),
locale));
}
if (ServiceUtil.isError(sendMailResult)) {
return ServiceUtil.returnError(ServiceUtil.getErrorMessage(sendMailResult));
}
result.put("messageWrapper", sendMailResult.get("messageWrapper"));
result.put("body", bodyWriter.toString());
result.put("subject", subject);
result.put("communicationEventId", sendMailResult.get("communicationEventId"));
if (UtilValidate.isNotEmpty(orderId)) {
result.put("orderId", orderId);
}
if (UtilValidate.isNotEmpty(custRequestId)) {
result.put("custRequestId", custRequestId);
}
return result;
}
public static String addListToCart(
Delegator delegator,
LocalDispatcher dispatcher,
ShoppingCart cart,
String prodCatalogId,
String shoppingListId,
boolean includeChild,
boolean setAsListItem,
boolean append)
throws java.lang.IllegalArgumentException {
String errMsg = null;
// no list; no add
if (shoppingListId == null) {
errMsg =
UtilProperties.getMessage(
resource_error, "shoppinglistevents.choose_shopping_list", cart.getLocale());
throw new IllegalArgumentException(errMsg);
}
// get the shopping list
GenericValue shoppingList = null;
List<GenericValue> shoppingListItems = null;
try {
shoppingList =
EntityQuery.use(delegator)
.from("ShoppingList")
.where("shoppingListId", shoppingListId)
.queryOne();
if (shoppingList == null) {
errMsg =
UtilProperties.getMessage(
resource_error,
"shoppinglistevents.error_getting_shopping_list_and_items",
cart.getLocale());
throw new IllegalArgumentException(errMsg);
}
shoppingListItems = shoppingList.getRelated("ShoppingListItem", null, null, false);
if (shoppingListItems == null) {
shoppingListItems = FastList.newInstance();
}
// include all items of child lists if flagged to do so
if (includeChild) {
List<GenericValue> childShoppingLists =
shoppingList.getRelated("ChildShoppingList", null, null, false);
for (GenericValue v : childShoppingLists) {
List<GenericValue> items = v.getRelated("ShoppingListItem", null, null, false);
shoppingListItems.addAll(items);
}
}
} catch (GenericEntityException e) {
Debug.logError(e, "Problems getting ShoppingList and ShoppingListItem records", module);
errMsg =
UtilProperties.getMessage(
resource_error,
"shoppinglistevents.error_getting_shopping_list_and_items",
cart.getLocale());
throw new IllegalArgumentException(errMsg);
}
// no items; not an error; just mention that nothing was added
if (UtilValidate.isEmpty(shoppingListItems)) {
errMsg =
UtilProperties.getMessage(
resource_error, "shoppinglistevents.no_items_added", cart.getLocale());
return errMsg;
}
// check if we are to clear the cart first
if (!append) {
cart.clear();
// Prevent the system from creating a new shopping list every time the cart is restored for
// anonymous user.
cart.setAutoSaveListId(shoppingListId);
}
// get the survey info for all the items
Map<String, List<String>> shoppingListSurveyInfo = getItemSurveyInfos(shoppingListItems);
// add the items
StringBuilder eventMessage = new StringBuilder();
for (GenericValue shoppingListItem : shoppingListItems) {
String productId = shoppingListItem.getString("productId");
BigDecimal quantity = shoppingListItem.getBigDecimal("quantity");
Timestamp reservStart = shoppingListItem.getTimestamp("reservStart");
BigDecimal reservLength = shoppingListItem.getBigDecimal("reservLength");
BigDecimal reservPersons = shoppingListItem.getBigDecimal("reservPersons");
// String accommodationMapId = shoppingListItem.getString("accommodationMapId");
// String accommodationSpotId = shoppingListItem.getString("accommodationSpotId");
String configId = shoppingListItem.getString("configId");
try {
String listId = shoppingListItem.getString("shoppingListId");
String itemId = shoppingListItem.getString("shoppingListItemSeqId");
Map<String, Object> attributes = FastMap.newInstance();
// list items are noted in the shopping cart
if (setAsListItem) {
attributes.put("shoppingListId", listId);
attributes.put("shoppingListItemSeqId", itemId);
}
// check if we have existing survey responses to append
if (shoppingListSurveyInfo.containsKey(listId + "." + itemId)
&& UtilValidate.isNotEmpty(shoppingListSurveyInfo.get(listId + "." + itemId))) {
attributes.put("surveyResponses", shoppingListSurveyInfo.get(listId + "." + itemId));
}
ProductConfigWrapper configWrapper = null;
if (UtilValidate.isNotEmpty(configId)) {
configWrapper =
ProductConfigWorker.loadProductConfigWrapper(
delegator,
dispatcher,
configId,
productId,
cart.getProductStoreId(),
prodCatalogId,
cart.getWebSiteId(),
cart.getCurrency(),
cart.getLocale(),
cart.getAutoUserLogin());
}
// TODO: add code to check for survey response requirement
// i cannot get the addOrDecrease function to accept a null reservStart field: i get a null
// pointer exception a null constant works....
if (reservStart == null) {
cart.addOrIncreaseItem(
productId,
null,
quantity,
null,
null,
null,
null,
null,
null,
attributes,
prodCatalogId,
configWrapper,
null,
null,
null,
dispatcher);
} else {
cart.addOrIncreaseItem(
productId,
null,
quantity,
reservStart,
reservLength,
reservPersons,
null,
null,
null,
null,
null,
attributes,
prodCatalogId,
configWrapper,
null,
null,
null,
dispatcher);
}
Map<String, Object> messageMap = UtilMisc.<String, Object>toMap("productId", productId);
errMsg =
UtilProperties.getMessage(
resource_error,
"shoppinglistevents.added_product_to_cart",
messageMap,
cart.getLocale());
eventMessage.append(errMsg).append("\n");
} catch (CartItemModifyException e) {
Debug.logWarning(
e,
UtilProperties.getMessage(
resource_error, "OrderProblemsAddingItemFromListToCart", cart.getLocale()));
Map<String, Object> messageMap = UtilMisc.<String, Object>toMap("productId", productId);
errMsg =
UtilProperties.getMessage(
resource_error,
"shoppinglistevents.problem_adding_product_to_cart",
messageMap,
cart.getLocale());
eventMessage.append(errMsg).append("\n");
} catch (ItemNotFoundException e) {
Debug.logWarning(
e, UtilProperties.getMessage(resource_error, "OrderProductNotFound", cart.getLocale()));
Map<String, Object> messageMap = UtilMisc.<String, Object>toMap("productId", productId);
errMsg =
UtilProperties.getMessage(
resource_error,
"shoppinglistevents.problem_adding_product_to_cart",
messageMap,
cart.getLocale());
eventMessage.append(errMsg).append("\n");
}
}
if (eventMessage.length() > 0) {
return eventMessage.toString();
}
// all done
return ""; // no message to return; will simply reply as success
}
public static String addBulkFromCart(
Delegator delegator,
LocalDispatcher dispatcher,
ShoppingCart cart,
GenericValue userLogin,
String shoppingListId,
String shoppingListTypeId,
String[] items,
boolean allowPromo,
boolean append)
throws IllegalArgumentException {
String errMsg = null;
if (items == null || items.length == 0) {
errMsg =
UtilProperties.getMessage(
resource_error, "shoppinglistevents.select_items_to_add_to_list", cart.getLocale());
throw new IllegalArgumentException(errMsg);
}
if (UtilValidate.isEmpty(shoppingListId)) {
// create a new shopping list
Map<String, Object> newListResult = null;
try {
newListResult =
dispatcher.runSync(
"createShoppingList",
UtilMisc.<String, Object>toMap(
"userLogin",
userLogin,
"productStoreId",
cart.getProductStoreId(),
"partyId",
cart.getOrderPartyId(),
"shoppingListTypeId",
shoppingListTypeId,
"currencyUom",
cart.getCurrency()));
} catch (GenericServiceException e) {
Debug.logError(e, "Problems creating new ShoppingList", module);
errMsg =
UtilProperties.getMessage(
resource_error,
"shoppinglistevents.cannot_create_new_shopping_list",
cart.getLocale());
throw new IllegalArgumentException(errMsg);
}
// check for errors
if (ServiceUtil.isError(newListResult)) {
throw new IllegalArgumentException(ServiceUtil.getErrorMessage(newListResult));
}
// get the new list id
if (newListResult != null) {
shoppingListId = (String) newListResult.get("shoppingListId");
}
// if no list was created throw an error
if (shoppingListId == null || shoppingListId.equals("")) {
errMsg =
UtilProperties.getMessage(
resource_error,
"shoppinglistevents.shoppingListId_is_required_parameter",
cart.getLocale());
throw new IllegalArgumentException(errMsg);
}
} else if (!append) {
try {
clearListInfo(delegator, shoppingListId);
} catch (GenericEntityException e) {
Debug.logError(e, module);
throw new IllegalArgumentException(
"Could not clear current shopping list: " + e.toString());
}
}
for (int i = 0; i < items.length; i++) {
Integer cartIdInt = null;
try {
cartIdInt = Integer.valueOf(items[i]);
} catch (Exception e) {
Debug.logWarning(
e,
UtilProperties.getMessage(
resource_error, "OrderIllegalCharacterInSelectedItemField", cart.getLocale()),
module);
}
if (cartIdInt != null) {
ShoppingCartItem item = cart.findCartItem(cartIdInt.intValue());
if (allowPromo || !item.getIsPromo()) {
Debug.logInfo(
"Adding cart item to shopping list ["
+ shoppingListId
+ "], allowPromo="
+ allowPromo
+ ", item.getIsPromo()="
+ item.getIsPromo()
+ ", item.getProductId()="
+ item.getProductId()
+ ", item.getQuantity()="
+ item.getQuantity(),
module);
Map<String, Object> serviceResult = null;
try {
Map<String, Object> ctx =
UtilMisc.<String, Object>toMap(
"userLogin",
userLogin,
"shoppingListId",
shoppingListId,
"productId",
item.getProductId(),
"quantity",
item.getQuantity());
ctx.put("reservStart", item.getReservStart());
ctx.put("reservLength", item.getReservLength());
ctx.put("reservPersons", item.getReservPersons());
// ctx.put("accommodationMapId", item.getAccommodationMapId());
// ctx.put("accommodationSpotId", item.getAccommodationSpotId());
if (item.getConfigWrapper() != null) {
ctx.put("configId", item.getConfigWrapper().getConfigId());
}
serviceResult = dispatcher.runSync("createShoppingListItem", ctx);
} catch (GenericServiceException e) {
Debug.logError(e, "Problems creating ShoppingList item entity", module);
errMsg =
UtilProperties.getMessage(
resource_error,
"shoppinglistevents.error_adding_item_to_shopping_list",
cart.getLocale());
throw new IllegalArgumentException(errMsg);
}
// check for errors
if (ServiceUtil.isError(serviceResult)) {
throw new IllegalArgumentException(ServiceUtil.getErrorMessage(serviceResult));
}
}
}
}
// return the shoppinglist id
return shoppingListId;
}
public static Map<String, Object> putFile(DispatchContext dctx, Map<String, ?> context) {
Locale locale = (Locale) context.get("locale");
Debug.logInfo("[putFile] starting...", module);
InputStream localFile = null;
try {
localFile = new FileInputStream((String) context.get("localFilename"));
} catch (IOException ioe) {
Debug.logError(ioe, "[putFile] Problem opening local file", module);
return ServiceUtil.returnError(
UtilProperties.getMessage(resource, "CommonFtpFileCannotBeOpen", locale));
}
List<String> errorList = new LinkedList<String>();
FTPClient ftp = new FTPClient();
try {
Integer defaultTimeout = (Integer) context.get("defaultTimeout");
if (UtilValidate.isNotEmpty(defaultTimeout)) {
Debug.logInfo(
"[putFile] set default timeout to: " + defaultTimeout.intValue() + " milliseconds",
module);
ftp.setDefaultTimeout(defaultTimeout.intValue());
}
Debug.logInfo("[putFile] connecting to: " + (String) context.get("hostname"), module);
ftp.connect((String) context.get("hostname"));
if (!FTPReply.isPositiveCompletion(ftp.getReplyCode())) {
Debug.logInfo("[putFile] Server refused connection", module);
errorList.add(UtilProperties.getMessage(resource, "CommonFtpConnectionRefused", locale));
} else {
String username = (String) context.get("username");
String password = (String) context.get("password");
Debug.logInfo(
"[putFile] logging in: username="******", password="******"[putFile] login failed", module);
errorList.add(
UtilProperties.getMessage(
resource,
"CommonFtpLoginFailure",
UtilMisc.toMap("username", username, "password", password),
locale));
} else {
Boolean binaryTransfer = (Boolean) context.get("binaryTransfer");
boolean binary = (binaryTransfer == null) ? false : binaryTransfer.booleanValue();
if (binary) {
ftp.setFileType(FTP.BINARY_FILE_TYPE);
}
Boolean passiveMode = (Boolean) context.get("passiveMode");
boolean passive = (passiveMode == null) ? true : passiveMode.booleanValue();
if (passive) {
ftp.enterLocalPassiveMode();
}
Debug.logInfo(
"[putFile] storing local file remotely as: " + context.get("remoteFilename"), module);
if (!ftp.storeFile((String) context.get("remoteFilename"), localFile)) {
Debug.logInfo("[putFile] store was unsuccessful", module);
errorList.add(
UtilProperties.getMessage(
resource,
"CommonFtpFileNotSentSuccesfully",
UtilMisc.toMap("replyString", ftp.getReplyString()),
locale));
} else {
Debug.logInfo("[putFile] store was successful", module);
List<String> siteCommands = checkList(context.get("siteCommands"), String.class);
if (siteCommands != null) {
for (String command : siteCommands) {
Debug.logInfo("[putFile] sending SITE command: " + command, module);
if (!ftp.sendSiteCommand(command)) {
errorList.add(
UtilProperties.getMessage(
resource,
"CommonFtpSiteCommandFailed",
UtilMisc.toMap("command", command, "replyString", ftp.getReplyString()),
locale));
}
}
}
}
}
ftp.logout();
}
} catch (IOException ioe) {
Debug.logWarning(ioe, "[putFile] caught exception: " + ioe.getMessage(), module);
errorList.add(
UtilProperties.getMessage(
resource,
"CommonFtpProblemWithTransfer",
UtilMisc.toMap("errorString", ioe.getMessage()),
locale));
} finally {
try {
if (ftp.isConnected()) {
ftp.disconnect();
}
} catch (Exception e) {
Debug.logWarning(e, "[putFile] Problem with FTP disconnect: ", module);
}
try {
localFile.close();
} catch (Exception e) {
Debug.logWarning(e, "[putFile] Problem closing local file: ", module);
}
}
if (errorList.size() > 0) {
Debug.logError(
"[putFile] The following error(s) (" + errorList.size() + ") occurred: " + errorList,
module);
return ServiceUtil.returnError(errorList);
}
Debug.logInfo("[putFile] finished successfully", module);
return ServiceUtil.returnSuccess();
}
public static Map<String, Object> setExpressCheckout(
DispatchContext dctx, Map<String, ? extends Object> context) {
ShoppingCart cart = (ShoppingCart) context.get("cart");
Locale locale = cart.getLocale();
if (cart == null || cart.items().size() <= 0) {
return ServiceUtil.returnError(
UtilProperties.getMessage(resource, "AccountingPayPalShoppingCartIsEmpty", locale));
}
GenericValue payPalConfig = getPaymentMethodGatewayPayPal(dctx, context, null);
if (payPalConfig == null) {
return ServiceUtil.returnError(
UtilProperties.getMessage(
resource, "AccountingPayPalPaymentGatewayConfigCannotFind", locale));
}
NVPEncoder encoder = new NVPEncoder();
// Set Express Checkout Request Parameters
encoder.add("METHOD", "SetExpressCheckout");
String token = (String) cart.getAttribute("payPalCheckoutToken");
if (UtilValidate.isNotEmpty(token)) {
encoder.add("TOKEN", token);
}
encoder.add("RETURNURL", payPalConfig.getString("returnUrl"));
encoder.add("CANCELURL", payPalConfig.getString("cancelReturnUrl"));
if (!cart.shippingApplies()) {
encoder.add("NOSHIPPING", "1");
} else {
encoder.add("CALLBACK", payPalConfig.getString("shippingCallbackUrl"));
encoder.add("CALLBACKTIMEOUT", "6");
// Default to no
String reqConfirmShipping =
"Y".equals(payPalConfig.getString("requireConfirmedShipping")) ? "1" : "0";
encoder.add("REQCONFIRMSHIPPING", reqConfirmShipping);
// Default shipment method
encoder.add("L_SHIPPINGOPTIONISDEFAULT0", "true");
encoder.add("L_SHIPPINGOPTIONNAME0", "Calculated Offline");
encoder.add("L_SHIPPINGOPTIONAMOUNT0", "0.00");
}
encoder.add("ALLOWNOTE", "1");
encoder.add("INSURANCEOPTIONOFFERED", "false");
if (UtilValidate.isNotEmpty(payPalConfig.getString("imageUrl"))) ;
encoder.add("PAYMENTACTION", "Order");
// Cart information
try {
addCartDetails(encoder, cart);
} catch (GenericEntityException e) {
Debug.logError(e, module);
return ServiceUtil.returnError(
UtilProperties.getMessage(
resource, "AccountingPayPalErrorDuringRetrievingCartDetails", locale));
}
NVPDecoder decoder;
try {
decoder = sendNVPRequest(payPalConfig, encoder);
} catch (PayPalException e) {
Debug.logError(e, module);
return ServiceUtil.returnError(e.getMessage());
}
Map<String, String> errorMessages = getErrorMessageMap(decoder);
if (UtilValidate.isNotEmpty(errorMessages)) {
if (errorMessages.containsKey("10411")) {
// Token has expired, get a new one
cart.setAttribute("payPalCheckoutToken", null);
return PayPalServices.setExpressCheckout(dctx, context);
}
return ServiceUtil.returnError(UtilMisc.toList(errorMessages.values()));
}
token = decoder.get("TOKEN");
cart.setAttribute("payPalCheckoutToken", token);
TokenWrapper tokenWrapper = new TokenWrapper(token);
cart.setAttribute("payPalCheckoutTokenObj", tokenWrapper);
PayPalServices.tokenCartMap.put(tokenWrapper, new WeakReference<ShoppingCart>(cart));
return ServiceUtil.returnSuccess();
}
// Note we're not doing a lot of error checking here as this method is really only used
// to confirm the order with PayPal, the subsequent authorizations will handle any errors
// that may occur.
public static Map<String, Object> doExpressCheckout(
DispatchContext dctx, Map<String, Object> context) {
LocalDispatcher dispatcher = dctx.getDispatcher();
Delegator delegator = dctx.getDelegator();
GenericValue userLogin = (GenericValue) context.get("userLogin");
GenericValue paymentPref = (GenericValue) context.get("orderPaymentPreference");
OrderReadHelper orh = new OrderReadHelper(delegator, paymentPref.getString("orderId"));
Locale locale = (Locale) context.get("locale");
GenericValue payPalPaymentSetting = getPaymentMethodGatewayPayPal(dctx, context, null);
GenericValue payPalPaymentMethod = null;
try {
payPalPaymentMethod = paymentPref.getRelatedOne("PaymentMethod", false);
payPalPaymentMethod = payPalPaymentMethod.getRelatedOne("PayPalPaymentMethod", false);
} catch (GenericEntityException e) {
Debug.logError(e, module);
return ServiceUtil.returnError(e.getMessage());
}
BigDecimal processAmount = paymentPref.getBigDecimal("maxAmount");
NVPEncoder encoder = new NVPEncoder();
encoder.add("METHOD", "DoExpressCheckoutPayment");
encoder.add("TOKEN", payPalPaymentMethod.getString("expressCheckoutToken"));
encoder.add("PAYMENTACTION", "Order");
encoder.add("PAYERID", payPalPaymentMethod.getString("payerId"));
// set the amount
encoder.add("AMT", processAmount.setScale(2).toPlainString());
encoder.add("CURRENCYCODE", orh.getCurrency());
BigDecimal grandTotal = orh.getOrderGrandTotal();
BigDecimal shippingTotal = orh.getShippingTotal().setScale(2, BigDecimal.ROUND_HALF_UP);
BigDecimal taxTotal = orh.getTaxTotal().setScale(2, BigDecimal.ROUND_HALF_UP);
BigDecimal subTotal =
grandTotal.subtract(shippingTotal).subtract(taxTotal).setScale(2, BigDecimal.ROUND_HALF_UP);
encoder.add("ITEMAMT", subTotal.toPlainString());
encoder.add("SHIPPINGAMT", shippingTotal.toPlainString());
encoder.add("TAXAMT", taxTotal.toPlainString());
NVPDecoder decoder = null;
try {
decoder = sendNVPRequest(payPalPaymentSetting, encoder);
} catch (PayPalException e) {
Debug.logError(e, module);
return ServiceUtil.returnError(e.getMessage());
}
if (decoder == null) {
return ServiceUtil.returnError(
UtilProperties.getMessage(resource, "AccountingPayPalUnknownError", locale));
}
Map<String, String> errorMessages = getErrorMessageMap(decoder);
if (UtilValidate.isNotEmpty(errorMessages)) {
if (errorMessages.containsKey("10417")) {
// "The transaction cannot complete successfully, Instruct the customer to use an
// alternative payment method"
// I've only encountered this once and there's no indication of the cause so the temporary
// solution is to try again
boolean retry = context.get("_RETRY_") == null || (Boolean) context.get("_RETRY_");
if (retry) {
context.put("_RETRY_", false);
return PayPalServices.doExpressCheckout(dctx, context);
}
}
return ServiceUtil.returnError(UtilMisc.toList(errorMessages.values()));
}
Map<String, Object> inMap = FastMap.newInstance();
inMap.put("userLogin", userLogin);
inMap.put("paymentMethodId", payPalPaymentMethod.get("paymentMethodId"));
inMap.put("transactionId", decoder.get("TRANSACTIONID"));
Map<String, Object> outMap = null;
try {
outMap = dispatcher.runSync("updatePayPalPaymentMethod", inMap);
} catch (GenericServiceException e) {
Debug.logError(e, module);
return ServiceUtil.returnError(e.getMessage());
}
if (ServiceUtil.isError(outMap)) {
Debug.logError(ServiceUtil.getErrorMessage(outMap), module);
return outMap;
}
return ServiceUtil.returnSuccess();
}
// auto-replenish service (deposit)
public static Map<String, Object> finAccountReplenish(
DispatchContext dctx, Map<String, 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");
String finAccountId = (String) context.get("finAccountId");
// lookup the FinAccount
GenericValue finAccount;
try {
finAccount =
EntityQuery.use(delegator)
.from("FinAccount")
.where("finAccountId", finAccountId)
.queryOne();
} catch (GenericEntityException e) {
Debug.logError(e, module);
return ServiceUtil.returnError(e.getMessage());
}
if (finAccount == null) {
return ServiceUtil.returnError(
UtilProperties.getMessage(
resourceError,
"AccountingFinAccountNotFound",
UtilMisc.toMap("finAccountId", finAccountId),
locale));
}
String currency = finAccount.getString("currencyUomId");
String statusId = finAccount.getString("statusId");
// look up the type -- determine auto-replenish is active
GenericValue finAccountType;
try {
finAccountType = finAccount.getRelatedOne("FinAccountType", false);
} catch (GenericEntityException e) {
Debug.logError(e, module);
return ServiceUtil.returnError(e.getMessage());
}
String replenishEnumId = finAccountType.getString("replenishEnumId");
if (!"FARP_AUTOMATIC".equals(replenishEnumId)) {
// type does not support auto-replenish
return ServiceUtil.returnSuccess();
}
// attempt to lookup the product store from a previous deposit
if (productStoreId == null) {
productStoreId = getLastProductStoreId(delegator, finAccountId);
if (productStoreId == null) {
return ServiceUtil.returnError(
UtilProperties.getMessage(
resourceError, "AccountingFinAccountCannotBeReplenish", locale));
}
}
// get the product store settings
GenericValue finAccountSettings;
Map<String, Object> psfasFindMap =
UtilMisc.<String, Object>toMap(
"productStoreId",
productStoreId,
"finAccountTypeId",
finAccount.getString("finAccountTypeId"));
try {
finAccountSettings =
EntityQuery.use(delegator)
.from("ProductStoreFinActSetting")
.where(psfasFindMap)
.cache()
.queryOne();
} catch (GenericEntityException e) {
Debug.logError(e, module);
return ServiceUtil.returnError(e.getMessage());
}
if (finAccountSettings == null) {
Debug.logWarning(
"finAccountReplenish Warning: not replenishing FinAccount ["
+ finAccountId
+ "] because no ProductStoreFinActSetting record found for: "
+ psfasFindMap,
module);
// no settings; don't replenish
return ServiceUtil.returnSuccess();
}
BigDecimal replenishThreshold = finAccountSettings.getBigDecimal("replenishThreshold");
if (replenishThreshold == null) {
Debug.logWarning(
"finAccountReplenish Warning: not replenishing FinAccount ["
+ finAccountId
+ "] because ProductStoreFinActSetting.replenishThreshold field was null for: "
+ psfasFindMap,
module);
return ServiceUtil.returnSuccess();
}
BigDecimal replenishLevel = finAccount.getBigDecimal("replenishLevel");
if (replenishLevel == null || replenishLevel.compareTo(BigDecimal.ZERO) == 0) {
Debug.logWarning(
"finAccountReplenish Warning: not replenishing FinAccount ["
+ finAccountId
+ "] because FinAccount.replenishLevel field was null or 0",
module);
// no replenish level set; this account goes not support auto-replenish
return ServiceUtil.returnSuccess();
}
// get the current balance
BigDecimal balance = finAccount.getBigDecimal("actualBalance");
// see if we are within the threshold for replenishment
if (balance.compareTo(replenishThreshold) > -1) {
Debug.logInfo(
"finAccountReplenish Info: Not replenishing FinAccount ["
+ finAccountId
+ "] because balance ["
+ balance
+ "] is greater than the replenishThreshold ["
+ replenishThreshold
+ "]",
module);
// not ready
return ServiceUtil.returnSuccess();
}
// configure rollback service to set status to Negative Pending Replenishment
if ("FNACT_NEGPENDREPL".equals(statusId)) {
try {
Map<String, Object> rollbackCtx =
UtilMisc.toMap(
"userLogin",
userLogin,
"finAccountId",
finAccountId,
"statusId",
"FNACT_NEGPENDREPL");
dispatcher.addRollbackService("updateFinAccount", rollbackCtx, true);
} catch (GenericServiceException e) {
Debug.logError(e, module);
return ServiceUtil.returnError(e.getMessage());
}
}
String replenishMethod = finAccountSettings.getString("replenishMethodEnumId");
BigDecimal depositAmount;
if (replenishMethod == null || "FARP_TOP_OFF".equals(replenishMethod)) {
// the deposit is level - balance (500 - (-10) = 510 || 500 - (10) = 490)
depositAmount = replenishLevel.subtract(balance);
} else if ("FARP_REPLENISH_LEVEL".equals(replenishMethod)) {
// the deposit is replenish-level itself
depositAmount = replenishLevel;
} else {
return ServiceUtil.returnError(
UtilProperties.getMessage(
resourceError, "AccountingFinAccountUnknownReplenishMethod", locale));
}
// get the owner party
String ownerPartyId = finAccount.getString("ownerPartyId");
if (ownerPartyId == null) {
// no owner cannot replenish; (not fatal, just not supported by this account)
Debug.logWarning(
"finAccountReplenish Warning: No owner attached to financial account ["
+ finAccountId
+ "] cannot auto-replenish",
module);
return ServiceUtil.returnSuccess();
}
// get the payment method to use to replenish
String paymentMethodId = finAccount.getString("replenishPaymentId");
if (paymentMethodId == null) {
Debug.logWarning(
"finAccountReplenish Warning: No payment method (replenishPaymentId) attached to financial account ["
+ finAccountId
+ "] cannot auto-replenish",
module);
return ServiceUtil.returnError(
UtilProperties.getMessage(
resourceError,
"AccountingFinAccountNoPaymentMethodAssociatedWithReplenishAccount",
locale));
}
GenericValue paymentMethod;
try {
paymentMethod =
EntityQuery.use(delegator)
.from("PaymentMethod")
.where("paymentMethodId", paymentMethodId)
.queryOne();
} catch (GenericEntityException e) {
Debug.logError(e, module);
return ServiceUtil.returnError(e.getMessage());
}
if (paymentMethod == null) {
// no payment methods on file; cannot replenish
Debug.logWarning(
"finAccountReplenish Warning: No payment method found for ID ["
+ paymentMethodId
+ "] for party ["
+ ownerPartyId
+ "] cannot auto-replenish",
module);
return ServiceUtil.returnError(
UtilProperties.getMessage(
resourceError,
"AccountingFinAccountNoPaymentMethodAssociatedWithReplenishAccount",
locale));
}
// hit the payment method for the amount to replenish
Map<String, BigDecimal> orderItemMap =
UtilMisc.toMap("Auto-Replenishment FA #" + finAccountId, depositAmount);
Map<String, Object> replOrderCtx = new HashMap<String, Object>();
replOrderCtx.put("productStoreId", productStoreId);
replOrderCtx.put("paymentMethodId", paymentMethod.getString("paymentMethodId"));
replOrderCtx.put("currency", currency);
replOrderCtx.put("partyId", ownerPartyId);
replOrderCtx.put("itemMap", orderItemMap);
replOrderCtx.put("userLogin", userLogin);
Map<String, Object> replResp;
try {
replResp = dispatcher.runSync("createSimpleNonProductSalesOrder", replOrderCtx);
} catch (GenericServiceException e) {
Debug.logError(e, module);
return ServiceUtil.returnError(e.getMessage());
}
if (ServiceUtil.isError(replResp)) {
return replResp;
}
String orderId = (String) replResp.get("orderId");
// create the deposit
Map<String, Object> depositCtx = new HashMap<String, Object>();
depositCtx.put("productStoreId", productStoreId);
depositCtx.put("finAccountId", finAccountId);
depositCtx.put("currency", currency);
depositCtx.put("partyId", ownerPartyId);
depositCtx.put("orderId", orderId);
depositCtx.put("orderItemSeqId", "00001"); // always one item on a replish order
depositCtx.put("amount", depositAmount);
depositCtx.put("reasonEnumId", "FATR_REPLENISH");
depositCtx.put("userLogin", userLogin);
try {
Map<String, Object> depositResp = dispatcher.runSync("finAccountDeposit", depositCtx);
if (ServiceUtil.isError(depositResp)) {
return depositResp;
}
} catch (GenericServiceException e) {
Debug.logError(e, module);
return ServiceUtil.returnError(e.getMessage());
}
// say we are in good standing again
if ("FNACT_NEGPENDREPL".equals(statusId)) {
try {
Map<String, Object> ufaResp =
dispatcher.runSync(
"updateFinAccount",
UtilMisc.<String, Object>toMap(
"finAccountId",
finAccountId,
"statusId",
"FNACT_ACTIVE",
"userLogin",
userLogin));
if (ServiceUtil.isError(ufaResp)) {
return ufaResp;
}
} catch (GenericServiceException e) {
Debug.logError(e, module);
return ServiceUtil.returnError(e.getMessage());
}
}
return ServiceUtil.returnSuccess();
}