D-Net

package eu.dnetlib.data.search.solr;

import eu.dnetlib.data.search.transform.TransformerException;

import eu.dnetlib.data.search.utils.solr.SolrResultSetOptionsUtil;

import eu.dnetlib.data.search.utils.solr.SolrResultsFormatter;

import gr.uoa.di.driver.enabling.resultset.ResultSet;

import io.micrometer.prometheus.PrometheusMeterRegistry;

import org.apache.solr.client.solrj.response.QueryResponse;

import org.apache.solr.common.SolrDocumentList;

import org.apache.solr.common.params.SolrParams;

import org.apache.solr.common.util.NamedList;

import org.z3950.zing.cql.CQLParseException;

/**

 * Created by antleb on 2/4/14.

 */

    private Logger logger = Logger.getLogger(getClass());

    private EPR epr = null;

    private NamedList<String> queryOpts = new NamedList<String>();

        String layout = epr.getParameter("layout");

        String mdformat = epr.getParameter("mdformat");

        String interpretation = epr.getParameter("interpretation");

        this.registry = registry;

    @Override

    public boolean isOpen() {

        return true;

    }

    @Override

    public boolean isAlive() {

        return true;

    }

    @Override

    public void close() {

        try {

            logger.debug("!!!!!!!!! !!!!!!! CLOSING !!!!!!!!! !!!!!!!!!! ");

            solrClient.close();

        } catch (IOException e) {

            logger.error("Error closing result set.", e);

        }

*/

    @Override

    public int size() {

    }

    @Deprecated

    public List<String> getElements(int from, int to) {

        return get(from, to);

    @Override

    @Deprecated

    public List<String> get(int from, int to) {

        List<String> res = new ArrayList<String>();

        HashMap<String, List<String>> map = new HashMap<String, List<String>>();

        logger.debug("from: " + from);

        logger.debug("to: " + to);

        queryOpts.add("start", from+1 + "");

        queryOpts.add("rows", to + 1+"");

        try {

            SolrDocumentList docs = rsp.getResults();

                for (int i = from - 1; i < to; i++) {

                    for (FacetField field : facetFields) {

                        if (field.getValueCount() > i) {

                            BrowseField bf = new BrowseField();

                            bf.setId(field.getValues().get(i).getName());

                            bf.setName(field.getValues().get(i).getName());

                            bf.setCount(field.getValues().get(i).getCount() + "");

                            if (map.get(field.getName()) == null) {

                                map.put(field.getName(), new ArrayList<String>());

                            }

                        }

                    }

                }

                    StringBuilder builder = new StringBuilder();

                    builder.append("\"" + facetEntry.getKey() + "\"" + " : ");

                    builder.append(facetEntry.getValue());

                    res.add(builder.toString());

                }

            logger.debug("found: " + docs.getNumFound());

            logger.debug("docs: " + docs.size());

            for (int i = 0; i < docs.size(); i++) {

            }

            return res;

        } catch (SolrServerException sse) {

            logger.error("Fail to get results from Solr. ", sse);

        } catch (IOException ioe) {

            logger.error("Fail to get results from Solr. ", ioe);

    public EPR getEpr() {

        return null;

    }

        List<String> refineSolrResults = new ArrayList<String>();

        List<String> searchSolrResults = new ArrayList<String>();

        HashMap<String, List<String>> map = new HashMap<String, List<String>>();

        queryOpts.add("rows", to +"");

            rsp = solrClient.query(SolrParams.toSolrParams(queryOpts));

            timer.stop(registry.timer("solr.server.response.duration"));

            logger.info("Solrj time " + estimatedTime/1000000 +  " milliseconds for query:" + queryOpts.get("q") +

                    " and facets " + queryOpts.getAll("facet.field") + " and fq " + queryOpts.getAll("fq") + " from: "

                    + from + " and size " + to);

                if (format != null && format.equals(MediaType.APPLICATION_JSON)) {

                    for (FacetField field : facetFields) {

                        map.put(field.getName(), new ArrayList<String>());

                        BrowseField bf = null;

                        for (int i = 0; i < field.getValueCount(); i++) {

                            bf = new BrowseField();

                            bf.setId(field.getValues().get(i).getName());

                            String[] facetedValues = field.getValues().get(i).getName().split("\\|\\|",2);

                            logger.debug("faceted values " + Arrays.toString(facetedValues));

                                bf.setName(facetedValues[1]);

                            } else if (field.getValues().get(i).getName().split("_\\:\\:",2).length > 1) {

                                bf.setName(field.getValues().get(i).getName().split("\\:\\:",2)[1].replaceAll("\\:\\:", "\\|"));

                            } else {

                                bf.setName(field.getValues().get(i).getName());

                            bf.setCount(field.getValues().get(i).getCount() + "");

                            map.get(field.getName()).add(new Gson().toJson(bf));

                    StringBuilder builder = null;

                    for (Map.Entry<String, List<String>> facetEntry : map.entrySet()) {

                        builder = new StringBuilder();

                        builder.append("\"" + facetEntry.getKey() + "\"" + " : ");

                        builder.append(facetEntry.getValue());

                        refineSolrResults.add(builder.toString());

                    }

                    createXmlRefineFields(refineSolrResults, oldRefineTransformer);

                logger.debug("["+ i +"]: " + docs.get(i).get("__result"));

                    if (transformer != null) {

                        result = transformer.transform(xml);

                    logger.warn("Error transforming " + result, te);

                    continue;

                }

                if (format != null && format.equals(MediaType.APPLICATION_JSON)) {

                    searchSolrResults.add(SolrResultsFormatter.xml2Json(result));

                } else { // default xml

                    searchSolrResults.add(result);

                }

            //logger.info("search results " + searchSolrResults);

            response.put("search", searchSolrResults);

            return response;

        } catch (SolrServerException sse) {

            logger.error("Error calling Solr.", sse);

        } catch (IOException ioe) {

            logger.error("Error calling Solr.", ioe);

     * limit is the maximum number of results the cursor get is allowed to fetch. If limit is set to -1 all

     * results are returned.

     */

    public void cursorGet(Transformer transformer, int limit, OutputStream os) throws SolrServerException, SearchServiceException {

        int rows = 500;

        int limitCounter = -1;

        queryOpts.remove("rows");

        queryOpts.add("shards.tolerant","true");

        queryOpts.add("cursorMark", "*");

        queryOpts.add("sort", "__indexrecordidentifier asc");

        String cursorMark = "*";

        String nextCursorMark = "";

            limitCounter = limit/rows;

            logger.info("limit counter " + limitCounter);

        }

            QueryResponse resp = solrClient.query(SolrParams.toSolrParams(queryOpts));

                //logger.info(">> " + limitCounter);

                cursorMark = nextCursorMark;

                nextCursorMark = resp.getNextCursorMark();

                    if (transformer != null) {

                        String result = null;

                        try {

                            logger.debug("RESULT " + result);

                            logger.warn("Error transforming " + result, te);

                            continue;

                        }

                            os.write(result.getBytes());

                            os.flush();

                        } catch (IOException e) {

                            logger.error("Cursor get... ", e);

                            continue;

                        }

                queryOpts.remove("cursorMark");

                queryOpts.add("cursorMark", nextCursorMark);

            logger.error("Error executing solr query. ", ioe);

    //Just copied and refactored the old one...

    @Deprecated

    private void createXmlRefineFields(List<String> res, Transformer oldRefineTransformer) {

        int max = -12;

            logger.debug("field " + field.getName() + " has count " + field.getValueCount());

                max = field.getValueCount();

            }

        }

            StringBuilder sb = new StringBuilder();

            for (FacetField field:facetFields) {

                if (field.getValueCount() > i) {

                    sb.append("<groupresult field=\"").append(field.getName()).append("\">");

                    sb.append("<count>").append(field.getValues().get(i).getCount()).append("</count>");

                    sb.append("<originalValue>").append(StringEscapeUtils.escapeXml(field.getValues().get(i).getName())).append("</originalValue>");

                    if(facetValues.length > 1) {

                        sb.append("<value>").append(StringEscapeUtils.escapeXml(facetValues[1])).append("</value>");

                    } else {

                        sb.append("<value>").append(StringEscapeUtils.escapeXml(facetValues[0])).append("</value>");

                    }

                    sb.append("</groupresult>");

                }

                //logger.debug("row: " + sb.toString());

                //logger.debug("row2: " + oldRefineTransformer.transform(sb.toString()));

                //TODO remove

                res.add(oldRefineTransformer.transform(sb.toString()));

            } catch (TransformerException te) {

                logger.error("Cannot transform refine for: " + sb.toString(), te);

            }

    }

        queryOpts.add("fl", "__result");

        queryOpts.add("sort", "__indexrecordidentifier asc");

        //queryOpts.add("q", new CqlTranslatorImpl().getTranslatedQuery("oaftype exact project").asLucene());

        System.out.println("results " + resp.getResults().size());

        int curs = 0;

        while (!cursorMark.equals(nextCursorMark)) {

            System.out.println("cursor " + cursorMark);

            System.out.println("next cursor " + nextCursorMark);

            cursorMark = nextCursorMark;

            for (int i = 0; i < resp.getResults().size(); i++) {

                String result = ((ArrayList<String>) resp.getResults().get(i).get("__result")).get(0);

                //System.out.println(result);

                resp = solrClient.query(SolrParams.toSolrParams(queryOpts));

            }

            nextCursorMark = resp.getNextCursorMark();

            queryOpts.add("cursorMark", nextCursorMark);

            System.out.println("CURS " + curs);

            curs ++;

        }

        //System.out.println((new CqlTranslatorImpl().getTranslatedQuery("objIdentifier = acm_________::0002c24f82c295e925a2bdf7bbf49bfc").asLucene()));

       // extraOpts.add("rows", "10");

       // extraOpts.addAll(queryOpts);

        //queryOpts.add("facet.mincount", "1");

        //queryOpts.add("fq", "popularity");

       // queryOpts.add("facet.field", "contextid");

       //  queryOpts.add("facet.field", "contextname");

       //  queryOpts.add("facet.mincount", "1");

       //  queryOpts.add("facet.threads", "10");

       // System.out.println(translatedQuery.getOptions().getSort().getMode());

       // System.out.println(translatedQuery.getOptions().getSort().getField());

        synchronized (solrClient) {

            resp = solrClient.query(SolrParams.toSolrParams(extraOpts));

        }*/

//        System.out.println("time: " + resp.getElapsedTime());

    //System.out.println("results: " + resp.getResults());

            System.out.println(count.getName() + " : " +  count.getCount());

            if (field.getValueCount() > max)

                max = field.getValueCount();

*/

//    public EPR getEpr() {

//        return epr;

//   }

    String name;

        return name;

    }

    public void setName(String name) {

        this.name = name;

    }

    public String getId() {

        return id;

    }

    public void setId(String id) {

        this.id = id;

    }

    public String getCount() {

        return count;

    }

    public void setCount(String count) {

        this.count = count;

    }

    String id;

    String count;