D-Net

package eu.dnetlib.openaire.exporter.model;

import org.junit.Before;

import org.junit.Test;

import static org.junit.Assert.assertEquals;

public class ProjectTest {

	Project pMZOS;

	Project pFP7;

	@Before

	public void setUp() throws Exception {

		pMZOS = new Project()

				.setFunder("MZOS")

				.setJurisdiction("HR")

				.setFundingpathid("irb_hr______::MZOS")

				.setAcronym("")

				.setTitle("Project Title")

				.setCode("115-1152437-2500")

				.setStartdate("2007-01-01")

				.setEnddate("2009-01-01");

		pFP7 = new Project()

				.setFunder("EC")

				.setJurisdiction("EU")

				.setFundingpathid("ec__________::EC::FP7::SP1::NMP")

				.setAcronym("REFFIBRE")

				.setTitle("Project Title")

				.setCode("604187")

				.setStartdate("2013-11-01")

				.setEnddate("20015-01-01");

	}

	@Test

	public void testIdNamespaceMZOS(){

		String ns = pMZOS.getIdnamespace();

		assertEquals("info:eu-repo/grantAgreement/MZOS//115-1152437-2500/HR", ns);

	}

	@Test

	public void testIdNamespaceFP7(){

		String ns = pFP7.getIdnamespace();

		assertEquals("info:eu-repo/grantAgreement/EC/FP7/604187/EU", ns);

	}

}

package eu.dnetlib.data.mapreduce.util;

import static org.junit.Assert.assertFalse;

import static org.junit.Assert.assertNotNull;

import java.util.List;

import org.junit.Test;

import eu.dnetlib.data.proto.KindProtos.Kind;

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

public class OafDecoderTest {

	@Test

	public void testAsXml() {

		final OafDecoder decoder = OafTest.embed(OafTest.getResult("50|id_1"), Kind.entity);

		assertNotNull(decoder);

		assertNotNull(decoder.asXml());

		System.out.println(IndentXmlString.apply(decoder.asXml()));

	}

	@Test

	public void testGetFieldValues() {

		final OafDecoder decoder = OafTest.embed(OafTest.getResult("50|id_1"), Kind.entity);

		final String path = "result/metadata/title/value";

		final List<String> titles = decoder.decodeEntity().getFieldValues(path);

		assertNotNull(titles);

		assertFalse(titles.isEmpty());

	}

}

package eu.dnetlib.pace;

import java.io.IOException;

import java.io.StringWriter;

import java.util.ArrayList;

import java.util.List;

import com.google.common.collect.Lists;

import org.apache.commons.io.IOUtils;

import org.apache.commons.lang.RandomStringUtils;

import org.apache.commons.lang.StringUtils;

import com.google.gson.Gson;

import eu.dnetlib.data.mapreduce.util.OafTest;

import eu.dnetlib.data.proto.FieldTypeProtos.Qualifier;

import eu.dnetlib.data.proto.FieldTypeProtos.StructuredProperty;

import eu.dnetlib.data.proto.FieldTypeProtos.StructuredProperty.Builder;

import eu.dnetlib.data.proto.OafProtos.Oaf;

import eu.dnetlib.data.proto.OafProtos.OafEntity;

import eu.dnetlib.data.proto.OrganizationProtos.Organization;

import eu.dnetlib.data.proto.PersonProtos.Person;

import eu.dnetlib.data.proto.ResultProtos.Result;

import eu.dnetlib.pace.config.Config;

import eu.dnetlib.pace.config.DedupConfig;

import eu.dnetlib.pace.config.Type;

import eu.dnetlib.pace.model.Field;

import eu.dnetlib.pace.model.FieldValueImpl;

import eu.dnetlib.pace.model.MapDocument;

import eu.dnetlib.pace.model.ProtoDocumentBuilder;

import eu.dnetlib.pace.model.gt.GTAuthor;

import eu.dnetlib.pace.model.gt.GTAuthorMapper;

public abstract class AbstractProtoPaceTest extends OafTest {

	protected DedupConfig getResultFullConf() {

		return DedupConfig.load(readFromClasspath("/eu/dnetlib/pace/result.full.pace.conf"));

	}

	protected DedupConfig getResultSimpleConf() {

		return DedupConfig.load(readFromClasspath("/eu/dnetlib/pace/result.simple.pace.conf"));

	}

	protected DedupConfig getResultConf() {

		return DedupConfig.load(readFromClasspath("/eu/dnetlib/pace/result.pace.conf"));

	}

	protected DedupConfig getOrganizationSimpleConf() {

		return DedupConfig.load(readFromClasspath("/eu/dnetlib/pace/organization.pace.conf"));

	}

	protected DedupConfig getResultAuthorsConf() {

		return DedupConfig.load(readFromClasspath("/eu/dnetlib/pace/result.authors.pace.conf"));

	}

	protected DedupConfig getPersonConf() {

		return DedupConfig.load(readFromClasspath("/eu/dnetlib/pace/person.pace.conf"));

	}

	protected DedupConfig getResultProdConf() {

		return DedupConfig.load(readFromClasspath("/eu/dnetlib/pace/result.prod.pace.conf"));

	}

	protected MapDocument person(final Config conf, final String id, final Oaf oaf) {

		return ProtoDocumentBuilder.newInstance(id, oaf.getEntity(), conf.model());

	}

	protected Oaf getPersonGT(final String path) {

		return new GTAuthorMapper().map(getGTAuthor(path));

	}

	protected GTAuthor getGTAuthor(final String path) {

		final Gson gson = new Gson();

		final String json = readFromClasspath(path);

		final GTAuthor gta = gson.fromJson(json, GTAuthor.class);

		return gta;

	}

	private String readFromClasspath(final String filename) {

		final StringWriter sw = new StringWriter();

		try {

			IOUtils.copy(getClass().getResourceAsStream(filename), sw);

			return sw.toString();

		} catch (final IOException e) {

			throw new RuntimeException("cannot load resource from classpath: " + filename);

		}

	}

	protected MapDocument result(final Config config, final String id, final String title) {

		return result(config, id, title, null, new ArrayList<String>(), null);

	}

	protected MapDocument result(final Config config, final String id, final String title, final String date) {

		return result(config, id, title, date, new ArrayList<String>(), null);

	}

	protected MapDocument result(final Config config, final String id, final String title, final String date, final List<String> pid) {

		return result(config, id, title, date, pid, null);

	}

	protected MapDocument result(final Config config, final String id, final String title, final String date, final String pid) {

		return result(config, id, title, date, pid, null);

	}

	protected MapDocument result(final Config config, final String id, final String title, final String date, final String pid, final List<String> authors) {

		return result(config, id, title, date, Lists.newArrayList(pid), authors);

	}

