How to use

org.dspace.discovery.DiscoverQuery

constructor

DiscoverQuery discoverQuery = new DiscoverQuery();
if (StringUtils.isNotBlank(type)) {
  discoverQuery.addFilterQueries("dc.type=" + type + "*");

private void calculateNewRangeBasedOnSearchIndex(Context context, List<String> filterQueries, DSpaceObject scope,
                         SearchService searchService) throws SearchServiceException {
  DiscoverQuery yearRangeQuery = new DiscoverQuery();
  yearRangeQuery.setMaxResults(1);
  //Set our query to anything that has this value
  yearRangeQuery.addFieldPresentQueries(dateFacet);
  //Set sorting so our last value will appear on top
  yearRangeQuery.setSortField(dateFacet + "_sort", DiscoverQuery.SORT_ORDER.asc);
  yearRangeQuery.addFilterQueries(filterQueries.toArray(new String[filterQueries.size()]));
  yearRangeQuery.addSearchField(dateFacet);
  DiscoverResult lastYearResult = searchService.search(context, scope, yearRangeQuery);
  if (0 < lastYearResult.getDspaceObjects().size()) {
    List<DiscoverResult.SearchDocument> searchDocuments = lastYearResult
      .getSearchDocument(lastYearResult.getDspaceObjects().get(0));
    if (0 < searchDocuments.size() && 0 < searchDocuments.get(0).getSearchFieldValues(dateFacet).size()) {
      oldestYear = Integer.parseInt(searchDocuments.get(0).getSearchFieldValues(dateFacet).get(0));
    }
  }
  //Now get the first year
  yearRangeQuery.setSortField(dateFacet + "_sort", DiscoverQuery.SORT_ORDER.desc);
  DiscoverResult firstYearResult = searchService.search(context, scope, yearRangeQuery);
  if (0 < firstYearResult.getDspaceObjects().size()) {
    List<DiscoverResult.SearchDocument> searchDocuments = firstYearResult
      .getSearchDocument(firstYearResult.getDspaceObjects().get(0));
    if (0 < searchDocuments.size() && 0 < searchDocuments.get(0).getSearchFieldValues(dateFacet).size()) {
      newestYear = Integer.parseInt(searchDocuments.get(0).getSearchFieldValues(dateFacet).get(0));
    }
  }
}

  @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;
  }
}

@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;
}

    /**
   * 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;
  }

public DiscoverQuery getQueryArgs(Context context, DSpaceObject scope, String... filterQueries) {
  DiscoverQuery queryArgs = new DiscoverQuery();
            DiscoverQuery yearRangeQuery = new DiscoverQuery();
            yearRangeQuery.setMaxResults(1);

collectionsCount = new HashMap<String, Integer>();
DiscoverQuery query = new DiscoverQuery();
query.setFacetMinCount(1);
query.addFacetField(new DiscoverFacetField("location.comm",

DiscoverQuery queryArgs = new DiscoverQuery();

queryArgs = new DiscoverQuery();

queryArgs = new DiscoverQuery();

this.response = ObjectModelHelper.getResponse(objectModel);
DiscoverQuery queryArgs = new DiscoverQuery();

this.queryArgs = new DiscoverQuery();

                     boolean items, boolean collections, boolean withdrawn,
                     boolean nonAnon) throws SQLException, ParseException {
DiscoverQuery discoverQuery = new DiscoverQuery();
discoverQuery.addFilterQueries("search.resourcetype:" + Constants.ITEM);

private DiscoverResult getSolrResponse() throws BrowseException {
  if (sResponse == null) {
    DiscoverQuery query = new DiscoverQuery();
    addLocationScopeFilter(query);
    addStatusFilter(query);

@Override
public int doOffsetQuery(String column, String value, boolean isAscending)
  throws BrowseException {
  DiscoverQuery query = new DiscoverQuery();
  addLocationScopeFilter(query);
  addStatusFilter(query);