/*******************************************************************************
* Licensed to the Apache Software Foundation (ASF) under one
* or more contributor license agreements. See the NOTICE file
* distributed with this work for additional information
* regarding copyright ownership. The ASF licenses this file
* to you under the Apache License, Version 2.0 (the
* "License"); you may not use this file except in compliance
* with the License. You may obtain a copy of the License at
*
* http://www.apache.org/licenses/LICENSE-2.0
*
* Unless required by applicable law or agreed to in writing,
* software distributed under the License is distributed on an
* "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY
* KIND, either express or implied. See the License for the
* specific language governing permissions and limitations
* under the License.
*******************************************************************************/
package org.apache.ofbiz.shipment.thirdparty.dhl;
import java.io.IOException;
import java.io.StringWriter;
import java.math.BigDecimal;
import java.util.HashMap;
import java.util.LinkedList;
import java.util.List;
import java.util.Locale;
import java.util.Map;
import javax.xml.parsers.ParserConfigurationException;
import org.apache.ofbiz.base.util.Base64;
import org.apache.ofbiz.base.util.Debug;
import org.apache.ofbiz.base.util.GeneralException;
import org.apache.ofbiz.base.util.HttpClient;
import org.apache.ofbiz.base.util.HttpClientException;
import org.apache.ofbiz.base.util.StringUtil;
import org.apache.ofbiz.base.util.UtilDateTime;
import org.apache.ofbiz.base.util.UtilMisc;
import org.apache.ofbiz.base.util.UtilProperties;
import org.apache.ofbiz.base.util.UtilValidate;
import org.apache.ofbiz.base.util.UtilXml;
import org.apache.ofbiz.content.content.ContentWorker;
import org.apache.ofbiz.entity.Delegator;
import org.apache.ofbiz.entity.GenericEntityException;
import org.apache.ofbiz.entity.GenericValue;
import org.apache.ofbiz.entity.util.EntityQuery;
import org.apache.ofbiz.entity.util.EntityUtilProperties;
import org.apache.ofbiz.service.DispatchContext;
import org.apache.ofbiz.service.GenericServiceException;
import org.apache.ofbiz.service.LocalDispatcher;
import org.apache.ofbiz.service.ModelService;
import org.apache.ofbiz.service.ServiceUtil;
import org.apache.ofbiz.shipment.shipment.ShipmentServices;
import org.w3c.dom.Document;
import org.w3c.dom.Element;
import org.xml.sax.SAXException;
/**
* DHL ShipmentServices
*
* <p>Implementation of DHL US domestic shipment interface using DHL ShipIT XML APi.</p>
*
* Shipment services not supported in DHL ShipIT 1.1
* <ul>
* <li>Multiple Piece shipping (Shipment must not have more than one
* ShipmentPackage)</li>
* <li>Dynamic editing of previously submitted shipment (void first then
* resubmit instead)</li>
* <li>Label size 4"x6"</li>
* <li>Out of origin shipping</li>
* </ul>
*
* TODO: International
*/
public class DhlServices {
public final static String module = DhlServices.class.getName();
public final static String shipmentPropertiesFile = "shipment.properties";
public final static String DHL_WEIGHT_UOM_ID = "WT_lb"; // weight Uom used by DHL
public static final String resourceError = "ProductUiLabels";
/**
* Opens a URL to DHL and makes a request.
*
* @param xmlString Name of the DHL service to invoke
* @param delegator the delegator
* @param shipmentGatewayConfigId the shipment gateway config id
* @param resource the resource file (i.e. shipment.properties)
* @param locale locale in use
* @return XML string response from DHL
* @throws DhlConnectException
*/
public static String sendDhlRequest(String xmlString, Delegator delegator, String shipmentGatewayConfigId,
String resource, Locale locale) throws DhlConnectException {
String conStr = getShipmentGatewayConfigValue(delegator, shipmentGatewayConfigId, "connectUrl", resource, "shipment.dhl.connect.url");
if (conStr == null) {
throw new DhlConnectException(UtilProperties.getMessage(resourceError,
"FacilityShipmentDhlConnectUrlIncomplete", locale));
}
// xmlString should contain the auth document at the beginning
// all documents require an <?xml version="1.0"?> header
if (xmlString == null) {
throw new DhlConnectException(UtilProperties.getMessage(resourceError,
"FacilityShipmentDhlXmlCannotBeNull", locale));
}
// prepare the connect string
conStr = conStr.trim();
String timeOutStr = getShipmentGatewayConfigValue(delegator, shipmentGatewayConfigId, "connectTimeout",
resource, "shipment.dhl.connect.timeout", "60");
int timeout = 60;
try {
timeout = Integer.parseInt(timeOutStr);
} catch (NumberFormatException e) {
Debug.logError(e, "Unable to set timeout to " + timeOutStr + " using default " + timeout);
}
if (Debug.verboseOn()) {
Debug.logVerbose("DHL Connect URL : " + conStr, module);
Debug.logVerbose("DHL XML String : " + xmlString, module);
}
HttpClient http = new HttpClient(conStr);
http.setTimeout(timeout * 1000);
String response = null;
try {
response = http.post(xmlString);
} catch (HttpClientException e) {
Debug.logError(e, "Problem connecting with DHL server", module);
throw new DhlConnectException(UtilProperties.getMessage(resourceError,
"FacilityShipmentDhlConnectUrlProblem", UtilMisc.toMap("errorString", e), locale), e);
}
if (response == null) {
throw new DhlConnectException(UtilProperties.getMessage(resourceError,
"FacilityShipmentDhlReceivedNullResponse", locale));
}
if (Debug.verboseOn()) {
Debug.logVerbose("DHL Response : " + response, module);
}
return response;
}
/*
* Service to obtain a rate estimate from DHL for a shipment. Notes: Only one package per shipment currently supported by DHL ShipIT.
* If this service returns a null shippingEstimateAmount, then the shipment has not been processed
*/
public static Map<String, Object> dhlRateEstimate(DispatchContext dctx, Map<String, ? extends Object> context) {
Delegator delegator = dctx.getDelegator();
LocalDispatcher dispatcher = dctx.getDispatcher();
Locale locale = (Locale) context.get("locale");
// some of these can be refactored
String carrierPartyId = (String) context.get("carrierPartyId");
String shipmentMethodTypeId = (String) context.get("shipmentMethodTypeId");
String shippingContactMechId = (String) context.get("shippingContactMechId");
BigDecimal shippableWeight = (BigDecimal) context.get("shippableWeight");
if (shipmentMethodTypeId.equals("NO_SHIPPING")) {
Map<String, Object> result = ServiceUtil.returnSuccess();
result.put("shippingEstimateAmount", null);
return result;
}
// translate shipmentMethodTypeId to DHL service code
String dhlShipmentDetailCode = null;
try {
GenericValue carrierShipmentMethod = EntityQuery.use(delegator).from("CarrierShipmentMethod")
.where("shipmentMethodTypeId", shipmentMethodTypeId, "partyId", carrierPartyId, "roleTypeId", "CARRIER")
.queryOne();
if (carrierShipmentMethod == null) {
return ServiceUtil.returnError(UtilProperties.getMessage(resourceError,
"FacilityShipmentDhlNoCarrierShipmentMethod",
UtilMisc.toMap("carrierPartyId", carrierPartyId, "shipmentMethodTypeId", shipmentMethodTypeId), locale));
}
dhlShipmentDetailCode = carrierShipmentMethod.getString("carrierServiceCode");
} catch (GenericEntityException e) {
Debug.logError(e, "Failed to get rate estimate: " + e.getMessage(), module);
}
String resource = (String) context.get("serviceConfigProps");
String shipmentGatewayConfigId = (String) context.get("shipmentGatewayConfigId");
// shipping credentials (configured in properties)
String userid = getShipmentGatewayConfigValue(delegator, shipmentGatewayConfigId, "accessUserId", resource, "shipment.dhl.access.userid");
String password = getShipmentGatewayConfigValue(delegator, shipmentGatewayConfigId, "accessPassword", resource, "shipment.dhl.access.password");
String shippingKey = getShipmentGatewayConfigValue(delegator, shipmentGatewayConfigId, "accessShippingKey", resource, "shipment.dhl.access.shippingKey");
String accountNbr = getShipmentGatewayConfigValue(delegator, shipmentGatewayConfigId, "accessAccountNbr", resource, "shipment.dhl.access.accountNbr");
if ((shippingKey == null) || (accountNbr == null) || (shippingKey.length() == 0) || (accountNbr.length() == 0)) {
return ServiceUtil.returnError(UtilProperties.getMessage(resourceError,
"FacilityShipmentDhlGatewayNotAvailable", locale));
}
// obtain the ship-to address
GenericValue shipToAddress = null;
if (shippingContactMechId != null) {
try {
shipToAddress = EntityQuery.use(delegator).from("PostalAddress").where("contactMechId", shippingContactMechId).queryOne();
if (shipToAddress == null) {
return ServiceUtil.returnError(UtilProperties.getMessage(resourceError,
"FacilityShipmentUnableFoundShipToAddresss", locale));
}
}
catch (GenericEntityException e) {
Debug.logError(e, module);
}
}
if ((shippableWeight == null) || (shippableWeight.compareTo(BigDecimal.ZERO) <= 0)) {
String tmpValue = EntityUtilProperties.getPropertyValue(shipmentPropertiesFile, "shipment.default.weight.value", delegator);
if (tmpValue != null) {
try {
shippableWeight = new BigDecimal(tmpValue);
} catch (Exception e) {
return ServiceUtil.returnError(UtilProperties.getMessage(resourceError,
"FacilityShipmentDhlDefaultShippableWeightNotConfigured", locale));
}
}
}
// TODO: if a weight UOM is passed in, use convertUom service to convert it here
if (shippableWeight.compareTo(BigDecimal.ONE) < 0) {
Debug.logWarning("DHL Estimate: Weight is less than 1 lb, submitting DHL minimum of 1 lb for estimate.", module);
shippableWeight = BigDecimal.ONE;
}
if ((dhlShipmentDetailCode.equals("G") && shippableWeight.compareTo(new BigDecimal("999")) > 0) || (shippableWeight.compareTo(new BigDecimal("150")) > 0)) {
return ServiceUtil.returnError(UtilProperties.getMessage(resourceError,
"FacilityShipmentDhlShippableWeightExceed", locale));
}
String weight = (Integer.valueOf((int) shippableWeight.longValue())).toString();
// create AccessRequest XML doc using FreeMarker template
String templateName = getShipmentGatewayConfigValue(delegator, shipmentGatewayConfigId, "rateEstimateTemplate", resource, "shipment.dhl.template.rate.estimate");
if ((templateName == null) || (templateName.trim().length() == 0)) {
return ServiceUtil.returnError(UtilProperties.getMessage(resourceError,
"FacilityShipmentDhlShipmentTemplateLocationNotFound", locale));
}
StringWriter outWriter = new StringWriter();
Map<String, Object> inContext = new HashMap<String, Object>();
inContext.put("action", "RateEstimate");
inContext.put("userid", userid);
inContext.put("password", password);
inContext.put("accountNbr", accountNbr);
inContext.put("shippingKey", shippingKey);
inContext.put("shipDate", UtilDateTime.nowTimestamp());
inContext.put("dhlShipmentDetailCode", dhlShipmentDetailCode);
inContext.put("weight", weight);
inContext.put("state", shipToAddress.getString("stateProvinceGeoId"));
// DHL ShipIT API does not accept ZIP+4
if ((shipToAddress.getString("postalCode") != null) && (shipToAddress.getString("postalCode").length() > 5)) {
inContext.put("postalCode", shipToAddress.getString("postalCode").substring(0,5));
} else {
inContext.put("postalCode", shipToAddress.getString("postalCode"));
}
try {
ContentWorker.renderContentAsText(dispatcher, templateName, outWriter, inContext, locale, "text/plain", null, null, false);
} catch (Exception e) {
Debug.logError(e, "Cannot get DHL Estimate: Failed to render DHL XML Request.", module);
return ServiceUtil.returnError(UtilProperties.getMessage(resourceError,
"FacilityShipmentDhlShipmentTemplateError", locale));
}
String requestString = outWriter.toString();
if (Debug.verboseOn()) {
Debug.logVerbose(requestString, module);
}
// send the request
String rateResponseString = null;
try {
rateResponseString = sendDhlRequest(requestString, delegator, shipmentGatewayConfigId, resource, locale);
if (Debug.verboseOn()) {
Debug.logVerbose(rateResponseString, module);
}
}
catch (DhlConnectException e) {
String uceErrMsg = "Error sending DHL request for DHL Service Rate: " + e.toString();
Debug.logError(e, uceErrMsg, module);
return ServiceUtil.returnError(UtilProperties.getMessage(resourceError,
"FacilityShipmentDhlShipmentTemplateSendingError",
UtilMisc.toMap("errorString", e.toString()), locale));
}
Document rateResponseDocument = null;
try {
rateResponseDocument = UtilXml.readXmlDocument(rateResponseString, false);
return handleDhlRateResponse(rateResponseDocument, locale);
}
catch (SAXException e2) {
String excErrMsg = "Error parsing the RatingServiceResponse: " + e2.toString();
Debug.logError(e2, excErrMsg, module);
return ServiceUtil.returnError(UtilProperties.getMessage(resourceError,
"FacilityShipmentFedexShipmentTemplateParsingError",
UtilMisc.toMap("errorString", e2.toString()), locale));
}
catch (ParserConfigurationException e2) {
String excErrMsg = "Error parsing the RatingServiceResponse: " + e2.toString();
Debug.logError(e2, excErrMsg, module);
return ServiceUtil.returnError(UtilProperties.getMessage(resourceError,
"FacilityShipmentFedexShipmentTemplateParsingError",
UtilMisc.toMap("errorString", e2.toString()), locale));
}
catch (IOException e2) {
String excErrMsg = "Error parsing the RatingServiceResponse: " + e2.toString();
Debug.logError(e2, excErrMsg, module);
return ServiceUtil.returnError(UtilProperties.getMessage(resourceError,
"FacilityShipmentFedexShipmentTemplateParsingError",
UtilMisc.toMap("errorString", e2.toString()), locale));
}
}
/*
* Parses an XML document from DHL to get the rate estimate
*/
public static Map<String, Object> handleDhlRateResponse(Document rateResponseDocument, Locale locale) {
List<Object> errorList = new LinkedList<Object>();
Map<String, Object> dhlRateCodeMap = new HashMap<String, Object>();
// process RateResponse
Element rateResponseElement = rateResponseDocument.getDocumentElement();
DhlServices.handleErrors(rateResponseElement, errorList, locale);
if (UtilValidate.isNotEmpty(errorList)) {
return ServiceUtil.returnError(errorList);
}
// handle Response element info
Element responseElement = UtilXml.firstChildElement(rateResponseElement, "Shipment");
Element responseEstimateDetailElement = UtilXml.firstChildElement(responseElement, "EstimateDetail");
DhlServices.handleErrors(responseElement, errorList, locale);
if (UtilValidate.isNotEmpty(errorList)) {
return ServiceUtil.returnError(errorList);
}
String dateGenerated = UtilXml.childElementValue(
responseEstimateDetailElement, "DateGenerated");
Element responseServiceLevelCommitmentElement = UtilXml
.firstChildElement(responseEstimateDetailElement,
"ServiceLevelCommitment");
String responseServiceLevelCommitmentDescription = UtilXml
.childElementValue(responseServiceLevelCommitmentElement,
"Desc");
Element responseRateEstimateElement = UtilXml.firstChildElement(
responseEstimateDetailElement, "RateEstimate");
String responseTotalChargeEstimate = UtilXml.childElementValue(
responseRateEstimateElement, "TotalChargeEstimate");
Element responseChargesElement = UtilXml.firstChildElement(
responseRateEstimateElement, "Charges");
List<? extends Element> chargeNodeList = UtilXml.childElementList(responseChargesElement,
"Charge");
List<Map<String, String>> chargeList = new LinkedList<Map<String,String>>();
if (UtilValidate.isNotEmpty(chargeNodeList)) {
for (Element responseChargeElement: chargeNodeList) {
Map<String, String> charge = new HashMap<String, String>();
Element responseChargeTypeElement = UtilXml.firstChildElement(
responseChargeElement, "Type");
String responseChargeTypeCode = UtilXml.childElementValue(
responseChargeTypeElement, "Code");
String responseChargeTypeDesc = UtilXml.childElementValue(
responseChargeTypeElement, "Desc");
String responseChargeValue = UtilXml.childElementValue(
responseChargeElement, "Value");
charge.put("chargeTypeCode", responseChargeTypeCode);
charge.put("chargeTypeDesc", responseChargeTypeDesc);
charge.put("chargeValue", responseChargeValue);
chargeList.add(charge);
}
}
BigDecimal shippingEstimateAmount = new BigDecimal(responseTotalChargeEstimate);
dhlRateCodeMap.put("dateGenerated", dateGenerated);
dhlRateCodeMap.put("serviceLevelCommitment",
responseServiceLevelCommitmentDescription);
dhlRateCodeMap.put("totalChargeEstimate", responseTotalChargeEstimate);
dhlRateCodeMap.put("chargeList", chargeList);
Map<String, Object> result = ServiceUtil.returnSuccess();
result.put("shippingEstimateAmount", shippingEstimateAmount);
result.put("dhlRateCodeMap", dhlRateCodeMap);
return result;
}
/*
* Register a DHL account for shipping by obtaining the DHL shipping key
*/
public static Map<String, Object> dhlRegisterInquire(DispatchContext dctx, Map<String, ? extends Object> context) {
Delegator delegator = dctx.getDelegator();
String resource = (String) context.get("serviceConfigProps");
String shipmentGatewayConfigId = (String) context.get("shipmentGatewayConfigId");
Locale locale = (Locale) context.get("locale");
Map<String, Object> result = new HashMap<String, Object>();
String postalCode = (String) context.get("postalCode");
String accountNbr = getShipmentGatewayConfigValue(delegator, shipmentGatewayConfigId, "accessAccountNbr",
resource, "shipment.dhl.access.accountNbr");
if (accountNbr == null) {
return ServiceUtil.returnError(UtilProperties.getMessage(resourceError,
"FacilityShipmentDhlAccessAccountNbrMandotoryForRegisterAccount", locale));
}
// create AccessRequest XML doc
Document requestDocument = createAccessRequestDocument(delegator, shipmentGatewayConfigId, resource);
String requestString = null;
Element requesElement = requestDocument.getDocumentElement();
Element registerRequestElement = UtilXml.addChildElement(requesElement, "Register", requestDocument);
registerRequestElement.setAttribute("version", "1.0");
registerRequestElement.setAttribute("action", "ShippingKey");
UtilXml.addChildElementValue(registerRequestElement, "AccountNbr", accountNbr, requestDocument);
UtilXml.addChildElementValue(registerRequestElement, "PostalCode", postalCode, requestDocument);
try {
requestString = UtilXml.writeXmlDocument(requestDocument);
Debug.logInfo("AccessRequest XML Document:" + requestString, module);
} catch (IOException e) {
String ioeErrMsg = "Error writing the AccessRequest XML Document to a String: " + e.toString();
Debug.logError(e, ioeErrMsg, module);
return ServiceUtil.returnError(UtilProperties.getMessage(resourceError,
"FacilityShipmentDhlErrorAccessRequestXmlToString",
UtilMisc.toMap("errorString", e.toString()), locale));
}
// send the request
String registerResponseString = null;
try {
registerResponseString = sendDhlRequest(requestString, delegator, shipmentGatewayConfigId, resource, locale);
Debug.logInfo("DHL request for DHL Register Account:" + registerResponseString, module);
} catch (DhlConnectException e) {
String uceErrMsg = "Error sending DHL request for DHL Register Account: " + e.toString();
Debug.logError(e, uceErrMsg, module);
return ServiceUtil.returnError(UtilProperties.getMessage(resourceError,
"FacilityShipmentDhlErrorSendingRequestRegisterAccount",
UtilMisc.toMap("errorString", e.toString()), locale));
}
Document registerResponseDocument = null;
try {
registerResponseDocument = UtilXml.readXmlDocument(registerResponseString, false);
result = handleDhlRegisterResponse(registerResponseDocument, locale);
Debug.logInfo("DHL response for DHL Register Account:" + registerResponseString, module);
} catch (SAXException e2) {
String excErrMsg = "Error parsing the RegisterAccountServiceSelectionResponse: " + e2.toString();
Debug.logError(e2, excErrMsg, module);
return ServiceUtil.returnError(UtilProperties.getMessage(resourceError,
"FacilityShipmentDhlErrorParsingRegisterAccountResponse",
UtilMisc.toMap("errorString", e2.toString()), locale));
} catch (ParserConfigurationException e2) {
String excErrMsg = "Error parsing the RegisterAccountServiceSelectionResponse: " + e2.toString();
Debug.logError(e2, excErrMsg, module);
return ServiceUtil.returnError(UtilProperties.getMessage(resourceError,
"FacilityShipmentDhlErrorParsingRegisterAccountResponse",
UtilMisc.toMap("errorString", e2.toString()), locale));
} catch (IOException e2) {
String excErrMsg = "Error parsing the RegisterAccountServiceSelectionResponse: " + e2.toString();
Debug.logError(e2, excErrMsg, module);
return ServiceUtil.returnError(UtilProperties.getMessage(resourceError,
"FacilityShipmentDhlErrorParsingRegisterAccountResponse",
UtilMisc.toMap("errorString", e2.toString()), locale));
}
return result;
}
/*
* Parse response from DHL registration request to get shipping key
*/
public static Map<String, Object> handleDhlRegisterResponse(Document registerResponseDocument, Locale locale) {
List<Object> errorList = new LinkedList<Object>();
// process RegisterResponse
Element registerResponseElement = registerResponseDocument.getDocumentElement();
DhlServices.handleErrors(registerResponseElement, errorList, locale);
if (UtilValidate.isNotEmpty(errorList)) {
return ServiceUtil.returnError(errorList);
}
// handle Response element info
Element responseElement = UtilXml.firstChildElement(registerResponseElement, "Register");
DhlServices.handleErrors(responseElement, errorList, locale);
if (UtilValidate.isNotEmpty(errorList)) {
return ServiceUtil.returnError(errorList);
}
String responseShippingKey = UtilXml.childElementValue(responseElement,"ShippingKey");
Map<String, Object> result = ServiceUtil.returnSuccess();
result.put("shippingKey", responseShippingKey);
return result;
}
/*
* Pass a shipment request to DHL via ShipIT and get a tracking number and a label back, among other things
*/
public static Map<String, Object> dhlShipmentConfirm(DispatchContext dctx, Map<String, ? extends Object> context) {
Delegator delegator = dctx.getDelegator();
LocalDispatcher dispatcher = dctx.getDispatcher();
Locale locale = (Locale) context.get("locale");
GenericValue userLogin = (GenericValue) context.get("userLogin");
String shipmentId = (String) context.get("shipmentId");
String shipmentRouteSegmentId = (String) context.get("shipmentRouteSegmentId");
Map<String, Object> shipmentGatewayConfig = ShipmentServices.getShipmentGatewayConfigFromShipment(delegator, shipmentId, locale);
String shipmentGatewayConfigId = (String) shipmentGatewayConfig.get("shipmentGatewayConfigId");
String resource = (String) shipmentGatewayConfig.get("configProps");
if (UtilValidate.isEmpty(shipmentGatewayConfigId) && UtilValidate.isEmpty(resource)) {
return ServiceUtil.returnError(UtilProperties.getMessage(resourceError,
"FacilityShipmentDhlGatewayNotAvailable", locale));
}
try {
GenericValue shipment = EntityQuery.use(delegator).from("Shipment").where("shipmentId", shipmentId).queryOne();
if (shipment == null) {
return ServiceUtil.returnError(UtilProperties.getMessage(resourceError,
"ProductShipmentNotFoundId", locale) + shipmentId);
}
GenericValue shipmentRouteSegment = EntityQuery.use(delegator).from("ShipmentRouteSegment").where("shipmentId", shipmentId, "shipmentRouteSegmentId", shipmentRouteSegmentId).queryOne();
if (shipmentRouteSegment == null) {
return ServiceUtil.returnError(UtilProperties.getMessage(resourceError,
"ProductShipmentRouteSegmentNotFound",
UtilMisc.toMap("shipmentId", shipmentId, "shipmentRouteSegmentId", shipmentRouteSegmentId), locale));
}
if (!"DHL".equals(shipmentRouteSegment.getString("carrierPartyId"))) {
return ServiceUtil.returnError(UtilProperties.getMessage(resourceError,
"FacilityShipmentDhlNotRouteSegmentCarrier",
UtilMisc.toMap("shipmentRouteSegmentId", shipmentRouteSegmentId, "shipmentId", shipmentId), locale));
}
// add ShipmentRouteSegment carrierServiceStatusId, check before all DHL services
if (UtilValidate.isNotEmpty(shipmentRouteSegment.getString("carrierServiceStatusId")) && !"SHRSCS_NOT_STARTED".equals(shipmentRouteSegment.getString("carrierServiceStatusId"))) {
return ServiceUtil.returnError(UtilProperties.getMessage(resourceError,
"FacilityShipmentDhlRouteSegmentStatusNotStarted",
UtilMisc.toMap("shipmentRouteSegmentId", shipmentRouteSegmentId, "shipmentId", shipmentId,
"shipmentRouteSegmentStatus", shipmentRouteSegment.getString("carrierServiceStatusId")), locale));
}
// Get Origin Info
GenericValue originPostalAddress = shipmentRouteSegment.getRelatedOne("OriginPostalAddress", false);
if (originPostalAddress == null) {
return ServiceUtil.returnError(UtilProperties.getMessage(resourceError,
"FacilityShipmentRouteSegmentOriginPostalAddressNotFound",
UtilMisc.toMap("shipmentId", shipmentId, "shipmentRouteSegmentId", shipmentRouteSegmentId), locale));
}
GenericValue originTelecomNumber = shipmentRouteSegment.getRelatedOne("OriginTelecomNumber", false);
if (originTelecomNumber == null) {
return ServiceUtil.returnError(UtilProperties.getMessage(resourceError,
"FacilityShipmentRouteSegmentOriginTelecomNumberNotFound",
UtilMisc.toMap("shipmentId", shipmentId, "shipmentRouteSegmentId", shipmentRouteSegmentId), locale));
}
String originPhoneNumber = originTelecomNumber.getString("areaCode") + originTelecomNumber.getString("contactNumber");
// don't put on country code if not specified or is the US country code (UPS wants it this way and assuming DHL will accept this)
if (UtilValidate.isNotEmpty(originTelecomNumber.getString("countryCode")) && !"001".equals(originTelecomNumber.getString("countryCode"))) {
originPhoneNumber = originTelecomNumber.getString("countryCode") + originPhoneNumber;
}
originPhoneNumber = StringUtil.replaceString(originPhoneNumber, "-", "");
originPhoneNumber = StringUtil.replaceString(originPhoneNumber, " ", "");
// lookup the two letter country code (in the geoCode field)
GenericValue originCountryGeo = originPostalAddress.getRelatedOne("CountryGeo", false);
if (originCountryGeo == null) {
return ServiceUtil.returnError(UtilProperties.getMessage(resourceError,
"FacilityShipmentRouteSegmentOriginCountryGeoNotFound",
UtilMisc.toMap("shipmentId", shipmentId, "shipmentRouteSegmentId", shipmentRouteSegmentId), locale));
}
// Get Dest Info
GenericValue destPostalAddress = shipmentRouteSegment.getRelatedOne("DestPostalAddress", false);
if (destPostalAddress == null) {
return ServiceUtil.returnError(UtilProperties.getMessage(resourceError,
"FacilityShipmentRouteSegmentDestPostalAddressNotFound",
UtilMisc.toMap("shipmentId", shipmentId, "shipmentRouteSegmentId", shipmentRouteSegmentId), locale));
}
// DHL requires destination phone number, default to sender # if no customer number
String destPhoneNumber = originPhoneNumber;
GenericValue destTelecomNumber = shipmentRouteSegment.getRelatedOne("DestTelecomNumber", false);
if (destTelecomNumber != null) {
destPhoneNumber = destTelecomNumber.getString("areaCode") + destTelecomNumber.getString("contactNumber");
// don't put on country code if not specified or is the US country code (UPS wants it this way)
if (UtilValidate.isNotEmpty(destTelecomNumber.getString("countryCode")) && !"001".equals(destTelecomNumber.getString("countryCode"))) {
destPhoneNumber = destTelecomNumber.getString("countryCode") + destPhoneNumber;
}
destPhoneNumber = StringUtil.replaceString(destPhoneNumber, "-", "");
destPhoneNumber = StringUtil.replaceString(destPhoneNumber, " ", "");
}
String recipientEmail = null;
Map<String, Object> results = dispatcher.runSync("getPartyEmail", UtilMisc.toMap("partyId", shipment.get("partyIdTo"), "userLogin", userLogin));
if (results.get("emailAddress") != null) {
recipientEmail = (String) results.get("emailAddress");
}
// lookup the two letter country code (in the geoCode field)
GenericValue destCountryGeo = destPostalAddress.getRelatedOne("CountryGeo", false);
if (destCountryGeo == null) {
return ServiceUtil.returnError(UtilProperties.getMessage(resourceError,
"FacilityShipmentRouteSegmentDestCountryGeoNotFound",
UtilMisc.toMap("shipmentId", shipmentId, "shipmentRouteSegmentId", shipmentRouteSegmentId), locale));
}
List<GenericValue> shipmentPackageRouteSegs = shipmentRouteSegment.getRelated("ShipmentPackageRouteSeg", null, UtilMisc.toList("+shipmentPackageSeqId"), false);
if (UtilValidate.isEmpty(shipmentPackageRouteSegs)) {
return ServiceUtil.returnError(UtilProperties.getMessage(resourceError,
"FacilityShipmentPackageRouteSegsNotFound",
UtilMisc.toMap("shipmentId", shipmentId, "shipmentRouteSegmentId", shipmentRouteSegmentId), locale));
}
if (shipmentPackageRouteSegs.size() != 1) {
return ServiceUtil.returnError(UtilProperties.getMessage(resourceError,
"FacilityShipmentDhlMultiplePackagesNotSupported", locale));
}
// get the weight from the ShipmentRouteSegment first, which overrides all later weight computations
boolean hasBillingWeight = false; // for later overrides
BigDecimal billingWeight = shipmentRouteSegment.getBigDecimal("billingWeight");
String billingWeightUomId = shipmentRouteSegment.getString("billingWeightUomId");
if ((billingWeight != null) && (billingWeight.compareTo(BigDecimal.ZERO) > 0)) {
hasBillingWeight = true;
if (billingWeightUomId == null) {
Debug.logWarning("Shipment Route Segment missing billingWeightUomId in shipmentId " + shipmentId, module);
billingWeightUomId = "WT_lb"; // TODO: this should be specified in a properties file
}
// convert
results = dispatcher.runSync("convertUom", UtilMisc.<String, Object>toMap("uomId", billingWeightUomId, "uomIdTo", DHL_WEIGHT_UOM_ID, "originalValue", billingWeight));
if (ServiceUtil.isError(results) || (results.get("convertedValue") == null)) {
Debug.logWarning("Unable to convert billing weights for shipmentId " + shipmentId , module);
// try getting the weight from package instead
hasBillingWeight = false;
} else {
billingWeight = (BigDecimal) results.get("convertedValue");
}
}
// loop through Shipment segments (NOTE: only one supported, loop is here for future refactoring reference)
BigDecimal packageWeight = null;
for (GenericValue shipmentPackageRouteSeg: shipmentPackageRouteSegs) {
GenericValue shipmentPackage = shipmentPackageRouteSeg.getRelatedOne("ShipmentPackage", false);
GenericValue shipmentBoxType = shipmentPackage.getRelatedOne("ShipmentBoxType", false);
if (shipmentBoxType != null) {
// TODO: determine what default UoM is (assuming inches) - there should be a defaultDimensionUomId in Facility
}
// next step is weight determination, so skip if we have a billing weight
if (hasBillingWeight) continue;
// compute total packageWeight (for now, just one package)
if (shipmentPackage.getString("weight") != null) {
packageWeight = new BigDecimal(shipmentPackage.getString("weight"));
} else {
// use default weight if available
try {
packageWeight = EntityUtilProperties.getPropertyAsBigDecimal(shipmentPropertiesFile, "shipment.default.weight.value", BigDecimal.ZERO);
} catch (NumberFormatException ne) {
Debug.logWarning("Default shippable weight not configured (shipment.default.weight.value)", module);
packageWeight = BigDecimal.ONE;
}
}
// convert weight
String weightUomId = (String) shipmentPackage.get("weightUomId");
if (weightUomId == null) {
Debug.logWarning("Shipment Route Segment missing weightUomId in shipmentId " + shipmentId, module);
weightUomId = "WT_lb"; // TODO: this should be specified in a properties file
}
results = dispatcher.runSync("convertUom", UtilMisc.<String, Object>toMap("uomId", weightUomId, "uomIdTo", DHL_WEIGHT_UOM_ID, "originalValue", packageWeight));
if ((results == null) || (results.get(ModelService.RESPONSE_MESSAGE).equals(ModelService.RESPOND_ERROR)) || (results.get("convertedValue") == null)) {
Debug.logWarning("Unable to convert weights for shipmentId " + shipmentId , module);
packageWeight = BigDecimal.ONE;
} else {
packageWeight = (BigDecimal) results.get("convertedValue");
}
}
// pick which weight to use and round it
BigDecimal weight = null;
if (hasBillingWeight) {
weight = billingWeight;
} else {
weight = packageWeight;
}
// want the rounded weight as a string, so we use the "" + int shortcut
String roundedWeight = weight.setScale(0, BigDecimal.ROUND_HALF_UP).toPlainString();
// translate shipmentMethodTypeId to DHL service code
String shipmentMethodTypeId = shipmentRouteSegment.getString("shipmentMethodTypeId");
String dhlShipmentDetailCode = null;
GenericValue carrierShipmentMethod = EntityQuery.use(delegator).from("CarrierShipmentMethod")
.where("shipmentMethodTypeId", shipmentMethodTypeId, "partyId", "DHL", "roleTypeId", "CARRIER")
.queryOne();
if (carrierShipmentMethod == null) {
return ServiceUtil.returnError(UtilProperties.getMessage(resourceError,
"FacilityShipmentDhlNoCarrierShipmentMethod",
UtilMisc.toMap("carrierPartyId", "DHL", "shipmentMethodTypeId", shipmentMethodTypeId), locale));
}
dhlShipmentDetailCode = carrierShipmentMethod.getString("carrierServiceCode");
// shipping credentials (configured in properties)
String userid = getShipmentGatewayConfigValue(delegator, shipmentGatewayConfigId, "accessUserId", resource, "shipment.dhl.access.userid");
String password = getShipmentGatewayConfigValue(delegator, shipmentGatewayConfigId, "accessPassword", resource, "shipment.dhl.access.password");
String shippingKey = getShipmentGatewayConfigValue(delegator, shipmentGatewayConfigId, "accessShippingKey", resource, "shipment.dhl.access.shippingKey");
String accountNbr = getShipmentGatewayConfigValue(delegator, shipmentGatewayConfigId, "accessAccountNbr", resource, "shipment.dhl.access.accountNbr");
if ((shippingKey == null) || (accountNbr == null) || (shippingKey.length() == 0) || (accountNbr.length() == 0)) {
return ServiceUtil.returnError(UtilProperties.getMessage(resourceError,
"FacilityShipmentDhlGatewayNotAvailable", locale));
}
// label image preference (PNG or GIF)
String labelImagePreference = getShipmentGatewayConfigValue(delegator, shipmentGatewayConfigId, "labelImageFormat", resource, "shipment.dhl.label.image.format");
if (labelImagePreference == null) {
Debug.logInfo("shipment.dhl.label.image.format not specified, assuming PNG", module);
labelImagePreference="PNG";
} else if (!(labelImagePreference.equals("PNG") || labelImagePreference.equals("GIF"))) {
Debug.logError("Illegal shipment.dhl.label.image.format: " + labelImagePreference, module);
return ServiceUtil.returnError(UtilProperties.getMessage(resourceError,
"FacilityShipmentDhlUnknownLabelImageFormat",
UtilMisc.toMap("labelImagePreference", labelImagePreference), locale));
}
// create AccessRequest XML doc using FreeMarker template
String templateName = getShipmentGatewayConfigValue(delegator, shipmentGatewayConfigId, "rateEstimateTemplate", resource, "shipment.dhl.template.rate.estimate");
if ((templateName == null) || (templateName.trim().length() == 0)) {
return ServiceUtil.returnError(UtilProperties.getMessage(resourceError,
"FacilityShipmentDhlRateEstimateTemplateNotConfigured", locale));
}
StringWriter outWriter = new StringWriter();
Map<String, Object> inContext = new HashMap<String, Object>();
inContext.put("action", "GenerateLabel");
inContext.put("userid", userid);
inContext.put("password", password);
inContext.put("accountNbr", accountNbr);
inContext.put("shippingKey", shippingKey);
inContext.put("shipDate", UtilDateTime.nowTimestamp());
inContext.put("dhlShipmentDetailCode", dhlShipmentDetailCode);
inContext.put("weight", roundedWeight);
inContext.put("senderPhoneNbr", originPhoneNumber);
inContext.put("companyName", destPostalAddress.getString("toName"));
inContext.put("attnTo", destPostalAddress.getString("attnName"));
inContext.put("street", destPostalAddress.getString("address1"));
inContext.put("streetLine2", destPostalAddress.getString("address2"));
inContext.put("city", destPostalAddress.getString("city"));
inContext.put("state", destPostalAddress.getString("stateProvinceGeoId"));
// DHL ShipIT API does not accept ZIP+4
if ((destPostalAddress.getString("postalCode") != null) && (destPostalAddress.getString("postalCode").length() > 5)) {
inContext.put("postalCode", destPostalAddress.getString("postalCode").substring(0,5));
} else {
inContext.put("postalCode", destPostalAddress.getString("postalCode"));
}
inContext.put("phoneNbr", destPhoneNumber);
inContext.put("labelImageType", labelImagePreference);
inContext.put("shipperReference", shipment.getString("primaryOrderId") + "-" + shipment.getString("primaryShipGroupSeqId"));
inContext.put("notifyEmailAddress", recipientEmail);
try {
ContentWorker.renderContentAsText(dispatcher, templateName, outWriter, inContext, locale, "text/plain", null, null, false);
} catch (Exception e) {
Debug.logError(e, "Cannot confirm DHL shipment: Failed to render DHL XML Request.", module);
return ServiceUtil.returnError(UtilProperties.getMessage(resourceError,
"FacilityShipmentFedexRateTemplateRenderingError", locale));
}
String requestString = outWriter.toString();
if (Debug.verboseOn()) {
Debug.logVerbose(requestString, module);
}
// send the request
String responseString = null;
try {
responseString = sendDhlRequest(requestString, delegator, shipmentGatewayConfigId, resource, locale);
if (Debug.verboseOn()) {
Debug.logVerbose(responseString, module);
}
} catch (DhlConnectException e) {
String uceErrMsg = "Error sending DHL request for DHL Service Rate: " + e.toString();
Debug.logError(e, uceErrMsg, module);
return ServiceUtil.returnError(UtilProperties.getMessage(resourceError,
"FacilityShipmentFedexRateTemplateSendingError",
UtilMisc.toMap("errorString", e.toString()), locale));
}
// pass to handler method
return handleDhlShipmentConfirmResponse(responseString, shipmentRouteSegment, shipmentPackageRouteSegs, locale);
} catch (GenericEntityException e) {
Debug.logError(e, module);
return ServiceUtil.returnError(UtilProperties.getMessage(resourceError,
"FacilityShipmentFedexRateTemplateReadingError",
UtilMisc.toMap("errorString", e.toString()), locale));
} catch (GenericServiceException e) {
Debug.logError(e, module);
return ServiceUtil.returnError(UtilProperties.getMessage(resourceError,
"FacilityShipmentFedexRateTemplateReadingError",
UtilMisc.toMap("errorString", e.toString()), locale));
}
}
// NOTE: Must VOID shipments on errors
public static Map<String, Object> handleDhlShipmentConfirmResponse(String rateResponseString, GenericValue shipmentRouteSegment,
List<GenericValue> shipmentPackageRouteSegs, Locale locale) throws GenericEntityException {
GenericValue shipmentPackageRouteSeg = shipmentPackageRouteSegs.get(0);
// TODO: figure out how to handle validation on return XML, which can be mangled
// Ideas: try again right away, let user try again, etc.
Document rateResponseDocument = null;
try {
rateResponseDocument = UtilXml.readXmlDocument(rateResponseString, false);
} catch (SAXException e2) {
String excErrMsg = "Error parsing the RatingServiceSelectionResponse: " + e2.toString();
Debug.logError(e2, excErrMsg, module);
// TODO: VOID
} catch (ParserConfigurationException e2) {
String excErrMsg = "Error parsing the RatingServiceSelectionResponse: " + e2.toString();
Debug.logError(e2, excErrMsg, module);
// TODO VOID
} catch (IOException e2) {
String excErrMsg = "Error parsing the RatingServiceSelectionResponse: " + e2.toString();
Debug.logError(e2, excErrMsg, module);
// TODO VOID
}
// tracking number: Shipment/ShipmentDetail/AirbillNbr
Element rootElement = rateResponseDocument.getDocumentElement();
Element shipmentElement = UtilXml.firstChildElement(rootElement, "Shipment");
Element shipmentDetailElement = UtilXml.firstChildElement(shipmentElement, "ShipmentDetail");
String trackingNumber = UtilXml.childElementValue(shipmentDetailElement, "AirbillNbr");
// label: Shipment/Label/Image
Element labelElement = UtilXml.firstChildElement(shipmentElement, "Label");
String encodedImageString = UtilXml.childElementValue(labelElement, "Image");
if (encodedImageString == null) {
Debug.logError("Cannot find response DHL shipment label. Rate response document is: " + rateResponseString, module);
return ServiceUtil.returnError(UtilProperties.getMessage(resourceError,
"FacilityShipmentDhlShipmentLabelError",
UtilMisc.toMap("shipmentPackageRouteSeg", shipmentPackageRouteSeg,
"rateResponseString", rateResponseString), locale));
}
// TODO: this is a temporary hack to replace the newlines so that Base64 likes the input This is NOT platform independent
int size = encodedImageString.length();
StringBuilder sb = new StringBuilder();
for (int i = 0; i < size; i++) {
if (encodedImageString.charAt(i) == '\n')
continue;
sb.append(encodedImageString.charAt(i));
}
byte[] labelBytes = Base64.base64Decode(sb.toString().getBytes());
if (labelBytes != null) {
// store in db blob
shipmentPackageRouteSeg.setBytes("labelImage", labelBytes);
} else {
Debug.logInfo("Failed to either decode returned DHL label or no data found in eCommerce/Shipment/Label/Image.", module);
// TODO: VOID
}
shipmentPackageRouteSeg.set("trackingCode", trackingNumber);
shipmentPackageRouteSeg.set("labelHtml", sb.toString());
shipmentPackageRouteSeg.store();
shipmentRouteSegment.set("trackingIdNumber", trackingNumber);
shipmentRouteSegment.put("carrierServiceStatusId", "SHRSCS_CONFIRMED");
shipmentRouteSegment.store();
return ServiceUtil.returnSuccess(UtilProperties.getMessage(resourceError,
"FacilityShipmentDhlShipmentConfirmed", locale));
}
public static Document createAccessRequestDocument(Delegator delegator, String shipmentGatewayConfigId, String resource) {
Document eCommerceRequestDocument = UtilXml.makeEmptyXmlDocument("eCommerce");
Element eCommerceRequesElement = eCommerceRequestDocument.getDocumentElement();
eCommerceRequesElement.setAttribute("version", getShipmentGatewayConfigValue(delegator, shipmentGatewayConfigId, "headVersion", resource, "shipment.dhl.head.version"));
eCommerceRequesElement.setAttribute("action", getShipmentGatewayConfigValue(delegator, shipmentGatewayConfigId, "headAction", resource, "shipment.dhl.head.action"));
Element requestorRequestElement = UtilXml.addChildElement(eCommerceRequesElement, "Requestor", eCommerceRequestDocument);
UtilXml.addChildElementValue(requestorRequestElement, "ID", getShipmentGatewayConfigValue(delegator, shipmentGatewayConfigId, "accessUserId", resource, "shipment.dhl.access.userid"),
eCommerceRequestDocument);
UtilXml.addChildElementValue(requestorRequestElement, "Password", getShipmentGatewayConfigValue(delegator, shipmentGatewayConfigId, "accessPassword", resource, "shipment.dhl.access.password"),
eCommerceRequestDocument);
return eCommerceRequestDocument;
}
public static void handleErrors(Element responseElement, List<Object> errorList, Locale locale) {
Element faultsElement = UtilXml.firstChildElement(responseElement,
"Faults");
List<? extends Element> faultElements = UtilXml.childElementList(faultsElement, "Fault");
if (UtilValidate.isNotEmpty(faultElements)) {
for (Element errorElement: faultElements) {
StringBuilder errorMessageBuf = new StringBuilder();
String errorCode = UtilXml.childElementValue(errorElement, "Code");
String errorDescription = UtilXml.childElementValue(errorElement, "Desc");
String errorSource = UtilXml.childElementValue(errorElement, "Source");
if (UtilValidate.isEmpty(errorSource)) {
errorSource = UtilXml.childElementValue(errorElement, "Context");
}
errorMessageBuf.append(UtilProperties.getMessage(resourceError, "FacilityShipmentDhlErrorMessage",
UtilMisc.toMap("errorCode", errorCode, "errorDescription", errorDescription), locale));
if (UtilValidate.isNotEmpty(errorSource)) {
errorMessageBuf.append(UtilProperties.getMessage(resourceError,
"FacilityShipmentDhlErrorMessageElement",
UtilMisc.toMap("errorSource", errorSource), locale));
}
errorList.add(errorMessageBuf.toString());
}
}
}
private static String getShipmentGatewayConfigValue(Delegator delegator, String shipmentGatewayConfigId, String shipmentGatewayConfigParameterName,
String resource, String parameterName) {
String returnValue = "";
if (UtilValidate.isNotEmpty(shipmentGatewayConfigId)) {
try {
GenericValue dhl = EntityQuery.use(delegator).from("ShipmentGatewayDhl").where("shipmentGatewayConfigId", shipmentGatewayConfigId).queryOne();
if (UtilValidate.isNotEmpty(dhl)) {
Object dhlField = dhl.get(shipmentGatewayConfigParameterName);
if (dhlField != null) {
returnValue = dhlField.toString().trim();
}
}
} catch (GenericEntityException e) {
Debug.logError(e, module);
}
} else {
String value = EntityUtilProperties.getPropertyValue(resource, parameterName, delegator);
if (value != null) {
returnValue = value.trim();
}
}
return returnValue;
}
private static String getShipmentGatewayConfigValue(Delegator delegator, String shipmentGatewayConfigId, String shipmentGatewayConfigParameterName,
String resource, String parameterName, String defaultValue) {
String returnValue = getShipmentGatewayConfigValue(delegator, shipmentGatewayConfigId, shipmentGatewayConfigParameterName, resource, parameterName);
if (UtilValidate.isEmpty(returnValue)) {
returnValue = defaultValue;
}
return returnValue;
}
}
@SuppressWarnings("serial")
class DhlConnectException extends GeneralException {
DhlConnectException() {
super();
}
DhlConnectException(String msg) {
super(msg);
}
DhlConnectException(Throwable t) {
super(t);
}
DhlConnectException(String msg, Throwable t) {
super(msg, t);
}
}