	protected MapDocument result(final Config config, final String id, final String title, final String date, final List<String> pid, final List<String> authors) {

		final Result.Metadata.Builder metadata = Result.Metadata.newBuilder();

		if (!StringUtils.isBlank(title)) {

			metadata.addTitle(getStruct(title, getQualifier("main title", "dnet:titles")));

			metadata.addTitle(getStruct(RandomStringUtils.randomAlphabetic(10), getQualifier("alternative title", "dnet:titles")));

		}

		if (!StringUtils.isBlank(date)) {

			metadata.setDateofacceptance(sf(date));

		}

		final OafEntity.Builder entity = oafEntity(id, eu.dnetlib.data.proto.TypeProtos.Type.result);

		final Result.Builder result = Result.newBuilder().setMetadata(metadata);

		if (authors != null) {

			for (final String author : authors) {

				result.addAuthor(person(author));

			}

		}

		entity.setResult(result);

		if (pid != null) {

			for(String p : pid) {

				if (!StringUtils.isBlank(p)) {

					entity.addPid(sp(p, "doi"));

					//entity.addPid(sp(RandomStringUtils.randomAlphabetic(10), "oai"));

				}

			}

		}

		final OafEntity build = entity.build();

		return ProtoDocumentBuilder.newInstance(id, build, config.model());

	}

	private Person.Builder person(final String author) {

		final Person.Builder person = Person.newBuilder();

		final eu.dnetlib.pace.model.Person p = new eu.dnetlib.pace.model.Person(author, false);

		final Person.Metadata.Builder metadata = Person.Metadata.newBuilder();

		if (p.isAccurate()) {

			metadata.setFirstname(sf(p.getNormalisedFirstName()));

			metadata.addSecondnames(sf(p.getNormalisedSurname()));

			metadata.setFullname(sf(p.getNormalisedFullname()));

		} else {

			metadata.setFullname(sf(p.getOriginal()));

		}

		return person.setMetadata(metadata);

	}

	private OafEntity.Builder oafEntity(final String id, final eu.dnetlib.data.proto.TypeProtos.Type type) {

		final OafEntity.Builder entity = OafEntity.newBuilder().setId(id).setType(type);

		return entity;

	}

	protected MapDocument organization(final Config config, final String id, final String legalName) {

		return organization(config, id, legalName, null);

	}

	protected MapDocument organization(final Config config, final String id, final String legalName, final String legalShortName) {

		final Organization.Metadata.Builder metadata = Organization.Metadata.newBuilder();

		if (legalName != null) {

			metadata.setLegalname(sf(legalName));

		}

		if (legalShortName != null) {

			metadata.setLegalshortname(sf(legalShortName));

		}

		final OafEntity.Builder entity = oafEntity(id, eu.dnetlib.data.proto.TypeProtos.Type.result);

		entity.setOrganization(Organization.newBuilder().setMetadata(metadata));

		return ProtoDocumentBuilder.newInstance(id, entity.build(), config.model());

	}

	private StructuredProperty sp(final String pid, final String type) {

		final Builder pidSp =

				StructuredProperty.newBuilder().setValue(pid)

						.setQualifier(Qualifier.newBuilder().setClassid(type).setClassname(type).setSchemeid("dnet:pid_types").setSchemename("dnet:pid_types"));

		return pidSp.build();

	}

	protected Field title(final String s) {

		return new FieldValueImpl(Type.String, "title", s);

	}

	protected static StructuredProperty.Builder getStruct(final String value, final Qualifier.Builder qualifier) {

		return StructuredProperty.newBuilder().setValue(value).setQualifier(qualifier);

	}

	/*

	 * protected static StringField.Builder sf(final String s) { return StringField.newBuilder().setValue(s); }

	 * 

	 * protected static Qualifier.Builder getQualifier(final String classname, final String schemename) { return

	 * Qualifier.newBuilder().setClassid(classname).setClassname(classname).setSchemeid(schemename).setSchemename(schemename); }

	 */

}

<?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>dnet-parent</artifactId>

		<version>1.0.0</version>

		<relativePath />

	</parent>

	<modelVersion>4.0.0</modelVersion>

	<groupId>eu.dnetlib</groupId>

	<artifactId>dnet-openaireplus-mapping-utils</artifactId>

	<packaging>jar</packaging>

	<version>6.0.1-SNAPSHOT</version>

	<scm>

		<developerConnection>scm:svn:https://svn.driver.research-infrastructures.eu/driver/dnet40/modules/dnet-openaireplus-mapping-utils/trunk</developerConnection>

	</scm>

	<dependencies>

		<dependency>

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

			<artifactId>guava</artifactId>

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

		</dependency>		

		<dependency>

			<groupId>junit</groupId>

			<artifactId>junit</artifactId>

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

			<scope>test</scope>

		</dependency>

		<dependency>

			<groupId>commons-codec</groupId>

			<artifactId>commons-codec</artifactId>

			<version>${commons.codec.version}</version>

		</dependency>

		<dependency>

			<groupId>dom4j</groupId>

			<artifactId>dom4j</artifactId>

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

			<exclusions>

				<exclusion>

					<artifactId>xml-apis</artifactId>

					<groupId>xml-apis</groupId>

				</exclusion>

			</exclusions>

		</dependency>

		<dependency>

			<groupId>net.sf.supercsv</groupId>

			<artifactId>super-csv</artifactId>

			<version>2.4.0</version>

		</dependency>

		<dependency>

			<groupId>eu.dnetlib</groupId>

			<artifactId>dnet-openaire-data-protos</artifactId>

			<version>[3.7.4]</version>

		</dependency>

		<dependency>

			<groupId>eu.dnetlib</groupId>

			<artifactId>dnet-pace-core</artifactId>

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

		</dependency>

		<dependency>

			<groupId>eu.dnetlib</groupId>

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

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

		</dependency>

		<dependency>

			<groupId>eu.dnetlib</groupId>

			<artifactId>dnet-hadoop-commons</artifactId>

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

		</dependency>

		<dependency>

			<groupId>eu.dnetlib</groupId>

			<artifactId>dnet-index-solr-common</artifactId>

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

		</dependency>	

		<dependency>

			<groupId>com.googlecode.protobuf-java-format</groupId>

			<artifactId>protobuf-java-format</artifactId>

			<version>1.2</version>

		</dependency>

		<dependency>

			<groupId>eu.dnetlib</groupId>

			<artifactId>dnet-openaireplus-profiles</artifactId>

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

			<scope>test</scope>

		</dependency>

	</dependencies>

</project>

package eu.dnetlib.data.transform.xml;

import java.util.List;

import com.google.common.collect.Lists;

import com.google.protobuf.Descriptors.FieldDescriptor;

import com.google.protobuf.Message.Builder;

import eu.dnetlib.data.mapreduce.util.OafRowKeyDecoder;

import eu.dnetlib.data.proto.DatasourceOrganizationProtos.DatasourceOrganization;

import eu.dnetlib.data.proto.DatasourceOrganizationProtos.DatasourceOrganization.Provision;

import eu.dnetlib.data.proto.DatasourceProtos.Datasource;

import eu.dnetlib.data.proto.FieldTypeProtos.DataInfo;

import eu.dnetlib.data.proto.FieldTypeProtos.KeyValue;

import eu.dnetlib.data.proto.OafProtos.Oaf;

import eu.dnetlib.data.proto.OafProtos.OafEntity;

import eu.dnetlib.data.proto.OafProtos.OafRel;

import eu.dnetlib.data.proto.OrganizationProtos.Organization;

import eu.dnetlib.data.proto.PersonProtos.Person;

import eu.dnetlib.data.proto.PersonResultProtos.PersonResult;

import eu.dnetlib.data.proto.PersonResultProtos.PersonResult.Authorship;

import eu.dnetlib.data.proto.ProjectOrganizationProtos.ProjectOrganization;

