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

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

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

Introduction

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

Prototype

public SolrQuery setQuery(String query)

Source Link

Usage

From source file:eu.europeana.core.querymodel.query.SolrQueryUtil.java

License:EUPL

public static SolrQuery createFromQueryParams(Map<String, String[]> params, QueryAnalyzer queryAnalyzer,
        Locale locale, RecordDefinition recordDefinition) throws EuropeanaQueryException {
    SolrQuery solrQuery = new SolrQuery();
    if (params.containsKey("query") || params.containsKey("query1")) {
        if (!params.containsKey("query")) { // support advanced search
            solrQuery.setQuery(queryAnalyzer.createAdvancedQuery(params, locale));
        } else {/*ww  w . j a va  2 s.  c  o m*/
            if (params.containsKey("zoeken_in") && !params.get("zoeken_in")[0].equalsIgnoreCase("text")) {
                String zoekenIn = params.get("zoeken_in")[0];
                solrQuery.setQuery(zoekenIn + ":\""
                        + queryAnalyzer.sanitizeAndTranslate(params.get("query")[0], locale) + "\""); // only get the first one
            } else {
                solrQuery.setQuery(queryAnalyzer.sanitizeAndTranslate(params.get("query")[0], locale)); // only get the first one
            }
        }
    } else {
        throw new EuropeanaQueryException(QueryProblem.MALFORMED_QUERY.toString());
    }
    if (solrQuery.getQuery().trim().length() == 0) { // throw exception when no query is specified
        throw new EuropeanaQueryException(QueryProblem.MALFORMED_QUERY.toString());
    }
    if (params.containsKey("start")) {
        try {
            Integer start = Integer.valueOf(params.get("start")[0]);
            solrQuery.setStart(start);
        } catch (NumberFormatException e) {
            // if number exception is thrown take default setting 0 (hardening parameter handling)
        }
    }
    if (params.containsKey("rows")) {
        try {
            Integer rows = Integer.valueOf(params.get("rows")[0]);
            solrQuery.setRows(rows);
        } catch (NumberFormatException e) {
            // number exception is thrown take default setting 12 (hardening parameter handling)
        }
    }
    if (solrQuery.getQueryType() == null) {
        solrQuery.setQueryType(
                queryAnalyzer.findSolrQueryType(solrQuery.getQuery(), recordDefinition).toString());
    }

    // set sort field
    if (params.containsKey("sortBy") && !params.get("sortBy")[0].isEmpty()) {
        String sortField = params.get("sortBy")[0];
        if (sortField.equalsIgnoreCase("title")) {
            sortField = "sort_title";
        } else if (sortField.equalsIgnoreCase("creator")) {
            sortField = "sort_creator";
        } else if (sortField.equalsIgnoreCase("year")) {
            sortField = "sort_all_year";
        } else if (sortField.equalsIgnoreCase("random")) {
            sortField = SolrQueryUtil.createRandomSortKey();
        }

        if (params.containsKey("sortOrder") && !params.get("sortOrder")[0].isEmpty()) {
            String sortOrder = params.get("sortOrder")[0];
            if (sortOrder.equalsIgnoreCase("desc")) {
                solrQuery.setSortField(sortField, SolrQuery.ORDER.desc);
            }
        } else {
            solrQuery.setSortField(sortField, SolrQuery.ORDER.asc);
        }
    }

    //set constraints
    List<String> filterQueries = new ArrayList<String>();
    if (params.containsKey("qf")) {
        Collections.addAll(filterQueries, params.get("qf"));
    }
    if (params.containsKey("qf[]")) {
        Collections.addAll(filterQueries, params.get("qf[]"));
    }
    if (filterQueries != null) {
        for (String filterQuery : filterQueries) {
            solrQuery.addFilterQuery(filterQuery);
        }
    }
    // determine which fields will be returned
    if (params.containsKey("fl")) {
        String displayFields = params.get("fl")[0];
        if (!displayFields.isEmpty()) {
            solrQuery.setFields(displayFields);
        }
    }
    // find rq and add to filter queries
    if (params.containsKey("rq") && params.get("rq").length != 0) {
        String refineSearchFilterQuery = queryAnalyzer.createRefineSearchFilterQuery(params, locale);
        if (!refineSearchFilterQuery.isEmpty()) {
            solrQuery.addFilterQuery(refineSearchFilterQuery);
        }
    }
    solrQuery.setFilterQueries(SolrQueryUtil.getFilterQueriesAsPhrases(solrQuery));
    return solrQuery;
}

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);/*from ww w  .j ava 2  s. c  o m*/
    solrQuery.addFacetField("YEAR");
    solrQuery.setRows(0);
    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.europeana.web.timeline.server.SolrServiceImpl.java

