Example usage for org.apache.solr.client.solrj SolrQuery setFacet

List of usage examples for org.apache.solr.client.solrj SolrQuery setFacet

  1. HOME
  2. Java
  3. org.apache.solr
  4. org.apache.solr.client.solrj.*
  5. SolrQuery
  6. setFacet

Introduction

In this page you can find the example usage for org.apache.solr.client.solrj SolrQuery setFacet.

Prototype

public SolrQuery setFacet(boolean b)

Source Link

Document

enable/disable faceting.

Usage

From source file:edu.vt.vbi.patric.common.DataApiHandler.java

License:Apache License

public SolrQuery buildSolrQuery(Map<String, String> key, String sorts, String facets, int start, int end,
        boolean highlight) {

    SolrQuery query = new SolrQuery();
    SolrInterface solr = new SolrInterface();

    // Processing key map
    query.setQuery(StringHelper.stripQuoteAndParseSolrKeywordOperator(key.get("keyword")));

    if (key.containsKey("filter") && key.get("filter") != null) {
        query.addFilterQuery(key.get("filter"));
    }/* w  w  w.  j  a va  2 s.c  o m*/
    if (key.containsKey("filter2") && key.get("filter2") != null) {
        query.addFilterQuery(key.get("filter2"));
    }

    // use SolrJoin if possible
    if (key.containsKey("join")) {
        query.addFilterQuery(key.get("join"));
    }

    if (key.containsKey("fields") && !key.get("fields").equals("")) {
        query.addField(key.get("fields"));
    }

    // sort conditions
    if (sorts != null && !sorts.equals("") && !sorts.equals("[]")) {
        try {
            JSONArray sorter = (JSONArray) new JSONParser().parse(sorts);
            for (Object aSort : sorter) {
                JSONObject jsonSort = (JSONObject) aSort;
                query.addSort(SolrQuery.SortClause.create(jsonSort.get("property").toString(),
                        jsonSort.get("direction").toString().toLowerCase()));
            }
        } catch (ParseException e) {
            LOGGER.error(e.getMessage(), e);
        }
    }

    // facet conditions
    if (facets != null && !facets.equals("") && !facets.equals("{}")) {
        query.setFacet(true).setFacetMinCount(1).setFacetLimit(-1).setFacetSort(FacetParams.FACET_SORT_COUNT)
                .set("json.nl", "map");

        try {
            JSONObject facetConditions = (JSONObject) new JSONParser().parse(facets);

            if (facetConditions.containsKey("facet.sort")) {
                String facetSort = facetConditions.get("facet.sort").toString();
                if (facetSort.equals("index")) {
                    query.setFacetSort(FacetParams.FACET_SORT_INDEX);
                }
            }

            if (facetConditions.containsKey("field_facets")) {
                String[] fieldFacets = facetConditions.get("field_facets").toString().split(",");
                query.addFacetField(fieldFacets);
            }

            if (facetConditions.containsKey("date_range_facets")
                    && !facetConditions.get("date_range_facets").equals("")) {
                String[] dateRangeFacets = facetConditions.get("date_range_facets").toString().split(",");
                for (String field : dateRangeFacets) {
                    query.addDateRangeFacet(field, solr.getRangeStartDate(), solr.getRangeEndDate(),
                            solr.getRangeDate());
                }
            }
        } catch (ParseException e) {
            LOGGER.error(e.getMessage(), e);
        }
    }

    // start & end
    query.setStart(start); // setting starting index

    if (end == -1) {
        query.setRows(MAX_ROWS);
    } else {
        query.setRows(end);
    }

    // highlight
    if (highlight) {
        query.set("hl", "on").set("hl.fl", "*");
    }

    return query;
}

From source file:edu.vt.vbi.patric.portlets.GenomeBrowser.java

License:Apache License