import eu.dnetlib.data.proto.ProjectOrganizationProtos.ProjectOrganization.Participation;

import eu.dnetlib.data.proto.ProjectPersonProtos.ProjectPerson;

import eu.dnetlib.data.proto.ProjectPersonProtos.ProjectPerson.ContactPerson;

import eu.dnetlib.data.proto.ProjectProtos.Project;

import eu.dnetlib.data.proto.RelMetadataProtos.RelMetadata;

import eu.dnetlib.data.proto.RelTypeProtos.RelType;

import eu.dnetlib.data.proto.RelTypeProtos.SubRelType;

import eu.dnetlib.data.proto.ResultProjectProtos.ResultProject;

import eu.dnetlib.data.proto.ResultProjectProtos.ResultProject.Outcome;

import eu.dnetlib.data.proto.ResultProtos.Result;

import eu.dnetlib.data.proto.ResultProtos.Result.Instance;

import eu.dnetlib.data.proto.TypeProtos.Type;

import org.apache.commons.lang.StringUtils;

import org.w3c.dom.Node;

import org.w3c.dom.NodeList;

public class DbmfToHbaseXsltFunctions extends CommonDNetXsltFunctions {

	public static String oafEntity(final String type,

			final String id,

			final String collectedFromId,

			final String collectedFromName,

			final NodeList identities,

			final String dateOfCollection,

			final String dateOfTransformation,

			final NodeList nodeList) {

		final String entityId = OafRowKeyDecoder.decode(id).getKey();

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

		for(int i = 0; i < identities.getLength(); i++){

			Node n = identities.item(i);

			String s = n.getTextContent();

			ids.add(s);

		}

		switch (Type.valueOf(type)) {

		case datasource:

			return serializeOafEntity(nodeList, Type.datasource, entityId, getKV(collectedFromId, collectedFromName), ids, dateOfCollection,

					dateOfTransformation, Datasource.newBuilder());

		case organization:

			return serializeOafEntity(nodeList, Type.organization, entityId, getKV(collectedFromId, collectedFromName), ids, dateOfCollection,

					dateOfTransformation, Organization.newBuilder());

		case person:

			return serializeOafEntity(nodeList, Type.person, entityId, getKV(collectedFromId, collectedFromName), ids, dateOfCollection,

					dateOfTransformation, Person.newBuilder());

		case project:

			return serializeOafEntity(nodeList, Type.project, entityId, getKV(collectedFromId, collectedFromName), ids, dateOfCollection,

					dateOfTransformation, Project.newBuilder());

		case result:

			return serializeOafEntity(nodeList, Type.result, entityId, getKV(collectedFromId, collectedFromName), ids, dateOfCollection,

					dateOfTransformation ,Result.newBuilder());

		default:

			throw new IllegalArgumentException("Invalid entity type: " + type);

		}

	}

	public static String oafRel(final String relationType,

			final String source,

			final String target,

			final NodeList nodeList,

			final String relClass,

			final String relScheme) {

		return oafRel(relationType, source, target, nodeList, relClass, relScheme, null, null);

	}

	public static String oafRel(final String relationType,

			final String source,

			final String target,

			final NodeList nodeList,

			final String relClass,

			final String relScheme,

			final String collectedFromId,

			final String collectedFromName) {

		final String eSource = OafRowKeyDecoder.decode(source).getKey();

		final String eTarget = OafRowKeyDecoder.decode(target).getKey();

		final RelType relType = RelType.valueOf(relationType);

		switch (relType) {

		case datasourceOrganization:

			Provision.Builder provision = Provision.newBuilder().setRelMetadata(

					RelMetadata.newBuilder().setSemantics(getSimpleQualifier(Provision.RelName.valueOf(relClass).toString(), relScheme)));

			DatasourceOrganization.Builder dorg = DatasourceOrganization.newBuilder().setProvision(provision);

			return serializeOafRel(nodeList, eSource, eTarget, relType, SubRelType.provision, relClass, collectedFromId, collectedFromName, false, dorg, provision);

		case personResult:

			Authorship.Builder auth = Authorship.newBuilder().setRelMetadata(

					RelMetadata.newBuilder().setSemantics(getSimpleQualifier(Authorship.RelName.valueOf(relClass).toString(), relScheme)));

			PersonResult.Builder personResult = PersonResult.newBuilder().setAuthorship(auth);

			return serializeOafRel(nodeList, eSource, eTarget, relType, SubRelType.authorship, relClass, collectedFromId, collectedFromName, false, personResult, auth);

		case projectPerson:

			ContactPerson.Builder contact = ContactPerson.newBuilder().setRelMetadata(

					RelMetadata.newBuilder().setSemantics(getSimpleQualifier(ContactPerson.RelName.valueOf(relClass).toString(), relScheme)));

			ProjectPerson.Builder projectPerson = ProjectPerson.newBuilder().setContactPerson(contact);

			return serializeOafRel(nodeList, eSource, eTarget, relType, SubRelType.contactPerson, relClass, collectedFromId, collectedFromName, false, projectPerson, contact);

		case projectOrganization:

			Participation.Builder participant = Participation.newBuilder().setRelMetadata(

					RelMetadata.newBuilder().setSemantics(getSimpleQualifier(Participation.RelName.valueOf(relClass).toString(), relScheme)));

			ProjectOrganization.Builder projectOrganization = ProjectOrganization.newBuilder().setParticipation(participant);

			return serializeOafRel(nodeList, eSource, eTarget, relType, SubRelType.participation, relClass, collectedFromId, collectedFromName, false, projectOrganization, participant);

		case resultProject:

			Outcome.Builder outcome = Outcome.newBuilder().setRelMetadata(

					RelMetadata.newBuilder().setSemantics(getSimpleQualifier(Outcome.RelName.valueOf(relClass).toString(), relScheme)));

			ResultProject.Builder resultProject = ResultProject.newBuilder().setOutcome(outcome);

			return serializeOafRel(nodeList, eSource, eTarget, relType, SubRelType.outcome, relClass, collectedFromId, collectedFromName, false, resultProject, outcome);

		default:

			throw new IllegalArgumentException("unhandled relType: " + relationType);

		}

	}

	// ////////////////////////////////////////////////////////

	protected static String serializeOafEntity(final NodeList nodelist,

			final Type type,

			final String id,

			final KeyValue collectedFrom,

			final List<String> identities,

			final String dateOfCollection,

			final String dateOfTransformation,

			final Builder entity) {

		try {

			final FieldDescriptor md = entity.getDescriptorForType().findFieldByName("metadata");

			final OafEntity.Builder parent = getEntity(type, id, collectedFrom, identities, dateOfCollection, dateOfTransformation, null);

			final Builder metadata = entity.newBuilderForField(md);

			final DataInfo.Builder dataInfo = DataInfo.newBuilder();

			if (type.equals(Type.result)) {

				final Instance.Builder instance = Instance.newBuilder();

				parseNodelist(nodelist, instance);

				FieldDescriptor instanceDescriptor = Result.getDescriptor().findFieldByName(Instance.getDescriptor().getName());

				if (instanceDescriptor != null) {

					entity.setField(instanceDescriptor, instance);

				}

			}

			parseNodelist(nodelist, parent, entity, metadata, dataInfo);

			final FieldDescriptor entityDescriptor = OafEntity.getDescriptor().findFieldByName(type.toString());

			final Oaf build = getOaf(parent.setField(entityDescriptor, entity.setField(md, metadata.build()).build()), dataInfo);

			return base64(build.toByteArray());

		} catch (Exception e) {

			e.printStackTrace(System.err);

			throw new RuntimeException(e);

		}

	}

