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

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

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

Introduction

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

Prototype

public SolrQuery addFacetField(String... fields)

Source Link

Document

Add field(s) for facet computation.

Usage

From source file:edu.harvard.liblab.ecru.rs.ResourceUtils.java

License:Open Source License

public static SolrQuery addFacetsToQuery(SolrQuery query, HashMap<String, List<String>> facetMap) {
    if (!facetMap.isEmpty()) {
        List<String> doFacet = facetMap.get("facet");
        if (doFacet == null || (!doFacet.isEmpty() && !doFacet.get(0).toLowerCase().equals("false"))) {
            query.setFacet(true);/* w  w  w.j  a  v a2  s  .  c  o m*/
            List<String> limits = facetMap.get("facet.limit");
            try {
                query.setFacetLimit(Integer.valueOf(limits.get(0)));

            } catch (Exception e) {
                // we don't care about this
            }
            query.setFacetMinCount(1);
            limits = facetMap.get("facet.mincout");
            try {
                query.setFacetLimit(Integer.valueOf(limits.get(0)));

            } catch (Exception e) {
                // we don't care about this
            }
            List<String> values = facetMap.get("facet.field");
            if (values != null && !values.isEmpty()) {
                query.addFacetField(values.toArray(new String[values.size()]));
            }
        }
    }
    return query;
}

From source file:edu.unc.lib.dl.search.solr.service.SolrSearchService.java

License:Apache License

/**
 * Attempts to retrieve the hierarchical facet from the facet field corresponding to fieldKey that matches the value
 * of searchValue. Retrieves and populates all tiers leading up to the tier number given in searchValue.
 * //  w w w  .j  av  a2  s . c o  m
 * @param fieldKey
 *           Key of the facet field to search for the facet within.
 * @param searchValue
 *           Value to find a matching facet for, should be formatted <tier>,<value>
 * @param accessGroups
 * @return
 */
public FacetFieldObject getHierarchicalFacet(AbstractHierarchicalFacet facet, AccessGroupSet accessGroups) {
    QueryResponse queryResponse = null;
    SolrQuery solrQuery = new SolrQuery();
    StringBuilder query = new StringBuilder();
    query.append("[* TO *]");

    try {
        // Add access restrictions to query
        addAccessRestrictions(query, accessGroups);
    } catch (AccessRestrictionException e) {
        // If the user doesn't have any access groups, they don't have access to anything, return null.
        LOG.error(e.getMessage());
        return null;
    }
    solrQuery.setQuery(query.toString());
    solrQuery.setRows(0);

    solrQuery.setFacet(true);
    solrQuery.setFacetMinCount(1);

    String solrFieldName = solrSettings.getFieldName(facet.getFieldName());

    solrQuery.addFacetField(solrFieldName);
    solrQuery.setFacetPrefix(solrFieldName, facet.getSearchValue());

    LOG.debug("getHierarchicalFacet query: " + solrQuery.toString());
    try {
        queryResponse = server.query(solrQuery);
    } catch (SolrServerException e) {
        LOG.error("Error retrieving Solr object request: " + e);
        return null;
    }
    FacetField facetField = queryResponse.getFacetField(solrFieldName);
    if (facetField.getValueCount() == 0)
        return null;
    return facetFieldFactory.createFacetFieldObject(facet.getFieldName(),
            queryResponse.getFacetField(solrFieldName));
}

From source file:edu.unc.lib.dl.search.solr.service.SolrSearchService.java

License:Apache License

/**
 * Constructs a SolrQuery object from the search state specified within a SearchRequest object. The request may
 * optionally request to retrieve facet results in addition to search results.
 * /*from www.j a va 2s .c  o m*/
 * @param searchRequest
 * @param isRetrieveFacetsRequest
 * @return
 */