private List<Integer> getFeatureCountHistogram(ResourceRequest request) throws IOException {

    String accession = request.getParameter("accession");
    String annotation = request.getParameter("annotation");
    String genomeId = request.getParameter("genomeId");

    SolrQuery query = new SolrQuery("accession:" + accession + " AND genome_id:" + genomeId);
    query.setFilterQueries("annotation:" + annotation + " AND !(feature_type:source)");
    query.setRows(0);//from  w ww.  java2 s. c  o m
    query.setFacet(true);
    query.setFacetMinCount(1);
    query.addNumericRangeFacet("start", 0, 10000000, 10000);

    List<Integer> results = new ArrayList<>();
    DataApiHandler dataApi = new DataApiHandler(request);

    LOGGER.trace("[{}] {}", SolrCore.FEATURE.getSolrCoreName(), query.toString());
    String apiResponse = dataApi.solrQuery(SolrCore.FEATURE, query);
    Map resp = jsonReader.readValue(apiResponse);
    Map facetCounts = (Map) resp.get("facet_counts");
    Map facetRanges = (Map) facetCounts.get("facet_ranges");
    List counts = (List) ((Map) facetRanges.get("start")).get("counts");

    for (int i = 0; i < counts.size(); i = i + 2) {
        int value = (Integer) counts.get(i + 1);
        results.add(value);
    }

    return results;
}

From source file:edu.vt.vbi.patric.portlets.TranscriptomicsGeneExp.java

License:Apache License

