D-Net

<?xml version="1.0" encoding="UTF-8"?>

<project xmlns="http://maven.apache.org/POM/4.0.0" xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance" xsi:schemaLocation="http://maven.apache.org/POM/4.0.0 http://maven.apache.org/maven-v4_0_0.xsd">

	<parent>

		<groupId>eu.dnetlib</groupId>

		<artifactId>dnet45-parent</artifactId>

		<version>1.0.0</version>

		<relativePath />

	</parent>

	<modelVersion>4.0.0</modelVersion>

	<artifactId>dnet-oai-utils</artifactId>

	<packaging>jar</packaging>

	<version>4.0.1</version>

	<scm>

		<developerConnection>scm:svn:https://svn.driver.research-infrastructures.eu/driver/dnet45/modules/dnet-oai-utils/tags/dnet-oai-utils-4.0.1</developerConnection>

	</scm>

	<dependencies>

		<dependency>

			<groupId>junit</groupId>

			<artifactId>junit</artifactId>

			<version>${junit.version}</version>

			<scope>test</scope>

		</dependency>

		<dependency>

			<groupId>eu.dnetlib</groupId>

			<artifactId>cnr-misc-utils</artifactId>

			<version>[1.0.0,2.0.0)</version>

		</dependency>

		<dependency>

			<groupId>com.google.guava</groupId>

			<artifactId>guava</artifactId>

			<version>${google.guava.version}</version>

		</dependency>

		<!-- Needed for locators -->

		<dependency>

			<groupId>eu.dnetlib</groupId>

			<artifactId>cnr-service-common</artifactId>

			<version>[2.1.0,3.0.0)</version>

		</dependency>

	</dependencies>

</project>

package eu.dnetlib.data.information.oai.utils;

/**

 * Static class keeping track of env variable and job parameter names used by default by OAI Job nodes.

 * Created by alessia on 09/11/16.

 */

public class OAIParameterNames {

	public static String OAI_COLLECTON = "oai_collection";

	public static String OAI_DB = "oai_dbName";

	public static String OAI_FORMAT_NAME = "oai_format";

	public static String OAI_FORMAT_LAYOUT = "oai_layout";

	public static String OAI_FORMAT_INTERPRETATION = "oai_interpretation";

	public static String OAI_SOURCE = "oai_source";

	public static String OAI_INDEXES = "oai_indexFieldNames";

	public static String OAI_CONFIGURED_SETS_ONLY = "oai_configuredSetsOnly";

	public static String OAI_CONFIGURATION_PROFILE = "oai_configuration";

	public static String OAI_ACTION_DATE = "oai_actionDate";

	/**

	 * @Deprecated please use OAI_ACTION_DATE instead.

	 */

	@Deprecated

	public static String OAI_FEED_DATE = "oai_feedDate";

	public static String OAI_SKIP_DUPLICATES = "oai_skipDuplicates";

	public static String OAI_DUPLICATE_XPATH = "oai_duplicateXPath";

	public static String OAI_SYNC_EPR = "oai_syncEpr";

	public static String OAI_ALWAYS_NEW_RECORD= "oai_alwaysNewRecord";

}

package eu.dnetlib.data.information.oai.publisher.conf;

import java.util.List;

import javax.annotation.Resource;

import com.google.common.collect.Lists;

import eu.dnetlib.data.information.oai.publisher.OaiPublisherException;

import eu.dnetlib.data.information.oai.publisher.OaiPublisherRuntimeException;

import eu.dnetlib.data.information.oai.publisher.info.MDFInfo;

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

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

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

import eu.dnetlib.enabling.locators.UniqueServiceLocator;

import eu.dnetlib.miscutils.functional.IdentityFunction;

import eu.dnetlib.miscutils.functional.UnaryFunction;

import eu.dnetlib.miscutils.functional.xml.ApplyXslt;

import org.apache.commons.lang.StringUtils;

import org.apache.commons.logging.Log;

import org.apache.commons.logging.LogFactory;

import org.dom4j.DocumentException;

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

import org.springframework.cache.annotation.CacheEvict;

import org.springframework.cache.annotation.Cacheable;

/**

 * Helper class for common queries to the IS.

 * 

 * @author alessia

 * 

 */

public class ISLookUpClient {

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

	@Value("${services.oai.publisher.db.xquery}")

	private String xpathToCurrentDB;

	/**

	 * lookup service.

	 */

	@Resource

	private UniqueServiceLocator serviceLocator;

	@Resource

	private OAIConfigurationExistReader configuration;

	public List<MDFInfo> listMetadataFormats(final boolean onlyEnabled) throws ISLookUpException, DocumentException, OaiPublisherException {

		return Lists.newArrayList(this.configuration.getMetadataFormatInfo(onlyEnabled));

	}

	@Cacheable(value = "unaryFunctions", key = "#tdsRuleId")

	public UnaryFunction<String, String> getUnaryFunctionFromTDSRule(final String tdsRuleId) {

		log.fatal("Not using cache to get TDSRule " + tdsRuleId);

		final String queryCodeRule = "//RESOURCE_PROFILE[.//RESOURCE_IDENTIFIER/@value='" + tdsRuleId

				+ "']/BODY/CONFIGURATION/SCRIPT/CODE/*[local-name()='stylesheet']";

		String xsltCode = null;

		try {

			xsltCode = this.serviceLocator.getService(ISLookUpService.class).getResourceProfileByQuery(queryCodeRule);

		} catch (ISLookUpDocumentNotFoundException e) {

			log.fatal("Unexisting TDSRule profile with identifier " + tdsRuleId);

			throw new OaiPublisherRuntimeException(e);

		} catch (ISLookUpException e) {

			throw new OaiPublisherRuntimeException(e);

		}

		if (StringUtils.isBlank(xsltCode)) {

			log.warn("Unexpected blank stylesheet in TDSRule profile with id: " + tdsRuleId + ". Returning identity function.");

			return new IdentityFunction<String>();

		} else return new ApplyXslt(xsltCode);

	}

	@Cacheable("oaiDB")

	public String getCurrentDB() throws ISLookUpDocumentNotFoundException, ISLookUpException {

		log.fatal("Not using cache to get the current OAI db");

		String currentDBName = this.serviceLocator.getService(ISLookUpService.class).getResourceProfileByQuery(xpathToCurrentDB);

		log.info("Current OAI DB:" + currentDBName);

		return currentDBName;

	}

	@CacheEvict(value = { "unaryFunctions", "oaiDB" }, allEntries = true, beforeInvocation = true)

	public void evictCaches() {

		log.info("Evicted caches oaiDB and unaryFunctions");

	}

	public OAIConfigurationExistReader getConfiguration() {

		return configuration;

	}

	public void setConfiguration(final OAIConfigurationExistReader configuration) {

		this.configuration = configuration;

	}

}

<ehcache>

	<!-- Sets the path to the directory where cache .data files are created. 

		If the path is a Java System Property it is replaced by its value in the 

		running VM. The following properties are translated: user.home - User's home 

		directory user.dir - User's current working directory java.io.tmpdir - Default 

		temp file path -->

	<diskStore path="java.io.tmpdir" />

	<!--Default Cache configuration. These will applied to caches programmatically 

		created through the CacheManager. The following attributes are required for 

		defaultCache: maxInMemory - Sets the maximum number of objects that will 

		be created in memory eternal - Sets whether elements are eternal. If eternal, 

		timeouts are ignored and the element is never expired. timeToIdleSeconds 

		- Sets the time to idle for an element before it expires. i.e. The maximum 

		amount of time between accesses before an element expires Is only used if 

		the element is not eternal. Optional attribute. A value of 0 means that an 

		Element can idle for infinity timeToLiveSeconds - Sets the time to live for 

		an element before it expires. i.e. The maximum time between creation time 

		and when an element expires. Is only used if the element is not eternal. 

		overflowToDisk - Sets whether elements can overflow to disk when the in-memory 

		cache has reached the maxInMemory limit. -->

	<!-- <defaultCache maxElementsInMemory="1000" overflowToDisk="true" -->

	<!-- eternal="true" diskPersistent="false" timeToIdleSeconds="0" -->

	<!-- timeToLiveSeconds="0" memoryStoreEvictionPolicy="LRU" -->

	<!-- diskExpiryThreadIntervalSeconds="120" diskSpoolBufferSizeMB="5" /> -->

	<cache name="unaryFunctions" maxElementsInMemory="5" eternal="false"

		timeToIdleSeconds="500" timeToLiveSeconds="500" overflowToDisk="false" />

	<cache name="oaiDB" maxElementsInMemory="1" eternal="false"

		timeToIdleSeconds="1800" timeToLiveSeconds="1800" overflowToDisk="false" />

