Example usage for org.apache.solr.common.params FacetParams FACET_DATE

Introduction

In this page you can find the example usage for org.apache.solr.common.params FacetParams FACET_DATE_END.

Prototype

String FACET_DATE_END

To view the source code for org.apache.solr.common.params FacetParams FACET_DATE_END.

Click Source Link

Document

Date string indicating the ending point for a date facet range.

Usage

From source file:org.dspace.app.xmlui.aspect.discovery.AbstractFiltersTransformer.java

License:Open Source License

protected SolrQuery prepareDefaultFilters(String scope) {

    queryArgs = new SolrQuery();

    /* Get Dynamic list of Facets off Request *
    for(String facet : getFacetsList())//from   ww  w .  j a  v a  2s .  c o m
    {
    queryArgs.addFacetField(facet);
    int max = ConfigurationManager.getIntProperty("search.facet.max", 10) + 1;
    //Set the default limit to 11
    queryArgs.setFacetLimit(max);
    queryArgs.setFacetMinCount(1);
    queryArgs.setFacet(true);
    }                                     */

    String[] facets = SearchUtils.getFacetsForType(scope);
    String[] dateFacets = SearchUtils.getDateFacetsForType(scope);

    log.debug("facets for scope '" + scope + "': " + (facets != null ? facets.length : null));
    log.debug("date facets for scope, " + scope + ": " + (dateFacets != null ? dateFacets.length : null));

    if (facets != null || dateFacets != null) {
        int max = ConfigurationManager.getIntProperty("search.facet.max", 10) + 1;
        //Set the default limit to 11
        queryArgs.setFacetLimit(max);
        queryArgs.setFacetMinCount(1);
        queryArgs.setFacet(true);
    }

    /** enable faceting of search results */
    if (facets != null)
        queryArgs.addFacetField(facets);

    /** add any dateFacets configured */
    if (dateFacets != null && 0 < dateFacets.length) {
        queryArgs.setParam(FacetParams.FACET_DATE, dateFacets);
        queryArgs.setParam(FacetParams.FACET_DATE_GAP, "+1YEAR");
        queryArgs.setParam(FacetParams.FACET_DATE_START,
                "NOW/YEAR-" + SearchUtils.getConfig().getString("solr.date.gap", "10") + "YEARS");
        queryArgs.setParam(FacetParams.FACET_DATE_END, "NOW");
        queryArgs.setParam(FacetParams.FACET_DATE_OTHER, FacetParams.FacetDateOther.ALL.toString());
    }

    //Add the default filters
    queryArgs.addFilterQuery(SearchUtils.getDefaultFilters(scope));

    return queryArgs;
}

From source file:org.dspace.app.xmlui.aspect.discovery.BrowseFacet.java

License:Open Source License

/**
 * Get the recently submitted items for the given community or collection.
 *
 * @param scope The collection./* w  w w  .ja  v a 2s . c  o m*/
 */