protected SolrQuery generateSearch(SearchRequest searchRequest) {
    SearchState searchState = (SearchState) searchRequest.getSearchState();
    SolrQuery solrQuery = new SolrQuery();
    StringBuilder termQuery = new StringBuilder();

    // Generate search term query string
    addSearchFields(searchState, termQuery);

    // Add range Fields to the query
    addRangeFields(searchState, termQuery);

    // No query terms given, make it an everything query
    StringBuilder query = new StringBuilder();
    if (termQuery.length() == 0) {
        query.append("*:* ");
    } else {
        query.append('(').append(termQuery).append(')');
    }

    // Add access restrictions to query
    try {
        addAccessRestrictions(query, searchRequest.getAccessGroups());
    } catch (AccessRestrictionException e) {
        // If the user doesn't have any access groups, they don't have access to anything, return null.
        LOG.debug("User had no access groups", e);
        return null;
    }

    // Add query
    solrQuery.setQuery(query.toString());

    if (searchState.getResultFields() != null) {
        for (String field : searchState.getResultFields()) {
            String solrFieldName = solrSettings.getFieldName(field);
            if (solrFieldName != null)
                solrQuery.addField(solrFieldName);
        }
    }

    if (searchState.getRollup() != null && searchState.getRollup()) {
        solrQuery.set(GroupParams.GROUP, true);
        if (searchState.getRollupField() == null)
            solrQuery.set(GroupParams.GROUP_FIELD, solrSettings.getFieldName(SearchFieldKeys.ROLLUP_ID.name()));
        else
            solrQuery.set(GroupParams.GROUP_FIELD, solrSettings.getFieldName(searchState.getRollupField()));

        solrQuery.set(GroupParams.GROUP_TOTAL_COUNT, true);
        if (searchState.getFacetsToRetrieve() != null && searchState.getFacetsToRetrieve().size() > 0) {
            solrQuery.set(GroupParams.GROUP_FACET, true);
        }
    }

    // Add sort parameters
    List<SearchSettings.SortField> sortFields = searchSettings.sortTypes.get(searchState.getSortType());
    if (sortFields != null) {
        for (int i = 0; i < sortFields.size(); i++) {
            SearchSettings.SortField sortField = sortFields.get(i);
            SolrQuery.ORDER sortOrder = SolrQuery.ORDER.valueOf(sortField.getSortOrder());
            if (!searchState.getSortNormalOrder())
                sortOrder = sortOrder.reverse();
            solrQuery.addSort(solrSettings.getFieldName(sortField.getFieldName()), sortOrder);
        }
    }

    // Set requested resource types
    String resourceTypeFilter = this.getResourceTypeFilter(searchState.getResourceTypes());
    if (resourceTypeFilter != null) {
        solrQuery.addFilterQuery(resourceTypeFilter);
    }

    // Turn on faceting
    if (searchRequest.isRetrieveFacets()) {
        solrQuery.setFacet(true);
        solrQuery.setFacetMinCount(1);
        if (searchState.getBaseFacetLimit() != null)
            solrQuery.setFacetLimit(searchState.getBaseFacetLimit());

        if (searchState.getFacetsToRetrieve() != null) {
            // Add facet fields
            for (String facetName : searchState.getFacetsToRetrieve()) {
                String facetField = solrSettings.getFieldName(facetName);
                if (facetField != null)
                    solrQuery.addFacetField(solrSettings.getFieldName(facetName));
            }
        }
    }

    // Override the base facet limit if overrides are given.
    if (searchState.getFacetLimits() != null) {
        for (Entry<String, Integer> facetLimit : searchState.getFacetLimits().entrySet()) {
            solrQuery.add("f." + solrSettings.getFieldName(facetLimit.getKey()) + ".facet.limit",
                    facetLimit.getValue().toString());
        }
    }

    // Add facet limits
    Map<String, Object> facets = searchState.getFacets();
    if (facets != null) {
        Iterator<Entry<String, Object>> facetIt = facets.entrySet().iterator();
        while (facetIt.hasNext()) {
            Entry<String, Object> facetEntry = facetIt.next();

            if (facetEntry.getValue() instanceof String) {
                LOG.debug("Adding facet " + facetEntry.getKey() + " as a String");
                // Add Normal facets
                solrQuery.addFilterQuery(solrSettings.getFieldName(facetEntry.getKey()) + ":\""
                        + SolrSettings.sanitize((String) facetEntry.getValue()) + "\"");
            } else {
                LOG.debug("Adding facet " + facetEntry.getKey() + " as a "
                        + facetEntry.getValue().getClass().getName());
                facetFieldUtil.addToSolrQuery(facetEntry.getValue(), solrQuery);
            }
        }
    }

    // Scope hierarchical facet results to the highest tier selected within the facet tree
    if (searchRequest.isRetrieveFacets() && searchRequest.isApplyCutoffs()
            && searchState.getFacetsToRetrieve() != null) {
        Set<String> facetsQueried = searchState.getFacets().keySet();
        // Apply closing cutoff to all cutoff facets that are being retrieved but not being queried for
        for (String fieldKey : searchState.getFacetsToRetrieve()) {
            if (!facetsQueried.contains(fieldKey)) {
                facetFieldUtil.addDefaultFacetPivot(fieldKey, solrQuery);
            }
        }

        // Add individual facet field sorts if they are present.
        if (searchState.getFacetSorts() != null) {
            for (Entry<String, String> facetSort : searchState.getFacetSorts().entrySet()) {
                solrQuery.add("f." + solrSettings.getFieldName(facetSort.getKey()) + ".facet.sort",
                        facetSort.getValue());
            }
        }
    }

    // Set Navigation options
    if (searchState.getStartRow() != null)
        solrQuery.setStart(searchState.getStartRow());
    if (searchState.getRowsPerPage() != null)
        solrQuery.setRows(searchState.getRowsPerPage());

    return solrQuery;
}

