D-Net

package eu.dnetlib.enabling.datasources;

import java.io.StringReader;

import java.util.Collections;

import java.util.Date;

import java.util.HashMap;

import java.util.List;

import java.util.Map;

import java.util.Map.Entry;

import org.apache.commons.lang.StringEscapeUtils;

import org.apache.commons.lang.StringUtils;

import org.apache.commons.lang.math.NumberUtils;

import org.apache.commons.logging.Log;

import org.apache.commons.logging.LogFactory;

import org.dom4j.Document;

import org.dom4j.Node;

import org.dom4j.io.SAXReader;

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

import com.google.common.base.Function;

import com.google.common.collect.Iterables;

import com.google.common.collect.Lists;

import com.google.common.collect.Maps;

import eu.dnetlib.enabling.datasources.common.Api;

import eu.dnetlib.enabling.datasources.common.BrowseTerm;

import eu.dnetlib.enabling.datasources.common.Datasource;

import eu.dnetlib.enabling.datasources.common.DatasourceManager;

import eu.dnetlib.enabling.datasources.common.DatasourceManagerException;

public class LocalOpenaireDatasourceManager implements DatasourceManager<Datasource<?, ?>, Api> {

	private DatasourceManagerClients datasourceManagerClients;

	private List<DbBrowsableField> browsableFields;

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

	@Override

	public void saveDs(final Datasource<?, ?> ds) throws DatasourceManagerException {

		if (StringUtils.isBlank(ds.getAggregator())) {

			ds.setAggregator("OPENAIRE");

		}

		final Map<String, Object> params = DatasourceFunctions.asMapOfSqlValues(ds);

		if ((ds.getOrganizations() != null) && !ds.getOrganizations().isEmpty()) {

			params.put("hasOrganization", 1);

		}

		datasourceManagerClients.updateSQL(ds.getId(), "addDatasource.sql.st", params, false, true);

	}

	@Override

	public void deleteDs(final String dsId) throws DatasourceManagerException {

		final Map<String, Object> params = Maps.newHashMap();

		params.put("dsId", DatasourceFunctions.asSqlValue(dsId));

		datasourceManagerClients.updateSQL(dsId, "deleteDatasource.sql.st", params, true, true);

	}

	@Override

	public Datasource<?, ?> getDs(final String dsId) throws DatasourceManagerException {

		final List<Datasource<?, ?>> list = datasourceManagerClients.getDatasourcesByCondition("ds.id = " + DatasourceFunctions.asSqlValue(dsId));

		if (list.size() != 1) { throw new DatasourceManagerException("Datasource not found, id=" + dsId); }

		return list.get(0);

	}

	@Override

	public void updateActivationStatus(final String dsId, final String ifaceId, final boolean active) throws DatasourceManagerException {

		final Map<String, Object> params = Maps.newHashMap();

		params.put("active", DatasourceFunctions.asSqlValue(active));

		params.put("ifaceId", DatasourceFunctions.asSqlValue(ifaceId));

		params.put("dsId", DatasourceFunctions.asSqlValue(dsId));

		datasourceManagerClients.updateSQL(dsId, "updateActivationStatus.sql.st", params, false, true);

	}

	@Override

	public void updateCompliance(final String dsId, final String ifaceId, final String level) throws DatasourceManagerException {

		final Map<String, Object> params = Maps.newHashMap();

		params.put("level", DatasourceFunctions.asSqlValue(level));

		params.put("ifaceId", DatasourceFunctions.asSqlValue(ifaceId));

		params.put("dsId", DatasourceFunctions.asSqlValue(dsId));

		datasourceManagerClients.updateSQL(dsId, "updateLevelOfCompliance.sql.st", params, false, true);

	}

	@Override

	public void updateBaseUrl(final String dsId, final String ifaceId, final String baseUrl) throws DatasourceManagerException {

		updateAccessParam(dsId, ifaceId, DatasourceParams.baseUrl.toString(), baseUrl);

	}

	@Override