protected QueryResponse getQueryResponse(DSpaceObject scope) {

    Request request = ObjectModelHelper.getRequest(objectModel);

    if (queryResults != null) {
        return queryResults;
    }

    queryArgs = new SolrQuery();

    //Make sure we add our default filters
    queryArgs.addFilterQuery(SearchUtils.getDefaultFilters(BROWSE_URL_BASE));

    queryArgs.setQuery("search.resourcetype: " + Constants.ITEM
            + ((request.getParameter("query") != null && !"".equals(request.getParameter("query")))
                    ? " AND (" + request.getParameter("query") + ")"
                    : ""));
    //        queryArgs.setQuery("search.resourcetype:" + Constants.ITEM);

    queryArgs.setRows(0);

    queryArgs.setSortField(ConfigurationManager.getProperty("recent.submissions.sort-option"),
            getParameterOrder());

    queryArgs.addFilterQuery(getParameterFacetQueries());

    queryArgs.setFacet(true);

    //Set the default limit to 11
    //query.setFacetLimit(11);
    queryArgs.setFacetMinCount(1);

    //sort
    //TODO: why this kind of sorting ? Should the sort not be on how many times the value appears like we do in the filter by sidebar ?
    queryArgs.setFacetSort(getParameterSortBy());

    String facetField = getParameterField();

    int page = getParameterPage();
    int rpp = getParameterRpp();

    // FIXME: Have to retrieve everything, since there is no way of getting total facets in order to do masked pagination.
    //        queryArgs.setParam(FacetParams.FACET_OFFSET, String.valueOf((page - 1) * rpp));
    //        queryArgs.setFacetLimit(rpp);//setParam(FacetParams.FACET_LIMIT, String.valueOf(rpp));
    queryArgs.setFacetLimit(-1);

    //        int offset = RequestUtils.getIntParameter(request, OFFSET);
    //        if (offset == -1) {
    //            offset = 0;
    //        }
    //        if (facetField != null && facetField.endsWith(".year")) {
    //            queryArgs.setParam(FacetParams.FACET_OFFSET, "0");
    //            queryArgs.setParam(FacetParams.FACET_LIMIT, "1000000");
    //            facetField = facetField.replace(".year", "");
    //        } else {
    //            queryArgs.setParam(FacetParams.FACET_OFFSET, String.valueOf(offset));
    //We add +1 so we can use the extra one to make sure that we need to show the next page
    //            queryArgs.setParam(FacetParams.FACET_LIMIT, String.valueOf(rpp));
    //        }

    if (scope != null) /* top level search / community */ {
        if (scope instanceof Community) {
            //queryArgs.setFilterQueries("location:m" + scope.getID());
            queryArgs.addFilterQuery("location:m" + scope.getID());
        } else if (scope instanceof Collection) {
            //queryArgs.setFilterQueries("location:l" + scope.getID());
            queryArgs.addFilterQuery("location:l" + scope.getID());
        }
    }

    boolean isDate = false;
    if (facetField != null && facetField.endsWith("_dt")) {
        facetField = facetField.split("_")[0];
        isDate = true;
    }

    if (isDate) {

        queryArgs.setParam(FacetParams.FACET_DATE, new String[] { facetField });
        queryArgs.setParam(FacetParams.FACET_DATE_GAP, "+1YEAR");

        Date lowestDate = getLowestDateValue(queryArgs.getQuery(), facetField, queryArgs.getFilterQueries());
        int thisYear = Calendar.getInstance().get(Calendar.YEAR);

        DateFormat formatter = new SimpleDateFormat("yyyy");
        int maxEndYear = Integer.parseInt(formatter.format(lowestDate));

        //Since we have a date, we need to find the last year
        String startDate = "NOW/YEAR-" + SearchUtils.getConfig().getString("solr.date.gap", "10") + "YEARS";
        String endDate = "NOW";
        //            int startYear = thisYear - (offset + DEFAULT_PAGE_SIZE);
        int startYear = thisYear - ((page - 1) * rpp);
        // We shouldn't go lower then our max bottom year
        // Make sure to substract one so the bottom year is also counted !
        if (startYear < maxEndYear) {
            startYear = maxEndYear - 1;
        }

        //            if (0 < offset) {
        if (page > 1) {
            //Say that we have an offset of 10 years
            //we need to go back 10 years (2010 - (2010 - 10))
            //(add one to compensate for the NOW in the start)
            //                int endYear = thisYear - offset + 1;
            int endYear = thisYear - ((page - 1) * rpp) + 1;

            endDate = "NOW/YEAR-" + (thisYear - endYear) + "YEARS";
            //Add one to the startyear to get one more result
            //When we select NOW, the current year is also used (so auto+1)
        }
        startDate = "NOW/YEAR-" + (thisYear - startYear) + "YEARS";

        queryArgs.setParam(FacetParams.FACET_DATE_START, startDate);
        queryArgs.setParam(FacetParams.FACET_DATE_END, endDate);

        queryArgs.setFacetMinCount(1);

        System.out.println(startDate);
        System.out.println(endDate);

    } else {
        queryArgs.addFacetField(new String[] { facetField });
    }

    //        log.debug("queryArgs: " + queryArgs.toString());

    String startsWith = getParameterStartsWith();
    if (startsWith != null) {
        queryArgs.setFacetPrefix(facetField, startsWith);
    }

    try {
        queryResults = searchService.search(queryArgs);
    } catch (SearchServiceException e) {
        log.error(e.getMessage(), e);
    }

    return queryResults;
}

From source file:org.dspace.app.xmlui.aspect.discovery.SearchFacetFilter.java

License:BSD License

