D-Net

package eu.dnetlib.parthenos.registry;

import java.io.IOException;

import java.io.InputStream;

import java.util.UUID;

import eu.dnetlib.parthenos.CRM;

import eu.dnetlib.parthenos.CRMdig;

import eu.dnetlib.parthenos.CRMpe;

import org.apache.commons.io.IOUtils;

import org.apache.jena.ontology.OntModel;

import org.apache.jena.ontology.OntModelSpec;

import org.apache.jena.rdf.model.InfModel;

import org.apache.jena.rdf.model.ModelFactory;

import org.apache.jena.rdf.model.ResIterator;

import org.apache.jena.rdf.model.Resource;

import org.apache.jena.vocabulary.RDF;

import org.gcube.informationsystem.resourceregistry.api.exceptions.ResourceRegistryException;

import org.junit.Before;

import org.junit.Ignore;

import org.junit.Test;

import org.junit.runner.RunWith;

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

import org.springframework.boot.test.context.SpringBootTest;

import org.springframework.core.io.ClassPathResource;

import org.springframework.test.context.TestPropertySource;

import org.springframework.test.context.junit4.SpringJUnit4ClassRunner;

/**

 * Created by Alessia Bardi on 28/09/2017.

 *

 * //TODO: Avoid loading remote resources (see setup())

 *

 * @author Alessia Bardi

 */

@Ignore

@RunWith(SpringJUnit4ClassRunner.class)

@SpringBootTest

@TestPropertySource(

		locations = "classpath:application-integrationtest.properties")

public class GCubeResourceRegistratorIntegrationTest {

	private String nakalaService = "eu/dnetlib/parthenos/registry/nakala.rdf";

	private String test = "eu/dnetlib/parthenos/registry/test.rdf";

	@Autowired

	private GCubeResourceRegistrator reg;

	private OntModel baseModel;

	@Before

	public void setup() throws ResourceRegistryException {

		baseModel = ModelFactory.createOntologyModel(OntModelSpec.RDFS_MEM_TRANS_INF);

		baseModel.read(CRMpe.RDFS_URL);

		baseModel.read(CRM.RDFS_URL);

		baseModel.read(CRMdig.RDFS_URL);

	}

	@Test

	public void testRegistration() throws Exception{

		String resource = getString(nakalaService);

		InfModel model = loadBaseModel();

		model.read(IOUtils.toInputStream(resource, "UTF-8"), CRMpe.NS);

		ResIterator subjects = model.listSubjectsWithProperty(RDF.type, CRM.E7_Activity);

		if (subjects.hasNext()) {

			Resource subject = subjects.nextResource();

			UUID uuid = UUID.randomUUID();

			System.out.println("Registering for uuid "+ uuid.toString());

			reg.register(subject, uuid.toString(), CRM.E7_Activity);

			reg.deleteResourcebyUUID(CRMpe.PE1_Service, uuid);

		}

	}

	//@Test

	//public void delete() throws ResourceRegistryException {

	//	reg.deleteResourcebyUUID(UUID.fromString("2adce5d8-66fe-41d6-9d4d-6ecd26faa8c3"));

	//}

	private String getString(final String classpath) {

		try {

			final ClassPathResource resource = new ClassPathResource(classpath);

			return IOUtils.toString(resource.getInputStream(), "UTF-8");

		}catch(IOException e){

			return null;

		}

	}

	private static InputStream getStream(final String classpath) throws IOException {

		return new ClassPathResource(classpath).getInputStream();

	}

	protected InfModel loadBaseModel() {

		return ModelFactory.createRDFSModel(baseModel);

	}

}

package eu.dnetlib.parthenos.registry;

import java.io.IOException;

import java.io.InputStream;

import java.io.StringWriter;

import com.fasterxml.jackson.core.JsonFactory;

import com.fasterxml.jackson.core.JsonGenerator;

import eu.dnetlib.parthenos.CRM;

import eu.dnetlib.parthenos.CRMdig;

import eu.dnetlib.parthenos.CRMpe;

import eu.dnetlib.parthenos.rdf.ResourceReader;

import org.apache.jena.ontology.OntModelSpec;

import org.apache.jena.rdf.model.InfModel;

import org.apache.jena.rdf.model.ModelFactory;

import org.apache.jena.rdf.model.ResIterator;

import org.apache.jena.rdf.model.Resource;

import org.apache.jena.vocabulary.RDF;

import org.junit.Assert;

import org.junit.Before;

import org.junit.Test;

import org.junit.runner.RunWith;

import org.junit.runners.JUnit4;

import org.springframework.core.io.ClassPathResource;

/**

 * Created by Alessia Bardi on 02/10/2017.

 *

 * @author Alessia Bardi

 */

@RunWith(JUnit4.class)

public class FacetWriterTest {

	private FacetWriter facetWriter;

	private ResourceReader rr;

	private static String baseURI = "http://parthenos.d4science.org/CRMext/CRMpe.rdfs/";

	@Before

	public void setup(){

		facetWriter = new FacetWriter();

		rr = new ResourceReader();

		facetWriter.setResourceReader(rr);

	}

	/**

	 *

	 * Method: writeIdentifierFacet(final JsonGenerator jg, final String identifier)

	 *

	 */

	@Test

	public void testWriteIdentifierFacet() throws Exception {

		JsonFactory jsonFactory = new JsonFactory();

		StringWriter sw = new StringWriter();

		JsonGenerator jg = jsonFactory.createGenerator(sw);

		facetWriter.writeIdentifierFacet(jg, "thisIsAnIDentifier");

		jg.close();

		System.out.println(sw.toString());

		Assert.assertEquals("{\"@class\":\"isIdentifiedBy\",\"target\":{\"@class\":\"IdentifierFacet\",\"value\":\"thisIsAnIDentifier\",\"type\":\"URI\"}}", sw.toString());

	}

	/**

	 *

	 * Method: writeContactReferenceFacet(final JsonGenerator jg, final Resource resource)

	 *

	 */

	@Test

	public void testWriteContactReferenceFacet() throws Exception {

		JsonFactory jsonFactory = new JsonFactory();

		StringWriter sw = new StringWriter();

		JsonGenerator jg = jsonFactory.createGenerator(sw);

		InfModel model = ModelFactory.createOntologyModel(OntModelSpec.RDFS_MEM_TRANS_INF);

		model.read(CRMpe.RDFS_URL);

		model.read(CRM.RDFS_URL);

		model.read(CRMdig.RDFS_URL);

		model.read(getStream("eu/dnetlib/parthenos/registry/test.rdf"), baseURI);

		model = ModelFactory.createRDFSModel(model);

		ResIterator iter = model.listResourcesWithProperty(RDF.type, CRMpe.PE1_Service);

		if(iter.hasNext()){

			Resource r = iter.nextResource();

			System.out.println("Found service "+r.getURI());

			facetWriter.writeContactReferenceFacet(jg, r);

			jg.close();

			System.out.println(sw.toString());

		}

		else {

			System.out.println("Could not find any service");

			throw new Exception("I was expecting some PE1_Service or subclass instances!");

		}

	}

	private InputStream getStream(final String classpath) throws IOException {

		return new ClassPathResource(classpath).getInputStream();

	}

}

package eu.dnetlib.parthenos.registry;

import java.io.IOException;

import com.fasterxml.jackson.core.JsonFactory;

import org.junit.Test;

import org.junit.runner.RunWith;

import org.junit.runners.JUnit4;

/**

 * Created by Alessia Bardi on 06/10/2017.

 *

 * @author Alessia Bardi

 */

@RunWith(JUnit4.class)

public class RelWriterTest {

	private RelWriter relWriter = new RelWriter();

	@Test

