Java tutorial
//============================================================================= //=== Copyright (C) 2001-2007 Food and Agriculture Organization of the //=== United Nations (FAO-UN), United Nations World Food Programme (WFP) //=== and United Nations Environment Programme (UNEP) //=== //=== This program is free software; you can redistribute it and/or modify //=== it under the terms of the GNU General Public License as published by //=== the Free Software Foundation; either version 2 of the License, or (at //=== your option) any later version. //=== //=== This program is distributed in the hope that it will be useful, but //=== WITHOUT ANY WARRANTY; without even the implied warranty of //=== MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU //=== General Public License for more details. //=== //=== You should have received a copy of the GNU General Public License //=== along with this program; if not, write to the Free Software //=== Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301, USA //=== //=== Contact: Jeroen Ticheler - FAO - Viale delle Terme di Caracalla 2, //=== Rome - Italy. email: geonetwork@osgeo.org //============================================================================== package org.fao.geonet.kernel.csw.services; import jeeves.resources.dbms.Dbms; import jeeves.server.context.ServiceContext; import jeeves.utils.Log; import jeeves.utils.Xml; import org.apache.commons.lang.StringUtils; import org.apache.lucene.search.Sort; import org.fao.geonet.GeonetContext; import org.fao.geonet.constants.Geonet; import org.fao.geonet.csw.common.ConstraintLanguage; import org.fao.geonet.csw.common.Csw; import org.fao.geonet.csw.common.ElementSetName; import org.fao.geonet.csw.common.OutputSchema; import org.fao.geonet.csw.common.ResultType; import org.fao.geonet.csw.common.exceptions.CatalogException; import org.fao.geonet.csw.common.exceptions.InvalidParameterValueEx; import org.fao.geonet.csw.common.exceptions.MissingParameterValueEx; import org.fao.geonet.csw.common.exceptions.NoApplicableCodeEx; import org.fao.geonet.kernel.DataManager; import org.fao.geonet.kernel.csw.CatalogConfiguration; import org.fao.geonet.kernel.csw.CatalogService; import org.fao.geonet.kernel.csw.services.getrecords.FieldMapper; import org.fao.geonet.kernel.csw.services.getrecords.SearchController; import org.fao.geonet.kernel.search.LuceneConfig; import org.fao.geonet.kernel.search.LuceneSearcher; import org.fao.geonet.kernel.search.SearchManager; import org.fao.geonet.kernel.search.spatial.Pair; import org.fao.geonet.util.ISODate; import org.fao.geonet.util.xml.NamespaceUtils; import org.jdom.Attribute; import org.jdom.Element; import org.jdom.Namespace; import org.springframework.util.CollectionUtils; import java.io.File; import java.util.ArrayList; import java.util.HashSet; import java.util.List; import java.util.Map; import java.util.Scanner; import java.util.Set; import java.util.StringTokenizer; /** * See OGC 07-006 and OGC 07-045. */ public class GetRecords extends AbstractOperation implements CatalogService { /** * OGC 07-006 10.8.4.4. */ private static final String defaultOutputFormat = "application/xml"; //--------------------------------------------------------------------------- //--- //--- Constructor //--- //--------------------------------------------------------------------------- private SearchController _searchController; private LuceneConfig _luceneConfig; /** * @param summaryConfig * @param luceneConfig */ public GetRecords(LuceneConfig luceneConfig) { _searchController = new SearchController(luceneConfig); this._luceneConfig = luceneConfig; } /** * @return */ public SearchController getSearchController() { return _searchController; }; //--------------------------------------------------------------------------- //--- //--- API methods //--- //--------------------------------------------------------------------------- public String getName() { return "GetRecords"; } /** * * @param request * @param context * @return * @throws CatalogException */ public Element execute(Element request, ServiceContext context) throws CatalogException { String timeStamp = new ISODate().toString(); // Return exception is indexing. GeonetContext gc = (GeonetContext) context.getHandlerContext(Geonet.CONTEXT_NAME); DataManager dataManager = gc.getDataManager(); if (dataManager.isIndexing()) { throw new RuntimeException("Catalog is indexing records, retry later."); } // // some validation checks (note: this is not an XSD validation) // // must be "CSW" checkService(request); // must be "2.0.2" checkVersion(request); // GeoNetwork only supports "application/xml" String outputFormat = checkOutputFormat(request); // one of ElementName XOR ElementSetName must be requested checkElementNamesXORElementSetName(request); // optional integer, value at least 1 int startPos = getStartPosition(request); // optional integer, value at least 1 int maxRecords = getMaxRecords(request); Element query = request.getChild("Query", Csw.NAMESPACE_CSW); // one of "hits", "results", "validate" or the GN-specific (invalid) "results_with_summary". ResultType resultType = ResultType.parse(request.getAttributeValue("resultType")); // either Record or IsoRecord OutputSchema outSchema = OutputSchema.parse(request.getAttributeValue("outputSchema")); // GeoNetwork-specific parameter defining how to deal with ElementNames. See documentation in // SearchController.applyElementNames() about these strategies. String elementnameStrategy = getElementNameStrategy(query); // value csw:Record or gmd:MD_Metadata // heikki: this is actually a List (in OGC 07-006), though OGC 07-045 states: // "Because for this application profile it is not possible that a query includes more than one typename, .." // So: a single String should be OK. However to increase backwards-compatibility with existing clients sending // a comma separated list (such as GN's own CSW Harvesting Client), the check assumes a comma-separated list, // and checks whether its values are not other than csw:Record or gmd:MD_Metadata. If both are sent, // gmd:MD_Metadata is preferred. String typeName = checkTypenames(query); // set of elementnames or null Set<String> elemNames = getElementNames(query); // If any element names are specified, it's an ad hoc query and overrides the element set name default. In that // case, we set setName to FULL instead of SUMMARY so that we can retrieve a CSW:Record and trim out the // elements that aren't in the elemNames set. ElementSetName setName = ElementSetName.FULL; // // no ElementNames requested: use ElementSetName // if ((elemNames == null)) { setName = getElementSetName(query, ElementSetName.SUMMARY); // elementsetname is FULL: use customized elementset if defined if (setName.equals(ElementSetName.FULL)) { List<Element> customElementSets; Dbms dbms = null; try { dbms = (Dbms) context.getResourceManager().open(Geonet.Res.MAIN_DB); customElementSets = dataManager.getCustomElementSets(dbms); // custom elementset defined if (!CollectionUtils.isEmpty(customElementSets)) { if (elemNames == null) { elemNames = new HashSet<String>(); } for (Element customElementSet : customElementSets) { elemNames.add(customElementSet.getChildText("xpath")); } } } catch (Exception x) { Log.warning(Geonet.CSW, "Failed to check for custom element sets; ignoring -- request will be handled with default FULL elementsetname. Message was: " + x.getMessage()); // an error here could make the dbms unusable so close it so that a new one can be used... // should it be committed or aborted? if (dbms != null) { try { context.getResourceManager().close(Geonet.Res.MAIN_DB, dbms); } catch (Exception e) { throw new RuntimeException("Unable to close database connection", e); } } } } } Element constr = query.getChild("Constraint", Csw.NAMESPACE_CSW); Element filterExpr = getFilterExpression(constr); String filterVersion = getFilterVersion(constr); // Get max hits to be used for summary - CSW GeoNetwork extension int maxHitsInSummary = 1000; String sMaxRecordsInKeywordSummary = query.getAttributeValue("maxHitsInSummary"); if (sMaxRecordsInKeywordSummary != null) { // TODO : it could be better to use service config parameter instead // sMaxRecordsInKeywordSummary = config.getValue("maxHitsInSummary", "1000"); maxHitsInSummary = Integer.parseInt(sMaxRecordsInKeywordSummary); } Sort sort = getSortFields(request, context); Element response; if (resultType == ResultType.VALIDATE) { //String schema = context.getAppPath() + Geonet.Path.VALIDATION + "csw/2.0.2/csw-2.0.2.xsd"; String schema = context.getAppPath() + Geonet.Path.VALIDATION + "csw202_apiso100/csw/2.0.2/CSW-discovery.xsd"; if (Log.isDebugEnabled(Geonet.CSW)) Log.debug(Geonet.CSW, "Validating request against " + schema); try { Xml.validate(schema, request); } catch (Exception e) { throw new NoApplicableCodeEx("Request failed validation:" + e.toString()); } response = new Element("Acknowledgement", Csw.NAMESPACE_CSW); response.setAttribute("timeStamp", timeStamp); Element echoedRequest = new Element("EchoedRequest", Csw.NAMESPACE_CSW); echoedRequest.addContent(request); response.addContent(echoedRequest); } else { response = new Element(getName() + "Response", Csw.NAMESPACE_CSW); Attribute schemaLocation = new Attribute("schemaLocation", "http://www.opengis.net/cat/csw/2.0.2 http://schemas.opengis.net/csw/2.0.2/CSW-discovery.xsd", Csw.NAMESPACE_XSI); response.setAttribute(schemaLocation); Element status = new Element("SearchStatus", Csw.NAMESPACE_CSW); status.setAttribute("timestamp", timeStamp); response.addContent(status); String cswServiceSpecificContraint = request.getChildText(Geonet.Elem.FILTER); Pair<Element, Element> search = _searchController.search(context, startPos, maxRecords, resultType, outSchema, setName, filterExpr, filterVersion, sort, elemNames, typeName, maxHitsInSummary, cswServiceSpecificContraint, elementnameStrategy); // Only add GeoNetwork summary on results_with_summary option if (resultType == ResultType.RESULTS_WITH_SUMMARY) { response.addContent(search.one()); } response.addContent(search.two()); } return response; } /** * TODO javadoc. * * @param params * @return * @throws CatalogException */ public Element adaptGetRequest(Map<String, String> params) throws CatalogException { String service = params.get("service"); String version = params.get("version"); String resultType = params.get("resulttype"); String outputFormat = params.get("outputformat"); String outputSchema = params.get("outputschema"); String startPosition = params.get("startposition"); String maxRecords = params.get("maxrecords"); String hopCount = params.get("hopcount"); String distribSearch = params.get("distributedsearch"); String typeNames = params.get("typenames"); String elemSetName = params.get("elementsetname"); String elemName = params.get("elementname"); String constraint = params.get("constraint"); String constrLang = params.get("constraintlanguage"); String constrLangVer = params.get("constraint_language_version"); String sortby = params.get("sortby"); String elementnameStrategy = params.get("elementnamestrategy"); //--- build POST request Element request = new Element(getName(), Csw.NAMESPACE_CSW); setAttrib(request, "service", service); setAttrib(request, "version", version); setAttrib(request, "resultType", resultType); setAttrib(request, "outputFormat", outputFormat); setAttrib(request, "outputSchema", outputSchema); setAttrib(request, "startPosition", startPosition); setAttrib(request, "maxRecords", maxRecords); if (distribSearch != null && distribSearch.equals("true")) { Element ds = new Element("DistributedSearch", Csw.NAMESPACE_CSW); ds.setText("TRUE"); if (hopCount != null) { ds.setAttribute("hopCount", hopCount); } request.addContent(ds); } //--- build query element Element query = new Element("Query", Csw.NAMESPACE_CSW); request.addContent(query); if (elementnameStrategy != null) { setAttrib(query, "elementnamestrategy", elementnameStrategy); } if (typeNames != null) { setAttrib(query, "typeNames", typeNames.replace(',', ' ')); } //--- these 2 are in mutual exclusion addElement(query, "ElementSetName", elemSetName); fill(query, "ElementName", elemName); //--- handle constraint ConstraintLanguage language = ConstraintLanguage.parse(constrLang); if (constraint != null) { Element constr = new Element("Constraint", Csw.NAMESPACE_CSW); query.addContent(constr); if (language == ConstraintLanguage.CQL) { addElement(constr, "CqlText", constraint); } else { try { constr.addContent(Xml.loadString(constraint, false)); } catch (Exception e) { e.printStackTrace(); throw new NoApplicableCodeEx("Constraint is not a valid xml"); } } setAttrib(constr, "version", constrLangVer); } //--- handle sortby if (sortby != null) { Element sortBy = new Element("SortBy", Csw.NAMESPACE_OGC); query.addContent(sortBy); StringTokenizer st = new StringTokenizer(sortby, ","); while (st.hasMoreTokens()) { String sortInfo = st.nextToken(); String field = sortInfo.substring(0, sortInfo.length() - 2); boolean ascen = sortInfo.endsWith(":A"); Element sortProp = new Element("SortProperty", Csw.NAMESPACE_OGC); sortBy.addContent(sortProp); Element propName = new Element("PropertyName", Csw.NAMESPACE_OGC).setText(field); Element sortOrder = new Element("SortOrder", Csw.NAMESPACE_OGC).setText(ascen ? "ASC" : "DESC"); sortProp.addContent(propName); sortProp.addContent(sortOrder); } } return request; } /** * TODO javadoc. * * @param parameterName * @return * @throws CatalogException */ public Element retrieveValues(String parameterName) throws CatalogException { Element listOfValues = null; if (parameterName.equalsIgnoreCase("resultType") || parameterName.equalsIgnoreCase("outputFormat") || parameterName.equalsIgnoreCase("elementSetName") || parameterName.equalsIgnoreCase("outputSchema") || parameterName.equalsIgnoreCase("typenames")) listOfValues = new Element("ListOfValues", Csw.NAMESPACE_CSW); // Handle resultType parameter if (parameterName.equalsIgnoreCase("resultType")) { List<Element> values = new ArrayList<Element>(); ResultType[] resultType = ResultType.values(); for (ResultType aResultType : resultType) { String value = aResultType.toString(); values.add(new Element("Value", Csw.NAMESPACE_CSW).setText(value)); } if (listOfValues != null) { listOfValues.addContent(values); } } // Handle elementSetName parameter if (parameterName.equalsIgnoreCase("elementSetName")) { List<Element> values = new ArrayList<Element>(); ElementSetName[] esn = ElementSetName.values(); for (ElementSetName anEsn : esn) { String value = anEsn.toString(); values.add(new Element("Value", Csw.NAMESPACE_CSW).setText(value)); } if (listOfValues != null) { listOfValues.addContent(values); } } // Handle outputFormat parameter if (parameterName.equalsIgnoreCase("outputformat")) { Set<String> formats = CatalogConfiguration.getGetRecordsOutputFormat(); List<Element> values = createValuesElement(formats); if (listOfValues != null) { listOfValues.addContent(values); } } // Handle outputSchema parameter if (parameterName.equalsIgnoreCase("outputSchema")) { Set<String> namespacesUri = CatalogConfiguration.getGetRecordsOutputSchema(); List<Element> values = createValuesElement(namespacesUri); if (listOfValues != null) { listOfValues.addContent(values); } } // Handle typenames parameter if (parameterName.equalsIgnoreCase("typenames")) { Set<String> typenames = CatalogConfiguration.getGetRecordsTypenames(); List<Element> values = createValuesElement(typenames); if (listOfValues != null) { listOfValues.addContent(values); } } return listOfValues; } //--------------------------------------------------------------------------- //--- //--- Private methods //--- //--------------------------------------------------------------------------- /** * GeoNetwork only supports default value for outputFormat. * * OGC 07-006: * The only value that is required to be supported is application/xml. Other supported values may include text/html * and text/plain. Cardinality: Zero or one (Optional). Default value is application/xml. * * In the case where the output format is application/xml, the CSW shall generate an XML document that validates * against a schema document that is specified in the output document via the xsi:schemaLocation attribute defined * in XML. * * @param request GetRecords request * @throws InvalidParameterValueEx hmm */ private String checkOutputFormat(Element request) throws InvalidParameterValueEx { String format = request.getAttributeValue("outputFormat"); if (format != null && !format.equals(defaultOutputFormat)) { throw new InvalidParameterValueEx("outputFormat", format); } else { return defaultOutputFormat; } } /** * If the request contains a Query element, it must have attribute typeNames. * * The OGC 07-045 spec is more restrictive than OGC 07-006. * * OGC 07-006 10.8.4.8: * The typeNames parameter is a list of one or more names of queryable entities in the catalogue's information model * that may be constrained in the predicate of the query. In the case of XML realization of the OGC core metadata * properties (Subclause 10.2.5), the element csw:Record is the only queryable entity. Other information models may * include more than one queryable component. For example, queryable components for the XML realization of the ebRIM * include rim:Service, rim:ExtrinsicObject and rim:Association. In such cases the application profile shall * describe how multiple typeNames values should be processed. * In addition, all or some of the these queryable entity names may be specified in the query to define which * metadata record elements the query should present in the response to the GetRecords operation. * * OGC 07-045 8.2.2.1.1: * Mandatory: Must support *one* of csw:Record? or gmd:MD_Metadata? in a query. Default value is csw:Record?. * * (note how OGC 07-045 mixes up a mandatory parameter that has a default value !!) * * We'll go for the default value option rather than the mandatory-ness. So: if typeNames is not present or empty, * "csw:Record" is used. * * If the request does not contain exactly one (or comma-separated, both) of the values specified in OGC 07-045, * an exception is thrown. If both are present "gmd:MD_Metadata" is preferred. * * @param query query element * @return typeName * @throws MissingParameterValueEx if typeNames is missing * @throws InvalidParameterValueEx if typeNames does not have one of the mandated values */ private String checkTypenames(Element query) throws MissingParameterValueEx, InvalidParameterValueEx { if (Log.isDebugEnabled(Geonet.CSW_SEARCH)) { Log.debug(Geonet.CSW_SEARCH, "checking typenames in query:\n" + Xml.getString(query)); } // // get the prefix used for CSW namespace used in this input document // String cswPrefix = getPrefixForNamespace(query, Csw.NAMESPACE_CSW); if (cswPrefix == null) { if (Log.isDebugEnabled(Geonet.CSW_SEARCH)) { Log.debug(Geonet.CSW_SEARCH, "checktypenames: csw prefix not found, using " + Csw.NAMESPACE_CSW.getPrefix()); } cswPrefix = Csw.NAMESPACE_CSW.getPrefix(); } // // get the prefix used for GMD namespace used in this input document // String gmdPrefix = getPrefixForNamespace(query, Csw.NAMESPACE_GMD); if (gmdPrefix == null) { if (Log.isDebugEnabled(Geonet.CSW_SEARCH)) { Log.debug(Geonet.CSW_SEARCH, "checktypenames: gmd prefix not found, using " + Csw.NAMESPACE_GMD.getPrefix()); } gmdPrefix = Csw.NAMESPACE_GMD.getPrefix(); } if (Log.isDebugEnabled(Geonet.CSW_SEARCH)) { Log.debug(Geonet.CSW_SEARCH, "checktypenames: csw prefix set to " + cswPrefix + ", gmd prefix set to " + gmdPrefix); } Attribute typeNames = query.getAttribute("typeNames", query.getNamespace()); typeNames = query.getAttribute("typeNames"); if (typeNames != null) { String typeNamesValue = typeNames.getValue(); // empty typenames element if (StringUtils.isEmpty(typeNamesValue)) { return cswPrefix + ":Record"; } // not empty: scan comma-separated string Scanner commaSeparator = new Scanner(typeNamesValue); commaSeparator.useDelimiter(","); String result = cswPrefix + ":Record"; while (commaSeparator.hasNext()) { String typeName = commaSeparator.next(); typeName = typeName.trim(); if (Log.isDebugEnabled(Geonet.CSW_SEARCH)) { Log.debug(Geonet.CSW_SEARCH, "checking typename in query:" + typeName); } if (!(typeName.equals(cswPrefix + ":Record") || typeName.equals(gmdPrefix + ":MD_Metadata"))) { throw new InvalidParameterValueEx("typeNames", "invalid value"); } if (typeName.equals(gmdPrefix + ":MD_Metadata")) { return typeName; } } return result; } // missing typeNames element else { return cswPrefix + ":Record"; } } /** * Returns the prefix used in the scope of an element for a particular namespace, or null if the namespace is not in * scope. * * @param element * @param namespace * @return */ private String getPrefixForNamespace(Element element, Namespace namespace) { List<Namespace> namespacesInScope = NamespaceUtils.getNamespacesInScope(element); for (Namespace ns : namespacesInScope) { if (ns.getURI().equals(namespace.getURI())) { return ns.getPrefix(); } } return null; } /** * GeoNetwork-specific parameter to control the behaviour when dealing with ElementNames. Supported values are * 'csw202', 'relaxed' , 'context' and 'geonetwork26'. If the parameter is missing or does not have one of these * values, the default value 'relaxed' is used. See documentation in SearchController.applyElementNames() about * these strategies. * * @param query query element * @return elementnames strategy */ private String getElementNameStrategy(Element query) { if (Log.isDebugEnabled(Geonet.CSW_SEARCH)) Log.debug(Geonet.CSW_SEARCH, "getting elementnameStrategy from query:\n" + Xml.getString(query)); Attribute elementNameStrategyA = query.getAttribute("elementnameStrategy"); // default String elementNameStrategy = "relaxed"; if (elementNameStrategyA != null) { elementNameStrategy = elementNameStrategyA.getValue(); } // empty or not one of the supported values if (StringUtils.isNotEmpty(elementNameStrategy) && !(elementNameStrategy.equals("csw202") || elementNameStrategy.equals("relaxed") || elementNameStrategy.equals("context") || elementNameStrategy.equals("geonetwork26"))) { // use default elementNameStrategy = "relaxed"; } if (Log.isDebugEnabled(Geonet.CSW_SEARCH)) Log.debug(Geonet.CSW_SEARCH, "elementNameStrategy: " + elementNameStrategy); return elementNameStrategy; } /** * Checks that not ElementName and ElementSetName are both present in the query, see OGC 07-006 section 10 8 4 9. * * @param request * @throws InvalidParameterValueEx */ private void checkElementNamesXORElementSetName(Element request) throws InvalidParameterValueEx { Element query = request.getChild("Query", Csw.NAMESPACE_CSW); if (query != null) { boolean elementNamePresent = !CollectionUtils .isEmpty(query.getChildren("ElementName", query.getNamespace())); boolean elementSetNamePresent = !CollectionUtils .isEmpty(query.getChildren("ElementSetName", query.getNamespace())); if (elementNamePresent && elementSetNamePresent) { throw new InvalidParameterValueEx("ElementName and ElementSetName", "mutually exclusive"); } } } /** * OGC 07-006 and OGC 07-045: * Non-zero, positive Integer. Optional. The default value is 1. * * @param request the request * @return startPosition * @throws InvalidParameterValueEx hmm */ private int getStartPosition(Element request) throws InvalidParameterValueEx { String start = request.getAttributeValue("startPosition"); if (start == null) { return 1; } try { int value = Integer.parseInt(start); if (value >= 1) { return value; } else { throw new InvalidParameterValueEx("startPosition", start); } } catch (NumberFormatException x) { throw new InvalidParameterValueEx("startPosition", start); } } /** * OGC 07-006 and OGC 07-045: * PositiveInteger. Optional. The default value is 10. * * @param request the request * @return maxRecords * @throws InvalidParameterValueEx hmm */ private int getMaxRecords(Element request) throws InvalidParameterValueEx { String max = request.getAttributeValue("maxRecords"); if (max == null) { return 10; } try { int value = Integer.parseInt(max); if (value >= 1) { return value; } else { throw new InvalidParameterValueEx("maxRecords", max); } } catch (NumberFormatException x) { throw new InvalidParameterValueEx("maxRecords", max); } } /** * a return value >= 0 means that a distributed search was requested, otherwise the method returns -1. * * TODO unused method * * @param request * @return * @throws InvalidParameterValueEx */ private int getHopCount(Element request) throws InvalidParameterValueEx { Element ds = request.getChild("DistributedSearch", Csw.NAMESPACE_CSW); if (ds == null) { return -1; } String hopCount = ds.getAttributeValue("hopCount"); if (hopCount == null) { return 2; } try { int value = Integer.parseInt(hopCount); if (value >= 0) { return value; } } catch (NumberFormatException ignored) { throw new InvalidParameterValueEx("hopCount", hopCount); } throw new InvalidParameterValueEx("hopCount", hopCount); } /** * TODO javadoc. * * @param request * @param context * @return */ private Sort getSortFields(Element request, ServiceContext context) { Element query = request.getChild("Query", Csw.NAMESPACE_CSW); if (query == null) { return null; } Element sortBy = query.getChild("SortBy", Csw.NAMESPACE_OGC); if (sortBy == null) { return null; } List list = sortBy.getChildren(); List<Pair<String, Boolean>> sortFields = new ArrayList<Pair<String, Boolean>>(); for (Object aList : list) { Element el = (Element) aList; String field = el.getChildText("PropertyName", Csw.NAMESPACE_OGC); String order = el.getChildText("SortOrder", Csw.NAMESPACE_OGC); // Map CSW search field to Lucene for sorting. And if not mapped assumes the field is a Lucene field. String luceneField = FieldMapper.map(field); if (luceneField != null) { sortFields.add(Pair.read(luceneField, "DESC".equals(order))); } else { sortFields.add(Pair.read(field, "DESC".equals(order))); } } GeonetContext gc = (GeonetContext) context.getHandlerContext(Geonet.CONTEXT_NAME); SearchManager sm = gc.getSearchmanager(); boolean requestedLanguageOnTop = sm.get_settingInfo().getRequestedLanguageOnTop(); // we always want to keep the relevancy as part of the sorting mechanism return LuceneSearcher.makeSort(sortFields, context.getLanguage(), requestedLanguageOnTop); } /** * Returns the values of ElementNames in the query, or null if there are none. * * @param query the query * @return set of elementname values */ private Set<String> getElementNames(Element query) { if (Log.isDebugEnabled(Geonet.CSW)) Log.debug(Geonet.CSW, "GetRecords getElementNames"); Set<String> elementNames = null; if (query != null) { List<Element> elementList = query.getChildren("ElementName", query.getNamespace()); for (Element element : elementList) { if (elementNames == null) { elementNames = new HashSet<String>(); } elementNames.add(element.getText()); } } // TODO in if(isDebugEnabled) condition. Jeeves LOG doesn't provide that useful function though. if (elementNames != null) { for (String elementName : elementNames) { if (Log.isDebugEnabled(Geonet.CSW)) Log.debug(Geonet.CSW, "ElementName: " + elementName); } } else { if (Log.isDebugEnabled(Geonet.CSW)) Log.debug(Geonet.CSW, "No ElementNames found in request"); } // TODO end if(isDebugEnabled) return elementNames; } /** * Retrieves the values of attribute typeNames. If typeNames contains csw:BriefRecord or csw:SummaryRecord, an * exception is thrown. * * @param query the query * @return list of typenames, or null if not found * @throws InvalidParameterValueEx if a typename is illegal */ private Set<String> getTypeNames(Element query) throws InvalidParameterValueEx { Set<String> typeNames = null; String typeNames$ = query.getAttributeValue("typeNames"); if (typeNames$ != null) { Scanner commaSeparatedScanner = new Scanner(typeNames$).useDelimiter(","); while (commaSeparatedScanner.hasNext()) { String typeName = commaSeparatedScanner.next().trim(); // These two are explicitly not allowed as search targets in CSW 2.0.2, so we throw an exception if the // client asks for them if (typeName.equals("csw:BriefRecord") || typeName.equals("csw:SummaryRecord")) { throw new InvalidParameterValueEx("typeName", typeName); } if (typeNames == null) { typeNames = new HashSet<String>(); } typeNames.add(typeName); } } // TODO in if(isDebugEnabled) condition. Jeeves LOG doesn't provide that useful function though. if (typeNames != null) { for (String typeName : typeNames) { if (Log.isDebugEnabled(Geonet.CSW)) Log.debug(Geonet.CSW, "TypeName: " + typeName); } } else { if (Log.isDebugEnabled(Geonet.CSW)) Log.debug(Geonet.CSW, "No TypeNames found in request"); } // TODO end if(isDebugEnabled) return typeNames; } }