/*******************************************************************************
* 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.party.contact;
import java.io.UnsupportedEncodingException;
import java.net.URLEncoder;
import java.util.Collection;
import java.util.HashMap;
import java.util.Iterator;
import java.util.LinkedList;
import java.util.List;
import java.util.Map;
import javax.servlet.ServletRequest;
import org.apache.ofbiz.base.util.Assert;
import org.apache.ofbiz.base.util.Debug;
import org.apache.ofbiz.base.util.UtilMisc;
import org.apache.ofbiz.base.util.UtilValidate;
import org.apache.ofbiz.entity.Delegator;
import org.apache.ofbiz.entity.GenericEntityException;
import org.apache.ofbiz.entity.GenericValue;
import org.apache.ofbiz.entity.condition.EntityCondition;
import org.apache.ofbiz.entity.util.EntityQuery;
import org.apache.ofbiz.entity.util.EntityUtil;
import org.apache.ofbiz.entity.util.EntityUtilProperties;
/**
* Worker methods for Contact Mechanisms
*/
public class ContactMechWorker {
public static final String module = ContactMechWorker.class.getName();
private ContactMechWorker() {}
public static List<Map<String, Object>> getPartyContactMechValueMaps(Delegator delegator, String partyId, boolean showOld) {
return getPartyContactMechValueMaps(delegator, partyId, showOld, null);
}
public static List<Map<String, Object>> getPartyContactMechValueMaps(Delegator delegator, String partyId, boolean showOld, String contactMechTypeId) {
List<Map<String, Object>> partyContactMechValueMaps = new LinkedList<Map<String,Object>>();
List<GenericValue> allPartyContactMechs = null;
try {
List<GenericValue> tempCol = EntityQuery.use(delegator).from("PartyContactMech").where("partyId", partyId).queryList();
if (contactMechTypeId != null) {
List<GenericValue> tempColTemp = new LinkedList<GenericValue>();
for (GenericValue partyContactMech: tempCol) {
GenericValue contactMech = delegator.getRelatedOne("ContactMech", partyContactMech, false);
if (contactMech != null && contactMechTypeId.equals(contactMech.getString("contactMechTypeId"))) {
tempColTemp.add(partyContactMech);
}
}
tempCol = tempColTemp;
}
if (!showOld) tempCol = EntityUtil.filterByDate(tempCol, true);
allPartyContactMechs = tempCol;
} catch (GenericEntityException e) {
Debug.logWarning(e, module);
}
if (allPartyContactMechs == null) return partyContactMechValueMaps;
for (GenericValue partyContactMech: allPartyContactMechs) {
GenericValue contactMech = null;
try {
contactMech = partyContactMech.getRelatedOne("ContactMech", false);
} catch (GenericEntityException e) {
Debug.logWarning(e, module);
}
if (contactMech != null) {
Map<String, Object> partyContactMechValueMap = new HashMap<String, Object>();
partyContactMechValueMaps.add(partyContactMechValueMap);
partyContactMechValueMap.put("contactMech", contactMech);
partyContactMechValueMap.put("partyContactMech", partyContactMech);
try {
partyContactMechValueMap.put("contactMechType", contactMech.getRelatedOne("ContactMechType", true));
} catch (GenericEntityException e) {
Debug.logWarning(e, module);
}
try {
List<GenericValue> partyContactMechPurposes = partyContactMech.getRelated("PartyContactMechPurpose", null, null, false);
if (!showOld) partyContactMechPurposes = EntityUtil.filterByDate(partyContactMechPurposes, true);
partyContactMechValueMap.put("partyContactMechPurposes", partyContactMechPurposes);
} catch (GenericEntityException e) {
Debug.logWarning(e, module);
}
try {
if ("POSTAL_ADDRESS".equals(contactMech.getString("contactMechTypeId"))) {
partyContactMechValueMap.put("postalAddress", contactMech.getRelatedOne("PostalAddress", false));
} else if ("TELECOM_NUMBER".equals(contactMech.getString("contactMechTypeId"))) {
partyContactMechValueMap.put("telecomNumber", contactMech.getRelatedOne("TelecomNumber", false));
}
} catch (GenericEntityException e) {
Debug.logWarning(e, module);
}
}
}
return partyContactMechValueMaps;
}
public static List<Map<String, Object>> getFacilityContactMechValueMaps(Delegator delegator, String facilityId, boolean showOld, String contactMechTypeId) {
List<Map<String, Object>> facilityContactMechValueMaps = new LinkedList<Map<String,Object>>();
List<GenericValue> allFacilityContactMechs = null;
try {
List<GenericValue> tempCol = EntityQuery.use(delegator).from("FacilityContactMech").where("facilityId", facilityId).queryList();
if (contactMechTypeId != null) {
List<GenericValue> tempColTemp = new LinkedList<GenericValue>();
for (GenericValue partyContactMech: tempCol) {
GenericValue contactMech = delegator.getRelatedOne("ContactMech", partyContactMech, false);
if (contactMech != null && contactMechTypeId.equals(contactMech.getString("contactMechTypeId"))) {
tempColTemp.add(partyContactMech);
}
}
tempCol = tempColTemp;
}
if (!showOld) tempCol = EntityUtil.filterByDate(tempCol, true);
allFacilityContactMechs = tempCol;
} catch (GenericEntityException e) {
Debug.logWarning(e, module);
}
if (allFacilityContactMechs == null) return facilityContactMechValueMaps;
for (GenericValue facilityContactMech: allFacilityContactMechs) {
GenericValue contactMech = null;
try {
contactMech = facilityContactMech.getRelatedOne("ContactMech", false);
} catch (GenericEntityException e) {
Debug.logWarning(e, module);
}
if (contactMech != null) {
Map<String, Object> facilityContactMechValueMap = new HashMap<String, Object>();
facilityContactMechValueMaps.add(facilityContactMechValueMap);
facilityContactMechValueMap.put("contactMech", contactMech);
facilityContactMechValueMap.put("facilityContactMech", facilityContactMech);
try {
facilityContactMechValueMap.put("contactMechType", contactMech.getRelatedOne("ContactMechType", true));
} catch (GenericEntityException e) {
Debug.logWarning(e, module);
}
try {
List<GenericValue> facilityContactMechPurposes = facilityContactMech.getRelated("FacilityContactMechPurpose", null, null, false);
if (!showOld) facilityContactMechPurposes = EntityUtil.filterByDate(facilityContactMechPurposes, true);
facilityContactMechValueMap.put("facilityContactMechPurposes", facilityContactMechPurposes);
} catch (GenericEntityException e) {
Debug.logWarning(e, module);
}
try {
if ("POSTAL_ADDRESS".equals(contactMech.getString("contactMechTypeId"))) {
facilityContactMechValueMap.put("postalAddress", contactMech.getRelatedOne("PostalAddress", false));
} else if ("TELECOM_NUMBER".equals(contactMech.getString("contactMechTypeId"))) {
facilityContactMechValueMap.put("telecomNumber", contactMech.getRelatedOne("TelecomNumber", false));
}
} catch (GenericEntityException e) {
Debug.logWarning(e, module);
}
}
}
return facilityContactMechValueMaps;
}
public static List<Map<String, GenericValue>> getOrderContactMechValueMaps(Delegator delegator, String orderId) {
List<Map<String, GenericValue>> orderContactMechValueMaps = new LinkedList<Map<String,GenericValue>>();
List<GenericValue> allOrderContactMechs = null;
try {
allOrderContactMechs = EntityQuery.use(delegator).from("OrderContactMech")
.where("orderId", orderId)
.orderBy("contactMechPurposeTypeId")
.queryList();
} catch (GenericEntityException e) {
Debug.logWarning(e, module);
}
if (allOrderContactMechs == null) return orderContactMechValueMaps;
for (GenericValue orderContactMech: allOrderContactMechs) {
GenericValue contactMech = null;
try {
contactMech = orderContactMech.getRelatedOne("ContactMech", false);
} catch (GenericEntityException e) {
Debug.logWarning(e, module);
}
if (contactMech != null) {
Map<String, GenericValue> orderContactMechValueMap = new HashMap<String, GenericValue>();
orderContactMechValueMaps.add(orderContactMechValueMap);
orderContactMechValueMap.put("contactMech", contactMech);
orderContactMechValueMap.put("orderContactMech", orderContactMech);
try {
orderContactMechValueMap.put("contactMechType", contactMech.getRelatedOne("ContactMechType", true));
} catch (GenericEntityException e) {
Debug.logWarning(e, module);
}
try {
GenericValue contactMechPurposeType = orderContactMech.getRelatedOne("ContactMechPurposeType", false);
orderContactMechValueMap.put("contactMechPurposeType", contactMechPurposeType);
} catch (GenericEntityException e) {
Debug.logWarning(e, module);
}
try {
if ("POSTAL_ADDRESS".equals(contactMech.getString("contactMechTypeId"))) {
orderContactMechValueMap.put("postalAddress", contactMech.getRelatedOne("PostalAddress", false));
} else if ("TELECOM_NUMBER".equals(contactMech.getString("contactMechTypeId"))) {
orderContactMechValueMap.put("telecomNumber", contactMech.getRelatedOne("TelecomNumber", false));
}
} catch (GenericEntityException e) {
Debug.logWarning(e, module);
}
}
}
return orderContactMechValueMaps;
}
public static Collection<Map<String, GenericValue>> getWorkEffortContactMechValueMaps(Delegator delegator, String workEffortId) {
Collection<Map<String, GenericValue>> workEffortContactMechValueMaps = new LinkedList<Map<String,GenericValue>>();
List<GenericValue> allWorkEffortContactMechs = null;
try {
allWorkEffortContactMechs = EntityQuery.use(delegator).from("WorkEffortContactMech")
.where("workEffortId", workEffortId)
.filterByDate()
.queryList();
} catch (GenericEntityException e) {
Debug.logWarning(e, module);
}
if (allWorkEffortContactMechs == null) return null;
for (GenericValue workEffortContactMech: allWorkEffortContactMechs) {
GenericValue contactMech = null;
try {
contactMech = workEffortContactMech.getRelatedOne("ContactMech", false);
} catch (GenericEntityException e) {
Debug.logWarning(e, module);
}
if (contactMech != null) {
Map<String, GenericValue> workEffortContactMechValueMap = new HashMap<String, GenericValue>();
workEffortContactMechValueMaps.add(workEffortContactMechValueMap);
workEffortContactMechValueMap.put("contactMech", contactMech);
workEffortContactMechValueMap.put("workEffortContactMech", workEffortContactMech);
try {
workEffortContactMechValueMap.put("contactMechType", contactMech.getRelatedOne("ContactMechType", true));
} catch (GenericEntityException e) {
Debug.logWarning(e, module);
}
try {
if ("POSTAL_ADDRESS".equals(contactMech.getString("contactMechTypeId"))) {
workEffortContactMechValueMap.put("postalAddress", contactMech.getRelatedOne("PostalAddress", false));
} else if ("TELECOM_NUMBER".equals(contactMech.getString("contactMechTypeId"))) {
workEffortContactMechValueMap.put("telecomNumber", contactMech.getRelatedOne("TelecomNumber", false));
}
} catch (GenericEntityException e) {
Debug.logWarning(e, module);
}
}
}
return workEffortContactMechValueMaps.size() > 0 ? workEffortContactMechValueMaps : null;
}
public static void getContactMechAndRelated(ServletRequest request, String partyId, Map<String, Object> target) {
Delegator delegator = (Delegator) request.getAttribute("delegator");
boolean tryEntity = true;
if (request.getAttribute("_ERROR_MESSAGE_") != null) tryEntity = false;
if ("true".equals(request.getParameter("tryEntity"))) tryEntity = true;
String donePage = request.getParameter("DONE_PAGE");
if (donePage == null) donePage = (String) request.getAttribute("DONE_PAGE");
if (UtilValidate.isEmpty(donePage)) donePage = "viewprofile";
target.put("donePage", donePage);
String contactMechTypeId = request.getParameter("preContactMechTypeId");
if (contactMechTypeId == null) contactMechTypeId = (String) request.getAttribute("preContactMechTypeId");
if (contactMechTypeId != null)
tryEntity = false;
String contactMechId = request.getParameter("contactMechId");
if (request.getAttribute("contactMechId") != null)
contactMechId = (String) request.getAttribute("contactMechId");
GenericValue contactMech = null;
if (contactMechId != null) {
target.put("contactMechId", contactMechId);
// try to find a PartyContactMech with a valid date range
List<GenericValue> partyContactMechs = null;
try {
partyContactMechs = EntityQuery.use(delegator).from("PartyContactMech")
.where("partyId", partyId, "contactMechId", contactMechId)
.filterByDate()
.queryList();
} catch (GenericEntityException e) {
Debug.logWarning(e, module);
}
GenericValue partyContactMech = EntityUtil.getFirst(partyContactMechs);
if (partyContactMech != null) {
target.put("partyContactMech", partyContactMech);
Collection<GenericValue> partyContactMechPurposes = null;
try {
partyContactMechPurposes = EntityUtil.filterByDate(partyContactMech.getRelated("PartyContactMechPurpose", null, null, false), true);
} catch (GenericEntityException e) {
Debug.logWarning(e, module);
}
if (UtilValidate.isNotEmpty(partyContactMechPurposes))
target.put("partyContactMechPurposes", partyContactMechPurposes);
}
try {
contactMech = EntityQuery.use(delegator).from("ContactMech").where("contactMechId", contactMechId).queryOne();
} catch (GenericEntityException e) {
Debug.logWarning(e, module);
}
if (contactMech != null) {
target.put("contactMech", contactMech);
contactMechTypeId = contactMech.getString("contactMechTypeId");
}
}
if (contactMechTypeId != null) {
target.put("contactMechTypeId", contactMechTypeId);
try {
GenericValue contactMechType = EntityQuery.use(delegator).from("ContactMechType").where("contactMechTypeId", contactMechTypeId).queryOne();
if (contactMechType != null)
target.put("contactMechType", contactMechType);
} catch (GenericEntityException e) {
Debug.logWarning(e, module);
}
Collection<GenericValue> purposeTypes = new LinkedList<GenericValue>();
Iterator<GenericValue> typePurposes = null;
try {
typePurposes = UtilMisc.toIterator(EntityQuery.use(delegator).from("ContactMechTypePurpose")
.where("contactMechTypeId", contactMechTypeId)
.queryList());
} catch (GenericEntityException e) {
Debug.logWarning(e, module);
}
while (typePurposes != null && typePurposes.hasNext()) {
GenericValue contactMechTypePurpose = typePurposes.next();
GenericValue contactMechPurposeType = null;
try {
contactMechPurposeType = contactMechTypePurpose.getRelatedOne("ContactMechPurposeType", false);
} catch (GenericEntityException e) {
Debug.logWarning(e, module);
}
if (contactMechPurposeType != null) {
purposeTypes.add(contactMechPurposeType);
}
}
if (purposeTypes.size() > 0)
target.put("purposeTypes", purposeTypes);
}
String requestName;
if (contactMech == null) {
// create
if ("POSTAL_ADDRESS".equals(contactMechTypeId)) {
if (request.getParameter("contactMechPurposeTypeId") != null || request.getAttribute("contactMechPurposeTypeId") != null) {
requestName = "createPostalAddressAndPurpose";
} else {
requestName = "createPostalAddress";
}
} else if ("TELECOM_NUMBER".equals(contactMechTypeId)) {
requestName = "createTelecomNumber";
} else if ("EMAIL_ADDRESS".equals(contactMechTypeId)) {
requestName = "createEmailAddress";
} else {
requestName = "createContactMech";
}
} else {
// update
if ("POSTAL_ADDRESS".equals(contactMechTypeId)) {
requestName = "updatePostalAddress";
} else if ("TELECOM_NUMBER".equals(contactMechTypeId)) {
requestName = "updateTelecomNumber";
} else if ("EMAIL_ADDRESS".equals(contactMechTypeId)) {
requestName = "updateEmailAddress";
} else {
requestName = "updateContactMech";
}
}
target.put("requestName", requestName);
if ("POSTAL_ADDRESS".equals(contactMechTypeId)) {
GenericValue postalAddress = null;
try {
if (contactMech != null) postalAddress = contactMech.getRelatedOne("PostalAddress", false);
} catch (GenericEntityException e) {
Debug.logWarning(e, module);
}
if (postalAddress != null) target.put("postalAddress", postalAddress);
} else if ("TELECOM_NUMBER".equals(contactMechTypeId)) {
GenericValue telecomNumber = null;
try {
if (contactMech != null) telecomNumber = contactMech.getRelatedOne("TelecomNumber", false);
} catch (GenericEntityException e) {
Debug.logWarning(e, module);
}
if (telecomNumber != null) target.put("telecomNumber", telecomNumber);
}
if ("true".equals(request.getParameter("useValues"))) tryEntity = true;
target.put("tryEntity", Boolean.valueOf(tryEntity));
try {
Collection<GenericValue> contactMechTypes = EntityQuery.use(delegator).from("ContactMechType").cache(true).queryList();
if (contactMechTypes != null) {
target.put("contactMechTypes", contactMechTypes);
}
} catch (GenericEntityException e) {
Debug.logWarning(e, module);
}
}
/** Returns the first valid FacilityContactMech found based on the given facilityId and a prioritized list of purposes
* @param delegator the delegator
* @param facilityId the facility id
* @param purposeTypes a List of ContactMechPurposeType ids which will be checked one at a time until a valid contact mech is found
* @return returns the first valid FacilityContactMech found based on the given facilityId and a prioritized list of purposes
*/
public static GenericValue getFacilityContactMechByPurpose(Delegator delegator, String facilityId, List<String> purposeTypes) {
if (UtilValidate.isEmpty(facilityId)) return null;
if (UtilValidate.isEmpty(purposeTypes)) return null;
for (String purposeType: purposeTypes) {
List<GenericValue> facilityContactMechPurposes = null;
List<EntityCondition> conditionList = new LinkedList<EntityCondition>();
conditionList.add(EntityCondition.makeCondition("facilityId", facilityId));
conditionList.add(EntityCondition.makeCondition("contactMechPurposeTypeId", purposeType));
EntityCondition entityCondition = EntityCondition.makeCondition(conditionList);
try {
facilityContactMechPurposes = EntityQuery.use(delegator).from("FacilityContactMechPurpose")
.where(entityCondition)
.orderBy("-fromDate")
.cache(true)
.filterByDate()
.queryList();
} catch (GenericEntityException e) {
Debug.logWarning(e, module);
continue;
}
for (GenericValue facilityContactMechPurpose: facilityContactMechPurposes) {
String contactMechId = facilityContactMechPurpose.getString("contactMechId");
List<GenericValue> facilityContactMechs = null;
conditionList = new LinkedList<EntityCondition>();
conditionList.add(EntityCondition.makeCondition("facilityId", facilityId));
conditionList.add(EntityCondition.makeCondition("contactMechId", contactMechId));
entityCondition = EntityCondition.makeCondition(conditionList);
try {
facilityContactMechs = EntityQuery.use(delegator).from("FacilityContactMech")
.where(entityCondition)
.orderBy("-fromDate")
.cache(true)
.filterByDate()
.queryList();
} catch (GenericEntityException e) {
Debug.logWarning(e, module);
}
if (UtilValidate.isNotEmpty(facilityContactMechs)) {
return EntityUtil.getFirst(facilityContactMechs);
}
}
}
return null;
}
public static void getFacilityContactMechAndRelated(ServletRequest request, String facilityId, Map<String, Object> target) {
Delegator delegator = (Delegator) request.getAttribute("delegator");
boolean tryEntity = true;
if (request.getAttribute("_ERROR_MESSAGE") != null) tryEntity = false;
if ("true".equals(request.getParameter("tryEntity"))) tryEntity = true;
String donePage = request.getParameter("DONE_PAGE");
if (donePage == null) donePage = (String) request.getAttribute("DONE_PAGE");
if (UtilValidate.isEmpty(donePage)) donePage = "viewprofile";
target.put("donePage", donePage);
String contactMechTypeId = request.getParameter("preContactMechTypeId");
if (contactMechTypeId == null) contactMechTypeId = (String) request.getAttribute("preContactMechTypeId");
if (contactMechTypeId != null)
tryEntity = false;
String contactMechId = request.getParameter("contactMechId");
if (request.getAttribute("contactMechId") != null)
contactMechId = (String) request.getAttribute("contactMechId");
GenericValue contactMech = null;
if (contactMechId != null) {
target.put("contactMechId", contactMechId);
// try to find a PartyContactMech with a valid date range
List<GenericValue> facilityContactMechs = null;
try {
facilityContactMechs = EntityQuery.use(delegator).from("FacilityContactMech")
.where("facilityId", facilityId, "contactMechId", contactMechId)
.filterByDate()
.queryList();
} catch (GenericEntityException e) {
Debug.logWarning(e, module);
}
GenericValue facilityContactMech = EntityUtil.getFirst(facilityContactMechs);
if (facilityContactMech != null) {
target.put("facilityContactMech", facilityContactMech);
Collection<GenericValue> facilityContactMechPurposes = null;
try {
facilityContactMechPurposes = EntityUtil.filterByDate(facilityContactMech.getRelated("FacilityContactMechPurpose", null, null, false), true);
} catch (GenericEntityException e) {
Debug.logWarning(e, module);
}
if (UtilValidate.isNotEmpty(facilityContactMechPurposes))
target.put("facilityContactMechPurposes", facilityContactMechPurposes);
}
try {
contactMech = EntityQuery.use(delegator).from("ContactMech").where("contactMechId", contactMechId).queryOne();
} catch (GenericEntityException e) {
Debug.logWarning(e, module);
}
if (contactMech != null) {
target.put("contactMech", contactMech);
contactMechTypeId = contactMech.getString("contactMechTypeId");
}
}
if (contactMechTypeId != null) {
target.put("contactMechTypeId", contactMechTypeId);
try {
GenericValue contactMechType = EntityQuery.use(delegator).from("ContactMechType").where("contactMechTypeId", contactMechTypeId).queryOne();
if (contactMechType != null)
target.put("contactMechType", contactMechType);
} catch (GenericEntityException e) {
Debug.logWarning(e, module);
}
Collection<GenericValue> purposeTypes = new LinkedList<GenericValue>();
Iterator<GenericValue> typePurposes = null;
try {
typePurposes = UtilMisc.toIterator(EntityQuery.use(delegator).from("ContactMechTypePurpose")
.where("contactMechTypeId", contactMechTypeId)
.queryList());
} catch (GenericEntityException e) {
Debug.logWarning(e, module);
}
while (typePurposes != null && typePurposes.hasNext()) {
GenericValue contactMechTypePurpose = typePurposes.next();
GenericValue contactMechPurposeType = null;
try {
contactMechPurposeType = contactMechTypePurpose.getRelatedOne("ContactMechPurposeType", false);
} catch (GenericEntityException e) {
Debug.logWarning(e, module);
}
if (contactMechPurposeType != null) {
purposeTypes.add(contactMechPurposeType);
}
}
if (purposeTypes.size() > 0)
target.put("purposeTypes", purposeTypes);
}
String requestName;
if (contactMech == null) {
// create
if ("POSTAL_ADDRESS".equals(contactMechTypeId)) {
if (request.getParameter("contactMechPurposeTypeId") != null || request.getAttribute("contactMechPurposeTypeId") != null) {
requestName = "createPostalAddressAndPurpose";
} else {
requestName = "createPostalAddress";
}
} else if ("TELECOM_NUMBER".equals(contactMechTypeId)) {
requestName = "createTelecomNumber";
} else if ("EMAIL_ADDRESS".equals(contactMechTypeId)) {
requestName = "createEmailAddress";
} else {
requestName = "createContactMech";
}
} else {
// update
if ("POSTAL_ADDRESS".equals(contactMechTypeId)) {
requestName = "updatePostalAddress";
} else if ("TELECOM_NUMBER".equals(contactMechTypeId)) {
requestName = "updateTelecomNumber";
} else if ("EMAIL_ADDRESS".equals(contactMechTypeId)) {
requestName = "updateEmailAddress";
} else {
requestName = "updateContactMech";
}
}
target.put("requestName", requestName);
if ("POSTAL_ADDRESS".equals(contactMechTypeId)) {
GenericValue postalAddress = null;
try {
if (contactMech != null) postalAddress = contactMech.getRelatedOne("PostalAddress", false);
} catch (GenericEntityException e) {
Debug.logWarning(e, module);
}
if (postalAddress != null) target.put("postalAddress", postalAddress);
} else if ("TELECOM_NUMBER".equals(contactMechTypeId)) {
GenericValue telecomNumber = null;
try {
if (contactMech != null) telecomNumber = contactMech.getRelatedOne("TelecomNumber", false);
} catch (GenericEntityException e) {
Debug.logWarning(e, module);
}
if (telecomNumber != null) target.put("telecomNumber", telecomNumber);
}
if ("true".equals(request.getParameter("useValues"))) tryEntity = true;
target.put("tryEntity", Boolean.valueOf(tryEntity));
try {
Collection<GenericValue> contactMechTypes = EntityQuery.use(delegator).from("ContactMechType").cache(true).queryList();
if (contactMechTypes != null) {
target.put("contactMechTypes", contactMechTypes);
}
} catch (GenericEntityException e) {
Debug.logWarning(e, module);
}
}
public static List<Map<String, Object>> getPartyPostalAddresses(ServletRequest request, String partyId, String curContactMechId) {
Delegator delegator = (Delegator) request.getAttribute("delegator");
List<Map<String, Object>> postalAddressInfos = new LinkedList<Map<String,Object>>();
List<GenericValue> allPartyContactMechs = null;
try {
allPartyContactMechs = EntityQuery.use(delegator).from("PartyContactMech").where("partyId", partyId).filterByDate().queryList();
} catch (GenericEntityException e) {
Debug.logWarning(e, module);
}
if (allPartyContactMechs == null) return postalAddressInfos;
for (GenericValue partyContactMech: allPartyContactMechs) {
GenericValue contactMech = null;
try {
contactMech = partyContactMech.getRelatedOne("ContactMech", false);
} catch (GenericEntityException e) {
Debug.logWarning(e, module);
}
if (contactMech != null && "POSTAL_ADDRESS".equals(contactMech.getString("contactMechTypeId")) && !contactMech.getString("contactMechId").equals(curContactMechId)) {
Map<String, Object> postalAddressInfo = new HashMap<String, Object>();
postalAddressInfos.add(postalAddressInfo);
postalAddressInfo.put("contactMech", contactMech);
postalAddressInfo.put("partyContactMech", partyContactMech);
try {
GenericValue postalAddress = contactMech.getRelatedOne("PostalAddress", false);
postalAddressInfo.put("postalAddress", postalAddress);
} catch (GenericEntityException e) {
Debug.logWarning(e, module);
}
try {
List<GenericValue> partyContactMechPurposes = EntityUtil.filterByDate(partyContactMech.getRelated("PartyContactMechPurpose", null, null, false), true);
postalAddressInfo.put("partyContactMechPurposes", partyContactMechPurposes);
} catch (GenericEntityException e) {
Debug.logWarning(e, module);
}
}
}
return postalAddressInfos;
}
public static Map<String, Object> getCurrentPostalAddress(ServletRequest request, String partyId, String curContactMechId) {
Delegator delegator = (Delegator) request.getAttribute("delegator");
Map<String, Object> results = new HashMap<String, Object>();
if (curContactMechId != null) {
List<GenericValue> partyContactMechs = null;
try {
partyContactMechs = EntityQuery.use(delegator).from("PartyContactMech")
.where("partyId", partyId, "contactMechId", curContactMechId)
.filterByDate()
.queryList();
} catch (GenericEntityException e) {
Debug.logWarning(e, module);
}
GenericValue curPartyContactMech = EntityUtil.getFirst(partyContactMechs);
results.put("curPartyContactMech", curPartyContactMech);
GenericValue curContactMech = null;
if (curPartyContactMech != null) {
try {
curContactMech = curPartyContactMech.getRelatedOne("ContactMech", false);
} catch (GenericEntityException e) {
Debug.logWarning(e, module);
}
Collection<GenericValue> curPartyContactMechPurposes = null;
try {
curPartyContactMechPurposes = EntityUtil.filterByDate(curPartyContactMech.getRelated("PartyContactMechPurpose", null, null, false), true);
} catch (GenericEntityException e) {
Debug.logWarning(e, module);
}
results.put("curPartyContactMechPurposes", curPartyContactMechPurposes);
}
results.put("curContactMech", curContactMech);
GenericValue curPostalAddress = null;
if (curContactMech != null) {
try {
curPostalAddress = curContactMech.getRelatedOne("PostalAddress", false);
} catch (GenericEntityException e) {
Debug.logWarning(e, module);
}
}
results.put("curPostalAddress", curPostalAddress);
}
return results;
}
public static boolean isUspsAddress(GenericValue postalAddress) {
if (postalAddress == null) {
// null postal address is not a USPS address
return false;
}
if (!"PostalAddress".equals(postalAddress.getEntityName())) {
// not a postal address not a USPS address
return false;
}
// get and clean the address strings
String addr1 = postalAddress.getString("address1");
String addr2 = postalAddress.getString("address2");
// get the matching string from general.properties
String matcher = EntityUtilProperties.getPropertyValue("general", "usps.address.match", postalAddress.getDelegator());
if (UtilValidate.isNotEmpty(matcher)) {
if (addr1 != null && addr1.toLowerCase().matches(matcher)) {
return true;
}
if (addr2 != null && addr2.toLowerCase().matches(matcher)) {
return true;
}
}
return false;
}
public static boolean isCompanyAddress(GenericValue postalAddress, String companyPartyId) {
if (postalAddress == null) {
// null postal address is not an internal address
return false;
}
if (!"PostalAddress".equals(postalAddress.getEntityName())) {
// not a postal address not an internal address
return false;
}
if (companyPartyId == null) {
// no partyId not an internal address
return false;
}
String state = postalAddress.getString("stateProvinceGeoId");
String addr1 = postalAddress.getString("address1");
String addr2 = postalAddress.getString("address2");
if (state != null) {
state = state.replaceAll("\\W", "").toLowerCase();
} else {
state = "";
}
if (addr1 != null) {
addr1 = addr1.replaceAll("\\W", "").toLowerCase();
} else {
addr1 = "";
}
if (addr2 != null) {
addr2 = addr2.replaceAll("\\W", "").toLowerCase();
} else {
addr2 = "";
}
// get all company addresses
Delegator delegator = postalAddress.getDelegator();
List<GenericValue> postalAddresses = new LinkedList<GenericValue>();
try {
List<GenericValue> partyContactMechs = EntityQuery.use(delegator).from("PartyContactMech")
.where("partyId", companyPartyId)
.filterByDate()
.queryList();
if (partyContactMechs != null) {
for (GenericValue pcm: partyContactMechs) {
GenericValue addr = pcm.getRelatedOne("PostalAddress", false);
if (addr != null) {
postalAddresses.add(addr);
}
}
}
} catch (GenericEntityException e) {
Debug.logError(e, "Unable to get party postal addresses", module);
}
if (postalAddresses != null) {
for (GenericValue addr: postalAddresses) {
String thisAddr1 = addr.getString("address1");
String thisAddr2 = addr.getString("address2");
String thisState = addr.getString("stateProvinceGeoId");
if (thisState != null) {
thisState = thisState.replaceAll("\\W", "").toLowerCase();
} else {
thisState = "";
}
if (thisAddr1 != null) {
thisAddr1 = thisAddr1.replaceAll("\\W", "").toLowerCase();
} else {
thisAddr1 = "";
}
if (thisAddr2 != null) {
thisAddr2 = thisAddr2.replaceAll("\\W", "").toLowerCase();
} else {
thisAddr2 = "";
}
if (thisAddr1.equals(addr1) && thisAddr2.equals(addr2) && thisState.equals(state)) {
return true;
}
}
}
return false;
}
public static String getContactMechAttribute(Delegator delegator, String contactMechId, String attrName) {
GenericValue attr = null;
try {
attr = EntityQuery.use(delegator).from("ContactMechAttribute").where("contactMechId", contactMechId, "attrName", attrName).queryOne();
} catch (GenericEntityException e) {
Debug.logError(e, module);
}
if (attr == null) {
return null;
} else {
return attr.getString("attrValue");
}
}
public static String getPostalAddressPostalCodeGeoId(GenericValue postalAddress, Delegator delegator) throws GenericEntityException {
// if postalCodeGeoId not empty use that
if (UtilValidate.isNotEmpty(postalAddress.getString("postalCodeGeoId"))) {
return postalAddress.getString("postalCodeGeoId");
}
// no postalCodeGeoId, see if there is a Geo record matching the countryGeoId and postalCode fields
if (UtilValidate.isNotEmpty(postalAddress.getString("countryGeoId")) && UtilValidate.isNotEmpty(postalAddress.getString("postalCode"))) {
// first try the shortcut with the geoId convention for "{countryGeoId}-{postalCode}"
GenericValue geo = EntityQuery.use(delegator).from("Geo").where("geoId", postalAddress.getString("countryGeoId") + "-" + postalAddress.getString("postalCode")).cache().queryOne();
if (geo != null) {
// save the value to the database for quicker future reference
if (postalAddress.isMutable()) {
postalAddress.set("postalCodeGeoId", geo.getString("geoId"));
postalAddress.store();
} else {
GenericValue mutablePostalAddress = EntityQuery.use(delegator).from("PostalAddress").where("contactMechId", postalAddress.getString("contactMechId")).queryOne();
mutablePostalAddress.set("postalCodeGeoId", geo.getString("geoId"));
mutablePostalAddress.store();
}
return geo.getString("geoId");
}
// no shortcut, try the longcut to see if there is something with a geoCode associated to the countryGeoId
GenericValue geoAssocAndGeoTo = EntityQuery.use(delegator).from("GeoAssocAndGeoTo")
.where("geoIdFrom", postalAddress.getString("countryGeoId"), "geoCode", postalAddress.getString("postalCode"), "geoAssocTypeId", "REGIONS")
.cache(true)
.queryFirst();
if (geoAssocAndGeoTo != null) {
// save the value to the database for quicker future reference
if (postalAddress.isMutable()) {
postalAddress.set("postalCodeGeoId", geoAssocAndGeoTo.getString("geoId"));
postalAddress.store();
} else {
GenericValue mutablePostalAddress = EntityQuery.use(delegator).from("PostalAddress").where("contactMechId", postalAddress.getString("contactMechId")).queryOne();
mutablePostalAddress.set("postalCodeGeoId", geoAssocAndGeoTo.getString("geoId"));
mutablePostalAddress.store();
}
return geoAssocAndGeoTo.getString("geoId");
}
}
// nothing found, return null
return null;
}
/**
* Returns a <b>PostalAddress</b> <code>GenericValue</code> as a URL encoded <code>String</code>.
*
* @param postalAddress A <b>PostalAddress</b> <code>GenericValue</code>.
* @return A URL encoded <code>String</code>.
* @throws GenericEntityException
* @throws UnsupportedEncodingException
*/
public static String urlEncodePostalAddress(GenericValue postalAddress) throws GenericEntityException, UnsupportedEncodingException {
Assert.notNull("postalAddress", postalAddress);
if (!"PostalAddress".equals(postalAddress.getEntityName())) {
throw new IllegalArgumentException("postalAddress argument is not a PostalAddress entity");
}
StringBuilder sb = new StringBuilder();
if (postalAddress.get("address1") != null) {
sb.append(postalAddress.get("address1"));
}
if (postalAddress.get("address2") != null) {
sb.append(", ").append(postalAddress.get("address2"));
}
if (postalAddress.get("city") != null) {
sb.append(", ").append(postalAddress.get("city"));
}
if (postalAddress.get("stateProvinceGeoId") != null) {
GenericValue geoValue = postalAddress.getRelatedOne("StateProvinceGeo", false);
if (geoValue != null) {
sb.append(", ").append(geoValue.get("geoName"));
}
} else if (postalAddress.get("countyGeoId") != null) {
GenericValue geoValue = postalAddress.getRelatedOne("CountyGeo", false);
if (geoValue != null) {
sb.append(", ").append(geoValue.get("geoName"));
}
}
if (postalAddress.get("postalCode") != null) {
sb.append(", ").append(postalAddress.get("postalCode"));
}
if (postalAddress.get("countryGeoId") != null) {
GenericValue geoValue = postalAddress.getRelatedOne("CountryGeo", false);
if (geoValue != null) {
sb.append(", ").append(geoValue.get("geoName"));
}
}
String postalAddressString = sb.toString().trim();
while (postalAddressString.contains(" ")) {
postalAddressString = postalAddressString.replace(" ", " ");
}
return URLEncoder.encode(postalAddressString, "UTF-8");
}
}