private JSONObject processSummary(ResourceRequest request) {
    JSONObject jsonResult = new JSONObject();

    String paramFeatureId = request.getParameter("featureId");
    String paramSampleId = request.getParameter("sampleId");
    String paramKeyword = request.getParameter("keyword");
    String paramLogRatio = request.getParameter("log_ratio");
    String paramZScore = request.getParameter("zscore");

    try {//  w w  w . j a  va 2s .  co m
        DataApiHandler dataApi = new DataApiHandler(request);
        //select?q=feature_id:PATRIC.83332.12.NC_000962.CDS.34.1524.fwd&rows=0&facet=true&facet.range.other=before&facet.range.other=after
        // &facet.range.start=-2&facet.range.end=2&facet.range.gap=0.5&facet.range=z_score&facet.range=log_ratio

        //select?q=feature_id:PATRIC.83332.12.NC_000962.CDS.34.1524.fwd&rows=0&facet=true&facet.mincount=1&facet.field=strain&facet.field=mutant&facet.field=condition
        SolrQuery query = new SolrQuery();

        if (paramKeyword != null && !paramKeyword.equals("")) {
            query.setQuery(paramKeyword + " AND feature_id:" + paramFeatureId);
        } else {
            query.setQuery("feature_id:" + paramFeatureId);
        }

        if (paramSampleId != null && !paramSampleId.equals("")) {
            String[] pids = paramSampleId.split(",");

            query.addFilterQuery("pid:(" + StringUtils.join(pids, " OR ") + ")");
        }
        if (paramLogRatio != null && !paramLogRatio.equals("") && !paramLogRatio.equals("0")) {
            query.addFilterQuery(
                    "log_ratio:[* TO -" + paramLogRatio + "] OR log_ratio:[" + paramLogRatio + " TO *]");
        }
        if (paramZScore != null && !paramZScore.equals("") && !paramZScore.equals("0")) {
            query.addFilterQuery("z_score:[* TO -" + paramZScore + "] OR z_score:[" + paramZScore + " TO *]");
        }

        query.setRows(dataApi.MAX_ROWS);
        query.setFacet(true).setFacetMinCount(1).set("json.nl", "map");
        query.set("facet.range.other", "before").add("facet.range.other", "after");
        query.addNumericRangeFacet("log_ratio", -2, 2, 0.5).addNumericRangeFacet("z_score", -2, 2, 0.5);
        query.addFacetField("strain").addFacetField("mutant").addFacetField("condition");

        LOGGER.debug("[{}] {}", SolrCore.TRANSCRIPTOMICS_GENE.getSolrCoreName(), query.toString());

        String apiResponse = dataApi.solrQuery(SolrCore.TRANSCRIPTOMICS_GENE, query);

        Map resp = jsonReader.readValue(apiResponse);
        Map respBody = (Map) resp.get("response");

        List<Map> sdl = (List<Map>) respBody.get("docs");

        // features
        JSONArray features = new JSONArray();
        for (Map doc : sdl) {
            JSONObject feature = new JSONObject();
            feature.put("exp_accession", doc.get("accession"));
            // feature.put("exp_channels", doc.get(""));
            feature.put("exp_condition", doc.get("condition"));
            feature.put("exp_id", doc.get("eid"));
            feature.put("exp_locustag", doc.get("refseq_locus_tag"));
            feature.put("exp_mutant", doc.get("mutant"));
            feature.put("exp_name", doc.get("expname"));
            feature.put("exp_organism", doc.get("organism"));
            feature.put("exp_pavg", doc.get("avg_intensity"));
            feature.put("exp_platform", doc.get("")); // ??
            feature.put("exp_pratio", doc.get("log_ratio"));
            feature.put("exp_samples", doc.get("")); // ??
            feature.put("exp_strain", doc.get("")); // ??
            feature.put("exp_timepoint", doc.get("timepoint"));
            feature.put("exp_zscore", doc.get("z_score"));
            // feature.put("figfam_id", doc.get("")); // ??
            feature.put("locus_tag", doc.get("alt_locus_tag"));
            feature.put("feature_id", doc.get("feature_id"));
            feature.put("pid", doc.get("pid"));
            feature.put("pmid", doc.get("pmid"));

            features.add(feature);
        }
        jsonResult.put("features", features);

        Map facets = (Map) resp.get("facet_counts");

        Map facetRanges = (Map) facets.get("facet_ranges");

        if (facetRanges.containsKey("log_ratio")) {
            Map facetLogRatio = (Map) facetRanges.get("log_ratio");
            final int before = (Integer) facetLogRatio.get("before");
            final int after = (Integer) facetLogRatio.get("after");
            Map facetRangeLogRatio = (Map) facetLogRatio.get("counts");

            List<JSONObject> list = new ArrayList<>();

            for (Map.Entry<String, Integer> entry : (Iterable<Map.Entry>) facetRangeLogRatio.entrySet()) {
                JSONObject json = new JSONObject();
                json.put("category", entry.getKey());
                json.put("count", entry.getValue());

                list.add(json);
            }

            boolean hasMinBucket = false;
            boolean hasMaxBucket = false;
            for (JSONObject entry : list) {
                if (entry.get("category").equals("-2.0")) {
                    entry.put("count", ((Integer) entry.get("count") + before));
                    hasMinBucket = true;
                } else if (entry.get("category").equals("2.0")) {
                    entry.put("count", ((Integer) entry.get("count") + after));
                    hasMaxBucket = true;
                }
            }
            if (!hasMinBucket) {
                JSONObject json = new JSONObject();
                json.put("category", "-2.0");
                json.put("count", before);
                list.add(json);
            }
            if (!hasMaxBucket) {
                JSONObject json = new JSONObject();
                json.put("category", "2.0");
                json.put("count", after);
                list.add(json);
            }

            jsonResult.put("log_ratio", list);
        }

        if (facetRanges.containsKey("z_score")) {
            Map facetZscore = (Map) facetRanges.get("z_score");
            final int before = (Integer) facetZscore.get("before");
            final int after = (Integer) facetZscore.get("after");
            Map facetRangeZscore = (Map) facetZscore.get("counts");

            List<JSONObject> list = new ArrayList<>();
            for (Map.Entry<String, Integer> entry : (Iterable<Map.Entry>) facetRangeZscore.entrySet()) {
                JSONObject json = new JSONObject();
                json.put("category", entry.getKey());
                json.put("count", entry.getValue());

                list.add(json);
            }

            boolean hasMinBucket = false;
            boolean hasMaxBucket = false;
            for (JSONObject entry : list) {
                if (entry.get("category").equals("-2.0")) {
                    entry.put("count", ((Integer) entry.get("count") + before));
                    hasMinBucket = true;
                } else if (entry.get("category").equals("2.0")) {
                    entry.put("count", ((Integer) entry.get("count") + after));
                    hasMaxBucket = true;
                }
            }
            if (!hasMinBucket) {
                JSONObject json = new JSONObject();
                json.put("category", "-2.0");
                json.put("count", before);
                list.add(json);
            }
            if (!hasMaxBucket) {
                JSONObject json = new JSONObject();
                json.put("category", "2.0");
                json.put("count", after);
                list.add(json);
            }

            jsonResult.put("z_score", list);
        }

        Map facetFields = (Map) facets.get("facet_fields");

        // strain
        if (facetFields.containsKey("strain")) {
            Map facetStrain = (Map) facetFields.get("strain");
            List<JSONObject> list = new ArrayList<>();
            for (Map.Entry<String, Integer> entry : (Iterable<Map.Entry>) facetStrain.entrySet()) {
                JSONObject json = new JSONObject();
                json.put("category", entry.getKey());
                json.put("count", entry.getValue());

                list.add(json);
            }
            jsonResult.put("strain", list);
        }

        // mutant
        if (facetFields.containsKey("mutant")) {
            Map facetMutant = (Map) facetFields.get("mutant");
            List<JSONObject> list = new ArrayList<>();
            for (Map.Entry<String, Integer> entry : (Iterable<Map.Entry>) facetMutant.entrySet()) {
                JSONObject json = new JSONObject();
                json.put("category", entry.getKey());
                json.put("count", entry.getValue());

                list.add(json);
            }
            jsonResult.put("mutant", list);
        }

        // condition
        if (facetFields.containsKey("condition")) {
            Map facetCondition = (Map) facetFields.get("condition");
            List<JSONObject> list = new ArrayList<>();
            for (Map.Entry<String, Integer> entry : (Iterable<Map.Entry>) facetCondition.entrySet()) {
                JSONObject json = new JSONObject();
                json.put("category", entry.getKey());
                json.put("count", entry.getValue());

                list.add(json);
            }
            jsonResult.put("condition", list);
        }
    } catch (IOException e) {
        LOGGER.error(e.getMessage(), e);
    }

    return jsonResult;
}

