D-Net

package eu.dnetlib.oai.parser;

import java.io.IOException;

import java.time.LocalDateTime;

import java.time.format.DateTimeFormatter;

import java.util.List;

import org.apache.commons.lang3.StringUtils;

import org.apache.commons.logging.Log;

import org.apache.commons.logging.LogFactory;

import org.bson.conversions.Bson;

import org.bson.types.ObjectId;

import org.z3950.zing.cql.CQLAndNode;

import org.z3950.zing.cql.CQLBooleanNode;

import org.z3950.zing.cql.CQLNode;

import org.z3950.zing.cql.CQLNotNode;

import org.z3950.zing.cql.CQLOrNode;

import org.z3950.zing.cql.CQLParseException;

import org.z3950.zing.cql.CQLParser;

import org.z3950.zing.cql.CQLTermNode;

import com.google.common.collect.Lists;

import com.mongodb.BasicDBObject;

import com.mongodb.BasicDBObjectBuilder;

import eu.dnetlib.index.parse.Relation;

import eu.dnetlib.index.parse.Relations;

import eu.dnetlib.oai.conf.OAIConfigurationReader;

import eu.dnetlib.rmi.provision.OaiPublisherRuntimeException;

/**

 * Instances of this class parse query string into mongo DBObject query.

 *

 * @author alessia

 */

public class MongoQueryParser {

	private static final Log log = LogFactory.getLog(MongoQueryParser.class); // NOPMD by marko on 11/24/08 5:02 PM

	/**

	 * Parses the given query string into a mongo DBObject.

	 *

	 * @param query

	 *            String to parse

	 * @return DBObject corresponding to the query string

	 */

	public Bson parse(final String query) {

		log.debug("PARSING: " + query);

		if (StringUtils.isBlank(query)) { return new BasicDBObject(); }

		final Bson parsed = toMongo(query);

		log.debug(parsed);

		return parsed;

	}

	private Bson toMongo(final String query) {

		final CQLParser parser = new CQLParser();

		CQLNode root;

		try {

			root = parser.parse(query);

			return this.toMongo(root);

		} catch (final CQLParseException e) {

			throw new OaiPublisherRuntimeException(e);

		} catch (final IOException e) {

			throw new OaiPublisherRuntimeException(e);

		}

	}

	private Bson toMongo(final CQLNode node) {

		if (node instanceof CQLTermNode) { return doTranslate((CQLTermNode) node); }

		if (node instanceof CQLBooleanNode) { return doTranslate((CQLBooleanNode) node); }

		throw new RuntimeException("error choice for CQLNode " + node.getClass());

	}

	private Bson doTranslate(final CQLTermNode termNode) {

		if (termNode.getTerm().equals("*")) { return new BasicDBObject(); }

		final String relation = termNode.getRelation().getBase();

		final Relation rel = Relations.get(relation);

		return this.handleRelationNode(rel, termNode);

	}

	private Bson handleRelationNode(final Relation rel, final CQLTermNode termNode) {

		final BasicDBObject mongoQueryObject = new BasicDBObject();

		final String term = termNode.getTerm();

		final String indexName = termNode.getIndex();

		Object termObj = term;

		if (indexName.equals("_id")) {

			termObj = new ObjectId(term);

		} else {

			if (indexName.equals(OAIConfigurationReader.DATESTAMP_FIELD) || indexName.equals(OAIConfigurationReader.LAST_COLLECTION_DATE_FIELD)) {

				// termObj = this.parseDate(term);

				final OAIDate termDate = this.parseDate(term);

				return handleDateRelationNode(indexName, rel, termDate);

			}

		}

		switch (rel) {

		case EQUAL:

		case EXACT:

			mongoQueryObject.put(indexName, termObj);

			break;

		case NOT:

			mongoQueryObject.put(indexName, new BasicDBObject("$ne", termObj));

			break;

		case GT:

			mongoQueryObject.put(indexName, new BasicDBObject("$gt", termObj));

			break;

		case GTE:

			mongoQueryObject.put(indexName, new BasicDBObject("$gte", termObj));

			break;

		case LT:

			mongoQueryObject.put(indexName, new BasicDBObject("$lt", termObj));

			break;

		case LTE:

			mongoQueryObject.put(indexName, new BasicDBObject("$lte", termObj));

			break;

		default:

			throw new OaiPublisherRuntimeException("Can't parse query: relation " + rel + " not supported!");

		}

		return mongoQueryObject;

	}

	/**

	 * The construction of the query changes based on the granularity of the date to handle.

	 * <p>

	 * If the date has yyyy-MM-ddThh:mm:ssZ granularity we have to create a range query because in mongo we have milliseconds, hence an

	 * exact match will return nothing.

	 * </p>

	 * <p>

	 * If the date has yyyy-MM-dd granularity then we have to trick the query. If we are interested in the date 2013-10-28, the date has

	 * been converted into 2013-10-28T00:00:00Z : if we ask for datestamp = 2013-10-28T00:00:00Z, we'll get nothing: we have to ask for

	 * records whose day is the one specified by the date.

	 * <p>

	 * </p>

	 *

	 * @param indexName

	 * @param rel

	 * @param date

	 * @return

	 */