	public void test() throws IOException {

		String rel = relWriter.writeRelationship(new JsonFactory(), "theType", "uuid1", "typeSource", "uuid2", "typeTarget");

		System.out.println(rel);

	}

}

package eu.dnetlib.parthenos.registry;

import java.io.IOException;

import java.io.InputStream;

import java.util.List;

import com.fasterxml.jackson.core.JsonFactory;

import eu.dnetlib.parthenos.CRM;

import eu.dnetlib.parthenos.CRMdig;

import eu.dnetlib.parthenos.CRMpe;

import eu.dnetlib.parthenos.jrr.ParthenosRegistryRel;

import eu.dnetlib.parthenos.jrr.ParthenosRegistryResource;

import eu.dnetlib.parthenos.publisher.ParthenosPublisherException;

import eu.dnetlib.parthenos.rdf.ResourceReader;

import org.apache.commons.io.IOUtils;

import org.apache.commons.lang3.StringUtils;

import org.apache.jena.ontology.OntModel;

import org.apache.jena.ontology.OntModelSpec;

import org.apache.jena.rdf.model.*;

import org.apache.jena.vocabulary.RDF;

import org.gcube.informationsystem.resourceregistry.api.exceptions.ResourceRegistryException;

import org.gcube.informationsystem.resourceregistry.client.ResourceRegistryClient;

import org.junit.Before;

import org.junit.Ignore;

import org.junit.Test;

import org.junit.runner.RunWith;

import org.junit.runners.JUnit4;

import org.mockito.Mockito;

import org.springframework.core.io.ClassPathResource;

import static org.junit.Assert.assertEquals;

/**

 * Created by Alessia Bardi on 28/09/2017.

 *

 * //TODO: Avoid loading remote resources (see setup())

 *

 * @author Alessia Bardi

 */

@Ignore

@RunWith(JUnit4.class)

public class GCubeResourceRegistratorTest {

	private String nakalaService = "eu/dnetlib/parthenos/registry/nakala.rdf";

	private String test = "eu/dnetlib/parthenos/registry/test.rdf";

	private GCubeResourceRegistrator reg;

	private OntModel baseModel;

	private ResourceRegistryClient regClient = Mockito.mock(ResourceRegistryClient.class);

	@Before

	public void setup() throws ResourceRegistryException {

		reg = new GCubeResourceRegistrator();

		FacetWriter facetWriter = new FacetWriter();

		facetWriter.setResourceReader(new ResourceReader());

		reg.setFacetWriter(facetWriter);

		reg.setResourceReader(new ResourceReader());

		baseModel = ModelFactory.createOntologyModel(OntModelSpec.RDFS_MEM_TRANS_INF);

		baseModel.read(CRMpe.RDFS_URL);

		baseModel.read(CRM.RDFS_URL);

		baseModel.read(CRMdig.RDFS_URL);

		Mockito.when(regClient.query(Mockito.anyString(), Mockito.anyInt(), Mockito.anyString())).thenReturn(null);

		reg.setResourceRegistryClient(regClient);

	}

	@Test

	public void testProcessService() throws Exception{

		String resource = getString(nakalaService);

		InfModel model = loadBaseModel();

		model.read(IOUtils.toInputStream(resource, "UTF-8"), CRMpe.NS);

		ResIterator subjects = model.listSubjectsWithProperty(RDF.type, CRM.E7_Activity);

		while (subjects.hasNext()) {

			Resource subject = subjects.nextResource();

			ParthenosRegistryResource prr = reg.processService(subject, new JsonFactory(), "FAKEUUID");

			System.out.println(prr.getJson());

			final List<ParthenosRegistryRel> resourceRels = reg.getResourceRels(subject, prr);

			for(ParthenosRegistryRel r : resourceRels){

				System.out.println(r.getJson());

			}

		}

	}

	@Test

	public void testLoadBaseModel() {

		//let's snapshot to a normal model to write all statements

		Model snapshot = ModelFactory.createDefaultModel();

		snapshot.add(baseModel);

	}

	@Test

	public void testLoadRDFFileWithModel() throws IOException {

		//let's snapshot to a normal model to write all statements

		Model snapshot = ModelFactory.createDefaultModel();

		snapshot.add(baseModel);

		snapshot.write(System.out);

	}

	@Test

	public void testRules() throws IOException {

		StmtIterator it = baseModel.listStatements(new SimpleSelector(ResourceFactory.createResource("uuid:AAAH"), RDF.type, (Resource) null));

		while(it.hasNext()){

			System.out.println(it.nextStatement().toString());

		}

		Resource classHS = ResourceFactory.createResource(CRMpe.NS+"PE1_Service");

		StmtIterator it2 = baseModel.listStatements(classHS, RDF.type, (Resource) null);

		while(it2.hasNext()){

			System.out.println(it2.nextStatement().toString());

		}

	}

	@Test

	public void testAmbiguousSpecificType() throws IOException {

		Resource res = baseModel.getResource("uuid:AAAH");

		Resource specificType = reg.getResourceReader().findSpecificType(res, CRMpe.PE1_Service);

		System.out.println(specificType.getURI());

		assertEquals(CRMpe.PE1_Service.getURI(), specificType.getURI());

	}

	@Test

	public void testDashes() throws IOException {

		System.out.println(StringUtils.remove(CRMpe.NS+"PE1_Service-HOLA", "-"));

	}

	@Test

	public void testJsonGeneration1() throws IOException, ResourceRegistryException, ParthenosPublisherException {

		testJsonGeneration(test);

	}

	@Test

	public void testJsonGeneration2() throws IOException, ResourceRegistryException, ParthenosPublisherException {

		//testJsonGeneration(recordPath);

	}

	@Test

	public void testJsonGeneration3() throws IOException, ResourceRegistryException, ParthenosPublisherException {

		testJsonGeneration(nakalaService);

	}

	private void testJsonGeneration(final String recordClasspath) throws IOException, ResourceRegistryException,

			ParthenosPublisherException {

		try {

			//reg.register(getString(recordClasspath), objIdentifier);

		}catch(NullPointerException npe){

			//ok: it is because of the registryPublisher

		}

	}

	private String getString(final String classpath) {

		try {

			final ClassPathResource resource = new ClassPathResource(classpath);

			return IOUtils.toString(resource.getInputStream(), "UTF-8");

		}catch(IOException e){

			return null;

		}

	}

	private static InputStream getStream(final String classpath) throws IOException {

		return new ClassPathResource(classpath).getInputStream();

	}

	protected InfModel loadBaseModel() {

		return ModelFactory.createRDFSModel(baseModel);

	}

}

package org.gcube.informationsystem.resourceregistry.publisher;

/**

 * Created by Alessia Bardi on 26/09/2017.

 *

 * @author Alessia Bardi

 */

public class ParthenosRegistryPublisherSetter {

	public static void forceToURL(String url) {

		ResourceRegistryPublisherFactory.forceToURL(url);

	}

}

package org.gcube.informationsystem.resourceregistry.client;

/**

 * Created by Alessia Bardi on 26/09/2017.

 *

 * @author Alessia Bardi

 */

public class ParthenosRegistryClientSetter {

	public static void forceToURL(String url) {

		ResourceRegistryClientFactory.forceToURL(url);

	}

}

package eu.dnetlib.parthenos.registry;

import java.io.BufferedOutputStream;

import java.io.ByteArrayOutputStream;

import java.io.IOException;

import com.fasterxml.jackson.core.JsonEncoding;

import com.fasterxml.jackson.core.JsonFactory;

import com.fasterxml.jackson.core.JsonGenerator;

import org.springframework.stereotype.Component;