From source file:eu.europeana.core.BeanQueryModelFactory.java

License:EUPL

@Override
public QueryResponse getSolrResponse(SolrQuery solrQuery, boolean isBriefDoc, Map<String, String[]> params)
        throws EuropeanaQueryException { // add bean to ???
    // since we make a defensive copy before the start is decremented we must do it here
    if (solrQuery.getStart() != null && solrQuery.getStart() > 0) {
        solrQuery.setStart(solrQuery.getStart() - 1);
    }//from w  w  w.j ava 2s.co  m
    // set facets
    if (isBriefDoc) {
        // only show spelling-suggestion on the first result page
        if ((solrQuery.getStart() == null || solrQuery.getStart() == 0)
                && solrQuery.getFilterQueries() == null) {
            // give spelling suggestions
            solrQuery.setParam("spellcheck", true);
            solrQuery.setParam("spellcheck.collate", true);
            solrQuery.setParam("spellcheck.extendedResults", true);
            solrQuery.setParam("spellcheck.onlyMorePopular", true);
            //                solrQuery.setParam("spellcheck.count", "4");
        }
        solrQuery.setFacet(true);
        solrQuery.setFacetMinCount(1);
        //solrQuery.setFacetLimit(100); solr default is 100 so doesn't need to be set explicitly
        if (solrQuery.getRows() == null) {
            solrQuery.setRows(12);
        }
        solrQuery.addFacetField(ThemeFilter.getTheme().getRecordDefinition().getFacetFieldStrings());
        // todo now hard-coded but these values must be retrieved from the RecordDefinition later
        if (solrQuery.getFields() == null) {
            solrQuery.setFields(
                    "europeana_uri,dc_title,europeana_object,dc_creator,europeana_year,europeana_provider,"
                            + "europeana_dataProvider,europeana_language,europeana_type,dc_description,dc_type");
            //            solrQuery.setFields("*,score");
            //            solrQuery.setFields(metadataModel.getRecordDefinition().getFieldStrings());
        }
        if (solrQuery.getQueryType().equalsIgnoreCase(QueryType.SIMPLE_QUERY.toString())) {
            solrQuery.setQueryType(queryAnalyzer
                    .findSolrQueryType(solrQuery.getQuery(), ThemeFilter.getTheme().getRecordDefinition())
                    .toString());
        }
    }
    SolrQuery dCopy = addHiddenQueryFilters(solrQuery, params);
    return getSolrResponseFromServer(dCopy, false);
}

From source file:eu.europeana.web.timeline.server.SolrServiceImpl.java

License:EUPL

