D-Net

package eu.dnetlib.data.search.web.api;

import eu.dnetlib.api.data.SearchServiceException;

import eu.dnetlib.data.search.app.SearchServiceImpl;

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

import eu.dnetlib.data.search.web.utils.RequestResponseHandler;

import eu.dnetlib.domain.data.SearchResult;

import eu.dnetlib.functionality.index.cql.CqlTranslator;

import eu.dnetlib.functionality.index.cql.CqlTranslatorImpl;

import org.apache.log4j.Logger;

import org.json.XML;

import org.springframework.beans.factory.annotation.Autowired;

import org.springframework.stereotype.Component;

import org.z3950.zing.cql.CQLParseException;

import javax.servlet.http.HttpServletRequest;

import javax.ws.rs.*;

import javax.ws.rs.core.Context;

import javax.ws.rs.core.MediaType;

import javax.ws.rs.core.Response;

import java.io.IOException;

import java.util.Arrays;

import java.util.List;

import java.util.Locale;

import java.util.Map;

/**

 * Created by kiatrop on 2/6/2016.

 */

@Component

@Path("/v2")

public class SearchApiService {

    private static final Logger logger = Logger.getLogger(SearchApiService.class);

    @Autowired

    private SearchServiceImpl searchService = null;

    @GET

    @Path("/api/resources")

    @Produces({MediaType.APPLICATION_JSON, MediaType.APPLICATION_XML})

    public Response fetchResources(@QueryParam("query") String query,

                                      @DefaultValue("1") @QueryParam("page") final int offset,

                                      @DefaultValue("10") @QueryParam("size") final int limit,

                                      @QueryParam("refine") @DefaultValue("false") final boolean refine,

                                      @QueryParam("fields") final List<String> fields,

                                      @QueryParam("fq") final List<String> fieldQueries,

                                      @QueryParam("format") final String format,

                                      @Context final HttpServletRequest request) {

        String type = null;

        if (format != null && !format.isEmpty() && format.equalsIgnoreCase("json")) {

            type = MediaType.APPLICATION_JSON;

        } else {

            type = MediaType.APPLICATION_XML;

        }

        if(query == null || query.isEmpty()) {

            return Response.status(Response.Status.BAD_REQUEST).

                    entity(APIResponseFormatter.compose400Message(type, "The 'query' parameter is required")).

                    type(type).build();

        }

        return getResponseByEntity(query, RequestResponseHandler.Entity.PUBLICATION, offset, limit, format, request, refine, fields, fieldQueries);

    }

/*

    @GET

    @Path("/api/publications")

    @Produces({MediaType.APPLICATION_JSON, MediaType.APPLICATION_XML})

    public Response fetchPublications(@QueryParam("q") String keywords,

                                      @DefaultValue("1") @QueryParam("page") final int offset,

                                      @DefaultValue("10") @QueryParam("size") final int limit,

                                      @QueryParam("refine") @DefaultValue("false") final boolean refine,

                                      @QueryParam("fields") final List<String> fields,

                                      @QueryParam("format") final String format,

                                      @Context final HttpServletRequest request) {

            String simpleQuery = createSimpleSearchQuery(RequestResponseHandler.Entity.PUBLICATION, keywords);

            return getResponseByEntity(simpleQuery, RequestResponseHandler.Entity.PUBLICATION, offset, limit, format, request, refine, fields);

    }

    private String createSimpleSearchQuery(RequestResponseHandler.Entity entity, String keywords) {

        StringBuilder queryBuilder = new StringBuilder();

        enhanceQueryWithEntityType(queryBuilder,entity);

        enhanceQueryWithKeywords(queryBuilder, keywords);

        return queryBuilder.toString();

    }

    private void enhanceQueryWithKeywords(StringBuilder queryBuilder, String keywords) {

        queryBuilder.append(' ').append(CQLQueryGeneration.Operator.AND).append(' ').append(keywords);

    }

    private String builtFullQuery(List<String> keywords, List<String> keywordOperators, RequestResponseHandler.Entity entity, HttpServletRequest request) {

        Map<String, String[]> parameterMap = request.getParameterMap();

        Map<String, String[]> operators = new HashMap<String, String[]>();

        Map<String, String[]> parameters = new HashMap<String, String[]>();

        extractParameterNOperatorsValues(parameterMap, operators, parameters, entity);

        return enhanceQuery(keywords, keywordOperators, operators, parameters, entity);

    }

/*    public static void buildFq(RequestResponseHandler.Entity entity, HttpServletRequest request, List<String> fields, List<FieldQuery> fieldQueries) {

        Map<String, String[]> parameterMap = request.getParameterMap();

        Map<String, String> indexParameterMap = entity.geIndexParameterMap();

        Map<String, String> parameterOperatorMap = entity.getParameterOperatorMap();

        //logger.debug(parameterOperatorMap.keySet());

        for (String field:fields) {

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

            String parameter = indexParameterMap.get(field);

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

            if (indexParameterMap.get(field) != null  ) {

                String[] refineValues = request.getParameterValues(parameter);

                String operatorParameter = parameterOperatorMap.get(parameter);

                String operatorValue = null;

                if (operatorParameter != null && !operatorParameter.trim().isEmpty()) {

                    operatorValue = request.getParameter(operatorParameter);

                    if (operatorValue == null || operatorValue.trim().isEmpty()) {

                        operatorValue = "AND";

                    }

                    fieldQueries.add(new FieldQuery(field, operatorValue, refineValues));

                } else {

                    //TODO throw exception?

                }

            }

        }

    }

*/