	protected static String serializeOafRel(final NodeList nodeList,

			final String sourceId,

			final String targetId,

			final RelType relType,

			final SubRelType subRelType,

			final String relClass,

			final String collectedFromId,

			final String collectedFromName,

			final boolean isChild,

			final Builder rel,

			final Builder subRel) {

		try {

			final DataInfo.Builder dataInfo = DataInfo.newBuilder();

			parseNodelist(nodeList, rel, subRel, dataInfo);

			OafRel.Builder builder = getRel(sourceId, targetId, relType, subRelType, relClass, collectedFromId, collectedFromName, isChild);

			FieldDescriptor subRelDescriptor = rel.getDescriptorForType().findFieldByName(subRelType.toString());

			rel.setField(subRelDescriptor, subRel.build());

			FieldDescriptor relDescriptor = OafRel.getDescriptor().findFieldByName(relType.toString());

			builder.setField(relDescriptor, rel.build());

			Oaf build = getOaf(builder, dataInfo);

			return base64(build.toByteArray());

		} catch (Exception e) {

			e.printStackTrace(System.err);

			throw new RuntimeException(e);

		}

	}

	private static void parseNodelist(final NodeList nodeList, final Builder... builders) {

		for (int i = 0; i < nodeList.getLength(); i++) {

			final Node fieldNode = nodeList.item(i);

			final Node attr = fieldNode.getAttributes().getNamedItem("name");

			final String fieldName = attr.getNodeValue();

			final NodeList children = fieldNode.getChildNodes();

			for (int j = 0; j < children.getLength(); j++) {

				final Node child = children.item(j);

				final String childName = child.getLocalName();

				if ("ITEM".equals(childName) || StringUtils.isBlank(childName)) {

					for (Builder builder : builders) {

						FieldDescriptor desc = builder.getDescriptorForType().findFieldByName(fieldName);

						if (desc != null) {

							String text = getText((StringUtils.isBlank(childName)) ? fieldNode : child);

							if (!StringUtils.isBlank(text)) {

								addField(builder, desc, text);

							}

						}

					}

				}

			}

		}

	}

	private static String getText(final Node node) {

		StringBuffer result = new StringBuffer();

		if (!node.hasChildNodes()) { return ""; }

		NodeList list = node.getChildNodes();

		for (int i = 0; i < list.getLength(); i++) {

			Node subnode = list.item(i);

			if (subnode.getNodeType() == Node.TEXT_NODE) {

				result.append(subnode.getNodeValue());

			} else if (subnode.getNodeType() == Node.CDATA_SECTION_NODE) {

				result.append(subnode.getNodeValue());

			} else if (subnode.getNodeType() == Node.ENTITY_REFERENCE_NODE) {

				result.append(getText(subnode));

			}

		}

		return result.toString().trim();

	}

}

package eu.dnetlib.openaire.exporter.model;

import java.io.IOException;

import java.io.StringReader;

import java.io.StringWriter;

import java.util.List;

import com.google.gson.Gson;

import org.supercsv.cellprocessor.Optional;

import org.supercsv.cellprocessor.ift.CellProcessor;

import org.supercsv.cellprocessor.ift.StringCellProcessor;

import org.supercsv.io.CsvBeanReader;

import org.supercsv.io.CsvBeanWriter;

import org.supercsv.io.ICsvBeanReader;

import org.supercsv.io.ICsvBeanWriter;

import org.supercsv.prefs.CsvPreference;

import org.supercsv.util.CsvContext;

/**

 * Created by claudio on 22/09/16.

 */

public class ProjectDetail {

	private static final String[] NAMEMAPPING = { "projectId", "acronym", "code", "optional1", "optional2", "jsonextrainfo", "fundingPath" };

	private String projectId;

	private String acronym;

	private String code;

	private String optional1;

	private String optional2;

	private String jsonextrainfo;

	private List<String> fundingPath;

	public ProjectDetail() {}

	public static ProjectDetail fromJson(final String json) {

		return new Gson().fromJson(json, ProjectDetail.class);

	}

	public static ProjectDetail fromCSV(final String csv) throws IOException {

		ICsvBeanReader beanReader = null;

		try {

			beanReader = new CsvBeanReader(new StringReader(csv), CsvPreference.STANDARD_PREFERENCE);

			return beanReader.read(ProjectDetail.class, NAMEMAPPING, getProcessors(new StringCellProcessor() {

				@Override

				public Object execute(final Object value, final CsvContext context) {

					return new Gson().fromJson(value.toString(), List.class);

				}

			}));

		} finally {

			if (beanReader != null) {

				beanReader.close();

			}

		}

	}

	/**

	 * Sets up the processors used for the examples. There are 10 CSV columns, so 10 processors are defined. Empty

	 * columns are read as null (hence the NotNull() for mandatory columns).

	 *

	 * @return the cell processors

	 */

	private static CellProcessor[] getProcessors(final CellProcessor fundingPathProcessor) {

		return new CellProcessor[] {

				new Optional(), // projectId

				new Optional(), // acronym

				new Optional(), // code

				new Optional(), // optional1

				new Optional(), // optional2

				new Optional(), // jsonextrainfo

				fundingPathProcessor

		};

	}

	public String asJson() {

		return new Gson().toJson(this) + '\n';

	}

	public String asCSV() throws IOException {

		final StringWriter sb = new StringWriter();

		try (ICsvBeanWriter beanWriter = new CsvBeanWriter(sb, CsvPreference.STANDARD_PREFERENCE)) {

			beanWriter.write(this, NAMEMAPPING, getProcessors(new StringCellProcessor() {

				@Override

				public Object execute(final Object value, final CsvContext context) {

					return new Gson().toJson(value);

				}

			}));

			beanWriter.flush();

		}

		return sb.toString();

	}

	public String getProjectId() {

		return projectId;

	}

	public ProjectDetail setProjectId(final String projectId) {

		this.projectId = projectId;

		return this;

	}

	public String getAcronym() {

		return acronym;

	}

	public ProjectDetail setAcronym(final String acronym) {

		this.acronym = acronym;

		return this;

	}

	public String getCode() {

		return code;

	}

	public ProjectDetail setCode(final String code) {

		this.code = code;

		return this;

	}

	public String getOptional1() {

		return optional1;

	}

	public ProjectDetail setOptional1(final String optional1) {

		this.optional1 = optional1;

		return this;

	}

	public String getOptional2() {

		return optional2;

	}

	public ProjectDetail setOptional2(final String optional2) {

		this.optional2 = optional2;

		return this;

	}

	public String getJsonextrainfo() {

		return jsonextrainfo;

	}

	public ProjectDetail setJsonextrainfo(final String jsonextrainfo) {

		this.jsonextrainfo = jsonextrainfo;

		return this;

	}

	public List<String> getFundingPath() {

		return fundingPath;

	}

	public ProjectDetail setFundingPath(final List<String> fundingPath) {

		this.fundingPath = fundingPath;

		return this;

	}

}

package eu.dnetlib.data.transform.xml;

import java.util.List;

