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

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

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

Introduction

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

Prototype

public SolrQuery setStart(Integer start)

Source Link

Usage

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

License:Apache License

/**
 * Retrieves a list of the nearest windowSize neighbors within the nearest parent collection or folder around the
 * item metadata, based on the order field of the item. The first windowSize - 1 neighbors are retrieved to each side
 * of the item, and trimmed so that there are always windowSize - 1 neighbors surrounding the item if possible. If no
 * order field is available, a list of arbitrary windowSize neighbors is returned.
 * /*from  w  ww . java  2 s .c o m*/
 * @param metadata
 *           Record which the window pivots around.
 * @param windowSize
 *           max number of items in the window. This includes the pivot, so odd numbers are recommended.
 * @param accessGroups
 *           Access groups of the user making this request.
 * @return
 */
public List<BriefObjectMetadataBean> getNeighboringItems(BriefObjectMetadataBean metadata, int windowSize,
        AccessGroupSet accessGroups) {

    // Get the common access restriction clause (starts with "AND ...")

    StringBuilder accessRestrictionClause = new StringBuilder();

    try {
        addAccessRestrictions(accessRestrictionClause, 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;
    }

    // Prepare the common query object, including a filter for resource type and the
    // facet which selects only the item's siblings.

    SolrQuery solrQuery = new SolrQuery();

    solrQuery.setFacet(true);
    solrQuery.addFilterQuery(solrSettings.getFieldName(SearchFieldKeys.RESOURCE_TYPE.name()) + ":File "
            + solrSettings.getFieldName(SearchFieldKeys.RESOURCE_TYPE.name()) + ":Aggregate");

    CutoffFacet ancestorPath = null;

    if (metadata.getResourceType().equals(searchSettings.resourceTypeFile)
            || metadata.getResourceType().equals(searchSettings.resourceTypeAggregate)) {
        ancestorPath = metadata.getAncestorPathFacet();
    } else {
        ancestorPath = metadata.getPath();
    }

    if (ancestorPath != null) {
        // We want only objects at the same level of the hierarchy
        ancestorPath.setCutoff(ancestorPath.getHighestTier() + 1);

        facetFieldUtil.addToSolrQuery(ancestorPath, solrQuery);
    }

    // If this item has no display order, get arbitrary items surrounding it.

    Long pivotOrder = metadata.getDisplayOrder();

    if (pivotOrder == null) {

        LOG.debug("No display order, just querying for " + windowSize + " siblings");

        StringBuilder query = new StringBuilder();

        List<BriefObjectMetadataBean> list = null;

        query.append("*:*");
        query.append(accessRestrictionClause);
        solrQuery.setQuery(query.toString());

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

        solrQuery.setSort(solrSettings.getFieldName(SearchFieldKeys.DISPLAY_ORDER.name()),
                SolrQuery.ORDER.desc);

        try {
            QueryResponse queryResponse = this.executeQuery(solrQuery);
            list = queryResponse.getBeans(BriefObjectMetadataBean.class);
        } catch (SolrServerException e) {
            LOG.error("Error retrieving Neighboring items: " + e);
            return null;
        }

        return list;

        // Otherwise, query for items surrounding this item.

    } else {

        LOG.debug("Display order is " + pivotOrder);

        // Find the right and left lists

        StringBuilder query;

        List<BriefObjectMetadataBean> leftList = null;
        List<BriefObjectMetadataBean> rightList = null;

        solrQuery.setStart(0);
        solrQuery.setRows(windowSize - 1);

        // Right list

        query = new StringBuilder();

        query.append(solrSettings.getFieldName(SearchFieldKeys.DISPLAY_ORDER.name())).append(":[")
                .append(pivotOrder + 1).append(" TO *]");
        query.append(accessRestrictionClause);
        solrQuery.setQuery(query.toString());

        solrQuery.setSort(solrSettings.getFieldName(SearchFieldKeys.DISPLAY_ORDER.name()), SolrQuery.ORDER.asc);

        try {
            QueryResponse queryResponse = this.executeQuery(solrQuery);
            rightList = queryResponse.getBeans(BriefObjectMetadataBean.class);
        } catch (SolrServerException e) {
            LOG.error("Error retrieving Neighboring items: " + e);
            return null;
        }

        LOG.debug("Got " + rightList.size() + " items for right list");

        // Left list

        // (Note that display order stuff is reversed.)

        query = new StringBuilder();

        query.append(solrSettings.getFieldName(SearchFieldKeys.DISPLAY_ORDER.name())).append(":[* TO ")
                .append(pivotOrder - 1).append("]");
        query.append(accessRestrictionClause);
        solrQuery.setQuery(query.toString());

        solrQuery.setSort(solrSettings.getFieldName(SearchFieldKeys.DISPLAY_ORDER.name()),
                SolrQuery.ORDER.desc);

        try {
            QueryResponse queryResponse = this.executeQuery(solrQuery);
            leftList = queryResponse.getBeans(BriefObjectMetadataBean.class);
        } catch (SolrServerException e) {
            LOG.error("Error retrieving Neighboring items: " + e);
            return null;
        }

        LOG.debug("Got " + leftList.size() + " items for left list");

        // Trim the lists

        int halfWindow = windowSize / 2;

        // If we have enough in both lists, trim both to be
        // halfWindow long.

        if (leftList.size() >= halfWindow && rightList.size() >= halfWindow) {

            LOG.debug("Trimming both lists");

            leftList.subList(halfWindow, leftList.size()).clear();
            rightList.subList(halfWindow, rightList.size()).clear();

            // If we don't have enough in the left list and we have extra in the right list,
            // try to pick up the slack by trimming fewer items from the right list.

        } else if (leftList.size() < halfWindow && rightList.size() > halfWindow) {

            LOG.debug("Picking up slack from right list");

            // How much extra do we need from the right list?

            int extra = halfWindow - leftList.size();

            // Only "take" the extra (ie, clear less of the right list) if we have it available.

            if (halfWindow + extra < rightList.size())
                rightList.subList(halfWindow + extra, rightList.size()).clear();

        } else if (rightList.size() < halfWindow && leftList.size() > halfWindow) {

            LOG.debug("Picking up slack from left list");

            int extra = halfWindow - rightList.size();

            if (halfWindow + extra < leftList.size())
                leftList.subList(halfWindow + extra, leftList.size()).clear();

        }

        // (Otherwise, we do no trimming, since both lists are smaller or the same size
        // as the window.)

        // Assemble the result.

        Collections.reverse(leftList);
        leftList.add(metadata);
        leftList.addAll(rightList);

        return leftList;

    }

}

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

License:Apache License

public long getChildrenCount(BriefObjectMetadataBean metadataObject, AccessGroupSet accessGroups) {
    QueryResponse queryResponse = null;/*w w  w  . j  a v a2 s.  c  o  m*/
    SolrQuery 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 -1;
    }

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

    solrQuery.setQuery(query.toString());

    query = new StringBuilder();
    query.append(solrSettings.getFieldName(SearchFieldKeys.ANCESTOR_PATH.name())).append(':')
            .append(SolrSettings.sanitize(metadataObject.getPath().getSearchValue())).append(",*");

    solrQuery.setFacet(true);
    solrQuery.addFilterQuery(query.toString());

    try {
        queryResponse = this.executeQuery(solrQuery);
        return queryResponse.getResults().getNumFound();
    } catch (SolrServerException e) {
        LOG.error("Error retrieving Solr search result request", e);
    }
    return -1;
}

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 v a  2 s . 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.usu.sdl.openstorefront.service.SearchServiceImpl.java