@Override
public List<Year> retrieveYears() {
    List<Year> years = new ArrayList<Year>();
    SolrQuery solrQuery = new SolrQuery();
    solrQuery.setQuery("*:*");
    solrQuery.setFacet(true);
    solrQuery.addFacetField("YEAR");
    solrQuery.setRows(0);/*from w ww. j  a  v a2  s  .c o  m*/
    solrQuery.setFacetLimit(20);
    solrQuery.setFacetSort(FacetParams.FACET_SORT);
    solrQuery.setSortField("YEAR", SolrQuery.ORDER.desc);
    solrQuery.setFilterQueries("YEAR:[* TO *]", "-YEAR:0000");
    LOG.fine(String.format("Query : %s", solrQuery));
    QueryResponse response = null;
    try {
        response = solrServer.query(solrQuery);

        List<FacetField> facetFields = response.getFacetFields();
        for (FacetField field : facetFields) {
            for (FacetField.Count count : field.getValues()) {
                Year year = new Year();
                year.setYear(count.getName());
                year.setAvailableItemCount(count.getCount());
                if (count.getCount() > 0) {
                    years.add(year);
                }
            }
        }
    } catch (SolrServerException e) {
        LOG.severe(String.format("Error during Solr query for years : %s", e));
    }
    return response == null ? null : years;
}

From source file:eu.prestoprime.search.util.SolrQueryUtils.java

License:Open Source License

/**
 * Enable faceting on this solrQuery. Also sets the fields for faceting from
 * the Hashmaps key. If this is already a subsequent query you have to put
 * the selected facetValues to the appropriate value fields of the Hashmap
 * //from  w  w w .  ja v a  2 s .c om
 * @param solrQuery
 *            solrQuery object
 * @param facets
 *            a HashMap containing facetFields and values as key and value
 *            respectively
 */
public static void setFacets(SolrQuery solrQuery, Map<P4FacetField, String> facets) {
    solrQuery.setFacet(true).setFacetLimit(10).setFacetMinCount(2);

    if (facets == null)
        facets = getDefaultFacetMap();

    for (Entry<P4FacetField, String> facet : facets.entrySet()) {
        // enable faceting on this field
        if (facet.getKey().getAssocField().getType().equals(Schema.FieldType.TDATE)) {
            // rangefacet on all fields of type tdate
            solrQuery.addDateRangeFacet(facet.getKey().getFieldName(), new Date(0), new Date(),
                    SearchConstants.getString("dateRangeFacetGranularity"));
            LOGGER.debug("Enable range faceting on field '" + facet.getKey().getFieldName() + "'");
        } else {
            solrQuery.addFacetField(facet.getKey().getFieldName());
            LOGGER.debug("Enable faceting on field '" + facet.getKey().getFieldName() + "'");
        }

        // if there is already a value for filtering on this facet then add
        // a filterquery for this
        if (facet.getValue() != null && facet.getValue().length() > 0) {
            LOGGER.debug("Set facet value '" + facet.getValue() + "' for field '"
                    + facet.getKey().getFieldName() + "'");
            solrQuery.addFilterQuery(facet.getKey().getFieldName() + ":" + facet.getValue());
        }
    }
}

From source file:eumetsat.pn.solr.webapp.SolrApp.java