From source file:edu.unc.lib.dl.search.solr.service.SolrSearchService.java

License:Apache License

/**
 * Returns a combined set of distinct field values for one or more fields, limited by the set of access groups
 * provided//  w w  w .j  a  v  a 2 s  . com
 * 
 * @param fields
 *           Solr field names to retrieve distinct values for
 * @param maxValuesPerField
 *           Max number of distinct values to retrieve for each field
 * @param accessGroups
 * @return
 * @throws AccessRestrictionException
 * @throws SolrServerException
 */
public java.util.Collection<String> getDistinctFieldValues(String[] fields, int maxValuesPerField,
        AccessGroupSet accessGroups) throws AccessRestrictionException, SolrServerException {
    SolrQuery solrQuery = new SolrQuery();
    StringBuilder query = new StringBuilder("*:*");
    addAccessRestrictions(query, accessGroups);
    solrQuery.setQuery(query.toString());
    solrQuery.setFacet(true);
    for (String facetField : fields)
        solrQuery.addFacetField(facetField);
    solrQuery.setFacetLimit(maxValuesPerField);
    solrQuery.setFacetSort("index");

    QueryResponse queryResponse = server.query(solrQuery);
    // Determine initial capacity for the result list
    int numberValues = 0;
    for (FacetField facet : queryResponse.getFacetFields())
        numberValues += facet.getValueCount();

    java.util.Collection<String> fieldValues = new java.util.HashSet<String>(numberValues);
    for (FacetField facet : queryResponse.getFacetFields())
        for (Count count : facet.getValues())
            fieldValues.add(count.getName());

    return fieldValues;
}

From source file:edu.unc.lib.dl.ui.service.SolrQueryLayerService.java

License:Apache License