<!-- 	<cache name="publisherfields" maxElementsInMemory="30" eternal="false" -->

<!-- 		timeToIdleSeconds="1800" timeToLiveSeconds="1800" overflowToDisk="false" /> -->

<!-- 	<cache name="publisheridscheme" maxElementsInMemory="1" eternal="false" -->

<!-- 		timeToIdleSeconds="1800" timeToLiveSeconds="1800" overflowToDisk="false" /> -->

<!-- 	<cache name="publisheridnamespace" maxElementsInMemory="1" -->

<!-- 		eternal="false" timeToIdleSeconds="1800" timeToLiveSeconds="1800" -->

<!-- 		overflowToDisk="false" /> -->

</ehcache>

package eu.dnetlib.data.information.oai.publisher.conf;

import static org.junit.Assert.assertEquals;

import static org.junit.Assert.assertNotNull;

import static org.junit.Assert.assertTrue;

import java.io.IOException;

import java.nio.charset.Charset;

import java.util.List;

import java.util.Map;

import org.apache.commons.io.IOUtils;

import org.apache.commons.logging.Log;

import org.apache.commons.logging.LogFactory;

import org.junit.Before;

import org.junit.Test;

import org.springframework.core.io.ClassPathResource;

import org.springframework.core.io.Resource;

import com.google.common.collect.ArrayListMultimap;

import com.google.common.collect.Lists;

import com.google.common.collect.Maps;

import com.google.common.collect.Multimap;

import eu.dnetlib.data.information.oai.publisher.PublisherField;

import eu.dnetlib.data.information.oai.publisher.info.MDFInfo;

import eu.dnetlib.data.information.oai.publisher.info.SetInfo;

public class OAIConfigurationParserTest {

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

	/** Resource under test **/

	private OAIConfigurationParser parser;

	/** Configuration profile to parse **/

	private String configurationProfile;

	/** File path where to find the XML configuration profile **/

	private String pathToProfile = "eu/dnetlib/data/information/oai/publisher/conf/OAIPublisherConfiguration-1.xml";

	/** Expected configuration based on the profile available at the given pathToProfile. **/

	private OAIConfiguration expectedConfiguration;

	@Before

	public void setUp() throws Exception {

		// preparing the expected configuration that we will use to perform asserts on the result of parsing

		expectedConfiguration = new OAIConfiguration();

		Map<String, SetInfo> setsMap = Maps.newHashMap();

		setsMap.put("set1", new SetInfo("set1", "set number 1", "test set", "(set =\"aSet\")", true));

		expectedConfiguration.setSetsMap(setsMap);

		expectedConfiguration.setFieldNames(Lists.newArrayList("title", "objIdentifier", "set"));

		Map<String, MDFInfo> formatsMap = Maps.newHashMap();

		formatsMap.put("oai_dc", new MDFInfo("oai_dc", "SCHEMA", "NAMESPACE", "oai_dc", "store", "driver", "", true));

		formatsMap.put("hope", new MDFInfo("hope", "SCHEMA", "NAMESPACE", "hope", "L", "I", "country = IT", "tdsRule", true));

		expectedConfiguration.setMdFormatsMap(formatsMap);

		expectedConfiguration.setIdNamespace("eagle");

		List<PublisherField> fields = Lists.newArrayList();

		String oaidcKey = "oai_dc-store-driver";

		String hopeKey = "hope-L-I";

		PublisherField titleField = new PublisherField();

		titleField.setFieldName("title");

		titleField.setRepeatable(true);

		Multimap<String, String> titleSources = ArrayListMultimap.create();

		titleSources.put(oaidcKey, "//*[local-name() = 'title']");

		titleSources.put(oaidcKey, "//*[local-name() ='alternative']");

		titleSources.put(hopeKey, "//title");

		titleSources.put(hopeKey, "//titleinfo");

		titleField.setSources(titleSources);

		fields.add(titleField);

		PublisherField objIdField = new PublisherField();

		objIdField.setFieldName("objIdentifier");

		objIdField.setRepeatable(false);

		Multimap<String, String> objIdSources = ArrayListMultimap.create();

		objIdSources.put(oaidcKey, "//*[local-name() ='objIdentifier']");

		objIdField.setSources(objIdSources);

		fields.add(objIdField);

		PublisherField setField = new PublisherField();

		setField.setFieldName("set");

		setField.setRepeatable(true);

		Multimap<String, String> setSources = ArrayListMultimap.create();

		setSources.put(oaidcKey, "//*[local-name() ='repositoryId']");

		setField.setSources(setSources);

		fields.add(setField);

		expectedConfiguration.setFields(fields);

		Resource resource = new ClassPathResource(pathToProfile);

		// setting up the parser and the profile as a string

		parser = new OAIConfigurationParser();

		configurationProfile = IOUtils.toString(resource.getInputStream(), Charset.forName("UTF-8"));

		log.info("setUp completed");

	}

	@Test

	public void testSchemeIdNamespace() throws IOException {

		OAIConfiguration result = parser.getConfiguration(configurationProfile);

		System.out.println(result.getIdScheme());

		System.out.println(result.getIdNamespace());

	}

	@Test

	public void testGetConfiguration() throws IOException {

		OAIConfiguration result = parser.getConfiguration(configurationProfile);

		assertNotNull(result);

		// asserts on sets

		assertTrue(result.getSetsMap().containsKey("set1"));

		SetInfo expected = expectedConfiguration.getSetsMap().get("set1");

		SetInfo parsedSet = result.getSetsMap().get("set1");

		assertEquals(expected.getQuery(), parsedSet.getQuery());

		assertEquals(expected.getSetDescription(), parsedSet.getSetDescription());

		assertEquals(expected.getSetName(), parsedSet.getSetName());

		assertEquals(expected.getSetSpec(), parsedSet.getSetSpec());

		// asserts on indices

		assertTrue(result.getFieldNames().containsAll(expectedConfiguration.getFieldNames()));

		assertEquals(3, result.getFieldsFor("oai_dc", "store", "driver").size());

		assertEquals(1, result.getFieldsFor("hope", "L", "I").size());

		// asserts on metadata formats

		assertTrue(result.getMdFormatsMap().containsKey("hope"));

		assertTrue(result.getMdFormatsMap().containsKey("oai_dc"));

		MDFInfo expectedFormat = expectedConfiguration.getMdFormatsMap().get("hope");

		MDFInfo parsedFormat = result.getMdFormatsMap().get("hope");

		assertEquals(expectedFormat.getBaseQuery(), parsedFormat.getBaseQuery());

		assertEquals(expectedFormat.getNamespace(), parsedFormat.getNamespace());

		assertEquals(expectedFormat.getPrefix(), parsedFormat.getPrefix());

		assertEquals(expectedFormat.getSchema(), parsedFormat.getSchema());

		assertEquals(expectedFormat.getSourceFormatInterpretation(), parsedFormat.getSourceFormatInterpretation());

		assertEquals(expectedFormat.getSourceFormatLayout(), parsedFormat.getSourceFormatLayout());

		assertEquals(expectedFormat.getSourceFormatName(), parsedFormat.getSourceFormatName());

		assertEquals(expectedFormat.getTransformationRuleID(), parsedFormat.getTransformationRuleID());

		assertEquals(expectedConfiguration.getIdNamespace(), result.getIdNamespace());

		assertEquals("oai", result.getIdScheme());

	}