    /*

    public static String createFqParameter(List<FieldQuery> fieldQueries) {

        StringBuilder fq = new StringBuilder();

        for (FieldQuery fieldQuery:fieldQueries) {

            fq.append(fieldQuery.getIndexField());

            if(fieldQuery.getValues() != null && fieldQuery.getValues().length == 0) {

                for(int i=0; i< fieldQuery.getValues().length; i++) {

                    fq.append(":").append(fieldQuery.getValues()[i] + " ");

                    if(i < fieldQuery.getValues().length-1) {

                        fq.append(" " + fieldQuery.getOperator() + " ");

                    }

                }

            }

        }

        return fq.toString();

    }

    @GET

    @Path("/api/publications/count")

    @Produces({MediaType.APPLICATION_JSON, MediaType.APPLICATION_XML})

    public Response fetchPublicationsCount(@QueryParam("q") String query) {

        String fullQuery = builtQueryByEntity(query, RequestResponseHandler.Entity.PUBLICATION);

        return getCount(fullQuery);

    }

    @GET

    @Path("/api/publications/{publicationid}")

    @Produces({MediaType.APPLICATION_JSON, MediaType.APPLICATION_XML})

    public Response fetchPublicationsById(@PathParam("publicationid") String publicationid) {

        return getResponseByEntityId(RequestResponseHandler.Entity.PUBLICATION, publicationid);

    }

    @GET

    @Path("/api/datasets")

    @Produces({MediaType.APPLICATION_JSON, MediaType.APPLICATION_XML})

    public Response fetchDatasets(@QueryParam("q") List<String> keywords,

                                  @QueryParam("op") final List<String> keywordOperators,

                                  @DefaultValue("1") @QueryParam("page") int offset,

                                  @DefaultValue("10") @QueryParam("size") int limit,

                                  @QueryParam("refine") @DefaultValue("false") boolean refine,

                                  @QueryParam("fields") final List<String> fields,

                                  @QueryParam("format") final String format,

                                  @Context HttpServletRequest request) {

        String fullQuery = builtFullQuery(keywords, keywordOperators, RequestResponseHandler.Entity.PUBLICATION, request);

        return getResponseByEntity(fullQuery, RequestResponseHandler.Entity.DATASET, offset, limit, format, request, refine, fields);

    }

    @GET

    @Path("/api/datasets/count")

    @Produces({MediaType.APPLICATION_JSON, MediaType.APPLICATION_XML})

    public Response fetchDatesetsCount(@QueryParam("q") String query) {

        String fullQuery = builtQueryByEntity(query, RequestResponseHandler.Entity.DATASET);

        return getCount(fullQuery);

    }

    @GET

    @Path("/api/datasets/{datasetid}")

    @Produces({MediaType.APPLICATION_JSON, MediaType.APPLICATION_XML})

    public Response fetchDatasets(@PathParam("datasetid") String datasetid) {

        return getResponseByEntityId(RequestResponseHandler.Entity.DATASET, datasetid);

    }

    @GET

    @Path("/api/projects")

    @Produces({MediaType.APPLICATION_JSON, MediaType.APPLICATION_XML})

    public Response fetchProjects(@QueryParam("q") List<String> keywords,

                                  @QueryParam("op") final List<String> keywordOperators,

                                  @DefaultValue("1") @QueryParam("page") final int offset,

                                  @DefaultValue("10") @QueryParam("size") final int limit,

                                  @QueryParam("refine") @DefaultValue("false") final boolean refine,

                                  @QueryParam("format") final String format,

                                  @QueryParam("fields") final List<String> fields,

                                  @Context final HttpServletRequest request)  {

        String fullQuery = builtFullQuery(keywords, keywordOperators, RequestResponseHandler.Entity.PROJECT, request);

        return getResponseByEntity(fullQuery, RequestResponseHandler.Entity.PROJECT, offset, limit, format, request, refine, fields);

    }

    @GET

    @Path("/api/projects/count")

    @Produces({MediaType.APPLICATION_JSON, MediaType.APPLICATION_XML})

    public Response fetchProjectsCount(@QueryParam("q") String query){

        String fullQuery = builtQueryByEntity(query, RequestResponseHandler.Entity.PROJECT);

        return getCount(fullQuery);

    }

    @GET

    @Path("/api/projects/{projectid}")

    @Produces({MediaType.APPLICATION_JSON, MediaType.APPLICATION_XML})

    public Response fetchProjects(@PathParam("projectid") String projectid) {

        return getResponseByEntityId(RequestResponseHandler.Entity.PROJECT, projectid);

    }

    @GET

    @Path("/api/projects/{projectId}/publications")

    @Produces({MediaType.APPLICATION_JSON, MediaType.APPLICATION_XML})

    public Response fetchProjectPublications(@PathParam("projectId") String projectId,

                                             @DefaultValue("1") @QueryParam("page") int offset,

                                             @DefaultValue("10") @QueryParam("size") int limit,

                                             @QueryParam("format") final String format,

                                             @Context HttpServletRequest request)  {

        String fullQuery = builtEntity2EntityRelationQuery(RequestResponseHandler.Entity.PUBLICATION, "relprojectid", projectId);

        return getResponseByEntity(fullQuery, RequestResponseHandler.Entity.PUBLICATION, offset, limit, format, request, false, null);

    }

    @GET

    @Path("/api/projects/{projectId}/publications/count")

    @Produces({MediaType.APPLICATION_JSON, MediaType.APPLICATION_XML})

    public Response fetchProjectPublicationsCount(@PathParam("projectId") String projectId) {

        String fullQuery = builtEntity2EntityRelationQuery(RequestResponseHandler.Entity.PUBLICATION, "relprojectid", projectId);

        return getCount(fullQuery);

    }

    @GET

    @Path("/api/projects/{projectId}/datasets")

    @Produces({MediaType.APPLICATION_JSON, MediaType.APPLICATION_XML})

    public Response fetchProjectDatasets(@PathParam("projectId") String projectId,

                                             @DefaultValue("1") @QueryParam("page") int offset,

                                             @DefaultValue("10") @QueryParam("size") int limit,

                                             @QueryParam("format") final String format,

                                             @Context HttpServletRequest request)  {

        String fullQuery = builtEntity2EntityRelationQuery(RequestResponseHandler.Entity.DATASET, "relprojectid", projectId);

        return getResponseByEntity(fullQuery, RequestResponseHandler.Entity.DATASET, offset, limit, format, request, false, null);

    }

    @GET

    @Path("/api/projects/{projectId}/datasets/count")

    @Produces({MediaType.APPLICATION_JSON, MediaType.APPLICATION_XML})

    public Response fetchProjectDatasetsCount(@PathParam("projectId") String projectId,

                                         @DefaultValue("1") @QueryParam("page") int offset,

                                         @DefaultValue("10") @QueryParam("size") int limit,

                                         @Context HttpServletRequest request)  {

        String fullQuery = builtEntity2EntityRelationQuery(RequestResponseHandler.Entity.DATASET, "relprojectid", projectId);

        return getCount(fullQuery);

    }

    @GET

    @Path("/api/datasources")

    @Produces({MediaType.APPLICATION_JSON, MediaType.APPLICATION_XML})

    public Response fetchDatasources(@QueryParam("q") List<String> keywords,

                                     @QueryParam("op") final List<String> keywordOperators,

                                     @DefaultValue("1") @QueryParam("page") final int offset,

                                     @DefaultValue("10") @QueryParam("size") final int limit,

                                     @QueryParam("refine") @DefaultValue("false") final boolean refine,

                                     @QueryParam("fields") final List<String> fields,

                                     @QueryParam("format") final String format,

                                     @Context final HttpServletRequest request)  {

        String fullQuery = builtFullQuery(keywords, keywordOperators, RequestResponseHandler.Entity.DATASOURCE, request);

        return getResponseByEntity(fullQuery, RequestResponseHandler.Entity.DATASOURCE, offset, limit, format, request, refine, fields);

    }

    @GET

    @Path("/api/datasources/count")

    @Produces({MediaType.APPLICATION_JSON, MediaType.APPLICATION_XML})

    public Response fetchDatasourcesCount(@QueryParam("q") String query){

        String fullQuery = builtQueryByEntity(query, RequestResponseHandler.Entity.DATASOURCE);

        return getCount(fullQuery);

    }

    @GET

    @Path("/api/datasources/{datasourceid}")

    @Produces({MediaType.APPLICATION_JSON, MediaType.APPLICATION_XML})

    public Response fetchDatasources(@PathParam("datasourceid") String datasourceid)  {

        return getResponseByEntityId(RequestResponseHandler.Entity.DATASOURCE, datasourceid);

    }

*/

