Semantic MediaWiki - Making multiday calender events

I just introduced a calendar in my semantic media wiki using the calendar format of the Semantic Result Formats extension. This format works quite straight forward: You define which attribute (must be of date format) shall be used, and each entry having it is displayed in the calender with its page name as a link. You can also restrict the selection by category.

{{#ask:
[[date::>{{CURRENTYEAR}}-1-1]]
|?date
|format=calendar
|limit=400
|sort=date
|order=ascending,ascending
}}
Shows all entries with a date attribute since the first of this year (max 400 entries).

The only problem is that the calendar can just handle single day events. It does not anticipate an end date. In the web I found no easy solution, so I came up with my own. I used the recurring event functionality.

DELETE triples from Virtuoso via Java

I already wrote about how to access a triple store via Java using Jena. There I also mentioned that writing SPARQL UPDATE queries (INSERT, UPDATE, DELETE) against external triple stores may not work if the triple store does not support SPARQL 1.1 UPDATE.

In my scenario I wanted to DELETE triples from a Virtuoso endpoint. The query syntax Virtuoso supports is

DELETE FROM <graph> { ?s ?p ?o.} WHERE { GRAPH <graph> { ?s ?p ?o.} }

which is not the syntax defined by SPARQL 1.1 UPDATE - DELETE. If you hand this query string over to Jena, it will transform it into valid SPARQL 1.1 UPDATE syntax, which will result in an error at the Virtuoso side.

To be able to submit a DELETE query to Virtuoso anyway, Jena cannot be used. Instead HTTP Post has to be used directly.

Therefore I found a nice solution in the Jena Users Mailinglist archive, which I minimally updated to fit Virtuosos needs.

private boolean runUpdateQuery(String queryString) throws Exception {
    SPARQLUpdate p = new SPARQLUpdate();
    p.setEndpoint(endpoint);
    p.setUpdateString(queryString);
    String response = p.execute();
    if (!response.contains("done")) {
        System.err.println("UPDATE/SPARQL failed: " + queryString);
        return false;
    }
    return true;
}

Whereby SPARQLUpdate is defined as: 

package de.semweb.sparql;

import java.io.BufferedReader;
import java.io.InputStreamReader;
import java.io.OutputStreamWriter;
import java.net.URL;
import java.net.URLConnection;
import java.net.URLEncoder;

/**
 *
 * @author admos0
 */
public class SPARQLUpdate {

    private String updateString = "";
    private String endpoint = "";

    public SPARQLUpdate() {
        // empty constructor
    }

    public SPARQLUpdate(String input) {
        this.updateString = input;
    }

    /**
     * @method  execute the update
     * @return  the response <String>
     */
    public String execute() throws Exception {
        if (this.endpoint.equals("")) throw new Exception("No endpoint specified");
        if (this.updateString.equals("")) throw new Exception("No update string specified");
   
   
        // Construct data
        String data = URLEncoder.encode("query", "UTF-8") + "=" +
                URLEncoder.encode(this.getUpdateString(), "UTF-8");
   
   
        // Send data
        URL url = new URL(endpoint);
   
        URLConnection conn = url.openConnection();
        conn.setDoOutput(true);
        OutputStreamWriter wr = new OutputStreamWriter(conn.getOutputStream());
        wr.write(data);
        wr.flush();
   
        // Get the response
        BufferedReader rd = new BufferedReader(new InputStreamReader(conn.getInputStream()));
        String response = "";
        String line;
        while ((line = rd.readLine()) != null) {
            response += line;
        }
       
        wr.close();
        rd.close();
       
        return response;
    }

    /**
     * @param set the endpoint
     */
    public void setEndpoint(String endpoint) {
        this.endpoint = endpoint;
    }

    /**
     * @return the endpoint
     */
    public String getEndpoint() {
        return this.endpoint;
    }


    /**
     * @param updateString the updateString to set
     */
    public void setUpdateString(String updateString) {
        this.updateString = updateString;
    }

    /**
     * @return the updateString
     */
    public String getUpdateString() {
        return updateString;
    }
}

Access Triple Store via Java

The easiest way to access triple stores via Java is to use Jena ARQ.

ARQ is a query engine for Jena that supports the SPARQL RDF Query language. SPARQL is the query language developed by the W3C RDF Data Access Working Group.

You can easily access the data in the store using SELECT, ASK, DESCRIBE, and CONSTRUCT queries.

Query query = QueryFactory.create("queryString");
QueryExecution queryExec = QueryExecutionFactory.sparqlService( endpoint, query );
ResultSet result = queryExec.execSelect(); // or execSelectTriples()

It results in a ResultSet or an Interator of triples which can easily be processed further.

while (result.hasNext()) {
    QuerySolution solution = result.next();
    Resource id = solution.getResource("id");
    Resource title = solution.getLiteral("title");
}

One QuerySolution thereby is one result row of the query and each cell can be accessed by the variable name used in the SPARQL query.

But sometimes you do not want to just extract data from your triple store, but INSERT, UPDATE or DELETE triples. This can also be done using Jena.

UpdateRequest update = UpdateFactory.create(queryString);           
UpdateProcessor uExec = UpdateExecutionFactory.createRemote(update, endpoint);
uExec.execute(); 

