Metacat

/**  '$RCSfile$'

 *  Copyright: 2010 Regents of the University of California and the

 *              National Center for Ecological Analysis and Synthesis

 *

 * This program is free software; you can redistribute it and/or modify

 * it under the terms of the GNU General Public License as published by

 * the Free Software Foundation; either version 2 of the License, or

 * (at your option) any later version.

 *

 * This program is distributed in the hope that it will be useful,

 * but WITHOUT ANY WARRANTY; without even the implied warranty of

 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the

 * GNU General Public License for more details.

 *

 * You should have received a copy of the GNU General Public License

 * along with this program; if not, write to the Free Software

 * Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307  USA

 */

package edu.ucsb.nceas.metacat.annotation;

import java.io.ByteArrayInputStream;

import java.io.FileInputStream;

import java.io.InputStream;

import junit.framework.Test;

import junit.framework.TestSuite;

import org.dataone.service.types.v1.Identifier;

import org.dataone.service.types.v1.ObjectFormatIdentifier;

import org.dataone.service.types.v1.Session;

import org.dataone.service.types.v1.SystemMetadata;

import edu.ucsb.nceas.metacat.dataone.D1NodeServiceTest;

import edu.ucsb.nceas.metacat.dataone.MNodeService;

public class DatapackageSummarizerTest extends D1NodeServiceTest {

    private static final String ANNOTATION_TEST_DOC = "test/eml-sample-annotation.xml";

	/**

	 * constructor for the test

	 */

	public DatapackageSummarizerTest(String name) {

		super(name);

	}

	/**

	 * Establish a testing framework by initializing appropriate objects

	 */

	public void setUp() throws Exception {

		super.setUp();

	}

	/**

	 * Release any objects after tests are complete

	 */

	public void tearDown() {

	}

	/**

	 * Create a suite of tests to be run together

	 */

	public static Test suite() {

		TestSuite suite = new TestSuite();

		suite.addTest(new DatapackageSummarizerTest("testGenerateAnnotation"));

		return suite;

	}

	public void testGenerateAnnotation() throws Exception {

		Identifier metadataPid = new Identifier();

		metadataPid.setValue("testAnnotation.eml." + System.currentTimeMillis());

		Session session = getTestSession();

		try {

			InputStream object = new ByteArrayInputStream(this.getTestDocFromFile(ANNOTATION_TEST_DOC).getBytes("UTF-8"));

			SystemMetadata sysmeta = createSystemMetadata(metadataPid, session.getSubject(), object);

			ObjectFormatIdentifier formatId = new ObjectFormatIdentifier();

			formatId.setValue("eml://ecoinformatics.org/eml-2.0.0");

			sysmeta.setFormatId(formatId);

			Identifier pid = MNodeService.getInstance(request).create(session, metadataPid, object, sysmeta);

			assertEquals(metadataPid.getValue(), pid.getValue());

		} catch (Exception e) {

			e.printStackTrace();

			fail("Could not add metadata test file: " + e.getMessage());

		}

		// generate the annotation for the metadata

		DatapackageSummarizer ds = new DatapackageSummarizer();

		String rdfContent = ds.generateAnnotation(metadataPid);

		// save the annotation

		Identifier annotationPid = new Identifier();

		annotationPid.setValue("http://annotation/" + metadataPid.getValue());

		try {

			InputStream object = new ByteArrayInputStream(rdfContent.getBytes("UTF-8"));

			SystemMetadata sysmeta = createSystemMetadata(annotationPid, session.getSubject(), object);

			ObjectFormatIdentifier formatId = new ObjectFormatIdentifier();

			formatId.setValue("http://www.w3.org/TR/rdf-syntax-grammar");

			sysmeta.setFormatId(formatId);

			Identifier pid = MNodeService.getInstance(request).create(session, annotationPid, object, sysmeta);

			assertEquals(annotationPid.getValue(), pid.getValue());

		} catch (Exception e) {

			e.printStackTrace();

			fail("Could not add annotation test file: " + e.getMessage());

		}

		// check that it was parsed?

	}

}

import java.io.StringWriter;

import com.hp.hpl.jena.ontology.AllValuesFromRestriction;

import com.hp.hpl.jena.ontology.Individual;

import com.hp.hpl.jena.ontology.ObjectProperty;

import com.hp.hpl.jena.ontology.OntClass;

import com.hp.hpl.jena.ontology.OntModel;

import com.hp.hpl.jena.ontology.Ontology;

import com.hp.hpl.jena.rdf.model.ModelFactory;

import com.hp.hpl.jena.rdf.model.Property;

import com.hp.hpl.jena.rdf.model.Resource;