	@Test

	public void splitRSToken() {

		String token = "1434158|dli||100|5551ed26e4b0f1f9ff635bab|false|";

		String[] splitted = token.split("\\|");

		System.out.println(splitted.length);

		for (String s : splitted) {

			System.out.println(s);

		}

	}

}

{"type_source": "SVN", "goal": "package -U source:jar",

"url": "http://svn-public.driver.research-infrastructures.eu/driver/dnet45/modules/dnet-oai-utils/trunk/",

"deploy_repository": "dnet45-snapshots", "version": "4", "mail": "sandro.labruzzo@isti.cnr.it,michele.artini@isti.cnr.it, claudio.atzori@isti.cnr.it, alessia.bardi@isti.cnr.it",

"deploy_repository_url": "http://maven.research-infrastructures.eu/nexus/content/repositories/dnet45-snapshots", "name": "dnet-oai-utils"}

package eu.dnetlib.data.information.oai.publisher.conf;

import java.util.Iterator;

import java.util.List;

import java.util.Set;

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

import com.google.common.collect.ArrayListMultimap;

import com.google.common.collect.Lists;

import com.google.common.collect.Multimap;

import com.google.common.collect.Sets;

import eu.dnetlib.common.rmi.UnimplementedException;

import eu.dnetlib.data.information.oai.publisher.OaiPublisherRuntimeException;

import eu.dnetlib.data.information.oai.publisher.PublisherField;

import eu.dnetlib.data.information.oai.publisher.info.MDFInfo;

import eu.dnetlib.data.information.oai.publisher.info.SetInfo;

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

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

import eu.dnetlib.enabling.tools.SplittedQueryExecutor;

/**

 * Instances of this class read the configuration of the OAI publisher from the IS, by performing xquery on the Exist database.

 * 

 * @author alessia

 * 

 */

public class OAIConfigurationExistReader implements OAIConfigurationReader {

	@Autowired

	private SplittedQueryExecutor queryExecutor;

	private String xpathToIdScheme = "//RESOURCE_PROFILE[.//RESOURCE_TYPE/@value = 'OAIPublisherConfigurationDSResourceType']//CONFIGURATION/IDSCHEME/text()";

	private String xpathToIdNamespace = "//RESOURCE_PROFILE[.//RESOURCE_TYPE/@value = 'OAIPublisherConfigurationDSResourceType']//CONFIGURATION/IDNAMESPACE/text()";

	@Override

	public List<SetInfo> getSets() {

		final String query = "for $x in collection('/db/DRIVER/OAIPublisherConfigurationDSResources/OAIPublisherConfigurationDSResourceType')//CONFIGURATION/OAISETS/OAISET "

				+ "return concat($x/spec, ':-:', $x/name, ':-:', $x//description , ':-:', $x//query, ':-:', $x/@enabled/string())";

		Iterable<SetInfo> sets = this.queryExecutor.query(SetInfo.class, query, ":-:");

		return Lists.newArrayList(sets);

	}

	@Override

	public List<SetInfo> getSets(final boolean onlyEnabled) {

		if (onlyEnabled) {

			final String query = "for $x in collection('/db/DRIVER/OAIPublisherConfigurationDSResources/OAIPublisherConfigurationDSResourceType')//CONFIGURATION/OAISETS/OAISET "

					+ "where $x/@enabled/string() = 'true' "

					+ "return concat($x/spec, ':-:', $x/name, ':-:', $x//description , ':-:', $x//query, ':-:', $x/@enabled/string())";

			Iterable<SetInfo> sets = this.queryExecutor.query(SetInfo.class, query, ":-:");

			return Lists.newArrayList(sets);

		} else return this.getSets();

	}

	@Override

	public List<String> getSetSpecs() {

		final String query = "for $x in collection('/db/DRIVER/OAIPublisherConfigurationDSResources/OAIPublisherConfigurationDSResourceType')//CONFIGURATION/OAISETS/OAISET "

				+ "return $x/spec/string() ";

		List<String> names = this.queryExecutor.performQuery(query);

		return names;

	}

	@Override

	public List<String> getSetSpecs(final boolean onlyEnabled) {

		final String query = "for $x in collection('/db/DRIVER/OAIPublisherConfigurationDSResources/OAIPublisherConfigurationDSResourceType')//CONFIGURATION/OAISETS/OAISET "

				+ "where $x/@enabled/string() = '" + onlyEnabled + "' " + "return $x/spec/string() ";

		List<String> names = this.queryExecutor.performQuery(query);

		return names;

	}

	@Override

	public SetInfo getSetInfo(final String setSpec) {

		final String query = "for $x in collection('/db/DRIVER/OAIPublisherConfigurationDSResources/OAIPublisherConfigurationDSResourceType')//CONFIGURATION/OAISETS/OAISET "

				+ "where $x/spec = '"

				+ setSpec

				+ "' "

				+ "return concat($x/spec, ':-:', $x/name, ':-:', $x//description , ':-:', $x//query, ':-:', $x/@enabled/string())";

		Iterable<SetInfo> sets = this.queryExecutor.query(SetInfo.class, query, ":-:");

		if (sets.iterator().hasNext()) return sets.iterator().next();

		else return null;

	}

	@Override

	public List<MDFInfo> getSourceMetadataFormats() {

		final String query = "for $x in collection('/db/DRIVER/OAIPublisherConfigurationDSResources/OAIPublisherConfigurationDSResourceType')//CONFIGURATION//METADATAFORMAT "

				+ "return concat($x//SOURCE_METADATA_FORMAT/@name/string(), ':-:',  $x//SOURCE_METADATA_FORMAT/@layout/string(), ':-:', $x//SOURCE_METADATA_FORMAT/@interpretation/string())";

		List<String> res;

		try {

			res = this.queryExecutor.getServiceLocator().getService(ISLookUpService.class).quickSearchProfile(query);

		} catch (ISLookUpException e) {

			throw new OaiPublisherRuntimeException(e);

		}

		Set<MDFInfo> sources = Sets.newHashSet();

		for (String src : res) {

			String[] splitted = src.split(":-:");

			MDFInfo mdfInfo = new MDFInfo();

			mdfInfo.setSourceFormatName(splitted[0]);

			mdfInfo.setSourceFormatLayout(splitted[1]);

			mdfInfo.setSourceFormatInterpretation(splitted[2]);

			sources.add(mdfInfo);

		}

		return Lists.newArrayList(sources);

	}

	@Override

	public List<MDFInfo> getMetadataFormatInfo() {

		final String query = "for $x in collection('/db/DRIVER/OAIPublisherConfigurationDSResources/OAIPublisherConfigurationDSResourceType')//CONFIGURATION//METADATAFORMAT "

				+ "return concat($x/@metadataPrefix/string(), ':-:', $x//SCHEMA , ':-:', $x//NAMESPACE,  "

				+ "':-:', $x//SOURCE_METADATA_FORMAT/@name/string(), ':-:',  $x//SOURCE_METADATA_FORMAT/@layout/string(), ':-:', $x//SOURCE_METADATA_FORMAT/@interpretation/string(), "

				+ "':-:', $x//BASE_QUERY, ':-:',  $x//TRANSFORMATION_RULE, ':-:', $x/@exportable/string() )";

		Iterable<MDFInfo> mdFormats = this.queryExecutor.query(MDFInfo.class, query, ":-:");

		return Lists.newArrayList(mdFormats);

	}

