D-Net

package eu.dnetlib.openaire.exporter.datasource.clients;

import java.io.IOException;

import java.nio.charset.Charset;

import java.util.List;

import java.util.Map;

import java.util.Queue;

import java.util.concurrent.LinkedBlockingQueue;

import java.util.function.Function;

import java.util.stream.Collectors;

import com.google.common.collect.Lists;

import com.google.common.xml.XmlEscapers;

import eu.dnetlib.OpenaireExporterConfig;

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

import eu.dnetlib.enabling.is.lookup.rmi.ISLookUpException;

import eu.dnetlib.enabling.is.lookup.rmi.ISLookUpService;

import eu.dnetlib.openaire.exporter.datasource.clients.utils.IndexDsInfo;

import eu.dnetlib.openaire.exporter.funders.context.Context;

import eu.dnetlib.openaire.exporter.funders.context.MappingUtils;

import org.apache.commons.io.IOUtils;

import org.apache.commons.lang3.StringUtils;

import org.apache.commons.logging.Log;

import org.apache.commons.logging.LogFactory;

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

import org.springframework.cache.annotation.CacheEvict;

import org.springframework.cache.annotation.Cacheable;

import org.springframework.core.io.ClassPathResource;

import org.springframework.stereotype.Component;

/**

 * Created by claudio on 20/10/2016.

 */

@Component

public class ISLookupClient {

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

	@Autowired

	private OpenaireExporterConfig config;

	@Autowired

	private ISLookUpService isLookUpService;

	@Cacheable("datasources-is-cache")

	public IndexDsInfo calculateCurrentIndexDsInfo() throws DatasourceManagerException {

		log.warn("calculateCurrentIndexDsInfo(): not using cache");

		final String[] arr;

		try {

			arr = _isLookUp(_getQuery(config.getFindIndexDsInfo())).split("@@@");

			return new IndexDsInfo(

				_isLookUp(_getQuery(config.getFindSolrIndexUrl())),

				arr[0].trim(), arr[1].trim(), arr[2].trim());

		} catch (IOException | ISLookUpException e) {

			throw new DatasourceManagerException("unable fetch index DS information from IS");

		}

	}

	@Cacheable("datasources-is-cache")

	public String getObjectStoreId(final String dsId, final Queue<Throwable> errors) throws IOException {

		log.warn(String.format("getObjectStoreId(%s): not using cache", dsId));

		final String xqueryTemplate = _getQuery(config.getFindObjectStore());

		try {

			return _isLookUp(String.format(xqueryTemplate, dsId));

		} catch (ISLookUpException e) {

			errors.add(new DatasourceManagerException("unable to find objectStore for datasource " + dsId));

			return "";

		}

	}

	@Cacheable("datasources-is-cache")

	public Map<String, Context> getContextMap() throws IOException {

		final Queue<Throwable> errors = new LinkedBlockingQueue<>();

		try {

			return getContextProfiles(errors).stream()

					.filter(StringUtils::isNotBlank)

					.map(s -> MappingUtils.parseContext(s, errors))

					.collect(Collectors.toMap(

							Context::getId,

							Function.identity()));

		} finally {

			if (!errors.isEmpty()) {

				log.error(errors);

			}

		}

	}

	private void updateDatasourceField(final String dsId, final String element, final String value, final Queue<Throwable> errors) {

		try {

			final String xquery = _getQuery(config.getUpdateRepoField());

			_isLookUp(

				String.format(

					xquery,

					XmlEscapers.xmlAttributeEscaper().escape(dsId),

					XmlEscapers.xmlContentEscaper().escape(element),

					XmlEscapers.xmlContentEscaper().escape(value)));

		} catch (IOException | ISLookUpException e) {

			errors.add(e);

		}

	}

	/// HELPERS

	private List<String> getContextProfiles(final Queue<Throwable> errors) throws IOException {

		log.warn("getContextProfiles(): not using cache");

		final String xqueryTemplate = _getQuery(config.getFindFunderContexts());

		return _quickSeachProfile(xqueryTemplate, errors);

	}

	private String _getQuery(final ClassPathResource resource) throws IOException {

		return IOUtils.toString(resource.getInputStream(), Charset.defaultCharset());

	}

	private String _isLookUp(final String xquery) throws ISLookUpException {

		log.debug(String.format("running xquery: %s", xquery));

		final String res = isLookUpService.getResourceProfileByQuery(xquery);

		log.debug(String.format("query result: %s", res));

		return res;

	}

	private List<String> _quickSeachProfile(final String xquery, final Queue<Throwable> errors) {

		final List<String> res = Lists.newArrayList();

		try {

			log.debug(String.format("running xquery: %s", xquery));

			res.addAll(isLookUpService.quickSearchProfile(xquery)) ;

			log.debug(String.format("query result size: %s", res.size()));

		} catch (Throwable e) {

			errors.add(e);

			return Lists.newArrayList();

		} finally {

			return res;

		}

	}

	@CacheEvict(cacheNames = "datasources-is-cache", allEntries = true)

	public void dropCache() {

		log.info("dropped dsManager IS cache");

	}

}