public void getChildrenCounts(List<BriefObjectMetadata> resultList, AccessGroupSet accessGroups,
        String countName, String queryAddendum, SolrQuery baseQuery) {
    long startTime = System.currentTimeMillis();
    if (resultList == null || resultList.size() == 0)
        return;/*  w ww . j a  va  2s. co m*/

    String ancestorPathField = solrSettings.getFieldName(SearchFieldKeys.ANCESTOR_PATH.name());
    SolrQuery solrQuery;
    if (baseQuery == null) {
        // Create a base query since we didn't receive one
        solrQuery = new SolrQuery();
        StringBuilder query = new StringBuilder("*:*");
        try {
            // Add access restrictions to query
            addAccessRestrictions(query, accessGroups);
        } catch (AccessRestrictionException e) {
            // If the user doesn't have any access groups, they don't have access to anything, return null.
            LOG.error(e.getMessage());
            return;
        }

        solrQuery.setStart(0);
        solrQuery.setRows(0);

        solrQuery.setQuery(query.toString());
    } else {
        // Starting from a base query
        solrQuery = baseQuery.getCopy();
        // Make sure we aren't returning any normal results
        solrQuery.setRows(0);
        // Remove all facet fields so we are only getting ancestor path
        if (solrQuery.getFacetFields() != null) {
            for (String facetField : solrQuery.getFacetFields()) {
                solrQuery.removeFacetField(facetField);
            }
        }
    }

    if (queryAddendum != null) {
        solrQuery.setQuery(solrQuery.getQuery() + " AND " + queryAddendum);
    }

    solrQuery.setFacet(true);
    solrQuery.setFacetMinCount(1);
    solrQuery.addFacetField(ancestorPathField);

    Integer countPageSize;
    try {
        countPageSize = new Integer(searchSettings.getProperty("search.facet.countPageSize"));
    } catch (NumberFormatException e) {
        countPageSize = 20;
    }

    solrQuery.add("f." + ancestorPathField + ".facet.limit", Integer.toString(Integer.MAX_VALUE));
    // Sort by value rather than count so that earlier tiers will come first in case the result gets cut off
    solrQuery.setFacetSort("index");

    java.util.Map<Integer, StringBuilder> tierQueryMap = new java.util.HashMap<Integer, StringBuilder>();
    java.util.Map<Integer, List<BriefObjectMetadata>> containerMap = new java.util.HashMap<Integer, List<BriefObjectMetadata>>();

    // Pare the list of ids we are searching for and assigning counts to down to just containers
    for (BriefObjectMetadata metadataObject : resultList) {
        if (metadataObject.getPath() != null && metadataObject.getContentModel() != null
                && metadataObject.getContentModel().contains(ContentModelHelper.Model.CONTAINER.toString())) {
            CutoffFacetNode highestTier = metadataObject.getPath().getHighestTierNode();
            StringBuilder tierQuery = tierQueryMap.get(highestTier.getTier());
            List<BriefObjectMetadata> containerObjects = containerMap.get(highestTier.getTier());
            if (tierQuery == null) {
                tierQuery = new StringBuilder();
                tierQueryMap.put(highestTier.getTier(), tierQuery);

                containerObjects = new ArrayList<BriefObjectMetadata>();
                containerMap.put(highestTier.getTier(), containerObjects);
            }

            if (tierQuery.length() == 0) {
                tierQuery.append(ancestorPathField).append(":(");
            } else {
                tierQuery.append(" OR ");
            }

            tierQuery.append(SolrSettings.sanitize(highestTier.getSearchValue())).append(",*");
            containerObjects.add(metadataObject);

            // If there are a lot of results, then do a partial lookup
            if (containerObjects.size() >= countPageSize) {
                tierQuery.append(")");
                this.executeChildrenCounts(tierQuery, containerObjects, solrQuery, countName,
                        highestTier.getTier());
                LOG.info("Partial query done at " + System.currentTimeMillis() + " ("
                        + (System.currentTimeMillis() - startTime) + ")");
                containerMap.remove(highestTier.getTier());
                tierQueryMap.remove(highestTier.getTier());
            }
        }
    }

    Iterator<java.util.Map.Entry<Integer, StringBuilder>> queryIt = tierQueryMap.entrySet().iterator();
    while (queryIt.hasNext()) {
        java.util.Map.Entry<Integer, StringBuilder> tierQueryEntry = queryIt.next();
        tierQueryEntry.getValue().append(')');
        this.executeChildrenCounts(tierQueryEntry.getValue(), containerMap.get(tierQueryEntry.getKey()),
                solrQuery, countName, tierQueryEntry.getKey());
    }
    LOG.info("Child count query done at " + System.currentTimeMillis() + " ("
            + (System.currentTimeMillis() - startTime) + ")");
}

From source file:edu.unc.lib.dl.ui.service.SolrQueryLayerService.java

License:Apache License

/**
 * Get the number of departments represented in the collection
 * //from w  w  w . j av  a2  s.c o  m
 * @return the count, or -1 if there was an error retrieving the count
 */

public int getDepartmentsCount() {

    SolrQuery query;
    QueryResponse response;

    query = new SolrQuery();
    query.setQuery("*:*");
    query.setRows(0);
    query.addFacetField("department");
    query.setFacetLimit(-1);

    try {
        response = this.executeQuery(query);
        return response.getFacetField("department").getValueCount();
    } catch (SolrServerException e) {
        LOG.error("Error retrieving Solr object request: " + e);
    }

    return -1;

}

From source file:edu.unc.lib.dl.ui.service.SolrQueryLayerService.java

License:Apache License

/**
 * Get the number of objects present in the collection for various formats
 * /*from  ww w.  ja v  a  2s.  c  o m*/
 * @return a map from format name to count
 */

public Map<String, Long> getFormatCounts() {

    SolrQuery query;
    QueryResponse response;

    query = new SolrQuery();
    query.setQuery("*:*");
    query.setRows(0);
    query.addFacetField("contentType");
    query.setFacetLimit(-1);

    HashMap<String, Long> counts = new HashMap<String, Long>();

    try {
        response = this.executeQuery(query);
        FacetField facetField = response.getFacetField("contentType");

        for (Count count : facetField.getValues()) {

            if (count.getName().startsWith("^text"))
                counts.put("text", count.getCount());
            else if (count.getName().startsWith("^image"))
                counts.put("image", count.getCount());
            else if (count.getName().startsWith("^dataset"))
                counts.put("dataset", count.getCount());
            else if (count.getName().startsWith("^audio"))
                counts.put("audio", count.getCount());
            else if (count.getName().startsWith("^video"))
                counts.put("video", count.getCount());

        }

    } catch (SolrServerException e) {
        LOG.error("Error retrieving Solr object request: " + e);
    }

    return counts;

}

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