/**

 * Created by Alessia Bardi on 02/10/2017.

 *

 * @author Alessia Bardi

 */

@Component

public class RelWriter {

	protected String writeRelationship(final JsonFactory jsonFactory, final String relType, final String sourceUUID, final String sourceType, final String targetUUID, final String targetType)

			throws IOException {

		final ByteArrayOutputStream out = new ByteArrayOutputStream();

		BufferedOutputStream bos = new BufferedOutputStream(out);

		JsonGenerator jg = jsonFactory.createGenerator(bos, JsonEncoding.UTF8);

		jg.writeStartObject();

		jg.writeStringField("@class", relType);

		jg.writeObjectFieldStart("source");

		jg.writeObjectFieldStart("header");

		jg.writeStringField("uuid", sourceUUID);

		jg.writeEndObject();

		jg.writeStringField("@class", sourceType);

		jg.writeEndObject();

		jg.writeObjectFieldStart("target");

		jg.writeObjectFieldStart("header");

		jg.writeStringField("uuid", targetUUID);

		jg.writeEndObject();

		jg.writeStringField("@class", targetType);

		jg.writeEndObject();

		jg.close();

		return out.toString("UTF-8");

	}

}

package eu.dnetlib.parthenos.registry;

import java.io.IOException;

import com.fasterxml.jackson.core.JsonGenerator;

import com.google.common.base.Joiner;

import eu.dnetlib.parthenos.CRM;

import eu.dnetlib.parthenos.CRMpe;

import eu.dnetlib.parthenos.rdf.ResourceReader;

import org.apache.commons.lang3.StringUtils;

import org.apache.jena.rdf.model.RDFNode;

import org.apache.jena.rdf.model.Resource;

import org.apache.jena.rdf.model.StmtIterator;

import org.apache.jena.vocabulary.RDF;

import org.gcube.resourcemanagement.model.reference.entity.facet.IdentifierFacet.IdentificationType;

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

import org.springframework.stereotype.Component;

/**

 * Created by Alessia Bardi on 02/10/2017.

 *

 * @author Alessia Bardi

 */

@Component

public class FacetWriter {

	@Autowired

	private ResourceReader resourceReader;

	//final IdentificationType type

	public void writeP1Facet(final JsonGenerator jg, final String value) throws IOException {

		jg.writeStartObject();

		jg.writeStringField("@class", "P1_is_identified_by");

		jg.writeObjectFieldStart("target");

		jg.writeStringField("@class", "SimpleFacet");

		jg.writeStringField("value", value);

		jg.writeEndObject();

		jg.writeEndObject();

	}

	public void writeIdentifierFacet(final JsonGenerator jg, final String identifier) throws IOException {

		jg.writeStartObject();

		jg.writeStringField("@class", "isIdentifiedBy");

		jg.writeObjectFieldStart("target");

		jg.writeStringField("@class", "IdentifierFacet");

		jg.writeStringField("value", identifier);

		jg.writeStringField("type", IdentificationType.URI.name());

		jg.writeEndObject();

		jg.writeEndObject();

	}

	public void writeP1Facets(final JsonGenerator jg, final Resource res) throws IOException {

		if(res.hasProperty(CRM.P1_is_identified_by)){

			StmtIterator idRelsIt = res.listProperties(CRM.P1_is_identified_by);

			while(idRelsIt.hasNext()){

				RDFNode obj = idRelsIt.nextStatement().getObject();

				String value = "";

				if(obj.isLiteral()){

					value = obj.asLiteral().getLexicalForm();

				}

				else if(obj.isResource()) {

					value = resourceReader.getLabel(obj.asResource());

				}

				if(StringUtils.isNotBlank(value)) writeP1Facet(jg, value);

			}

		}

	}

	public void writeInfoFacet(final JsonGenerator jg, final Resource res) throws IOException {

		jg.writeStartObject();

		jg.writeStringField("@class", "consistsOf");

		jg.writeObjectFieldStart("target");

		jg.writeStringField("@class", "PE_Info_Facet");

		jg.writeStringField("title", resourceReader.getTitle(res));

		jg.writeStringField("description", Joiner.on(",").join(resourceReader.getDescriptions(res)));

		//new object comp + field value + schema="noSchema"

		String competence = Joiner.on(',').join(resourceReader.getCompetences(res));

		if(StringUtils.isNotBlank(competence)) {

			writeValueSchema(jg, "competence", competence, "noSchema");

		}

		//TODO: uncomment this when George adds the rel to the model

		//String availability = getAvailabilityFromRDFResource(res);

//		if(StringUtils.isNotBlank(availability)) {

//			writeValueSchema(jg, "availability", availability, "noSchema");

//		}

		jg.writeEndObject();

		jg.writeEndObject();

	}

	protected void writeValueSchema(final JsonGenerator jg, final String fieldName, final String value, final String schema) throws IOException {

		jg.writeObjectFieldStart(fieldName);

		jg.writeStringField("value", value);

		jg.writeStringField("schema", schema);

		jg.writeEndObject();

	}

	public void writeEventFacet(final JsonGenerator jg) {

		//TODO: implement me. get begin/end of operation from PP42_has_declarative_time

	}

	public void writeRightsFacet(final JsonGenerator jg, final Resource res) throws IOException {

		//TODO: implement me. E30_Right facet extends from licenseFacet but it is not correct (textUrl is mandatory, we can't use it in Parthenos)

	}

	public void writeContactReferenceFacet(final JsonGenerator jg, final Resource actor) throws IOException {

		if (actor != null) {

			String appellation = resourceReader.getTitle(actor);

			String description = Joiner.on(',').join(resourceReader.getDescriptions(actor));

			String legalAddress = "";

			String email = "";

			String website = "";

			String address = "";

			String phoneNumber = "";

			//more contact point per provider

			StmtIterator contactPointsStm = actor.listProperties(CRM.P76_has_contact_point);

			while (contactPointsStm.hasNext()) {

				Resource cp = contactPointsStm.nextStatement().getResource();

				//contact points can bean E45_Address or E51_Contact_Point

				if ((cp.hasProperty(RDF.type, CRM.E45_Address) || cp.hasProperty(RDF.type, CRM.E51_Contact_Point)) && cp.hasProperty(CRM.P2_has_type)) {

					Resource addressType = cp.getPropertyResourceValue(CRM.P2_has_type);

					String info = resourceReader.getLabel(cp);

					String addressTypeLabel = resourceReader.getLabel(addressType);

					switch (addressTypeLabel.toLowerCase()) {

					case "email":

						email = info;

						break;

					case "legal address":

						legalAddress = info;

						break;

					case "address":

						address = info;

						break;

					case "phone":

						phoneNumber = info;

						break;

					case "web":

						website = info;

						break;

					}

				}

			}

			jg.writeStartObject();

			jg.writeStringField("@class", "consistsOf");

			jg.writeObjectFieldStart("target");

			jg.writeStringField("@class", "PE_Contact_Reference_Facet");

			jg.writeStringField("appellation", appellation);

			jg.writeStringField("description", description);

			jg.writeStringField("legalAddress", legalAddress);

			if(StringUtils.isNotBlank(email)) jg.writeStringField("email", email);

			jg.writeStringField("website", website);

			jg.writeStringField("address", address);

			jg.writeStringField("phoneNumber", phoneNumber);

			jg.writeEndObject();

			jg.writeEndObject();

		}

	}

