D-Net

package eu.dnetlib.msro.logging;

import java.time.LocalDateTime;

import java.time.ZoneId;

import java.util.HashMap;

import java.util.Iterator;

import java.util.Map;

import java.util.Map.Entry;

import java.util.stream.Collectors;

import org.apache.commons.lang3.StringUtils;

import org.apache.commons.logging.Log;

import org.apache.commons.logging.LogFactory;

import org.bson.Document;

import org.bson.conversions.Bson;

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

import com.mongodb.BasicDBObject;

import com.mongodb.BasicDBObjectBuilder;

import com.mongodb.DBObject;

import com.mongodb.client.MongoCollection;

import com.mongodb.client.MongoCursor;

import com.mongodb.client.MongoDatabase;

import com.mongodb.client.model.Filters;

public class DnetLoggerMongoDao implements DnetLoggerDao {

	private static final Log log = LogFactory.getLog(DnetLoggerMongoDao.class);

	private MongoDatabase db;

	@Override

	public void init(final String collection) {

		final MongoCollection<Document> coll = db.getCollection(collection);

		if (coll == null) {

			log.info(String.format("creating collection %s", collection));

			db.createCollection(collection);

		}

	}

	@Override

	public void configureIndex(final String collection, final Map<String, IndexConf> conf) {

		final MongoCollection<DBObject> coll = db.getCollection(collection, DBObject.class);

		coll.dropIndexes();

		for (final String key : conf.keySet()) {

			coll.createIndex(new BasicDBObject(key, 1));

		}

	}

	@Override

	public void writeLog(final String collection, final Map<String, Object> map) {

		final MongoCollection<DBObject> coll = db.getCollection(collection, DBObject.class);

		final DBObject obj = BasicDBObjectBuilder.start(replaceKeyNames(map)).get();

		coll.insertOne(obj);

	}

	private Map<String, Object> replaceKeyNames(final Map<String, Object> inputMap) {

		final Map<String, Object> outMap = new HashMap<>();

		if (inputMap != null) {

			for (final Entry<String, Object> e : inputMap.entrySet()) {

				final String k = e.getKey();

				if (StringUtils.isNotBlank(k)) {

					final Object v = e.getValue();

					outMap.put(k.replaceAll("\\.", "_"), v != null ? v : "null");

				}

			}

		}

		return outMap;

	}

	@Override

	public Map<String, String> findOne(final String collection, final String key, final String value) {

		final MongoCollection<DBObject> coll = db.getCollection(collection, DBObject.class);

		final DBObject obj = coll.find(Filters.eq(key, value)).sort(new BasicDBObject(LogMessage.LOG_DATE_FIELD, -1)).first();

		return dbObject2Map(obj);

	}

	@Override

	public Map<String, String> findOne(final String collection, final Map<String, Object> criteria) {

		final MongoCollection<DBObject> coll = db.getCollection(collection, DBObject.class);

		final DBObject obj = coll.find(new BasicDBObject(criteria)).sort(new BasicDBObject(LogMessage.LOG_DATE_FIELD, -1)).first();

		return dbObject2Map(obj);

	}

	@Override

	public Iterator<Map<String, String>> obtainLogIterator(final String collection) {

		final MongoCollection<DBObject> coll = db.getCollection(collection, DBObject.class);

		return iter(collection, coll.find().iterator());

	}

	@Override

	public Iterator<Map<String, String>> find(final String collection, final String key, final String value) {

		final MongoCollection<DBObject> coll = db.getCollection(collection, DBObject.class);

		return iter(collection, coll.find(Filters.eq(key, value)).iterator());

	}

	@Override

	public Iterator<Map<String, String>> find(final String collection, final Map<String, Object> criteria) {

		final MongoCollection<DBObject> coll = db.getCollection(collection, DBObject.class);

		return iter(collection, coll.find(new BasicDBObject(criteria)).iterator());

	}

	@Override

	public Iterator<Map<String, String>> findByDateRange(final String collection, final LocalDateTime startDate, final LocalDateTime endDate) {

		final MongoCollection<DBObject> coll = db.getCollection(collection, DBObject.class);

		final Bson dateQuery = dateRangeQuery(startDate, endDate);

		// System.out.println(mongoQueryObject);

		return iter(collection, coll.find(dateQuery).iterator());

	}

	@Override

	public Iterator<Map<String, String>> findByDateRange(final String collection,

			final LocalDateTime startDate,

			final LocalDateTime endDate,

			final String key,

			final String value) {

		final MongoCollection<DBObject> coll = db.getCollection(collection, DBObject.class);

		final Bson dateQuery = dateRangeQuery(startDate, endDate);

		final BasicDBObject customQuery = new BasicDBObject(key, value);

		return iter(collection, coll.find(Filters.and(dateQuery, customQuery)).iterator());

	}

	@Override

	public Iterator<Map<String, String>> findByDateRange(final String collection,

			final LocalDateTime startDate,

			final LocalDateTime endDate,

			final Map<String, Object> criteria) {

		final MongoCollection<DBObject> coll = db.getCollection(collection, DBObject.class);

		final Bson dateQuery = dateRangeQuery(startDate, endDate);

		final BasicDBObject customQuery = new BasicDBObject(criteria);

		return iter(collection, coll.find(Filters.and(dateQuery, customQuery)).iterator());

	}

	private Bson dateRangeQuery(final LocalDateTime startDate, final LocalDateTime endDate) {

		final long start = startDate.atZone(ZoneId.systemDefault()).toInstant().toEpochMilli();

		final long end = endDate.atZone(ZoneId.systemDefault()).toInstant().toEpochMilli();

		final Bson dateFilter =

				Filters.and(Filters.gte(LogMessage.LOG_DATE_FIELD, start), Filters.lt(LogMessage.LOG_DATE_FIELD, end));

		log.debug("Date filter created: " + dateFilter);

		// return new BasicDBObject(LogMessage.LOG_DATE_FIELD, BasicDBObjectBuilder.start("$gte", startDate.getTime()).append("$lt",

		// endDate.getTime()).get());

		return dateFilter;

	}

	private Iterator<Map<String, String>> iter(final String collection, final MongoCursor<DBObject> cursor) {

		return new Iterator<Map<String, String>>() {

			@Override

			public boolean hasNext() {

				return cursor.hasNext();

			}

			@Override

			public Map<String, String> next() {

				return dbObject2Map(cursor.next());

			}

			@Override

			public void remove() {

				throw new RuntimeException("NOT IMPLEMENTED");

			}

		};

	}

	public MongoDatabase getDb() {

		return db;

	}

	@Required

	public void setDb(final MongoDatabase db) {

		this.db = db;

	}

	private Map<String, String> dbObject2Map(final DBObject obj) {

		return obj != null ? obj.keySet()

				.stream()

				.filter(k -> !k.startsWith("_"))

				.collect(Collectors.toMap(k -> k, k -> "" + obj.get(k))) : new HashMap<>();

	}

}