License:Apache License

@Override
public List<ComponentSearchView> getSearchItems(SearchQuery query, FilterQueryParams filter) {
    // use for advanced search with And - Or combinations on separate fields
    String queryOperator = " " + SolrAndOr.OR + " ";
    String myQueryString;//  ww w .  j a  va  2 s.  c  o m

    // If incoming query string is blank, default to solar *:* for the full query
    if (StringUtils.isNotBlank(query.getQuery())) {
        StringBuilder queryData = new StringBuilder();

        Field fields[] = SolrComponentModel.class.getDeclaredFields();
        for (Field field : fields) {
            org.apache.solr.client.solrj.beans.Field fieldAnnotation = field
                    .getAnnotation(org.apache.solr.client.solrj.beans.Field.class);
            if (fieldAnnotation != null && field.getType() == String.class) {
                String name = field.getName();
                if (StringUtils.isNotBlank(fieldAnnotation.value())
                        && org.apache.solr.client.solrj.beans.Field.DEFAULT
                                .equals(fieldAnnotation.value()) == false) {
                    name = fieldAnnotation.value();
                }

                queryData.append(SolrEquals.EQUAL.getSolrOperator()).append(name)
                        .append(SolrManager.SOLR_QUERY_SEPERATOR).append(query.getQuery())
                        .append(queryOperator);
            }
        }
        myQueryString = queryData.toString();
        if (myQueryString.endsWith(queryOperator)) {
            queryData.delete((myQueryString.length() - (queryOperator.length())), myQueryString.length());
            myQueryString = queryData.toString();
        }
    } else {
        myQueryString = SolrManager.SOLR_ALL_QUERY;
    }
    log.log(Level.FINER, myQueryString);

    // execute the searchComponent method and bring back from solr a list array
    List<SolrComponentModel> resultsList = new ArrayList<>();
    try {
        SolrQuery solrQuery = new SolrQuery();
        solrQuery.setQuery(myQueryString);

        // fields to be returned back from solr
        solrQuery.setFields(SolrComponentModel.ID_FIELD, SolrComponentModel.ISCOMPONENT_FIELD);
        solrQuery.setStart(filter.getOffset());
        solrQuery.setRows(filter.getMax());

        Field sortField = ReflectionUtil.getField(new SolrComponentModel(), filter.getSortField());
        if (sortField != null) {
            String sortFieldText = filter.getSortField();
            org.apache.solr.client.solrj.beans.Field fieldAnnotation = sortField
                    .getAnnotation(org.apache.solr.client.solrj.beans.Field.class);
            if (fieldAnnotation != null) {
                sortFieldText = fieldAnnotation.value();
            }
            SolrQuery.ORDER order = SolrQuery.ORDER.desc;
            if (OpenStorefrontConstant.SORT_ASCENDING.equalsIgnoreCase(filter.getSortOrder())) {
                order = SolrQuery.ORDER.asc;
            }
            solrQuery.addSort(sortFieldText, order);
        }

        solrQuery.setIncludeScore(true);

        QueryResponse response = SolrManager.getServer().query(solrQuery);
        SolrDocumentList results = response.getResults();
        DocumentObjectBinder binder = new DocumentObjectBinder();
        resultsList = binder.getBeans(SolrComponentModel.class, results);
    } catch (SolrServerException ex) {
        throw new OpenStorefrontRuntimeException("Search Failed",
                "Contact System Admin.  Seach server maybe Unavailable", ex);
    } catch (Exception ex) {
        log.log(Level.WARNING, "Solr query failed unexpectly; likely bad input.", ex);
    }

    //Pulling the full object on the return
    List<ComponentSearchView> views = new ArrayList<>();

    List<String> componentIds = new ArrayList<>();
    for (SolrComponentModel result : resultsList) {
        if (result.getIsComponent()) {
            componentIds.add(result.getId());
        }
    }

    //remove bad indexes, if any
    List<ComponentSearchView> componentSearchViews = getComponentService().getSearchComponentList(componentIds);
    Set<String> goodComponentIdSet = new HashSet<>();
    for (ComponentSearchView view : componentSearchViews) {
        goodComponentIdSet.add(view.getComponentId());
    }

    for (String componentId : componentIds) {
        if (goodComponentIdSet.contains(componentId) == false) {
            log.log(Level.FINE, MessageFormat.format("Removing bad index: {0}", componentId));
            deleteById(componentId);
        }
    }
    views.addAll(componentSearchViews);

    List<ComponentSearchView> articleViews = getAttributeService().getArticlesSearchView();
    Map<String, ComponentSearchView> allViews = new HashMap<>();
    for (ComponentSearchView componentSearchView : articleViews) {
        AttributeCodePk attributeCodePk = new AttributeCodePk();
        attributeCodePk.setAttributeType(componentSearchView.getArticleAttributeType());
        attributeCodePk.setAttributeCode(componentSearchView.getArticleAttributeCode());
        allViews.put(attributeCodePk.toKey(), componentSearchView);
    }
    for (SolrComponentModel result : resultsList) {

        if (result.getIsComponent() == false) {
            ComponentSearchView view = allViews.get(result.getId());
            if (view != null) {
                views.add(view);
            } else {
                log.log(Level.FINE, MessageFormat.format("Removing bad index: {0}", result.getId()));
                deleteById(result.getId());
            }
        }
    }

    //TODO: Get the score and sort by score
    return views;
}

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"));
    }//from  ww w . ja va2 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.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);
            }/*w w  w.  ja  v a 2  s.  c  o  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;
}

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

License:Apache License

private void processHeatMap(ResourceRequest request, ResourceResponse response) throws IOException {

    DataApiHandler dataApi = new DataApiHandler(request);

    String genomeId, taxonId, algorithm, map;

    genomeId = request.getParameter("genomeId");
    taxonId = request.getParameter("taxonId");
    algorithm = request.getParameter("algorithm");
    map = request.getParameter("map");

    JSONObject json = new JSONObject();

    try {/*from  w w w  .  ja  v  a2  s .c  om*/

        SolrQuery query = new SolrQuery("pathway_id:" + map);

        if (algorithm != null && !algorithm.equals("")) {
            query.addFilterQuery("annotation:" + algorithm);
        }

        if (taxonId != null && !taxonId.equals("")) {
            query.addFilterQuery(
                    SolrCore.GENOME.getSolrCoreJoin("genome_id", "genome_id", "taxon_lineage_ids:" + taxonId));
        }
        if (genomeId != null && !genomeId.equals("")) {
            query.addFilterQuery(SolrCore.GENOME.getSolrCoreJoin("genome_id", "genome_id",
                    "genome_id:(" + genomeId.replaceAll(",", " OR ") + ")"));
        }
        query.setRows(dataApi.MAX_ROWS).setFields("genome_id,annotation,ec_number,ec_description")
                .setFacet(true);
        // {stat:{field:{field:genome_ec,limit:-1,facet:{gene_count:\"unique(feature_id)\"}}}}
        query.add("json.facet", "{stat:{field:{field:genome_ec,limit:-1}}}}");

        LOGGER.debug("heatmap step 1: {}", query.toString());

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

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

        if (numFound > 0) {
            List<Map> buckets = (List<Map>) ((Map) ((Map) resp.get("facets")).get("stat")).get("buckets");

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

            Map<String, Integer> mapStat = new HashMap<>();
            for (Map value : buckets) {
                if (Integer.parseInt(value.get("count").toString()) > 0) {
                    mapStat.put(value.get("val").toString(), (Integer) value.get("count"));
                }
            }

            JSONArray items = new JSONArray();
            for (Map doc : sdl) {
                final JSONObject item = new JSONObject();
                item.put("genome_id", doc.get("genome_id"));
                item.put("algorithm", doc.get("annotation"));
                item.put("ec_number", doc.get("ec_number"));
                item.put("ec_name", doc.get("ec_description"));
                Integer count = mapStat.get(doc.get("genome_id") + "_" + doc.get("ec_number"));
                item.put("gene_count", String.format("%02x", count)); // 2-digit hex string

                items.add(item);
            }
            // if data exceeds limit, keep going
            int i = 1;
            while (sdl.size() == 25000) {
                query.setStart(25000 * i);
                apiResponse = dataApi.solrQuery(SolrCore.PATHWAY, query);

                resp = jsonReader.readValue(apiResponse);
                respBody = (Map) resp.get("response");
                sdl = (List<Map>) respBody.get("docs");

                for (Map doc : sdl) {
                    final JSONObject item = new JSONObject();
                    item.put("genome_id", doc.get("genome_id"));
                    item.put("algorithm", doc.get("annotation"));
                    item.put("ec_number", doc.get("ec_number"));
                    item.put("ec_name", doc.get("ec_description"));
                    Integer count = mapStat.get(doc.get("genome_id") + "_" + doc.get("ec_number"));
                    item.put("gene_count", String.format("%02x", count)); // 2-digit hex string

                    items.add(item);
                }
                i++;
            }

            json.put("data", items);
        }
    } catch (IOException e) {
        LOGGER.error(e.getMessage(), e);
    }

    try {
        SolrQuery query = new SolrQuery("*:*");

        if (taxonId != null && !taxonId.equals("")) {
            query.addFilterQuery(
                    SolrCore.GENOME.getSolrCoreJoin("genome_id", "genome_id", "taxon_lineage_ids:" + taxonId));
        }
        if (genomeId != null && !genomeId.equals("")) {
            query.addFilterQuery(SolrCore.GENOME.getSolrCoreJoin("genome_id", "genome_id",
                    "genome_id:(" + genomeId.replaceAll(",", " OR ") + ")"));
        }
        if (algorithm != null && !algorithm.equals("")) {
            switch (algorithm) {
            case "PATRIC":
                query.addFilterQuery("patric_cds:[1 TO *]");
                break;
            case "RefSeq":
                query.addFilterQuery("refseq_cds:[1 TO *]");
                break;
            case "BRC1":
                query.addFilterQuery("brc1_cds:[1 TO *]");
                break;
            }
        }
        query.setFields("genome_id,genome_name").setRows(dataApi.MAX_ROWS).addSort("genome_name",
                SolrQuery.ORDER.asc);

        LOGGER.debug("step 2: [{}] {}", SolrCore.GENOME.getSolrCoreName(), query.toString());

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

        Map resp = jsonReader.readValue(apiResponse);
        Map respBody = (Map) resp.get("response");
        List<Genome> genomes = dataApi.bindDocuments((List<Map>) respBody.get("docs"), Genome.class);

        JSONArray items = new JSONArray();
        for (Genome genome : genomes) {
            JSONObject item = new JSONObject();
            item.put("genome_id", genome.getId());
            item.put("genome_name", genome.getGenomeName());

            items.add(item);
        }

        json.put("genomes", items);

    } catch (IOException e) {
        LOGGER.error(e.getMessage(), e);
    }

    response.setContentType("application/json");
    json.writeJSONString(response.getWriter());
}

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