@Override
protected Map<String, Object> search(String searchTerms, String filterString, int from, int size) {
    Map<String, Object> data = new HashMap<>();
    // put "session" parameters here rightaway so it can be used in template even when empty result
    data.put("search_terms", searchTerms == null ? "*:*" : searchTerms);
    data.put("filter_terms", filterString == null ? "" : filterString);

    Stopwatch stopwatch = Stopwatch.createStarted();

    try {/* ww w. j  av a  2 s  . com*/
        SolrQuery query = new SolrQuery();

        query.setQuery(searchTerms);
        query.setStart(from == -1 ? 0 : from);
        query.setRows(size);
        query.setFields("id", "title", "description", "thumbnail_s", "status_s", "score"); // "exclude" xmldoc
        query.setParam("qt", "edismax"); // probably default already

        // boosting
        query.setParam("qf", "title^10 description status^2 keywords");

        // set highlight, see also https://cwiki.apache.org/confluence/display/solr/Standard+Highlighter
        query.setHighlight(true).setHighlightSnippets(17).setHighlightFragsize(0); // http://wiki.apache.org/solr/HighlightingParameters
        query.setParam("hl.preserveMulti", "true"); // preserve non-matching keywords
        query.setParam("hl.fl", "id", "title", "description", "keywords"); // "*"); // select fields to highlight
        // override defaults:
        query.setParam("hl.simple.pre", "<em><strong>");
        query.setParam("hl.simple.post", "</strong></em>");

        // configure faceting, see also http://wiki.apache.org/solr/SolrFacetingOverview and http://wiki.apache.org/solr/Solrj and https://wiki.apache.org/solr/SimpleFacetParameters and 
        query.setFacet(true).setFacetLimit(4).setFacetMissing(true);
        // not in API, probably normally set in schema.xml:
        query.setParam("facet.field", "satellite_s", "instrument_s", "category", "societalBenefitArea_ss",
                "distribution_ss");

        // filtering
        Set<String> hiddenFacets = new HashSet<>(); // hiding no facets yet
        if (filterString != null && !filterString.isEmpty()) {
            Multimap<String, String> filterTermsMap = parseFiltersTerms(filterString);

            if (filterTermsMap.size() > 0) {
                for (Map.Entry<String, String> entry : filterTermsMap.entries()) {
                    String filter = " +" + entry.getKey() + ":" + entry.getValue();
                    query.addFilterQuery(filter);

                    hiddenFacets.add(entry.getKey() + ":" + entry.getValue());
                }
            }
        }
        data.put("tohide", hiddenFacets);

        log.debug("Solr query: {}", query);
        QueryResponse response = solr.query(query);

        if (response == null) {
            log.error("Response from {} is null!", this.name);
            data.put("total_hits", 0);
            data = addMessage(data, MessageLevel.danger, "Response is null from " + this.name);
        } else {
            log.trace("Got response: {}", response);

            if (response.getStatus() == 0) {
                List<Map<String, Object>> resHits = new ArrayList<>();
                SolrDocumentList results = response.getResults();
                Map<String, Map<String, List<String>>> highlights = response.getHighlighting();

                data.put("total_hits", results.getNumFound());
                if (results.getNumFound() < 1) {
                    addMessage(data, MessageLevel.info, "No results found!");
                }

                data.put("max_score", results.getMaxScore());
                Map<String, Object> pagination = computePaginationParams(
                        ((Long) (data.get("total_hits"))).intValue(), from);
                data.put("pagination", pagination);

                for (SolrDocument result : results) {
                    HashMap<String, Object> resHit = new HashMap<>();

                    String currentId = (String) result.getFieldValue("id");
                    Map<String, List<String>> currentHighlights = highlights.get(currentId);
                    resHit.put("id", currentId);
                    resHit.put("score", String.format("%.4g", result.getFieldValue("score")));

                    resHit.put("abstract", hightlightIfGiven(result, currentHighlights, "description"));

                    resHit.put("title", hightlightIfGiven(result, currentHighlights, "title"));
                    resHit.put("keywords", Joiner.on(", ").join(
                            (Collection<String>) hightlightIfGiven(result, currentHighlights, "keywords")));
                    resHit.put("satellite", result.get("satellite_s"));
                    resHit.put("thumbnail", result.get("thumbnail_s"));
                    resHit.put("status", result.get("status_s"));
                    resHit.put("distribution", result.get("distribution_ss"));

                    resHits.add(resHit);
                }

                data.put("hits", resHits);

                // faceting information:
                List<FacetField> facets = response.getFacetFields();
                log.trace("Facets ({}): {}", facets.size(), facets);

                //jsObj.get("facets").get("categories").get("terms") - then term und count
                // convert to format of Elasticsearch:
                Map<String, Object> facetsJson = new HashMap<>();
                for (FacetField facet : facets) {
                    Map<String, Object> facetMap = new HashMap<>();
                    facetMap.put("total", facet.getValueCount());
                    List<Map<String, Object>> terms = new ArrayList<>();
                    for (Count count : facet.getValues()) {
                        if (count.getCount() > 0) {
                            Map<String, Object> termMap = new HashMap<>();
                            termMap.put("count", count.getCount());
                            termMap.put("term", count.getName() == null ? "N/A" : count.getName());
                            terms.add(termMap);
                        }
                    }
                    facetMap.put("terms", terms);
                    facetsJson.put(facet.getName(), facetMap);
                }
                data.put("facets", facetsJson);
            } else { // non-OK resonse
                log.error("Received non-200 response: {}", response);
                data = addMessage(data, MessageLevel.danger, "Non 200 response: " + response.toString());
            }
        }

        data.put("elapsed", (double) (stopwatch.elapsed(TimeUnit.MILLISECONDS)) / (double) 1000);
        log.trace("Prepared data for template: {}", data);
    } catch (SolrServerException e) {
        log.error("Error querying Solr", e);
        addMessage(data, MessageLevel.danger, "Error during search: " + e.getMessage());
        //            errorResponse(e);
    }

    stopwatch.stop();

    return data;
}

