/**
* If the {@link ConfigurationProperties} has a name for the initial admin user, create the user
* and add it to the model.
*/
protected void createInitialAdminUser(Model model) {
String initialAdminUsername = ConfigurationProperties.getProperty("initialAdminUser");
if (initialAdminUsername == null) {
return;
}
// A hard-coded MD5 encryption of "defaultAdmin"
String initialAdminPassword = "******";
String vitroDefaultNs = DEFAULT_DEFAULT_NAMESPACE;
Resource user = model.createResource(vitroDefaultNs + "defaultAdminUser");
model.add(
model.createStatement(
user,
model.createProperty(VitroVocabulary.RDF_TYPE),
model.getResource(VitroVocabulary.USER)));
model.add(
model.createStatement(
user,
model.createProperty(VitroVocabulary.USER_USERNAME),
model.createTypedLiteral(initialAdminUsername)));
model.add(
model.createStatement(
user,
model.createProperty(VitroVocabulary.USER_MD5PASSWORD),
model.createTypedLiteral(initialAdminPassword)));
model.add(
model.createStatement(
user,
model.createProperty(VitroVocabulary.USER_ROLE),
model.createTypedLiteral("role:/50")));
}
public void setUp() {
model = getModel();
Resource S2 = model.createResource(anchor + "subject2");
S = model.createResource(anchor + "subject");
P = model.createProperty(anchor + "predicate");
O = model.createLiteral(anchor + "object");
SPO = model.createStatement(S, P, O);
SPO2 = model.createStatement(S2, P, O);
}
/**
* Builds up the one triple that states where the actual data for the target mapping comes from.
* Such a source can be simply a database table or an SQL query.
*
* @param r2rml the target com.hp.hpl.jena.rdf.model.Model
* @param relation the data source (table name or SQL query)
* @return the whole Statement stating where the data comes from, e.g. '[] rr:tableName "EMP"'
*/
private Statement buildLogicalTableTriple(Model r2rml, SqlOpBase relation) {
// subject (a blank node [])
Resource logicalTableSubject = ResourceFactory.createResource();
// predicate (rr:tableName or rr:sqlQuery)
Property logicalTablePredicate;
// object (a Literal like "SELECT DEPTNO FROM DEPT WHERE DEPTNO > 23" or
// simply a table name like "DEPTNO"
Literal logicalTableObject;
// it's a table
if (relation instanceof SqlOpTable) {
SqlOpTable tbl = (SqlOpTable) relation;
logicalTablePredicate = ResourceFactory.createProperty(rrNamespace, "tableName");
logicalTableObject = ResourceFactory.createPlainLiteral(tbl.getTableName());
// it's a query
} else if (relation instanceof SqlOpQuery) {
SqlOpQuery query = (SqlOpQuery) relation;
logicalTablePredicate = ResourceFactory.createProperty(rrNamespace, "sqlQuery");
logicalTableObject = ResourceFactory.createPlainLiteral(query.getQueryString());
// it's not possible
} else {
// should never be called since a relation can either be a table
// or a query
logicalTablePredicate = ResourceFactory.createProperty("");
logicalTableObject = ResourceFactory.createPlainLiteral("");
}
Statement logicalTblStatement =
r2rml.createStatement(logicalTableSubject, logicalTablePredicate, logicalTableObject);
return logicalTblStatement;
}
/**
* create a Statement in a given Model with (S, P, O) extracted by parsing a string.
*
* @param lockModel the model the statement is attached to
* @param an "S P O" string.
* @return model.createStatement(S, P, O)
*/
public static Statement statement(Model m, String fact) {
StringTokenizer st = new StringTokenizer(fact);
Resource sub = resource(m, st.nextToken());
Property pred = property(m, st.nextToken());
RDFNode obj = rdfNode(m, st.nextToken());
return m.createStatement(sub, pred, obj);
}
@Override
public Edge addEdge(
final Object id, final Vertex outVertex, final Vertex inVertex, final String label) {
final Resource inV = model.createResource(inVertex.getId().toString());
final Resource outV = model.createResource(outVertex.getId().toString());
final Property edge = model.createProperty(label);
final Statement statement = model.createStatement(outV, edge, inV);
model.add(statement);
return new JenaEdge(model, edge, inV, outV);
}
@Test
public void shouldIgnoreHashUrisOutsideTheRepositoryDomain() throws RepositoryException {
final Model m = createDefaultModel();
final Statement x =
m.createStatement(
testSubjects.toDomain("/"), createProperty("info:x"), createResource("info:x#abc"));
final Statement statement = testObj.skolemize(testSubjects, x);
assertEquals(x, statement);
}
@Test
public void shouldPassthroughValidStatements() throws RepositoryException {
final Model m = createDefaultModel();
final Statement x =
m.createStatement(
testSubjects.toDomain("/"), createProperty("info:x"), createPlainLiteral("x"));
final Statement statement = testObj.skolemize(testSubjects, x);
assertEquals(x, statement);
}
public void testIsReified() {
ReifiedStatement rs = model.createReifiedStatement(aURI, SPO);
Resource BS = model.createResource(anchor + "BS");
Property BP = model.createProperty(anchor + "BP");
RDFNode BO = model.createProperty(anchor + "BO");
model.add(rs, P, O);
assertTrue("st should be reified now", SPO.isReified());
assertTrue("m should have st reified now", model.isReified(SPO));
assertFalse(
"this new statement should not be reified", model.createStatement(BS, BP, BO).isReified());
}
@Test
public void shouldSkolemizeBlankNodeObjects() throws RepositoryException {
final Model m = createDefaultModel();
final Statement x =
m.createStatement(testSubjects.toDomain("/"), createProperty("info:x"), createResource());
testObj.jcrTools = mock(JcrTools.class);
when(testObj.jcrTools.findOrCreateNode(eq(mockSession), anyString())).thenReturn(mockNode);
when(mockNode.getPath()).thenReturn("/.well-known/x");
final Statement statement = testObj.skolemize(testSubjects, x);
assertEquals("info:fedora/.well-known/x", statement.getObject().toString());
}
/**
* check that, from a model with any combination of the statements given, we can convert R into a
* ReifiedStatement iff the four components of the quad are in the model.
*/
public void testReificationCombinations() {
Resource RR = model.createResource(aURI), SS = model.createResource(anotherURI);
Property PP = (Property) RR.as(Property.class);
Object[][] statements = {
{model.createStatement(RR, RDF.type, RDF.Statement), new Integer(1)},
{model.createStatement(RR, RDF.subject, SS), new Integer(2)},
{model.createStatement(RR, RDF.predicate, PP), new Integer(4)},
{model.createStatement(RR, RDF.object, O), new Integer(8)},
{model.createStatement(SS, PP, O), new Integer(16)},
{model.createStatement(RR, PP, O), new Integer(32)},
{model.createStatement(SS, RDF.subject, SS), new Integer(64)},
{model.createStatement(SS, RDF.predicate, PP), new Integer(128)},
{model.createStatement(SS, RDF.object, O), new Integer(256)},
{model.createStatement(SS, RDF.type, RDF.Statement), new Integer(512)}
};
if (model.getReificationStyle() != ModelFactory.Minimal)
testCombinations(model, RR, 0, statements, statements.length);
}
@Test(expected = PathNotFoundException.class)
public void shouldNotAllowHashUriSubjectsForResourcesThatDontExist() throws RepositoryException {
final Model m = createDefaultModel();
final Statement x =
m.createStatement(
testSubjects.toDomain("/some/#/abc"),
createProperty("info:x"),
testSubjects.toDomain("/"));
testObj.jcrTools = mock(JcrTools.class);
when(mockNode.getParent()).thenReturn(mockHashNode);
when(mockHashNode.getParent()).thenReturn(mockChildNode);
when(mockSession.nodeExists("/some")).thenReturn(false);
when(testObj.jcrTools.findOrCreateNode(mockSession, "/some/#/abc", NT_FOLDER))
.thenReturn(mockNode);
testObj.skolemize(testSubjects, x);
}
public static Statement createStatement(Triple triple) throws OREException {
Model model = ModelFactory.createDefaultModel();
Resource resource = model.createResource(triple.getSubjectURI().toString());
Property property = model.createProperty(triple.getPredicate().getURI().toString());
RDFNode node;
if (triple.isLiteral()) {
node = model.createTypedLiteral(triple.getObjectLiteral());
} else {
node = model.createResource(triple.getObjectURI().toString());
}
Statement statement = model.createStatement(resource, property, node);
return statement;
}
@Test
public void shouldCreateHashUriObjects() throws RepositoryException {
final Model m = createDefaultModel();
final Statement x =
m.createStatement(
testSubjects.toDomain("/"),
createProperty("info:x"),
testSubjects.toDomain("/some/#/abc"));
testObj.jcrTools = mock(JcrTools.class);
when(mockNode.getParent()).thenReturn(mockHashNode);
when(mockHashNode.getParent()).thenReturn(mockChildNode);
when(mockSession.nodeExists("/some")).thenReturn(true);
when(mockSession.getNode("/some")).thenReturn(mockChildNode);
when(testObj.jcrTools.findOrCreateNode(mockSession, "/some/#/abc", NT_FOLDER))
.thenReturn(mockNode);
final Statement statement = testObj.skolemize(testSubjects, x);
assertEquals(x, statement);
verify(testObj.jcrTools).findOrCreateNode(mockSession, "/some/#/abc", NT_FOLDER);
verify(mockNode).addMixin(FEDORA_RESOURCE);
}
@Test
public void shouldAddBlankNodePairtreeMixin() throws RepositoryException {
final Model m = createDefaultModel();
final Resource resource = createResource();
final Statement x = m.createStatement(resource, createProperty("info:x"), resource);
testObj.jcrTools = mock(JcrTools.class);
when(testObj.jcrTools.findOrCreateNode(eq(mockSession), anyString())).thenReturn(mockNode);
when(mockNode.getPath()).thenReturn("/x");
when(mockNode.getParent()).thenReturn(mockHashNode);
when(mockHashNode.getParent()).thenReturn(mockChildNode);
when(mockHashNode.isNew()).thenReturn(true);
when(FedoraTypesUtils.getClosestExistingAncestor(mockSession, "/.well-known/genid/"))
.thenReturn(mockChildNode);
final Statement statement = testObj.skolemize(testSubjects, x);
assertEquals("info:fedora/x", statement.getSubject().toString());
assertEquals("info:fedora/x", statement.getObject().toString());
verify(testObj.jcrTools).findOrCreateNode(mockSession, "/.well-known/genid/");
verify(mockNode).addMixin(FEDORA_SKOLEM);
verify(mockNode.getParent()).addMixin(FEDORA_PAIRTREE);
}
/**
* Builds up statements like [] rr:template "http://data.example.com/department/{DEPTNO}" or []
* rr:class ex:Department and returns them as a Statement List.
*
* @param r2rml the target com.hp.hpl.jena.rdf.model.Model
* @param mappingData the target that should be mapped to relational structures (subject,
* predicate or object)
* @param varDefs the construction definition of the target value based in the actual database
* value and some additional data like prefix strings or certain functions like uri( ... )
* @return a List<Statement> containing all the subject map statements
*/
private List<Statement> buildMapStatements(Model r2rml, Node mappingData, VarDefinition varDefs) {
List<Statement> results = new ArrayList<Statement>();
// a blank node []
Resource mapSubject = ResourceFactory.createResource();
// rr:template or rr:column or rr:constant
Property mapPredicate;
// a literal like "http://data.example.com/department/{DEPTNO}" or
// simply "DEPTNO" (column name) or a constant "Foo bar!!"
// (or in rare cases a URI, which is handled separately)
Literal mapObject;
// template or column or constant
if (mappingData.isVariable()) {
Collection<RestrictedExpr> restrictions = varDefs.getDefinitions((Var) mappingData);
List<PredicateAndObject> mapPredicateAndObjects = processRestrictions(restrictions);
for (PredicateAndObject result : mapPredicateAndObjects) {
mapPredicate = result.getPrediacte();
Statement resultStatement;
RDFNode rawObject = result.getRawObject();
// object is literal
if (rawObject.isLiteral()) {
mapObject = rawObject.asLiteral();
resultStatement = r2rml.createStatement(mapSubject, mapPredicate, mapObject);
// object is blank node
} else if (rawObject.isAnon()) {
Resource mapResObject = rawObject.asResource();
resultStatement = r2rml.createStatement(mapSubject, mapPredicate, mapResObject);
// object is resource
} else {
Resource mapResObject = rawObject.asResource();
resultStatement = r2rml.createStatement(mapSubject, mapPredicate, mapResObject);
}
results.add(resultStatement);
}
// everything that is not a variable is handled as a constant
} else if (mappingData.isConcrete()) {
// URIs and Literals have to be handled separately since the methods
// to retrieve the respective value are different
Statement resultStatement;
// URI
if (mappingData.isURI()) {
/*
* This case is somewhat special since the mapObject is not a
* Literal. So, this needs some special handling:
* - the Literal mapObject will not be used
* - a special mapObject_uri Resource will be created
* - the result will be created, appended to the List and
* returned to not go through any further ordinary processing
*/
Resource mapObject_uri = ResourceFactory.createResource(mappingData.getURI());
mapPredicate = ResourceFactory.createProperty(rrNamespace, "constant");
resultStatement = r2rml.createStatement(mapSubject, mapPredicate, mapObject_uri);
results.add(resultStatement);
return results;
// Literal
} else if (mappingData.isLiteral()) {
mapObject = ResourceFactory.createPlainLiteral(mappingData.getLiteral().toString(false));
// else (e.g. blank node)
} else { // mapSubject.isBlank() == true
/*
* Hmm... I think this violates the standard. So lean back and
* enjoy the trace...
*/
mapObject = null;
}
mapPredicate = ResourceFactory.createProperty(rrPrefix, "constant");
resultStatement = r2rml.createStatement(mapSubject, mapPredicate, mapObject);
results.add(resultStatement);
}
return results;
}
/**
* Builds up the RDF model "r2ml" representing the R2RML structure of the given Sparqlify-ML
* definitions. At this point only parts of the Sparqlify-ML view definitions are considered.
* These are so called patterns representing quads (graph, subject, predicate, object) that can be
* valid resources or variables with certain restrictions derived from Sparqlify-ML expressions
* like "uri(concat("http://panlex.org/plx/", ?li))" meaning that the actual value is constructed
* by creating a URI based on the concatenation of "http://panlex.org/plx/" and the value of the
* "li" column in the current line of the table and database at hand.
*
* @param r2rml the target com.hp.hpl.jena.rdf.model.Model
* @param pattern a quad that may contain variables in the subject, predicate or object position
* @param relation the considered database table or constructed logical relation defined by a
* query or view
* @param varDefs the construction definition of the target value based in the actual database
* value and some additional data like prefix strings or certain functions like uri( ... )
*/
private void exportPattern(Model r2rml, Quad pattern, SqlOpBase relation, VarDefinition varDefs) {
/*
* Just some hints concerning the variable names: I will give my best to
* be as consistent as possible obeying the following rules:
* - there is always a scope of a triple that defines the current
* subject predicate and object
* - since triples can be nested it may be ambiguous what the
* current subject, predicate or object is
* - since triples in R2RML refer to a subject ("rr:subjectMap"),
* predicate or object ("predicateObjectMap") things become even
* more unclear
* - I will determine a scope based on the its subject, so if the
* subject is "foo", "fooSubject" is the subject in the "foo" scope.
* "fooPredicate" is the predicate in the "foo" scope and so on.
* - since there may be several predicates and objects I will prefix a
* hint stating the special use of the considered part of a triple,
* so "fooPredicate_bar" is the predicate in the "foo" scope to
* define "bar"
* - statements are named the same way: <scope>Statement_<use>
*/
// create the triples map subject
String triplesMapId = String.format("#TriplesMap%d", idCounter++);
Resource triplesMapSubject = ResourceFactory.createResource(triplesMapId);
// create logical table triple
Property triplesMapPredicate_logicalTable =
ResourceFactory.createProperty(rrNamespace + "logicalTable");
Statement logicalTblStatement_tblDefinition = buildLogicalTableTriple(r2rml, relation);
r2rml.add(logicalTblStatement_tblDefinition);
Statement triplesMapStatement_logicalTable =
r2rml.createStatement(
triplesMapSubject,
triplesMapPredicate_logicalTable,
logicalTblStatement_tblDefinition.getSubject());
r2rml.add(triplesMapStatement_logicalTable);
/*
* subject map
*/
Node subjectMapObject_templColOrConst = pattern.getSubject();
List<Statement> triplesMapStatement_subjectMaps =
buildMapStatements(r2rml, subjectMapObject_templColOrConst, varDefs);
// there may be more than one entry, e.g.
// [] rr:template "http://data.example.com/department/{DEPTNO}" and
// [] rr:class ex:Department
for (Statement statement : triplesMapStatement_subjectMaps) {
r2rml.add(statement);
}
// build up the subject map triple that looks sth. like this:
// <#TriplesMap2> rr:subjectMap []
if (triplesMapStatement_subjectMaps.size() > 0) {
// rr:subjectMap
Property triplesMapPredicate_subjectMap =
ResourceFactory.createProperty(rrNamespace, "subjectMap");
// []
RDFNode triplesMapObject_subjectMap =
(RDFNode) triplesMapStatement_subjectMaps.get(0).getSubject();
// <#TriplesMap2> rr:subjectMap []
Statement subjectMapTriple =
r2rml.createStatement(
triplesMapSubject, triplesMapPredicate_subjectMap, triplesMapObject_subjectMap);
r2rml.add(subjectMapTriple);
}
/*
* predicate map
*/
Node predicateMap_templColOrConst = pattern.getPredicate();
List<Statement> prediacteMapStatements =
buildMapStatements(r2rml, predicateMap_templColOrConst, varDefs);
// there may be more than one entry, e.g.
// [] rr:template "http://data.example.com/department/{DEPTNO}" and
// [] rr:class ex:Department
for (Statement statement : prediacteMapStatements) {
r2rml.add(statement);
}
/*
* object map
*/
Node objectMap_templColOrConst = pattern.getObject();
List<Statement> objectMapStatements =
buildMapStatements(r2rml, objectMap_templColOrConst, varDefs);
// there may be more than one entry, e.g.
// [] rr:template "http://data.example.com/department/{DEPTNO}" and
// [] rr:class ex:Department
for (Statement statement : objectMapStatements) {
r2rml.add(statement);
}
/*
* predicate object map
*/
// build the predicate-object map triple that may look like this:
// <#TriplesMap2> rr:prediacteObjectMap
// [ rr:predicateMap
// [ rr:constant
// ex:name
// ] ;
// rr:objectMap
// [ rr:column "ENAME"
// ];
// ]
// [#1]
Resource triplesMapObject_predicateObjectMap = ResourceFactory.createResource();
// 1) the statement for [#1] rr:predicateMap [#2]
Property predicateObjectMapPredicate_predicateMap =
ResourceFactory.createProperty(rrNamespace, "predicateMap");
// [#2]
RDFNode predicateObjectMapObject_predicateMap =
(RDFNode) prediacteMapStatements.get(0).getSubject();
Statement predicateObjectMapStatement_predicateMap =
r2rml.createStatement(
triplesMapObject_predicateObjectMap,
predicateObjectMapPredicate_predicateMap,
predicateObjectMapObject_predicateMap);
r2rml.add(predicateObjectMapStatement_predicateMap);
// 2) the statement for [#1] rr:objectMap [#3]
Property prediacteObjectMapPrediacte_objectMap =
ResourceFactory.createProperty(rrNamespace, "objectMap");
// [#3]
RDFNode prediacteObjectMapObject_objectMap = (RDFNode) objectMapStatements.get(0).getSubject();
Statement predicateObjectMapStatement_objectMap =
r2rml.createStatement(
triplesMapObject_predicateObjectMap,
prediacteObjectMapPrediacte_objectMap,
prediacteObjectMapObject_objectMap);
r2rml.add(predicateObjectMapStatement_objectMap);
// 3) the statement for <#TriplesMap2> rr:prediacteObjectMap [#1]
Property triplesMapPredicate_predicateObjectMap =
ResourceFactory.createProperty(rrNamespace, "predicateObjectMap");
Statement triplesMapStatement_predicateObjectMap =
r2rml.createStatement(
triplesMapSubject,
triplesMapPredicate_predicateObjectMap,
triplesMapObject_predicateObjectMap);
r2rml.add(triplesMapStatement_predicateObjectMap);
}