License:Apache License

@SuppressWarnings("unchecked")
private JSONObject processGeneTab(DataApiHandler dataApi, String pathwayClass, String pathwayId,
        String ecNumber, String annotation, String contextType, String contextId)
        throws PortletException, IOException {

    JSONObject jsonResult = new JSONObject();
    SolrQuery query = new SolrQuery("*:*");

    if (pathwayClass != null && !pathwayClass.equals("")) {
        query.addFilterQuery("pathway_class:" + pathwayClass);
    }//from w  w w  .j a va 2  s  . c  o  m

    if (pathwayId != null && !pathwayId.equals("")) {
        query.addFilterQuery("pathway_id:" + pathwayId);
    }

    if (ecNumber != null && !ecNumber.equals("")) {
        query.addFilterQuery("ec_number:" + ecNumber);
    }

    if (annotation != null && !annotation.equals("")) {
        query.addFilterQuery("annotation:" + annotation);
    }

    if (contextType.equals("genome")) {
        query.addFilterQuery(
                SolrCore.GENOME.getSolrCoreJoin("genome_id", "genome_id", "genome_id:" + contextId));
    } else if (contextType.equals("taxon")) {
        query.addFilterQuery(
                SolrCore.GENOME.getSolrCoreJoin("genome_id", "genome_id", "taxon_lineage_ids:" + contextId));
    }

    JSONArray items = new JSONArray();
    int count_total = 0;
    int count_unique = 0;

    try {
        Set<String> listFeatureIds = new HashSet<>();

        query.setFields("pathway_id,pathway_name,feature_id,ec_number,ec_description");
        query.setRows(dataApi.MAX_ROWS);

        LOGGER.trace("[{}] {}", SolrCore.PATHWAY.getSolrCoreName(), query);

        String apiResponse = dataApi.solrQuery(SolrCore.PATHWAY, query);
        Map resp = jsonReader.readValue(apiResponse);
        Map respBody = (Map) resp.get("response");

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

        Map<String, Map> mapStat = new HashMap<>();
        for (Map doc : sdl) {

            mapStat.put(doc.get("feature_id").toString(), doc);
            listFeatureIds.add(doc.get("feature_id").toString());
        }

        int i = 1;
        while (sdl.size() == 25000) {
            query.setStart(25000 * i);

            LOGGER.trace("[{}] {}, iter={}", SolrCore.PATHWAY.getSolrCoreName(), query, i);

            apiResponse = dataApi.solrQuery(SolrCore.PATHWAY, query);
            resp = jsonReader.readValue(apiResponse);
            respBody = (Map) resp.get("response");

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

            for (Map doc : sdl) {

                mapStat.put(doc.get("feature_id").toString(), doc);
                listFeatureIds.add(doc.get("feature_id").toString());
            }
            i++;
        }

        // get pathway list
        if (!listFeatureIds.isEmpty()) {
            SolrQuery featureQuery = new SolrQuery(
                    "feature_id:(" + StringUtils.join(listFeatureIds, " OR ") + ")");
            featureQuery.setFields(
                    "genome_name,genome_id,accession,alt_locus_tag,refseq_locus_tag,patric_id,feature_id,gene,product");
            featureQuery.setRows(Math.max(dataApi.MAX_ROWS, listFeatureIds.size()));

            LOGGER.trace("[{}] {}, {}", SolrCore.FEATURE.getSolrCoreName(), featureQuery,
                    listFeatureIds.size());

            apiResponse = dataApi.solrQuery(SolrCore.FEATURE, featureQuery);
            resp = jsonReader.readValue(apiResponse);
            respBody = (Map) resp.get("response");

            List<GenomeFeature> features = dataApi.bindDocuments((List<Map>) respBody.get("docs"),
                    GenomeFeature.class);

            for (GenomeFeature feature : features) {
                String featureId = feature.getId();
                Map stat = mapStat.get(featureId);

                JSONObject item = new JSONObject();
                item.put("genome_name", feature.getGenomeName());
                item.put("genome_id", feature.getGenomeId());
                item.put("accession", feature.getAccession());
                item.put("feature_id", feature.getId());
                item.put("alt_locus_tag", feature.getAltLocusTag());
                item.put("refseq_locus_tag", feature.getRefseqLocusTag());
                item.put("algorithm", annotation);
                item.put("patric_id", feature.getPatricId());
                item.put("gene", feature.getGene());
                item.put("product", feature.getProduct());

                item.put("ec_name", stat.get("ec_description"));
                item.put("ec_number", stat.get("ec_number"));
                item.put("pathway_id", stat.get("pathway_id"));
                item.put("pathway_name", stat.get("pathway_name"));

                items.add(item);
            }

            i = 1;
            while (features.size() == 25000) {
                featureQuery.setStart(25000 * i);

                LOGGER.trace("[{}] {}, iter={}", SolrCore.FEATURE.getSolrCoreName(), featureQuery, i);

                apiResponse = dataApi.solrQuery(SolrCore.FEATURE, featureQuery);
                resp = jsonReader.readValue(apiResponse);
                respBody = (Map) resp.get("response");

                features = dataApi.bindDocuments((List<Map>) respBody.get("docs"), GenomeFeature.class);

                for (GenomeFeature feature : features) {
                    String featureId = feature.getId();
                    Map stat = mapStat.get(featureId);

                    JSONObject item = new JSONObject();
                    item.put("genome_name", feature.getGenomeName());
                    item.put("genome_id", feature.getGenomeId());
                    item.put("accession", feature.getAccession());
                    item.put("feature_id", feature.getId());
                    item.put("alt_locus_tag", feature.getAltLocusTag());
                    item.put("refseq_locus_tag", feature.getRefseqLocusTag());
                    item.put("algorithm", annotation);
                    item.put("patric_id", feature.getPatricId());
                    item.put("gene", feature.getGene());
                    item.put("product", feature.getProduct());

                    item.put("ec_name", stat.get("ec_description"));
                    item.put("ec_number", stat.get("ec_number"));
                    item.put("pathway_id", stat.get("pathway_id"));
                    item.put("pathway_name", stat.get("pathway_name"));

                    items.add(item);
                }
                i++;
            }

            count_total = items.size();
            count_unique = count_total;
        }
    } catch (IOException e) {
        LOGGER.error(e.getMessage(), e);
    }

    // Wrapping jsonResult
    jsonResult.put("total", count_total);
    jsonResult.put("results", items);
    jsonResult.put("unique", count_unique);

    return jsonResult;
}

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

