Java tutorial
/* * This library is part of OpenCms - * the Open Source Content Management System * * Copyright (c) Alkacon Software GmbH (http://www.alkacon.com) * * This library is free software; you can redistribute it and/or * modify it under the terms of the GNU Lesser General Public * License as published by the Free Software Foundation; either * version 2.1 of the License, or (at your option) any later version. * * This library 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 * Lesser General Public License for more details. * * For further information about Alkacon Software GmbH, please see the * company website: http://www.alkacon.com * * For further information about OpenCms, please see the * project website: http://www.opencms.org * * You should have received a copy of the GNU Lesser General Public * License along with this library; if not, write to the Free Software * Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA */ package org.opencms.search; import org.opencms.i18n.CmsEncoder; import org.opencms.main.CmsException; import org.opencms.main.CmsIllegalArgumentException; import org.opencms.main.CmsLog; import org.opencms.main.OpenCms; import org.opencms.search.fields.CmsSearchField; import org.opencms.util.CmsStringUtil; import java.util.ArrayList; import java.util.Arrays; import java.util.Iterator; import java.util.List; import org.apache.commons.collections.ListUtils; import org.apache.commons.logging.Log; import org.apache.lucene.search.BooleanClause; import org.apache.lucene.search.BooleanClause.Occur; import org.apache.lucene.search.Sort; import org.apache.lucene.search.SortField; /** * Contains the search parameters for a call to <code>{@link org.opencms.search.CmsSearchIndex#search(org.opencms.file.CmsObject, CmsSearchParameters)}</code>.<p> * * Primary purpose is translation of search arguments to response parameters and from request parameters as * well as support for creation of restrictions of several search query parameter sets. <p> * * @since 6.0.0 */ public class CmsSearchParameters { /** * Describes a specific search field query.<p> */ public static class CmsSearchFieldQuery { /** The field name. */ private String m_fieldName; /** The occur parameter for this field. */ private Occur m_fieldOccur; /** The search term list. */ private List<String> m_searchTerms; /** The occur parameter used for the search term combination. */ private Occur m_termOccur; /** * Creates a new search field query with a variable length search term list.<p> * * @param fieldName the field name * @param fieldOccur the occur parameter for this field * @param termList the search term list * @param termOccur the occur parameter used for the search term combination */ public CmsSearchFieldQuery(String fieldName, Occur fieldOccur, List<String> termList, Occur termOccur) { super(); m_fieldName = fieldName; m_fieldOccur = fieldOccur; m_searchTerms = termList; m_termOccur = termOccur; } /** * Creates a new search field query with just a single search term.<p> * * Please note: Since there is only one term, the ocucr parameter for the term combination is * not required and set to <code>null</code>.<p> * * @param fieldName the field name * @param searchTerm the search term * @param fieldOccur the occur parameter for this field */ public CmsSearchFieldQuery(String fieldName, String searchTerm, Occur fieldOccur) { this(fieldName, fieldOccur, Arrays.asList(searchTerm), null); } /** * Returns the field name.<p> * * @return the field name */ public String getFieldName() { return m_fieldName; } /** * Returns the occur parameter for this field query.<p> * * @return the occur parameter for this field query */ public Occur getOccur() { return m_fieldOccur; } /** * Returns the first entry from the term list.<p> * * @return the search query * * @deprecated use {@link #getSearchTerms()} instead */ @Deprecated public String getSearchQuery() { return m_searchTerms.get(0); } /** * Returns the search term list.<p> * * @return the search term list */ public List<String> getSearchTerms() { return m_searchTerms; } /** * Returns the occur parameter used for the search term combination of this field query.<p> * * @return the occur parameter used for the search term combination of this field query */ public Occur getTermOccur() { return m_termOccur; } /** * Sets the name of the field to use this query for.<p> * * @param fieldName the name of the field to use this query for */ public void setFieldName(String fieldName) { m_fieldName = fieldName; } /** * Sets the occur parameter for this field query.<p> * * @param occur the occur parameter to set */ public void setOccur(BooleanClause.Occur occur) { m_fieldOccur = occur; } /** * Sets the search keywords to just a single entry.<p> * * @param searchQuery the single search keyword to set * * @deprecated use {@link #setSearchTerms(List)} instead */ @Deprecated public void setSearchQuery(String searchQuery) { setSearchTerms(Arrays.asList(searchQuery)); } /** * Sets the search terms.<p> * * @param searchTerms the search terms to set */ public void setSearchTerms(List<String> searchTerms) { m_searchTerms = searchTerms; } } /** Sort result documents by date of creation, then score. */ public static final Sort SORT_DATE_CREATED = new Sort( new SortField(CmsSearchField.FIELD_DATE_CREATED, SortField.STRING, true)); /** Sort result documents by date of last modification, then score. */ public static final Sort SORT_DATE_LASTMODIFIED = new Sort( new SortField(CmsSearchField.FIELD_DATE_LASTMODIFIED, SortField.STRING, true)); /** Default sort order (by document score). */ public static final Sort SORT_DEFAULT = Sort.RELEVANCE; /** Names of the default sort options. */ public static final String[] SORT_NAMES = { "SORT_DEFAULT", "SORT_DATE_CREATED", "SORT_DATE_LASTMODIFIED", "SORT_TITLE" }; /** Sort result documents by title, then score. */ public static final Sort SORT_TITLE = new Sort( new SortField[] { new SortField(CmsSearchField.FIELD_TITLE, SortField.STRING), SortField.FIELD_SCORE }); /** The log object for this class. */ private static final Log LOG = CmsLog.getLog(CmsSearchParameters.class); /** The number of displayed pages returned by getPageLinks(). */ protected int m_displayPages; /** The number of matches per page. */ protected int m_matchesPerPage; /** If <code>true</code>, the category count is calculated for all search results. */ private boolean m_calculateCategories; /** The list of categories to limit the search to. */ private List<String> m_categories; /** Indicates if all fields should be used for generating the excerpt, regardless if they have been searched or not. */ private boolean m_excerptOnlySearchedFields; /** The map of individual search field queries. */ private List<CmsSearchFieldQuery> m_fieldQueries; /** The list of search index fields to search in. */ private List<String> m_fields; /** The index to search. */ private CmsSearchIndex m_index; /** Indicates if the query part should be ignored so that only filters are used for searching. */ private boolean m_isIgnoreQuery; /** The creation date the resources have to have as maximum. */ private long m_maxDateCreated; /** The last modification date the resources have to have as maximum. */ private long m_maxDateLastModified; /** The creation date the resources have to have as minimum. */ private long m_minDateCreated; /** The last modification date the resources have to have as minimum. */ private long m_minDateLastModified; /** The current result page. */ private int m_page; /** The pre-parsed query. */ private String m_parsedQuery; /** The search query to use. */ private String m_query; /** The minimum length of the search query. */ private int m_queryLength; /** The list of resource types to limit the search to. */ private List<String> m_resourceTypes; /** Only resource that are sub-resource of one of the search roots are included in the search result. */ private List<String> m_roots; /** The sort order for the search. */ private Sort m_sort; /** * Creates a new search parameter instance with no search query and * default values for the remaining parameters. <p> * * Before using this search parameters for a search method * <code>{@link #setQuery(String)}</code> has to be invoked. <p> * */ public CmsSearchParameters() { this(""); } /** * Creates a new search parameter instance with the provided search query and * default values for the remaining parameters. <p> * * Only the "meta" field (combination of content and title) will be used for search. * No search root restriction is chosen. * No category restriction is used. * No category counts are calculated for the result. * Sorting is turned off. This is a simple but fast setup. <p> * * @param query the query to search for */ public CmsSearchParameters(String query) { this(query, null, null, null, null, false, null); } /** * Creates a new search parameter instance with the provided parameter values.<p> * * @param query the search term to search the index * @param fields the list of fields to search * @param roots only resource that are sub-resource of one of the search roots are included in the search result * @param categories the list of categories to limit the search to * @param resourceTypes the list of resource types to limit the search to * @param calculateCategories if <code>true</code>, the category count is calculated for all search results * (use with caution, this option uses much performance) * @param sort the sort order for the search */ public CmsSearchParameters(String query, List<String> fields, List<String> roots, List<String> categories, List<String> resourceTypes, boolean calculateCategories, Sort sort) { super(); m_query = (query == null) ? "" : query; if (fields == null) { fields = new ArrayList<String>(2); fields.add(CmsSearchIndex.DOC_META_FIELDS[0]); fields.add(CmsSearchIndex.DOC_META_FIELDS[1]); } m_fields = fields; if (roots == null) { roots = new ArrayList<String>(2); } m_roots = roots; m_categories = (categories == null) ? new ArrayList<String>() : categories; m_resourceTypes = (resourceTypes == null) ? new ArrayList<String>() : resourceTypes; m_calculateCategories = calculateCategories; // null sort is allowed default m_sort = sort; m_page = 1; m_queryLength = -1; m_matchesPerPage = 10; m_displayPages = 10; m_isIgnoreQuery = false; m_minDateCreated = Long.MIN_VALUE; m_maxDateCreated = Long.MAX_VALUE; m_minDateLastModified = Long.MIN_VALUE; m_maxDateLastModified = Long.MAX_VALUE; } /** * Adds an individual query for a search field.<p> * * If this is used, any setting made with {@link #setQuery(String)} and {@link #setFields(List)} * will be ignored and only the individual field search settings will be used.<p> * * @param query the query to add * * @since 7.5.1 */ public void addFieldQuery(CmsSearchFieldQuery query) { if (m_fieldQueries == null) { m_fieldQueries = new ArrayList<CmsSearchFieldQuery>(); m_fields = new ArrayList<String>(); } m_fieldQueries.add(query); // add the used field used in the fields query to the list of fields used in the search if (!m_fields.contains(query.getFieldName())) { m_fields.add(query.getFieldName()); } } /** * Adds an individual query for a search field.<p> * * If this is used, any setting made with {@link #setQuery(String)} and {@link #setFields(List)} * will be ignored and only the individual field search settings will be used.<p> * * @param fieldName the field name * @param searchQuery the search query * @param occur the occur parameter for the query in the field * * @since 7.5.1 */ public void addFieldQuery(String fieldName, String searchQuery, Occur occur) { CmsSearchFieldQuery newQuery = new CmsSearchFieldQuery(fieldName, searchQuery, occur); addFieldQuery(newQuery); } /** * Returns whether category counts are calculated for search results or not. <p> * * @return a boolean that tells whether category counts are calculated for search results or not */ public boolean getCalculateCategories() { return m_calculateCategories; } /** * Returns the list of categories to limit the search to.<p> * * @return the list of categories to limit the search to */ public List<String> getCategories() { return m_categories; } /** * Returns the maximum number of pages which should be shown.<p> * * @return the maximum number of pages which should be shown */ public int getDisplayPages() { return m_displayPages; } /** * Returns the list of individual field queries.<p> * * @return the list of individual field queries * * @since 7.5.1 */ public List<CmsSearchFieldQuery> getFieldQueries() { return m_fieldQueries; } /** * Returns the list of search index field names (Strings) to search in.<p> * * @return the list of search index field names (Strings) to search in */ public List<String> getFields() { return m_fields; } /** * Get the name of the index for the search.<p> * * @return the name of the index for the search */ public String getIndex() { return m_index.getName(); } /** * Gets the number of matches displayed on each page.<p> * * @return matches per result page */ public int getMatchesPerPage() { return m_matchesPerPage; } /** * Returns the maximum creation date a resource must have to be included in the search result.<p> * * @return the maximum creation date a resource must have to be included in the search result */ public long getMaxDateCreated() { return m_maxDateCreated; } /** * Returns the maximum last modification date a resource must have to be included in the search result.<p> * * @return the maximum last modification date a resource must have to be included in the search result */ public long getMaxDateLastModified() { return m_maxDateLastModified; } /** * Returns the minimum creation date a resource must have to be included in the search result.<p> * * @return the minimum creation date a resource must have to be included in the search result */ public long getMinDateCreated() { return m_minDateCreated; } /** * Returns the minimum last modification date a resource must have to be included in the search result.<p> * * @return the minimum last modification date a resource must have to be included in the search result */ public long getMinDateLastModified() { return m_minDateLastModified; } /** * Returns the parsed query.<p> * * The parsed query is automatically set by the OpenCms search index when a query is created * with either {@link #setQuery(String)} or {@link #addFieldQuery(CmsSearchFieldQuery)}. * The Lucene query build from the parameters is stored here and can be later used * for paging through the results.<p> * * Please note that this returns only to the query part, not the filter part of the search.<p> * * @return the parsed query */ public String getParsedQuery() { return m_parsedQuery; } /** * Returns the search query to use.<p> * * @return the search query to use */ public String getQuery() { return m_query; } /** * Gets the minimum search query length.<p> * * @return the minimum search query length */ public int getQueryLength() { return m_queryLength; } /** * Returns the list of resource types to limit the search to.<p> * * @return the list of resource types to limit the search to * * @since 7.5.1 */ public List<String> getResourceTypes() { return m_resourceTypes; } /** * Returns the list of strings of search roots to use.<p> * * Only resource that are sub-resource of one of the search roots are included in the search result.<p> * * @return the list of strings of search roots to use */ public List<String> getRoots() { return m_roots; } /** * Returns the list of categories to limit the search to.<p> * * @return the list of categories to limit the search to */ public String getSearchCategories() { return toSeparatedString(getCategories(), ','); } /** * Returns the search index to search in or null if not set before * (<code>{@link #setSearchIndex(CmsSearchIndex)}</code>). <p> * * @return the search index to search in or null if not set before (<code>{@link #setSearchIndex(CmsSearchIndex)}</code>) */ public CmsSearchIndex getSearchIndex() { return m_index; } /** * Returns the search page to display.<p> * * @return the search page to display */ public int getSearchPage() { return m_page; } /** * Returns the comma separated lists of root folder names to restrict search to.<p> * * This method is a "sibling" to method <code>{@link #getRoots()}</code> but with * the support of being usable with widget technology. <p> * * @return the comma separated lists of field names to search in * * @see #setSortName(String) */ public String getSearchRoots() { return toSeparatedString(m_roots, ','); } /** * Returns the instance that defines the sort order for the results. * * @return the instance that defines the sort order for the results */ public Sort getSort() { return m_sort; } /** * Returns the name of the sort option being used.<p> * @return the name of the sort option being used * * @see #SORT_NAMES * @see #setSortName(String) */ public String getSortName() { if (m_sort == SORT_DATE_CREATED) { return SORT_NAMES[1]; } if (m_sort == SORT_DATE_LASTMODIFIED) { return SORT_NAMES[2]; } if (m_sort == SORT_TITLE) { return SORT_NAMES[3]; } return SORT_NAMES[0]; } /** * Returns <code>true</code> if the category count is calculated for all search results.<p> * * @return <code>true</code> if the category count is calculated for all search results */ public boolean isCalculateCategories() { return m_calculateCategories; } /** * Returns <code>true</code> if fields configured for the excerpt should be used for generating the excerpt only * if they have been actually searched in.<p> * * The default setting is <code>false</code>, which means all text fields configured for the excerpt will * be used to generate the excerpt, regardless if they have been searched in or not.<p> * * Please note: A field will only be included in the excerpt if it has been configured as <code>excerpt="true"</code> * in <code>opencms-search.xml</code>. This method controls if so configured fields are used depending on the * fields searched, see {@link #setFields(List)}.<p> * * @return <code>true</code> if fields configured for the excerpt should be used for generating the excerpt only * if they have been actually searched in */ public boolean isExcerptOnlySearchedFields() { return m_excerptOnlySearchedFields; } /** * Returns <code>true</code> if the query part should be ignored so that only filters are used for searching.<p> * * @return <code>true</code> if the query part should be ignored so that only filters are used for searching * * @since 8.0.0 */ public boolean isIgnoreQuery() { return m_isIgnoreQuery; } /** * Creates a merged parameter set from this parameters, restricted by the given other parameters.<p> * * This is mainly intended for "search in search result" functions.<p> * * The restricted query is build of the queries of both parameters, appended with AND.<p> * * The lists in the restriction for <code>{@link #getFields()}</code>, <code>{@link #getRoots()}</code> and * <code>{@link #getCategories()}</code> are <b>intersected</b> with the lists of this search parameters. Only * elements contained in both lists are included for the created search parameters. * If a list in either the restriction or in this search parameters is <code>null</code>, * the list from the other search parameters is used directly.<p> * * The values for * <code>{@link #isCalculateCategories()}</code> * and <code>{@link #getSort()}</code> of this parameters are used for the restricted parameters.<p> * * @param restriction the parameters to restrict this parameters with * @return the restricted parameters */ @SuppressWarnings("unchecked") public CmsSearchParameters restrict(CmsSearchParameters restriction) { // append queries StringBuffer query = new StringBuffer(256); if (getQuery() != null) { // don't blow up unnecessary closures (if CmsSearch is reused and restricted several times) boolean closure = !getQuery().startsWith("+("); if (closure) { query.append("+("); } query.append(getQuery()); if (closure) { query.append(")"); } } if (restriction.getQuery() != null) { // don't let Lucene max terms be exceeded in case someone reuses a CmsSearch and continuously restricts // query with the same restrictions... if (query.indexOf(restriction.getQuery()) < 0) { query.append(" +("); query.append(restriction.getQuery()); query.append(")"); } } // restrict fields List<String> fields = null; if ((m_fields != null) && (m_fields.size() > 0)) { if ((restriction.getFields() != null) && (restriction.getFields().size() > 0)) { fields = ListUtils.intersection(m_fields, restriction.getFields()); } else { fields = m_fields; } } else { fields = restriction.getFields(); } // restrict roots List<String> roots = null; if ((m_roots != null) && (m_roots.size() > 0)) { if ((restriction.getRoots() != null) && (restriction.getRoots().size() > 0)) { roots = ListUtils.intersection(m_roots, restriction.getRoots()); // TODO: This only works if there are equal paths in both parameter sets - for two distinct sets // all root restrictions are dropped with an empty list. } else { roots = m_roots; } } else { roots = restriction.getRoots(); } // restrict categories List<String> categories = null; if ((m_categories != null) && (m_categories.size() > 0)) { if ((restriction.getCategories() != null) && (restriction.getCategories().size() > 0)) { categories = ListUtils.intersection(m_categories, restriction.getCategories()); } else { categories = m_categories; } } else { categories = restriction.getCategories(); } // restrict resource types List<String> resourceTypes = null; if ((m_resourceTypes != null) && (m_resourceTypes.size() > 0)) { if ((restriction.getResourceTypes() != null) && (restriction.getResourceTypes().size() > 0)) { resourceTypes = ListUtils.intersection(m_resourceTypes, restriction.getResourceTypes()); } else { resourceTypes = m_resourceTypes; } } else { resourceTypes = restriction.getResourceTypes(); } // create the new search parameters CmsSearchParameters result = new CmsSearchParameters(query.toString(), fields, roots, categories, resourceTypes, m_calculateCategories, m_sort); result.setIndex(getIndex()); return result; } /** * Set whether category counts shall be calculated for the corresponding search results or not.<p> * * @param flag true if category counts shall be calculated for the corresponding search results or false if not */ public void setCalculateCategories(boolean flag) { m_calculateCategories = flag; } /** * Set the list of categories (strings) to this parameters. <p> * * @param categories the list of categories (strings) of this parameters */ public void setCategories(List<String> categories) { m_categories = categories; } /** * Sets the maximum number of pages which should be shown.<p> * * Enter an odd value to achieve a nice, "symmetric" output.<p> * * @param value the maximum number of pages which should be shown */ public void setDisplayPages(int value) { m_displayPages = value; } /** * Controls if the excerpt from a field is generated only for searched fields, or for all fields (the default).<p> * * @param excerptOnlySearchedFields if <code>true</code>, the excerpt is generated only from the fields actually searched in * * @see #isExcerptOnlySearchedFields() */ public void setExcerptOnlySearchedFields(boolean excerptOnlySearchedFields) { m_excerptOnlySearchedFields = excerptOnlySearchedFields; } /** * Sets the list of strings of names of fields to search in. <p> * * @param fields the list of strings of names of fields to search in to set */ public void setFields(List<String> fields) { m_fields = fields; } /** * Sets the flag to indicate if the query part should be ignored so that only filters are used for searching.<p> * * @param isIgnoreQuery the flag to indicate if the query part should be ignored * * @since 8.0.0 */ public void setIgnoreQuery(boolean isIgnoreQuery) { m_isIgnoreQuery = isIgnoreQuery; } /** * Set the name of the index to search.<p> * * * @param indexName the name of the index */ public void setIndex(String indexName) { CmsSearchIndex index; if (CmsStringUtil.isNotEmpty(indexName)) { try { index = OpenCms.getSearchManager().getIndex(indexName); if (index == null) { throw new CmsException(Messages.get().container(Messages.ERR_INDEX_NOT_FOUND_1, indexName)); } setSearchIndex(index); } catch (Exception exc) { if (LOG.isErrorEnabled()) { LOG.error(Messages.get().getBundle().key(Messages.LOG_INDEX_ACCESS_FAILED_1, indexName), exc); } } } } /** * Sets the number of matches per page.<p> * * @param matches the number of matches per page */ public void setMatchesPerPage(int matches) { m_matchesPerPage = matches; } /** * Sets the maximum creation date a resource must have to be included in the search result.<p> * * @param maxDateCreated the maximum creation date to set */ public void setMaxDateCreated(long maxDateCreated) { m_maxDateCreated = maxDateCreated; } /** * Sets the maximum last modification date a resource must have to be included in the search result.<p> * * @param maxDateLastModified the maximum last modification date to set */ public void setMaxDateLastModified(long maxDateLastModified) { m_maxDateLastModified = maxDateLastModified; } /** * Sets the minimum creation date a resource must have to be included in the search result.<p> * * @param minDateCreated the minimum creation date to set */ public void setMinDateCreated(long minDateCreated) { m_minDateCreated = minDateCreated; } /** * Sets the minimum last modification date a resource must have to be included in the search result.<p> * * @param minDateLastModified he minimum last modification date to set */ public void setMinDateLastModified(long minDateLastModified) { m_minDateLastModified = minDateLastModified; } /** * Sets the parsed query.<p> * * The parsed query is automatically set by the OpenCms search index when a query is created * with either {@link #setQuery(String)} or {@link #addFieldQuery(CmsSearchFieldQuery)}. * The Lucene query build from the parameters is stored here and can be later used * for paging through the results.<p> * * Please note that this applies only to the query part, not the filter part of the search.<p> * * @param parsedQuery the parsed query to set */ public void setParsedQuery(String parsedQuery) { m_parsedQuery = parsedQuery; } /** * Sets the query to search for. <p> * * The decoding here is tailored for query strings that are * additionally manually UTF-8 encoded at client side (javascript) to get around an * issue with special chars in applications that use non- UTF-8 encoding * (e.g. ISO-8859-1) OpenCms applications. It is not recommended to use this with * front ends that don't encode manually as characters like sole "%" (without number suffix) * will cause an Exception.<p> * * @param query the query to search for to set */ public void setQuery(String query) { // for use with widgets the exception is thrown here to enforce the error message next to the widget if (query.trim().length() < getQueryLength()) { throw new CmsIllegalArgumentException( Messages.get().container(Messages.ERR_QUERY_TOO_SHORT_1, new Integer(getQueryLength()))); } m_query = query; } /** * Sets the minimum length of the search query.<p> * * @param length the minimum search query length */ public void setQueryLength(int length) { m_queryLength = length; } /** * Set the list of resource types (strings) to limit the search to. <p> * * @param resourceTypes the list of resource types (strings) to limit the search to * * @since 7.5.1 */ public void setResourceTypes(List<String> resourceTypes) { m_resourceTypes = resourceTypes; } /** * Sets the list of strings of roots to search under for the search.<p> * * @param roots the list of strings of roots to search under for the search to set */ public void setRoots(List<String> roots) { m_roots = roots; } /** * Set the comma separated search root names to restrict search to.<p> * * @param categories the comma separated category names to restrict search to */ public void setSearchCategories(String categories) { setCategories(CmsStringUtil.splitAsList(categories, ',')); } /** * Sets the search index to use for the search. <p> * * @param index the search index to use for the search to set. * * @throws CmsIllegalArgumentException if null is given as argument */ public void setSearchIndex(CmsSearchIndex index) throws CmsIllegalArgumentException { if (index == null) { throw new CmsIllegalArgumentException(Messages.get().container(Messages.ERR_INDEX_NULL_0)); } m_index = index; } /** * Set the search page to display. <p> * * @param page the search page to display */ public void setSearchPage(int page) { m_page = page; } /** * Set the comma separated search root names to restrict search to.<p> * * @param rootNameList the comma separated search root names to restrict search to */ public void setSearchRoots(String rootNameList) { m_roots = CmsStringUtil.splitAsList(rootNameList, ','); } /** * Set the instance that defines the sort order for search results. * * @param sortOrder the instance that defines the sort order for search results to set */ public void setSort(Sort sortOrder) { m_sort = sortOrder; } /** * Sets the internal member of type <code>{@link Sort}</code> according to * the given sort name. <p> * * For a list of valid sort names, please see <code>{@link #SORT_NAMES}</code>.<p> * * @param sortName the name of the sort to use * * @see #SORT_NAMES */ public void setSortName(String sortName) { if (sortName.equals(SORT_NAMES[1])) { m_sort = SORT_DATE_CREATED; } else if (sortName.equals(SORT_NAMES[2])) { m_sort = SORT_DATE_LASTMODIFIED; } else if (sortName.equals(SORT_NAMES[3])) { m_sort = SORT_TITLE; } else { m_sort = SORT_DEFAULT; } } /** * Creates a query String build from this search parameters for HTML links.<p> * * @return a query String build from this search parameters for HTML links */ public String toQueryString() { StringBuffer result = new StringBuffer(128); result.append("?action=search"); if (getParsedQuery() != null) { result.append("&parsedQuery="); result.append(CmsEncoder.encodeParameter(getParsedQuery())); } else { result.append("&query="); result.append(CmsEncoder.encodeParameter(getQuery())); } result.append("&matchesPerPage="); result.append(getMatchesPerPage()); result.append("&displayPages="); result.append(getDisplayPages()); result.append("&index="); result.append(CmsEncoder.encodeParameter(getIndex())); Sort sort = getSort(); if (sort != CmsSearchParameters.SORT_DEFAULT) { result.append("&sort="); if (sort == CmsSearchParameters.SORT_TITLE) { result.append("title"); } else if (sort == CmsSearchParameters.SORT_DATE_CREATED) { result.append("date-created"); } else if (sort == CmsSearchParameters.SORT_DATE_LASTMODIFIED) { result.append("date-lastmodified"); } } if ((getCategories() != null) && (getCategories().size() > 0)) { result.append("&category="); Iterator<String> it = getCategories().iterator(); while (it.hasNext()) { result.append(it.next()); if (it.hasNext()) { result.append(','); } } } if (getMinDateCreated() > Long.MIN_VALUE) { result.append("&minDateCreated="); result.append(getMinDateCreated()); } if (getMinDateLastModified() > Long.MIN_VALUE) { result.append("&minDateLastModified="); result.append(getMinDateLastModified()); } if (getMaxDateCreated() < Long.MAX_VALUE) { result.append("&maxDateCreated="); result.append(getMaxDateCreated()); } if (getMaxDateLastModified() < Long.MAX_VALUE) { result.append("&maxDateLastModified="); result.append(getMaxDateLastModified()); } if ((getRoots() != null) && (getRoots().size() > 0)) { result.append("&searchRoots="); Iterator<String> it = getRoots().iterator(); while (it.hasNext()) { result.append(CmsEncoder.encode(it.next())); if (it.hasNext()) { result.append(','); } } } if (isExcerptOnlySearchedFields()) { result.append("&excerptOnlySearchedFields=true"); } return result.toString(); } /** * @see java.lang.Object#toString() */ @Override public String toString() { StringBuffer result = new StringBuffer(); result.append("query:["); result.append(m_query); result.append("] "); if ((m_fields != null) && (m_fields.size() > 0)) { result.append("fields:["); for (int i = 0; i < m_fields.size(); i++) { result.append(m_fields.get(i)); if ((i + 1) < m_fields.size()) { result.append(", "); } } result.append("] "); } if ((m_roots != null) && (m_roots.size() > 0)) { result.append("roots:["); for (int i = 0; i < m_roots.size(); i++) { result.append(m_roots.get(i)); if ((i + 1) < m_roots.size()) { result.append(", "); } } result.append("] "); } if ((m_categories != null) && (m_categories.size() > 0)) { result.append("categories:["); for (int i = 0; i < m_categories.size(); i++) { result.append(m_categories.get(i)); if ((i + 1) < m_categories.size()) { result.append(", "); } } result.append("] "); } if ((m_resourceTypes != null) && (m_resourceTypes.size() > 0)) { result.append("resourceTypes:["); for (int i = 0; i < m_resourceTypes.size(); i++) { result.append(m_resourceTypes.get(i)); if ((i + 1) < m_resourceTypes.size()) { result.append(", "); } } result.append("] "); } if (m_calculateCategories) { result.append("calculate-categories "); } if (m_excerptOnlySearchedFields) { result.append("excerpt-searched-fields-only "); } result.append("sort:["); if (m_sort == CmsSearchParameters.SORT_DEFAULT) { result.append("default"); } else if (m_sort == CmsSearchParameters.SORT_TITLE) { result.append("title"); } else if (m_sort == CmsSearchParameters.SORT_DATE_CREATED) { result.append("date-created"); } else if (m_sort == CmsSearchParameters.SORT_DATE_LASTMODIFIED) { result.append("date-lastmodified"); } else { result.append("unknown"); } result.append("]"); return result.toString(); } /** * Concatenates the elements of the string list separated by the given separator character.<p> * * @param stringList the list * @param separator the separator * * @return the concatenated string */ private String toSeparatedString(List<String> stringList, char separator) { StringBuffer result = new StringBuffer(); Iterator<String> it = stringList.iterator(); while (it.hasNext()) { result.append(it.next()); if (it.hasNext()) { result.append(separator); } } return result.toString(); } }