import java.util.Map;

import com.google.common.collect.Iterables;

import com.google.common.collect.Lists;

import com.google.protobuf.Descriptors.Descriptor;

import eu.dnetlib.data.mapreduce.util.OafRowKeyDecoder;

import eu.dnetlib.data.proto.FieldTypeProtos.KeyValue;

import eu.dnetlib.data.proto.FieldTypeProtos.StructuredProperty;

import eu.dnetlib.data.proto.OafProtos.Oaf;

import eu.dnetlib.data.proto.OafProtos.OafEntity;

import eu.dnetlib.data.proto.PersonProtos.Person;

import eu.dnetlib.data.proto.ResultProtos.Result;

import eu.dnetlib.data.proto.ResultProtos.Result.Context;

import eu.dnetlib.data.proto.ResultProtos.Result.ExternalReference;

import eu.dnetlib.data.proto.ResultProtos.Result.Instance;

import eu.dnetlib.data.proto.ResultProtos.Result.Journal;

import eu.dnetlib.data.proto.TypeProtos.Type;

import org.apache.commons.lang.StringUtils;

import org.w3c.dom.NodeList;

public class OafToHbaseXsltFunctions extends CommonDNetXsltFunctions {

	public static String oafResult(

			final String resultId,

			final String provenance,

			final String trust,

			final NodeList about,

			final String hostedbyId,

			final String hostedbyName,

			final String collectedFromId,

			final String collectedFromName,

			final String originalId,

			final String dateOfCollection,

			final String dateOfTransformation,

			final NodeList nodelist) {

		try {

			final String entityId = OafRowKeyDecoder.decode(resultId).getKey();

			final ValueMap values = ValueMap.parseNodeList(nodelist);

			final Descriptor mDesc = Result.Metadata.getDescriptor();

			final Result.Metadata.Builder metadata = buildMetadata(values, mDesc);

			final Result.Builder result = buildResult(metadata, values, mDesc, hostedbyId, hostedbyName);

			final OafEntity.Builder entity = buildOafEntity(result, entityId, nodelist, getKV(collectedFromId, collectedFromName), originalId);

			entity.setDateofcollection(dateOfCollection)

					.setDateoftransformation(dateOfTransformation).setOaiprovenance(getOAIProvenance(about));

			final Oaf oaf = getOaf(entity, getDataInfo(about, provenance, trust, false, false));

			return base64(oaf.toByteArray());

		} catch (final Throwable e) {

			handleException(e, resultId, hostedbyId, hostedbyName, provenance, trust, collectedFromId, collectedFromName, originalId, dateOfCollection);

		}

		return null;

	}

	public static String oafResultUpdate(final String resultId,

			final String provenance,

			final String trust,

			final NodeList nodelist,

			final String hostedbyId,

			final String hostedbyName) {

		try {

			final String entityId = OafRowKeyDecoder.decode(resultId).getKey();

			final ValueMap values = ValueMap.parseNodeList(nodelist);

			final Descriptor mDesc = Result.Metadata.getDescriptor();

			final Result.Metadata.Builder metadata = buildMetadata(values, mDesc);

			final Result.Builder result = buildResult(metadata, values, mDesc, hostedbyId, hostedbyName);

			final OafEntity.Builder entity = buildOafEntity(result, entityId, nodelist, null, null);

			final Oaf oaf = getOaf(entity, null);

			return base64(oaf.toByteArray());

		} catch (final Throwable e) {

			handleException(e, resultId, hostedbyId, hostedbyName, provenance, trust, null, null, null, null);

		}

		return null;

	}

	private static OafEntity.Builder buildOafEntity(final Result.Builder result,

			final String entityId,

			final NodeList nodelist,

			KeyValue collectedFrom,

			String originalId) {

		final List<StructuredProperty> pids = Lists.newArrayList();

		pids.addAll(parsePids(nodelist));

		final OafEntity.Builder entity =

				getEntity(Type.result, entityId, collectedFrom, StringUtils.isBlank(originalId) ? null : Lists.newArrayList(originalId), null, null, pids)

						.setResult(result);

		return entity;

	}

	private static Result.Metadata.Builder buildMetadata(final ValueMap values, final Descriptor mDesc) {

		final Result.Metadata.Builder metadata = Result.Metadata.newBuilder();

		addStructuredProps(metadata, mDesc.findFieldByName("subject"), values.get("subject"), "keyword", "dnet:subject_classification_typologies");

		addStructuredProps(metadata, mDesc.findFieldByName("title"), values.get("title"), "main title", "dnet:dataCite_title");

		for (final String fieldname : Lists.newArrayList("description", "source", "contributor")) {

			if (values.get(fieldname) != null) {

				for (final String s : values.get(fieldname).listValues()) {

					addField(metadata, mDesc.findFieldByName(fieldname), s);

				}

			}

		}

		addField(metadata, mDesc.findFieldByName("language"), setQualifier(getDefaultQualifier("dnet:languages"), values.get("language").listValues()));

		addField(metadata, mDesc.findFieldByName("dateofacceptance"), values.get("dateaccepted").listValues());

		addField(metadata, mDesc.findFieldByName("publisher"), values.get("publisher").listValues());

		addField(metadata, mDesc.findFieldByName("embargoenddate"), values.get("embargoenddate").listValues());

		addField(metadata, mDesc.findFieldByName("storagedate"), values.get("storagedate").listValues());

		addField(metadata, mDesc.findFieldByName("resulttype"), getSimpleQualifier("publication", "dnet:result_typologies"));

		addField(metadata, mDesc.findFieldByName("fulltext"), values.get("fulltext").listValues());

		addField(metadata, mDesc.findFieldByName("format"), values.get("format").listValues());

		if (values.get("concept") != null) {

			for (final Element e : values.get("concept")) {

				final String id = e.getAttributes().get("id");

				if (StringUtils.isBlank(id)) throw new IllegalArgumentException("Context id cannot be blank");

				metadata.addContext(Context.newBuilder().setId(id));

			}

		}

		if (values.get("journal") != null) {

			for (final Element e : values.get("journal")) {

				final Journal.Builder journal = Journal.newBuilder();

				if (e.getText() != null) {

					journal.setName(e.getText());

				}

				final Map<String, String> attr = e.getAttributes();

				if (attr != null) {

					if (attr.get("issn") != null) {

						journal.setIssnPrinted(attr.get("issn"));

					}

					if (attr.get("eissn") != null) {

						journal.setIssnOnline(attr.get("eissn"));

					}

					if (attr.get("lissn") != null) {

						journal.setIssnLinking(attr.get("lissn"));

					}

				}

				metadata.setJournal(journal.build());

			}

		}

		return metadata;

	}