License:Apache License

private void printRefSeqInfo(ResourceRequest request, ResourceResponse response) throws IOException {

    String contextType = request.getParameter("cType");
    String contextId = request.getParameter("cId");

    DataApiHandler dataApi = new DataApiHandler(request);
    SolrQuery query = new SolrQuery();

    if (contextType.equals("genome")) {
        query.setQuery("genome_id:" + contextId);
    } else if (contextType.equals("feature")) {
        query.setQuery(SolrCore.FEATURE.getSolrCoreJoin("genome_id", "genome_id", "feature_id:" + contextId));
    }//from   w  ww  .  j  av a 2 s  .co m
    query.setRows(dataApi.MAX_ROWS).addSort("accession", SolrQuery.ORDER.asc);

    JSONArray jsonResult = new JSONArray();

    LOGGER.trace("[{}] {}", SolrCore.SEQUENCE.getSolrCoreName(), query.toString());
    String apiResponse = dataApi.solrQuery(SolrCore.SEQUENCE, query);
    Map resp = jsonReader.readValue(apiResponse);
    Map respBody = (Map) resp.get("response");

    List<GenomeSequence> sequences = dataApi.bindDocuments((List<Map>) respBody.get("docs"),
            GenomeSequence.class);

    for (GenomeSequence sequence : sequences) {

        JSONObject seq = new JSONObject();
        seq.put("length", sequence.getLength());
        seq.put("name", sequence.getAccession());
        seq.put("accn", sequence.getAccession());
        //         seq.put("sid", sequence.getId());
        seq.put("sid", sequence.getGenomeId());
        seq.put("start", 0);
        seq.put("end", sequence.getLength());
        seq.put("seqDir", "");
        seq.put("seqChunkSize", sequence.getLength());

        jsonResult.add(seq);
    }

    // TODO: remove this when data API limit is removed
    int i = 1;
    while (sequences.size() == 25000) {
        query.setStart(25000 * i);

        apiResponse = dataApi.solrQuery(SolrCore.SEQUENCE, query);
        resp = jsonReader.readValue(apiResponse);
        respBody = (Map) resp.get("response");

        sequences = dataApi.bindDocuments((List<Map>) respBody.get("docs"), GenomeSequence.class);

        for (GenomeSequence sequence : sequences) {

            JSONObject seq = new JSONObject();
            seq.put("length", sequence.getLength());
            seq.put("name", sequence.getAccession());
            seq.put("accn", sequence.getAccession());
            seq.put("sid", sequence.getGenomeId());
            seq.put("start", 0);
            seq.put("end", sequence.getLength());
            seq.put("seqDir", "");
            seq.put("seqChunkSize", sequence.getLength());

            jsonResult.add(seq);
        }
        i++;
    }

    response.setContentType("application/json");
    jsonResult.writeJSONString(response.getWriter());
    response.getWriter().close();
}

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

