D-Net

package eu.dnetlib.parthenos.registry;

import java.io.IOException;

import java.io.StringWriter;

import java.util.List;

import java.util.Map;

import java.util.Set;

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 com.google.common.collect.Sets;

import eu.dnetlib.parthenos.CRM;

import eu.dnetlib.parthenos.CRMdig;

import eu.dnetlib.parthenos.CRMpe;

import org.apache.commons.io.IOUtils;

import org.apache.commons.lang3.StringUtils;

import org.apache.commons.logging.Log;

import org.apache.commons.logging.LogFactory;

import org.apache.jena.assembler.AssemblerHelp;

import org.apache.jena.assembler.exceptions.AmbiguousSpecificTypeException;

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.springframework.beans.factory.annotation.Autowired;

import org.springframework.stereotype.Component;

/**

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

 *

 * @author Alessia Bardi

 */

@Component

public class GCubeResourceGenerator {

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

	private OntModel baseModel;

	@Autowired

	private FacetWriter facetWriter;

	public GCubeResourceGenerator() {

		final String url = "http://www.w3.org/TR/REC-rdf-syntax/example14.nt";

		baseModel = ModelFactory.createOntologyModel(OntModelSpec.RDFS_MEM_TRANS_INF);

		baseModel.read(CRMpe.RDFS_URL);

		baseModel.read(CRM.RDFS_URL);

		baseModel.read(CRMdig.RDFS_URL);

	}

	protected InfModel loadBaseModel(){

		return ModelFactory.createRDFSModel(baseModel);

	}

	/**

	 * Generates the Gcube ER instances (Entity [Resource/Facet] and Relation) as json strings to be registered from a given RDF record serialised in RDF/XML PLAIN format.

	 * @param rdfRecord RDF record in RDF/XML PLAIN format

	 * @return an Iterable of json strings or an empty Iterable if the record is blank

	 */

	public Iterable<String> getGCubeER(final String rdfRecord) throws IOException {

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

		//This map contains the pair (rdf:about, registryUUID) registered so far, useful I guess to create relationships between resources/facets.

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

		if (StringUtils.isBlank(rdfRecord)) {

			log.warn("Got empty record");

			return Lists.newArrayList();

		}

		InfModel model = loadBaseModel();

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

		JsonFactory jsonFactory = new JsonFactory();

		Set<String> uriProcessed = Sets.newHashSet();

		//let's start with services

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

		while (iter.hasNext()) {

			Resource res = iter.nextResource();

			String resourceURI = res.getURI();

			if (!uriProcessed.contains(resourceURI)) {

				log.debug("Processing "+resourceURI);

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

				StringWriter sw = new StringWriter();

				JsonGenerator jg = jsonFactory.createGenerator(sw);

				jg.writeStartObject();

				jg.writeStringField("@class", specificType.getURI());

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

				jg.writeArrayFieldStart("consistsOf");

				//list of facets

				facetWriter.writeIdentifierFacet(jg, resourceURI);

				facetWriter.writeInfoFacet(jg, res);

				facetWriter.writeEventFacet(jg);

				facetWriter.writeRightsFacet(jg, res);

				facetWriter.writeContactReferenceFacet(jg, res);

				facetWriter.writeDesignatedAccessPointFacet(jg, res);

				jg.writeEndArray();

				// ******* RELATIONSHIPS *****//

				jg.writeArrayFieldStart("isRelatedto");

				jg.writeEndArray();

				jg.writeEndObject();

				jg.close();

				String json = sw.toString();

				log.debug(json);

				jsonResources.add(json);

				uriProcessed.add(resourceURI);

			} else {

				log.debug(resourceURI+" already processed, now skipping it");

			}

		}

		return jsonResources;

	}

	/**

	 * Finds the most specific type of res.

	 * @param res Resource you want to find the most specific type

	 * @param fallbackType Resource representing the type to return if there is no type or if we get AmbiguousSpecificTypeException

	 * @return Resource: the most specific type, if any. fallbackType otherwise

	 */

	protected Resource findSpecificType(final Resource res, final Resource fallbackType){

		Resource specType = fallbackType;

		try{

			specType = AssemblerHelp.findSpecificType(res, fallbackType);

		}catch(AmbiguousSpecificTypeException e){

			log.warn(res.getURI()+": "+e.getMessage());

		}

		return specType;

	}

	public FacetWriter getFacetWriter() {

		return facetWriter;

	}

	public void setFacetWriter(final FacetWriter facetWriter) {

		this.facetWriter = facetWriter;

	}

}