Attention: This just works with triple stores supporting SPARQL 1.1 UPDATE.

MediaWiki - Further plugins which make MediaWiki better

In Semantic Media Wiki - making MediaWiki better I already briefly explained how the Semantic Media Wiki and the Semantic Forms plugin make the MediaWiki software better. But since I am using these, I also come over some other plugins which are also pretty great:

• Parser Function - Introduces logic by provideing functions like if, ifexists, switch, etc.  
• Arrays - Creates an additional set of parser functions that operate on arrays
• Semantic Result Formats - Additional formats to present results of semantic queries, like timeline, chart or tag cloud.
• Data Transfer - Enables you to create pages out of csv or xml files by filling the data into templates. Great way to import big amounts of data.

Semantic Media Wiki - making MediaWiki better

The Semantic Media Wiki is a plugin for the widly known Media Wiki software. In combination with the Semantic Forms plugin it brings the Media Wiki software to a complete new level. Here I just want to give a short overview why I think it is great. For a more detailed view, look at the extension pages.

The use case my department has is to collect information about data sets and create lists of them depending on their attributes.

Media Wiki

In a normal Media Wiki templates would be used to get a similar amount of information for each data set, and subsequently the lists would be manually updated after each creation or update of a data set.
This means a lot of work to keep the lists up to date and also the outfilling of a template is not very user friendly.

Media Wiki with Semantic Media Wiki and Semantic Forms plugin

With the Semantic Forms plugin forms can be created which assist the user to fill in a template. Therefore first in the template a predicate is defined for each variable, which has a type (Text, String, Number, Boolean, Page, Date, ...) and can be restricted to a given set of value (Enum).
Based on the type of the type of the predicate, the input field in the form is pictured (Textbox, Date Picker, Checkbox, DropDown, ...).
By saving the form, the data is stored in the template whereby the values of the variables is connected to the prediactes.
These predicates now can be used in queries to create dynamic lists.

In the use case of my department the form/template has fields for the owner of the data (Page, Textfield), the license it is under (String, Textfield) and of which type it is (String Enum, DropDown). Out of two different lists are created. Once the one for all data sets, to give an overview, and once a set of lists which contain all data sets of one type.
The owner field is also reused in other categories like project and presentations. This enables us to present all things (data sets, projects and presentations) a person is the owner of on it's user page, by making the query part of a user page template.

As you see you not only can create lists for one category, but by reusing prediactes easily merge data out of the whole wiki. Just like in the semantic web... :)

For examples of the use of this plugins please see the http://hackerspaces.org wiki or the CCC Camp Wiki.

Semscape - Visualizing Semantic Data Landscapes with Cytoscape 3.0 (GSoC 2012)

Semscape is a cytoscape 3.0 plugin which was developed by Yigang Zhou in the Google Summer of Code 2012. The project was mentored by Andra Waagmeester, Andrea Splendiani, Helena Deus, and me. 
Semscape allows to explore RDF endpoints via SPARQL queries and graphically represents the results in Cytoscape. In contrast to existing RDF visualization solutions, Semscape not only can represent data extracted out of SPARQL endpoints, but also the underlying schema of the data. This feature makes it much easier to explore foreign endpoints, where the RDF model is unknown.

For more information see:

• Installation: https://code.google.com/p/vsdlc3/wiki/DownloadRunSetup 
• UserGuide: https://code.google.com/p/vsdlc3/wiki/UserGuide 
• Blog: http://vsdlc3.blogspot.de/

SIGINT 2012 - Raising of the Dead?

The slides of my talk "The Semantic Web - Raising of the Dead?" at SIGINT 2012 can be found here. Also the video of my talk is available here. An embedded version will hopefully follow soon.

Update: And here is a youtube version

How to generate Java files from OWL-files in Jena - Extension

This is an extension of Andra Waagmester's "How to generate Java files from OWL-files in Jena."

For some files, like the PAV OWL-file, you will just get the header, but none of the predicates or classes. Here is the reason why:

Schemagen is picking a namespace for your ontology, and is defaulting to the value of the xmlns-attribute:

<rdf:RDF xmlns="&pav;2.0/"
     xml:base="&pav;2.0/"

Hence http://purl.org/pav/2.0/

However, all of their declarations are actually in a non-versioned namespace:

xmlns:pav="http://purl.org/pav/"

So it is necessary to tell schemagen to use the right namespace with -a, or change the file so that the namespaces are consistent. Run:

java -cp lib/icu4j-3.4.4.jar:lib/jena-arq-2.9.0-incubating.jar:lib/jena-core-2.7.0-incubating.jar:lib/jena-iri-0.9.0-incubating.jar:lib/log4j-1.2.16.jar:lib/slf4j-api-1.6.4.jar:lib/slf4j-log4j12-1.6.4.jar:lib/xercesImpl-2.10.0.jar:lib/xml-apis-1.4.01.jar jena.schemagen -i $inputFile -o "./src" --package "de.fraunhofer.scai.bio.uima.xcas2rdf.vocabulary" --owl -a "http://purl.org/pav/" pav

.. and it will generate what is expected.

Another tip is to add  --ontology to get OntProperty, OntClass, etc, declarations generated in the output file.