	private static Result.Builder buildResult(final Result.Metadata.Builder metadata,

			final ValueMap values,

			final Descriptor mDesc,

			final String hostedbyId,

			final String hostedbyName) {

		final Result.Builder result = Result.newBuilder();

		if (values.get("creator") != null) {

			for (final String fullname : Iterables.limit(values.get("creator").listValues(), 10)) {

				final Person.Metadata.Builder authorMetadata = Person.Metadata.newBuilder();

				authorMetadata.setFullname(sf(fullname));

				final eu.dnetlib.pace.model.Person p = new eu.dnetlib.pace.model.Person(fullname, false);

				if (p.isAccurate()) {

					authorMetadata.setFirstname(sf(p.getNormalisedFirstName()));

					authorMetadata.clearSecondnames().addSecondnames(sf(p.getNormalisedSurname()));

					authorMetadata.setFullname(sf(p.getNormalisedFullname()));

				}

				result.addAuthor(Person.newBuilder().setMetadata(authorMetadata));

			}

		}

		final Instance.Builder instance = Instance.newBuilder().setHostedby(getKV(hostedbyId, hostedbyName));

		addField(instance, Instance.getDescriptor().findFieldByName("licence"),

				setQualifier(getDefaultQualifier("dnet:access_modes"), values.get("accessrights").listValues()));

		addField(instance, Instance.getDescriptor().findFieldByName("instancetype"),

				setQualifier(getDefaultQualifier("dnet:publication_resource"), values.get("cobjcategory").listValues()));

		if (values.get("identifier") != null) {

			addField(instance, Instance.getDescriptor().findFieldByName("url"),

					Lists.newArrayList(Iterables.filter(values.get("identifier").listValues(), urlFilter)));

		}

		result.addInstance(instance);

		final List<Element> extrefs = values.get("reference");

		if (!extrefs.isEmpty()) {

			final Descriptor extDesc = ExternalReference.getDescriptor();

			for (final Element element : extrefs) {

				final ExternalReference.Builder extref = ExternalReference.newBuilder();

				addField(extref, extDesc.findFieldByName("url"), element.getText());

				addField(extref, extDesc.findFieldByName("sitename"), element.getAttributes().get("source"));

				addField(extref, extDesc.findFieldByName("refidentifier"), element.getAttributes().get("identifier"));

				addField(extref, extDesc.findFieldByName("label"), element.getAttributes().get("title"));

				addField(extref, extDesc.findFieldByName("query"), element.getAttributes().get("query"));

				addField(extref, extDesc.findFieldByName("qualifier"),

						setQualifier(getDefaultQualifier("dnet:externalReference_typologies"), Lists.newArrayList(element.getAttributes().get("type")))

								.build());

				result.addExternalReference(extref);

			}

		}

		return result.setMetadata(metadata);

	}

	private static void handleException(Throwable e, final String resultId, final String hostedbyId, final String hostedbyName,

			final String provenance, final String trust, final String collectedFromId, final String collectedFromName,

			final String originalId, final String dateOfCollection) {

		System.err.println("resultId: " + resultId);

		if (StringUtils.isNotBlank(hostedbyId)) System.err.println("hostedbyId: " + hostedbyId);

		if (StringUtils.isNotBlank(hostedbyName)) System.err.println("hostedbyName: " + hostedbyName);

		if (StringUtils.isNotBlank(provenance)) System.err.println("provenance: " + provenance);

		if (StringUtils.isNotBlank(trust)) System.err.println("trust: " + trust);

		if (StringUtils.isNotBlank(collectedFromId)) System.err.println("collectedFromId: " + collectedFromId);

		if (StringUtils.isNotBlank(collectedFromName)) System.err.println("collectedFromName: " + collectedFromName);

		if (StringUtils.isNotBlank(originalId)) System.err.println("originalId: " + originalId);

		if (StringUtils.isNotBlank(dateOfCollection)) System.err.println("dateOfCollection: " + dateOfCollection);

		e.printStackTrace();

		throw new RuntimeException(e);

	}

}

package eu.dnetlib.pace.model;

import java.util.List;

import java.util.Map;

import com.google.common.collect.Maps;

import com.google.protobuf.GeneratedMessage;

import eu.dnetlib.data.transform.AbstractProtoMapper;

public class ProtoDocumentBuilder extends AbstractProtoMapper {

	public static MapDocument newInstance(final String id, final GeneratedMessage proto, final List<FieldDef> fields) {

		final Map<String, Field> fieldMap = new ProtoDocumentBuilder().generateFieldMap(proto, fields);

		return new MapDocument(id, fieldMap);

	}

	private Map<String, Field> generateFieldMap(final GeneratedMessage proto, final List<FieldDef> fields) {

		final Map<String, Field> fieldMap = Maps.newHashMap();

		for (final FieldDef fd : fields) {

			final FieldList fl = new FieldListImpl(fd.getName(), fd.getType());

			for (final Object o : processPath(proto, fd.getPathList(), fd.getType())) {

				fl.add(new FieldValueImpl(fd.getType(), fd.getName(), o));

			}

			fieldMap.put(fd.getName(), fl);

		}

		return fieldMap;

	}

}

package eu.dnetlib.data.transform.xml;

import java.util.List;

import java.util.Map;

import com.google.common.collect.Lists;

import com.google.common.collect.Maps;

import eu.dnetlib.data.mapreduce.util.OafRowKeyDecoder;

import eu.dnetlib.data.proto.FieldTypeProtos.StructuredProperty;

import eu.dnetlib.data.proto.OafProtos.Oaf;

import eu.dnetlib.data.proto.OafProtos.OafEntity;

import eu.dnetlib.data.proto.ResultProtos.Result;

import eu.dnetlib.data.proto.ResultProtos.Result.Instance;

import eu.dnetlib.data.proto.TypeProtos.Type;

import org.w3c.dom.NamedNodeMap;

import org.w3c.dom.Node;

import org.w3c.dom.NodeList;

public class OdfToHbaseXsltFunctions extends CommonDNetXsltFunctions {

	private static Map<String, String> mappingAccess = Maps.newHashMap();

	static {

		mappingAccess.put("info:eu-repo/semantics/openAccess", "OPEN");

		mappingAccess.put("info:eu-repo/semantics/closedAccess", "CLOSED");

		mappingAccess.put("info:eu-repo/semantics/restrictedAccess", "RESTRICTED");

		mappingAccess.put("info:eu-repo/semantics/embargoedAccess", "EMBARGO");

		// Transformator now maps the access rights into proper values, not sure if it does for all datasets.

		mappingAccess.put("OPEN", "OPEN");

		mappingAccess.put("CLOSED", "CLOSED");

		mappingAccess.put("RESTRICTED", "RESTRICTED");

		mappingAccess.put("EMBARGO", "EMBARGO");

	}

