| /* |
| * 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.party; |
| |
| import java.sql.Timestamp; |
| import java.util.HashMap; |
| import java.util.LinkedList; |
| import java.util.List; |
| import java.util.Locale; |
| import java.util.Map; |
| |
| import javax.servlet.ServletRequest; |
| |
| import org.apache.ofbiz.base.util.Debug; |
| import org.apache.ofbiz.base.util.GeneralException; |
| import org.apache.ofbiz.base.util.UtilFormatOut; |
| 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.condition.EntityConditionList; |
| import org.apache.ofbiz.entity.condition.EntityExpr; |
| import org.apache.ofbiz.entity.condition.EntityFunction; |
| import org.apache.ofbiz.entity.condition.EntityOperator; |
| import org.apache.ofbiz.entity.model.ModelEntity; |
| import org.apache.ofbiz.entity.util.EntityQuery; |
| import org.apache.ofbiz.entity.util.EntityUtil; |
| |
| /** |
| * Worker methods for Party Information |
| */ |
| public class PartyWorker { |
| |
| public static String module = PartyWorker.class.getName(); |
| |
| private PartyWorker() {} |
| |
| public static Map<String, GenericValue> getPartyOtherValues(ServletRequest request, String partyId, String partyAttr, String personAttr, String partyGroupAttr) { |
| Delegator delegator = (Delegator) request.getAttribute("delegator"); |
| Map<String, GenericValue> result = new HashMap<String, GenericValue>(); |
| try { |
| GenericValue party = EntityQuery.use(delegator).from("Party").where("partyId", partyId).queryOne(); |
| |
| if (party != null) |
| result.put(partyAttr, party); |
| } catch (GenericEntityException e) { |
| Debug.logWarning(e, "Problems getting Party entity", module); |
| } |
| |
| try { |
| GenericValue person = EntityQuery.use(delegator).from("Person").where("partyId", partyId).queryOne(); |
| |
| if (person != null) |
| result.put(personAttr, person); |
| } catch (GenericEntityException e) { |
| Debug.logWarning(e, "Problems getting Person entity", module); |
| } |
| |
| try { |
| GenericValue partyGroup = EntityQuery.use(delegator).from("PartyGroup").where("partyId", partyId).queryOne(); |
| |
| if (partyGroup != null) |
| result.put(partyGroupAttr, partyGroup); |
| } catch (GenericEntityException e) { |
| Debug.logWarning(e, "Problems getting PartyGroup entity", module); |
| } |
| return result; |
| } |
| |
| /** |
| * Generate a sequenced club id using the prefix passed and a sequence value + check digit |
| * @param delegator used to obtain a sequenced value |
| * @param prefix prefix inserted at the beginning of the ID |
| * @param length total length of the ID including prefix and check digit |
| * @return Sequenced Club ID string with a length as defined starting with the prefix defined |
| */ |
| public static String createClubId(Delegator delegator, String prefix, int length) { |
| final String clubSeqName = "PartyClubSeq"; |
| String clubId = prefix != null ? prefix : ""; |
| |
| // generate the sequenced number and pad |
| Long seq = delegator.getNextSeqIdLong(clubSeqName); |
| clubId = clubId + UtilFormatOut.formatPaddedNumber(seq.longValue(), (length - clubId.length() - 1)); |
| |
| // get the check digit |
| int check = UtilValidate.getLuhnCheckDigit(clubId); |
| clubId = clubId + Integer.toString(check); |
| |
| return clubId; |
| } |
| |
| public static GenericValue findPartyLatestContactMech(String partyId, String contactMechTypeId, Delegator delegator) { |
| try { |
| return EntityQuery.use(delegator).from("PartyAndContactMech") |
| .where("partyId", partyId, "contactMechTypeId", contactMechTypeId) |
| .orderBy("-fromDate") |
| .filterByDate() |
| .queryFirst(); |
| } catch (GenericEntityException e) { |
| Debug.logError(e, "Error while finding latest ContactMech for party with ID [" + partyId + "] TYPE [" + contactMechTypeId + "]: " + e.toString(), module); |
| return null; |
| } |
| } |
| |
| public static GenericValue findPartyLatestPostalAddress(String partyId, Delegator delegator) { |
| GenericValue pcm = findPartyLatestContactMech(partyId, "POSTAL_ADDRESS", delegator); |
| if (pcm != null) { |
| try { |
| return pcm.getRelatedOne("PostalAddress", false); |
| } catch (GenericEntityException e) { |
| Debug.logError(e, "Error while finding latest PostalAddress for party with ID [" + partyId + "]: " + e.toString(), module); |
| } |
| } |
| return null; |
| } |
| |
| public static GenericValue findPartyLatestPostalAddressGeoPoint(String partyId, Delegator delegator) { |
| GenericValue latestPostalAddress = findPartyLatestPostalAddress(partyId, delegator); |
| if (latestPostalAddress != null) { |
| try { |
| GenericValue latestGeoPoint = latestPostalAddress.getRelatedOne("GeoPoint", false); |
| if (latestGeoPoint != null) { |
| return latestGeoPoint; |
| } |
| return null; |
| } catch (GenericEntityException e) { |
| Debug.logError(e, "Error while finding latest GeoPoint for party with ID [" + partyId + "]: " + e.toString(), module); |
| } |
| } |
| return null; |
| } |
| |
| public static GenericValue findPartyLatestTelecomNumber(String partyId, Delegator delegator) { |
| GenericValue pcm = findPartyLatestContactMech(partyId, "TELECOM_NUMBER", delegator); |
| if (pcm != null) { |
| try { |
| return pcm.getRelatedOne("TelecomNumber", false); |
| } catch (GenericEntityException e) { |
| Debug.logError(e, "Error while finding latest TelecomNumber for party with ID [" + partyId + "]: " + e.toString(), module); |
| } |
| } |
| return null; |
| } |
| |
| public static GenericValue findPartyLatestUserLogin(String partyId, Delegator delegator) { |
| try { |
| return EntityQuery.use(delegator).from("UserLogin").where("partyId", partyId).orderBy("-" + ModelEntity.STAMP_FIELD).queryFirst(); |
| } catch (GenericEntityException e) { |
| Debug.logError(e, "Error while finding latest UserLogin for party with ID [" + partyId + "]: " + e.toString(), module); |
| return null; |
| } |
| } |
| |
| public static Timestamp findPartyLastLoginTime(String partyId, Delegator delegator) { |
| try { |
| GenericValue v = EntityQuery.use(delegator).from("UserLoginHistory").where("partyId", partyId).orderBy("-fromDate").queryFirst(); |
| if (v != null) { |
| return v.getTimestamp("fromDate"); |
| } else { |
| return null; |
| } |
| } catch (GenericEntityException e) { |
| Debug.logError(e, "Error while finding latest login time for party with ID [" + partyId + "]: " + e.toString(), module); |
| return null; |
| } |
| |
| } |
| |
| public static Locale findPartyLastLocale(String partyId, Delegator delegator) { |
| // just get the most recent UserLogin for this party, if there is one... |
| GenericValue userLogin = findPartyLatestUserLogin(partyId, delegator); |
| if (userLogin == null) { |
| return null; |
| } |
| String localeString = userLogin.getString("lastLocale"); |
| if (UtilValidate.isNotEmpty(localeString)) { |
| return UtilMisc.parseLocale(localeString); |
| } else { |
| return null; |
| } |
| } |
| |
| public static String findFirstMatchingPartyId(Delegator delegator, String address1, String address2, String city, |
| String stateProvinceGeoId, String postalCode, String postalCodeExt, String countryGeoId, |
| String firstName, String middleName, String lastName) throws GeneralException { |
| |
| String[] info = findFirstMatchingPartyAndContactMechId(delegator, address1, address2, city, stateProvinceGeoId, postalCode, |
| postalCodeExt, countryGeoId, firstName, middleName, lastName); |
| if (info != null) { |
| return info[0]; |
| } |
| return null; |
| } |
| |
| public static String[] findFirstMatchingPartyAndContactMechId(Delegator delegator, String address1, String address2, String city, |
| String stateProvinceGeoId, String postalCode, String postalCodeExt, String countryGeoId, |
| String firstName, String middleName, String lastName) throws GeneralException { |
| |
| List<GenericValue> matching = findMatchingPersonPostalAddresses(delegator, address1, address2, city, stateProvinceGeoId, postalCode, |
| postalCodeExt, countryGeoId, firstName, middleName, lastName); |
| GenericValue v = EntityUtil.getFirst(matching); |
| if (v != null) { |
| return new String[] { v.getString("partyId"), v.getString("contactMechId") }; |
| } |
| return null; |
| } |
| |
| /** Finds all matching PartyAndPostalAddress records based on the values provided. Excludes party records with a statusId of PARTY_DISABLED. Results are ordered by descending PartyContactMech.fromDate. |
| * The matching process is as follows: |
| * 1. Calls {@link #findMatchingPartyPostalAddress(Delegator, String, String, String, String, String, String, String, String)} to retrieve a list of address matched PartyAndPostalAddress records. Results are limited to Parties of type PERSON. |
| * 2. For each matching PartyAndPostalAddress record, the Person record for the Party is then retrieved and an upper case comparison is performed against the supplied firstName, lastName and if provided, middleName. |
| * |
| * @param delegator Delegator instance |
| * @param address1 PostalAddress.address1 to match against (Required). |
| * @param address2 Optional PostalAddress.address2 to match against. |
| * @param city PostalAddress.city value to match against (Required). |
| * @param stateProvinceGeoId Optional PostalAddress.stateProvinceGeoId value to match against. If null or "**" is passed then the value will be ignored during matching. "NA" can be passed in place of "_NA_". |
| * @param postalCode PostalAddress.postalCode value to match against. Cannot be null but can be skipped by passing a value starting with an "*". If the length of the supplied string is 10 characters and the string contains a "-" then the postal code will be split at the "-" and the second half will be used as the postalCodeExt. |
| * @param postalCodeExt Optional PostalAddress.postalCodeExt value to match against. Will be overridden if a postalCodeExt value is retrieved from postalCode as described above. |
| * @param countryGeoId Optional PostalAddress.countryGeoId value to match against. |
| * @param firstName Person.firstName to match against (Required). |
| * @param middleName Optional Person.middleName to match against. |
| * @param lastName Person.lastName to match against (Required). |
| * @return List of PartyAndPostalAddress GenericValue objects that match the supplied criteria. |
| * @throws GeneralException |
| */ |
| public static List<GenericValue> findMatchingPersonPostalAddresses(Delegator delegator, String address1, String address2, String city, |
| String stateProvinceGeoId, String postalCode, String postalCodeExt, String countryGeoId, |
| String firstName, String middleName, String lastName) throws GeneralException { |
| // return list |
| List<GenericValue> returnList = new LinkedList<GenericValue>(); |
| |
| // address information |
| if (firstName == null || lastName == null) { |
| throw new IllegalArgumentException(); |
| } |
| |
| List<GenericValue> validFound = findMatchingPartyPostalAddress(delegator, address1, address2, city, stateProvinceGeoId, postalCode, postalCodeExt, countryGeoId, "PERSON"); |
| |
| if (UtilValidate.isNotEmpty(validFound)) { |
| for (GenericValue partyAndAddr: validFound) { |
| String partyId = partyAndAddr.getString("partyId"); |
| if (UtilValidate.isNotEmpty(partyId)) { |
| GenericValue p = EntityQuery.use(delegator).from("Person").where("partyId", partyId).queryOne(); |
| if (p != null) { |
| String fName = p.getString("firstName"); |
| String lName = p.getString("lastName"); |
| String mName = p.getString("middleName"); |
| if (lName.toUpperCase().equals(lastName.toUpperCase())) { |
| if (fName.toUpperCase().equals(firstName.toUpperCase())) { |
| if (mName != null && middleName != null) { |
| if (mName.toUpperCase().equals(middleName.toUpperCase())) { |
| returnList.add(partyAndAddr); |
| } |
| } else if (middleName == null) { |
| returnList.add(partyAndAddr); |
| } |
| } |
| } |
| } |
| } |
| } |
| } |
| |
| return returnList; |
| } |
| |
| /** |
| * @deprecated Renamed to {@link #findMatchingPersonPostalAddresses(Delegator, String, String, String, String, String, String, String, String, String, String)} |
| */ |
| @Deprecated |
| public static List<GenericValue> findMatchingPartyAndPostalAddress(Delegator delegator, String address1, String address2, String city, |
| String stateProvinceGeoId, String postalCode, String postalCodeExt, String countryGeoId, |
| String firstName, String middleName, String lastName) throws GeneralException { |
| return PartyWorker.findMatchingPersonPostalAddresses(delegator, address1, address2, city, stateProvinceGeoId, postalCode, postalCodeExt, countryGeoId, firstName, middleName, lastName); |
| } |
| |
| /** |
| * Finds all matching parties based on the values provided. Excludes party records with a statusId of PARTY_DISABLED. Results are ordered by descending PartyContactMech.fromDate. |
| * 1. Candidate addresses are found by querying PartyAndPostalAddress using the supplied city and if provided, stateProvinceGeoId, postalCode, postalCodeExt and countryGeoId |
| * 2. In-memory address line comparisons are then performed against the supplied address1 and if provided, address2. Address lines are compared after the strings have been converted using {@link #makeMatchingString(Delegator, String)}. |
| * |
| * @param delegator Delegator instance |
| * @param address1 PostalAddress.address1 to match against (Required). |
| * @param address2 Optional PostalAddress.address2 to match against. |
| * @param city PostalAddress.city value to match against (Required). |
| * @param stateProvinceGeoId Optional PostalAddress.stateProvinceGeoId value to match against. If null or "**" is passed then the value will be ignored during matching. "NA" can be passed in place of "_NA_". |
| * @param postalCode PostalAddress.postalCode value to match against. Cannot be null but can be skipped by passing a value starting with an "*". If the length of the supplied string is 10 characters and the string contains a "-" then the postal code will be split at the "-" and the second half will be used as the postalCodeExt. |
| * @param postalCodeExt Optional PostalAddress.postalCodeExt value to match against. Will be overridden if a postalCodeExt value is retrieved from postalCode as described above. |
| * @param countryGeoId Optional PostalAddress.countryGeoId value to match against. |
| * @param partyTypeId Optional Party.partyTypeId to match against. |
| * @return List of PartyAndPostalAddress GenericValue objects that match the supplied criteria. |
| * @throws GenericEntityException |
| */ |
| public static List<GenericValue> findMatchingPartyPostalAddress(Delegator delegator, String address1, String address2, String city, |
| String stateProvinceGeoId, String postalCode, String postalCodeExt, String countryGeoId, String partyTypeId) throws GenericEntityException { |
| |
| if (address1 == null || city == null || postalCode == null) { |
| throw new IllegalArgumentException(); |
| } |
| |
| List<EntityCondition> addrExprs = new LinkedList<EntityCondition>(); |
| if (stateProvinceGeoId != null) { |
| if ("**".equals(stateProvinceGeoId)) { |
| Debug.logWarning("Illegal state code passed!", module); |
| } else if ("NA".equals(stateProvinceGeoId)) { |
| addrExprs.add(EntityCondition.makeCondition("stateProvinceGeoId", EntityOperator.EQUALS, "_NA_")); |
| } else { |
| addrExprs.add(EntityCondition.makeCondition("stateProvinceGeoId", EntityOperator.EQUALS, stateProvinceGeoId.toUpperCase())); |
| } |
| } |
| |
| if (!postalCode.startsWith("*")) { |
| if (postalCode.length() == 10 && postalCode.indexOf("-") != -1) { |
| String[] zipSplit = postalCode.split("-", 2); |
| postalCode = zipSplit[0]; |
| postalCodeExt = zipSplit[1]; |
| } |
| addrExprs.add(EntityCondition.makeCondition("postalCode", EntityOperator.EQUALS, postalCode)); |
| } |
| |
| if (postalCodeExt != null) { |
| addrExprs.add(EntityCondition.makeCondition("postalCodeExt", EntityOperator.EQUALS, postalCodeExt)); |
| } |
| |
| addrExprs.add(EntityCondition.makeCondition(EntityFunction.UPPER_FIELD("city"), EntityOperator.EQUALS, EntityFunction.UPPER(city))); |
| |
| if (countryGeoId != null) { |
| addrExprs.add(EntityCondition.makeCondition("countryGeoId", EntityOperator.EQUALS, countryGeoId.toUpperCase())); |
| } |
| |
| // limit to only non-disabled status |
| addrExprs.add(EntityCondition.makeCondition(EntityCondition.makeCondition("statusId", EntityOperator.EQUALS, null), |
| EntityOperator.OR, EntityCondition.makeCondition("statusId", EntityOperator.NOT_EQUAL, "PARTY_DISABLED"))); |
| |
| if (partyTypeId != null) { |
| addrExprs.add(EntityCondition.makeCondition("partyTypeId", EntityOperator.EQUALS, partyTypeId)); |
| } |
| |
| List<GenericValue> addresses = EntityQuery.use(delegator).from("PartyAndPostalAddress") |
| .where(EntityCondition.makeCondition(addrExprs, EntityOperator.AND)) |
| .orderBy("-fromDate") |
| .filterByDate() |
| .queryList(); |
| |
| if (UtilValidate.isEmpty(addresses)) { |
| // No address matches, return an empty list |
| return addresses; |
| } |
| |
| List<GenericValue> validFound = new LinkedList<GenericValue>(); |
| // check the address line |
| for (GenericValue address: addresses) { |
| // address 1 field |
| String addr1Source = PartyWorker.makeMatchingString(delegator, address1); |
| String addr1Target = PartyWorker.makeMatchingString(delegator, address.getString("address1")); |
| |
| if (addr1Target != null) { |
| Debug.logInfo("Comparing address1 : " + addr1Source + " / " + addr1Target, module); |
| if (addr1Target.equals(addr1Source)) { |
| |
| // address 2 field |
| if (address2 != null) { |
| String addr2Source = PartyWorker.makeMatchingString(delegator, address2); |
| String addr2Target = PartyWorker.makeMatchingString(delegator, address.getString("address2")); |
| if (addr2Target != null) { |
| Debug.logInfo("Comparing address2 : " + addr2Source + " / " + addr2Target, module); |
| |
| if (addr2Source.equals(addr2Target)) { |
| Debug.logInfo("Matching address2; adding valid address", module); |
| validFound.add(address); |
| } |
| } |
| } else { |
| if (address.get("address2") == null) { |
| Debug.logInfo("No address2; adding valid address", module); |
| validFound.add(address); |
| } |
| } |
| } |
| } |
| } |
| return validFound; |
| } |
| |
| /** |
| * Converts the supplied String into a String suitable for address line matching. |
| * Performs the following transformations on the supplied String: |
| * - Converts to upper case |
| * - Retrieves all records from the AddressMatchMap table and replaces all occurrences of addressMatchMap.mapKey with addressMatchMap.mapValue using upper case matching. |
| * - Removes all non-word characters from the String i.e. everything except A-Z, 0-9 and _ |
| * @param delegator A Delegator instance |
| * @param address The address String to convert |
| * @return The converted Address |
| */ |
| public static String makeMatchingString(Delegator delegator, String address) { |
| if (address == null) { |
| return null; |
| } |
| |
| // upper case the address |
| String str = address.trim().toUpperCase(); |
| |
| // replace mapped words |
| List<GenericValue> addressMap = null; |
| try { |
| addressMap = EntityQuery.use(delegator).from("AddressMatchMap").orderBy("sequenceNum").queryList(); |
| } catch (GenericEntityException e) { |
| Debug.logError(e, module); |
| } |
| |
| if (addressMap != null) { |
| for (GenericValue v: addressMap) { |
| str = str.replaceAll(v.getString("mapKey").toUpperCase(), v.getString("mapValue").toUpperCase()); |
| } |
| } |
| |
| // remove all non-word characters |
| return str.replaceAll("\\W", ""); |
| } |
| |
| public static List<String> getAssociatedPartyIdsByRelationshipType(Delegator delegator, String partyIdFrom, String partyRelationshipTypeId) { |
| List<GenericValue> partyList = new LinkedList<GenericValue>(); |
| List<String> partyIds = null; |
| try { |
| EntityConditionList<EntityExpr> baseExprs = EntityCondition.makeCondition(UtilMisc.toList( |
| EntityCondition.makeCondition("partyIdFrom", partyIdFrom), |
| EntityCondition.makeCondition("partyRelationshipTypeId", partyRelationshipTypeId)), EntityOperator.AND); |
| List<GenericValue> associatedParties = EntityQuery.use(delegator).from("PartyRelationship").where(baseExprs).cache(true).queryList(); |
| partyList.addAll(associatedParties); |
| while (UtilValidate.isNotEmpty(associatedParties)) { |
| List<GenericValue> currentAssociatedParties = new LinkedList<GenericValue>(); |
| for (GenericValue associatedParty : associatedParties) { |
| EntityConditionList<EntityExpr> innerExprs = EntityCondition.makeCondition(UtilMisc.toList( |
| EntityCondition.makeCondition("partyIdFrom", associatedParty.get("partyIdTo")), |
| EntityCondition.makeCondition("partyRelationshipTypeId", partyRelationshipTypeId)), EntityOperator.AND); |
| List<GenericValue> associatedPartiesChilds = EntityQuery.use(delegator).from("PartyRelationship").where(innerExprs).cache(true).queryList(); |
| if (UtilValidate.isNotEmpty(associatedPartiesChilds)) { |
| currentAssociatedParties.addAll(associatedPartiesChilds); |
| } |
| partyList.add(associatedParty); |
| } |
| associatedParties = currentAssociatedParties; |
| } |
| partyIds = EntityUtil.getFieldListFromEntityList(partyList, "partyIdTo", true); |
| } catch (GenericEntityException e) { |
| Debug.logWarning(e, module); |
| } |
| return partyIds; |
| } |
| |
| /** |
| * Generic service to find party by id. |
| * By default return the party find by partyId |
| * but you can pass searchPartyFirst at false if you want search in partyIdentification before |
| * or pass searchAllId at true to find apartyuct with this id (party.partyId and partyIdentification.idValue) |
| * @param delegator the delegator |
| * @param idToFind the party id to find |
| * @param partyIdentificationTypeId the party identification type id to use |
| * @param searchPartyFirst search first with party id |
| * @param searchAllId search all the party ids |
| * @return returns the parties founds |
| * @throws GenericEntityException |
| */ |
| public static List<GenericValue> findPartiesById(Delegator delegator, |
| String idToFind, String partyIdentificationTypeId, |
| boolean searchPartyFirst, boolean searchAllId) throws GenericEntityException { |
| |
| if (Debug.verboseOn()) Debug.logVerbose("Analyze partyIdentification: entered id = " + idToFind + ", partyIdentificationTypeId = " + partyIdentificationTypeId, module); |
| |
| GenericValue party = null; |
| List<GenericValue> partiesFound = null; |
| |
| // 1) look if the idToFind given is a real partyId |
| if (searchPartyFirst) { |
| party = EntityQuery.use(delegator).from("Party").where("partyId", idToFind).cache().queryOne(); |
| } |
| |
| if (searchAllId || (searchPartyFirst && UtilValidate.isEmpty(party))) { |
| // 2) Retrieve party in PartyIdentification |
| Map<String, String> conditions = UtilMisc.toMap("idValue", idToFind); |
| if (UtilValidate.isNotEmpty(partyIdentificationTypeId)) { |
| conditions.put("partyIdentificationTypeId", partyIdentificationTypeId); |
| } |
| partiesFound = EntityQuery.use(delegator).from("PartyIdentificationAndParty").where(conditions).orderBy("partyId").cache(true).queryList(); |
| } |
| |
| if (! searchPartyFirst) { |
| party = EntityQuery.use(delegator).from("Party").where("partyId", idToFind).cache().queryOne(); |
| } |
| |
| if (party != null) { |
| if (UtilValidate.isNotEmpty(partiesFound)) partiesFound.add(party); |
| else partiesFound = UtilMisc.toList(party); |
| } |
| if (Debug.verboseOn()) Debug.logVerbose("Analyze partyIdentification: found party.partyId = " + party + ", and list : " + partiesFound, module); |
| return partiesFound; |
| } |
| |
| public static List<GenericValue> findPartiesById(Delegator delegator, String idToFind, String partyIdentificationTypeId) |
| throws GenericEntityException { |
| return findPartiesById(delegator, idToFind, partyIdentificationTypeId, true, false); |
| } |
| |
| public static String findPartyId(Delegator delegator, String idToFind, String partyIdentificationTypeId) throws GenericEntityException { |
| GenericValue party = findParty(delegator, idToFind, partyIdentificationTypeId); |
| if (party != null) { |
| return party.getString("partyId"); |
| } else { |
| return null; |
| } |
| } |
| |
| public static String findPartyId(Delegator delegator, String idToFind) throws GenericEntityException { |
| return findPartyId(delegator, idToFind, null); |
| } |
| |
| public static GenericValue findParty(Delegator delegator, String idToFind, String partyIdentificationTypeId) throws GenericEntityException { |
| List<GenericValue> parties = findPartiesById(delegator, idToFind, partyIdentificationTypeId); |
| GenericValue party = EntityUtil.getFirst(parties); |
| return party; |
| } |
| |
| public static List<GenericValue> findParties(Delegator delegator, String idToFind, String partyIdentificationTypeId) throws GenericEntityException { |
| List<GenericValue> partiesByIds = findPartiesById(delegator, idToFind, partyIdentificationTypeId); |
| List<GenericValue> parties = null; |
| if (UtilValidate.isNotEmpty(partiesByIds)) { |
| for (GenericValue party : partiesByIds) { |
| GenericValue partyToAdd = party; |
| //retreive party GV if the actual genericValue came from viewEntity |
| if (! "Party".equals(party.getEntityName())) { |
| partyToAdd = EntityQuery.use(delegator).from("Party").where("partyId", party.get("partyId")).cache().queryOne(); |
| } |
| |
| if (UtilValidate.isEmpty(parties)) { |
| parties = UtilMisc.toList(partyToAdd); |
| } |
| else { |
| parties.add(partyToAdd); |
| } |
| } |
| } |
| return parties; |
| } |
| |
| public static List<GenericValue> findParties(Delegator delegator, String idToFind) throws GenericEntityException { |
| return findParties(delegator, idToFind, null); |
| } |
| |
| public static GenericValue findParty(Delegator delegator, String idToFind) throws GenericEntityException { |
| return findParty(delegator, idToFind, null); |
| } |
| |
| } |