import com.hp.hpl.jena.util.iterator.ExtendedIterator;

	public static String rdf = "http://www.w3.org/1999/02/22-rdf-syntax-ns#";

	public static String rdfs = "http://www.w3.org/2000/01/rdf-schema#";

	public static String owl = "http://www.w3.org/2002/07/owl#";

	public static String oboe = "http://ecoinformatics.org/oboe/oboe.1.0/oboe.owl#";

	public static String oboe_core = "http://ecoinformatics.org/oboe/oboe.1.0/oboe-core.owl#";

	public static String oa = "http://www.w3.org/ns/oa#";

	public static String oa_source = "http://www.w3.org/ns/oa.rdf";

	public static String dcterms = "http://purl.org/dc/terms/";

	public static String dcterms_source = "http://dublincore.org/2012/06/14/dcterms.rdf";

	public static String foaf = "http://xmlns.com/foaf/0.1/";

	public static String foaf_source = "http://xmlns.com/foaf/spec/index.rdf";

    public static String prov = "http://www.w3.org/ns/prov#";

    public static String prov_source = "http://www.w3.org/ns/prov.owl";

    public static String cito =  "http://purl.org/spar/cito/";

    /**

     * Generate annotation for given metadata identifier

     * @param metadataPid

     */

    public String generateAnnotation(Identifier metadataPid) throws Exception {

    	DataPackage dataPackage = this.getDataPackage(metadataPid);

		OntModel m = ModelFactory.createOntologyModel();

		Ontology ont = m.createOntology("http://annotation/" + metadataPid.getValue());

		// TODO: import the ontologies we use

		ont.addImport(m.createResource(oboe));

		m.addSubModel(ModelFactory.createOntologyModel().read(oboe));

		ont.addImport(m.createResource(oa));

		m.addSubModel(ModelFactory.createOntologyModel().read(oa_source));

		ont.addImport(m.createResource(dcterms));

		m.addSubModel(ModelFactory.createOntologyModel().read(dcterms_source));

		ont.addImport(m.createResource(foaf));

		m.addSubModel(ModelFactory.createOntologyModel().read(foaf_source));

		ont.addImport(m.createResource(prov));

		//m.addSubModel(ModelFactory.createOntologyModel().read(prov_source));

		ont.addImport(m.createResource(cito));

		// properties

		ObjectProperty hasBodyProperty = m.getObjectProperty(oa + "hasBody");

		ObjectProperty hasTargetProperty = m.getObjectProperty(oa + "hasTarget");

		ObjectProperty hasSourceProperty = m.getObjectProperty(oa + "hasSource");

		ObjectProperty annotatedByProperty = m.getObjectProperty(oa + "annotatedBy");

		Property identifierProperty = m.getProperty(dcterms + "identifier");

		Property nameProperty = m.getProperty(foaf + "name");

		ObjectProperty ofCharacteristic = m.getObjectProperty(oboe_core + "ofCharacteristic");

		ObjectProperty usesStandard = m.getObjectProperty(oboe_core + "usesStandard");

		// classes

		OntClass measurementClass =  m.getOntClass(oboe_core + "Measurement");

		OntClass characteristicClass = m.getOntClass(oboe_core + "Characteristic");

		OntClass standardClass =  m.getOntClass(oboe_core + "Standard");

		Resource annotationClass =  m.getOntClass(oa + "Annotation");

		Resource specificResourceClass =  m.getOntClass(oa + "SpecificResource");

		Resource entityClass =  m.getResource(prov + "Entity");

		Resource personClass =  m.getResource(prov + "Person");

		int cnt = 0;

		// these apply to every attribute annotation

		Individual meta1 = m.createIndividual(ont.getURI() + "#meta" + cnt, entityClass);

		Individual p1 = m.createIndividual(ont.getURI() + "#person" + cnt, personClass);

		p1.addProperty(nameProperty, "Ben Leinfelder");

		meta1.addProperty(identifierProperty, metadataPid.getValue());

		// loop through the tables and attributes

		Entity[] entities = dataPackage.getEntityList();

		for (Entity entity: entities) {

			String entityName = entity.getName();

			logMetacat.debug("Entity name: " + entityName);

			Attribute[] attributes = entity.getAttributeList().getAttributes();

			for (Attribute attribute: attributes) {

				String attributeName = attribute.getName();

				String attributeLabel = attribute.getLabel();

				String attributeDefinition = attribute.getDefinition();

				String attributeType = attribute.getAttributeType();

				String attributeScale = attribute.getMeasurementScale();

				String attributeUnitType = attribute.getUnitType();

				String attributeUnit = attribute.getUnit();

				String attributeDomain = attribute.getDomain().getClass().getSimpleName();

				logMetacat.debug("Attribute name: " + attributeName);

				logMetacat.debug("Attribute label: " + attributeLabel);

				logMetacat.debug("Attribute definition: " + attributeDefinition);

				logMetacat.debug("Attribute type: " + attributeType);

				logMetacat.debug("Attribute scale: " + attributeScale);

				logMetacat.debug("Attribute unit type: " + attributeUnitType);

				logMetacat.debug("Attribute unit: " + attributeUnit);

				logMetacat.debug("Attribute domain: " + attributeDomain);

				// look up the characteristic or standard subclasses

				Resource standard = this.lookupStandard(standardClass, attribute);

				Resource characteristic = this.lookupCharacteristic(characteristicClass, attribute);

				if (standard != null || characteristic != null) {

					// instances

					Individual m1 = m.createIndividual(ont.getURI() + "#measurement" + cnt, measurementClass);

					Individual a1 = m.createIndividual(ont.getURI() + "#annotation" + cnt, annotationClass);

					Individual t1 = m.createIndividual(ont.getURI() + "#target" + cnt, specificResourceClass);

					// statements about the annotation

					a1.addProperty(hasBodyProperty, m1);

					a1.addProperty(hasTargetProperty, t1);

					t1.addProperty(hasSourceProperty, meta1);

					a1.addProperty(annotatedByProperty, p1);

					// describe the measurement in terms of restrictions

					if (standard != null) {

						AllValuesFromRestriction avfr = m.createAllValuesFromRestriction(null, usesStandard, standard);

						m1.addOntClass(avfr);

					}

					if (characteristic != null) {

						AllValuesFromRestriction avfr = m.createAllValuesFromRestriction(null, ofCharacteristic, characteristic);

						m1.addOntClass(avfr);

					}

					cnt++;

				}

			}		

		}

		StringWriter sw = new StringWriter();

		// only write the base model

		//m.write(sw, "RDF/XML-ABBREV");

		m.write(sw, null);

		return sw.toString();

	}

	private Resource lookupStandard(OntClass standardClass, Attribute attribute) {

		// what's our unit?

		String unit = attribute.getUnit().toLowerCase();

		boolean found = false;

		ExtendedIterator iter = standardClass.listSubClasses(false);

		while (iter.hasNext()) {

			OntClass subclass = (OntClass) iter.next();

			String subclassName = subclass.getLocalName().toLowerCase();

			logMetacat.debug("subclass: " + subclassName);

			if (subclassName.equals(unit)) {

				found = true;

			}

			if (subclass.hasLabel(unit, null)) {

				found = true;

			}

			if (found) {

				return subclass;

			}

		}

		return null;

	}

	private Resource lookupCharacteristic(OntClass characteristicClass, Attribute attribute) {

		// what's our label?

		String label = attribute.getLabel().toLowerCase();

		boolean found = false;

		// find something that matches

		ExtendedIterator iter = characteristicClass.listSubClasses();

		while (iter.hasNext()) {

			OntClass subclass = (OntClass) iter.next();

			String subclassName = subclass.getLocalName().toLowerCase();

			logMetacat.debug("subclass: " + subclassName);

			if (subclassName.equals(label)) {

				found = true;

			}

			if (subclass.hasLabel(label, null)) {

				found = true;

			}

			if (found) {

				return subclass;

			}

		}

		return null;

	}

	private DataPackage getDataPackage(Identifier pid) throws Exception {

		// for using the MN API as the MN itself

		MockHttpServletRequest request = new MockHttpServletRequest(null, null, null);

		Session session = new Session();

        Subject subject = MNodeService.getInstance(request).getCapabilities().getSubject(0);

        session.setSubject(subject);

		InputStream emlStream = MNodeService.getInstance(request).get(session, pid);

		// parse the metadata

		DataPackageParserInterface parser = new Eml200DataPackageParser();

		parser.parse(emlStream);

		DataPackage dataPackage = parser.getDataPackage();

		return dataPackage;

	}

	private void summarize(List<Identifier> identifiers) throws SQLException {

					// get the package

					DataPackage dataPackage = this.getDataPackage(pid);

			SortedProperties testProperties = new SortedProperties("test/test.properties");

			testProperties.load();

			String metacatContextDir = testProperties.getProperty("metacat.contextDir");

			PropertyService.getInstance(metacatContextDir + "/WEB-INF");

			testGenerate();

//			testSummary();

			System.exit(0);

	}

	public static void testGenerate() throws Exception {

		Identifier metadataPid = new Identifier();

		metadataPid.setValue("doi:10.5072/FK2445ZN4");

		DatapackageSummarizer ds = new DatapackageSummarizer();

		String rdfString = ds.generateAnnotation(metadataPid);

		logMetacat.info("RDF annotation: \n" + rdfString);

	}

	public static void testSummary() throws Exception {