/ - Diff - D-Net - D-Net project tracking tool

     package eu.dnetlib.openaire.directindex.api;
     import eu.dnetlib.functionality.index.utils.ZkServers;
     import org.apache.commons.logging.Log;
     import org.apache.commons.logging.LogFactory;
     import org.apache.solr.client.solrj.impl.CloudSolrClient;
     public class IndexClientManager {
         private static final Log log = LogFactory.getLog(IndexClientManager.class);
         private CloudSolrClient client = null;
         public CloudSolrClient getClient(IndexDsInfo info) {
             if (client == null) {
                 log.info(String.format("Initializing solr client (%s) with collection %s", info.getIndexBaseUrl(), info.getColl()));
                 ZkServers zk = ZkServers.newInstance(info.getIndexBaseUrl());
                 CloudSolrClient.Builder builder = new CloudSolrClient.Builder(zk.getHosts(), zk.getChroot()).withParallelUpdates(true);
                 client = builder.build();
+            }
             client.setDefaultCollection(info.getColl());
             return client;
+        }
+    }

     package eu.dnetlib.openaire.directindex.api;
     import org.apache.commons.logging.Log;
     import org.apache.commons.logging.LogFactory;
     import org.apache.solr.client.solrj.impl.CloudSolrClient;
     import org.springframework.beans.factory.annotation.Autowired;
     import org.springframework.beans.factory.annotation.Value;
     import javax.annotation.Resource;
     import java.util.concurrent.Executors;
     import java.util.concurrent.ScheduledExecutorService;
     import java.util.concurrent.TimeUnit;
     public class ResultSubmitterService {
         private static final Log log = LogFactory.getLog(ResultSubmitterService.class);
         @Autowired
         private IndexDSRetriever indexDSRetriever;
         @Resource(name = "indexClientManager")
         private IndexClientManager clientManager;
         /**
          * Autocommit feature activation flag
          */
         @Value(value = "${openaire.api.directindex.autocommit.active}")
         private boolean autocommitactive;
         /**
          * Autocommit frequency (Seconds)
          */
         @Value(value = "${openaire.api.directindex.autocommit.frequency}")
         private long commitfrquency = 60;
         private ScheduledExecutorService executor;
         public ResultSubmitterService() {
             executor = Executors.newSingleThreadScheduledExecutor();
             updateCommitSchedule();
+        }
         private void updateCommitSchedule() {
             log.info("updating commit schedule");
             executor.scheduleAtFixedRate(() -> {
                 if (isAutocommitactive()) {
                     try {
                         IndexDsInfo info = indexDSRetriever.calculateCurrentIndexDsInfo();
                         CloudSolrClient client = clientManager.getClient(info);
                         log.info("performing commit on " + info.getColl());
                         client.commit();
                     } catch (Throwable e) {
                         log.error("unable to perform commit", e);
+                    }
+                }
             }, 0, getCommitfrquency(), TimeUnit.SECONDS);
+        }
         public boolean isAutocommitactive() {
             return autocommitactive;
+        }
         public synchronized void setAutocommitactive(boolean autocommitactive) {
             this.autocommitactive = autocommitactive;
+        }
         public long getCommitfrquency() {
             return commitfrquency;
+        }
         public synchronized void setCommitfrquency(long commitfrquency) {
             this.commitfrquency = commitfrquency;
+        }
+    }

     package eu.dnetlib.openaire.directindex.api;
     import eu.dnetlib.common.rmi.RMIException;
     public class DirecIndexApiException extends RMIException {
     	/**
+    	 *
     	 */
     	private static final long serialVersionUID = -3888037031334809448L;
     	public DirecIndexApiException(final String string) {
     		super(string);
+    	}
     	public DirecIndexApiException(final String string, final Throwable exception) {
     		super(string, exception);
+    	}
     	public DirecIndexApiException(final Throwable exception) {
     		super(exception);
+    	}
+    }

     package eu.dnetlib.openaire.directindex.objects;
     import java.io.Serializable;
     public class DsmSearchRequest implements Serializable {
     	private static final long serialVersionUID = -2532361140043817319L;
     	private String id;
     	public DsmSearchRequest() {}
     	public DsmSearchRequest(final String id) {
     		this.id = id;
+    	}
     	public String getId() {
     		return id;
+    	}
     	public void setId(final String id) {
     		this.id = id;
+    	}
+    }

     package eu.dnetlib.openaire.directindex.objects;
     import com.google.gson.Gson;
     import eu.dnetlib.enabling.is.lookup.rmi.ISLookUpException;
     import eu.dnetlib.enabling.is.lookup.rmi.ISLookUpService;
     import eu.dnetlib.miscutils.datetime.DateUtils;
     import eu.dnetlib.miscutils.functional.hash.Hashing;
     import eu.dnetlib.miscutils.functional.string.EscapeXml;
     import eu.dnetlib.openaire.directindex.api.DirecIndexApiException;
     import eu.dnetlib.openaire.directindex.api.OpenAIRESubmitterUtils;
     import io.swagger.annotations.ApiModelProperty;
     import org.apache.commons.lang.StringUtils;
     import org.apache.commons.logging.Log;
     import org.apache.commons.logging.LogFactory;
     import org.apache.velocity.app.VelocityEngine;
     import org.springframework.ui.velocity.VelocityEngineUtils;
     import java.text.SimpleDateFormat;
     import java.util.*;
     import java.util.concurrent.TimeUnit;
     /**
      * Created by michele on 02/12/15.
      */
     public class ResultEntry {
     	private String openaireId;
     	private String originalId;
     	private String title;
     	private List<String> authors = new ArrayList<>();
     	private String publisher;
     	private String description;
     	private String language;
     	private List<PidEntry> pids = new ArrayList<>();
     	/**
     	 * @Deprecated: use accessRightCode
     	 */
     	@Deprecated
     	private String licenseCode;
     	private String accessRightCode;
     	private String embargoEndDate;
     	/**
     	 * One of publication, dataset, software, other. Default value is publication.
     	 */
     	private String type = "publication";
     	private String resourceType;
     	private String url;
     	private String collectedFromId;
     	private String hostedById;
     	// String according to the EGI context profile, example: egi::classification::natsc::math
     	private List<String> contexts = new ArrayList<>();
     	// String according to openaire guidelines:
     	// info:eu-repo/grantAgreement/Funder/FundingProgram/ProjectID/[Jurisdiction]/[ProjectName]/[ProjectAcronym]
     	private List<String> linksToProjects = new ArrayList<>();
     	private static final Log log = LogFactory.getLog(ResultEntry.class);
     	public ResultEntry() {}
     	public String getOpenaireId() {
     		return openaireId;
+    	}
     	public void setOpenaireId(final String openaireId) {
     		this.openaireId = openaireId;
+    	}
     	public String getOriginalId() {
     		return originalId;
+    	}
     	public void setOriginalId(final String originalId) {
     		this.originalId = originalId;
+    	}
     	@ApiModelProperty(required = true)
     	public String getTitle() {
     		return title;
+    	}
     	public void setTitle(final String title) {
     		this.title = title;
+    	}
     	public List<String> getAuthors() {
     		return authors;
+    	}
     	public void setAuthors(final List<String> authors) {
     		this.authors = authors;
+    	}
     	public String getPublisher() {
     		return publisher;
+    	}
     	public void setPublisher(final String publisher) {
     		this.publisher = publisher;
+    	}
     	public String getDescription() {
     		return description;
+    	}
     	public void setDescription(final String description) {
     		this.description = description;
+    	}
     	@ApiModelProperty(value = "ISO Alpha-3 code. E.g. 'eng', 'ita'")
     	public String getLanguage() {
     		return language;
+    	}
     	public void setLanguage(final String language) {
     		this.language = language;
+    	}
     	public List<PidEntry> getPids() {
     		return pids;
+    	}
     	public void setPids(final List<PidEntry> pids) {
     		this.pids = pids;
+    	}
     	@Deprecated
     	@ApiModelProperty(required = false, allowableValues = "OPEN, CLOSED, RESTRICTED, EMBARGO, UNKNOWN, OTHER, OPEN SOURCE")
     	public String getLicenseCode() {
     		return licenseCode;
+    	}
     	@Deprecated
     	public void setLicenseCode(final String licenseCode) {
     		this.licenseCode = licenseCode;
+    	}
     	/**
     	 * Set required = true when the deprecated licenseCode is not used anymore by our client and it is removed
     	 * @return access rights code
     	 */
     	@ApiModelProperty(required = false, allowableValues = "OPEN, CLOSED, RESTRICTED, EMBARGO, UNKNOWN, OTHER, OPEN SOURCE")
     	public String getAccessRightCode() {
     		return accessRightCode;
+    	}
     	public void setAccessRightCode(final String accessRightCode) {
     		this.accessRightCode = accessRightCode;
+    	}
     	@ApiModelProperty(required = true, value = "Use 001 for articles, 021 for datasets, 0029 for software. See: http://api.openaire.eu/vocabularies/dnet:publication_resource for all the available resource types.")
     	public String getResourceType() {
     		return resourceType;
+    	}
     	public void setResourceType(final String resourceType) {
     		this.resourceType = resourceType;
+    	}
     	@ApiModelProperty(required = true)
     	public String getUrl() {
     		return url;
+    	}
     	public void setUrl(final String url) {
     		this.url = url;
+    	}
     	@ApiModelProperty(required = true, value = "Use opendoar___::2659 for Zenodo Publications; re3data_____::r3d100010468 for Zenodo datasets; infrastruct::openaire for OpenAIRE portal.")
     	public String getCollectedFromId() {
     		return collectedFromId;
+    	}
     	public void setCollectedFromId(final String collectedFromId) {
     		this.collectedFromId = collectedFromId;
+    	}
     	public String getHostedById() {
     		return hostedById;
+    	}
     	public void setHostedById(final String hostedById) {
     		this.hostedById = hostedById;
+    	}
     	@ApiModelProperty(value = "E.g. fet, egi::classification::natsc::math::pure, egi::projects::EMI")
     	public List<String> getContexts() {
     		return contexts;
+    	}
     	public void setContexts(final List<String> contexts) {
     		this.contexts = contexts;
+    	}
     	@ApiModelProperty(value = "E.g. info:eu-repo/grantAgreement/EC/FP7/283595/EU//OpenAIREplus")
     	public List<String> getLinksToProjects() {
     		return linksToProjects;
+    	}
     	public void setLinksToProjects(final List<String> linksToProjects) {
     		this.linksToProjects = linksToProjects;
+    	}
     	@ApiModelProperty(allowableValues = "publication, dataset, software, other")
     	public String getType() {
     		return type;
+    	}
     	public void setType(final String type) {
     		this.type = type;
+    	}
     	public String getEmbargoEndDate() {
     		return embargoEndDate;
+    	}
     	public void setEmbargoEndDate(final String embargoEndDate) {
     		this.embargoEndDate = embargoEndDate;
+    	}
     	@Override
     	public String toString() {
     		return new Gson().toJson(this);
+    	}
     	public String getAnyId() {
     		return StringUtils.isNotBlank(openaireId) ? openaireId : originalId;
+    	}
+    }

     package eu.dnetlib.openaire.directindex.objects;
     import io.swagger.annotations.ApiModelProperty;
     /**
      * Created by michele on 02/12/15.
      */
     public class PidEntry {
     	private String type;
     	private String value;
     	public PidEntry() {
+    	}
     	public PidEntry(final String type, final String value) {
     		this.type = type;
     		this.value = value;
+    	}
     	@ApiModelProperty(required = true, value = "E.g. doi, pmc, urn. See http://api.openaire.eu/vocabularies/dnet:pid_types")
     	public String getType() {
     		return type;
+    	}
     	public void setType(final String type) {
     		this.type = type;
+    	}
     	@ApiModelProperty(required = true)
     	public String getValue() {
     		return value;
+    	}
     	public void setValue(final String value) {
     		this.value = value;
+    	}
+    }

     package eu.dnetlib.openaire.directindex.objects;
     import java.text.SimpleDateFormat;
     import java.util.Date;
     import java.util.HashMap;
     import java.util.List;
     import java.util.Map;
     import java.util.concurrent.TimeUnit;
     import org.apache.commons.lang.StringUtils;
     import org.apache.commons.logging.Log;
     import org.apache.commons.logging.LogFactory;
     import org.apache.velocity.app.VelocityEngine;
     import org.springframework.ui.velocity.VelocityEngineUtils;
     import eu.dnetlib.enabling.is.lookup.rmi.ISLookUpException;
     import eu.dnetlib.enabling.is.lookup.rmi.ISLookUpService;
     import eu.dnetlib.miscutils.datetime.DateUtils;
     import eu.dnetlib.miscutils.functional.hash.Hashing;
     import eu.dnetlib.miscutils.functional.string.EscapeXml;
     import eu.dnetlib.openaire.directindex.api.DirecIndexApiException;
     import eu.dnetlib.openaire.directindex.api.OpenAIRESubmitterUtils;
     public class ResultEntryToOaf {
     	private static final Log log = LogFactory.getLog(ResultEntryToOaf.class);
     	private static long last_cache_update = 0;
     	private static final Map<String, Map<String, String>> cached_vocabularies = new HashMap<>();
     	private static final Map<String, DatasourceEntry> cached_datasources = new HashMap<>();
     	private static final Map<String, String> cached_contexts = new HashMap<>();
     	private OpenAIRESubmitterUtils utils;
     	public ResultEntryToOaf(final OpenAIRESubmitterUtils utils) {
     		this.utils = utils;
+    	}
     	public String asOafRecord(final ResultEntry entry,
     		final VelocityEngine ve,
     		final ISLookUpService lookupService,
     		final String oafSchemaLocation) throws Exception {
     		if (StringUtils.isBlank(entry.getOriginalId())
     			&& StringUtils
     				.isBlank(entry.getOpenaireId())) {
     			throw new DirecIndexApiException("One of the following fields is required: originalId or openaireId");
+    		}
     		if (StringUtils.isBlank(entry.getTitle())) { throw new DirecIndexApiException("A required field is missing: title"); }
     		if (StringUtils.isBlank(entry.getUrl())) { throw new DirecIndexApiException("A required field is missing: url"); }
     		if (StringUtils.isBlank(entry.getLicenseCode()) && StringUtils.isBlank(entry.getAccessRightCode())) {
     			throw new DirecIndexApiException("A required field is missing: accessRightCode");
+    		}
     		if (StringUtils.isBlank(entry.getResourceType())) { throw new DirecIndexApiException("A required field is missing: resourceType"); }
     		if (StringUtils.isBlank(entry.getCollectedFromId())) { throw new DirecIndexApiException("A required field is missing: collectedFromId"); }
     		if (StringUtils.isBlank(entry.getType())) { throw new DirecIndexApiException("A required field is missing: type"); }
     		final DatasourceEntry collectedFromEntry = getDatasourceInfo(entry.getCollectedFromId(), utils);
     		final DatasourceEntry hostedByEntry = getDatasourceInfo(entry.getHostedById(), utils);
     		if (StringUtils.isBlank(entry.getOpenaireId())) {
     			entry.setOpenaireId(calculateOpenaireId(entry.getOriginalId(), collectedFromEntry));
+    		}
     		if (!entry.getOpenaireId()
     			.matches("^\\w{12}::\\w{32}$")) {
     			throw new DirecIndexApiException(
     				"Invalid openaireId: " + entry.getOpenaireId() + " - regex ^\\w{12}::\\w{32}$ not matched");
+    		}
     		final List<OpenAIRESubmitterUtils.ContextInfo> contextInfos = utils.processContexts(entry.getContexts(), getContexts(lookupService));
     		final Map<String, Object> model = new HashMap<>();
     		model.put("esc", new EscapeXml());
     		model.put("util", utils);
     		model.put("pub", entry);
     		model.put("objIdentifier", entry.getOpenaireId());
     		model.put("oafSchemaLocation", oafSchemaLocation);
     		model.put("resultTypes", getVocabulary("dnet:result_typologies", lookupService));
     		model.put("rights", getVocabulary("dnet:access_modes", lookupService));
     		model.put("resourceTypes", getVocabulary("dnet:publication_resource", lookupService));
     		model.put("pidTypes", getVocabulary("dnet:pid_types", lookupService));
     		model.put("languages", getVocabulary("dnet:languages", lookupService));
     		model.put("contexts", getContexts(lookupService));
     		model.put("contextInfo", contextInfos);
     		model.put("dateOfCollection", new SimpleDateFormat("yyyy-MM-dd\'T\'hh:mm:ss\'Z\'").format(new Date()));
     		model.put("collectedFrom", collectedFromEntry);
     		model.put("hostedBy", hostedByEntry);
     		return VelocityEngineUtils.mergeTemplateIntoString(ve, "/eu/dnetlib/openaire/directindex/indexRecord.xml.vm", "UTF-8", model);
+    	}
     	private synchronized static DatasourceEntry getDatasourceInfo(final String dsId, final OpenAIRESubmitterUtils utils) throws ISLookUpException {
     		if (StringUtils
     			.isBlank(dsId)) {
     			return new DatasourceEntry("openaire____::1256f046-bf1f-4afc-8b47-d0b147148b18", "Unknown Repository", "unknown_____");
+    		}
     		if (!cached_datasources.containsKey(dsId)) {
     			final DatasourceEntry ds = utils.findDatasource(dsId);
     			if (ds == null || StringUtils.isBlank(ds.getName()) || StringUtils.isBlank(ds.getPrefix())) {
     				log.error("Invalid datasource id: " + dsId);
     				throw new ISLookUpException("Invalid datasource id: " + dsId);
     			} else {
     				cached_datasources.put(dsId, ds);
+    			}
+    		}
     		return cached_datasources.get(dsId);
+    	}
     	private synchronized static Map<String, String> getVocabulary(final String voc, final ISLookUpService lookupService) throws ISLookUpException {
     		if (DateUtils.now() - last_cache_update < TimeUnit.MINUTES.toMillis(15) && cached_vocabularies.containsKey(voc)) {
     			return cached_vocabularies.get(voc);
     		} else {
     			final String query = "collection('/db/DRIVER/VocabularyDSResources/VocabularyDSResourceType')[.//VOCABULARY_NAME/@code='" + voc
     				+ "']//TERM/concat(@code, ' @@@ ', @english_name)";
     			final Map<String, String> map = new HashMap<>();
     			for (final String s : lookupService.quickSearchProfile(query)) {
     				final String[] arr = s.split("@@@");
     				map.put(arr[0].trim(), arr[1].trim());
+    			}
     			cached_vocabularies.put(voc, map);
     			last_cache_update = DateUtils.now();
     			return map;
+    		}
+    	}
     	private synchronized static Map<String, String> getContexts(final ISLookUpService lookupService) throws ISLookUpException {
     		if (DateUtils.now() - last_cache_update > TimeUnit.MINUTES.toMillis(15) || cached_contexts.isEmpty()) {
     			final String query =
     				"collection('/db/DRIVER/ContextDSResources/ContextDSResourceType')[.//context/@type='community' or .//context/@type='ri']//*[name()='context' or name()='category' or name()='concept']/concat(@id, ' @@@ ', @label)";
     			cached_contexts.clear();
     			for (final String s : lookupService.quickSearchProfile(query)) {
     				final String[] arr = s.split("@@@");
     				cached_contexts.put(arr[0].trim(), arr[1].trim());
+    			}
     			last_cache_update = DateUtils.now();
+    		}
     		return cached_contexts;
+    	}
     	private static String calculateOpenaireId(final String originalId, final DatasourceEntry collectedFromEntry) {
     		return collectedFromEntry.getPrefix() + "::" + Hashing.md5(originalId);
+    	}
     	public static String calculateOpenaireId(final String originalId, final String collectedFromId, final OpenAIRESubmitterUtils utils)
     		throws ISLookUpException {
     		return calculateOpenaireId(originalId, getDatasourceInfo(collectedFromId, utils));
+    	}
     	public OpenAIRESubmitterUtils getUtils() {
     		return utils;
+    	}
     	public void setUtils(final OpenAIRESubmitterUtils utils) {
     		this.utils = utils;
+    	}
+    }

     <?xml version="1.0" ?>
     <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>
     	<groupId>eu.dnetlib</groupId>
     	<artifactId>dnet-directindex-api</artifactId>
     	<packaging>jar</packaging>
     	<version>3.0.1</version>
     	<scm>
     		<developerConnection>scm:svn:https://svn.driver.research-infrastructures.eu/driver/dnet45/modules/dnet-directindex-api/tags/dnet-directindex-api-3.0.1</developerConnection>
     	</scm>
     	<dependencies>
     		<dependency>
     			<groupId>eu.dnetlib</groupId>
     			<artifactId>dnet-openaireplus-mapping-utils</artifactId>
     			<version>[7.0.0,8.0.0)</version>
     			<exclusions>
     				<exclusion>
     					<groupId>eu.dnetlib</groupId>
     					<artifactId>dnet-hadoop-commons</artifactId>
     				</exclusion>
     			</exclusions>
     		</dependency>
     		<dependency>
     			<groupId>eu.dnetlib</groupId>
     			<artifactId>dnet-index-client</artifactId>
     			<version>[3.0.0,4.0.0)</version>
     		</dependency>
     		<dependency>
     			<groupId>junit</groupId>
     			<artifactId>junit</artifactId>
     			<version>${junit.version}</version>
     			<scope>test</scope>
     		</dependency>
     		<dependency>
     			<groupId>io.springfox</groupId>
     			<artifactId>springfox-swagger2</artifactId>
     			<version>${springfox-version}</version>
     		</dependency>
     		<dependency>
     			<groupId>org.mockito</groupId>
     			<artifactId>mockito-core</artifactId>
     			<version>1.9.5</version>
     		</dependency>
     		<dependency>
     			<groupId>org.apache.velocity</groupId>
     			<artifactId>velocity</artifactId>
     			<version>1.7</version>
     			<exclusions>
     				<exclusion>
     					<artifactId>antlr</artifactId>
     					<groupId>antlr</groupId>
     				</exclusion>
     			</exclusions>
     		</dependency>
     		<dependency>
     			<groupId>org.apache.velocity</groupId>
     			<artifactId>velocity-tools</artifactId>
     			<version>2.0</version>
     			<exclusions>
     				<exclusion>
     					<artifactId>antlr</artifactId>
     					<groupId>antlr</groupId>
     				</exclusion>
     			</exclusions>
     		</dependency>
     		<dependency>
     			<groupId>org.springframework</groupId>
     			<artifactId>spring-context-support</artifactId>
     			<version>${spring.version}</version>
     		</dependency>
     		<dependency>
     			<groupId>com.fasterxml.jackson.core</groupId>
     			<artifactId>jackson-annotations</artifactId>
     			<version>2.9.4</version>
     		</dependency>
         </dependencies>
     	<properties>
     		<springfox-version>2.5.0</springfox-version>
     	</properties>
     </project>

     package eu.dnetlib.openaire.directindex.objects;
     import eu.dnetlib.miscutils.functional.hash.Hashing;
     import org.apache.commons.lang.StringUtils;
     /**
      * Created by michele on 02/12/15.
      */
     public class DatasourceEntry {
     	private String id;
     	private String name;
     	private String prefix;
     	public DatasourceEntry() {
+    	}
     	public DatasourceEntry(final String id, final String name, final String prefix) {
     		this.id = id;
     		this.name = name;
     		this.prefix = prefix;
+    	}
     	public String getId() {
     		return id;
+    	}
     	public void setId(final String id) {
     		this.id = id;
+    	}
     	public String getName() {
     		return name;
+    	}
     	public void setName(final String name) {
     		this.name = name;
+    	}
     	public String getPrefix() {
     		return prefix;
+    	}
     	public void setPrefix(final String prefix) {
     		this.prefix = prefix;
+    	}
     	public String calculateOpenaireId() {
     		if (StringUtils.isNotBlank(id)) {
     			final String[] arr = id.split("::");
     			if (arr.length == 2) {
     				return String.format("%s::%s", arr[0], Hashing.md5(arr[1]));
+    			}
+    		}
     		return "";
+    	}
+    }

     openaire.api.directindex.mongo.host=localhost
     openaire.api.directindex.mongo.port=27017
     openaire.api.directindex.mongo.db=openaireplus_apis
     openaire.api.directindex.mongo.collection=recent_publications
     openaire.api.directindex.layoutToRecord.xslt=/eu/dnetlib/msro/openaireplus/workflows/index/openaireLayoutToRecordStylesheet.xsl
     openaire.api.directindex.findSolrIndexUrl.xquery=/eu/dnetlib/openaire/directindex/findSolrIndexUrl.xquery
     openaire.api.directindex.findIndexDsInfo.xquery=/eu/dnetlib/openaire/directindex/findIndexDsInfo.xquery
     openaire.api.directindex.autocommit.active=true
     openaire.api.directindex.autocommit.frequency=6
     openaire.api.community=http://${container.hostname}/openaire/community/
     openaire.api.dsm=http://${container.hostname}/openaire/ds/

     <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" /> -->
     <!-- Expires once in a day -->
     	<cache name="indexDsInfo" maxElementsInMemory="5" eternal="false"
     		timeToIdleSeconds="86400" timeToLiveSeconds="86400" 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.openaire.directindex.utils;
     import com.fasterxml.jackson.databind.ObjectMapper;
     import com.fasterxml.jackson.databind.ObjectWriter;
     import com.google.common.collect.Maps;
     import eu.dnetlib.functionality.index.solr.feed.StreamingInputDocumentFactory;
     import eu.dnetlib.miscutils.datetime.DateUtils;
     import eu.dnetlib.miscutils.functional.xml.ApplyXslt;
     import org.apache.commons.io.IOUtils;
     import org.apache.solr.common.SolrInputDocument;
     import org.junit.Test;
     import org.springframework.core.io.ClassPathResource;
     import javax.xml.stream.XMLStreamException;
     import javax.xml.transform.Transformer;
     import javax.xml.transform.TransformerException;
     import javax.xml.transform.TransformerFactory;
     import javax.xml.transform.stream.StreamResult;
     import javax.xml.transform.stream.StreamSource;
     import java.io.IOException;
     import java.io.InputStream;
     import java.io.StringReader;
     import java.io.StringWriter;
     import java.text.SimpleDateFormat;
     import java.util.Map;
     import static org.junit.Assert.assertFalse;
     import static org.junit.Assert.assertNotNull;
     public class OpenaireLayoutToRecordStylesheetTest {
     	private static final String OPENAIRE_LAYOUT_TO_RECORD_STYLESHEET_XSL = "eu/dnetlib/openaire/directindex/utils/openaireLayoutToRecordStylesheet.xsl";
     	private static final String MDFORMAT_FIELDS_PROFILE = "eu/dnetlib/openaire/directindex/utils/2-8b9503d9-8a86-4330-93ef-7e0cd9bc87c2.xml";
     	private static final String OAF_RECORD = "eu/dnetlib/openaire/directindex/utils/oafRecord.xml";
     	@Test
     	public void directIndexOafToIndexTest() throws IOException, TransformerException, XMLStreamException {
     		final Transformer layoutTransformer = TransformerFactory.newInstance().newTransformer(streamSource(OPENAIRE_LAYOUT_TO_RECORD_STYLESHEET_XSL));
     		final StreamResult layoutToXsltXslt = new StreamResult(new StringWriter());
     		layoutTransformer.setParameter("format", "DMF");
     		layoutTransformer.transform(new StreamSource(new StringReader(getLayoutSource("DMF"))), layoutToXsltXslt);
     		String xslt2xslt = layoutToXsltXslt.getWriter().toString();
     		//System.out.println(xslt2xslt);
     		ApplyXslt applyXslt = new ApplyXslt(xslt2xslt);
     		String indexRecord = applyXslt.evaluate(readFromClasspath(OAF_RECORD));
     		//System.out.println(indexRecord);
     		StreamingInputDocumentFactory factory = new StreamingInputDocumentFactory();
     		SolrInputDocument doc = factory.parseDocument(DateUtils.now_ISO8601(), indexRecord, "dsId", "dnetResult");
     		assertNotNull(doc);
     		assertFalse(doc.isEmpty());
     		assertFalse(doc.containsKey("__dsid"));
     		assertFalse(doc.containsKey("__dsversion"));
     		assertFalse(doc.containsKey("__deleted"));
     		System.out.println("SolrDocument");
     		System.out.println(doc.values());
     		System.out.println("SolrDocument fields");
     		Map<String, Object> fields = Maps.newHashMap();
     		doc.entrySet().stream()
     				.forEach(e -> {
     					Object value = e.getValue().getValueCount() == 1 ? e.getValue().getFirstValue() : e.getValue().getValues();
     					fields.put(e.getKey(), value);
     				});
     		final ObjectWriter objectWriter = new ObjectMapper()
     				.setDateFormat(new SimpleDateFormat("yyyy-MM-dd'T'HH:mm:ss.SSS'Z'"))
     				.writerWithDefaultPrettyPrinter();
     		System.out.println(objectWriter.writeValueAsString(fields));
+    	}
     	private String getLayoutSource(final String format) throws IOException {
     		return readFromClasspath(MDFORMAT_FIELDS_PROFILE);
+    	}
     	private StreamSource streamSource(final String s) throws IOException {
     		return new StreamSource(new StringReader(readFromClasspath(s)));
+    	}
     	private String readFromClasspath(final String s) throws IOException {
     		ClassPathResource resource = new ClassPathResource(s);
     		InputStream inputStream = resource.getInputStream();
     		return IOUtils.toString(inputStream);
+    	}
+    }

     distinct-values(for $s in collection('/db/DRIVER/ServiceResources/SearchServiceResourceType')//SERVICE_PROPERTIES[./PROPERTY[@key = 'infrastructure' and @value = 'public'] ]
     let $format := $s/PROPERTY[@key = "mdformat"]/@value/string()
     return(
     for $x in collection('/db/DRIVER/IndexDSResources/IndexDSResourceType')
     where
         $x//METADATA_FORMAT =$format and
                 $x//METADATA_FORMAT_INTERPRETATION = 'openaire' and
                 $x//METADATA_FORMAT_LAYOUT = 'index'
     return
         concat($x//RESOURCE_IDENTIFIER/@value/string(), ' @@@ ', $format , ' @@@ ', $format , '-index-openaire')
     ))

     package eu.dnetlib.openaire.directindex.api;
     import static org.mockito.Mockito.CALLS_REAL_METHODS;
     import static org.mockito.Mockito.doReturn;
     import static org.mockito.Mockito.mock;
     import static org.mockito.Mockito.withSettings;
     import java.util.ArrayList;
     import java.util.List;
     import java.util.Map;
     import java.util.Map.Entry;
     import org.junit.Assert;
     import org.junit.Before;
     import org.junit.Test;
     import org.junit.runner.RunWith;
     import org.mockito.runners.MockitoJUnitRunner;
     import com.google.common.collect.Lists;
     import com.google.common.collect.Maps;
     import com.google.gson.Gson;
     import eu.dnetlib.openaire.directindex.objects.DatasourceEntry;
     /**
      * Created by Alessia Bardi on 26/05/2017.
+     *
      * @author Alessia Bardi
      */
     @RunWith(MockitoJUnitRunner.class)
     public class OpenAIRESubmitterUtilsTest {
     	private OpenAIRESubmitterUtils utils;
     	final String fullProject = "info:eu-repo/grantAgreement/EC/FP7/244909/EU/Making Capabilities Work/WorkAble";
     	final String minimalProject = "info:eu-repo/grantAgreement/EC/FP7/244909///WorkAble";
     	final String onlyId = "info:eu-repo/grantAgreement/EC/FP7/244909/";
     	final String onlyTitle = "info:eu-repo/grantAgreement/EC/FP7/244909/EU/Making Capabilities Work";
     	final String escapedId = "info:eu-repo/grantAgreement/RCUK//NE%2FL003066%2F1/";
     	final String heProjectFromZenodo =
     		"info:eu-repo/grantAgreement/EC/Horizon Europe Framework Programme - HORIZON-CSA\\HORIZON Action Grant Budget-Based/101058527/";
     	final String chistera = "info:eu-repo/grantAgreement/CHIST-ERA//CHIST-ERA-19-XAI-002/";
     	@Before
     	public void setup() {
     		utils = mock(OpenAIRESubmitterUtils.class, withSettings().defaultAnswer(CALLS_REAL_METHODS));
     		doReturn(Lists.newArrayList("dh-ch", "dariah", "bar", "x")).when(utils).translateZenodoCommunity("https://zenodo.org/communities/dimpo");
     		doReturn(Lists.newArrayList()).when(utils).translateZenodoCommunity("https://zenodo.org/communities/dumbo");
+    	}
     	@Test
     	public void testCalculateProjectInfoCHISTERA() {
     		final Map<String, String> project = utils.calculateProjectInfo(chistera);
     		print(project);
     		Assert.assertEquals("CHIST-ERA-19-XAI-002", project.get("code"));
     		Assert.assertEquals("chistera____::289ec73ce0e9ece89a0cbdf74c445cd8", project.get("id"));
+    	}
     	@Test
     	public void testCalculateProjectInfoZenodo() {
     		final Map<String, String> project = utils.calculateProjectInfo(onlyId);
     		print(project);
     		Assert.assertEquals("244909", project.get("code"));
+    	}
     	@Test
     	public void testCalculateProjectInfoZenodoHE() {
     		final Map<String, String> project = utils.calculateProjectInfo(heProjectFromZenodo);
     		print(project);
     		Assert.assertEquals("101058527", project.get("code"));
     		Assert.assertEquals("corda_____he::eab43774d3762e87f5e66030c6e01d2b", project.get("id"));
+    	}
     	@Test
     	public void testCalculateProjectInfoEscaped() {
     		final Map<String, String> project = utils.calculateProjectInfo(escapedId);
     		print(project);
     		Assert.assertEquals("NE/L003066/1", project.get("code"));
+    	}
     	@Test
     	public void testCalculateProjectInfoFull() {
     		final Map<String, String> project = utils.calculateProjectInfo(fullProject);
     		print(project);
     		Assert.assertEquals(10, project.size());
     		for (final String k : project.keySet()) {
     			Assert.assertNotNull(project.get(k));
     			Assert.assertNotSame("", project.get(k));
+    		}
+    	}
     	@Test
     	public void testCalculateProjectInfoOnlyId() {
     		final Map<String, String> project = utils.calculateProjectInfo(onlyId);
     		print(project);
     		Assert.assertEquals("244909", project.get("code"));
+    	}
     	@Test
     	public void testCalculateProjectInfoMinimalAcro() {
     		final Map<String, String> project = utils.calculateProjectInfo(minimalProject);
     		print(project);
     		Assert.assertEquals("244909", project.get("code"));
     		Assert.assertEquals("WorkAble", project.get("acronym"));
+    	}
     	@Test
     	public void testCalculateProjectInfoOnlyTitle() {
     		final Map<String, String> project = utils.calculateProjectInfo(onlyTitle);
     		print(project);
     		Assert.assertEquals("244909", project.get("code"));
     		Assert.assertEquals("Making Capabilities Work", project.get("title"));
+    	}
     	@Test
     	public void testJerusalem() {
     		final String s =
     			"info:eu-repo/grantAgreement/EC/FP7/337895/EU/Opening Jerusalem Archives: For a connected History of ‘Citadinité’ in the Holy City (1840-1940)/OPEN-JERUSALEM";
     		final Map<String, String> project = utils.calculateProjectInfo(s);
     		print(project);
     		Assert.assertEquals("337895", project.get("code"));
     		Assert.assertEquals("Opening Jerusalem Archives: For a connected History of ‘Citadinité’ in the Holy City (1840-1940)", project.get("title"));
     		Assert.assertEquals("OPEN-JERUSALEM", project.get("acronym"));
+    	}
     	private void print(final Map<String, String> map) {
     		for (final Entry e : map.entrySet()) {
     			System.out.println(e.getKey() + " = " + e.getValue());
+    		}
+    	}
     	@Test
     	public void testContext() {
     		final List<String> zenodoCommunities = new ArrayList<>();
     		zenodoCommunities.add("https://zenodo.org/communities/dimpo");
     		zenodoCommunities.add("https://zenodo.org/communities/dumbo");
     		final Map<String, String> labelMap = Maps.newHashMap();
     		labelMap.put("dariah", "DARIAH");
     		labelMap.put("dh-ch", "DH-CH");
     		labelMap.put("foo", "FOO");
     		labelMap.put("bar", "");
     		final List<OpenAIRESubmitterUtils.ContextInfo> tmp = utils.processContexts(zenodoCommunities, labelMap);
     		Assert.assertEquals(2, tmp.size());
     		Assert.assertTrue(tmp.get(0).getId().equals("dh-ch") || tmp.get(1).getId().equalsIgnoreCase("dh-ch"));
     		Assert.assertTrue(tmp.get(0).getId().equals("dariah") || tmp.get(1).getId().equalsIgnoreCase("dariah"));
+    	}
     	@Test
     	public void testWrongH2020() {
     		final String link = "info:eu-repo/grantAgreement/EC/Horizon 2020 Framework Programme - Research and Innovation action/881825/";
     		final Map<String, String> info = utils.calculateProjectInfo(link);
     		System.out.println(info);
     		Assert.assertEquals("H2020", info.get("fundingName"));
+    	}
     	@Test
     	public void testFindDatasource_01() {
     		final OpenAIRESubmitterUtils utils = new OpenAIRESubmitterUtils("", "https://services.openaire.eu/openaire/ds/");
     		final DatasourceEntry res = utils.findDatasource("opendoar____::1112");
     		System.err.println(new Gson().toJson(res));
+    	}
+    }

     <?xml version="1.0" encoding="UTF-8"?>
     #macro(context $ctx)
             <$!ctx.elem id="$!esc.evaluate($!ctx.id)" label="$!esc.evaluate($!ctx.label)" #if($!ctx.isRoot()) type="community"#end>
     	#foreach($child in $!ctx.children)#context($child)#end
             </$!ctx.elem>
     #end
     <record xmlns:dri="http://www.driver-repository.eu/namespace/dri" xmlns:oaf="http://namespace.openaire.eu/oaf">
     	<result>
     		<header>
     			<dri:objIdentifier>$!esc.evaluate($!objIdentifier)</dri:objIdentifier>
     			<dri:dateOfCollection>$!esc.evaluate($!dateOfCollection)</dri:dateOfCollection>
     			<dri:status>under curation</dri:status>
     			<counters/>
     		</header>
     		<metadata>
     			<oaf:entity schemaLocation="http://namespace.openaire.eu/oaf $!oafSchemaLocation">
     				<oaf:result>
     					<title classid="main title" classname="main title" schemeid="dnet:dataCite_title" schemename="dnet:dataCite_title">
     						$!esc.evaluate($!pub.title)
     					</title>
     					#foreach($author in $!pub.authors)
                         	<creator rank="$velocityCount" name="" surname="">$!esc.evaluate($!author)</creator>
                         #end
     					<dateofacceptance/>
     					<resulttype classid="$!esc.evaluate($!pub.type)" classname="$!esc.evaluate($!resultTypes.get($!pub.type))" schemeid="dnet:result_typologies" schemename="dnet:result_typologies"/>
     					<language classid="$!esc.evaluate($!pub.language)" classname="$!esc.evaluate($!languages.get($!pub.language))" schemeid="dnet:languages"
     					          schemename="dnet:languages"/>
     					<description>
     						$!esc.evaluate($!pub.description)
     					</description>
     					<country classid="" classname="" schemeid="" schemename=""/>
     					<subject classid="" classname="" schemeid="" schemename=""/>
     					<relevantdate classid="" classname="" schemeid="" schemename=""/>
     					<publisher>$!esc.evaluate($!pub.publisher)</publisher>
     					<embargoenddate>$!esc.evaluate($!pub.embargoEndDate)</embargoenddate>
     					<journal issn="" eissn="" lissn="" ep="" iss="" sp="" vol=""/>
     					<source/>
     					<fulltext/>
     					<format/>
     					<storagedate/>
     					<resourcetype classid="" classname="" schemeid="" schemename=""/>
     					<device/>
     					<size/>
     					<version/>
     					<lastmetadataupdate/>
     					<metadataversionnumber/>
     					<documentationUrl/>
     					<codeRepositoryUrl/>
     					<programmingLanguage classid="" classname="" schemeid="" schemename="" />
     					<contactperson />
     					<contactgroup />
     					<tool />
     					<originalId>$!esc.evaluate($!pub.originalId)</originalId>
     					<collectedfrom name="$!esc.evaluate($!collectedFrom.name)" id="$!esc.evaluate($!collectedFrom.calculateOpenaireId())"/>
     					#foreach($pid in $!pub.pids)
     						<pid classid="$!esc.evaluate($!pid.type)" classname="$!esc.evaluate($!pidTypes.get($!pid.type))" schemeid="dnet:pid_types"
     						     schemename="dnet:pid_types">$!esc.evaluate($pid.value)</pid>
     					#end
     					#if($!pub.accessRightCode)
     						<bestaccessright classid="$!esc.evaluate($!pub.accessRightCode)" classname="$!esc.evaluate($!rights.get($!pub.accessRightCode))"
     						                 schemeid="dnet:access_modes" schemename="dnet:access_modes"/>
     					#elseif($!pub.licenseCode)
     							<bestaccessright classid="$!esc.evaluate($!pub.licenseCode)" classname="$!esc.evaluate($!rights.get($!pub.licenseCode))"
     							                 schemeid="dnet:access_modes" schemename="dnet:access_modes"/>
     					#else
     						<bestaccessright classid="UNKNOWN" classname="not available" schemeid="dnet:access_modes" schemename="dnet:access_modes" />
     					#end
     					#foreach($ctx in $contextInfo)
                             #context($ctx)
                         #end
     					<datainfo>
     						<inferred>false</inferred>
     						<deletedbyinference>false</deletedbyinference>
     						<trust>0.9</trust>
     						<inferenceprovenance/>
     						<provenanceaction classid="user:insert" classname="user:insert" schemeid="dnet:provenanceActions" schemename="dnet:provenanceActions"/>
     					</datainfo>
     					<rels>
     						#foreach($link in $!pub.linksToProjects)
     							#set( $info = $!util.calculateProjectInfo($!link) )
     							<rel inferred="false" trust="0.9" inferenceprovenance="" provenanceaction="user:claim">
     								<to class="isProducedBy" scheme="dnet:result_project_relations" type="project">$!esc.evaluate($!info.id)</to>
     								<code>$!esc.evaluate($!info.code)</code>
     								<acronym>$!esc.evaluate($!info.acronym)</acronym>
     								<title>$!esc.evaluate($!info.title)</title>
     								<contracttype classid="" classname="" schemeid="" schemename=""/>
     								<funding>
     									<funder id="$!esc.evaluate($!info.funderId)"
     									        shortname="$!esc.evaluate($!info.funderShortName)"
     									        name="$!esc.evaluate($!info.funderName)"
     									        jurisdiction="$!esc.evaluate($!info.jurisdiction)"/>
     									#if($!info.fundingId)
     									<funding_level_0 name="$!esc.evaluate($!info.fundingName)">$!esc.evaluate($!info.fundingId)</funding_level_0>
     									#end
     								</funding>
     								<websiteurl/>
     							</rel>
     						#end
     					</rels>
     					<children>
     						<instance id="$!esc.evaluate($!objIdentifier)">
     							<instancetype classid="$!esc.evaluate($!pub.resourceType)" classname="$!esc.evaluate($resourceTypes.get($!pub.resourceType))"
     							              schemeid="dnet:publication_resource" schemename="dnet:publication_resource"/>
     							<collectedfrom name="$!esc.evaluate($!collectedFrom.name)" id="$!esc.evaluate($!collectedFrom.calculateOpenaireId())"/>
     							<hostedby name="$!esc.evaluate($!hostedBy.name)" id="$!esc.evaluate($!hostedBy.calculateOpenaireId())"/>
     							#if($!pub.accessRightCode)
     								<accessright classid="$!esc.evaluate($!pub.accessRightCode)" classname="$!esc.evaluate($!rights.get($!pub.accessRightCode))"
     								                 schemeid="dnet:access_modes" schemename="dnet:access_modes"/>
     							#elseif($!pub.licenseCode)
     								<accessright classid="$!esc.evaluate($!pub.licenseCode)" classname="$!esc.evaluate($!rights.get($!pub.licenseCode))"
     								                 schemeid="dnet:access_modes" schemename="dnet:access_modes"/>
     							#else
     								<accessright classid="UNKNOWN" classname="not available" schemeid="dnet:access_modes" schemename="dnet:access_modes" />
     							#end
     							<dateofacceptance/>
     							<webresource>
     								<url>$!esc.evaluate($!pub.url)</url>
     							</webresource>
     						</instance>
     					</children>
     				</oaf:result>
     			</oaf:entity>
     		</metadata>
     	</result>
     </record>

     package eu.dnetlib.openaire.directindex.objects;
     import static org.mockito.Matchers.anyString;
     import static org.mockito.Mockito.CALLS_REAL_METHODS;
     import static org.mockito.Mockito.doReturn;
     import static org.mockito.Mockito.mock;
     import static org.mockito.Mockito.when;
     import static org.mockito.Mockito.withSettings;
     import java.io.InputStreamReader;
     import java.io.StringReader;
     import java.util.ArrayList;
     import java.util.Arrays;
     import java.util.List;
     import java.util.Properties;
     import org.apache.commons.lang3.StringEscapeUtils;
     import org.apache.velocity.app.VelocityEngine;
     import org.dom4j.Document;
     import org.dom4j.Node;
     import org.dom4j.io.OutputFormat;
     import org.dom4j.io.SAXReader;
     import org.dom4j.io.XMLWriter;
     import org.junit.Assert;
     import org.junit.Before;
     import org.junit.Test;
     import org.junit.runner.RunWith;
     import org.mockito.Mock;
     import org.mockito.runners.MockitoJUnitRunner;
     import com.google.common.collect.Lists;
     import com.google.gson.Gson;
     import eu.dnetlib.enabling.is.lookup.rmi.ISLookUpService;
     import eu.dnetlib.openaire.directindex.api.DirecIndexApiException;
     import eu.dnetlib.openaire.directindex.api.OpenAIRESubmitterUtils;
     /**
      * Created by michele on 14/12/15.
      */
     @RunWith(MockitoJUnitRunner.class)
     public class ResultEntryToOafTest {
     	private VelocityEngine ve;
     	private final String community_api = "https://dev-openaire.d4science.org/openaire/community/";
     	private final String dsm_api = "https://dev-openaire.d4science.org/openaire/ds/";
     	@Mock
     	private ISLookUpService lookUpService;
     	private ResultEntryToOaf toOaf;
     	private OpenAIRESubmitterUtils utils;
     	@Before
     	public void setUp() throws Exception {
     		utils = mock(OpenAIRESubmitterUtils.class, withSettings().defaultAnswer(CALLS_REAL_METHODS));
     		doReturn(Lists.newArrayList("dh-ch", "dariah", "bar", "x")).when(utils).translateZenodoCommunity("https://zenodo.org/communities/dimpo");
     		doReturn(Lists.newArrayList()).when(utils).translateZenodoCommunity("https://zenodo.org/communities/dumbo");
     		doReturn(Lists.newArrayList("noLabel", "enermaps")).when(utils).translateZenodoCommunity("https://sandbox.zenodo.org/communities/oac-ni");
     		doReturn(Lists.newArrayList("noLabel", "enermaps")).when(utils).translateZenodoCommunity("https://zenodo.org/communities/oac-ni");
     		doReturn(new DatasourceEntry("test________::XXX", "XXX", "xxxx________")).when(utils).findDatasource(anyString());
     		toOaf = new ResultEntryToOaf(utils);
     		final Properties props = new Properties();
     		props.setProperty("resource.loader", "class");
     		props.setProperty("class.resource.loader.class", "org.apache.velocity.runtime.resource.loader.ClasspathResourceLoader");
     		props.setProperty("runtime.log.logsystem.class", "org.apache.velocity.runtime.log.Log4JLogChute");
     		ve = new VelocityEngine();
     		ve.init(props);
     		when(lookUpService.quickSearchProfile(anyString())).thenAnswer(invocation -> {
     			final String query = invocation.getArguments()[0].toString();
     			if (query.contains("dnet:result_typologies")) {
     				return Arrays.asList("publication @@@ publication", "dataset @@@ dataset", "software @@@ software", "other @@@ other");
     			} else if (query.contains("dnet:access_modes")) {
     				return Arrays.asList("OPEN @@@ Open Access");
     			} else if (query.contains("dnet:publication_resource")) {
     				return Arrays.asList("0001 @@@ Journal Article");
     			} else if (query.contains("dnet:pid_types")) {
     				return Arrays.asList("oai @@@ Open Archive Initiative", "doi @@@ Digital object identifier");
     			} else if (query.contains("dnet:languages")) {
     				return Arrays.asList("ita @@@ Italian");
     			} else if (query.contains("ContextDSResourceType")) {
     				return Arrays
     					.asList("egi::classification::natsc::math::stats @@@ Statistics and Probability", "egi::classification::natsc::math::pure @@@ Pure Mathematics", "egi::classification::natsc::math @@@ Mathematics", "egi::classification::natsc @@@ Natural Sciences", "egi::classification @@@ EGI classification scheme", "egi @@@ EGI", "enermaps @@@ Energy Research", "enermaps::selection @@@ Selected by the H2020 EnerMaps project");
     			} else {
     				return new ArrayList<String>();
+    			}
     		});
+    	}
     	@Test
     	public void testAsIndexRecord() throws Exception {
     		final ResultEntry pub = new ResultEntry();
     		pub.setOriginalId("ORIG_ID_1234");
     		pub.setTitle("TEST TITLE <test>");
     		pub.getAuthors().add("Michele Artini");
     		pub.getAuthors().add("Claudio Atzori");
     		pub.getAuthors().add("Alessia Bardi");
     		pub.setPublisher("Test publisher");
     		pub.setDescription("DESCRIPTION & DESCRIPTION & DESCRIPTION & DESCRIPTION & DESCRIPTION & DESCRIPTION & DESCRIPTION ");
     		pub.setLanguage("ita");
     		pub.setLicenseCode("OPEN");
     		pub.setResourceType("0001");
     		pub.setUrl("http://test.it/a=1&b=2");
     		pub.getPids().add(new PidEntry("doi", "10.000/xyz-123"));
     		pub.getPids().add(new PidEntry("oai", "oai:1234"));
     		pub.setCollectedFromId("test________::zenodo");
     		pub.setHostedById("test________::UNKNOWN");
     		pub.getLinksToProjects().add("info:eu-repo/grantAgreement/EC/FP7/283595/EU//OpenAIREplus");
     		pub.getLinksToProjects().add("info:eu-repo/grantAgreement/RCUK//244%2F909/EU/Making Capabilities Work/WorkAble");
     		pub.getContexts().add("egi::classification::natsc::math::pure");
     		pub.getContexts().add("egi::classification::natsc::math::stats");
     		pub.getContexts().add("enermaps");
     		pub.getContexts().add("enermaps::selection");
     		final String xml = toOaf.asOafRecord(pub, ve, lookUpService, "http://oaf/oaf.xsd");
     		final Document doc = new SAXReader().read(new StringReader(xml));
     		final Node resultNode = doc.selectSingleNode("//oaf:result");
     		Assert.assertNotNull(resultNode);
     		final Node origIdNode = resultNode.selectSingleNode("./originalId");
     		Assert.assertNotNull(origIdNode);
     		Assert.assertEquals("ORIG_ID_1234", origIdNode.getText());
     		final Node titleNode = resultNode.selectSingleNode("./title");
     		Assert.assertNotNull(titleNode);
     		Assert.assertNotNull(titleNode.getText());
     		final List<Node> accessRightsNodes = resultNode.selectNodes(".//accessright/@classid");
     		for (final Node aNode : accessRightsNodes) {
     			Assert.assertEquals("OPEN", aNode.getStringValue());
+    		}
     		final Node bestARNode = resultNode.selectSingleNode("./bestaccessright/@classid");
     		Assert.assertEquals("OPEN", bestARNode.getStringValue());
     		// final OutputFormat format = OutputFormat.createPrettyPrint();
     		// final XMLWriter writer = new XMLWriter(System.out, format);
     		// writer.write(doc);
+    	}
     	@Test
     	public void testAsIndexRecordAccessRight() throws Exception {
     		final ResultEntry pub = new ResultEntry();
     		pub.setOriginalId("ORIG_ID_1234");
     		pub.setTitle("TEST TITLE <test>");
     		pub.getAuthors().add("Michele Artini");
     		pub.getAuthors().add("Claudio Atzori");
     		pub.getAuthors().add("Alessia Bardi");
     		pub.setPublisher("Test publisher");
     		pub.setDescription("DESCRIPTION & DESCRIPTION & DESCRIPTION & DESCRIPTION & DESCRIPTION & DESCRIPTION & DESCRIPTION ");
     		pub.setLanguage("ita");
     		pub.setLicenseCode("CLOSED");
     		pub.setAccessRightCode("OPEN");
     		pub.setResourceType("0001");
     		pub.setUrl("http://test.it/a=1&b=2");
     		pub.getPids().add(new PidEntry("doi", "10.000/xyz-123"));
     		pub.getPids().add(new PidEntry("oai", "oai:1234"));
     		pub.setCollectedFromId("test________::zenodo");
     		pub.setHostedById("test________::UNKNOWN");
     		pub.getLinksToProjects().add("info:eu-repo/grantAgreement/EC/FP7/283595/EU//OpenAIREplus");
     		pub.getLinksToProjects().add("info:eu-repo/grantAgreement/EC/FP7/244909/EU/Making Capabilities Work/WorkAble");
     		pub.getContexts().add("egi::classification::natsc::math::pure");
     		pub.getContexts().add("egi::classification::natsc::math::stats");
     		final String xml = toOaf.asOafRecord(pub, ve, lookUpService, "http://oaf/oaf.xsd");
     		final Document doc = new SAXReader().read(new StringReader(xml));
     		final Node resultNode = doc.selectSingleNode("//oaf:result");
     		Assert.assertNotNull(resultNode);
     		final Node origIdNode = resultNode.selectSingleNode("./originalId");
     		Assert.assertNotNull(origIdNode);
     		Assert.assertEquals("ORIG_ID_1234", origIdNode.getText());
     		final Node titleNode = resultNode.selectSingleNode("./title");
     		Assert.assertNotNull(titleNode);
     		Assert.assertNotNull(titleNode.getText());
     		final List<Node> accessRightsNodes = resultNode.selectNodes(".//accessright/@classid");
     		for (final Node aNode : accessRightsNodes) {
     			Assert.assertEquals("OPEN", aNode.getStringValue());
+    		}
     		final Node bestARNode = resultNode.selectSingleNode("./bestaccessright/@classid");
     		Assert.assertEquals("OPEN", bestARNode.getStringValue());
     		// final OutputFormat format = OutputFormat.createPrettyPrint();
     		// final XMLWriter writer = new XMLWriter(System.out, format);
     		// writer.write(doc);
+    	}
     	@Test
     	public void testAsORP() throws Exception {
     		final ResultEntry pub = new ResultEntry();
     		pub.setOriginalId("ORIG_ID_1234");
     		pub.setTitle("TEST TITLE <test>");
     		pub.getAuthors().add("Michele Artini");
     		pub.getAuthors().add("Claudio Atzori");
     		pub.getAuthors().add("Alessia Bardi");
     		pub.setPublisher("Test publisher");
     		pub.setDescription("DESCRIPTION & DESCRIPTION & DESCRIPTION & DESCRIPTION & DESCRIPTION & DESCRIPTION & DESCRIPTION ");
     		pub.setLanguage("ita");
     		pub.setLicenseCode("CLOSED");
     		pub.setAccessRightCode("OPEN");
     		pub.setResourceType("0020");
     		pub.setType("other");
     		pub.setUrl("http://test.it/a=1&b=2");
     		pub.getPids().add(new PidEntry("doi", "10.000/xyz-123"));
     		pub.getPids().add(new PidEntry("oai", "oai:1234"));
     		pub.setCollectedFromId("test________::zenodo");
     		pub.setHostedById("test________::UNKNOWN");
     		pub.getLinksToProjects().add("info:eu-repo/grantAgreement/EC/FP7/283595/EU//OpenAIREplus");
     		pub.getLinksToProjects().add("info:eu-repo/grantAgreement/EC/FP7/244909/EU/Making Capabilities Work/WorkAble");

Project

General

Profile

D-Net

Revision 62685

Added by Alessia Bardi over 1 year ago