root/trunk/java/org.semanticdesktop.nepomuk.comp.pimoservice.test/src/org/semanticdesktop/nepomuk/comp/pimoservice/test/PimoOntologyTest.java

/**
 * 
 */
package org.semanticdesktop.nepomuk.comp.pimoservice.test;

import java.io.FileInputStream;
import java.io.IOException;
import java.io.InputStream;
import java.util.Collection;

import junit.framework.TestCase;

import org.ontoware.aifbcommons.collection.ClosableIterator;
import org.ontoware.rdf2go.RDF2Go;
import org.ontoware.rdf2go.model.Model;
import org.ontoware.rdf2go.model.ModelSet;
import org.ontoware.rdf2go.model.Statement;
import org.ontoware.rdf2go.model.Syntax;
import org.ontoware.rdf2go.model.node.LanguageTagLiteral;
import org.ontoware.rdf2go.model.node.Node;
import org.ontoware.rdf2go.model.node.PlainLiteral;
import org.ontoware.rdf2go.model.node.URI;
import org.ontoware.rdf2go.model.node.Variable;
import org.ontoware.rdf2go.model.node.impl.PlainLiteralImpl;
import org.ontoware.rdf2go.model.node.impl.URIImpl;
import org.ontoware.rdf2go.vocabulary.RDF;
import org.ontoware.rdf2go.vocabulary.RDFS;
import org.semanticdesktop.nepomuk.comp.pimoservice.PimoQuery;
import org.semanticdesktop.nepomuk.comp.pimoservice.client.ClientSession;
import org.semanticdesktop.nepomuk.comp.pimoservice.client.PimoClient;
import org.semanticdesktop.nepomuk.comp.pimoservice.impl.PimoServiceImpl;
import org.semanticdesktop.nepomuk.mockup.MockupNepomukServices;
import org.semanticdesktop.nepomuk.util.TestTool;
import org.semanticdesktop.services.NepomukServices;
import org.semanticdesktop.services.ServiceNotFoundException;
import org.semanticdesktop.services.pimoservice.PimoService;
import org.semanticdesktop.services.rdfrepository.RDF2GoRepository;
import org.semanticdesktop.services.rdfrepository.RDFRepositoryCommon;
import org.semanticdesktop.services.vocabulary.NAO;
import org.semanticdesktop.services.vocabulary.NCAL;
import org.semanticdesktop.services.vocabulary.NCO;
import org.semanticdesktop.services.vocabulary.PIMO;

/**
 * A JUnit test that runs common commands realizing a scenario.
 * The scenario under focus is Claudia and her trip to Belfast.
 * She annotates her co-worker Dirk, etc.
 * 
 * This JUnit test serves as a tutorial how to program using the 
 * PIMO Service and the PIMO Ontology.
 * @author Martin Klinkigt
 *
 */
public class PimoOntologyTest extends TestCase {
        
        NepomukServices services;
        PimoService pimoservice;
        PimoClient pimoclient;
        PimoQuery query;
        ClientSession session;
        RDF2GoRepository repository;
        ModelSet main;
        
        final String claudiaNameSpace = "http://www.sap.com/people/claudia#";
        final String claudiaEmail = "claudi-1@csc.kth.se";
        final String claudiaPimoUri = "http://www.sap.com/people/claudia#PIMO";
        final String claudiaUserUri = "http://www.sap.com/people/claudia#Claudia";

        /* (non-Javadoc)
         * @see junit.framework.TestCase#setUp()
         */
        protected void setUp() throws Exception {
                TestTool.setFullLogging();
                super.setUp();
        }

        /* (non-Javadoc)
         * @see junit.framework.TestCase#tearDown()
         */
        protected void tearDown() throws Exception {
                super.tearDown();
        }
        