    /*

    @Path("/api/datasources/{datasourceid}/publications")

    @Path("/api/datasources/{datasourceid}/publications/count")

    Same for datasets.

    NOT supported by schema. No such field as *reldatasourceid*.

    To oercomethis collectedFrom and hostedBy are added in the other paths when needed

    */

/*

    @GET

    @Path("/api/organizations")

    @Produces({MediaType.APPLICATION_JSON, MediaType.APPLICATION_XML})

    public Response fetchOrganisations(@QueryParam("q") List<String> keywords,

                                       @QueryParam("op") final List<String> keywordOperators,

                                       @DefaultValue("1") @QueryParam("page") final int offset,

                                       @DefaultValue("10") @QueryParam("size") final int limit,

                                       @QueryParam("refine") @DefaultValue("false") final boolean refine,

                                       @QueryParam("fields") final List<String> fields,

                                       @QueryParam("format") final String format,

                                       @Context final HttpServletRequest request) {

        String fullQuery = builtFullQuery(keywords, keywordOperators, RequestResponseHandler.Entity.ORGANIZATION, request);

        return getResponseByEntity(fullQuery, RequestResponseHandler.Entity.ORGANIZATION, offset, limit, format, request, refine, fields);

    }

    @GET

    @Path("/api/organizations/count")

    @Produces({MediaType.APPLICATION_JSON, MediaType.APPLICATION_XML})

    public Response fetchOrganizationsCount(@QueryParam("q") String query){

        String fullQuery = builtQueryByEntity(query, RequestResponseHandler.Entity.ORGANIZATION);

        return getCount(fullQuery);

    }

    @GET

    @Path("/api/organizations/{organizationid}")

    @Produces({MediaType.APPLICATION_JSON, MediaType.APPLICATION_XML})

    public Response fetchOrganizations(@PathParam("organizationid") String organizationid) {

        return getResponseByEntityId(RequestResponseHandler.Entity.ORGANIZATION, organizationid);

    }

    @GET

    @Path("/api/organizations/{organizationid}/datasources")

    @Produces({MediaType.APPLICATION_JSON, MediaType.APPLICATION_XML})

    public Response fetchOrganizationDatasources(@PathParam("organizationid") String organizationid,

                                                 @DefaultValue("1") @QueryParam("page") int offset,

                                                 @DefaultValue("10") @QueryParam("size") int limit,

                                                 @QueryParam("format") final String format,

                                                 @Context HttpServletRequest request)  {

        String fullQuery = builtEntity2EntityRelationQuery(RequestResponseHandler.Entity.DATASOURCE, "relorganizationid", organizationid);

        return getResponseByEntity(fullQuery, RequestResponseHandler.Entity.DATASOURCE, offset, limit, format, request, false, null);

    }

    @GET

    @Path("/api/organizations/{organizationid}/datasources/count")

    @Produces({MediaType.APPLICATION_JSON, MediaType.APPLICATION_XML})

    public Response fetchOrganizationDatasources(@PathParam("organizationid") String organizationid)  {

        String fullQuery = builtEntity2EntityRelationQuery(RequestResponseHandler.Entity.DATASOURCE, "relorganizationid", organizationid);

        return getCount(fullQuery);

    }

    @GET

    @Path("/api/organizations/{organizationid}/projects")

    @Produces({MediaType.APPLICATION_JSON, MediaType.APPLICATION_XML})

    public Response fetchOrganizationProjects(@PathParam("organizationid") String organizationid,

                                                 @DefaultValue("1") @QueryParam("page") int offset,

                                                 @DefaultValue("10") @QueryParam("size") int limit,

                                                 @QueryParam("format") final String format,

                                                 @Context HttpServletRequest request)  {

        String fullQuery = builtEntity2EntityRelationQuery(RequestResponseHandler.Entity.PROJECT, "relprojectid", organizationid);

        return getResponseByEntity(fullQuery, RequestResponseHandler.Entity.PROJECT, offset, limit, format, request, false, null);

    }

    @GET

    @Path("/api/organizations/{organizationid}/projects/count")

    @Produces({MediaType.APPLICATION_JSON, MediaType.APPLICATION_XML})

    public Response fetchOrganizationProjectsCount(@PathParam("organizationid") String organizationid)  {

        String fullQuery = builtEntity2EntityRelationQuery(RequestResponseHandler.Entity.PROJECT, "relprojectid", organizationid);

        return getCount(fullQuery);

    }

    @GET

    @Path("/api/people")

    @Produces({MediaType.APPLICATION_JSON, MediaType.APPLICATION_XML})

    public Response fetchPeople(@QueryParam("q") List<String> keywords,

                                @QueryParam("op") final List<String> keywordOperators,

                                @DefaultValue("1") @QueryParam("page") final int offset,

                                @DefaultValue("10") @QueryParam("size") final int limit,

                                @QueryParam("refine") @DefaultValue("false") final boolean refine,

                                @QueryParam("fields") final List<String> fields,

                                @QueryParam("format") final String format,

                                @Context final HttpServletRequest request) {

        String fullQuery = builtFullQuery(keywords, keywordOperators, RequestResponseHandler.Entity.PERSON, request);

        return getResponseByEntity(fullQuery, RequestResponseHandler.Entity.PERSON, offset, limit, format, request, refine, fields);

    }

    @GET

    @Path("/api/people/count")

    @Produces({MediaType.APPLICATION_JSON, MediaType.APPLICATION_XML})

    public Response fetchPeopleCount(@QueryParam("q") String query){

        String fullQuery = builtQueryByEntity(query, RequestResponseHandler.Entity.PERSON);

        return getCount(fullQuery);

    }

    @GET

    @Path("/api/people/{personid}")

    @Produces({MediaType.APPLICATION_JSON, MediaType.APPLICATION_XML})

    public Response fetchPeople(@PathParam("personid") String personid) {

        return getResponseByEntityId(RequestResponseHandler.Entity.PERSON, personid);

    }

    @GET

    @Path("/api/people/{personid}/publications")

    @Produces({MediaType.APPLICATION_JSON, MediaType.APPLICATION_XML})

    public Response fetchPeoplePublications(@PathParam("personid") String personid,

                                            @DefaultValue("1") @QueryParam("page") final int offset,

                                            @DefaultValue("10") @QueryParam("size") final int limit,

                                            @QueryParam("format") final String format,

                                            @Context final HttpServletRequest request) {

        String fullQuery = builtEntity2EntityRelationQuery(RequestResponseHandler.Entity.PUBLICATION, "relpersonid", personid);

        return getResponseByEntity(fullQuery, RequestResponseHandler.Entity.PUBLICATION, offset, limit, format, request, false, null);

    }

    @GET

    @Path("/api/people/{personid}/publications/count")

    @Produces({MediaType.APPLICATION_JSON, MediaType.APPLICATION_XML})

    public Response fetchPeoplePublicationsCount(@PathParam("personid") String personid) {

        String fullQuery = builtEntity2EntityRelationQuery(RequestResponseHandler.Entity.PUBLICATION, "relpersonid", personid);

        return getCount(fullQuery);

    }

    @GET

    @Path("/api/people/{personid}/datasets")

    @Produces({MediaType.APPLICATION_JSON, MediaType.APPLICATION_XML})

    public Response fetchPeopleDatasets(@PathParam("personid") String personid,

                                        @DefaultValue("1") @QueryParam("page") final int offset,

                                        @DefaultValue("10") @QueryParam("size") final int limit,

                                        @QueryParam("format") final String format,

                                        @Context final HttpServletRequest request) {

        String fullQuery = builtEntity2EntityRelationQuery(RequestResponseHandler.Entity.DATASET, "relpersonid", personid);

        return getResponseByEntity(fullQuery, RequestResponseHandler.Entity.DATASET, offset, limit, format, request, false, null);

    }

    @GET

    @Path("/api/people/{personid}/datasets/count")

    @Produces({MediaType.APPLICATION_JSON, MediaType.APPLICATION_XML})

    public Response fetchPeopleDatasetsCount(@PathParam("personid") String personid) {

        String fullQuery = builtEntity2EntityRelationQuery(RequestResponseHandler.Entity.DATASET, "relpersonid", personid);

        return getCount(fullQuery);

    }

    private String enhanceQuery(List<String> keywords, List<String> keywordOperators, Map<String, String[]> operatorTypeValues, Map<String, String[]> parameterTypeValues, RequestResponseHandler.Entity entity) {

        StringBuilder queryBuilder = new StringBuilder();

        //There is always an entity

        enhanceQueryWithEntityType(queryBuilder, entity);

        enhanceQueryWithKeywords(queryBuilder, keywordOperators, keywords);

        Map<String, String> parameterIndexMap = entity.getParameterIndexMap();

        Map<String, String> parameterOperatorMap = entity.getParameterOperatorMap();

        enhanceQueryWithParameters(queryBuilder, operatorTypeValues, parameterTypeValues, parameterIndexMap, parameterOperatorMap);

        return queryBuilder.toString();

    }

*/