	public void writeDesignatedAccessPointFacet(final JsonGenerator jg, final Resource resource) throws IOException {

		//PP28_has_designated_access_point

		StmtIterator apStms = resource.listProperties(CRMpe.PP28_has_designated_access_point);

		while (apStms.hasNext()) {

			String entryName = resourceReader.getLabel(resource);

			//(mandatory)

			String endpoint = "";

			String protocol = "";

			String description = Joiner.on(',').join(resourceReader.getDescriptions(resource));

			//TODO: authorization is a ValueSchema, I do not understand how to use it and how to map it

			String authorization = "";

			Resource ap = apStms.next().getResource();

			endpoint = ap.getURI();

			//TODO: where to get protocol and authorization?

			jg.writeStartObject();

			jg.writeStringField("@class", "consistsOf");

			jg.writeObjectFieldStart("target");

			jg.writeStringField("@class", "PE29_Access_Point");

			jg.writeStringField("entryName", entryName);

			jg.writeStringField("description", description);

			jg.writeStringField("endpoint", endpoint);

			jg.writeStringField("protocol", protocol);

			//TODO: authorization is a ValueSchema, I do not understand how to use it and how to map it

			//jg.writeStringField("authorization", authorization);

			jg.writeEndObject();

			jg.writeEndObject();

		}

	}

	public void writeTemporalCoverageFacet(final JsonGenerator jg, final Resource resource) {

		//TODO: CoverageFacet wants a value and a mandatory schema. Can't be applied to Parthenos.

	}

	public ResourceReader getResourceReader() {

		return resourceReader;

	}

	public void setResourceReader(final ResourceReader resourceReader) {

		this.resourceReader = resourceReader;

	}

}

package eu.dnetlib.parthenos.registry;

import java.io.BufferedOutputStream;

import java.io.ByteArrayOutputStream;

import java.io.IOException;

import java.util.List;

import java.util.Map;

import java.util.UUID;

import javax.annotation.PostConstruct;

import com.fasterxml.jackson.core.JsonEncoding;

import com.fasterxml.jackson.core.JsonFactory;

import com.fasterxml.jackson.core.JsonGenerator;

import com.google.common.collect.Lists;

import com.google.common.collect.Maps;

import eu.dnetlib.parthenos.CRM;

import eu.dnetlib.parthenos.CRMdig;

import eu.dnetlib.parthenos.CRMpe;

import eu.dnetlib.parthenos.jrr.ParthenosRegistryRel;

import eu.dnetlib.parthenos.jrr.ParthenosRegistryResource;

import eu.dnetlib.parthenos.publisher.ParthenosPublisherException;

import eu.dnetlib.parthenos.rdf.ResourceReader;

import org.apache.commons.lang3.StringUtils;

import org.apache.commons.logging.Log;

import org.apache.commons.logging.LogFactory;

import org.apache.jena.rdf.model.Property;

import org.apache.jena.rdf.model.Resource;

import org.apache.jena.rdf.model.StmtIterator;

import org.apache.jena.vocabulary.RDF;

import org.gcube.common.authorization.client.Constants;

import org.gcube.common.authorization.library.AuthorizationEntry;

import org.gcube.common.authorization.library.provider.SecurityTokenProvider;

import org.gcube.common.scope.api.ScopeProvider;

import org.gcube.informationsystem.model.reference.relation.IsIdentifiedBy;

import org.gcube.informationsystem.resourceregistry.api.exceptions.ResourceRegistryException;

import org.gcube.informationsystem.resourceregistry.api.exceptions.query.InvalidQueryException;

import org.gcube.informationsystem.resourceregistry.client.ParthenosRegistryClientSetter;

import org.gcube.informationsystem.resourceregistry.client.ResourceRegistryClient;

import org.gcube.informationsystem.resourceregistry.client.ResourceRegistryClientFactory;

import org.gcube.informationsystem.resourceregistry.publisher.ParthenosRegistryPublisherSetter;

import org.gcube.informationsystem.resourceregistry.publisher.ResourceRegistryPublisher;

import org.gcube.informationsystem.resourceregistry.publisher.ResourceRegistryPublisherFactory;

import org.gcube.resourcemanagement.model.reference.entity.facet.IdentifierFacet;

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

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

import org.springframework.stereotype.Component;

/**

 * Created by Alessia Bardi on 26/09/2017.

 *

 * TODO: when the mappings have a definitive URI generation policy then we need to be able to "upsert" (Luca will prepare new method for me).

 * When generating relationships, it could be the case that the linked entity was generated from another file, so we have to ask

 * the registry if it already exists a resource with a given URI. We cannot do it now because different entities with the same fake UUID are

 * generated by the mappings, now. See also https://support.d4science.org/issues/9820#change-56673

 *

 * @author Alessia Bardi

 */

@Component

public class GCubeResourceRegistrator {

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

	@Value("${gcube.registry.baseurl}")

	private String registryBaseURL;

	@Value("${gcube.registry.application.token}")

	private String applicationToken;

	@Autowired

	private FacetWriter facetWriter;

	@Autowired

	private RelWriter relWriter;

	@Autowired

	private ResourceReader resourceReader;

	private ResourceRegistryPublisher resourceRegistryPublisher;

	private ResourceRegistryClient resourceRegistryClient;

	@PostConstruct

	public void init() throws Exception {

		ParthenosRegistryClientSetter.forceToURL(getRegistryBaseURL());

		ParthenosRegistryPublisherSetter.forceToURL(getRegistryBaseURL());

		log.info("Registry URL forced to " + getRegistryBaseURL());

		if (StringUtils.isNotBlank(getApplicationToken())) {

			GCubeResourceRegistrator.setContext(getApplicationToken());

			log.info("GCube Context set");

		} else {

			log.fatal("GCube context cannot be configured without a value in gcube.registry.application.token");

		}

		this.resourceRegistryPublisher = ResourceRegistryPublisherFactory.create();

		this.resourceRegistryClient = ResourceRegistryClientFactory.create();

	}

	protected static String getCurrentScope(String token) throws Exception {

		AuthorizationEntry authorizationEntry = Constants.authorizationService().get(token);

		String context = authorizationEntry.getContext();

		log.info("Context of token " + token + " is: " + context);

		return context;

	}

	protected static void setContext(String token) throws Exception {

		SecurityTokenProvider.instance.set(token);

		ScopeProvider.instance.set(getCurrentScope(token));

	}

	public int unregister(final String datasourceApi) {

		//TODO: implement me

		return -1;

	}

	protected boolean deleteResourcebyUUID(final Resource resourceType, final UUID uuid) throws ResourceRegistryException {

		//return resourceRegistryPublisher.deleteResource(uuid);

		throw new UnsupportedOperationException();

	}

	/**

	 *

	 * @param rdfResource

	 * @param uuid

	 * @param type

	 * @throws IOException

	 * @throws ResourceRegistryException

	 * @throws ParthenosPublisherException

	 *

	 */

