/**
Licensed to the Apache Software Foundation (ASF) under one
or more contributor license agreements. See the NOTICE file
distributed with this work for additional information
regarding copyright ownership. The ASF licenses this file
to you under the Apache License, Version 2.0 (the
"License"); you may not use this file except in compliance
with the License. You may obtain a copy of the License at
http://www.apache.org/licenses/LICENSE-2.0
Unless required by applicable law or agreed to in writing,
software distributed under the License is distributed on an
"AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY
KIND, either express or implied. See the License for the
specific language governing permissions and limitations
under the License.
**/
package org.ofbiz.googlecheckout;
import java.math.BigDecimal;
import java.util.Collection;
import java.util.HashMap;
import java.util.List;
import java.util.Locale;
import java.util.Map;
import javolution.util.FastMap;
import org.ofbiz.base.util.Debug;
import org.ofbiz.base.util.GeneralException;
import org.ofbiz.base.util.UtilGenerics;
import org.ofbiz.base.util.UtilMisc;
import org.ofbiz.base.util.UtilValidate;
import org.ofbiz.entity.Delegator;
import org.ofbiz.entity.GenericEntityException;
import org.ofbiz.entity.GenericValue;
import org.ofbiz.entity.condition.EntityCondition;
import org.ofbiz.entity.condition.EntityOperator;
import org.ofbiz.entity.util.EntityUtil;
import org.ofbiz.order.order.OrderChangeHelper;
import org.ofbiz.order.shoppingcart.CheckOutHelper;
import org.ofbiz.order.shoppingcart.ItemNotFoundException;
import org.ofbiz.order.shoppingcart.ShoppingCart;
import org.ofbiz.order.shoppingcart.ShoppingCartItem;
import org.ofbiz.party.party.PartyWorker;
import org.ofbiz.service.LocalDispatcher;
import org.ofbiz.service.ServiceUtil;
import com.google.checkout.checkout.Item;
import com.google.checkout.notification.Address;
import com.google.checkout.notification.AuthorizationAmountNotification;
import com.google.checkout.notification.ChargeAmountNotification;
import com.google.checkout.notification.ChargebackAmountNotification;
import com.google.checkout.notification.FinancialOrderState;
import com.google.checkout.notification.MerchantCodes;
import com.google.checkout.notification.NewOrderNotification;
import com.google.checkout.notification.OrderAdjustment;
import com.google.checkout.notification.OrderStateChangeNotification;
import com.google.checkout.notification.RefundAmountNotification;
import com.google.checkout.notification.RiskInformationNotification;
import com.google.checkout.notification.Shipping;
import com.google.checkout.notification.StructuredName;
public class GoogleCheckoutHelper {
private static final String module = GoogleCheckoutHelper.class.getName();
public static final String SALES_CHANNEL = "GC_SALES_CHANNEL";
public static final String ORDER_TYPE = "SALES_ORDER";
public static final String PAYMENT_METHOD = "EXT_GOOGLE_CHECKOUT";
public static final int SHIPPING_ADDRESS = 10;
public static final int BILLING_ADDRESS = 50;
protected LocalDispatcher dispatcher;
protected Delegator delegator;
protected GenericValue system;
public GoogleCheckoutHelper(LocalDispatcher dispatcher, Delegator delegator) {
this.dispatcher = dispatcher;
this.delegator = delegator;
try {
system = delegator.findOne("UserLogin", true, "userLoginId", "system");
} catch (GenericEntityException e) {
Debug.logError(e, module);
system = delegator.makeValue("UserLogin");
system.set("userLoginId", "system");
system.set("partyId", "admin");
system.set("isSystem", "Y");
}
}
public void processStateChange(OrderStateChangeNotification info) throws GeneralException {
String externalId = info.getGoogleOrderNumber();
GenericValue order = null;
try {
List<GenericValue> orders = delegator.findByAnd("OrderHeader", UtilMisc.toMap("externalId", externalId, "salesChannelEnumId" , SALES_CHANNEL));
order = EntityUtil.getFirst(orders);
} catch (GenericEntityException e) {
Debug.logError(e, module);
}
if (order != null) {
String orderId = order.getString("orderId");
// check for a financial state change
FinancialOrderState oldFin = info.getPreviousFinancialOrderState();
FinancialOrderState newFin = info.getNewFinancialOrderState();
if (!oldFin.equals(newFin)) {
// financial state change
if (newFin.equals(FinancialOrderState.CANCELLED) || newFin.equals(FinancialOrderState.CANCELLED_BY_GOOGLE)) {
// cancel the order
if (!"ORDER_CANCELLED".equals(order.getString("statusId"))) {
OrderChangeHelper.cancelOrder(dispatcher, system, orderId);
}
} else if (newFin.equals(FinancialOrderState.CHARGEABLE) && oldFin.equals(FinancialOrderState.REVIEWING)) {
// approve the order
if (!"ORDER_APPROVED".equals(order.getString("statusId"))) {
OrderChangeHelper.approveOrder(dispatcher, system, orderId, hasHoldOrderNotes(orderId));
}
} else if (newFin.equals(FinancialOrderState.PAYMENT_DECLINED)) {
// reject the order
if (!"ORDER_REJECTED".equals(order.getString("statusId"))) {
OrderChangeHelper.rejectOrder(dispatcher, system, orderId);
}
}
// TODO: look at how to implement the other state changes
// CHARGED, CHARGING
}
}
}
public void processRiskNotification(RiskInformationNotification info) throws GeneralException {
// TODO implement me (if desired)
return; // the notification will be accepted
}
public void processAuthNotification(AuthorizationAmountNotification info) throws GeneralException {
String externalId = info.getGoogleOrderNumber();
List<GenericValue> orders = null;
GenericValue orderPaymentPreference = null;
try {
orders = delegator.findByAnd("OrderHeader", UtilMisc.toMap("externalId", externalId, "salesChannelEnumId", SALES_CHANNEL));
} catch (GenericEntityException e) {
Debug.logError(e, module);
}
if (UtilValidate.isNotEmpty(orders)) {
GenericValue order = EntityUtil.getFirst(orders);
List<GenericValue> orderPaymentPreferences = order.getRelated("OrderPaymentPreference");
if (UtilValidate.isNotEmpty(orderPaymentPreferences)) {
orderPaymentPreference = EntityUtil.getFirst(orderPaymentPreferences);
BigDecimal maxAmount = new BigDecimal(info.getAuthorizationAmount());
//Update orderPaymentPreference
Map<String, Object> paymentPrefMap = UtilMisc.toMap("orderPaymentPreferenceId", orderPaymentPreference.get("orderPaymentPreferenceId"), "maxAmount", maxAmount, "statusId", "PAYMENT_AUTHORIZED", "paymentMethodTypeId", "EXT_GOOGLE_CHECKOUT");
updatePaymentPreference(paymentPrefMap);
//Create PaymentGatewayResponse
Map<String, Object> newGatewayMap = UtilMisc.toMap("amount", maxAmount, "transCodeEnumId", "PGT_AUTHORIZE", "referenceNum", externalId, "gatewayAvsResult", info.getAvsResponse(), "currencyUomId", info.getCurrencyCode());
newGatewayMap.put("orderPaymentPreferenceId", orderPaymentPreference.get("orderPaymentPreferenceId"));
newGatewayMap.put("paymentMethodTypeId", orderPaymentPreference.get("paymentMethodTypeId"));
newGatewayMap.put("transactionDate", order.getTimestamp("orderDate"));
createPaymentGatewayResponse(newGatewayMap);
}
}
return;
}
public void processChargeNotification(ChargeAmountNotification info) throws GeneralException {
String externalId = info.getGoogleOrderNumber();
List<GenericValue> orders = null;
GenericValue orderPaymentPreference = null;
try {
orders = delegator.findByAnd("OrderHeader", UtilMisc.toMap("externalId", externalId, "salesChannelEnumId", SALES_CHANNEL));
} catch (GenericEntityException e) {
Debug.logError(e, module);
}
if (UtilValidate.isNotEmpty(orders)) {
GenericValue order = EntityUtil.getFirst(orders);
List<GenericValue> orderPaymentPreferences = order.getRelated("OrderPaymentPreference");
if (UtilValidate.isNotEmpty(orderPaymentPreferences)) {
orderPaymentPreference = EntityUtil.getFirst(orderPaymentPreferences);
BigDecimal maxAmount = new BigDecimal(info.getTotalChargeAmount());
//Update orderPaymentPreference
Map<String, Object> paymentPrefMap = UtilMisc.toMap("orderPaymentPreferenceId", orderPaymentPreference.get("orderPaymentPreferenceId"), "maxAmount", maxAmount, "statusId", "PAYMENT_SETTLED", "paymentMethodTypeId", "EXT_GOOGLE_CHECKOUT");
updatePaymentPreference(paymentPrefMap);
//Create PaymentGatewayResponse
maxAmount = new BigDecimal(info.getLatestChargeAmount());
Map<String, Object> newGatewayMap = UtilMisc.toMap("amount", maxAmount, "transCodeEnumId", "PGT_CAPTURE", "referenceNum", externalId, "currencyUomId", info.getCurrencyCode());
newGatewayMap.put("orderPaymentPreferenceId", orderPaymentPreference.get("orderPaymentPreferenceId"));
newGatewayMap.put("paymentMethodTypeId", orderPaymentPreference.get("paymentMethodTypeId"));
newGatewayMap.put("transactionDate", order.getTimestamp("orderDate"));
createPaymentGatewayResponse(newGatewayMap);
}
}
return;
}
public void processRefundNotification(RefundAmountNotification info) throws GeneralException {
String externalId = info.getGoogleOrderNumber();
List<GenericValue> orders = null;
GenericValue orderPaymentPreference = null;
try {
orders = delegator.findByAnd("OrderHeader", UtilMisc.toMap("externalId", externalId, "salesChannelEnumId", SALES_CHANNEL));
} catch (GenericEntityException e) {
Debug.logError(e, module);
}
if (UtilValidate.isNotEmpty(orders)) {
GenericValue order = EntityUtil.getFirst(orders);
List<GenericValue> orderPaymentPreferences = order.getRelated("OrderPaymentPreference");
if (UtilValidate.isNotEmpty(orderPaymentPreferences)) {
orderPaymentPreference = EntityUtil.getFirst(orderPaymentPreferences);
BigDecimal maxAmount = new BigDecimal(info.getTotalRefundAmount());
//Update orderPaymentPreference
Map<String, Object> paymentPrefMap = UtilMisc.toMap("orderPaymentPreferenceId", orderPaymentPreference.get("orderPaymentPreferenceId"), "maxAmount", maxAmount, "statusId", "PAYMENT_REFUNDED", "paymentMethodTypeId", "EXT_GOOGLE_CHECKOUT");
updatePaymentPreference(paymentPrefMap);
//Create PaymentGatewayResponse
maxAmount = new BigDecimal(info.getLatestRefundAmount());
Map<String, Object> newGatewayMap = UtilMisc.toMap("amount", maxAmount, "transCodeEnumId", "PGT_REFUND", "referenceNum", externalId, "currencyUomId", info.getCurrencyCode());
newGatewayMap.put("orderPaymentPreferenceId", orderPaymentPreference.get("orderPaymentPreferenceId"));
newGatewayMap.put("paymentMethodTypeId", orderPaymentPreference.get("paymentMethodTypeId"));
newGatewayMap.put("transactionDate", order.getTimestamp("orderDate"));
createPaymentGatewayResponse(newGatewayMap);
}
}
return;
}
public void processChargeBackNotification(ChargebackAmountNotification info) throws GeneralException {
// TODO: implement me (if desired)
return; // the notification will be accepted
}
public void createOrder(NewOrderNotification info, String productStoreId, Locale locale) throws GeneralException {
// get the google order number
String externalId = info.getGoogleOrderNumber();
// check and make sure this order doesn't already exist
List<GenericValue> existingOrder = delegator.findByAnd("OrderHeader", UtilMisc.toMap("externalId", externalId));
if (UtilValidate.isNotEmpty(existingOrder)) {
//throw new GeneralException("Google order #" + externalId + " already exists.");
Debug.logWarning("Google order #" + externalId + " already exists.", module);
return;
}
// get the config object
GenericValue googleCfg = GoogleRequestServices.getGoogleConfiguration(delegator, productStoreId);
if (googleCfg == null) {
throw new GeneralException("No google configuration found for product store : " + productStoreId);
}
String websiteId = googleCfg.getString("webSiteId");
String currencyUom = googleCfg.getString("currencyUomId");
String prodCatalogId = googleCfg.getString("prodCatalogId");
boolean errorOnUnknownItem = googleCfg.get("errorOnBadItem") != null &&
"Y".equalsIgnoreCase(googleCfg.getString("errorOnBadItem")) ? true : false;
// Initialize the shopping cart
ShoppingCart cart = new ShoppingCart(delegator, productStoreId, websiteId, locale, currencyUom);
cart.setUserLogin(system, dispatcher);
cart.setOrderType(ORDER_TYPE);
cart.setChannelType(SALES_CHANNEL);
//cart.setOrderDate(UtilDateTime.toTimestamp(info.getTimestamp().()));
cart.setExternalId(externalId);
Debug.logInfo("Created shopping cart for Google order: ", module);
Debug.logInfo("-- WebSite : " + websiteId, module);
Debug.logInfo("-- Product Store : " + productStoreId, module);
Debug.logInfo("-- Locale : " + locale.toString(), module);
Debug.logInfo("-- Google Order # : " + externalId, module);
// set the customer information
Address shippingAddress = info.getBuyerShippingAddress();
Address billingAddress = info.getBuyerBillingAddress();
String[] partyInfo = getPartyInfo(shippingAddress, billingAddress);
if (partyInfo == null || partyInfo.length != 3) {
throw new GeneralException("Unable to parse/create party information, invalid number of parameters returned");
}
cart.setOrderPartyId(partyInfo[0]);
cart.setPlacingCustomerPartyId(partyInfo[0]);
cart.setShippingContactMechId(partyInfo[1]);
// contact info
String shippingEmail = shippingAddress.getEmail();
if (UtilValidate.isNotEmpty(shippingEmail)) {
setContactInfo(cart, "PRIMARY_EMAIL", shippingEmail);
}
String billingEmail = billingAddress.getEmail();
if (UtilValidate.isNotEmpty(billingEmail)) {
setContactInfo(cart, "BILLING_EMAIL", billingEmail);
}
String shippingPhone = shippingAddress.getPhone();
if (UtilValidate.isNotEmpty(shippingPhone)) {
setContactInfo(cart, "PHONE_SHIPPING", shippingPhone);
}
String billingPhone = billingAddress.getPhone();
if (UtilValidate.isNotEmpty(billingPhone)) {
setContactInfo(cart, "PHONE_BILLING", billingPhone);
}
// set the order items
Collection<Item> items = UtilGenerics.checkCollection(info.getShoppingCart().getItems());
for (Item item : items) {
try {
addItem(cart, item, prodCatalogId, 0);
} catch (ItemNotFoundException e) {
Debug.logWarning(e, "Item was not found : " + item.getMerchantItemId(), module);
// throwing this exception tell google the order failed; it will continue to retry
if (errorOnUnknownItem) {
throw new GeneralException("Invalid item requested from Google Checkout - " + item.getMerchantItemId());
}
}
}
// handle the adjustments
OrderAdjustment adjustment = info.getOrderAdjustment();
if (adjustment != null) {
addAdjustments(cart, adjustment);
// ship group info
Shipping shipping = info.getOrderAdjustment().getShipping();
addShipInfo(cart, shipping, partyInfo[1]);
}
// set the cart payment method
cart.addPaymentAmount(PAYMENT_METHOD, new BigDecimal(info.getOrderTotal()));
// validate the payment methods
CheckOutHelper coh = new CheckOutHelper(dispatcher, delegator, cart);
Map<String, Object> validateResp = coh.validatePaymentMethods();
if (ServiceUtil.isError(validateResp)) {
throw new GeneralException(ServiceUtil.getErrorMessage(validateResp));
}
// create the order & process payments
Map<String, Object> createResp = coh.createOrder(system);
String orderId = cart.getOrderId();
if (ServiceUtil.isError(createResp)) {
throw new GeneralException(ServiceUtil.getErrorMessage(createResp));
}
// notify google of our order number
try {
dispatcher.runAsync("sendGoogleOrderNumberRequest", UtilMisc.toMap("orderId", orderId), true);
} catch (GeneralException e) {
Debug.logError(e, module);
}
}
protected void addItem(ShoppingCart cart, Item item, String prodCatalogId, int groupIdx) throws GeneralException {
String productId = item.getMerchantItemId();
BigDecimal qty = new BigDecimal(item.getQuantity());
BigDecimal price = new BigDecimal(item.getUnitPriceAmount());
price = price.setScale(ShoppingCart.scale, ShoppingCart.rounding);
HashMap<Object, Object> attrs = new HashMap<Object, Object>();
attrs.put("shipGroup", groupIdx);
int idx = cart.addItemToEnd(productId, null, qty, null, null, attrs, prodCatalogId, null, dispatcher, Boolean.FALSE, Boolean.TRUE, Boolean.TRUE, Boolean.TRUE);
ShoppingCartItem cartItem = cart.findCartItem(idx);
cartItem.setQuantity(qty, dispatcher, cart, true, false);
// locate the price verify it matches the expected price
BigDecimal cartPrice = cartItem.getBasePrice();
cartPrice = cartPrice.setScale(ShoppingCart.scale, ShoppingCart.rounding);
if (price.doubleValue() != cartPrice.doubleValue()) {
// does not match; honor the price but hold the order for manual review
cartItem.setIsModifiedPrice(true);
cartItem.setBasePrice(price);
cart.setHoldOrder(true);
cart.addInternalOrderNote("Price received [" + price + "] (for item # " + productId + ") from Google Checkout does not match the price in the database [" + cartPrice + "]. Order is held for manual review.");
}
// assign the item to its ship group
cart.setItemShipGroupQty(cartItem, qty, groupIdx);
}
protected void addAdjustments(ShoppingCart cart, OrderAdjustment adjustment) {
// handle shipping
Shipping shipping = adjustment.getShipping();
BigDecimal shipAmount = new BigDecimal(shipping.getShippingCost());
GenericValue shipAdj = delegator.makeValue("OrderAdjustment", FastMap.newInstance());
shipAdj.set("orderAdjustmentTypeId", "SHIPPING_CHARGES");
shipAdj.set("amount", shipAmount);
cart.addAdjustment(shipAdj);
// handle tax
BigDecimal taxAmount = new BigDecimal(adjustment.getTotalTax());
GenericValue taxAdj = delegator.makeValue("OrderAdjustment", FastMap.newInstance());
taxAdj.set("orderAdjustmentTypeId", "SALES_TAX");
taxAdj.set("amount", taxAmount);
cart.addAdjustment(taxAdj);
// handle promotions
Collection<MerchantCodes> merchantCodes = UtilGenerics.checkCollection(adjustment.getMerchantCodes());
for (MerchantCodes codes : merchantCodes) {
GenericValue promoAdj = delegator.makeValue("OrderAdjustment", FastMap.newInstance());
promoAdj.set("orderAdjustmentTypeId", "PROMOTION_ADJUSTMENT");
promoAdj.set("description", "Promotion Code: " + codes.getCode());
promoAdj.set("comments", "Google Promotion: " + codes.getMessage());
promoAdj.set("amount", new BigDecimal(-1 * (codes.getAppliedAmount()))); // multiply by -1
cart.addAdjustment(promoAdj);
}
}
protected void addShipInfo(ShoppingCart cart, Shipping shipping, String shipContactMechId) {
String shippingName = shipping.getShippingName();
GenericValue googleShipping = null;
try {
googleShipping = delegator.findOne("GoogleCoShippingMethod", UtilMisc.toMap("shipmentMethodName", shippingName,
"productStoreId", cart.getProductStoreId()), false);
} catch (GenericEntityException e) {
Debug.logError(e, module);
}
if (googleShipping != null) {
String shipmentMethodTypeId = googleShipping.getString("shipmentMethodTypeId");
String carrierPartyId = googleShipping.getString("carrierPartyId");
Boolean maySplit = Boolean.FALSE;
cart.setShipmentMethodTypeId(shipmentMethodTypeId);
cart.setCarrierPartyId(carrierPartyId);
cart.setMaySplit(maySplit);
cart.setShippingContactMechId(shipContactMechId);
} else {
Debug.logWarning("No valid fulfillment method found! No shipping info set!", module);
}
}
protected String[] getPartyInfo(Address shipAddr, Address billAddr) throws GeneralException {
String shipCmId = null;
String billCmId = null;
String partyId = null;
// look for an existing shipping address
List<GenericValue> shipInfo = PartyWorker.findMatchingPartyAndPostalAddress(delegator, shipAddr.getAddress1(),
(UtilValidate.isEmpty(shipAddr.getAddress2()) ? null : shipAddr.getAddress2()), shipAddr.getCity(), shipAddr.getRegion(),
shipAddr.getPostalCode(), null, getCountryGeoId(shipAddr.getCountryCode()), shipAddr.getStructuredName().getFirstName(),
null, shipAddr.getStructuredName().getLastName());
if (UtilValidate.isNotEmpty(shipInfo)) {
GenericValue first = EntityUtil.getFirst(shipInfo);
shipCmId = first.getString("contactMechId");
partyId = first.getString("partyId");
Debug.logInfo("Existing shipping address found : " + shipCmId + " (party: " + partyId + ")", module);
}
// look for an existing billing address
List<GenericValue> billInfo = PartyWorker.findMatchingPartyAndPostalAddress(delegator, billAddr.getAddress1(),
(UtilValidate.isEmpty(billAddr.getAddress2()) ? null : billAddr.getAddress2()), billAddr.getCity(), billAddr.getRegion(),
billAddr.getPostalCode(), null, getCountryGeoId(billAddr.getCountryCode()), billAddr.getStructuredName().getFirstName(),
null, billAddr.getStructuredName().getLastName());
if (UtilValidate.isNotEmpty(billInfo)) {
GenericValue first = EntityUtil.getFirst(billInfo);
billCmId = first.getString("contactMechId");
if (partyId == null) {
partyId = first.getString("partyId");
} else {
String billPartyId = first.getString("partyId");
if (!billPartyId.equals(partyId)) {
// address found for a different partyID -- probably a duplicate
Debug.logWarning("Duplicate partyId found : " + billPartyId + " -> " + partyId, module);
}
}
Debug.logInfo("Existing billing address found : " + billCmId + " (party: " + partyId + ")", module);
}
// create the party if necessary
if (partyId == null) {
partyId = createPerson(shipAddr.getStructuredName());
}
// create the shipping address if necessary
if (shipCmId == null) {
shipCmId = createPartyAddress(partyId, shipAddr);
addPurposeToAddress(partyId, shipCmId, SHIPPING_ADDRESS);
}
// create the billing address if necessary
if (billCmId == null) {
// check the billing address again (in case it was just created)
billInfo = PartyWorker.findMatchingPartyAndPostalAddress(delegator, billAddr.getAddress1(),
billAddr.getAddress2(), billAddr.getCity(), billAddr.getRegion(),
billAddr.getPostalCode(), null, getCountryGeoId(billAddr.getCountryCode()), billAddr.getStructuredName().getFirstName(),
null, billAddr.getStructuredName().getLastName());
if (UtilValidate.isNotEmpty(billInfo)) {
GenericValue first = EntityUtil.getFirst(billInfo);
billCmId = first.getString("contactMechId");
} else {
billCmId = createPartyAddress(partyId, shipAddr);
addPurposeToAddress(partyId, billCmId, BILLING_ADDRESS);
}
}
return new String[] { partyId, shipCmId, billCmId };
}
protected String createPerson(StructuredName name) throws GeneralException {
Map<String, Object> personMap = FastMap.newInstance();
personMap.put("firstName", name.getFirstName());
personMap.put("lastName", name.getLastName());
personMap.put("userLogin", system);
Map<String, Object> personResp = dispatcher.runSync("createPerson", personMap);
if (ServiceUtil.isError(personResp)) {
throw new GeneralException("Unable to create new customer account: " + ServiceUtil.getErrorMessage(personResp));
}
String partyId = (String) personResp.get("partyId");
Debug.logInfo("New party created : " + partyId, module);
return partyId;
}
protected String createPartyAddress(String partyId, Address addr) throws GeneralException {
// check for zip+4
String postalCode = addr.getPostalCode();
String postalCodeExt = null;
if (postalCode.length() == 10 && postalCode.indexOf("-") != -1) {
String[] strSplit = postalCode.split("-", 2);
postalCode = strSplit[0];
postalCodeExt = strSplit[1];
}
// prepare the create address map
Map<String, Object> addrMap = FastMap.newInstance();
addrMap.put("partyId", partyId);
addrMap.put("toName", addr.getContactName());
addrMap.put("address1", addr.getAddress1());
addrMap.put("address2", addr.getAddress2());
addrMap.put("city", addr.getCity());
addrMap.put("stateProvinceGeoId",addr.getRegion());
addrMap.put("countryGeoId", getCountryGeoId(addr.getCountryCode()));
addrMap.put("postalCode", postalCode);
addrMap.put("postalCodeExt", postalCodeExt);
addrMap.put("allowSolicitation", "Y");
addrMap.put("contactMechPurposeTypeId", "GENERAL_LOCATION");
addrMap.put("userLogin", system); // run as the system user
// invoke the create address service
Map<String, Object> addrResp = dispatcher.runSync("createPartyPostalAddress", addrMap);
if (ServiceUtil.isError(addrResp)) {
throw new GeneralException("Unable to create new customer address record: " +
ServiceUtil.getErrorMessage(addrResp));
}
String contactMechId = (String) addrResp.get("contactMechId");
Debug.logInfo("Created new address for partyId [" + partyId + "] :" + contactMechId, module);
return contactMechId;
}
protected void addPurposeToAddress(String partyId, String contactMechId, int addrType) throws GeneralException {
// convert the int to a purpose type ID
String contactMechPurposeTypeId = getAddressType(addrType);
// check to make sure the purpose doesn't already exist
List<GenericValue> values = delegator.findByAnd("PartyContactMechPurpose", UtilMisc.toMap("partyId", partyId,
"contactMechId", contactMechId, "contactMechPurposeTypeId", contactMechPurposeTypeId));
if (UtilValidate.isEmpty(values)) {
Map<String, Object> addPurposeMap = FastMap.newInstance();
addPurposeMap.put("contactMechId", contactMechId);
addPurposeMap.put("partyId", partyId);
addPurposeMap.put("contactMechPurposeTypeId", contactMechPurposeTypeId);
addPurposeMap.put("userLogin", system);
Map<String, Object> addPurposeResp = dispatcher.runSync("createPartyContactMechPurpose", addPurposeMap);
if (addPurposeResp != null && ServiceUtil.isError(addPurposeResp)) {
throw new GeneralException(ServiceUtil.getErrorMessage(addPurposeResp));
}
}
}
protected String getAddressType(int addrType) {
String contactMechPurposeTypeId = "GENERAL_LOCATION";
switch (addrType) {
case SHIPPING_ADDRESS:
contactMechPurposeTypeId = "SHIPPING_LOCATION";
break;
case BILLING_ADDRESS:
contactMechPurposeTypeId = "BILLING_LOCATION";
break;
}
return contactMechPurposeTypeId;
}
protected void setContactInfo(ShoppingCart cart, String contactMechPurposeTypeId, String infoString) throws GeneralException {
Map<String, Object> lookupMap = FastMap.newInstance();
String cmId = null;
String entityName = "PartyAndContactMech";
if (contactMechPurposeTypeId.startsWith("PHONE_")) {
lookupMap.put("partyId", cart.getOrderPartyId());
lookupMap.put("contactNumber", infoString);
entityName = "PartyAndTelecomNumber";
} else if (contactMechPurposeTypeId.endsWith("_EMAIL")) {
lookupMap.put("partyId", cart.getOrderPartyId());
lookupMap.put("infoString", infoString);
} else {
throw new GeneralException("Invalid contact mech type");
}
List<GenericValue> cmLookup;
try {
cmLookup = delegator.findByAnd(entityName, lookupMap, UtilMisc.toList("-fromDate"));
cmLookup = EntityUtil.filterByDate(cmLookup);
} catch (GenericEntityException e) {
Debug.logError(e, module);
throw e;
}
if (UtilValidate.isNotEmpty(cmLookup)) {
GenericValue v = EntityUtil.getFirst(cmLookup);
if (v != null) {
cmId = v.getString("contactMechId");
}
} else {
// create it
lookupMap.put("contactMechPurposeTypeId", contactMechPurposeTypeId);
lookupMap.put("userLogin", system);
Map<String, Object> createResp = null;
if (contactMechPurposeTypeId.startsWith("PHONE_")) {
try {
createResp = dispatcher.runSync("createPartyTelecomNumber", lookupMap);
} catch (GeneralException e) {
Debug.logError(e, module);
throw e;
}
} else if (contactMechPurposeTypeId.endsWith("_EMAIL")) {
lookupMap.put("emailAddress", lookupMap.get("infoString"));
lookupMap.put("allowSolicitation", "Y");
try {
createResp = dispatcher.runSync("createPartyEmailAddress", lookupMap);
} catch (GeneralException e) {
Debug.logError(e, module);
throw e;
}
}
if (createResp == null || ServiceUtil.isError(createResp)) {
throw new GeneralException("Unable to create the request contact mech");
}
// get the created ID
cmId = (String) createResp.get("contactMechId");
}
if (cmId != null) {
cart.addContactMech(contactMechPurposeTypeId, cmId);
}
}
protected String getCountryGeoId(String geoCode) {
if (geoCode != null && geoCode.length() == 3) {
return geoCode;
}
List<GenericValue> geos = null;
try {
geos = delegator.findByAnd("Geo", UtilMisc.toMap("geoCode", geoCode, "geoTypeId", "COUNTRY"));
} catch (GenericEntityException e) {
Debug.logError(e, module);
}
if (UtilValidate.isNotEmpty(geos)) {
return EntityUtil.getFirst(geos).getString("geoId");
} else {
return "_NA_";
}
}
protected boolean hasHoldOrderNotes(String orderId) {
EntityCondition idCond = EntityCondition.makeCondition("orderId", EntityOperator.EQUALS, orderId);
EntityCondition content = EntityCondition.makeCondition("noteInfo", EntityOperator.LIKE, "%Order is held%");
EntityCondition mainCond = EntityCondition.makeCondition(UtilMisc.toList(idCond, content), EntityOperator.AND);
List<GenericValue> holdOrderNotes = null;
try {
holdOrderNotes = delegator.findList("OrderHeaderNoteView", mainCond, null, null, null, false);
} catch (GenericEntityException e) {
Debug.logError(e, module);
}
return UtilValidate.isNotEmpty(holdOrderNotes);
}
protected void updatePaymentPreference(Map<String, Object> paymentPrefMap) {
GenericValue newPref = delegator.makeValue("OrderPaymentPreference");
newPref.set("orderPaymentPreferenceId", paymentPrefMap.get("orderPaymentPreferenceId"));
newPref.set("createdByUserLogin", system.getString("userLoginId"));
newPref.setNonPKFields(paymentPrefMap);
try {
delegator.store(newPref);
} catch (GenericEntityException e) {
Debug.logError(e, module);
}
}
protected void createPaymentGatewayResponse(Map<String, Object> newGatewayMap) {
try {
String responseId = delegator.getNextSeqId("PaymentGatewayResponse");
GenericValue response = delegator.makeValue("PaymentGatewayResponse");
response.set("paymentGatewayResponseId", responseId);
response.setNonPKFields(newGatewayMap);
delegator.create(response);
} catch (GenericEntityException e) {
Debug.logError(e, module);
}
}
}