	@Override

	public List<MDFInfo> getMetadataFormatInfo(final boolean onlyEnabled) {

		if (onlyEnabled) {

			final String query = "for $x in collection('/db/DRIVER/OAIPublisherConfigurationDSResources/OAIPublisherConfigurationDSResourceType')//CONFIGURATION//METADATAFORMAT "

					+ "where $x/@exportable/string() = 'true' "

					+ "return concat($x/@metadataPrefix/string(), ':-:', $x//SCHEMA , ':-:', $x//NAMESPACE,  "

					+ "':-:', $x//SOURCE_METADATA_FORMAT/@name/string(), ':-:',  $x//SOURCE_METADATA_FORMAT/@layout/string(), ':-:', $x//SOURCE_METADATA_FORMAT/@interpretation/string(), "

					+ "':-:', $x//BASE_QUERY, ':-:',  $x//TRANSFORMATION_RULE, ':-:', $x/@exportable/string() )";

			Iterable<MDFInfo> mdFormats = this.queryExecutor.query(MDFInfo.class, query, ":-:");

			return Lists.newArrayList(mdFormats);

		} else return getMetadataFormatInfo();

	}

	@Override

	public MDFInfo getMetadataFormatInfo(final String mdPrefix) {

		final String query = "for $x in collection('/db/DRIVER/OAIPublisherConfigurationDSResources/OAIPublisherConfigurationDSResourceType')//CONFIGURATION//METADATAFORMAT "

				+ "where $x/@metadataPrefix/string()='"

				+ mdPrefix

				+ "' "

				+ "return concat($x/@metadataPrefix/string(), ':-:', $x//SCHEMA , ':-:', $x//NAMESPACE,  "

				+ "':-:', $x//SOURCE_METADATA_FORMAT/@name/string(), ':-:',  $x//SOURCE_METADATA_FORMAT/@layout/string(), ':-:', $x//SOURCE_METADATA_FORMAT/@interpretation/string(), "

				+ "':-:', $x//BASE_QUERY,':-:', $x//TRANSFORMATION_RULE, ':-:', $x/@exportable/string() )";

		Iterable<MDFInfo> mdFormats = this.queryExecutor.query(MDFInfo.class, query, ":-:");

		Iterator<MDFInfo> iterator = mdFormats.iterator();

		if (iterator.hasNext()) return iterator.next();

		else return null;

	}

	@Override

	public List<PublisherField> getFields() {

		throw new UnimplementedException();

	}

	@Override

	public List<PublisherField> getFields(final String format, final String interpretation, final String layout) {

		final String query = "for $x in collection('/db/DRIVER/OAIPublisherConfigurationDSResources/OAIPublisherConfigurationDSResourceType')//CONFIGURATION//INDICES/INDEX "

				+ "return concat($x/@name, ':-:', $x/@repeatable, ':-:', string-join($x/SOURCE[@name='"

				+ format

				+ "' and @interpretation='"

				+ interpretation

				+ "' and @layout='" + layout + "']/@path, ':-:'))";

		List<String> res;

		try {

			res = this.queryExecutor.getServiceLocator().getService(ISLookUpService.class).quickSearchProfile(query);

		} catch (ISLookUpException e) {

			throw new OaiPublisherRuntimeException(e);

		}

		List<PublisherField> fields = Lists.newArrayList();

		for (String index : res) {

			String[] splitted = index.split(":-:");

			String indexName = splitted[0];

			String repeatable = splitted[1];

			PublisherField field = new PublisherField();

			field.setFieldName(indexName);

			field.setRepeatable(Boolean.valueOf(repeatable));

			Multimap<String, String> sources = ArrayListMultimap.create();

			String mdFormat = format + "-" + layout + "-" + interpretation;

			for (int i = 2; i < splitted.length; i++) {

				sources.put(mdFormat, splitted[i]);

			}

			field.setSources(sources);

			fields.add(field);

		}

		return fields;

	}

	@Override

	public List<String> getFieldNames() {

		String query = "//RESOURCE_PROFILE[.//RESOURCE_TYPE/@value = 'OAIPublisherConfigurationDSResourceType']//CONFIGURATION//INDICES/INDEX/@name/string()";

		try {

			return this.queryExecutor.getServiceLocator().getService(ISLookUpService.class).quickSearchProfile(query);

		} catch (ISLookUpException e) {

			throw new OaiPublisherRuntimeException(e);

		}

	}

	@Override

	public List<MDFInfo> getFormatsServedBy(final String sourceFormatName, final String sourceFormatLayout, final String sourceFormatInterpretation) {

		final String query = "for $x in collection('/db/DRIVER/OAIPublisherConfigurationDSResources/OAIPublisherConfigurationDSResourceType')//CONFIGURATION//METADATAFORMAT[.//SOURCE_METADATA_FORMAT/@name = '"

				+ sourceFormatName

				+ "' and .//SOURCE_METADATA_FORMAT/@layout = '"

				+ sourceFormatLayout

				+ "' and .//SOURCE_METADATA_FORMAT/@interpretation = '"

				+ sourceFormatInterpretation

				+ "'] "

				+ "return concat($x/@metadataPrefix/string(), ':-:', $x//SCHEMA , ':-:', $x//NAMESPACE,  "

				+ "':-:', $x//SOURCE_METADATA_FORMAT/@name/string(), ':-:',  $x//SOURCE_METADATA_FORMAT/@layout/string(), ':-:', $x//SOURCE_METADATA_FORMAT/@interpretation/string(), "

				+ "':-:', $x//BASE_QUERY, ':-:',  $x//TRANSFORMATION_RULE, ':-:', $x/@exportable/string() )";

		Iterable<MDFInfo> mdFormats = this.queryExecutor.query(MDFInfo.class, query, ":-:");

		return Lists.newArrayList(mdFormats);

	}

	@Override

	public String getIdScheme() {

		try {

			return this.queryExecutor.getServiceLocator().getService(ISLookUpService.class).getResourceProfileByQuery(getXpathToIdScheme());

		} catch (ISLookUpException e) {

			throw new OaiPublisherRuntimeException(e);

		}

	}

	@Override

	public String getIdNamespace() {

		try {

			return this.queryExecutor.getServiceLocator().getService(ISLookUpService.class).getResourceProfileByQuery(getXpathToIdNamespace());

		} catch (ISLookUpException e) {

			throw new OaiPublisherRuntimeException(e);

		}

	}

	public SplittedQueryExecutor getQueryExecutor() {

		return queryExecutor;

	}

	public void setQueryExecutor(final SplittedQueryExecutor queryExecutor) {

		this.queryExecutor = queryExecutor;

	}

	public String getXpathToIdScheme() {

		return xpathToIdScheme;

	}

	public void setXpathToIdScheme(final String xpathToIdScheme) {

		this.xpathToIdScheme = xpathToIdScheme;

	}

	public String getXpathToIdNamespace() {

		return xpathToIdNamespace;

	}

	public void setXpathToIdNamespace(final String xpathToIdNamespace) {

		this.xpathToIdNamespace = xpathToIdNamespace;

	}

}

package eu.dnetlib.data.information.oai.publisher.conf;

import java.io.IOException;

import java.util.Collection;

import java.util.List;

import javax.annotation.Resource;

import org.apache.commons.logging.Log;

import org.apache.commons.logging.LogFactory;

import com.google.common.base.Function;

import com.google.common.base.Predicate;

import com.google.common.collect.Collections2;

import com.google.common.collect.Iterables;

import com.google.common.collect.Lists;

import eu.dnetlib.data.information.oai.publisher.OaiPublisherRuntimeException;

import eu.dnetlib.data.information.oai.publisher.PublisherField;

import eu.dnetlib.data.information.oai.publisher.info.MDFInfo;

import eu.dnetlib.data.information.oai.publisher.info.SetInfo;