	public void register(final Resource rdfResource, final String uuid, final Resource type) throws IOException, ResourceRegistryException, ParthenosPublisherException {

		String resURI = rdfResource.getURI();

		log.debug("Processing resource " + resURI + " for registration on JRR");

		JsonFactory jsonFactory = new JsonFactory();

		ParthenosRegistryResource prr = null;

		List<ParthenosRegistryRel> rels;

		switch(type.getLocalName()){

		case "E7_Activity":

			if(rdfResource.hasProperty(RDF.type, CRMpe.PE1_Service)) {

				prr = processService(rdfResource, jsonFactory, uuid);

			}

			else{

				if(rdfResource.hasProperty(RDF.type, CRMpe.PE35_Project)){

					prr = processProject(rdfResource, jsonFactory, uuid);

				}

			}

			break;

		case "E55_Type":

			if(rdfResource.hasProperty(RDF.type, CRMpe.PE36_Competency_Type)) {

				prr = processBasicResource(rdfResource, CRMpe.PE36_Competency_Type, jsonFactory, uuid);

			}

			else{

				if(rdfResource.hasProperty(RDF.type, CRMpe.PE37_Protocol_Type))

					prr = processBasicResource(rdfResource, CRMpe.PE37_Protocol_Type, jsonFactory, uuid);

			}

			//TODO: need other E55_Types?

			break;

		case "E70_Thing":

			if(rdfResource.hasProperty(RDF.type, CRMdig.D1_Digital_Object)) {

				prr = processDigitalObject(rdfResource, jsonFactory, uuid);

			}

			//TODO: include PE32_Curated_Thing and E19_PhysicalObject?

			break;

		case "E39_Actor":

			prr = processActor(rdfResource, jsonFactory, uuid);

			break;

		case "E29_Design_or_Procedure":

			prr = processBasicResource(rdfResource, CRM.E29_Design_or_Procedure, jsonFactory, uuid);

			break;

		default:

			throw new IllegalArgumentException(String.format("Type "+type.getLocalName()+" not supported"));

		}

		if(prr != null) {

			this.resourceRegistryPublisher.createResource(prr.getJson());

			rels = getResourceRels(rdfResource, prr);

			int registeredRels = 0;

			for(ParthenosRegistryRel r : rels){

				//TODO: handle exception

				String res = this.resourceRegistryPublisher.createIsRelatedTo(r.getJson());

				//TODO: handle negative response

				if(StringUtils.isNotBlank(res)) registeredRels++;

			}

			log.debug(String.format("Registered %d/%d relationships for uri %s, uuid %s", registeredRels, rels.size(), resURI, uuid));

		}

		else{

			log.warn("Could not register on registry: "+resURI);

		}

	}

	protected ParthenosRegistryResource processService(final Resource res, final JsonFactory jsonFactory, final String uuid) throws IOException {

		//ensure we are not registering generic PE1_Service because the class is abstract and the registry complaints.

		//We only want specific types of services.

		if (res.hasProperty(RDF.type, CRMpe.PE8_E_Service)

				|| res.hasProperty(RDF.type, CRMpe.PE2_Hosting_Service)

				|| res.hasProperty(RDF.type, CRMpe.PE3_Curating_Service)) {

			final ByteArrayOutputStream out = new ByteArrayOutputStream();

			BufferedOutputStream bos = new BufferedOutputStream(out);

			JsonGenerator jg = jsonFactory.createGenerator(bos, JsonEncoding.UTF8);

			jg.writeStartObject();

			//it should never happen to get PE1_Service as a specific type -- it happened in Parthenos top level entities

			String specificType = resourceReader.findSpecificType(res, CRMpe.PE1_Service).getLocalName();

			writeCommon(res, specificType, jg, uuid);

			//******THE FACETS *******//

			jg.writeArrayFieldStart("consistsOf");

			//list of facets

			writeCommonFacets(res, jg);

			facetWriter.writeEventFacet(jg);

			facetWriter.writeRightsFacet(jg, res);

			if (res.hasProperty(CRMpe.PP2_provided_by)) {

				//TODO: shouldn't this be a rel to an actor?

				Resource provider = res.getPropertyResourceValue(CRMpe.PP2_provided_by);

				facetWriter.writeContactReferenceFacet(jg, provider);

			}

			facetWriter.writeDesignatedAccessPointFacet(jg, res);

			jg.writeEndArray();

			jg.writeEndObject();

			jg.close();

			String json = out.toString("UTF-8");

			log.debug(json);

			return new ParthenosRegistryResource().setJson(json).setType(specificType).setUuid(uuid);

		}

		else{

			log.warn(String.format("Skipping resource: %s It is not an instance of a specific service"));

			return null;

		}

	}

	protected ParthenosRegistryResource processProject(final Resource res, final JsonFactory jsonFactory, final String uuid) throws IOException {

		String specificType = resourceReader.findSpecificType(res, CRMpe.PE35_Project).getLocalName();

		final ByteArrayOutputStream out = new ByteArrayOutputStream();

		BufferedOutputStream bos = new BufferedOutputStream(out);

		JsonGenerator jg = jsonFactory.createGenerator(bos, JsonEncoding.UTF8);

		jg.writeStartObject();

		writeCommon(res, specificType, jg, uuid);

		jg.writeArrayFieldStart("consistsOf");

		writeCommonFacets(res, jg);

		jg.writeEndArray();

		jg.writeEndObject();

		jg.close();

		String json = out.toString("UTF-8");

		log.debug(json);

		return new ParthenosRegistryResource().setJson(json).setType(specificType).setUuid(uuid);

	}

	protected ParthenosRegistryResource processActor(final Resource res, final JsonFactory jsonFactory, final String uuid) throws IOException {

		String specificType = resourceReader.findSpecificType(res, CRM.E39_Actor).getLocalName();

		final ByteArrayOutputStream out = new ByteArrayOutputStream();

		BufferedOutputStream bos = new BufferedOutputStream(out);

		JsonGenerator jg = jsonFactory.createGenerator(bos, JsonEncoding.UTF8);

		jg.writeStartObject();

		writeCommon(res, specificType, jg, uuid);

		//******THE FACETS *******//

		jg.writeArrayFieldStart("consistsOf");

		//list of facets

		writeCommonFacets(res, jg);

		facetWriter.writeContactReferenceFacet(jg, res);

		jg.writeEndArray();

		jg.writeEndObject();

		jg.close();

		String json = out.toString("UTF-8");

		log.debug(json);

		return new ParthenosRegistryResource().setJson(json).setType(specificType).setUuid(uuid);

	}

	protected ParthenosRegistryResource processDigitalObject(final Resource res, final JsonFactory jsonFactory, final String uuid) throws IOException {

		String specificType = resourceReader.findSpecificType(res, CRMdig.D1_Digital_Object).getLocalName();

		final ByteArrayOutputStream out = new ByteArrayOutputStream();

		BufferedOutputStream bos = new BufferedOutputStream(out);

		JsonGenerator jg = jsonFactory.createGenerator(bos, JsonEncoding.UTF8);

		jg.writeStartObject();

		writeCommon(res, specificType, jg, uuid);

		//******THE FACETS *******//

		jg.writeArrayFieldStart("consistsOf");

		//list of facets

		writeCommonFacets(res, jg);

		facetWriter.writeTemporalCoverageFacet(jg, res);

		facetWriter.writeRightsFacet(jg, res);

		jg.writeEndArray();

		jg.writeEndObject();

		jg.close();

		String json = out.toString("UTF-8");

		log.debug(json);

		return new ParthenosRegistryResource().setUuid(uuid).setType(specificType).setJson(json);

	}

	protected ParthenosRegistryResource processBasicResource(final Resource res, final Resource basicType, final JsonFactory jsonFactory, final String uuid) throws IOException {

		final ByteArrayOutputStream out = new ByteArrayOutputStream();

		BufferedOutputStream bos = new BufferedOutputStream(out);

		JsonGenerator jg = jsonFactory.createGenerator(bos, JsonEncoding.UTF8);

		jg.writeStartObject();

		String specificType = resourceReader.findSpecificType(res, basicType).getLocalName();

		writeCommon(res, specificType, jg, uuid);

		//******THE FACETS *******//

		jg.writeArrayFieldStart("consistsOf");

		writeCommonFacets(res, jg);

		jg.writeEndArray();

		jg.writeEndObject();

		jg.close();

		String json = out.toString("UTF-8");

		log.debug(json);

		return new ParthenosRegistryResource().setJson(json).setType(specificType).setUuid(uuid);

	}

	protected List<ParthenosRegistryRel> getResourceRels(final Resource resource, final ParthenosRegistryResource prr) throws IOException, ResourceRegistryException,

