org.dspace.discovery.DiscoverQuery java code examples

Add the Codota plugin to your IDE and get smart completions

private void myMethod () {
 ArrayList a =new ArrayList<String>()
new ArrayList()
new ArrayList<Object>()
Smart code suggestions by Codota
}

private DiscoverResult getSolrResponse() throws BrowseException {
  if (sResponse == null) {
    DiscoverQuery query = new DiscoverQuery();
    addLocationScopeFilter(query);
    addStatusFilter(query);
          DiscoveryConfigurationParameters.SORT.VALUE);
      query.addFacetField(dff);
      query.setFacetMinCount(1);
      query.setMaxResults(0);
    } else {
      query.setMaxResults(limit/* > 0 ? limit : 20*/);
      if (offset > 0) {
        query.setStart(offset);
        query.addFilterQueries("{!field f=" + facetField + "_authority_filter}"
                      + authority);
      } else if (value != null && !valuePartial) {
        query.addFilterQueries("{!field f=" + facetField + "_value_filter}" + value);
      } else if (valuePartial) {
        query.addFilterQueries("{!field f=" + facetField + "_partial}" + value);
      query.addFilterQueries("search.resourcetype:" + Constants.ITEM);
      if (orderField != null) {
        query.setSortField("bi_" + orderField + "_sort",
                  ascending ? SORT_ORDER.asc : SORT_ORDER.desc);

private String getNextPageURL(Request request) {
  Map<String, String> parameters = new HashMap<String, String>();
  parameters.put(FACET_FIELD, request.getParameter(FACET_FIELD));
  if (queryArgs.getFacetOffset() != -1)
  {
    parameters.put(OFFSET, String.valueOf(queryArgs.getFacetOffset() + DEFAULT_PAGE_SIZE));
  }
  // Add the filter queries
  String url = generateURL("browse-discovery", parameters);
  String[] fqs = getParameterFacetQueries();
  if (fqs != null) {
    StringBuilder urlBuilder = new StringBuilder(url);
    for (String fq : fqs) {
      urlBuilder.append("&fq=").append(fq);
    }
    url = urlBuilder.toString();
  }
  return url;
}

  @Override
  public String calculateExtremeValue(Context context, String valueField,
                    String sortField,
                    DiscoverQuery.SORT_ORDER sortOrder)
    throws SearchServiceException {

    DiscoverQuery maxQuery = new DiscoverQuery();
    maxQuery.setMaxResults(1);
    //Set our query to anything that has this value
    maxQuery.addFieldPresentQueries(valueField);
    //Set sorting so our last value will appear on top
    maxQuery.setSortField(sortField, sortOrder);
    maxQuery.addSearchField(valueField);
    DiscoverResult maxResult = this.search(context,maxQuery);
    if (0 < maxResult.getDspaceObjects().size()) {
      List<DiscoverResult.SearchDocument> searchDocuments = maxResult
        .getSearchDocument(maxResult.getDspaceObjects().get(0));
      if (0 < searchDocuments.size() && 0 < searchDocuments.get(0).getSearchFieldValues
        (valueField).size()) {
        return searchDocuments.get(0).getSearchFieldValues(valueField).get(0);
      }
    }
    return null;
  }
}

    /**
   * Retrieves the lowest date value in the given field
   * @param query a solr query
   * @param dateField the field for which we want to retrieve our date
   * @param filterquery the filterqueries
   * @return the lowest date found, in a date object
   */
  private Date getLowestDateValue(Context context, String query, String dateField, String... filterquery){


    try {
      DiscoverQuery discoverQuery = new DiscoverQuery();
      discoverQuery.setQuery(query);
      discoverQuery.setMaxResults(1);
      discoverQuery.setSortField(dateField, DiscoverQuery.SORT_ORDER.asc);
      discoverQuery.addFilterQueries(filterquery);

      DiscoverResult rsp = searchService.search(context, discoverQuery);
//            if(0 < rsp.getResults().getNumFound()){
//                return (Date) rsp.getResults().get(0).getFieldValue(dateField);
//            }
    }catch (Exception e){
      log.error("Unable to get lowest date", e);
    }
    return null;
  }

if(discoveryQuery.getQuery() != null){
  query = discoveryQuery.getQuery();
for (int i = 0; i < discoveryQuery.getFilterQueries().size(); i++) {
  String filterQuery = discoveryQuery.getFilterQueries().get(i);
  solrQuery.addFilterQuery(filterQuery);
if(discoveryQuery.getDSpaceObjectFilter() != -1){
  solrQuery.addFilterQuery("search.resourcetype:" + discoveryQuery.getDSpaceObjectFilter());
for (int i = 0; i < discoveryQuery.getFieldPresentQueries().size(); i++) {
  String filterQuery = discoveryQuery.getFieldPresentQueries().get(i);
  solrQuery.addFilterQuery(filterQuery + ":[* TO *]");
if(discoveryQuery.getStart() != -1){
  solrQuery.setStart(discoveryQuery.getStart());
if(discoveryQuery.getMaxResults() != -1){
  solrQuery.setRows(discoveryQuery.getMaxResults());
if(discoveryQuery.getSortField() != null){
  SolrQuery.ORDER order = SolrQuery.ORDER.asc;
  if(discoveryQuery.getSortOrder().equals(DiscoverQuery.SORT_ORDER.desc))
    order = SolrQuery.ORDER.desc;
  solrQuery.addSortField(discoveryQuery.getSortField(), order);
for(String property : discoveryQuery.getProperties().keySet()){
  List<String> values = discoveryQuery.getProperties().get(property);

public DiscoverQuery getQueryArgs(Context context, DSpaceObject scope, String... filterQueries) {
  DiscoverQuery queryArgs = new DiscoverQuery();
    queryArgs.setFacetMinCount(1);
  queryArgs.addFilterQueries(discoveryConfiguration.getDefaultFilterQueries().toArray(new String[discoveryConfiguration.getDefaultFilterQueries().size()]));
  queryArgs.addFilterQueries(filterQueries);
            DiscoverQuery yearRangeQuery = new DiscoverQuery();
            yearRangeQuery.setMaxResults(1);
            yearRangeQuery.addFieldPresentQueries(dateFacet);
            yearRangeQuery.setSortField(dateFacet + "_sort", DiscoverQuery.SORT_ORDER.asc);
            yearRangeQuery.addFilterQueries(filterQueries);
            yearRangeQuery.addSearchField(dateFacet);
            DiscoverResult lastYearResult = getSearchService().search(context, scope, yearRangeQuery);
            yearRangeQuery.setSortField(dateFacet + "_sort", DiscoverQuery.SORT_ORDER.desc);
            DiscoverResult firstYearResult = getSearchService().search(context, scope, yearRangeQuery);
            if( 0 < firstYearResult.getDspaceObjects().size()){
            queryArgs.addFacetField(new DiscoverFacetField(facet.getIndexFieldName(), facet.getType(), 10, facet.getSortOrder()));
          }else{
            java.util.List<String> facetQueries = new ArrayList<String>();
              queryArgs.addFacetQuery(facetQuery);
        queryArgs.addFacetField(new DiscoverFacetField(facet.getIndexFieldName(), DiscoveryConfigurationParameters.TYPE_TEXT, facetLimit, facet.getSortOrder()));

this.queryArgs = new DiscoverQuery();
queryArgs.addFilterQueries(defaultFilterQueries.toArray(new String[defaultFilterQueries.size()]));
  queryArgs.addFilterQueries(filterQueries.toArray(new String[filterQueries.size()]));
queryArgs.setMaxResults(getParameterRpp());
  queryArgs.setSortField(sortBy, DiscoverQuery.SORT_ORDER.desc);
  queryArgs.setSortField(sortBy, DiscoverQuery.SORT_ORDER.asc);
  queryArgs.addProperty("collapse.field", groupBy);
  queryArgs.addProperty("collapse.threshold", "1");
  queryArgs.addProperty("collapse.includeCollapsedDocs.fl", "handle");
  queryArgs.addProperty("collapse.facet", "before");
  queryArgs.setSortField("dc.type", DiscoverQuery.SORT_ORDER.asc);
queryArgs.setQuery(query != null && !query.trim().equals("") ? query : null);
  queryArgs.setStart((page - 1) * queryArgs.getMaxResults());
  queryArgs.setStart(0);

queryArgs = new DiscoverQuery();
queryArgs.addFilterQueries(defaultFilterQueries.toArray(new String[defaultFilterQueries.size()]));
queryArgs.setQuery(((request.getParameter("query") != null && !"".equals(request.getParameter("query").trim())) ? request.getParameter("query") : null));
queryArgs.setDSpaceObjectFilter(Constants.ITEM);
queryArgs.setMaxResults(0);
queryArgs.addFilterQueries(getDiscoveryFilterQueries());
queryArgs.setFacetMinCount(1);
queryArgs.setFacetOffset(offset);
queryArgs.addFacetField(discoverFacetField);

queryArgs = new DiscoverQuery();
queryArgs.setQuery("search.resourcetype: " + Constants.ITEM + ((request.getParameter("query") != null && !"".equals(request.getParameter("query"))) ? " AND (" + request.getParameter("query") + ")" : ""));
queryArgs.setMaxResults(0);
queryArgs.setSortField(
    ConfigurationManager.getProperty("recent.submissions.sort-option"),
    DiscoverQuery.SORT_ORDER.asc
);
queryArgs.addFilterQueries(getParameterFacetQueries());
queryArgs.setFacetMinCount(1);
queryArgs.setFacetOffset(offset);

collectionsCount = new HashMap<String, Integer>();
DiscoverQuery query = new DiscoverQuery();
query.setFacetMinCount(1);
query.addFacetField(new DiscoverFacetField("location.comm",
                      DiscoveryConfigurationParameters.TYPE_STANDARD, -1,
                      DiscoveryConfigurationParameters.SORT.COUNT));
query.addFacetField(new DiscoverFacetField("location.coll",
                      DiscoveryConfigurationParameters.TYPE_STANDARD, -1,
                      DiscoveryConfigurationParameters.SORT.COUNT));
query.addFilterQueries("search.resourcetype:2");    // count only items
query.addFilterQueries("NOT(discoverable:false)");  // only discoverable
query.setMaxResults(0);

this.response = ObjectModelHelper.getResponse(objectModel);
DiscoverQuery queryArgs = new DiscoverQuery();
queryArgs.setQuery(request.getParameter("q"));
  queryArgs.addFilterQueries(request.getParameterValues("fq"));
    queryArgs.addFacetField(new DiscoverFacetField(facetField, DiscoveryConfigurationParameters.TYPE_AC, facetLimit, facetSort));
  facetMinCount = 1;
queryArgs.setFacetMinCount(facetMinCount);
String jsonWrf = request.getParameter("json.wrf");

result.setStart(query.getStart());
result.setMaxResults(query.getMaxResults());
result.setTotalSearchResults(solrQueryResponse.getResults().getNumFound());
List<String> searchFields = query.getSearchFields();
for (SolrDocument doc : solrQueryResponse.getResults()) {
  DSpaceObject dso = findDSpaceObject(context, doc);
  for (int i = 0; i <  facetFields.size(); i++) {
    FacetField facetField = facetFields.get(i);
    DiscoverFacetField facetFieldConfig = query.getFacetFields().get(i);
    List<FacetField.Count> facetValues = facetField.getValues();
    if (facetValues != null) {

DiscoverQuery queryArgs = new DiscoverQuery();
queryArgs.addFilterQueries(defaultFilterQueries.toArray(new String[defaultFilterQueries.size()]));
queryArgs.setDSpaceObjectFilter(Constants.ITEM);
  queryArgs.setMaxResults(recentSubmissionConfiguration.getMax());
  String sortField = SearchUtils.getSearchService().toSortFieldIndex(recentSubmissionConfiguration.getMetadataSortField(), recentSubmissionConfiguration.getType());
  if(sortField != null){
    queryArgs.setSortField(
        sortField,
        DiscoverQuery.SORT_ORDER.desc

  params.put(CommonParams.Q, URLEncoder.encode(query.getQuery(), org.dspace.constants.Constants.DEFAULT_ENCODING));
params.put(FacetParams.FACET_MINCOUNT, String.valueOf(query.getFacetMinCount()));
if (query.getFacetFields() != null || query.getFilterQueries() != null) {
  StringBuilder urlBuilder = new StringBuilder(solrRequestUrl);
  if(query.getFacetFields() != null){
    for (DiscoverFacetField facetFieldConfig : query.getFacetFields()) {
      urlBuilder.append("&").append(FacetParams.FACET_FIELD).append("=");
  if(query.getFilterQueries() != null){
    for (String filterQuery : query.getFilterQueries()) {
      try {
        urlBuilder.append("&").append(CommonParams.FQ).append("=").append(URLEncoder.encode(filterQuery, org.dspace.constants.Constants.DEFAULT_ENCODING));

                     boolean items, boolean collections, boolean withdrawn,
                     boolean nonAnon) throws SQLException, ParseException {
DiscoverQuery discoverQuery = new DiscoverQuery();
discoverQuery.addFilterQueries("search.resourcetype:" + Constants.ITEM);
    discoverQuery.addFilterQueries("location:m" + scope.getID());
  } else if (scope instanceof Collection) {
    discoverQuery.addFilterQueries("location:l" + scope.getID());
  discoverQuery.addFilterQueries("lastModified:[" + new DCDate(startDate).toString()
                      + " TO " + new DCDate(endDate).toString() + "]");
} else if (startDate != null) {
  discoverQuery.addFilterQueries("lastModified:[" + new DCDate(startDate).toString() + " TO *]");
} else if (endDate != null) {
  discoverQuery.addFilterQueries("lastModified:[* TO " + new DCDate(endDate).toString() + " ]");
  discoverQuery.addFilterQueries("archived: true OR withdrawn: false");
} else {
  discoverQuery.addFilterQueries("archived: true OR withdrawn: true");
discoverQuery.setSortField("search.resourceid", DiscoverQuery.SORT_ORDER.asc);

@Override
public String doMaxQuery(String column, String table, int itemID)
  throws BrowseException {
  DiscoverQuery query = new DiscoverQuery();
  query.setQuery("search.resourceid:" + itemID
            + " AND search.resourcetype:" + Constants.ITEM);
  query.setMaxResults(1);
  DiscoverResult resp = null;
  try {
    resp = searcher.search(context, query);
  } catch (SearchServiceException e) {
    throw new BrowseException(e);
  }
  if (resp.getTotalSearchResults() > 0) {
    SearchDocument doc = resp.getSearchDocument(
      resp.getDspaceObjects().get(0)).get(0);
    return (String) doc.getSearchFieldValues(column).get(0);
  }
  return null;
}

public void addYearRangeFacet(DiscoverySearchFilterFacet facet, FacetYearRange facetYearRange) {
  if (facetYearRange.isValid()) {
    int newestYear = facetYearRange.getNewestYear();
    int oldestYear = facetYearRange.getOldestYear();
    String dateFacet = facetYearRange.getDateFacet();
    int gap = facetYearRange.getYearGap();
    // We need to determine our top year so we can start our count from a clean year
    // Example: 2001 and a gap from 10 we need the following result: 2010 - 2000 ; 2000 - 1990 hence the top
    // year
    int topYear = getTopYear(newestYear, gap);
    if (gap == 1) {
      //We need a list of our years
      //We have a date range add faceting for our field
      //The faceting will automatically be limited to the 10 years in our span due to our filterquery
      this.addFacetField(new DiscoverFacetField(facet.getIndexFieldName(), facet.getType(), 10,
                           facet.getSortOrderSidebar()));
    } else {
      List<String> facetQueries = buildFacetQueriesWithGap(newestYear, oldestYear, dateFacet, gap, topYear,
                                 facet.getFacetLimit());
      for (String facetQuery : CollectionUtils.emptyIfNull(facetQueries)) {
        this.addFacetQuery(facetQuery);
      }
    }
  }
}

private void addLocationScopeFilter(DiscoverQuery query) {
  if (containerID != null) {
    if (containerIDField.startsWith("collection")) {
      query.addFilterQueries("location.coll:" + containerID);
    } else if (containerIDField.startsWith("community")) {
      query.addFilterQueries("location.comm:" + containerID);
    }
  }
}

DiscoverQuery discoverQuery = new DiscoverQuery();
if (StringUtils.isNotBlank(type)) {
  discoverQuery.addFilterQueries("dc.type=" + type + "*");
discoverQuery.addFilterQueries(accessionedQuery.toString());
discoverQuery.addFilterQueries("withdrawn: false");
discoverQuery.addFilterQueries("archived: true");

+ (queryArgs == null ? "" : queryArgs.getQuery()) + "\",results=(" + countCommunities + ","
+ countCollections + "," + countItems + ")"));

Javadoc

This class represents a query which the discovery backend can use

Most used methods

addFilterQueries
Adds new filter queries
getFacetOffset
Gets the facet field offset
getMaxResults
The maximum number of results returned by this query
getQuery
<init>
addFacetField
Adds a new facet field
addFacetQuery
Adds a new facet query
addFieldPresentQueries
Adds a query that will ensure that a certain field is present in the index
addSearchField
getDSpaceObjectFilter
Gets the DSpace object filter can be used to only return objects from a certain DSpace Object type
getFacetFields
Gets the facets fields configured
getFacetMinCount
Gets the minimum number of values that need to be present before a valid facet value has been found

Popular in Java

Reading from database using SQL prepared statement
onCreateOptionsMenu (Activity)
getSharedPreferences (Context)
scheduleAtFixedRate (Timer)
Schedules the specified task for repeated fixed-rate execution, beginning after the specified delay.
OutputStream (java.io)
A writable sink for bytes.Most clients will use output streams that write data to the file system (
SQLException (java.sql)
An exception that indicates a failed JDBC operation. It provides the following information about pro
Stack (java.util)
The Stack class represents a last-in-first-out (LIFO) stack of objects. It extends class Vector with
StringTokenizer (java.util)
The string tokenizer class allows an application to break a string into tokens. The tokenization met
Timer (java.util)
A facility for threads to schedule tasks for future execution in a background thread. Tasks may be s
HttpServlet (javax.servlet.http)
Provides an abstract class to be subclassed to create an HTTP servlet suitable for a Web site. A sub

How to useDiscoverQuery in org.dspace.discovery

Best Java code snippets using org.dspace.discovery.DiscoverQuery (Showing top 20 results out of 315)

How to use
DiscoverQuery
in
org.dspace.discovery