/**

 * Instances of this class reads the OAI configuration from a string, which is the configuration profile passed in as a string.

 * 

 * @author alessia

 * 

 */

public class OAIConfigurationStringReader implements OAIConfigurationReader {

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

	private OAIConfiguration oaiConfiguration;

	@Resource

	private OAIConfigurationParser configurationParser;

	public OAIConfigurationStringReader() {

		oaiConfiguration = null;

	}

	public OAIConfigurationStringReader(final String profile) {

		this.readConfiguration(profile);

	}

	public void readConfiguration(final String profile) {

		log.debug(profile);

		try {

			oaiConfiguration = configurationParser.getConfiguration(profile);

		} catch (IOException e) {

			throw new OaiPublisherRuntimeException("Could not read OAI configuration profile", e);

		}

	}

	public boolean isConfigurationLoaded() {

		return this.oaiConfiguration != null;

	}

	@Override

	public List<SetInfo> getSets() {

		if (isConfigurationLoaded()) return Lists.newArrayList(this.oaiConfiguration.getSetsMap().values());

		else throw new OaiPublisherRuntimeException("Configuration is not loaded");

	}

	@Override

	public List<SetInfo> getSets(final boolean onlyEnabled) {

		if (isConfigurationLoaded()) return Lists.newArrayList(Iterables.filter(this.oaiConfiguration.getSetsMap().values(), new Predicate<SetInfo>() {

			/**

			 * {@inheritDoc}

			 * 

			 * @see com.google.common.base.Predicate#apply(java.lang.Object)

			 */

			@Override

			public boolean apply(final SetInfo setInfo) {

				if (onlyEnabled) return setInfo.isEnabled();

				else return true;

			}

		}));

		else throw new OaiPublisherRuntimeException("Configuration is not loaded");

	}

	@Override

	public List<String> getSetSpecs() {

		if (isConfigurationLoaded()) return Lists.newArrayList(this.oaiConfiguration.getSetsMap().keySet());

		else throw new OaiPublisherRuntimeException("Configuration is not loaded");

	}

	@Override

	public List<String> getSetSpecs(final boolean onlyEnabled) {

		if (isConfigurationLoaded()) {

			if (!onlyEnabled) return this.getSetSpecs();

			List<SetInfo> enabled = this.getSets(true);

			return Lists.newArrayList(Iterables.transform(enabled, new Function<SetInfo, String>() {

				@Override

				public String apply(final SetInfo setInfo) {

					return setInfo.getSetSpec();

				}

			}));

		} else throw new OaiPublisherRuntimeException("Configuration is not loaded");

	}

	@Override

	public List<MDFInfo> getSourceMetadataFormats() {

		if (isConfigurationLoaded()) return Lists.newArrayList(this.oaiConfiguration.getSourcesMDF());

		else throw new OaiPublisherRuntimeException("Configuration is not loaded");

	}

	@Override

	public SetInfo getSetInfo(final String setSpec) {

		if (isConfigurationLoaded()) return this.oaiConfiguration.getSetsMap().get(setSpec);

		else throw new OaiPublisherRuntimeException("Configuration is not loaded");

	}

	@Override

	public List<MDFInfo> getMetadataFormatInfo() {

		if (isConfigurationLoaded()) return Lists.newArrayList(this.oaiConfiguration.getMdFormatsMap().values());

		else throw new OaiPublisherRuntimeException("Configuration is not loaded");

	}

	@Override

	public List<MDFInfo> getMetadataFormatInfo(final boolean onlyEnabled) {

		if (isConfigurationLoaded()) {

			if (!onlyEnabled) return this.getMetadataFormatInfo();

			else return Lists.newArrayList(Iterables.filter(this.oaiConfiguration.getMdFormatsMap().values(), new Predicate<MDFInfo>() {

				/**

				 * {@inheritDoc}

				 * 

				 * @see com.google.common.base.Predicate#apply(java.lang.Object)

				 */

				@Override

				public boolean apply(final MDFInfo mdfInfo) {

					if (onlyEnabled) return mdfInfo.isEnabled();

					else return true;

				}

			}));

		} else throw new OaiPublisherRuntimeException("Configuration is not loaded");

	}

	@Override

	public MDFInfo getMetadataFormatInfo(final String mdPrefix) {

		if (isConfigurationLoaded()) return this.oaiConfiguration.getMdFormatsMap().get(mdPrefix);

		else throw new OaiPublisherRuntimeException("Configuration is not loaded");

	}

	@Override

	public List<PublisherField> getFields() {

		if (isConfigurationLoaded()) return this.oaiConfiguration.getFields();

		else throw new OaiPublisherRuntimeException("Configuration is not loaded");

	}

	@Override

	public List<PublisherField> getFields(final String format, final String interpretation, final String layout) {

		if (isConfigurationLoaded()) return Lists.newArrayList(this.oaiConfiguration.getFieldsFor(format, layout, interpretation));

		else throw new OaiPublisherRuntimeException("Configuration is not loaded");

	}

	@Override

	public List<String> getFieldNames() {

		if (isConfigurationLoaded()) return this.oaiConfiguration.getFieldNames();

		else throw new OaiPublisherRuntimeException("Configuration is not loaded");

	}

	@Override

	public List<MDFInfo> getFormatsServedBy(final String sourceFormatName, final String sourceFormatLayout, final String sourceFormatInterpretation) {

		if (isConfigurationLoaded()) {

			Collection<MDFInfo> unfiltered = this.oaiConfiguration.getMdFormatsMap().values();

			return Lists.newArrayList(Collections2.filter(unfiltered, new Predicate<MDFInfo>() {

				@Override

				public boolean apply(final MDFInfo mdf) {

					return (mdf.getSourceFormatName() == sourceFormatName) && (mdf.getSourceFormatLayout() == sourceFormatLayout)

							&& (mdf.getSourceFormatInterpretation() == sourceFormatInterpretation);

				}

			}));

		} else throw new OaiPublisherRuntimeException("Configuration is not loaded");

	}

	@Override

	public String getIdScheme() {

		if (isConfigurationLoaded()) return this.oaiConfiguration.getIdScheme();

		else throw new OaiPublisherRuntimeException("Configuration is not loaded");

	}

	@Override

	public String getIdNamespace() {

		if (isConfigurationLoaded()) return this.oaiConfiguration.getIdNamespace();

		else throw new OaiPublisherRuntimeException("Configuration is not loaded");

	}

	public OAIConfiguration getOaiConfiguration() {

		return oaiConfiguration;

	}

	public void setOaiConfiguration(final OAIConfiguration oaiConfiguration) {

		this.oaiConfiguration = oaiConfiguration;

	}

	public OAIConfigurationParser getConfigurationParser() {

		return configurationParser;

	}

	public void setConfigurationParser(final OAIConfigurationParser configurationParser) {

		this.configurationParser = configurationParser;

	}

}

package eu.dnetlib.data.information.oai.publisher.conf;

import java.util.Collection;

import java.util.List;

import javax.annotation.Resource;

import org.apache.commons.logging.Log;

import org.apache.commons.logging.LogFactory;

import eu.dnetlib.data.information.oai.publisher.PublisherField;

import eu.dnetlib.data.information.oai.publisher.info.MDFInfo;

import eu.dnetlib.data.information.oai.publisher.info.SetInfo;

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

import eu.dnetlib.enabling.is.registry.rmi.ISRegistryException;

import eu.dnetlib.enabling.is.registry.rmi.ISRegistryService;

import eu.dnetlib.enabling.locators.UniqueServiceLocator;

import eu.dnetlib.miscutils.functional.string.EscapeXml;

public class OAIConfigurationWriter {

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

	@Resource

	private UniqueServiceLocator serviceLocator;

	@Resource(name = "oaiConfigurationExistReader")

	private OAIConfigurationReader configuration;