			InvalidQueryException, ParthenosPublisherException {

		JsonFactory jsonFactory = new JsonFactory();

		List<ParthenosRegistryRel> jsonRels = Lists.newArrayList();

		if(resource.hasProperty(RDF.type, CRMpe.PE1_Service)) {

			jsonRels.addAll(getRels(resource, prr, CRM.P129_is_about, jsonFactory));

			jsonRels.addAll(getRels(resource, prr, CRMpe.PP2_provided_by, jsonFactory));

			//TODO: IsRelatedTo the contact person of the provider. Interpret '"Follow path of service ‘Provided by’ and switch E39 for E21: E21- >p76->E51"

			jsonRels.addAll(getRels(resource, prr, CRMpe.PP45_has_competency, jsonFactory));

			jsonRels.addAll(getRels(resource, prr, CRMpe.PP4_hosts_object, jsonFactory));

			jsonRels.addAll(getRels(resource, prr, CRMpe.PP31_uses_curation_plan, jsonFactory));

			jsonRels.addAll(getRels(resource, prr, CRMpe.PP32_curates, jsonFactory));

			jsonRels.addAll(getRels(resource, prr, CRMpe.PP6_hosts_digital_object, jsonFactory));

			jsonRels.addAll(getRels(resource, prr, CRMpe.PP7_hosts_software_object, jsonFactory));

			jsonRels.addAll(getRels(resource, prr, CRMpe.PP8_hosts_dataset, jsonFactory));

			jsonRels.addAll(getRels(resource, prr, CRMpe.PP29_uses_access_protocol, jsonFactory));

			jsonRels.addAll(getRels(resource, prr, CRMpe.PP47_has_protocol_type, jsonFactory));

			jsonRels.addAll(getRels(resource, prr, CRMpe.PP46_brokers_access_to, jsonFactory));

			jsonRels.addAll(getRels(resource, prr, CRMpe.PP11_curates_volatile_digital_object, jsonFactory));

			jsonRels.addAll(getRels(resource, prr, CRMpe.PP12_curates_volatile_software, jsonFactory));

			jsonRels.addAll(getRels(resource, prr, CRMpe.PP13_curates_volatile_dataset, jsonFactory));

			jsonRels.addAll(getRels(resource, prr, CRMpe.PP15_delivers_on_request, jsonFactory));

			jsonRels.addAll(getRels(resource, prr, CRMpe.PP45_has_competency, jsonFactory));

			jsonRels.addAll(getInverseRels(resource, prr, CRMpe.PP1i_is_currently_offered_by, CRMpe.PP1_currently_offers, jsonFactory));

			jsonRels.addAll(getInverseRels(resource, prr, CRMpe.PP46i_has_access_brokered_by, CRMpe.PP46_brokers_access_to, jsonFactory));

		}

		if(resource.hasProperty(RDF.type, CRMdig.D1_Digital_Object)){

			jsonRels.addAll(getInverseRels(resource, prr, CRMpe.PP6i_is_digital_object_hosted_by, CRMpe.PP6_hosts_digital_object, jsonFactory));

			jsonRels.addAll(getInverseRels(resource, prr, CRMpe.PP18i_is_digital_object_part_of, CRMpe.PP18_has_digital_object_part, jsonFactory));

			jsonRels.addAll(getInverseRels(resource, prr, CRMpe.PP39i_has_metadata, CRMpe.PP39_is_metadata_for, jsonFactory));

			jsonRels.addAll(getInverseRels(resource, prr, CRMpe.PP41i_is_indexed_by, CRMpe.PP41_is_index_of, jsonFactory));

		}

		if(resource.hasProperty(RDF.type, CRMpe.PE18_Dataset)) {

			jsonRels.addAll(getInverseRels(resource, prr, CRMpe.PP23i_is_dataset_part_of, CRMpe.PP23_has_dataset_part, jsonFactory));

			jsonRels.addAll(getInverseRels(resource, prr, CRMpe.PP8i_is_dataset_hosted_by, CRMpe.PP8_hosts_dataset, jsonFactory));

		}

		if(resource.hasProperty(RDF.type, CRMdig.D14_Software)) {

			jsonRels.addAll(getInverseRels(resource, prr, CRMpe.PP14i_is_run_by, CRMpe.PP14_runs_on_request, jsonFactory));

			jsonRels.addAll(getInverseRels(resource, prr, CRMpe.PP15i_is_delivered_by, CRMpe.PP15_delivers_on_request, jsonFactory));

			jsonRels.addAll(getInverseRels(resource, prr, CRMpe.PP21i_is_software_part_of, CRMpe.PP21_has_software_part, jsonFactory));

			//TODO: is this correct? Service --> uses access protocol --> Software ?

			jsonRels.addAll(getInverseRels(resource, prr, CRMpe.PP29i_is_access_protocol_used_by, CRMpe.PP29_uses_access_protocol, jsonFactory));

		}

		if(resource.hasProperty(RDF.type, CRMpe.PE19_Persistent_Digital_Object)) {

			jsonRels.addAll(getRels(resource, prr, CRMpe.PP16_has_persistent_digital_object_part, jsonFactory));

			jsonRels.addAll(getInverseRels(resource, prr, CRMpe.PP16i_is_persistent_digital_object_part_of, CRMpe.PP16_has_persistent_digital_object_part, jsonFactory));

			jsonRels.addAll(getInverseRels(resource, prr, CRMpe.PP17i_is_snapshot_of, CRMpe.PP17_has_snapshot, jsonFactory));

		}

		if(resource.hasProperty(RDF.type, CRMpe.PE20_Volatile_Digital_Object)) {

			jsonRels.addAll(getRels(resource, prr, CRMpe.PP17_has_snapshot, jsonFactory));

			jsonRels.addAll(getRels(resource, prr, CRMpe.PP18_has_digital_object_part, jsonFactory));

			jsonRels.addAll(getInverseRels(resource, prr, CRMpe.PP11i_is_volatile_digital_object_curated_by, CRMpe.PP11_curates_volatile_digital_object, jsonFactory));

		}

		if(resource.hasProperty(RDF.type, CRMpe.PE21_Persistent_Software)) {

			jsonRels.addAll(getRels(resource, prr, CRMpe.PP19_has_persistent_software_part, jsonFactory));

			jsonRels.addAll(getInverseRels(resource, prr, CRMpe.PP19i_is_persistent_software_part_of, CRMpe.PP19_has_persistent_software_part, jsonFactory));

			jsonRels.addAll(getInverseRels(resource, prr, CRMpe.PP22i_is_release_of, CRMpe.PP22_has_release, jsonFactory));

		}

		if(resource.hasProperty(RDF.type, CRMpe.PE22_Persistent_Dataset)) {

			jsonRels.addAll(getRels(resource, prr, CRMpe.PP20_has_persistent_dataset_part, jsonFactory));

			jsonRels.addAll(getRels(resource, prr, CRMpe.PP39_is_metadata_for, jsonFactory));

			jsonRels.addAll(getInverseRels(resource, prr, CRMpe.PP20i_is_persistent_dataset_part_of, CRMpe.PP20_has_persistent_dataset_part, jsonFactory));

			jsonRels.addAll(getInverseRels(resource, prr, CRMpe.PP24i_is_dataset_snapshot_of, CRMpe.PP24_has_dataset_snapshot, jsonFactory));

			jsonRels.addAll(getInverseRels(resource, prr, CRMpe.PP40i_is_deprecated_by, CRMpe.PP40_created_successor_of, jsonFactory));

		}

		if(resource.hasProperty(RDF.type, CRMpe.PE23_Volatile_Software)) {

			jsonRels.addAll(getRels(resource, prr, CRMpe.PP21_has_software_part, jsonFactory));

			jsonRels.addAll(getRels(resource, prr, CRMpe.PP22_has_release, jsonFactory));

			jsonRels.addAll(getInverseRels(resource, prr, CRMpe.PP12i_is_volatile_software_curated_by, CRMpe.PP12_curates_volatile_software, jsonFactory));

		}

		if(resource.hasProperty(RDF.type, CRMpe.PE24_Volatile_Dataset)) {

			jsonRels.addAll(getRels(resource, prr, CRMpe.PP23_has_dataset_part, jsonFactory));

			jsonRels.addAll(getRels(resource, prr, CRMpe.PP24_has_dataset_snapshot, jsonFactory));

			jsonRels.addAll(getRels(resource, prr, CRMpe.PP41_is_index_of, jsonFactory));

			jsonRels.addAll(getInverseRels(resource, prr, CRMpe.PP13i_is_volatile_dataset_curated_by, CRMpe.PP13_curates_volatile_dataset, jsonFactory));

		}

		if(resource.hasProperty(RDF.type, CRMpe.PE26_RI_Project)) {

			jsonRels.addAll(getRels(resource, prr, CRMpe.PP25_has_maintaining_RI, jsonFactory));

			jsonRels.addAll(getRels(resource, prr, CRMpe.PP1_currently_offers, jsonFactory));

		}

		if(resource.hasProperty(RDF.type, CRMpe.PE35_Project)) {

			jsonRels.addAll(getRels(resource, prr, CRMpe.PP43_supported_project_activity, jsonFactory));

			jsonRels.addAll(getRels(resource, prr, CRMpe.PP44_has_maintaining_team, jsonFactory));

		}

		if(resource.hasProperty(RDF.type, CRM.E39_Actor)) {

			jsonRels.addAll(getInverseRels(resource, prr, CRMpe.PP2i_provides, CRMpe.PP2_provided_by, jsonFactory));

		}

		if(resource.hasProperty(RDF.type, CRMpe.PE34_Team)) {

			jsonRels.addAll(getInverseRels(resource, prr, CRMpe.PP44i_is_maintaining_team_of, CRMpe.PP44_has_maintaining_team, jsonFactory));

		}

		if(resource.hasProperty(RDF.type, CRM.E70_Thing)) {

			jsonRels.addAll(getInverseRels(resource, prr, CRMpe.PP4i_is_object_hosted_by, CRMpe.PP4_hosts_object, jsonFactory));

		}

		if(resource.hasProperty(RDF.type, CRMpe.PE25_RI_Consortium)) {

			jsonRels.addAll(getInverseRels(resource, prr, CRMpe.PP25i_is_maintaining_RI_of, CRMpe.PP25_has_maintaining_RI, jsonFactory));

		}

		if(resource.hasProperty(RDF.type, CRMpe.PE28_Curation_Plan)) {

			jsonRels.addAll(getInverseRels(resource, prr, CRMpe.PP31i_is_curation_plan_used_by, CRMpe.PP31_uses_curation_plan, jsonFactory));

		}

		if(resource.hasProperty(RDF.type, CRMpe.PE32_Curated_Thing)) {

			jsonRels.addAll(getInverseRels(resource, prr, CRMpe.PP32i_is_curated_by, CRMpe.PP32_curates, jsonFactory));

		}

		if(resource.hasProperty(RDF.type, CRM.E65_Creation)) {

			jsonRels.addAll(getRels(resource, prr, CRMpe.PP40_created_successor_of, jsonFactory));

		}

		if(resource.hasProperty(RDF.type, CRM.E7_Activity)) {

			jsonRels.addAll(getInverseRels(resource, prr, CRMpe.PP43i_is_project_activity_supported_by, CRMpe.PP43_supported_project_activity, jsonFactory));

		}

		if(resource.hasProperty(RDF.type, CRMpe.PE36_Competency_Type)) {

			jsonRels.addAll(getInverseRels(resource, prr, CRMpe.PP45i_is_competency_of, CRMpe.PP45_has_competency, jsonFactory));

		}

		if(resource.hasProperty(RDF.type, CRMpe.PE37_Protocol_Type)) {

			jsonRels.addAll(getInverseRels(resource, prr, CRMpe.PP47i_is_protocol_type_of, CRMpe.PP47_has_protocol_type, jsonFactory));

		}

		if(resource.hasProperty(RDF.type, CRMpe.PE38_Schema)) {

			jsonRels.addAll(getInverseRels(resource, prr, CRMpe.PP47i_is_protocol_type_of, CRMpe.PP47_has_protocol_type, jsonFactory));

		}

		return jsonRels;

	}