	public void addApi(final Api iface) throws DatasourceManagerException {

		final Map<String, Object> params = Maps.newHashMap();

		params.put("datasource", DatasourceFunctions.asSqlValue(iface.getDatasource()));

		params.put("id", DatasourceFunctions.asSqlValue(iface.getId()));

		params.put("typology", DatasourceFunctions.asSqlValue(iface.getTypology()));

		params.put("protocol", DatasourceFunctions.asSqlValue(iface.getAccessProtocol()));

		params.put("baseUrl", DatasourceFunctions.asSqlValue(iface.getBaseUrl()));

		params.put("description", DatasourceFunctions.asSqlValue(iface.getContentDescription()));

		params.put("compliance", DatasourceFunctions.asSqlValue(iface.getCompliance()));

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

		if (iface.getAccessParams() != null) {

			for (final Entry<String, String> e : iface.getAccessParams().entrySet()) {

				accessParams.put(DatasourceFunctions.asSqlValue(e.getKey()), DatasourceFunctions.asSqlValue(e.getValue()));

			}

		}

		params.put("accessParams", accessParams);

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

		if (iface.getExtraFields() != null) {

			for (final Entry<String, String> e : iface.getExtraFields().entrySet()) {

				extraFields.put(DatasourceFunctions.asSqlValue(e.getKey()), DatasourceFunctions.asSqlValue(e.getValue()));

			}

		}

		params.put("extraFields", extraFields);

		datasourceManagerClients.updateSQL(dsId, "insertInterface.sql.st", params, false, true);

	}

	@Override

	public void deleteApi(String dsId, final String ifcId) throws DatasourceManagerException {

		final Map<String, Object> params = Maps.newHashMap();

		params.put("datasource", DatasourceFunctions.asSqlValue(dsId));

		params.put("id", DatasourceFunctions.asSqlValue(ifcId));

		datasourceManagerClients.updateSQL(dsId, "deleteInterface.sql.st", params, false, true);

	}

	@Override

	public boolean updateAccessParam(final String dsId, final String ifaceId, final String field, final String value) throws DatasourceManagerException {

		final String openaireDsId = datasourceManagerClients.findDatasourceId(dsId);

		final Map<String, Object> params = Maps.newHashMap();

		params.put("dsId", DatasourceFunctions.asSqlValue(openaireDsId));

		params.put("ifaceId", DatasourceFunctions.asSqlValue(ifaceId));

		params.put("field", DatasourceFunctions.asSqlValue(field));

		params.put("accessParam", true);

		if (value != null) {

			params.put("value", DatasourceFunctions.asSqlValue(value));

		}

		if (datasourceManagerClients.isDefinedParam(ifaceId, field)) {

			params.put("update", 1);

		}

		return datasourceManagerClients.updateSQL(openaireDsId, "updateApiCollectionsRow.sql.st", params, false, true);

	}

	@Override

	public boolean deleteAccessParam(final String dsId, final String ifaceId, final String field) throws DatasourceManagerException {

		final Map<String, Object> params = Maps.newHashMap();

		params.put("dsId", DatasourceFunctions.asSqlValue(dsId));

		params.put("ifaceId", DatasourceFunctions.asSqlValue(ifaceId));

		params.put("field", DatasourceFunctions.asSqlValue(field));

		return datasourceManagerClients.updateSQL(dsId, "deleteApiCollectionsRow.sql.st", params, false, true);

	}

	@Override

	public boolean updateSQL(final String dsId, final String sql, final boolean delete) throws DatasourceManagerException {

		return datasourceManagerClients.updateSQL(dsId, sql, delete, true);

	}

	@Override

	public Date findNextScheduledExecution(final String dsId, final String ifaceId)

			throws DatasourceManagerException {

		return datasourceManagerClients.findNextScheduledExecution(dsId, ifaceId);

	}

	@Override

	public boolean bulkUpdateApiAccessParams(final String repoId, final String ifaceId, final Map<String, String> params)

			throws DatasourceManagerException {

		return performUpdate(repoId, ifaceId, params, true);

	}

	private boolean performUpdate(final String repoId, final String ifaceId, final Map<String, String> params, final boolean accessParam)

			throws DatasourceManagerException {

		final String dsId = datasourceManagerClients.findDatasourceId(repoId);

		if (!accessParam) {

			deleteOldExtraFields(dsId, ifaceId);

		}

		for (final Map.Entry<String, String> e : params.entrySet()) {

			performSingleUpdate(dsId, ifaceId, e.getKey(), e.getValue(), accessParam);

		}

		datasourceManagerClients.regenerateProfile(dsId);

		return true;

	}

	private boolean deleteOldExtraFields(final String dsId, final String ifaceId) throws DatasourceManagerException {

		final Map<String, Object> params = Maps.newHashMap();

		params.put("dsId", DatasourceFunctions.asSqlValue(dsId));

		params.put("ifaceId", DatasourceFunctions.asSqlValue(ifaceId));

		return datasourceManagerClients.updateSQL(dsId, "deleteOldExtraFields.sql.st", params, false, false);

	}