	public static String odfResult(

			final String resultId,

			final NodeList about,

			final NodeList metadata,

			final NodeList titles,

			final NodeList subjects,

			final NodeList publisher,

			final NodeList descriptions,

			final NodeList dates,

			final NodeList dateaccepted,

			final NodeList resourceTypes,

			final NodeList formats,

			final NodeList sizes,

			final NodeList languages,

			final NodeList cobjcategory,

			final NodeList contributors,

			final NodeList rights,

			final NodeList version,

			final NodeList pidList,

			final String provenance,

			final String trust,

			final String hostedbyId,

			final String hostedbyName,

			final String collectedfromId,

			final String collectedfromName,

			final NodeList originalIds,

			final String instanceUri,

			final String dateOfCollection,

			final String dateOfTransformation) {

		try {

			final String entityId = OafRowKeyDecoder.decode(resultId).getKey();

			final Result.Builder result = Result.newBuilder();

			Result.Metadata.Builder metadataProto = Result.Metadata.newBuilder();

			// subject

			for (int i = 0; i < subjects.getLength(); i++) {

				Node currentNode = subjects.item(i);

				NodeList childNodes = currentNode.getChildNodes();

				if (childNodes.getLength() > 0) {

					String subjectValue = childNodes.item(0).getNodeValue();

					addField(metadataProto, Result.Metadata.getDescriptor().findFieldByName("subject"),

							getStructuredProperty(subjectValue, "keyword", "keyword", "dnet:subject_classification_typologies", "dnet:subject_classification_typologies"));

				}

			}

			// title

			for (int i = 0; i < titles.getLength(); i++) {

				Node currentNode = titles.item(i);

				NodeList childNodes = currentNode.getChildNodes();

				if (childNodes.getLength() > 0) {

					String titleValue = childNodes.item(0).getNodeValue();

					String classname = "main title";

					String classid = "main title";

					if (currentNode.hasAttributes()) {

						NamedNodeMap attributes = currentNode.getAttributes();

						Node titleType = attributes.getNamedItem("titleType");

						if (titleType != null && titleType.getNodeValue().equals("AlternativeTitle")) {

							classname = "alternative title";

							classid = "alternative title";

						}

						if (titleType != null && titleType.getNodeValue().equals("Subtitle")) {

							classname = "subtitle";

							classid = "subtitle";

						}

						if (titleType != null && titleType.getNodeValue().equals("TranslatedTitle")) {

							classname = "translated title";

							classid = "translated title";

						}

					}

					addField(metadataProto, Result.Metadata.getDescriptor().findFieldByName("title"),

							getStructuredProperty(titleValue, classname, classid, "dnet:dataCite_title", "dnet:dataCite_title"));

				}

			}

			// description

			for (int i = 0; i < descriptions.getLength(); i++) {

				Node currentNode = descriptions.item(i);

				if (currentNode != null && currentNode.hasChildNodes()) {

					String descriptionValue = currentNode.getChildNodes().item(0).getNodeValue();

					addField(metadataProto, Result.Metadata.getDescriptor().findFieldByName("description"), descriptionValue);

				}

			}

			// contributors

			for (int i = 0; i < contributors.getLength(); i++) {

				Node currentNode = contributors.item(i);

				if (currentNode != null && currentNode.hasChildNodes()) {

					String contributorValue = currentNode.getChildNodes().item(0).getNodeValue();

					addField(metadataProto, Result.Metadata.getDescriptor().findFieldByName("contributor"), contributorValue);

				}

			}

			// publisher

			addField(metadataProto, Result.Metadata.getDescriptor().findFieldByName("publisher"), getFirstItem(publisher));

			// dates

			for (int i = 0; i < dates.getLength(); i++) {

				Node currentNode = dates.item(i);

				if (currentNode != null && currentNode.hasAttributes() && currentNode.hasChildNodes()) {

					String dateAttribute = currentNode.getAttributes().getNamedItem("dateType").getNodeValue();

					String dateValue = currentNode.getChildNodes().item(0).getNodeValue();

					String protoAttribute = "relevantdate";

					if ("Accepted".equals(dateAttribute)) {

						protoAttribute = "dateofacceptance";

					} else if ("Issued".equals(dateAttribute)) {

						protoAttribute = "storagedate";

					} else if ("Updated".equals(dateAttribute)) {

						protoAttribute = "lastmetadataupdate";

					} else if ("Available".equals(dateAttribute)) {

						protoAttribute = "embargoenddate";

					}

					if (protoAttribute.equals("relevantdate") == false) {

						addField(metadataProto, Result.Metadata.getDescriptor().findFieldByName(protoAttribute), dateValue);

					} else {

						addField(metadataProto, Result.Metadata.getDescriptor().findFieldByName(protoAttribute),

								getStructuredProperty(dateValue, "UNKNOWN", "UNKNOWN", "dnet:dataCite_date", "dnet:dataCite_date"));

					}

				}

			}

			// dateofacceptance

			addField(metadataProto, Result.Metadata.getDescriptor().findFieldByName("dateofacceptance"), getFirstItem(dateaccepted));

			// size

			addField(metadataProto, Result.Metadata.getDescriptor().findFieldByName("size"), getFirstItem(sizes));

			// format

			addField(metadataProto, Result.Metadata.getDescriptor().findFieldByName("format"), getFirstItem(formats));

			// version

			addField(metadataProto, Result.Metadata.getDescriptor().findFieldByName("version"), getFirstItem(version));

			// language

			addField(metadataProto, Result.Metadata.getDescriptor().findFieldByName("language"),

					setQualifier(getDefaultQualifier("dnet:languages"), Lists.newArrayList(getFirstItem(languages))));

			//resource type

			addField(metadataProto, Result.Metadata.getDescriptor().findFieldByName("resourcetype"),

					setQualifier(getDefaultQualifier("dnet:dataCite_resource"), Lists.newArrayList(getFirstItem(resourceTypes))));

			// resultType

			addField(metadataProto, Result.Metadata.getDescriptor().findFieldByName("resulttype"), getSimpleQualifier("dataset", "dnet:result_typologies"));

			String tmpID;

			String TmpName;

			if (hostedbyId == null && hostedbyName == null) {

				tmpID = collectedfromId;

				TmpName = collectedfromName;

			} else {

				tmpID = hostedbyId;

				TmpName = hostedbyName;

			}

			final Instance.Builder instance = Instance.newBuilder().setHostedby(getKV(tmpID, TmpName));

			String tmpRigths = "UNKNOWN";

			final String firstRight = getFirstItem(rights);

			if (mappingAccess.containsKey(firstRight)) {

				tmpRigths = mappingAccess.get(firstRight);

			}

			addField(instance, Instance.getDescriptor().findFieldByName("licence"),

					setQualifier(getDefaultQualifier("dnet:access_modes"), Lists.newArrayList(tmpRigths)));

			addField(instance, Instance.getDescriptor().findFieldByName("instancetype"),

					setQualifier(getDefaultQualifier("dnet:dataCite_resource"), Lists.newArrayList(getFirstItem(cobjcategory))));

			addField(instance, Instance.getDescriptor().findFieldByName("url"), instanceUri);

			result.addInstance(instance);

			List<StructuredProperty> pids = parsePids(pidList);

			// original ids

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

			for (int i = 0; i < originalIds.getLength(); i++) {

				Node currentNode = originalIds.item(i);

				if (currentNode != null && currentNode.hasChildNodes()) {

					originalIdList.add(currentNode.getChildNodes().item(0).getNodeValue());

				}

			}

			OafEntity.Builder entity =

					getEntity(Type.result, entityId, getKV(collectedfromId, collectedfromName), originalIdList, dateOfCollection, dateOfTransformation, pids).setResult(

							result.setMetadata(metadataProto));

			entity.setOaiprovenance(getOAIProvenance(about));

			Oaf oaf = getOaf(entity, getDataInfo(about, provenance, trust, false, false));

			return base64(oaf.toByteArray());

		} catch (Exception e) {

			e.printStackTrace(System.err);

			throw new RuntimeException(e);

		}

	}

	public static String getFirstItem(final NodeList list) {

		String out = "";

		if (list != null) {

			if (list.getLength() > 0 && list.item(0).getChildNodes() != null && list.item(0).getChildNodes().getLength() > 0) {

				out = list.item(0).getChildNodes().item(0).getNodeValue();

			}

		}

		return out;

	}

}

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