	protected List<ParthenosRegistryRel> getRels(final Resource subject, final ParthenosRegistryResource subjectPrr, final Property rel, final JsonFactory jsonFactory) throws IOException, InvalidQueryException, ParthenosPublisherException, ResourceRegistryException {

		List<ParthenosRegistryRel> rels = Lists.newArrayList();

		StmtIterator it = subject.listProperties(rel);

		while (it.hasNext()) {

			Resource obj = it.nextStatement().getResource();

			if (obj == null) throw new ParthenosPublisherException(String.format("No target resource available for %s --> %s", subject.getURI(), rel.getURI()));

			ParthenosRegistryResource target = findInRegistry(obj.getURI());

			if(target == null){

				log.debug(String.format("Rel: %s - %s - %s: target is not yet registered", subject.getURI(), rel.getLocalName(), obj.getURI()));

			}

			else{

				rels.add(getRel(subjectPrr, rel, target, jsonFactory));

			}

		}

		return rels;

	}

	protected ParthenosRegistryRel getRel(final ParthenosRegistryResource subjectPrr, final Property rel, final ParthenosRegistryResource targetPrr, final JsonFactory jsonFactory ) throws IOException {

		String relJson = relWriter.writeRelationship(jsonFactory, rel.getLocalName(), subjectPrr.getUuid(), subjectPrr.getRegistryType(), targetPrr.getUuid(), targetPrr.getRegistryType());

		return new ParthenosRegistryRel().json(relJson).relName(rel.getLocalName());

	}

	protected List<ParthenosRegistryRel> getInverseRels(final Resource resource, final ParthenosRegistryResource resourcePRR, final Property rel, final Property inverseRel, final JsonFactory jsonFactory) throws IOException, InvalidQueryException, ResourceRegistryException {

		List<ParthenosRegistryRel> rels = Lists.newArrayList();

		StmtIterator it = resource.listProperties(rel);

		while (it.hasNext()) {

			Resource obj = it.nextStatement().getResource();

			String objURI = obj.getURI();

			ParthenosRegistryResource registryRes = findInRegistry(objURI);

			if (registryRes != null) {

				rels.add(getRel(registryRes, inverseRel, resourcePRR, jsonFactory));

			}

		}

		return rels;

	}

	/**

	 * Write the common properties: header, class for all resources

	 *

	 * @param resource  input Resource.

	 * @param className name of the class for the registry

	 * @param jg        JsonGenerator to write with.

	 * @param uuid      uuid of the resource

	 */

	protected void writeCommon(final Resource resource, final String className, final JsonGenerator jg, final String uuid)

			throws IOException {

		jg.writeObjectFieldStart("header");

		jg.writeStringField("uuid", uuid);

		jg.writeEndObject();

		jg.writeStringField("@class", StringUtils.remove(className, '-'));

	}

	/**

	 * Write the common facets: identifier and info facets

	 *

	 * @param res

	 * @param jg

	 */

	protected void writeCommonFacets(final Resource res, final JsonGenerator jg) throws IOException {

		facetWriter.writeIdentifierFacet(jg, res.getURI());

		facetWriter.writeP1Facets(jg, res);

		facetWriter.writeInfoFacet(jg, res);

	}