    @Deprecated

    private void enhanceQueryWithKeywords(StringBuilder queryBuilder, List<String> keywordOperators, List<String> keywords) {

        if (keywordOperators != null && !keywordOperators.isEmpty()) {

            if (keywords != null && !keywords.isEmpty()) {

                if (keywordOperators.size() != keywords.size()) {

                    throw new IllegalArgumentException("Keywords and Operators are not matched");

                }

            } else {

                throw new IllegalArgumentException("Keywords and Operators are not matched");

            }

        }

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

            queryBuilder.append(' ').append(keywordOperators.get(i)).append(' ').append('(').append(keywords.get(i)).append(")");

        }

    }

    private void enhanceQueryWithParameters(StringBuilder queryBuilder, Map<String, String[]> operators, Map<String, String[]> parameters, Map<String, String> parameterIndexMap, Map<String, String> parameterOperatorMap) {

        if (parameterIndexMap != null && !parameterIndexMap.isEmpty()) {

            if (parameterOperatorMap != null && !parameterOperatorMap.isEmpty()) {

                for(String operatorType:operators.keySet()) {

                    //enhance messages with >, < ?? or maybe move all checks in the beginning?

                    if (operators.get(operatorType).length != parameters.get(parameterOperatorMap.get(operatorType)).length ) {

                        throw new IllegalArgumentException("Parameters and Operators are not matched");

                    }

                    String parameterName = parameterOperatorMap.get(operatorType);

                    for(int i = 0; i < operators.get(operatorType).length; i++) {

                        String indexField = parameterIndexMap.get(parameterOperatorMap.get(operatorType));

                        /*logger.debug("operator " + operatorType);

                        logger.debug("operator map get" + parameterOperatorMap.get(operatorType));

                        logger.debug("index map" + parameterIndexMap.keySet());

                        logger.debug("index map values" + parameterIndexMap.values());

                        logger.debug("index field " + indexField);*/

                        if (indexField != null) {

/*                          logger.debug(indexField + " " + operators.get(operatorType)[i] + " " + parameters.get(parameterName)[i]);*/

                            queryBuilder.append(' ').append(operators.get(operatorType)[i]).append('(').append(indexField).append(" = ").append(parameters.get(parameterName)[i]).append(")");

                        } else { //TODO check if needed

                            logger.debug("and here!");

                            logger.debug(" " + operators.get(operatorType)[i] + " " + parameters.get(operatorType)[i]);

                            queryBuilder.append(" " + operators.get(operatorType)[i] + " " + parameters.get(operatorType)[i]);

                        }

                    }

                }

            } else  {

                throw new IllegalArgumentException("Keywords and Operators are not matched");

            }

        }

    }

    /*

    private boolean isFirstTerm(StringBuilder queryBuilder) {

        return queryBuilder.toString().trim().equals("");

    }*/

    public void builtEntityIdQuery(StringBuilder queryBuilder, RequestResponseHandler.Entity entity, String entityId){

        enhanceQueryWithEntityType(queryBuilder, entity);

        enhanceQueryWithEntityId(queryBuilder, entityId);

    }

    public String builtEntity2EntityRelationQuery(RequestResponseHandler.Entity entity, String relationfield, String entityId){

        StringBuilder queryBuilder = new StringBuilder();

        enhanceQueryWithEntityType(queryBuilder, entity);

        enhanceQueryWithEntity2EntityId(queryBuilder, relationfield, entityId);

        return queryBuilder.toString();

    }

    private void enhanceQueryWithEntity2EntityId(StringBuilder queryBuilder, String relationfield, String entityId) {

        CQLQueryGeneration.appendTerm(queryBuilder, CQLQueryGeneration.Operator.AND, " " + relationfield + " ", CQLQueryGeneration.Operator.EXACT, entityId);

    }

    public void enhanceQueryWithEntityType(StringBuilder queryBuilder, RequestResponseHandler.Entity entity) {

        queryBuilder.append(entity.getQueryPrefix());

    }

    public void enhanceQueryWithEntityId(StringBuilder queryBuilder, String entityId) {

        CQLQueryGeneration.appendTerm(queryBuilder, CQLQueryGeneration.Operator.AND, "objidentifier", CQLQueryGeneration.Operator.EXACT, entityId);

    }

    public String builtQueryByEntity(String query, RequestResponseHandler.Entity entity) {

        StringBuilder queryBuilder = new StringBuilder();

        queryBuilder.append(entity.getQueryPrefix());

        if (query != null && !query.trim().isEmpty()) {

            CQLQueryGeneration.appendSimpleTerm(queryBuilder, CQLQueryGeneration.Operator.AND, "(" + query + ")");

        }

        return queryBuilder.toString();

    }

    public void extractParameterNOperatorsValues(Map<String, String[]> parameterMap, Map<String, String[]> operatorTypeValues, Map<String, String[]> parameterTypeValues, RequestResponseHandler.Entity entity) {

        for (String parameter:parameterMap.keySet()) {

            Map<String, String> parameterIndexMap = entity.getParameterIndexMap();

            Map<String, String> parameterOperatorMap = entity.getParameterOperatorMap();

            if (parameterOperatorMap.get(parameter) != null) {

                operatorTypeValues.put(parameter, parameterMap.get(parameter));

            } else if (parameterIndexMap.get(parameter) != null) {

                parameterTypeValues.put(parameter, parameterMap.get(parameter));

            } else if (!parameter.equals("q") && !parameter.equals("op") && !parameter.equals("size") && !parameter.equals("page") && !parameter.equals("fields") && !parameter.equals("refine")){

                throw new IllegalArgumentException("The parameter " + parameter + " is not supported.");

            }

            if (parameterTypeValues.get(parameter) == null) {

                logger.debug("parameterTypeValues is null");

            } else {

                logger.debug("parameterTypeValues " + Arrays.asList(parameterTypeValues.get(parameter)));

            }

        }

        //TODO make checks per type????

        if (operatorTypeValues.size() != parameterTypeValues.size()) {

            throw new IllegalArgumentException("Parameters and Operators do not match.");

        }

    }