	private boolean performSingleUpdate(final String dsId, final String ifaceId, final String field, final String value, final boolean accessParam)

			throws DatasourceManagerException {

		final Map<String, Object> params = Maps.newHashMap();

		params.put("dsId", DatasourceFunctions.asSqlValue(dsId));

		params.put("ifaceId", DatasourceFunctions.asSqlValue(ifaceId));

		params.put("field", DatasourceFunctions.asSqlValue(field));

		params.put("accessParam", accessParam);

		if (value != null) {

			params.put("value", DatasourceFunctions.asSqlValue(value));

		}

		if (accessParam && datasourceManagerClients.isDefinedParam(ifaceId, field)) {

			params.put("update", 1);

			params.put("preserveOriginal", 1);

		}

		return datasourceManagerClients.updateSQL(dsId, "updateApiCollectionsRow.sql.st", params, false, false);

	}

	public DatasourceManagerClients getDatasourceManagerClients() {

		return datasourceManagerClients;

	}

	@Required

	public void setDatasourceManagerClients(final DatasourceManagerClients datasourceManagerClients) {

		this.datasourceManagerClients = datasourceManagerClients;

	}

	@Override

	public boolean overrideCompliance(final String repoId, final String ifaceId, final String compliance) throws DatasourceManagerException {

		final String dsId = datasourceManagerClients.findDatasourceId(repoId);

		final Map<String, Object> params = Maps.newHashMap();

		params.put("dsId", DatasourceFunctions.asSqlValue(dsId));

		params.put("ifaceId", DatasourceFunctions.asSqlValue(ifaceId));

		params.put("field", DatasourceFunctions.asSqlValue(DatasourceConstants.OVERRIDING_COMPLIANCE_FIELD));

		if (StringUtils.isEmpty(compliance)) {

			params.put("delete", true);

			log.debug("Removing compliance");

		} else {

			params.put("value", DatasourceFunctions.asSqlValue(compliance));

			if (datasourceManagerClients.isDefinedParam(ifaceId, DatasourceConstants.OVERRIDING_COMPLIANCE_FIELD)) {

				params.put("update", true);

				log.debug("Updating compliance: " + compliance);

			} else {

				params.put("insert", true);

				log.debug("Adding compliance: " + compliance);

			}

		}

		return datasourceManagerClients.updateSQL(dsId, "overrideCompliance.sql.st", params, false, true);

	}

	@Override

	public List<BrowsableField> listBrowsableFields() throws DatasourceManagerException {

		return Lists.transform(getBrowsableFields(), new Function<DbBrowsableField, BrowsableField>() {

			@Override

			public BrowsableField apply(final DbBrowsableField f) {

				return new BrowsableField(f.getId(), f.getLabel());

			}

		});

	}

	@Override

	public List<BrowseTerm> browseField(final String f) throws DatasourceManagerException {

		final List<BrowseTerm> list = Lists.newArrayList();

		try {

			final DbBrowsableField field = findBrowseField(f);

			if (field != null) {

				final SAXReader reader = new SAXReader();

				for (final String s : datasourceManagerClients.searchSQL(field.getSql())) {

					final Document doc = reader.read(new StringReader(s));

					final String id = doc.valueOf("/ROW/FIELD[@name='id']");

					final String name = doc.valueOf("/ROW/FIELD[@name='name']");

					final int value = NumberUtils.toInt(doc.valueOf("/ROW/FIELD[@name='count']"), 0);

					if (StringUtils.isNotEmpty(id)) {

						list.add(new BrowseTerm(id, name, value));

					}

				}

			}

		} catch (final Exception e) {

			log.error("Error browsing field " + f, e);

		}

		return list;

	}

	@Override