	private Bson handleDateRelationNode(final String indexName, final Relation rel, final OAIDate date) {

		final BasicDBObject mongoQueryObject = new BasicDBObject();

		LocalDateTime fromDate = date.date;

		switch (rel) {

		case EQUAL:

		case EXACT:

			if (date.onlyDate) {

				final LocalDateTime endDate = date.date.plusDays(1);

				mongoQueryObject.put(indexName, BasicDBObjectBuilder.start("$gte", fromDate.toLocalDate()).append("$lt", endDate.toLocalDate()).get());

			} else {

				final LocalDateTime endDate = date.date.plusSeconds(1);

				mongoQueryObject.put(indexName, BasicDBObjectBuilder.start("$gte", fromDate.toLocalDate()).append("$lt", endDate.toLocalDate()).get());

			}

			break;

		case NOT:

			mongoQueryObject.put(indexName, new BasicDBObject("$ne", fromDate.toLocalDate()));

			break;

		case GT:

			mongoQueryObject.put(indexName, new BasicDBObject("$gt", fromDate.toLocalDate()));

			break;

		case GTE:

			mongoQueryObject.put(indexName, new BasicDBObject("$gte", fromDate.toLocalDate()));

			break;

		case LT:

			mongoQueryObject.put(indexName, new BasicDBObject("$lt", fromDate.toLocalDate()));

			break;

		case LTE:

			/*

			 * If the request is date <= YYYY-MM-DD then we need to change the date. The parseDate returned YYYY-MM-DDT00:00:00Z, but we

			 * need YYYY-MM-DDT23:59:59Z. To simplify we can add one day and perform < instead of <=.

			 */

			if (date.onlyDate) {

				fromDate = date.date.plusDays(1);

				mongoQueryObject.put(indexName, new BasicDBObject("$lt", fromDate.toLocalDate()));

			} else {

				mongoQueryObject.put(indexName, new BasicDBObject("$lte", fromDate.toLocalDate()));

			}

			break;

		default:

			throw new OaiPublisherRuntimeException("Can't parse query: relation " + rel + " not supported!");

		}

		return mongoQueryObject;

	}

	private Bson doTranslate(final CQLBooleanNode node) {

		if (node instanceof CQLAndNode) { return getBooleanQuery("$and", node); }

		if (node instanceof CQLOrNode) { return getBooleanQuery("$or", node); }

		if (node instanceof CQLNotNode) { return getNotQuery((CQLNotNode) node); }

		throw new RuntimeException("error choice for CQLBooleanNode " + node.getClass());

	}

	private Bson getBooleanQuery(final String mongoOperator, final CQLBooleanNode node) {

		final Bson left = this.toMongo(node.left);

		final Bson right = this.toMongo(node.right);

		final BasicDBObject opQuery = new BasicDBObject();

		final List<Bson> termList = Lists.newArrayList(left, right);

		opQuery.put(mongoOperator, termList);

		return opQuery;

	}

	private Bson getNotQuery(final CQLNotNode node) {

		final Bson left = this.toMongo(node.left);

		final Bson right = this.toMongo(node.right);

		final Bson notRight = new BasicDBObject("$not", right);

		final BasicDBObject andQuery = new BasicDBObject();

		final List<Bson> termList = Lists.newArrayList(left, notRight);

		andQuery.put("$and", termList);

		return andQuery;

	}

	private OAIDate parseDate(final String date) {

		final DateTimeFormatter dateNoTimeFormatter = DateTimeFormatter.ofPattern("yyyy-MM-dd");

		final DateTimeFormatter iso8601NoMsTimeFormatter = DateTimeFormatter.ofPattern("yyyy-MM-dd'T'HH:mm:ssZ");

		final DateTimeFormatter iso8601Formatter = DateTimeFormatter.ofPattern("yyyy-MM-dd'T'HH:mm:ssZ");

		OAIDate res = null;

		try {

			log.debug("Using default " + iso8601Formatter.getClass());

			final LocalDateTime dt = LocalDateTime.parse(date, iso8601Formatter);

			res = new OAIDate(dt, false);

		} catch (final Exception e) {

			try {

				log.debug("Switching to ISO with no millisecond date formatter: yyyy-MM-dd'T'HH:mm:ssZ");

				final LocalDateTime dt = LocalDateTime.parse(date, iso8601NoMsTimeFormatter);

				res = new OAIDate(dt, false);

			} catch (final Exception ex) {

				log.debug("Switching to simple date formatter: yyyy-MM-dd");

				final LocalDateTime dt = LocalDateTime.parse(date, dateNoTimeFormatter);

				res = new OAIDate(dt, true);

			}

		}

		return res;

	}

	class OAIDate {

		LocalDateTime date;

		boolean onlyDate;

		OAIDate(final LocalDateTime date, final boolean onlyDate) {

			this.date = date;

			this.onlyDate = onlyDate;

		}

	}

}