	private boolean execute(final String xUpdate) throws ISRegistryException {

		log.debug("Running XUpdate:\n" + xUpdate);

		boolean done = this.serviceLocator.getService(ISRegistryService.class).executeXUpdate(xUpdate);

		if (!done) {

			log.fatal("Could not perform the following Xupdate:\n" + xUpdate);

		}

		return done;

	}

	public boolean updateMetadataFormat(final String mdPrefix, final MDFInfo newInfo) throws ISRegistryException {

		final String xUpdate = "update replace //RESOURCE_PROFILE[.//RESOURCE_TYPE/@value='OAIPublisherConfigurationDSResourceType']"

				+ "//CONFIGURATION//METADATAFORMAT[./@metadataPrefix/string()='" + mdPrefix + "'] with <METADATAFORMAT exportable=\"" + newInfo.isEnabled()

				+ "\" metadataPrefix=\"" + newInfo.getPrefix() + "\">" + "<NAMESPACE>" + newInfo.getNamespace() + "</NAMESPACE><SCHEMA>" + newInfo.getSchema()

				+ "</SCHEMA><SOURCE_METADATA_FORMAT interpretation=\"" + newInfo.getSourceFormatInterpretation() + "\" layout=\""

				+ newInfo.getSourceFormatLayout() + "\" name=\"" + newInfo.getSourceFormatName() + "\"/><TRANSFORMATION_RULE>"

				+ newInfo.getTransformationRuleID() + "</TRANSFORMATION_RULE><BASE_QUERY>" + new EscapeXml().evaluate(newInfo.getBaseQuery())

				+ "</BASE_QUERY></METADATAFORMAT>";

		return this.execute(xUpdate);

	}

	public boolean addMetadataFormat(final MDFInfo newInfo) throws ISRegistryException {

		String action = "update insert ";

		String newNode = "<METADATAFORMAT metadataPrefix='" + newInfo.getPrefix() + "' exportable='" + newInfo.isEnabled() + "' ><NAMESPACE>"

				+ newInfo.getNamespace() + "</NAMESPACE><SCHEMA>" + newInfo.getSchema() + "</SCHEMA>" + "<SOURCE_METADATA_FORMAT interpretation='"

				+ newInfo.getSourceFormatInterpretation() + "' layout='" + newInfo.getSourceFormatLayout() + "' name='" + newInfo.getSourceFormatName()

				+ "' /><TRANSFORMATION_RULE>" + newInfo.getTransformationRuleID() + "</TRANSFORMATION_RULE><BASE_QUERY>"

				+ new EscapeXml().evaluate(newInfo.getBaseQuery()) + "</BASE_QUERY></METADATAFORMAT>";

		String targetNode = "//RESOURCE_PROFILE[.//RESOURCE_TYPE/@value='OAIPublisherConfigurationDSResourceType']//CONFIGURATION/METADATAFORMATS";

		String xUpdate = action + newNode + " into " + targetNode;

		return this.execute(xUpdate);

	}

	public boolean deleteMetadataFormat(final String mdPrefix) throws ISRegistryException {

		String xUpdate =

				"update delete //RESOURCE_PROFILE[.//RESOURCE_TYPE/@value='OAIPublisherConfigurationDSResourceType']//CONFIGURATION//METADATAFORMATS/METADATAFORMAT[./@metadataPrefix/string()='"

						+ mdPrefix + "']";

		return this.execute(xUpdate);

	}

	public boolean updateOAISet(final String setSpec, final SetInfo newInfo) throws ISRegistryException {

		final String xUpdate = "update replace //RESOURCE_PROFILE[.//RESOURCE_TYPE/@value='OAIPublisherConfigurationDSResourceType']"

				+ "//CONFIGURATION//OAISET[spec/text()='" + setSpec + "'] with " + "<OAISET enabled=\"" + newInfo.isEnabled() + "\">" + "<spec>"

				+ newInfo.getSetSpec() + "</spec>" + "<name>" + newInfo.getSetName() + "</name>" + "<description>" + newInfo.getSetDescription()

				+ "</description>" + "<query>" + new EscapeXml().evaluate(newInfo.getQuery()) + "</query></OAISET>";

		return this.execute(xUpdate);

	}

	public boolean addOAISet(final SetInfo newInfo) throws ISRegistryException {

		String action = "update insert ";

		String newNode = "<OAISET enabled=\"" + newInfo.isEnabled() + "\">" + "<spec>" + newInfo.getSetSpec() + "</spec>" + "<name>" + newInfo.getSetName()

				+ "</name>" + "<description>" + newInfo.getSetDescription() + "</description>" + "<query>" + new EscapeXml().evaluate(newInfo.getQuery())

				+ "</query></OAISET>";

		String targetNode = "//RESOURCE_PROFILE[.//RESOURCE_TYPE/@value='OAIPublisherConfigurationDSResourceType']//CONFIGURATION/OAISETS";

		String xUpdate = action + newNode + " into " + targetNode;

		return this.execute(xUpdate);

	}

	public boolean deleteOAISet(final String setSpec) throws ISRegistryException {

		String xUpdate =

				"update delete //RESOURCE_PROFILE[.//RESOURCE_TYPE/@value='OAIPublisherConfigurationDSResourceType']//CONFIGURATION//OAISET[spec/text()='"

						+ setSpec + "']";

		return this.execute(xUpdate);

	}

	public boolean updateIndices(final String format, final String layout, final String interpretation, final List<PublisherField> indexes)

			throws ISRegistryException {

		boolean dropped = this.dropIndexesFor(format, layout, interpretation);

		String xUpdateAction = "update insert ";

		String nodeTemplate = " <SOURCE name='" + format + "' layout='" + layout + "' interpretation='" + interpretation + "' ";

		String targetTemplate = "//RESOURCE_PROFILE[.//RESOURCE_TYPE/@value='OAIPublisherConfigurationDSResourceType']//CONFIGURATION/INDICES/INDEX";

		if (!dropped) { return false; }

		for (PublisherField field : indexes) {

			String targetNode = targetTemplate + "[@name='" + field.getFieldName() + "']";

			Collection<String> paths = field.getSources().get(format + "-" + layout + "-" + interpretation);

			for (String p : paths) {

				// insert one SOURCE node at a time, otherwise Exist complaints.

				String node = nodeTemplate + " path=\"" + p + "\" />";

				String xUpdate = xUpdateAction + node + " into " + targetNode;

				boolean done = this.execute(xUpdate);

				if (!done) { return false; }

			}

			// finally let's update the repeatability

			String updateRepeatability = "update value " + targetNode + "/@repeatable with '" + field.isRepeatable() + "'";

			boolean done = this.execute(updateRepeatability);

			if (!done) { return false; }

		}

		return true;

	}

	private boolean dropIndexesFor(final String format, final String layout, final String interpretation) throws ISRegistryException {

		String xUpdate =

				"update delete //RESOURCE_PROFILE[.//RESOURCE_TYPE/@value='OAIPublisherConfigurationDSResourceType']//CONFIGURATION//INDEX/SOURCE[./@interpretation/string()='"

						+ interpretation + "' and ./@name/string()='" + format + "' and ./@layout/string()='" + layout + "'] ";

		return this.execute(xUpdate);

	}