/**
 * Get the recently submitted items for the given community or collection.
 *
 * @param scope The collection./*from w ww  .  j av  a2  s .co m*/
 */
protected QueryResponse getQueryResponse(DSpaceObject scope) {

    Request request = ObjectModelHelper.getRequest(objectModel);

    if (queryResults != null) {
        return queryResults;
    }

    queryArgs = new SolrQuery();

    //Make sure we add our default filters
    queryArgs.addFilterQuery(SearchUtils.getDefaultFilters("search"));

    queryArgs.setQuery("search.resourcetype: " + Constants.ITEM
            + ((request.getParameter("query") != null && !"".equals(request.getParameter("query")))
                    ? " AND (" + request.getParameter("query") + ")"
                    : ""));
    //        queryArgs.setQuery("search.resourcetype:" + Constants.ITEM);

    queryArgs.setRows(0);

    queryArgs.addFilterQuery(getParameterFilterQueries());

    //Set the default limit to 11
    //query.setFacetLimit(11);
    queryArgs.setFacetMinCount(1);

    //sort
    //TODO: why this kind of sorting ? Should the sort not be on how many times the value appears like we do in the filter by sidebar ?
    queryArgs.setFacetSort(config.getPropertyAsType("solr.browse.sort", "lex"));

    queryArgs.setFacet(true);
    String facetField = request.getParameter(SearchFilterParam.FACET_FIELD);

    int offset = RequestUtils.getIntParameter(request, SearchFilterParam.OFFSET);
    if (offset == -1) {
        offset = 0;
    }
    if (facetField.endsWith(".year")) {
        //            TODO: dates are now handled in another way, throw this away?
        queryArgs.setParam(FacetParams.FACET_OFFSET, "0");
        queryArgs.setParam(FacetParams.FACET_LIMIT, "1000000");

    } else {
        queryArgs.setParam(FacetParams.FACET_OFFSET, String.valueOf(offset));

        //We add +1 so we can use the extra one to make sure that we need to show the next page
        queryArgs.setParam(FacetParams.FACET_LIMIT, String.valueOf(DEFAULT_PAGE_SIZE + 1));
    }

    if (scope != null) /* top level search / community */ {
        if (scope instanceof Community) {
            queryArgs.setFilterQueries("location:m" + scope.getID());
        } else if (scope instanceof Collection) {
            queryArgs.setFilterQueries("location:l" + scope.getID());
        }
    }

    boolean isDate = false;
    if (facetField.endsWith("_dt")) {
        facetField = facetField.split("_")[0];
        isDate = true;
    }

    if (isDate) {

        queryArgs.setParam(FacetParams.FACET_DATE, facetField);
        queryArgs.setParam(FacetParams.FACET_DATE_GAP, "+1YEAR");

        Date lowestDate = getLowestDateValue(queryArgs.getQuery(), facetField, queryArgs.getFilterQueries());
        int thisYear = Calendar.getInstance().get(Calendar.YEAR);

        DateFormat formatter = new SimpleDateFormat("yyyy");
        int maxEndYear = Integer.parseInt(formatter.format(lowestDate));

        //Since we have a date, we need to find the last year
        String startDate = "NOW/YEAR-" + SearchUtils.getConfig().getString("solr.date.gap", "10") + "YEARS";
        String endDate = "NOW";
        int startYear = thisYear - (offset + DEFAULT_PAGE_SIZE);
        // We shouldn't go lower then our max bottom year
        // Make sure to substract one so the bottom year is also counted !
        if (startYear < maxEndYear) {
            startYear = maxEndYear - 1;
        }

        if (0 < offset) {
            //Say that we have an offset of 10 years
            //we need to go back 10 years (2010 - (2010 - 10))
            //(add one to compensate for the NOW in the start)
            int endYear = thisYear - offset + 1;

            endDate = "NOW/YEAR-" + (thisYear - endYear) + "YEARS";
            //Add one to the startyear to get one more result
            //When we select NOW, the current year is also used (so auto+1)
        }
        startDate = "NOW/YEAR-" + (thisYear - startYear) + "YEARS";

        queryArgs.setParam(FacetParams.FACET_DATE_START, startDate);
        queryArgs.setParam(FacetParams.FACET_DATE_END, endDate);

        System.out.println(startDate);
        System.out.println(endDate);

    } else {
        if (request.getParameter(SearchFilterParam.STARTS_WITH) != null) {
            queryArgs.setFacetPrefix(facetField,
                    request.getParameter(SearchFilterParam.STARTS_WITH).toLowerCase());
        }

        queryArgs.addFacetField(facetField);
    }

    try {
        queryResults = searchService.search(queryArgs);
    } catch (SearchServiceException e) {
        log.error(e.getMessage(), e);
    }

    return queryResults;
}