License:Apache License

/**
 * wrapper function of field facet query
 *
 * @param core SolrCore//from ww w  .  j ava 2 s.  c  o m
 * @param queryParam query condition
 * @param filterParam filter condition
 * @param facetFields comma separated list of fields
 */
public Map getFieldFacets(SolrCore core, String queryParam, String filterParam, String facetFields)
        throws IOException {
    Map<String, Object> res = new HashMap<>();
    SolrQuery query = new SolrQuery();

    query.setQuery(queryParam);
    if (filterParam != null) {
        query.addFilterQuery(filterParam);
    }
    query.setRows(0).setFacet(true).setFacetLimit(-1).setFacetMinCount(1)
            .setFacetSort(FacetParams.FACET_SORT_COUNT).set("json.nl", "map");
    query.addFacetField(facetFields.split(","));

    List<String> fields = Arrays.asList(facetFields.split(","));

    LOGGER.trace("getFieldFacets: [{}] {}", core.getSolrCoreName(), query.toString());
    String response = this.solrQuery(core, query);
    Map resp = jsonParser.readValue(response);
    Map facet_fields = (Map) ((Map) resp.get("facet_counts")).get("facet_fields");

    Map<String, Object> facets = new HashMap<>();
    for (String field : fields) {
        Map values = (Map) facet_fields.get(field);
        Map<String, Integer> facetValues = new LinkedHashMap<>();

        for (Map.Entry<String, Integer> entry : (Iterable<Map.Entry>) values.entrySet()) {
            facetValues.put(entry.getKey(), entry.getValue());
        }

        facets.put(field, facetValues);
    }

    res.put("total", ((Map) resp.get("response")).get("numFound"));
    res.put("facets", facets);

    return res;
}

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"));
    }/*ww  w .j a va2s  .  c  om*/
    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.common.FacetHelper.java

License:Apache License

private static JSONObject getSingleFacetsData(DataApiHandler dataApi, SolrCore core, String keyword,
        String single_facet, String[] facets, String fq) throws IOException, ParseException {

    SolrInterface solr = new SolrInterface();

    keyword = StringHelper.stripQuoteAndParseSolrKeywordOperator(keyword);

    int beginindex = keyword.indexOf(" AND (" + single_facet);
    int endindex = 0;

    StringBuffer s = new StringBuffer(keyword);

    if (beginindex < 0) {
        beginindex = keyword.indexOf("(" + single_facet);
        endindex = keyword.indexOf(") AND ", beginindex);
        if (endindex < 0) {
            endindex = keyword.indexOf("))", beginindex);

            // TODO: this cause java.lang.StringIndexOutOfBoundsException: String index out of range: -1
            // when Patric Libs keyword - (*) and endindex: 2
            LOGGER.debug("string:{}, beginIndex: {}, endIndex:{}", s, beginindex, endindex);
            if (endindex > 0) {
                s.delete(beginindex, endindex + 2);
            }/*from   w  ww  . j a v a 2  s.co m*/
        } else {
            s.delete(beginindex, endindex + 6);
        }
    } else {
        endindex = keyword.indexOf("))", beginindex);
        if (endindex == -1) {
            endindex = keyword.indexOf("])", beginindex);
        }
        s.delete(beginindex, endindex + 2);
    }
    if (s.length() == 0)
        s.append("(*)");

    SolrQuery query = new SolrQuery();
    query.setQuery(s.toString());
    if (fq != null) {
        query.setFilterQueries(fq);
    }

    query.setStart(0).setRows(1).setFacet(true).setFacetMinCount(1).set("json.nl", "map");

    for (String facet : facets) {
        if (!facet.equals("completion_date") && !facet.equals("release_date")) {
            query.addFacetField(facet);
        } else {
            query.addDateRangeFacet(facet, solr.getRangeStartDate(), solr.getRangeEndDate(),
                    solr.getRangeDate());
        }
    }

    String apiResponse = dataApi.solrQuery(core, query);

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

    JSONObject ret = new JSONObject();
    ret.put("response", new JSONObject(respBody));
    ret.put("facets", FacetHelper.formatFacetTree((Map) resp.get("facet_counts")));

    return ret;
}