	public List<SearchInterfacesEntry> searchInterface(final String field, final String value) throws DatasourceManagerException {

		try {

			final Map<String, Object> params = Maps.newHashMap();

			params.put("value", value);

			if (!field.equalsIgnoreCase("__search__")) {

				params.put("field", field);

			}

			final DbBrowsableField f = findBrowseField(field);

			if ((f == null) || f.isText()) {

				params.put("delimeter", "'");

			}

			final SAXReader reader = new SAXReader();

			final Iterable<String> iter = datasourceManagerClients.searchSQL("searchRepoInterfaces.sql.st", params);

			return Lists.newArrayList(Iterables.transform(iter, new Function<String, SearchInterfacesEntry>() {

				@Override

				public SearchInterfacesEntry apply(final String s) {

					final SearchInterfacesEntry iface = new SearchInterfacesEntry();

					try {

						final Document doc = reader.read(new StringReader(s));

						final String country = doc.valueOf("/ROW/FIELD[@name='country']");

						iface.setRepoId(doc.valueOf("/ROW/FIELD[@name='repoid']"));

						iface.setRepoCountry(StringUtils.isEmpty(country) ? "-" : country.toUpperCase());

						iface.setRepoName(StringEscapeUtils.unescapeXml(doc.valueOf("/ROW/FIELD[@name='reponame']")));

						iface.setRepoPrefix(doc.valueOf("/ROW/FIELD[@name='repoprefix']"));

						iface.setId(doc.valueOf("/ROW/FIELD[@name='id']"));

						iface.setActive(Boolean.valueOf(doc.valueOf("/ROW/FIELD[@name='active']")));

						iface.setProtocol(doc.valueOf("/ROW/FIELD[@name='protocol']"));

						iface.setCompliance(doc.valueOf("/ROW/FIELD[@name='compliance']"));

						iface.setAggrDate(doc.valueOf("/ROW/FIELD[@name='aggrdate']"));

						iface.setAggrTotal(NumberUtils.toInt(doc.valueOf("/ROW/FIELD[@name='aggrtotal']"), 0));

					} catch (final Exception e) {

						log.error(e);

					}

					return iface;

				}

			}));

		} catch (final Exception e) {

			log.error("Error searching field " + field + " - value: " + value, e);

		}

		return Lists.newArrayList();

	}

	private DbBrowsableField findBrowseField(final String id) {

		for (final DbBrowsableField f : getBrowsableFields()) {

			if (f.getId().equals(id)) { return f; }

		}

		return null;

	}

	@Override

	public List<RepositoryMapEntry> getRepositoryMap() throws DatasourceManagerException {

		final SAXReader reader = new SAXReader();

		try {

			final Iterable<String> iter = datasourceManagerClients.searchSQL("findReposMap.sql.st", null);

			return Lists.newArrayList(Iterables.transform(iter, s -> {

				final RepositoryMapEntry r = new RepositoryMapEntry();

				try {

					final Document doc = reader.read(new StringReader(s));

					r.setId(doc.valueOf("/ROW/FIELD[@name='id']"));

					r.setName(StringEscapeUtils.unescapeXml(doc.valueOf("/ROW/FIELD[@name='name']")));

					r.setLat(NumberUtils.toFloat(doc.valueOf("/ROW/FIELD[@name='lat']"), 0));

					r.setLng(NumberUtils.toFloat(doc.valueOf("/ROW/FIELD[@name='lng']"), 0));

				} catch (final Exception e) {

					log.error(e);

				}

				return r;

			}));

		} catch (final Exception e) {

			log.error("Error obtaing repo map entries", e);

		}

		return Lists.newArrayList();

	}

	@Override

	public List<SimpleDatasourceDesc> simpleListDatasourcesByType(final String type) throws DatasourceManagerException {

		final Map<String, Object> params = Maps.newHashMap();

		params.put("type", type);

		final List<SimpleDatasourceDesc> list = Lists.newArrayList();

		try {

			final SAXReader reader = new SAXReader();

			for (final String s : datasourceManagerClients.searchSQL("simpleFindRepos.sql.st", params)) {

				final Document doc = reader.read(new StringReader(s));

				final SimpleDatasourceDesc r = new SimpleDatasourceDesc();

				r.setId(doc.valueOf("/ROW/FIELD[@name='id']"));

				r.setOrigId(doc.valueOf("/ROW/FIELD[@name='id']"));

				r.setName(StringEscapeUtils.unescapeXml(doc.valueOf("/ROW/FIELD[@name='name']")));

				for (final Object o : doc.selectNodes("/ROW/FIELD[@name='apis']/ITEM")) {

					r.getApis().add(((Node) o).getText());

				}

				r.setValid(true); // TODO

				r.setTypology(type);

				list.add(r);

			}

			Collections.sort(list);

		} catch (final Exception e) {

			log.error("Error listing repos", e);

		}

		return list;

	}

	public List<DbBrowsableField> getBrowsableFields() {

		return browsableFields;

	}

	@Required

	public void setBrowsableFields(final List<DbBrowsableField> browsableFields) {

		this.browsableFields = browsableFields;

	}

}