	public ParthenosRegistryResource findInRegistry(final String uri) throws ResourceRegistryException {

		Map<String, Object> queryMap = Maps.newHashMap();

		queryMap.put("value", uri);

		List<org.gcube.informationsystem.model.reference.entity.Resource> resources = resourceRegistryClient.getFilteredResources(

				org.gcube.informationsystem.model.reference.entity.Resource.class, IsIdentifiedBy.class, IdentifierFacet.class, true, queryMap);

		if(resources.isEmpty()) return null;

		org.gcube.informationsystem.model.reference.entity.Resource resource = resources.get(0);

		if(resources.size() > 1){

			log.warn("More than one resource in registry with uri "+uri+" -- considering the first, with uuid: "+resource.getHeader().getUUID());

		}

		//build PRR from res, need to have type and uuid

		//TODO: check the type is what we want

		ParthenosRegistryResource prr = new ParthenosRegistryResource().setUuid(resource.getHeader().getUUID().toString()).setType(resource.getClass().getSimpleName());

		log.debug(prr.toString());

		return prr;

	}

	public FacetWriter getFacetWriter() {

		return facetWriter;

	}

	public void setFacetWriter(final FacetWriter facetWriter) {

		this.facetWriter = facetWriter;

	}

	public String getApplicationToken() {

		return applicationToken;

	}

	public void setApplicationToken(final String applicationToken) {

		this.applicationToken = applicationToken;

	}

	public String getRegistryBaseURL() {

		return registryBaseURL;

	}

	public void setRegistryBaseURL(final String registryBaseURL) {

		this.registryBaseURL = registryBaseURL;

	}

	public RelWriter getRelWriter() {

		return relWriter;

	}

	public void setRelWriter(final RelWriter relWriter) {

		this.relWriter = relWriter;

	}

	public ResourceRegistryPublisher getResourceRegistryPublisher() {

		return resourceRegistryPublisher;

	}

	public void setResourceRegistryPublisher(final ResourceRegistryPublisher resourceRegistryPublisher) {

		this.resourceRegistryPublisher = resourceRegistryPublisher;

	}

	public ResourceRegistryClient getResourceRegistryClient() {

		return resourceRegistryClient;

	}

	public void setResourceRegistryClient(final ResourceRegistryClient resourceRegistryClient) {

		this.resourceRegistryClient = resourceRegistryClient;

	}

	public ResourceReader getResourceReader() {

		return resourceReader;

	}

	public void setResourceReader(final ResourceReader resourceReader) {

		this.resourceReader = resourceReader;

	}

}

	public void testError500_1() throws Exception{

//@Ignore

//Ignore test because ot requires a running virtuoso server

gcube.catalogue.baseurl = https://catalogue-ws.d4science.org/catalogue-ws/

gcube.uri.resolver=https://data1-p.d4science.org/parthenos_registry

    <orderEntry type="inheritedJdk" />

    <orderEntry type="library" name="Maven: org.apache.jena:jena-arq:3.9.0" level="project" />

    <orderEntry type="library" name="Maven: org.apache.jena:jena-shaded-guava:3.9.0" level="project" />

    <orderEntry type="library" name="Maven: com.github.jsonld-java:jsonld-java:0.12.1" level="project" />

    <orderEntry type="library" name="Maven: org.apache.thrift:libthrift:0.10.0" level="project" />

    <orderEntry type="library" name="Maven: org.apache.jena:jena-core:3.9.0" level="project" />

    <orderEntry type="library" name="Maven: org.apache.jena:jena-iri:3.9.0" level="project" />

    <orderEntry type="library" name="Maven: org.apache.jena:jena-base:3.9.0" level="project" />

    <orderEntry type="library" name="Maven: org.apache.commons:commons-compress:1.17" level="project" />

    <orderEntry type="library" name="Maven: org.apache.jena:jena-tdb:3.9.0" level="project" />

    <orderEntry type="library" name="Maven: org.apache.jena:jena-rdfconnection:3.9.0" level="project" />

    <orderEntry type="library" name="Maven: org.apache.jena:jena-cmds:3.9.0" level="project" />

    <orderEntry type="library" name="Maven: org.apache.jena:jena-tdb2:3.9.0" level="project" />

    <orderEntry type="library" name="Maven: org.apache.jena:jena-dboe-trans-data:3.9.0" level="project" />

    <orderEntry type="library" name="Maven: org.apache.jena:jena-dboe-transaction:3.9.0" level="project" />

    <orderEntry type="library" name="Maven: org.apache.jena:jena-dboe-base:3.9.0" level="project" />

    <orderEntry type="library" name="Maven: org.apache.jena:jena-dboe-index:3.9.0" level="project" />

    <orderEntry type="library" name="Maven: org.gcube.information-system:parthenos-entities:1.0.0-SNAPSHOT" level="project" />

    <orderEntry type="library" name="Maven: org.gcube.information-system:information-system-model:2.1.0-SNAPSHOT" level="project" />

    <orderEntry type="library" name="Maven: org.gcube.resource-management:gcube-model:1.1.0-SNAPSHOT" level="project" />

    <orderEntry type="library" name="Maven: com.fasterxml.jackson.core:jackson-annotations:2.8.0" level="project" />

    <orderEntry type="library" name="Maven: com.fasterxml.jackson.core:jackson-core:2.8.9" level="project" />

    <orderEntry type="library" name="Maven: org.gcube.information-system:resource-registry-publisher:2.0.1-SNAPSHOT" level="project" />

    <orderEntry type="library" name="Maven: org.gcube.common:authorization-client:2.0.3-SNAPSHOT" level="project" />

    <orderEntry type="library" name="Maven: org.gcube.common:common-authorization:2.1.3-SNAPSHOT" level="project" />

    <orderEntry type="library" name="Maven: org.gcube.core:common-configuration-scanner:1.1.0-SNAPSHOT" level="project" />

    <orderEntry type="library" name="Maven: org.aspectj:aspectjrt:1.8.10" level="project" />

    <orderEntry type="library" name="Maven: org.gcube.resources.discovery:ic-client:1.0.4-4.13.0-162683" level="project" />

    <orderEntry type="library" name="Maven: org.gcube.core:common-scope:1.2.0-4.13.0-125717" level="project" />

    <orderEntry type="library" name="Maven: org.gcube.core:common-scope-maps:1.0.9-4.13.0-171240" level="project" />

    <orderEntry type="library" name="Maven: org.gcube.resources.discovery:discovery-client:1.0.1-4.13.0-125857" level="project" />

    <orderEntry type="library" name="Maven: org.gcube.resources:common-gcore-resources:1.3.4-4.13.0-162605" level="project" />

    <orderEntry type="library" name="Maven: org.gcube.core:common-gcore-stubs:1.2.2-4.13.0-132342" level="project" />

    <orderEntry type="library" name="Maven: org.gcube.information-system:resource-registry-client:2.0.1-SNAPSHOT" level="project" />

    <orderEntry type="library" name="Maven: org.gcube.information-system:resource-registry-api:2.0.1-SNAPSHOT" level="project" />

	private final String createItemPath = "rest/api/items/create";

	private final String updateItemPath = "rest/api/items/update";

	private final String showItemPath = "rest/api/items/show"; //param id

	private final String purgeItemPath = "rest/api/items/purge";

	//private final String showGroupPath = "rest/api/groups/show"; //param id

	//private final String createGroupPath = "rest/api/groups/create";

	//private final String purgeGroupPath = "rest/api/groups/purge";

	private String purgeBodyTemplate = "{\"id\":\"%s\"}";

	private RestTemplate jrrRestTemplate;