/*

    *//* For each parameter get the values and the operators *//*

    public void extractParameterOperatorsNValues(Map<String, String[]> requestParameterMap, Map<String, String[]> keywordOperatorValueMap, Map<String, String[]> keywordValuesMap,

                                                 Map<String, String[]> operatorValueMap, Map<String, String[]> parameterValuesMap, RequestResponseHandler.Entity entity) {

        for (String parameter:requestParameterMap.keySet()) {

            Map<String, String> parameterIndexMap = entity.getParameterIndexMap();

            Map<String, String> parameterOperatoMap = entity.getParameterOperatorMap();

            if (parameterOperatoMap.get(parameter) != null) {

                operatorValueMap.put(parameter, requestParameterMap.get(parameter));

            } else if (parameterIndexMap.get(parameter) != null) {

                parameterValuesMap.put(parameter, requestParameterMap.get(parameter));

            } else if (parameter.equals("q")) {

                keywordValuesMap.put("q", requestParameterMap.get("q"));

            } else if (parameter.equals("op")) {

                keywordOperatorValueMap.put("op", requestParameterMap.get("op"));

            } else if (!parameter.equals("size") && !parameter.equals("page") && !parameter.equals("fields") && !parameter.equals("refine")){

                throw new IllegalArgumentException("The parameter " + parameter + " is not supported.");

            }

            if (parameterValuesMap.get(parameter) == null) {

                logger.debug("parameterTypeValues is null");

            } else {

                logger.debug("parameterTypeValues " + Arrays.asList(parameterValuesMap.get(parameter)));

            }

        }

        if ((operatorValueMap.size() != parameterValuesMap.size()) || (keywordOperatorValueMap.size() != keywordValuesMap.size())) {

            throw new IllegalArgumentException("Operators do not match parameters.");

        }

    }*/

    private Response getCount(String query) {

        try {

            SearchResult searchResult = searchService.search(query, null, Locale.getDefault().toString(), 0, 0);

            return Response.status(Response.Status.OK).entity(ResponseFormatter.createCountMeta(query.replace("\"", "\\\""), searchResult.getTotal())).build();

        } catch (SearchServiceException sse) {

            return Response.status(Response.Status.INTERNAL_SERVER_ERROR).entity(ResponseFormatter.compose500Message("Fail to fetch count for query " + query.replace("\"", "\\\"") + ".", sse.getMessage())).build();

        }

    }

    /* TODO remove?

    private Response getCountByEntity2EntityRelation(String query, RequestResponseHandler.Entity entity, String relationfield, String entityId) {

        String fullQuery =  builtEntity2EntityRelationQuery(entity, relationfield, entityId);

        try {

            SearchResult searchResult = searchService.search(fullQuery, null, Locale.getDefault().toString(), 0, 0);

            return Response.status(Response.Status.OK).entity(ResponseFormatter.createCountMeta(fullQuery.replace("\"", "\\\""), searchResult.getTotal())).build();

        } catch (SearchServiceException sse) {

            return Response.status(Response.Status.INTERNAL_SERVER_ERROR).entity(ResponseFormatter.compose500Message("Fail to fetch count for query " + fullQuery.replace("\"", "\\\"") + ".", sse.getMessage())).build();

        }

    } */

    private Response getResponseByEntityId(RequestResponseHandler.Entity entity, String entityId) {

        try {

            StringBuilder queryBuilder = new StringBuilder();

            builtEntityIdQuery(queryBuilder, entity, entityId);

            String fullQuery = queryBuilder.toString();

            SearchResult searchResult = searchService.search(fullQuery, null, Locale.getDefault().toString(), 1, 1);

            if (searchResult.getSearchResults() == null || searchResult.getSearchResults().isEmpty() ||

                    searchResult.getSearchResults().size() == 0 || searchResult.getSearchResults().get(0) == null) {

                return Response.status(Response.Status.NOT_FOUND).entity(

                        ResponseFormatter.compose404Message("404 - " + entity +" with id "

                                + entityId + " not found.")).type(MediaType.APPLICATION_JSON).build();

            }

            return Response.status(Response.Status.OK).entity(ResponseFormatter.createEntityResponse(entity, XML.toJSONObject(searchResult.getSearchResults().get(0)).toString())).type(MediaType.APPLICATION_JSON).build();

        } catch (SearchServiceException sse) {

            logger.error("Fail to fetch "+ entity + " with id " + entityId, sse);

            return Response.status(Response.Status.INTERNAL_SERVER_ERROR).entity(ResponseFormatter.compose500Message("Fail to fetch " + entity + " with id " + entityId, sse.getMessage())).build();

        }

    }

    private Response getResponseByEntity(String fullQuery, RequestResponseHandler.Entity entity, int offset, int limit, String format, HttpServletRequest request, boolean refine, List<String> refineFields, List<String> fieldQueries) {

        try {

            SearchResult solrResults = searchService.newSearch(fullQuery, Locale.getDefault().toString(), refineFields, fieldQueries, offset, limit, format);

            return Response.status(Response.Status.OK).entity(ResponseFormatter.createEntitiesResponse(request, entity, fullQuery.replace("\"", "\\\""),

                    solrResults.getSearchResults().toString(), solrResults.getTotal()+"", offset+"", limit+"", refine, SolrResultsFormatter.jsonList2Json(solrResults.getBrowseResults()))).type(MediaType.APPLICATION_JSON).build();

        } catch (SearchServiceException sse) {

            logger.error("Fail to get " + entity.getPlural() , sse);

            return Response.status(Response.Status.INTERNAL_SERVER_ERROR).

                    entity(ResponseFormatter.compose500Message("Fail to fetch " + entity.getPlural(), sse.getMessage())).type(MediaType.APPLICATION_JSON).build();

        }

    }

    private void formatRefineResults(StringBuilder refineBuilder, SearchResult refineResults) {

        int i = 0;

        for (String json: refineResults.getBrowseResults()) {

            if (i == (refineResults.getBrowseResults().size() - 1)) {

                refineBuilder.append(json);

            } else {

                refineBuilder.append(json).append(",");

            }

            i++;

        }

    }