License:EUPL

@Override
public List<Item> retrieveBriefItems(String query, Integer offset, Integer limit) {
    SolrQuery solrQuery = new SolrQuery();
    solrQuery.setQuery(query);
    solrQuery.setParam("fl", "title,YEAR,TYPE,europeana_uri,europeana_object,dc_creator"); // todo: some of these fields are unused
    solrQuery.setFilterQueries("YEAR:[* TO *]", "title:[* TO *]", "-YEAR:0000");
    solrQuery.setRows(limit);/*  ww w . j a v a  2s  .c o m*/
    solrQuery.setStart(offset);
    QueryResponse response = null;
    try {
        response = solrServer.query(solrQuery);
        LOG.fine(String.format("Query : %s Offset : %d Limit %d", query, offset, limit));
    } catch (SolrServerException e) {
        LOG.severe(String.format("Error during Solr query for items: %s", e));
    }
    if (response != null) {
        return response.getBeans(Item.class);
    } else {
        return null;
    }
}

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 {/*w ww .  j  a  v  a  2  s .  c o  m*/
        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:fi.vm.sade.organisaatio.service.search.OrganisaatioSearchService.java

License:EUPL

public List<OrganisaatioPerustieto> searchHierarchy(final SearchCriteria searchCriteria) {
    long time = System.currentTimeMillis();
    final List<String> kunta = searchCriteria.getKunta();
    final List<String> restrictionList = searchCriteria.getOidRestrictionList();
    final String organisaatioTyyppi = searchCriteria.getOrganisaatioTyyppi();
    final List<String> kieli = searchCriteria.getKieli();
    String searchStr = searchCriteria.getSearchStr();
    String oid = searchCriteria.getOid();

    SolrQuery q = createOrgQuery(searchCriteria, kunta, restrictionList, organisaatioTyyppi, kieli, searchStr,
            oid);//w  w w  .  ja v  a 2s.  c o m

    q.set("fl", OID, PATH);
    // max rows to return
    q.setRows(10000);
    try {
        QueryResponse response = solr.query(q, METHOD.POST);

        LOG.debug("Sending query: " + q.getQuery() + ", filters: " + Joiner.on(" ").join(q.getFilterQueries()));
        LOG.debug("Search matched {} results, fetching docs...", response.getResults().getNumFound());
        if (response.getResults().getNumFound() == 0) {
            // short circuit no results here
            return Lists.newArrayList();
        }
        Set<String> oids = Sets.newHashSet();
        Set<String> paths = Sets.newHashSet();
        for (SolrDocument doc : response.getResults()) {
            if (!rootOrganisaatioOid.equals(doc.getFieldValue(OID))) {
                paths.add((String) doc.getFieldValue(OID));
            }

            if (!searchCriteria.getSkipParents()) {
                for (Object path : doc.getFieldValues(PATH)) {
                    if (!rootOrganisaatioOid.equals(path)) {
                        oids.add((String) path);
                    }
                }
            }
            oids.add((String) doc.getFirstValue(OID));
        }

        // get the actual docs
        q = new SolrQuery("*:*");
        q.setFields("*");
        addDateFilters(searchCriteria, q);

        // filter out oph (TODO do not index oph)
        q.addFilterQuery(String.format("-%s:%s", OID, rootOrganisaatioOid));

        // filter out types in upper hierarchy
        if (organisaatioTyyppi != null && organisaatioTyyppi.length() > 0) {
            final Set<String> limitToTypes = orgTypeLimit.get(organisaatioTyyppi);
            q.addFilterQuery(String.format("%s:(%s)", ORGANISAATIOTYYPPI, Joiner.on(" ").join(limitToTypes)));
        }

        // restrictions
        if (restrictionList.size() > 0) {
            // filter based on restriction list
            q.addFilterQuery(String.format("%s:(%s)", PATH, Joiner.on(" ").join(restrictionList)));
        }

        String query = String.format("%s:(%s)", OID, Joiner.on(" ").join(oids));
        if (paths.size() > 0) {
            query = query + String.format(" %s:(%s)", PATH, Joiner.on(" ").join(paths));
        }
        q.setQuery(query);
        q.setRows(10000);

        response = solr.query(q, METHOD.POST);

        LOG.debug("Search time :{} ms.", (System.currentTimeMillis() - time));

        final SolrDocumentToOrganisaatioPerustietoTypeFunction converter = new SolrDocumentToOrganisaatioPerustietoTypeFunction(
                oids);

        final List<OrganisaatioPerustieto> result = Lists
                .newArrayList(Lists.transform(response.getResults(), converter));

        LOG.debug("Total time :{} ms.", (System.currentTimeMillis() - time));
        return result;
    } catch (SolrServerException e) {
        LOG.error("Error executing search, q={}", q.getQuery());
        throw new RuntimeException(e);
    }
}

From source file:fr.aliacom.obm.common.contact.ContactDao.java

License:Open Source License

private List<Contact> searchContact(AccessToken at, List<AddressBook> addrBooks, Connection con, String querys,
        int limit) throws MalformedURLException, SQLException {
    List<Contact> ret = new LinkedList<Contact>();
    Set<Integer> evtIds = new HashSet<Integer>();

    PreparedStatement ps = null;//from  ww  w. j  a  v  a  2  s. c  om
    ResultSet rs = null;
    try {
        if (addrBooks.size() > 0) {
            SolrHelper solrHelper = solrHelperFactory.createClient(at);
            CommonsHttpSolrServer solrServer = solrHelper.getSolrContact();
            StringBuilder sb = new StringBuilder();
            sb.append("-is:archive ");
            sb.append("+addressbookId:(");
            int idx = 0;
            for (AddressBook book : addrBooks) {
                if (idx > 0) {
                    sb.append(" OR ");
                }
                sb.append(book.getUid());
                idx++;
            }
            sb.append(")");
            if (querys != null && !"".equals(querys)) {
                sb.append(" +(displayname:(");
                sb.append(querys.toLowerCase());
                sb.append("*) OR firstname:(");
                sb.append(querys.toLowerCase());
                sb.append("*) OR lastname:(");
                sb.append(querys.toLowerCase());
                sb.append("*) OR email:(");
                sb.append(querys.toLowerCase());
                sb.append("*))");
            }
            SolrQuery params = new SolrQuery();
            params.setQuery(sb.toString());
            params.setIncludeScore(true);
            params.setRows(limit);

            try {
                QueryResponse resp = solrServer.query(params);

                SolrDocumentList results = resp.getResults();
                if (logger.isDebugEnabled()) {
                    logger.debug("SOLR query time for " + results.size() + " results: " + resp.getElapsedTime()
                            + "ms.");
                }

                for (int i = 0; i < limit && i < results.size(); i++) {
                    SolrDocument doc = results.get(i);
                    Map<String, Object> payload = doc.getFieldValueMap();
                    evtIds.add((Integer) payload.get("id"));
                }
            } catch (SolrServerException e) {
                logger.error("Error querying server for '" + sb.toString() + " url: "
                        + ClientUtils.toQueryString(params, false), e);
            }
        }

        IntegerSQLCollectionHelper eventIds = new IntegerSQLCollectionHelper(evtIds);
        String q = "SELECT " + CONTACT_SELECT_FIELDS + ", now() as last_sync FROM Contact, ContactEntity WHERE "
                + "contactentity_contact_id=contact_id AND contact_archive != 1 AND contact_id IN ("
                + eventIds.asPlaceHolders() + ")";

        ps = con.prepareStatement(q);
        eventIds.insertValues(ps, 1);
        rs = ps.executeQuery();
        Map<Integer, Contact> entityContact = new HashMap<Integer, Contact>();

        int i = 0;
        while (rs.next() && i < limit) {
            int entity = rs.getInt("contactentity_entity_id");
            if (!entityContact.containsKey(entity)) {
                Contact ct = contactFromCursor(rs);
                entityContact.put(ct.getEntityId(), ct);
                ret.add(ct);
                i++;
            }
        }
        rs.close();
        rs = null;

        if (!entityContact.isEmpty()) {
            loadPhones(con, entityContact);
            loadIMIdentifiers(con, entityContact);
            loadWebsites(con, entityContact);
            loadAddresses(at, con, entityContact);
            loadEmails(con, entityContact);
            loadBirthday(con, entityContact);
            loadAnniversary(con, entityContact);
        }

    } finally {
        obmHelper.cleanup(null, ps, rs);
    }
    return ret;
}

From source file:fr.aliacom.obm.common.contact.ContactDaoJdbcImpl.java

License:Open Source License

private List<Contact> searchContact(AccessToken at, Collection<AddressBook> addrBooks, Connection con,
        String query, int limit, Integer offset)
        throws MalformedURLException, SQLException, LocatorClientException {

    Set<Integer> contactIds = new HashSet<Integer>();

    if (addrBooks.size() > 0) {
        SolrHelper solrHelper = solrHelperFactory.createClient(at);
        CommonsHttpSolrServer solrServer = solrHelper.getSolrContact();
        StringBuilder sb = new StringBuilder();
        sb.append("-is:archive ");
        sb.append("+addressbookId:(");
        int idx = 0;
        for (AddressBook book : addrBooks) {
            if (idx > 0) {
                sb.append(" OR ");
            }/*from   w  ww.  j a  va  2  s.c  om*/
            sb.append(book.getUid());
            idx++;
        }
        sb.append(")");
        if (query != null && !"".equals(query)) {
            sb.append(" +(displayname:(");
            sb.append(query.toLowerCase());
            sb.append("*) OR firstname:(");
            sb.append(query.toLowerCase());
            sb.append("*) OR lastname:(");
            sb.append(query.toLowerCase());
            sb.append("*) OR email:(");
            sb.append(query.toLowerCase());
            sb.append("*))");
        }
        SolrQuery params = new SolrQuery();
        params.setQuery(sb.toString());
        params.setIncludeScore(true);
        params.setRows(limit);
        params.setStart(offset);

        try {
            QueryResponse resp = solrServer.query(params);

            SolrDocumentList results = resp.getResults();
            if (logger.isDebugEnabled()) {
                logger.debug(
                        "SOLR query time for " + results.size() + " results: " + resp.getElapsedTime() + "ms.");
            }

            for (int i = 0; i < limit && i < results.size(); i++) {
                SolrDocument doc = results.get(i);
                Map<String, Object> payload = doc.getFieldValueMap();
                contactIds.add((Integer) payload.get("id"));
            }
        } catch (SolrServerException e) {
            logger.error("Error querying server for '" + sb.toString() + " url: "
                    + ClientUtils.toQueryString(params, false), e);
        }
    }

    ContactResults contactResults = loadContactsFromDB(contactIds, con, limit);

    if (!contactResults.contactMap.isEmpty()) {
        loadPhones(con, contactResults.contactMap);
        loadIMIdentifiers(con, contactResults.contactMap);
        loadWebsites(con, contactResults.contactMap);
        loadAddresses(at, con, contactResults.contactMap);
        loadEmails(con, contactResults.contactMap);
        loadBirthday(con, contactResults.contactMap);
        loadAnniversary(con, contactResults.contactMap);
    }

    return contactResults.contactList;
}

From source file:fr.aliasource.index.solr.SolrClient.java

License:GNU General Public License

private SolrParams createParams(String query) {
    SolrQuery sq = new SolrQuery();
    sq.setQuery(query);
    sq.setFilterQueries("type:" + getType());
    sq.setIncludeScore(true);/*from w w  w . j av a  2  s .c  o m*/
    sq.setRows(Integer.MAX_VALUE);
    sq.addSortField("date", SolrQuery.ORDER.desc);
    return sq;
}

From source file:fr.cnes.sitools.metacatalogue.csw.extractor.CswMetadataExtractor.java

License:Open Source License

@Override
public void execute(MetadataContainer data) throws ProcessException {
    logger = getLogger(context);/*  w  ww .j  a  v  a  2s  .c  om*/
    Element metadata = data.getXmlData();

    String resourcesFolder = HarvesterSettings.getInstance().getResourcePath(schemaName, "solr-fields.xsl");
    File sFileXSL = new File(resourcesFolder);

    List<Element> children = metadata.getChildren();

    List<MetadataRecords> listMetadataRecords = new ArrayList<MetadataRecords>();

    for (Element child : children) {

        try {
            XSLTUtils utils = XSLTUtils.getInstance();
            InputStream stream = utils.transform(sFileXSL, child);

            // BufferedReader stdIn = new BufferedReader(new InputStreamReader(stream));
            // String userInput;
            //
            // while ((userInput = stdIn.readLine()) != null) {
            // System.out.println(userInput);
            // }

            Element doc = Xml.loadStream(stream);

            List<Field> fields = getFields(doc);
            List<Error> errors = getErrors(doc);

            CswGeometryExtractor extractor = new CswGeometryExtractor();

            MetadataRecords mdRecords = new MetadataRecords(fields, errors);

            mdRecords = extractor.extractGeometry(child, mdRecords, this.schemaName);
            if (mdRecords != null) {
                // add the custom attributes
                addCustomAttributes(child, mdRecords, conf.getAttributes());

                // public services
                addField(mdRecords, String.valueOf(conf.isPublicServices()),
                        MetacatalogField._PUBLIC_SERVICES.getField());

                HarvestStatus status = (HarvestStatus) context.getAttributes().get(ContextAttributes.STATUS);

                // modified
                List<String> frmt = HarvesterSettings.getInstance().getDateFormats();
                String modified = DateUtils.format(status.getStartDate(), frmt);
                addField(mdRecords, modified, MetacatalogField.MODIFIED.getField());

                // created
                Date creationDate = null;
                SolrServer server = (SolrServer) context.getAttributes().get("INDEXER_SERVER");
                SolrQuery solrQuery = new SolrQuery();
                String identifier = getId(doc);
                if (identifier != null) {
                    try {
                        solrQuery.setQuery(MetacatalogField.IDENTIFIER.getField() + ":"
                                + String.format("\"%s\"", identifier.toString()));
                        QueryResponse rsp = server.query(solrQuery);
                        SolrDocumentList listDocuments = rsp.getResults();
                        if (!listDocuments.isEmpty()) {
                            SolrDocument solrDocument = listDocuments.get(0);
                            creationDate = (Date) solrDocument.get(MetacatalogField.CREATED.getField());
                        }
                    } catch (SolrServerException e) {
                        e.printStackTrace();
                    }
                }
                String created;
                if (creationDate != null) {
                    created = DateUtils.format(creationDate, frmt);
                } else {
                    created = DateUtils.format(status.getStartDate(), frmt);
                }
                addField(mdRecords, created, MetacatalogField.CREATED.getField());

                listMetadataRecords.add(mdRecords);

            }

        } catch (TransformerConfigurationException e) {
            logger.log(Level.WARNING, e.getMessage(), e);
        } catch (TransformerException e) {
            logger.log(Level.WARNING, e.getMessage(), e);
        } catch (Exception e) {
            logger.log(Level.WARNING, e.getMessage(), e);
        }
    }

    if (data.getMetadataRecords() == null) {
        data.setMetadataRecords(listMetadataRecords);
    } else {
        data.getMetadataRecords().addAll(listMetadataRecords);
    }
    next.execute(data);

}

From source file:fr.cnes.sitools.metacatalogue.CswMetadataIndexerTestCase.java

License:Open Source License

private void assertMetadataInserted() throws SolrServerException {
    SolrQuery query = new SolrQuery();
    query.setQuery("*:*");

    QueryResponse rsp = server.query(query);
    assertNotNull(rsp);/* w w w.  java2  s .c  o m*/
    SolrDocumentList listDoc = rsp.getResults();
    assertNotNull(listDoc);
    assertEquals(nbFieldsExpected, listDoc.getNumFound());
}