From source file:org.jahia.services.search.facets.SimpleJahiaJcrFacets.java

License:Open Source License

/**
 * @deprecated Use getFacetRangeCounts which is more generalized
 *//*from   w w  w.jav  a2  s.  c om*/
@Deprecated
public void getFacetDateCounts(String dateFacet, NamedList<Object> resOuter)
        throws IOException, ParseException, RepositoryException, JahiaException {

    parseParams(FacetParams.FACET_DATE, dateFacet);
    String f = facetValue;

    final NamedList<Object> resInner = new SimpleOrderedMap<Object>();
    String fieldName = StringUtils.substringBeforeLast(f, PROPNAME_INDEX_SEPARATOR);
    ExtendedPropertyDefinition epd = NodeTypeRegistry.getInstance()
            .getNodeType(params.get("f." + f + ".facet.nodetype")).getPropertyDefinition(fieldName);
    String fieldNameInIndex = getFieldNameInIndex(f, fieldName, epd, params.getFieldParam(f, "facet.locale"));
    String prefix = params.getFieldParam(f, FacetParams.FACET_PREFIX);
    DateField ft = StringUtils.isEmpty(prefix) ? JahiaQueryParser.DATE_TYPE : JahiaQueryParser.JR_DATE_TYPE;
    final SchemaField sf = new SchemaField(fieldNameInIndex, ft);

    // TODO: Should we use the key now ?
    //    resOuter.add(key, resInner);
    resOuter.add(fieldName + PROPNAME_INDEX_SEPARATOR + fieldNameInIndex, resInner);

    if (!(epd.getRequiredType() == PropertyType.DATE)) {
        throw new SolrException(SolrException.ErrorCode.BAD_REQUEST,
                "Can not date facet on a field which is not a DateField: " + f);
    }
    Integer minCount = params.getFieldInt(f, FacetParams.FACET_MINCOUNT);
    if (minCount == null) {
        Boolean zeros = params.getFieldBool(f, FacetParams.FACET_ZEROS);
        // mincount = (zeros!=null && zeros) ? 0 : 1;
        minCount = (zeros != null && !zeros) ? 1 : 0;
        // current default is to include zeros.
    }

    final String startS = required.getFieldParam(f, FacetParams.FACET_DATE_START);
    final Date start;
    try {
        start = JahiaQueryParser.DATE_TYPE.parseMath(NOW, startS);
    } catch (SolrException e) {
        throw new SolrException(SolrException.ErrorCode.BAD_REQUEST,
                "date facet 'start' is not a valid Date string: " + startS, e);
    }
    final String endS = required.getFieldParam(f, FacetParams.FACET_DATE_END);
    Date end; // not final, hardend may change this
    try {
        end = JahiaQueryParser.DATE_TYPE.parseMath(NOW, endS);
    } catch (SolrException e) {
        throw new SolrException(SolrException.ErrorCode.BAD_REQUEST,
                "date facet 'end' is not a valid Date string: " + endS, e);
    }

    if (end.before(start)) {
        throw new SolrException(SolrException.ErrorCode.BAD_REQUEST,
                "date facet 'end' comes before 'start': " + endS + " < " + startS);
    }

    final String gap = required.getFieldParam(f, FacetParams.FACET_DATE_GAP);
    final DateMathParser dmp = new DateMathParser(DateField.UTC, Locale.US);
    dmp.setNow(NOW);

    String[] iStrs = params.getFieldParams(f, FacetParams.FACET_DATE_INCLUDE);
    // Legacy support for default of [lower,upper,edge] for date faceting
    // this is not handled by FacetRangeInclude.parseParam because
    // range faceting has differnet defaults
    final EnumSet<FacetRangeInclude> include = (null == iStrs || 0 == iStrs.length)
            ? EnumSet.of(FacetRangeInclude.LOWER, FacetRangeInclude.UPPER, FacetRangeInclude.EDGE)
            : FacetRangeInclude.parseParam(iStrs);

    try {
        Date low = start;
        while (low.before(end)) {
            dmp.setNow(low);
            String label = JahiaQueryParser.DATE_TYPE.toExternal(low);

            Date high = dmp.parseMath(gap);
            if (end.before(high)) {
                if (params.getFieldBool(f, FacetParams.FACET_DATE_HARD_END, false)) {
                    high = end;
                } else {
                    end = high;
                }
            }
            if (high.before(low)) {
                throw new SolrException(SolrException.ErrorCode.BAD_REQUEST,
                        "date facet infinite loop (is gap negative?)");
            }
            final boolean includeLower = (include.contains(FacetRangeInclude.LOWER)
                    || (include.contains(FacetRangeInclude.EDGE) && low.equals(start)));
            final boolean includeUpper = (include.contains(FacetRangeInclude.UPPER)
                    || (include.contains(FacetRangeInclude.EDGE) && high.equals(end)));

            Query rangeQuery = getRangeQuery(ft, null, sf, prefix, low, high, includeLower, includeUpper);

            int count = rangeCount(rangeQuery);
            if (count >= minCount) {
                // TODO: Can we use just label here ?                  
                resInner.add(label + PROPNAME_INDEX_SEPARATOR + rangeQuery.toString(), count);
            }
            low = high;
        }
    } catch (java.text.ParseException e) {
        throw new SolrException(SolrException.ErrorCode.BAD_REQUEST,
                "date facet 'gap' is not a valid Date Math string: " + gap, e);
    }

    // explicitly return the gap and end so all the counts are meaningful
    resInner.add("gap", gap);
    resInner.add("start", start);
    resInner.add("end", end);

    final String[] othersP = params.getFieldParams(f, FacetParams.FACET_DATE_OTHER);
    if (null != othersP && 0 < othersP.length) {
        final Set<FacetDateOther> others = EnumSet.noneOf(FacetDateOther.class);

        for (final String o : othersP) {
            others.add(FacetDateOther.get(o));
        }

        // no matter what other values are listed, we don't do
        // anything if "none" is specified.
        if (!others.contains(FacetDateOther.NONE)) {
            boolean all = others.contains(FacetDateOther.ALL);

            if (all || others.contains(FacetDateOther.BEFORE)) {
                Query rangeQuery = getRangeQuery(ft, null, sf, prefix, null, start, false,
                        (include.contains(FacetRangeInclude.OUTER)
                                || (!(include.contains(FacetRangeInclude.LOWER)
                                        || include.contains(FacetRangeInclude.EDGE)))));
                int count = rangeCount(rangeQuery);
                if (count >= minCount) {
                    resInner.add(
                            FacetDateOther.BEFORE.toString() + PROPNAME_INDEX_SEPARATOR + rangeQuery.toString(),
                            count);
                }
            }
            if (all || others.contains(FacetDateOther.AFTER)) {
                Query rangeQuery = getRangeQuery(ft, null, sf, prefix, end, null,
                        (include.contains(FacetRangeInclude.OUTER)
                                || (!(include.contains(FacetRangeInclude.UPPER)
                                        || include.contains(FacetRangeInclude.EDGE)))),
                        false);
                int count = rangeCount(rangeQuery);
                if (count >= minCount) {
                    resInner.add(
                            FacetDateOther.AFTER.toString() + PROPNAME_INDEX_SEPARATOR + rangeQuery.toString(),
                            count);
                }
            }
            if (all || others.contains(FacetDateOther.BETWEEN)) {
                Query rangeQuery = getRangeQuery(ft, null, sf, prefix, start, end,
                        (include.contains(FacetRangeInclude.LOWER) || include.contains(FacetRangeInclude.EDGE)),
                        (include.contains(FacetRangeInclude.UPPER)
                                || include.contains(FacetRangeInclude.EDGE)));
                int count = rangeCount(rangeQuery);
                if (count >= minCount) {
                    resInner.add(FacetDateOther.BETWEEN.toString() + PROPNAME_INDEX_SEPARATOR
                            + rangeQuery.toString(), count);
                }
            }
        }
    }
}

Example usage for org.apache.solr.common.params FacetParams FACET_DATE_END

Introduction

Prototype

Document

Usage