D-Net

package eu.dnetlib.vocabularies.publisher;

import java.io.StringReader;

import java.util.List;

import eu.dnetlib.vocabularies.publisher.model.Synonym;

import org.apache.commons.logging.Log;

import org.apache.commons.logging.LogFactory;

import org.dom4j.Document;

import org.dom4j.DocumentException;

import org.dom4j.Element;

import org.dom4j.io.SAXReader;

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

import org.springframework.cache.annotation.Cacheable;

import com.google.common.collect.Lists;

import eu.dnetlib.enabling.tools.SplittedQueryExecutor;

import eu.dnetlib.vocabularies.publisher.model.Vocabulary;

import eu.dnetlib.vocabularies.publisher.model.VocabularyTerm;

public class VocabularyRetriever {

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

	@Autowired

	private SplittedQueryExecutor queryExecutor;

	@Cacheable("vocabularies")

	public List<Vocabulary> listVocabularies() {

		log.debug("listVocabularies(): not using cache");

		String query = "for $x in collection('/db/DRIVER/VocabularyDSResources/VocabularyDSResourceType') order by $x//VOCABULARY_NAME "

				+ "return concat ($x//RESOURCE_IDENTIFIER/@value, ':-:',$x//VOCABULARY_NAME, ':-:',$x//VOCABULARY_DESCRIPTION, ':-:',$x//VOCABULARY_NAME/@code)";

		Iterable<Vocabulary> vocs = this.queryExecutor.query(Vocabulary.class, query);

		return Lists.newArrayList(vocs);

	}

	@Cacheable(value = "terms", key = "#id")

	public Vocabulary getVocabulary(final String id) throws VocabularyNotFoundException {

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

		// get the vocabulary info:

		String queryVoc = "let $x := /*[.//RESOURCE_IDENTIFIER/@value='"

				+ id

				+ "']"

				+ " return concat ($x//RESOURCE_IDENTIFIER/@value, ':-:',$x//VOCABULARY_NAME, ':-:',$x//VOCABULARY_DESCRIPTION, ':-:',$x//VOCABULARY_NAME/@code)";

		Vocabulary voc = getVocabularyByQuery(queryVoc);

		if (voc == null) throw new VocabularyNotFoundException("Can't find vocabulary by id: " + id);

		else return voc;

	}

	@Cacheable(value = "termsByCode", key = "#code")

	public Vocabulary getVocabularyByCode(final String code) throws VocabularyNotFoundException {

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

		String queryVoc = "let $x := //RESOURCE_PROFILE[.//VOCABULARY_NAME/@code='"

				+ code

				+ "']"

				+ " return concat ($x//RESOURCE_IDENTIFIER/@value, ':-:',$x//VOCABULARY_NAME, ':-:',$x//VOCABULARY_DESCRIPTION, ':-:',$x//VOCABULARY_NAME/@code)";

		Vocabulary voc = getVocabularyByQuery(queryVoc);

		if (voc == null) throw new VocabularyNotFoundException("Can't find vocabulary by code: " + code);

		else return voc;

	}

	@Cacheable(value = "synonymsByCode", key = "#termCode")

	public VocabularyTerm getTermSynonyms(final String vocabularyCode, final String termCode) throws VocabularyNotFoundException {

		log.warn(String.format("getTermSynonyms(%s, %s): not using cache", vocabularyCode, termCode));

		final Vocabulary voc = getVocabularyByCode(vocabularyCode);

		final VocabularyTerm vt = voc.getTerms().stream()

				.filter(t -> t.getCode().equalsIgnoreCase(termCode))

				.findFirst()

				.get();

		String querySynonyms =

				String.format("for $x in /*[.//RESOURCE_IDENTIFIER/@value='%s']//TERM[./@code = '%s']//SYNONYM " +

						"return concat ($x/@term,':-:',$x/@encoding)", voc.getId(), termCode);

		vt.setSynonyms(Lists.newArrayList(queryExecutor.query(Synonym.class, querySynonyms)));

		return vt;

	}

	private Vocabulary getVocabularyByQuery(final String query) {

		Iterable<Vocabulary> vocs = this.queryExecutor.query(Vocabulary.class, query);

		if (vocs.iterator().hasNext()) {

			Vocabulary theVoc = vocs.iterator().next();

			if (theVoc.getId() == null) return null;

			// now the terms

			String queryTerms = "for $x in /*[.//RESOURCE_IDENTIFIER/@value='" + theVoc.getId() + "']//TERM order by $x/@english_name "

					+ "return concat ($x/@english_name,':-:',$x/@native_name,':-:',$x/@encoding,':-:',$x/@code)";

			Iterable<VocabularyTerm> terms = this.queryExecutor.query(VocabularyTerm.class, queryTerms);

			theVoc.setTerms(Lists.newArrayList(terms));

			return theVoc;

		} else return null;

	}

	/*

	private Vocabulary getTermByQuery(final String query) throws DocumentException {

		Iterable<Vocabulary> vocs = this.queryExecutor.query(Vocabulary.class, query);

		if (vocs.iterator().hasNext()) {

			Vocabulary vocabulary = vocs.iterator().next();

			if (vocabulary.getId() == null) return null;

			// now the terms

			String queryTerms = String.format(

					"for $x in collection('/db/DRIVER/VocabularyDSResources/VocabularyDSResourceType') \n" +

							"where $x[./RESOURCE_PROFILE/HEADER/RESOURCE_IDENTIFIER/@value/string() = '%s']\n" +

							"return $x/RESOURCE_PROFILE/BODY/CONFIGURATION", vocabulary.getId());

			List<String> vocabProfiles = queryExecutor.performQuery(queryTerms);

			if (vocabProfiles != null && vocabProfiles.size() == 1) {

				final String termsXml = vocabProfiles.get(0);

				log.debug("got terms: " + termsXml);

				final Document doc = new SAXReader().read(new StringReader(termsXml));

				final List<VocabularyTerm> terms = Lists.newArrayList();

				for(Object t : doc.selectNodes("//TERM")) {

					final Element term = (Element) t;

					final List<Synonym> synonyms = Lists.newArrayList();

					for(Object s : term.selectNodes("//SYNONYM")) {

						Element syn = (Element) s;

						synonyms.add(new Synonym(syn.valueOf("./@term"), syn.valueOf("./@encoding")));

					}

					terms.add(new VocabularyTerm(

							term.valueOf("./@english_name"),

							term.valueOf("./@native_name"),

							term.valueOf("./@encoding"),

							term.valueOf("./@code"),

							synonyms));

				}

				vocabulary.setTerms(terms);

				return vocabulary;

			} else {

				throw new IllegalStateException(String.format("found more than one Vocabulary with id '%s'", vocabulary.getId()));

			}

		} else return null;

	}

	*/

}