        /**
         * A walkthrough of many things that happen in Claudia's scenario of 
         * working with Dirk and going to Belfast
         */
        public void testClaudiasScenario() throws Exception {
                // initialize PIMO for Claudia
                MockupNepomukServices mockup = new MockupNepomukServices();
                RDF2GoRepository repository = mockup.getRdf2gorepository();
                
                // Replace normal mockup configuration with correct uris for this test.
        // This is done BEFORE the first call to mockup.getPimoService(),
        // because otherwise the mockup will use its own configuration for 
        // claudia.
        {
            ModelSet ms = repository.getRepository(RDFRepositoryCommon.CONFIG_REPOSITORY_ID);
            Model m = ms.getModel(new URIImpl(RDFRepositoryCommon.DEFAULTGRAPH_URI));
            // m is not the default Model from the config repository (=not the main repository)
            m.open();
            InputStream in  = getClass().getResourceAsStream("claudiaconfig.n3");
            try  {
                try {
                    m.readFrom(in, Syntax.Turtle);
                } finally {
                    in.close();
                }
            } catch (IOException x)
            {
                throw new ServiceNotFoundException("Cannot initialize pimo config: "+x, x);
            }
            m.close();
        }

        // get the other Services needed to interact with PIMO
                pimoclient = mockup.getPimoClient();
                query = pimoclient.getPimoQuery();
                main = pimoclient.getMainRepository();
                session = pimoclient.createSession();
        ModelSet workmodelset = session.getWorkModelSet();
        
                // first tests on PIMO-Client related to CONFIGURATION values
                // get Identifier for Claudia from PimoClient,
                URI claudiaURI = pimoclient.getUserUri();
                assertEquals(claudiaUserUri,claudiaURI.toString());
                assertEquals(claudiaNameSpace,pimoclient.getUserNamespace().toString());
                
        // get Identifier for Claudias PIMO from PimoClient
                URI claudiaPimo = pimoclient.getPimoUri();
                assertEquals(claudiaPimoUri,claudiaPimo.toString());
                
                // load RDF about Dirk as NCO PersonContact from file
                // as if Claudia kept an Address book and had a vCard entry for Dirk.
        // In Nepomuk, this would have been crawled by DataWrapper Aperture
        // already and put into the "main" RDFRepository. 
                // file://home/claudia/dirk.vcf#dirk
                URI dirkPersonContact = new URIImpl("file://home/claudia/dirk.vcf#dirk");
        Model mDirk = main.getModel(dirkPersonContact);
        mDirk.open();
        InputStream inDirk  = getClass().getResourceAsStream("dirk.n3");
        try  {
            try {
                mDirk.readFrom(inDirk, Syntax.Turtle);
            } finally {
                inDirk.close();
            }
        } catch (IOException x)
        {
            throw new ServiceNotFoundException("Cannot load Dirk: "+x, x);
        }
        inDirk.close();
                        
                // Create a PIMO:Person from the NCO:PersonContact.
        // The dirkPimo URI is the unique identifier for the Person Dirk 
        // on Claudias system. It is then connected to the URI in the
        // vCard using the PIMO:groundingOccurrence relation.
        // We call this process "rebirth" as Dirk is now reborn as PIMO Thing,
        // or "thingification".
                URI dirkPimo = session.createResourceFromGroundingOccurence(dirkPersonContact, "Dirk Hagemann", PIMO.Person);
                session.commit();
        // Thingification also copies the identifiers of the occurrence to the Thing,
        // so that other services can find Things based on nao:identifier and its sub-properties.
                assertTrue(main.containsStatements(Variable.ANY, dirkPimo, NAO.identifier, new PlainLiteralImpl("dirk@sap.com")));
                
        // dirkPimo is the unique identifier but does not have many properties.
        // dirkPersonContact has properties defined in the address book.
        // Both represent the same entity, the user now wants to see all
        // facts about the Person Dirk in an integrated view

                // load resource closure about dirk, fully inferred, the facts about his grounding occurrence
                // are facts about dirk as person
                session.bufferResourceClosure(dirkPimo, PIMO.GroundingClosure);

                //integratedView.dump();
                // assert that the name, address, email is taken from the grounding
                assertTrue(workmodelset.containsStatements(Variable.ANY, dirkPimo, NCO.nameFamily, new PlainLiteralImpl("Hagemann")));
                assertTrue(workmodelset.containsStatements(Variable.ANY, dirkPimo, NCO.nameGiven, new PlainLiteralImpl("Dirk")));
                
                // User tries to edit the facts about the grounding - this is forbidden
                try {
            workmodelset.removeStatement(PIMO.GroundingClosure, dirkPimo, NCO.nameGiven, new PlainLiteralImpl("Dirk"));
                        fail("can remove a fact inferred from the GroundingClosure");
                } catch (Exception e) {
                        // it works
                }
                
                // find out somehow which triples of the resource closure integratedView 
                // can be edited (which were created by
                // PIMO or NEPOMUK) and which come from NIE
                // See ModelSetDiff. Works over the contextURI
                
                // Edit facts that have been said about the dirkPimo.
        {
            // the complicated way:
            // First get a valid contextURI from the session.
                URI contextURI = session.getWorkModel().getContextURI();
            // then add to the context
                URI dirkSAPPage = new URIImpl("http://www.sap.com/people/DirkHagemann");
                // Add the new fact using the workmodelset and the new context URI
                workmodelset.addStatement(contextURI, dirkPimo, PIMO.referencingOccurrence, dirkSAPPage);
           
            // The same can be done without caring for context by using the magic 
            // model directly, which adds everything to the work model by default
            URI dirkID = new URIImpl("http://id.sap.com/person/1650");
            session.getMagicModel().addStatement(dirkPimo, PIMO.hasOtherRepresentation, dirkID);
            assertEquals("context uri stays the same until commit", contextURI, session.getWorkModel().getContextURI());
            assertEquals("the magicmodel has the same context as the workmodel, for convenience",
                session.getWorkModel().getContextURI(), session.getMagicModel().getContextURI());
    
                // we must commit the session to add the statements in the repository
            // committing the session will not flush the buffers! 
            // The closure is still buffered.
                session.commit();
            
            assertTrue(main.containsStatements(contextURI, dirkPimo, PIMO.referencingOccurrence, new URIImpl("http://www.sap.com/people/DirkHagemann")));
            assertTrue(main.containsStatements(contextURI, dirkPimo, PIMO.hasOtherRepresentation, dirkID));
                assertTrue(main.containsStatements(contextURI, dirkPimo, PIMO.referencingOccurrence, dirkSAPPage));
                assertTrue(main.containsStatements(contextURI, dirkPimo, PIMO.hasOtherRepresentation, dirkID));
        }
                // create claudia:InitialMeetinginBelfast
                URI belfastMeeting = session.createResource("Initial Meeting in Belfast", PIMO.Meeting);
                session.commit();

                // get possible Properties
                Collection<URI> meetProps = query.getPossiblePropertiesForThing(belfastMeeting.toString(), true, true);
                assertFalse(meetProps.contains(NCAL.dtstart));
                assertFalse(meetProps.contains(NCAL.categories));
                assertFalse(meetProps.contains(NCAL.contact));
                assertFalse(meetProps.contains(NCAL.location));
                assertFalse(meetProps.contains(NCAL.duration));
                
                // add to befastMeeting the type NCAL.Event to get NCAL properties
                session.getMagicModel().addStatement(belfastMeeting, RDF.type, NCAL.Event);
        // this implicitly created a new context, which has to be committed.
                session.commit();
                
                // HELP the user editing claudia:InitialMeetinginBelfast 
                // query for a list of properties that can be added to claudia:InitialMeetinginBelfast
                // This list contains PIMO properties but also NIE/NCAL properties!
        if (1==2) // TODO: this is broken at the moment 
        {
                meetProps = query.getPossiblePropertiesForThing(belfastMeeting.toString(), true, true);
                assertTrue(meetProps.contains(NCAL.dtstart));
                assertTrue(meetProps.contains(NCAL.categories));
                assertTrue(meetProps.contains(NCAL.contact));
                // Location is not one of them, rather PIMO.hasLocation should be used
        // assertTrue(meetProps.contains(NCAL.location));
                assertTrue(meetProps.contains(NCAL.duration));
        }
                
                // select three NCAL properties to be added to the claudia:InitialMeetinginBelfast
                PlainLiteral belfastLocation = new PlainLiteralImpl("Hotel Belfast");
                PlainLiteral belfastStart = new PlainLiteralImpl("20070304T230000");
                PlainLiteral belfastDuration = new PlainLiteralImpl("DURATION:PT1H0M0S");
                URI belfastDate = session.createResource(NCAL.NcalDateTime);
                session.getMagicModel().addStatement(belfastDate, NCAL.dateTime, belfastStart);
        session.getMagicModel().addStatement(belfastMeeting, NCAL.duration, belfastDuration);
        session.getMagicModel().addStatement(belfastMeeting, NCAL.location, belfastLocation);
                session.commit();
                
                // add some fact about belfast may be automaticaly with local data alignment
                // TODO asserts
                
                // (create class flight)
                URI flight = session.createClass("Flight", PIMO.Event);
                
                // (create flights)
                URI LHL4573 = session.createResource("LHL 4573 - Frankfurt - Belfast", flight);
                URI LHL7452 = session.createResource("LHL 7452 - Belfast - Frankfurt", flight);
                
                // add pimo:hasPart to claudia:InitialMeetinginBelfast for the flights
                Model wk = session.getWorkModel();
                wk.addStatement(belfastMeeting, PIMO.hasPart, LHL4573);
                wk.addStatement(belfastMeeting, PIMO.hasPart, LHL7452);
                
                // SAVE
                session.commit();
                // is it saved?
                assertTrue(main.containsStatements(Variable.ANY, belfastMeeting, RDF.type, PIMO.Meeting));
                assertTrue(main.containsStatements(Variable.ANY, flight, RDFS.subClassOf, PIMO.Event));
                assertTrue(main.containsStatements(Variable.ANY, LHL4573, RDF.type, flight));
                assertTrue(main.containsStatements(Variable.ANY, LHL7452, RDF.type, flight));
                // check inferencing
                assertTrue(main.containsStatements(Variable.ANY, LHL4573, PIMO.partOf, belfastMeeting));
                assertTrue(main.containsStatements(Variable.ANY, LHL7452, PIMO.partOf, belfastMeeting));
                
        // Claudia now represents the City of Belfast
                // create Belfast, implicitly also a new context in the clientsession
                URI belfast = session.createResource("Belfast", PIMO.City);
                
                // add pimo:hasLocation to claudia:InitialMeetinginBelfast to Belfast
                session.getMagicModel().addStatement(belfastMeeting, PIMO.hasLocation, belfast);
                
                // link Belfast with Wikipedia entry about Belfast using
                // pimo:referencingOccurrence
        // This indicates that Claudia's Belfast "is the same concept as described
        // on that resource I refer to".
        // See also this paper for more deliberate use:
        // "PIMO Population and Semantic Annotation for the Gnowsis Semantic Desktop"
        // http://ftp.informatik.rwth-aachen.de/Publications/CEUR-WS/Vol-202/SEMDESK2006_0008.pdf
        session.getMagicModel().addStatement(belfast,PIMO.referencingOccurrence,new URIImpl("http://en.wikipedia.org/wiki/Belfast"));
                
                // link Belfast with DBPEdia entry about Belfast using
                // pimo:hasOtherRepresentation
                // http://dbpedia.org/resource/Belfast
        // This indicates that there is another ontology that represents the 
        // same concept as Claudia's Belfast.
        session.getMagicModel().addStatement(belfast,PIMO.hasOtherRepresentation,new URIImpl("http://dbpedia.org/resource/Belfast"));
        
        // commit this session
        session.commit();
                
                // BONUS: load belfast information including hasOtherRepresentation 
                // closure using linked data on HTTP GET (accept:rdf) on http://dbpedia.org/resource/Belfast
        {
            // Assuming we forgot above lines and only remember Belfast.
            session.bufferOpenLinkedData(belfast);
            
            // now assert the facts from DBPedia are also facts about claudia's Belfast
            // look in the workmodelset and see that it contains statements
            // with non English literals
            String nonEnglishLiteral = "";
            boolean englishLiteral = false;
            ClosableIterator<? extends Statement> iter = null;
            try {
                iter = workmodelset.findStatements(Variable.ANY, belfast, Variable.ANY, Variable.ANY);
                while (iter.hasNext()) {
                        Statement s = iter.next();
                        Node node = s.getObject();
                        if (node instanceof LanguageTagLiteral) {
                                LanguageTagLiteral literal = node.asLanguageTagLiteral();
                                if(literal.getLanguageTag().equals("en")) {
                                        englishLiteral = true;
                                } else {
                                        nonEnglishLiteral +=literal.getLanguageTag()+",";
                                }
                        }
                }
            } finally {
                iter.close();
            }
            assertTrue("Result contains a statement about Belfast which is English",englishLiteral);
            assertTrue("Result should contain statement about Belfast which is not English",nonEnglishLiteral.length()>0);
            
            // we only want statements in the language which Claudia speaks
            // filter belfast data based on the language of the user configured in
            // pimoclient
            session.setLanguageFilter(true);
            
            nonEnglishLiteral = "";
            englishLiteral = false;
            try {
                iter = workmodelset.findStatements(Variable.ANY, belfast, Variable.ANY, Variable.ANY);
                while (iter.hasNext()) {
                        Statement s = iter.next();
                        Node node = s.getObject();
                        if (node instanceof LanguageTagLiteral) {
                                LanguageTagLiteral literal = node.asLanguageTagLiteral();
                                if(literal.getLanguageTag().equals("en")) {
                                        englishLiteral = true;
                                } else {
                            nonEnglishLiteral +=literal.getLanguageTag()+",";
                                }
                        }
                }
            } finally {
                iter.close();
            }
            assertTrue("Result contains a statement about Belfast which is English",englishLiteral);
            assertTrue("Result contains a statement about Belfast which is not English, languages are: "+nonEnglishLiteral,nonEnglishLiteral.length()==0);

        }
                
                // on the linked data, show an integratd view of belfast,
                // including its relation with the meeting (location)
                // and the english rdfs:comment from dbpedia
                // TODO
        
        // now we tag some local files
        // first we need the aperture crawl result in the repository.
        main.open();
        main.readFrom(getClass().getResourceAsStream("ClaudiaDocumentsCrawl.trix"),Syntax.Trix);
        // okay, now we must create a tag. But Claudia makes a mistake.
        // for taging she must create a nao:Tag but she makes something better ...
        URI cid = session.createResource("CID", PIMO.Project);
        session.commit();
        // this is not a tag, but Claudia tries to add it to a local file
        URI CIDJobOffer = new URIImpl("file:/D:/Nepomuk/workspace/claudia_stern/documents/projects/CID/Job%20Offer%20CID%20Training.doc");
        session.addTag(CIDJobOffer, cid);
        session.commit();
        // nothing went wrong, because the system makes cid to a nao:Tag
        // and created a PIMO.Document from the URI to the file system
        // This is better because we don't only have a simple tag with text
        // but the whole hierarchy. So we also know, that this file is a
        // document from a project.
        
        // we don't know the uri if this thing, so try to get it
        URI CIDJobOfferDocument = null;
        ClosableIterator<? extends Statement> iter = null;
        try {
                iter = main.findStatements(Variable.ANY, Variable.ANY, NAO.hasTag, cid);
                for (int i = 0; iter.hasNext(); i++) {
                        if (i==0) {
                                // the first entry
                                CIDJobOfferDocument = iter.next().getSubject().asURI();
                                assertFalse(CIDJobOfferDocument==null);
                        } else {
                                // something went wrong.
                                fail("There are more than one thing, which has the tag: "+cid);
                        }
                }
        } finally {
                iter.close();
        }
        assertTrue(main.containsStatements(Variable.ANY, CIDJobOfferDocument, NAO.hasTag, cid));
        assertTrue(main.containsStatements(Variable.ANY, CIDJobOfferDocument, PIMO.groundingOccurrence, CIDJobOffer));
        // now we tag Dirk with this cid tag
        session.addTag(dirkPimo, cid);
        session.commit();
        assertTrue(main.containsStatements(Variable.ANY, dirkPimo, NAO.hasTag, cid));
        // for more information about tagging see:
        // https://dev.nepomuk.semanticdesktop.org/wiki/ClientSession
        }
        

}