	public boolean addNewIndex(final String format,

			final String layout,

			final String interpretation,

			final String indexName,

			final boolean isRepeatable,

			final String[] paths) throws ISLookUpException, ISRegistryException {

		String action = "update insert ";

		String nodeTemplate = " <SOURCE name='" + format + "' layout='" + layout + "' interpretation='" + interpretation + "' ";

		String targetTemplate = "//RESOURCE_PROFILE[.//RESOURCE_TYPE/@value='OAIPublisherConfigurationDSResourceType']//CONFIGURATION/INDICES";

		if (this.configuration.getFieldNames().contains(indexName)) {

			String targetNode = targetTemplate + "/INDEX[@name/string()='" + indexName + "']";

			for (String p : paths) {

				// insert one SOURCE node at a time, otherwise Exist complaints.

				String node = nodeTemplate + " path=\"" + p + "\" />";

				String xUpdate = action + node + " into " + targetNode;

				boolean done = this.execute(xUpdate);

				if (!done) { return false; }

			}

		} else {

			String targetNode = targetTemplate;

			String node = "<INDEX name='" + indexName + "' repeatable='" + isRepeatable + "'>";

			for (String p : paths) {

				node += nodeTemplate + " path=\"" + p + "\" />";

			}

			node += "</INDEX>";

			String xUpdate = action + node + " into " + targetNode;

			boolean done = this.execute(xUpdate);

			if (!done) { return false; }

		}

		return true;

	}

	public OAIConfigurationReader getConfiguration() {

		return configuration;

	}

	public void setConfiguration(final OAIConfigurationReader configuration) {

		this.configuration = configuration;

	}

}

package eu.dnetlib.data.information.oai.publisher.conf;

import java.util.Collection;

import java.util.List;

import java.util.Map;

import java.util.Set;

import com.google.common.base.Joiner;

import com.google.common.base.Predicate;

import com.google.common.collect.Collections2;

import com.google.common.collect.Sets;

import eu.dnetlib.data.information.oai.publisher.PublisherField;

import eu.dnetlib.data.information.oai.publisher.info.MDFInfo;

import eu.dnetlib.data.information.oai.publisher.info.SetInfo;

/**

 * An instance of this class represents an OAI Configuration profile.

 * 

 * @author alessia

 * 

 */

public class OAIConfiguration {

	/**

	 * Map for OAI sets. Keys: setSpec, values: SetInfo instances.

	 */

	private Map<String, SetInfo> setsMap;

	/**

	 * Map for metadata formats. Keys: metadata prefix, values: MDFInfo instances.

	 */

	private Map<String, MDFInfo> mdFormatsMap;

	private List<PublisherField> fields;

	private List<String> fieldNames;

	/**

	 * Used to generate the OAI identifiers compliant to the protocol. See

	 * http://www.openarchives.org/OAI/openarchivesprotocol.html#UniqueIdentifier. See property services.oai.publisher.id.scheme.

	 */

	private String idScheme;

	/**

	 * Used to generate the OAI identifiers compliant to the protocol. See

	 * http://www.openarchives.org/OAI/openarchivesprotocol.html#UniqueIdentifier. See property services.oai.publisher.id.namespace.

	 */

	private String idNamespace;

	private Set<MDFInfo> sourcesMDF = Sets.newHashSet();

	public Collection<PublisherField> getFieldsFor(final String format, final String layout, final String interpretation) {

		final String mdRef = Joiner.on("-").join(format, layout, interpretation);

		return Collections2.filter(this.getFields(), new Predicate<PublisherField>() {

			@Override

			public boolean apply(final PublisherField theField) {

				if (theField.getSources() == null) return false;

				return theField.getSources().containsKey(mdRef);

			}

		});

	}

	public Map<String, SetInfo> getSetsMap() {

		return setsMap;

	}

	public void setSetsMap(final Map<String, SetInfo> setsMap) {

		this.setsMap = setsMap;

	}

	public Map<String, MDFInfo> getMdFormatsMap() {

		return mdFormatsMap;

	}

	public void setMdFormatsMap(final Map<String, MDFInfo> mdFormatsMap) {

		this.mdFormatsMap = mdFormatsMap;

	}

	public List<PublisherField> getFields() {

		return fields;

	}

	public void setFields(final List<PublisherField> fields) {

		this.fields = fields;

	}

	public List<String> getFieldNames() {

		return fieldNames;

	}

	public void setFieldNames(final List<String> fieldNames) {

		this.fieldNames = fieldNames;

	}

	public Set<MDFInfo> getSourcesMDF() {

		return sourcesMDF;

	}

	public void setSourcesMDF(final Set<MDFInfo> sourcesMDF) {

		this.sourcesMDF = sourcesMDF;

	}

	public String getIdScheme() {

		return idScheme;

	}

	public void setIdScheme(final String idScheme) {

		this.idScheme = idScheme;

	}

	public String getIdNamespace() {

		return idNamespace;

	}

	public void setIdNamespace(final String idNamespace) {

		this.idNamespace = idNamespace;

	}

}

package eu.dnetlib.data.information.oai.publisher.conf;

import java.util.List;

import eu.dnetlib.data.information.oai.publisher.PublisherField;

import eu.dnetlib.data.information.oai.publisher.info.MDFInfo;

import eu.dnetlib.data.information.oai.publisher.info.SetInfo;

public interface OAIConfigurationReader {

	/**

	 * Constant names of fields used by the publisher to store records in the OAIStores. If you want an index over them, you need to specify

	 * it in the OAI Publisher Configuration profile.

	 */

	public final static String ID_FIELD = "objIdentifier";

	public final static String DATESTAMP_FIELD = "datestamp";

	public final static String SET_FIELD = "set";

	public final static String DELETED_FIELD = "deleted";

	public final static String BODY_FIELD = "body";

	public final static String UPDATED_FIELD = "updated";

	public final static String LAST_COLLECTION_DATE_FIELD = "lastCollectionDate";

	public List<SetInfo> getSets();

	public List<SetInfo> getSets(final boolean onlyEnabled);

	public List<String> getSetSpecs();

	public List<String> getSetSpecs(final boolean onlyEnabled);

	public SetInfo getSetInfo(final String setSpec);

	public List<MDFInfo> getMetadataFormatInfo();

	public List<MDFInfo> getMetadataFormatInfo(final boolean onlyEnabled);

	public MDFInfo getMetadataFormatInfo(final String mdPrefix);

	public List<String> getFieldNames();

	public List<PublisherField> getFields();

	public List<PublisherField> getFields(final String format, final String interpretation, final String layout);

	/**

	 * Used to generate the OAI identifiers compliant to the protocol. See

	 * http://www.openarchives.org/OAI/openarchivesprotocol.html#UniqueIdentifier.

	 */

	public String getIdScheme();

	/**

	 * Used to generate the OAI identifiers compliant to the protocol. See

	 * http://www.openarchives.org/OAI/openarchivesprotocol.html#UniqueIdentifier.

	 */

	public String getIdNamespace();

	public List<MDFInfo> getSourceMetadataFormats();

	public List<MDFInfo> getFormatsServedBy(String sourceFormatName, String sourceFormatLayout, String sourceFormatInterpretation);

}

package eu.dnetlib.data.information.oai.publisher.conf;

import java.io.IOException;

import java.io.StringReader;

import java.util.List;

import java.util.Map;

import javax.xml.stream.XMLInputFactory;

import javax.xml.stream.XMLStreamConstants;

import javax.xml.stream.XMLStreamException;

import javax.xml.stream.XMLStreamReader;

import javax.xml.transform.stream.StreamSource;

import org.apache.commons.logging.Log;

import org.apache.commons.logging.LogFactory;

import com.google.common.collect.ArrayListMultimap;

import com.google.common.collect.Lists;

import com.google.common.collect.Maps;

import com.google.common.collect.Multimap;

import eu.dnetlib.data.information.oai.publisher.OaiPublisherRuntimeException;

import eu.dnetlib.data.information.oai.publisher.PublisherField;

import eu.dnetlib.data.information.oai.publisher.info.MDFInfo;

import eu.dnetlib.data.information.oai.publisher.info.SetInfo;

/**

 * Parses an XML document representing the OAI configuration profile and creates the corresponding OAIConfiguration object.

 * 

 * @author alessia

 * 

 */

public class OAIConfigurationParser {

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

	private final ThreadLocal<XMLInputFactory> factory = new ThreadLocal<XMLInputFactory>() {

		@Override

		protected XMLInputFactory initialValue() {

			return XMLInputFactory.newInstance();

		}

	};