/*

    public static void main(String[] args) {

        String json = " {\"result\":{\"xmlns:oaf\":\"http://namespace.openaire.eu/oaf\",\"xmlns:xsi\":\"http://www.w3.o" +

                "rg/2001/XMLSchema-instance\",\"header\":{\"dri:dateOfCollection\":\"2016-05-20T03:34:07Z\",\"dri:dateOfTransformation\":\"\",\"counters\":{\"counter_dedup\":{\"value\":2},\"counter_doi\":{\"value\":2},\"counter_authorship\":{\"va" +

                "lue\":1},\"counter_authorship_inferred\":{\"value\":1}},\"dri:objIdentifier\":\"dedup_wf_001::0f5604702b32f59d9789573113279e69\"},\"metadata\":{\"oaf:entity\":{\"oaf:result\":{\"datainfo\":{\"provenanceaction\":{\"schemename\"" +

                ":\"dnet:provenanceActions\",\"classname\":\"sysimport:dedup\",\"schemeid\":\"dnet:provenanceActions\",\"classid\":\"sysimport:dedup\"},\"trust\":0.9,\"inferenceprovenance\":\"dedup-similarity-result\",\"deletedbyinference\":fal" +

                "se,\"inferred\":true},\"rels\":{\"rel\":{\"to\":{\"content\":\"dedup_wf_001::884d8c367553a8de98ec90ece1b1be4a\",\"scheme\":\"dnet:person_result_relations\",\"class\":\"hasAuthor\",\"type\":\"person\"},\"provenanceaction\":\"sysimpor" +

                "t:crosswalk:repository\",\"trust\":0.9,\"inferenceprovenance\":\"\",\"ranking\":1,\"inferred\":true,\"fullname\":\"Krafft, Alexander\"}},\"subject\":[{\"content\":\"Clinic for Obstetrics\",\"schemename\":\"dnet:result_subject\",\"c" +

                "lassname\":\"keyword\",\"schemeid\":\"dnet:result_subject\",\"classid\":\"keyword\"},{\"content\":\"610 Medicine & health\",\"schemename\":\"dnet:result_subject\",\"classname\":\"keyword\",\"schemeid\":\"dnet:result_subject\",\"class" +

                "id\":\"keyword\"},{\"content\":\"News\",\"schemename\":\"dnet:result_subject\",\"classname\":\"keyword\",\"schemeid\":\"dnet:result_subject\",\"classid\":\"keyword\"}],\"collectedfrom\":[{\"id\":\"opendoar____::0efe32849d230d7f53049d" +

                "dc4a4b0c60\",\"name\":\"Zurich Open Repository and Archive\"},{\"id\":\"opendoar____::8b6dd7db9af49e67306feb59a8bdc52c\",\"name\":\"Europe PubMed Central\"}],\"children\":{\"result\":[{\"title\":{\"content\":\"Iron supplementat" +

                "ion in pregnancy\",\"schemename\":\"dnet:dataCite_title\",\"classname\":\"main title\",\"schemeid\":\"dnet:dataCite_title\",\"classid\":\"main title\"},\"resulttype\":{\"schemename\":\"dnet:result_typologies\",\"classname\":\"publi" +

                "cation\",\"schemeid\":\"dnet:result_typologies\",\"classid\":\"publication\"},\"dateofacceptance\":\"1981-09-01\",\"objidentifier\":\"od_______908::f27f9e68f0b9f510ebf572ba295344e1\"},{\"title\":{\"content\":\"Iron supplementat" +

                "ion in pregnancy\",\"schemename\":\"dnet:dataCite_title\",\"classname\":\"main title\",\"schemeid\":\"dnet:dataCite_title\",\"classid\":\"main title\"},\"resulttype\":{\"schemename\":\"dnet:result_typologies\",\"classname\":\"publi" +

                "cation\",\"schemeid\":\"dnet:result_typologies\",\"classid\":\"publication\"},\"dateofacceptance\":\"2013-01-01\",\"publisher\":\"BMJ Publishing Group\",\"objidentifier\":\"od_______885::0f5604702b32f59d9789573113279e69\"}],\"i" +

                "nstance\":[{\"webresource\":{\"url\":\"http://europepmc.org/articles/PMC2306130\"},\"id\":\"opendoar____::8b6dd7db9af49e67306feb59a8bdc52c\",\"licence\":{\"schemename\":\"dnet:access_modes\",\"classname\":\"Open Access\",\"sche" +

                "meid\":\"dnet:access_modes\",\"classid\":\"OPEN\"},\"hostedby\":{\"id\":\"opendoar____::8b6dd7db9af49e67306feb59a8bdc52c\",\"name\":\"Europe PubMed Central\"},\"instancetype\":{\"schemename\":\"dnet:publication_resource\",\"class" +

                "name\":\"Article\",\"schemeid\":\"dnet:publication_resource\",\"classid\":\"0001\"}},{\"webresource\":{\"url\":\"http://www.zora.uzh.ch/87059/1/30_13_Krafft_2013bmj_f4399_full.pdf\"},\"id\":\"opendoar____::0efe32849d230d7f530" +

                "49ddc4a4b0c60\",\"licence\":{\"schemename\":\"dnet:access_modes\",\"classname\":\"Open Access\",\"schemeid\":\"dnet:access_modes\",\"classid\":\"OPEN\"},\"hostedby\":{\"id\":\"opendoar____::0efe32849d230d7f53049ddc4a4b0c60\",\"name" +

                "\":\"Zurich Open Repository and Archive\"},\"instancetype\":{\"schemename\":\"dnet:publication_resource\",\"classname\":\"Article\",\"schemeid\":\"dnet:publication_resource\",\"classid\":\"0001\"}}]},\"pid\":[{\"content\":\"10.5167" +

                "/uzh-87059\",\"schemename\":\"dnet:pid_types\",\"classname\":\"doi\",\"schemeid\":\"dnet:pid_types\",\"classid\":\"doi\"},{\"content\":\"PMC2306130\",\"schemename\":\"dnet:pid_types\",\"classname\":\"pmc\",\"schemeid\":\"dnet:pid_types\"," +

                "\"classid\":\"pmc\"},{\"content\":\"10.1136/bmj.f4399\",\"schemename\":\"dnet:pid_types\",\"classname\":\"doi\",\"schemeid\":\"dnet:pid_types\",\"classid\":\"doi\"}],\"resourcetype\":{\"schemename\":\"\",\"classname\":\"\",\"schemeid\":\"\",\"c" +

                "lassid\":\"\"},\"format\":\"\",\"dateofacceptance\":\"2013-01-01\",\"embargoenddate\":\"\",\"version\":\"\",\"size\":\"\",\"publisher\":\"BMJ Publishing Group\",\"country\":{\"schemename\":\"\",\"classname\":\"\",\"schemeid\":\"\",\"classid\":\"\"},\"" +

                "metadataversionnumber\":\"\",\"title\":{\"content\":\"Iron supplementation in pregnancy\",\"schemename\":\"dnet:dataCite_title\",\"classname\":\"main title\",\"schemeid\":\"dnet:dataCite_title\",\"classid\":\"main title\"},\"result" +

                "type\":{\"schemename\":\"dnet:result_typologies\",\"classname\":\"publication\",\"schemeid\":\"dnet:result_typologies\",\"classid\":\"publication\"},\"source\":\"Krafft, Alexander (2013). Iron supplementation in pregnancy. Br" +

                "itish Medical Journal, 347:f4399.\",\"contributor\":\"\",\"description\":\"\",\"originalId\":[\"oai:europepmc.org:1052305\",\"oai:www.zora.uzh.ch:87059\"],\"lastmetadataupdate\":\"\",\"relevantdate\":{\"schemename\":\"\",\"classnam" +

                "e\":\"\",\"schemeid\":\"\",\"classid\":\"\"},\"device\":\"\",\"bestlicense\":{\"schemename\":\"dnet:access_modes\",\"classname\":\"Open Access\",\"schemeid\":\"dnet:access_modes\",\"classid\":\"OPEN\"},\"language\":{\"schemename\":\"dnet:langu" +

                "ages\",\"classname\":\"English\",\"schemeid\":\"dnet:languages\",\"classid\":\"eng\"},\"storagedate\":\"\",\"fulltext\":\"\"},\"xsi:schemaLocation\":\"http://namespace.openaire.eu/oaf https://www.openaire.eu/schema/0.2/oaf-0.2.xs" +

                "d\"}},\"xmlns:dri\":\"http://www.driver-repository.eu/namespace/dri\"}}";

        String s = "{\"result\":{\"xmlns:oaf\":\"http://namespace.openaire.eu/oaf\",\"xmlns:xsi\":\"http://www.w3.org/2001" +

                "/XMLSchema-instance\",\"header\":{\"dri:dateOfCollection\":\"2014-04-10T13:35:33Z\",\"dri:dateOfTransformation\":\"\",\"counters\":{\"counter_dedup\":{\"value\":2},\"counter_authorship\":{\"value\":1},\"counter_authorship_infer" +

                "red\":{\"value\":1}},\"dri:objIdentifier\":\"dedup_wf_001::4d934888dee33a62dece6fa36192c710\"},\"metadata\":{\"oaf:entity\":{\"oaf:result\":{\"datainfo\":{\"provenanceaction\":{\"schemename\":\"dnet:provenanceActions\",\"classn" +

                "ame\":\"sysimport:dedup\",\"schemeid\":\"dnet:provenanceActions\",\"classid\":\"sysimport:dedup\"},\"trust\":0.9,\"inferenceprovenance\":\"dedup-similarity-result\",\"deletedbyinference\":false,\"inferred\":true},\"rels\":{\"rel\"" +

                ":{\"to\":{\"content\":\"od______1232::d4f9cea02c7762da24cd71ea0b9791de\",\"scheme\":\"dnet:person_result_relations\",\"class\":\"hasAuthor\",\"type\":\"person\"},\"provenanceaction\":\"sysimport:crosswalk:repository\",\"trust\":0" +

                ".9,\"inferenceprovenance\":\"\",\"ranking\":1,\"inferred\":true,\"fullname\":\"Anonymous\"}},\"subject\":{\"content\":\"Señoríos-Legislación\",\"schemename\":\"dnet:result_subject\",\"classname\":\"keyword\",\"schemeid\":\"dnet:result" +

                "_subject\",\"classid\":\"keyword\"},\"collectedfrom\":[{\"id\":\"opendoar____::e53a0a2978c28872a4505bdb51db06dc\",\"name\":\"Biblioteca Virtual del Patrimonio Bibliográfico (Virtual Library of Bibliographical Heritage)\"" +

                "},{\"id\":\"opendoar____::7aee26c309def8c5a2a076eb250b8f36\",\"name\":\"Biblioteca Virtual de Aragón\"}],\"children\":{\"result\":[{\"title\":{\"content\":\"Discurso sobre los señoríos : necesidad y justicia del decreto de" +

                " Cortes de 6 de Agosto de 1811 y ventaja que debe causar a la Nación\",\"schemename\":\"dnet:dataCite_title\",\"classname\":\"main title\",\"schemeid\":\"dnet:dataCite_title\",\"classid\":\"main title\"},\"resulttype\":{\"sch" +

                "emename\":\"dnet:result_typologies\",\"classname\":\"publication\",\"schemeid\":\"dnet:result_typologies\",\"classid\":\"publication\"},\"dateofacceptance\":\"1820-01-01\",\"objidentifier\":\"od______2719::bc2326a31763719dc5ebd" +

                "38f16a25404\"},{\"title\":{\"content\":\"Discurso sobre los señoríos : necesidad y justicia del decreto de Cortes de 6 de Agosto de 1811 y ventaja que debe causar a la Nación\",\"schemename\":\"dnet:dataCite_title\"," +

                "\"classname\":\"main title\",\"schemeid\":\"dnet:dataCite_title\",\"classid\":\"main title\"},\"resulttype\":{\"schemename\":\"dnet:result_typologies\",\"classname\":\"publication\",\"schemeid\":\"dnet:result_typologies\",\"classid\"" +

                ":\"publication\"},\"dateofacceptance\":\"1820-01-01\",\"objidentifier\":\"od______1232::4d934888dee33a62dece6fa36192c710\"}],\"instance\":[{\"webresource\":[{\"url\":\"http://bvpb.mcu.es/es/consulta/registro.cmd?id=403864\"" +

                "},{\"url\":\"http://bvpb.mcu.es/es/catalogo_imagenes/grupo.cmd?path=2755\"}],\"id\":\"opendoar____::e53a0a2978c28872a4505bdb51db06dc\",\"licence\":{\"schemename\":\"dnet:access_modes\",\"classname\":\"Open Access\",\"schemei" +

                "d\":\"dnet:access_modes\",\"classid\":\"OPEN\"},\"hostedby\":{\"id\":\"opendoar____::e53a0a2978c28872a4505bdb51db06dc\",\"name\":\"Biblioteca Virtual del Patrimonio Bibliográfico (Virtual Library of Bibliographical Herita" +

                "ge)\"},\"instancetype\":{\"schemename\":\"dnet:publication_resource\",\"classname\":\"Book\",\"schemeid\":\"dnet:publication_resource\",\"classid\":\"0002\"}},{\"webresource\":{\"url\":\"http://bibliotecavirtual.aragon.es/bva/i18" +

                "n/consulta/registro.cmd?id=2878\"},\"id\":\"opendoar____::7aee26c309def8c5a2a076eb250b8f36\",\"licence\":{\"schemename\":\"dnet:access_modes\",\"classname\":\"Open Access\",\"schemeid\":\"dnet:access_modes\",\"classid\":\"OPEN\"" +

                "},\"hostedby\":{\"id\":\"opendoar____::7aee26c309def8c5a2a076eb250b8f36\",\"name\":\"Biblioteca Virtual de Aragón\"},\"instancetype\":{\"schemename\":\"dnet:publication_resource\",\"classname\":\"Book\",\"schemeid\":\"dnet:publi" +

                "cation_resource\",\"classid\":\"0002\"}}]},\"pid\":{\"schemename\":\"\",\"classname\":\"\",\"schemeid\":\"\",\"classid\":\"\"},\"resourcetype\":{\"schemename\":\"\",\"classname\":\"\",\"schemeid\":\"\",\"classid\":\"\"},\"format\":\"\",\"dateofaccepta" +

                "nce\":\"1820-01-01\",\"embargoenddate\":\"\",\"version\":\"\",\"size\":\"\",\"country\":{\"schemename\":\"\",\"classname\":\"\",\"schemeid\":\"\",\"classid\":\"\"},\"publisher\":\"\",\"metadataversionnumber\":\"\",\"title\":{\"content\":\"Discurso sob" +

                "re los señoríos : necesidad y justicia del decreto de Cortes de 6 de Agosto de 1811 y ventaja que debe causar a la Nación\",\"schemename\":\"dnet:dataCite_title\",\"classname\":\"main title\",\"schemeid\":\"dnet:dataC" +

                "ite_title\",\"classid\":\"main title\"},\"resulttype\":{\"schemename\":\"dnet:result_typologies\",\"classname\":\"publication\",\"schemeid\":\"dnet:result_typologies\",\"classid\":\"publication\"},\"source\":\"\",\"contributor\":\"Impr" +

                "enta de Heras, imp.\",\"description\":\"\",\"originalId\":[\"oai:bvpb.mcu.es:403864\",\"oai:bibliotecavirtual.aragon.es:2878\"],\"lastmetadataupdate\":\"\",\"relevantdate\":{\"schemename\":\"\",\"classname\":\"\",\"schemeid\":\"\",\"cl" +

                "assid\":\"\"},\"device\":\"\",\"bestlicense\":{\"schemename\":\"dnet:access_modes\",\"classname\":\"Open Access\",\"schemeid\":\"dnet:access_modes\",\"classid\":\"OPEN\"},\"language\":{\"schemename\":\"dnet:languages\",\"classname\":\"Span" +

                "ish\",\"schemeid\":\"dnet:languages\",\"classid\":\"esl/spa\"},\"storagedate\":\"\",\"fulltext\":\"\"},\"xsi:schemaLocation\":\"http://namespace.openaire.eu/oaf https://www.openaire.eu/schema/0.2/oaf-0.2.xsd\"}},\"xmlns:dri\":\"h" +

                "ttp://www.driver-repository.eu/namespace/dri\"}}\n";

        JSONObject finalOject = new JSONObject();

        finalOject.put("dri:objIdentifier", new JSONObject(json).getJSONObject("result").getJSONObject("header").getString("dri:objIdentifier"));

        finalOject.put("content", new JSONObject(new JSONObject(json).getJSONObject("result").getJSONObject("metadata").getJSONObject("oaf:entity").getJSONObject("oaf:result"),

                new String[]{"title", "description", "language", "bestlicense", "pid", "rels"}));

        System.out.println(finalOject);

        JSONObject jsonObject = new JSONObject(s).getJSONObject("result").getJSONObject("metadata").getJSONObject("oaf:entity").getJSONObject("oaf:result");

        System.out.println("title --> " + jsonObject.getJSONObject("title").getString("content"));

        System.out.println("pid --> " + jsonObject.getJSONArray("pid"));

        JSONObject newJsonObject1 = new JSONObject(jsonObject, new String[]{"title", "description", "language", "bestlicense", "pid", "rels"});

    }

*/

    public static void main(String[] args) throws IOException, CQLParseException {

        CqlTranslator translator = new CqlTranslatorImpl();

        System.out.println(translator.toLucene("relfundinglevel0_id = ec__________::EC::FP7"));

    }

}