License:Apache License

@Override
public void init() throws PortletException {
    super.init();

    ObjectMapper objectMapper = new ObjectMapper();
    jsonReader = objectMapper.reader(Map.class);

    // update genome-id mapping cache
    try {/*from w w w .  ja  v  a 2 s.c o  m*/
        DataApiHandler dataApi = new DataApiHandler();

        SolrQuery query = new SolrQuery("*:*");
        query.setFields("genome_name,genome_id").setRows(dataApi.MAX_ROWS);

        LOGGER.trace("[{}] {}", SolrCore.GENOME, query);

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

        Map resp = jsonReader.readValue(apiResponse);
        Map respBody = (Map) resp.get("response");
        List<Genome> genomes = dataApi.bindDocuments((List<Map>) respBody.get("docs"), Genome.class);

        StringBuilder sb = new StringBuilder();
        sb.append("var genomeMap = new Array();\n");

        for (Genome genome : genomes) {
            sb.append("genomeMap[\"").append(genome.getGenomeName().replaceAll("[\\s\\(\\)\\:\\[\\],]+", "_"))
                    .append("\"] = \"").append(genome.getId()).append("\";\n");
        }

        // 2nd query due to the DataAPI has 25k limit
        query.setStart(25001);

        LOGGER.trace("[{}] {}", SolrCore.GENOME, query);

        apiResponse = dataApi.solrQuery(SolrCore.GENOME, query);
        resp = jsonReader.readValue(apiResponse);
        respBody = (Map) resp.get("response");
        genomes = dataApi.bindDocuments((List<Map>) respBody.get("docs"), Genome.class);

        for (Genome genome : genomes) {
            sb.append("genomeMap[\"").append(genome.getGenomeName().replaceAll("[\\s\\(\\)\\:\\[\\],]+", "_"))
                    .append("\"] = \"").append(genome.getId()).append("\";\n");
        }

        PrintWriter out = new PrintWriter(new FileWriter(getPortletContext().getRealPath("/js/genomeMaps.js")));
        out.println(sb.toString());
        out.close();
    } catch (IOException e) {
        LOGGER.error(e.getMessage(), e);
    }
}