From source file:fr.hoteia.qalingo.core.solr.service.impl.CategorySolrServiceImpl.java

License:Apache License

/**
  * /*from  w w  w  . ja  v  a2  s.  co m*/
  */
public CategoryResponseBean searchCategory() throws SolrServerException, IOException {

    SolrQuery solrQuery = new SolrQuery();
    solrQuery.setQuery("*");
    solrQuery.setFacet(true);
    solrQuery.setFacetMinCount(1);
    solrQuery.setFacetLimit(8);
    solrQuery.addFacetField("name");
    solrQuery.addFacetField("code");

    SolrRequest request = new QueryRequest(solrQuery, METHOD.POST);
    request.setPath(getRequestPath());
    QueryResponse response = new QueryResponse(solrServer.request(request), solrServer);
    List<CategorySolr> productSolrList = response.getBeans(CategorySolr.class);
    List<FacetField> productSolrFacetFieldList = response.getFacetFields();

    CategoryResponseBean categoryResponseBean = new CategoryResponseBean();
    categoryResponseBean.setCategorySolrList(productSolrList);
    categoryResponseBean.setCategorySolrFacetFieldList(productSolrFacetFieldList);

    return categoryResponseBean;
}

From source file:fr.hoteia.qalingo.core.solr.service.impl.CustomerSolrServiceImpl.java

License:Apache License

/**
  * /*from   w  w w. j  a  v a  2  s  . c o m*/
  */
public CustomerResponseBean searchCustomer() throws SolrServerException, IOException {

    SolrQuery solrQuery = new SolrQuery();
    solrQuery.setQuery("*");
    solrQuery.setFacet(true);
    solrQuery.setFacetMinCount(1);
    solrQuery.setFacetLimit(8);
    solrQuery.addFacetField("lastname");

    SolrRequest request = new QueryRequest(solrQuery, METHOD.POST);
    request.setPath(getRequestPath());
    QueryResponse response = new QueryResponse(solrServer.request(request), solrServer);
    List<CustomerSolr> customerSolrList = response.getBeans(CustomerSolr.class);
    List<FacetField> customerSolrFacetFieldList = response.getFacetFields();

    CustomerResponseBean customerResponseBean = new CustomerResponseBean();
    customerResponseBean.setCustomerSolrList(customerSolrList);
    customerResponseBean.setCustomerSolrFacetFieldList(customerSolrFacetFieldList);

    return customerResponseBean;
}

From source file:fr.hoteia.qalingo.core.solr.service.impl.ProductSolrServiceImpl.java

License:Apache License

/**
  * //from w  w w. j av a  2  s .c om
  */
public ProductResponseBean searchProduct() throws SolrServerException, IOException {

    SolrQuery solrQuery = new SolrQuery();
    solrQuery.setQuery("*");
    solrQuery.setFacet(true);
    solrQuery.setFacetMinCount(1);
    solrQuery.setFacetLimit(8);
    solrQuery.addFacetField("name");
    solrQuery.addFacetField("code");

    SolrRequest request = new QueryRequest(solrQuery, METHOD.POST);
    request.setPath(getRequestPath());
    QueryResponse response = new QueryResponse(solrServer.request(request), solrServer);
    List<ProductSkuSolr> productSkuSolrList = response.getBeans(ProductSkuSolr.class);
    List<FacetField> productSolrFacetFieldList = response.getFacetFields();

    ProductResponseBean productResponseBean = new ProductResponseBean();
    productResponseBean.setProductSolrList(productSkuSolrList);
    productResponseBean.setProductSolrFacetFieldList(productSolrFacetFieldList);

    return productResponseBean;
}