<xsl:stylesheet xmlns:xsl="http://www.w3.org/1999/XSL/Transform"

	xmlns:dc="http://purl.org/dc/elements/1.1/" xmlns:dr="http://www.driver-repository.eu/namespace/dr"

	xmlns:dri="http://www.driver-repository.eu/namespace/dri" xmlns:oaa="http://namespace.openaire.eu/oaa"

	xmlns:oaf="http://namespace.openaire.eu/oaf" xmlns:dnet="eu.dnetlib.data.transform.xml.OafToHbaseXsltFunctions"

	xmlns:exslt="http://exslt.org/common"

	xmlns:action="http://namespace.openaire.eu/action" version="1.0"

	extension-element-prefixes="exslt"

	exclude-result-prefixes="xsl dc dr dri oaa oaf dnet exslt">

	<xsl:output omit-xml-declaration="yes" indent="yes" />

	<xsl:param name="trust" select="string('0.9')" />

	<xsl:param name="provenance" select="string('UNKNOWN')" />

	<xsl:template match="/*">

		<xsl:choose>

			<xsl:when test="count(//RELATION) = 0">

				<ACTIONS />

			</xsl:when>

			<xsl:otherwise>

				<ACTIONS>

					<xsl:for-each select="//RELATION">

						<xsl:choose>

							<xsl:when test="./@type = 'resultProject'">

								<xsl:variable name="resultId" select="./@source" />

								<xsl:variable name="projectId">

									<xsl:choose>

										<xsl:when test="starts-with(@target, '40|')">

											<xsl:value-of select="./@target" />

										</xsl:when>

										<xsl:otherwise>

											<xsl:value-of select="dnet:oafSplitId('project', normalize-space(@target))"/>

										</xsl:otherwise>

									</xsl:choose>

								</xsl:variable>

								<ACTION targetKey="{$resultId}" targetColumnFamily="resultProject_outcome_isProducedBy" targetColumn="{$projectId}">

									<xsl:value-of select="dnet:rel($resultId, $projectId, 'resultProject', 'outcome', 'isProducedBy', $provenance, $trust)" />

								</ACTION>

								<ACTION targetKey="{$projectId}" targetColumnFamily="resultProject_outcome_produces" targetColumn="{$resultId}">

									<xsl:value-of select="dnet:rel($projectId, $resultId, 'resultProject', 'outcome', 'produces', $provenance, $trust)" />

								</ACTION>

							</xsl:when>

							<!-- TODO: check this block, it caused problems:

									Cannot convert argument/return type in call to method 'eu.dnetlib.actionmanager.actions.infopackage.DMFInfoPackageToHbaseXsltFunctions.oafPersonResultFromInfoPackage(node-set, node-set, result-tree, reference, reference)'

									FATAL ERROR:  'Could not compile stylesheet'

							<xsl:when test="./@type = 'personResult'">

								<xsl:variable name="personId" select="./@source" />

								<xsl:variable name="resultId" select="./@target" />

								<xsl:variable name="pos">

									<xsl:choose>

										<xsl:when test="@position"><xsl:value-of select="@position"/></xsl:when>

										<xsl:otherwise>1000</xsl:otherwise>

									</xsl:choose>

								</xsl:variable>

								<ACTION targetKey="{$personId}" targetColumnFamily="personResult" targetColumn="{$resultId}">

									<xsl:value-of select="dnet:oafPersonResultFromInfoPackage($personId, $resultId, $pos, $provenance, $trust)" />

								</ACTION>

								<ACTION targetKey="{$resultId}" targetColumnFamily="personResult" targetColumn="{$personId}">

									<xsl:value-of select="dnet:oafPersonResultFromInfoPackage($resultId, $personId, $pos, $provenance, $trust)" />

								</ACTION>

							</xsl:when>

							-->

						</xsl:choose>

					</xsl:for-each>

				</ACTIONS>

			</xsl:otherwise>

		</xsl:choose>

	</xsl:template>

</xsl:stylesheet>

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

<xsl:stylesheet xmlns:xsl="http://www.w3.org/1999/XSL/Transform"

                xmlns:dc="http://purl.org/dc/elements/1.1/" xmlns:dr="http://www.driver-repository.eu/namespace/dr"

                xmlns:dri="http://www.driver-repository.eu/namespace/dri" xmlns:oaa="http://namespace.openaire.eu/oaa"

                xmlns:oaf="http://namespace.openaire.eu/oaf" xmlns:dnet="eu.dnetlib.data.transform.xml.OafToHbaseXsltFunctions"

                xmlns:date="java.lang.System"

                xmlns:exslt="http://exslt.org/common"

                version="1.0"

                extension-element-prefixes="exslt"

                exclude-result-prefixes="xsl dc dr dri oaa oaf dnet exslt date">

    <xsl:output omit-xml-declaration="yes" indent="yes"/>

    <xsl:param name="trust" select="string('0.9')"/>

    <xsl:param name="provenance" select="string('UNKNOWN')"/>

    <xsl:template match="/*">

        <xsl:variable name="about" select="/*[local-name() = 'record']/*[local-name() = 'about']"/>

        <xsl:variable name="dateofcollection" select="//dr:dateOfCollection"/>

        <xsl:variable name="dateoftransformation" select="//dr:dateOfTransformation"/>

        <xsl:variable name="metadata" select="exslt:node-set(//*[local-name()='metadata']/*)"/>

        <xsl:choose>

            <xsl:when test="count($metadata) = 0">

                <ROWS/>

            </xsl:when>

            <xsl:otherwise>

                <xsl:variable name="objidentifier" select="/record/*[local-name() = 'header']/*[local-name() = 'objIdentifier']"/>

                <xsl:variable name="resultId" select="dnet:oafSimpleId('result', $objidentifier)"/>

                <xsl:variable name="hostedbyid" select="dnet:oafSplitId('datasource', //oaf:hostedBy/@id)"/>

                <xsl:variable name="hostedbyname" select="//oaf:hostedBy/@name"/>

                <xsl:variable name="collectedfromid" select="dnet:oafSplitId('datasource', //oaf:collectedFrom/@id)"/>

                <xsl:variable name="collectedfromname" select="//oaf:collectedFrom/@name"/>

                <xsl:variable name="originalidTest" select="/record/*[local-name() = 'header']/*[local-name() = 'recordIdentifier']"/>

                <xsl:variable name="originalid">

                    <xsl:choose>

                        <xsl:when test="contains($originalidTest, '::')">

                            <xsl:value-of select="substring-after($originalidTest, '::')"/>

                        </xsl:when>

                        <xsl:otherwise>

                            <xsl:value-of select="$originalidTest"/>

                        </xsl:otherwise>

                    </xsl:choose>

                </xsl:variable>

                <xsl:variable name="result"

                              select="dnet:oafResult($resultId, $provenance, $trust, $about, $hostedbyid, $hostedbyname,

	                          $collectedfromid, $collectedfromname, $originalid, $dateofcollection, $dateoftransformation, $metadata)"/>

                <ROWS>

	                <ROW targetKey="{$resultId}" targetColumnFamily="result">

                        <QUALIFIER name="{concat('update_', date:nanoTime())}" type="base64"><xsl:value-of select="$result"/></QUALIFIER>

                    </ROW>

                </ROWS>

            </xsl:otherwise>

        </xsl:choose>

    </xsl:template>