	public OAIConfiguration getConfiguration(final String configurationProfile) throws IOException {

		log.debug(configurationProfile);

		OAIConfiguration config = new OAIConfiguration();

		Map<String, SetInfo> setsMap = Maps.newHashMap();

		Map<String, MDFInfo> mdFormatsMap = Maps.newHashMap();

		List<String> indexNames = Lists.newArrayList();

		List<PublisherField> fields = Lists.newArrayList();

		try {

			final XMLStreamReader parser = factory.get().createXMLStreamReader(new StreamSource(new StringReader(configurationProfile)));

			while (parser.hasNext()) {

				int event = parser.next();

				if (event == XMLStreamConstants.START_ELEMENT) {

					final String localName = parser.getLocalName();

					if (localName.equals("IDSCHEME")) {

						config.setIdScheme(parser.getElementText());

					} else if (localName.equals("IDNAMESPACE")) {

						config.setIdNamespace(parser.getElementText());

					} else if (localName.equals("OAISET")) {

						boolean inSet = true;

						SetInfo setInfo = new SetInfo();

						String enabled = parser.getAttributeValue(null, "enabled");

						setInfo.setEnabled(Boolean.parseBoolean(enabled));

						while (parser.hasNext() && inSet) {

							event = parser.next();

							if (event == XMLStreamConstants.START_ELEMENT) {

								String setElementName = parser.getLocalName();

								String setElementValue = parser.getElementText();

								this.handleSetInfo(setInfo, setElementName, setElementValue);

							}

							if ((event == XMLStreamConstants.END_ELEMENT) && parser.getLocalName().equals("OAISET")) {

								inSet = false;

								setsMap.put(setInfo.getSetSpec(), setInfo);

							}

						}

					} else {

						if (localName.equals("METADATAFORMAT")) {

							boolean inMetadata = true;

							MDFInfo mdfInfo = new MDFInfo();

							String exportable = parser.getAttributeValue(null, "exportable");

							mdfInfo.setEnabled(Boolean.parseBoolean(exportable));

							String mdPrefix = parser.getAttributeValue(null, "metadataPrefix");

							mdfInfo.setPrefix(mdPrefix);

							while (parser.hasNext() && inMetadata) {

								event = parser.next();

								if (event == XMLStreamConstants.START_ELEMENT) {

									String mdfElementName = parser.getLocalName();

									if (mdfElementName.equals("SOURCE_METADATA_FORMAT")) {

										this.handleSourceMDF(mdfInfo, parser);

										config.getSourcesMDF().add(mdfInfo);

									} else {

										String mdfElementValue = parser.getElementText();

										this.handleMDFInfo(mdfInfo, mdfElementName, mdfElementValue);

									}

								}

								if ((event == XMLStreamConstants.END_ELEMENT) && parser.getLocalName().equals("METADATAFORMAT")) {

									inMetadata = false;

									mdFormatsMap.put(mdPrefix, mdfInfo);

								}

							}

						} else {

							// INDICES

							if (localName.equals("INDEX")) {

								boolean inIndex = true;

								PublisherField publisherField = new PublisherField();

								String indexName = parser.getAttributeValue(null, "name");

								String repeatable = parser.getAttributeValue(null, "repeatable");

								boolean isRepeatable = Boolean.valueOf(repeatable);

								indexNames.add(indexName);

								publisherField.setFieldName(indexName);

								publisherField.setRepeatable(isRepeatable);

								// now let's set the SOURCES

								Multimap<String, String> fieldSources = ArrayListMultimap.create();

								while (parser.hasNext() && inIndex) {

									event = parser.next();

									if (event == XMLStreamConstants.START_ELEMENT) {

										String currentElementName = parser.getLocalName();

										this.handleIndex(fieldSources, indexName, parser, currentElementName);

									}

									if ((event == XMLStreamConstants.END_ELEMENT) && parser.getLocalName().equals("INDEX")) {

										inIndex = false;

									}

								}

								publisherField.setSources(fieldSources);

								fields.add(publisherField);

							}

						}

					}

				}

			}

			config.setFields(fields);

			config.setFieldNames(indexNames);

			config.setMdFormatsMap(mdFormatsMap);

			config.setSetsMap(setsMap);

			return config;

		} catch (final XMLStreamException e) {

			throw new OaiPublisherRuntimeException(e);

		}

	}

	/**

	 * Sets information about the indices.

	 * 

	 * @param fieldSources

	 * @param indexName

	 * @param parser

	 * @param currentLocalName

	 */

	private void handleIndex(final Multimap<String, String> fieldSources, final String indexName, final XMLStreamReader parser, final String currentLocalName) {

		if (currentLocalName.equals("SOURCE")) {

			MDFInfo indexSource = new MDFInfo();

			this.handleSourceMDF(indexSource, parser);

			String key = indexSource.getSourceFormatName() + "-" + indexSource.getSourceFormatLayout() + "-" + indexSource.getSourceFormatInterpretation();

			fieldSources.put(key, parser.getAttributeValue(null, "path"));

		} else {

			log.warn("I do not know how to handle INDEX element with name " + currentLocalName);

		}

	}

	/**

	 * Sets information about the source metadata format in the given instance of MDFInfo.

	 * 

	 * @param mdfInfo

	 * @param parser

	 */

	private void handleSourceMDF(final MDFInfo mdfInfo, final XMLStreamReader parser) {

		String interpretation = parser.getAttributeValue(null, "interpretation");

		String layout = parser.getAttributeValue(null, "layout");

		String name = parser.getAttributeValue(null, "name");

		mdfInfo.setSourceFormatInterpretation(interpretation);

		mdfInfo.setSourceFormatLayout(layout);

		mdfInfo.setSourceFormatName(name);

	}

	/**

	 * Sets information in the MDFInfo instance based on the element name.

	 * 

	 * @param mdfInfo

	 * @param mdfElementName

	 * @param mdfElementValue

	 */

	private void handleMDFInfo(final MDFInfo mdfInfo, final String elementName, final String elementValue) {

		if (elementName.equals("NAMESPACE")) {

			mdfInfo.setNamespace(elementValue);

		} else {

			if (elementName.equals("SCHEMA")) {

				mdfInfo.setSchema(elementValue);

			} else {

				if (elementName.equals("TRANSFORMATION_RULE")) {

					mdfInfo.setTransformationRuleID(elementValue);

				} else {

					if (elementName.equals("BASE_QUERY")) {

						mdfInfo.setBaseQuery(elementValue);

					} else {

						log.warn("I do not know how to handle Metadata Format element with name " + elementName + " and value " + elementValue);

					}

				}

			}

		}

	}

	/**

	 * Sets information in the SetInfo instance based on the element name.

	 * 

	 * @param setInfo

	 * @param elementName

	 * @param elementValue

	 */

	private void handleSetInfo(final SetInfo setInfo, final String elementName, final String elementValue) {

		if (elementName.equals("spec")) {

			setInfo.setSetSpec(elementValue);

		} else {

			if (elementName.equals("name")) {

				setInfo.setSetName(elementValue);

			} else {

				if (elementName.equals("description")) {

					setInfo.setSetDescription(elementValue);

				} else {

					if (elementName.equals("query")) {

						setInfo.setQuery(elementValue);

					} else {

						log.warn("I do not know how to handle Set element with name " + elementName + " and value " + elementValue);

					}

				}

			}

		}

	}

}

package eu.dnetlib.data.information.oai.publisher.info;

import java.util.List;

import org.apache.commons.lang.StringEscapeUtils;

import org.apache.commons.lang.StringUtils;

import com.google.common.collect.Lists;

import eu.dnetlib.data.information.oai.publisher.BadResumptionTokenException;

public class ResumptionTokenImpl implements ResumptionToken {