public static String RenderTemplatePage(Bindings b, String templateName) throws IOException {
MediaType mt = MediaType.TEXT_HTML;
Resource config = model.createResource("eh:/root");
Mode prefixMode = Mode.PreferPrefixes;
ShortnameService sns = new StandardShortnameService();
List<Resource> noResults = CollectionUtils.list(root.inModel(model));
Graph resultGraph = graphModel.getGraph();
resultGraph.getPrefixMapping().setNsPrefix("api", API.NS);
resultGraph.add(Triple.create(root.asNode(), API.items.asNode(), RDF.nil.asNode()));
APIResultSet rs = new APIResultSet(resultGraph, noResults, true, true, "details", View.ALL);
VelocityRenderer vr = new VelocityRenderer(mt, null, config, prefixMode, sns);
VelocityRendering vx = new VelocityRendering(b, rs, vr);
VelocityEngine ve = vx.createVelocityEngine();
VelocityContext vc = vx.createVelocityContext(b);
ByteArrayOutputStream bos = new ByteArrayOutputStream();
Writer w = new OutputStreamWriter(bos, "UTF-8");
Template t = ve.getTemplate(templateName);
t.merge(vc, w);
w.close();
return bos.toString();
}
/**
* Query SPARQL endpoint with a SELECT query
*
* @param qExec QueryExecution encapsulating the query
* @return model retrieved by querying the endpoint
*/
private Model getSelectModel(QueryExecution qExec) {
Model model = ModelFactory.createDefaultModel();
Graph graph = model.getGraph();
ResultSet results = qExec.execSelect();
while (results.hasNext()) {
QuerySolution sol = results.next();
String subject;
String predicate;
RDFNode object;
try {
subject = sol.getResource("s").toString();
predicate = sol.getResource("p").toString();
object = sol.get("o");
} catch (NoSuchElementException e) {
logger.error("SELECT query does not return a (?s ?p ?o) Triple");
continue;
}
Node objNode;
if (object.isLiteral()) {
Literal obj = object.asLiteral();
objNode = NodeFactory.createLiteral(obj.getString(), obj.getDatatype());
} else {
objNode = NodeFactory.createLiteral(object.toString());
}
graph.add(
new Triple(NodeFactory.createURI(subject), NodeFactory.createURI(predicate), objNode));
}
return model;
}
/**
* Returns a collection of RDFStatements that match the described subject
*
* @param subject Subject
* @return collection of RDFStatements
*/
public Collection<RDFStatement> getStatements(String subject) {
if (subject == null || subject.isEmpty()) {
return null;
}
List<RDFStatement> statement = null;
try {
// define a describe query
String query = String.format("DESCRIBE %s FROM < %s >", subject, this.graphName);
logger.debug("Query: \n{}", query);
Query sparqlQuery = QueryFactory.create(query);
VirtuosoQueryExecution vqe = VirtuosoQueryExecutionFactory.create(sparqlQuery, this.graph);
// execute the query and get the graph
Model model = vqe.execDescribe();
Graph queriedGraph = model.getGraph();
// itreate over the retrieved triples, and place them inside a list
ExtendedIterator<Triple> iter = queriedGraph.find(Node.ANY, Node.ANY, Node.ANY);
statement = new ArrayList<>();
while (iter.hasNext()) {
Triple t = (Triple) iter.next();
RDFStatement stmt =
new RDFStatement(
t.getSubject().toString(), t.getPredicate().toString(), t.getObject().toString());
statement.add(stmt);
}
} catch (Exception ex) {
logger.error("Exception occured while querying for statements", ex);
}
return statement;
}
@Override
public void add(Triple[] arg0) {
Graph g = GraphFactory.createPlainGraph();
for (int i = 0; i < arg0.length; i++) {
g.add(arg0[i]);
}
add(g);
}
@Override
public void add(List<Triple> arg0) {
Graph g = GraphFactory.createPlainGraph();
for (Triple t : arg0) {
g.add(t);
}
add(g);
}
/**
* @param mGraph
* @return
*/
protected static Graph getHiddenTriples(Model m) {
Graph mGraph = m.getGraph();
final Reifier r = mGraph.getReifier();
return new GraphBase() {
public ExtendedIterator graphBaseFind(TripleMatch m) {
return r.findEither(m, true);
}
};
}
@Override
public boolean contains(Node g, Node s, Node p, Node o) {
Graph graph = getGraph(g);
if (graph != null) {
return graph.contains(s, p, o);
} else {
return false;
}
}
/**
* Extended find interface used in situations where the implementator may or may not be able to
* answer the complete query. It will attempt to answer the pattern but if its answers are not
* known to be complete then it will also pass the request on to the nested Finder to append more
* results.
*
* @param pattern a TriplePattern to be matched against the data
* @param continuation either a Finder or a normal Graph which will be asked for additional match
* results if the implementor may not have completely satisfied the query.
*/
@Override
public ExtendedIterator<Triple> findWithContinuation(TriplePattern pattern, Finder continuation) {
if (graph == null) return new NullIterator<Triple>();
if (continuation == null) {
return graph.find(pattern.asTripleMatch());
} else {
return graph.find(pattern.asTripleMatch()).andThen(continuation.find(pattern));
}
}
@Override
public void add(Iterator<Triple> arg0) {
Graph g = GraphFactory.createPlainGraph();
while (arg0.hasNext()) {
Triple t = arg0.next();
g.add(t);
}
add(g);
}
@Override
public void add(Quad quad) {
Graph graph;
if (quad.isDefaultGraph()) {
graph = getDefaultGraph();
} else {
graph = getGraph(quad.getGraph());
}
if (graph != null) {
graph.add(quad.asTriple());
}
}
public static void removeAll(Graph g, Node s, Node p, Node o) {
ExtendedIterator<Triple> it = g.find(s, p, o);
try {
while (it.hasNext()) {
Triple t = it.next();
g.delete(t);
it.remove();
}
} finally {
it.close();
}
}
/** Removes the triple t (if possible) from the set belonging to this graph. */
@Override
public void performDelete(Triple t) {
version++;
if (fdata != null) {
Graph data = fdata.getGraph();
if (data != null) {
data.delete(t);
}
}
if (!this.isPrepared()) {
fdeductions.getGraph().delete(t);
}
}
/**
* Adds a set of precomputed triples to the deductions store. These do not, themselves, fire any
* rules but provide additional axioms that might enable future rule firing when real data is
* added. Used to implement bindSchema processing in the parent Reasoner.
*
* @return return true if the rule set has also been loaded
*/
protected boolean preloadDeductions(Graph preloadIn) {
Graph d = fdeductions.getGraph();
BasicForwardRuleInfGraph preload = (BasicForwardRuleInfGraph) preloadIn;
// If the rule set is the same we can reuse those as well
if (preload.rules == rules) {
// Load raw deductions
for (Iterator<Triple> i = preload.find(null, null, null); i.hasNext(); ) {
d.add(i.next());
}
engine.setRuleStore(preload.engine.getRuleStore());
return true;
} else {
return false;
}
}
public OntModel applyRenamings() {
OntModel result = ModelFactory.createMem();
Graph graph = result.getGraph();
Iterator it = model.getGraph().find(Triple.ANY);
while (it.hasNext()) {
Triple t = (Triple) it.next();
Node s = t.getSubject().isURI() ? rename(t.getSubject()) : null;
Node o = t.getObject().isURI() ? rename(t.getObject()) : null;
if (s != null || o != null)
t =
Triple.create(
s != null ? s : t.getSubject(), t.getPredicate(), o != null ? o : t.getObject());
graph.add(t);
}
return result;
}
private void addStages(ArrayList<Stage> stages, NamedGraphMap arguments, Mapping map) {
Iterator<Map.Entry<String, Cons>> it2 = triples.entrySetIterator();
while (it2.hasNext()) {
Map.Entry<String, Cons> e = it2.next();
String name = e.getKey();
Cons nodeTriples = e.getValue();
Graph g = arguments.get(name);
int nBlocks = Cons.size(nodeTriples), i = nBlocks;
Triple[] nodes = new Triple[nBlocks];
while (nodeTriples != null) {
nodes[--i] = nodeTriples.head;
nodeTriples = nodeTriples.tail;
}
nodes = sortTriples(nodes);
Stage next = g.queryHandler().patternStage(map, constraint, nodes);
stages.add(next);
}
}
@Override
public void addGraph(Node gn, Graph g) {
// Convert to quads.
// super.addGraph(gn, g) ;
ExtendedIterator<Triple> iter = g.find(Node.ANY, Node.ANY, Node.ANY);
for (; iter.hasNext(); ) {
Triple t = iter.next();
add(gn, t.getSubject(), t.getPredicate(), t.getObject());
}
}
public static boolean isContainer(Graph graph, Node container, Node containerType) {
// if ( container.isLiteral() )
// return false ;
if (containerType == null)
return isContainer(graph, container, BAG)
|| isContainer(graph, container, ALT)
|| isContainer(graph, container, SEQ);
return graph.contains(container, RDFtype, containerType);
}
/**
* Create the graph used to hold the deductions. Can be overridden by subclasses that need special
* purpose graph implementations here. Assumes the graph underlying fdeductions and associated
* SafeGraph wrapper can be reused if present thus enabling preservation of listeners.
*/
protected Graph createDeductionsGraph() {
if (fdeductions != null) {
Graph dg = fdeductions.getGraph();
if (dg != null) {
// Reuse the old graph in order to preserve any listeners
safeDeductions.getBulkUpdateHandler().removeAll();
return dg;
}
}
Graph dg = Factory.createGraphMem(style);
safeDeductions = new SafeGraph(dg);
return dg;
}
/**
* Create the graph used to hold the deductions. Can be overridden by subclasses that need special
* purpose graph implementations here. Assumes the graph underlying fdeductions and associated
* SafeGraph wrapper can be reused if present thus enabling preservation of listeners.
*/
protected Graph createDeductionsGraph() {
if (fdeductions != null) {
Graph dg = fdeductions.getGraph();
if (dg != null) {
// Reuse the old graph in order to preserve any listeners
safeDeductions.clear();
return dg;
}
}
Graph dg = Factory.createGraphMem();
safeDeductions = new SafeGraph(dg);
return dg;
}
/**
* Create an instance of the SecuredGraph
*
* @param securityEvaluator The security evaluator to use
* @param graphIRI The IRI for the graph.
* @param graph The graph that we are wrapping.
* @return the secured graph
*/
public static SecuredGraph getInstance(
final SecurityEvaluator securityEvaluator, final String graphIRI, final Graph graph) {
final ItemHolder<Graph, SecuredGraphImpl> holder =
new ItemHolder<Graph, SecuredGraphImpl>(graph);
final SecuredGraphImpl checker = new SecuredGraphImpl(securityEvaluator, graphIRI, holder) {};
// If we going to create a duplicate proxy return this one.
if (graph instanceof SecuredGraphImpl) {
if (checker.isEquivalent((SecuredGraphImpl) graph)) {
return (SecuredGraph) graph;
}
}
return holder.setSecuredItem(new SecuredItemInvoker(graph.getClass(), checker));
}
public static void removeAll(Graph g) {
ExtendedIterator<Triple> it = GraphUtil.findAll(g);
try {
while (it.hasNext()) {
Triple t = it.next();
g.delete(t);
it.remove();
}
} finally {
it.close();
}
// get rid of remaining blank nodes using a SPARQL DELETE
if (g instanceof SparqlGraph) {
((SparqlGraph) g).removeAll();
}
}
public static Collection<Node> containerMembers(Graph graph, Node container, Node containerType) {
if (!isContainer(graph, container, containerType)) return null;
ExtendedIterator<Triple> iter = graph.find(container, Node.ANY, Node.ANY);
SortedMap<Integer, Node> triples = new TreeMap<Integer, Node>(order);
try {
for (; iter.hasNext(); ) {
Triple t = iter.next();
int index = getIndex(t);
if (index == NOT_FOUND) continue;
// Insert
triples.put(new Integer(index), t.getObject());
}
} finally {
iter.close();
}
return triples.values();
}
@Override
public void delete(Graph g) {
Model[] model = separateStatementsWithBlankNodes(g);
deleteModel(model[1] /*statements without blank nodes*/);
// replace blank nodes in remaining statements with variables
StringBuffer patternBuff = new StringBuffer();
Iterator<Triple> tripIt = g.find(null, null, null);
while (tripIt.hasNext()) {
Triple t = tripIt.next();
patternBuff.append(SparqlGraph.sparqlNodeDelete(t.getSubject(), null));
patternBuff.append(" ");
patternBuff.append(SparqlGraph.sparqlNodeDelete(t.getPredicate(), null));
patternBuff.append(" ");
patternBuff.append(SparqlGraph.sparqlNodeDelete(t.getObject(), null));
patternBuff.append(" .\n");
}
StringBuffer queryBuff = new StringBuffer();
String graphURI = graph.getGraphURI();
queryBuff.append(
"DELETE { " + ((graphURI != null) ? "GRAPH <" + graphURI + "> { " : "") + " \n");
queryBuff.append(patternBuff);
if (graphURI != null) {
queryBuff.append(" } \n");
}
queryBuff.append("} WHERE { \n");
if (graphURI != null) {
queryBuff.append(" GRAPH <" + graphURI + "> { \n");
}
queryBuff.append(patternBuff);
if (graphURI != null) {
queryBuff.append(" } \n");
}
queryBuff.append("} \n");
log.debug(queryBuff.toString());
graph.executeUpdate(queryBuff.toString());
}
private static int countContainerMember(
Graph graph, Node container, Node containerType, Node member, boolean stopEarly) {
if (graph == null) {
Log.warn(GraphContainerUtils.class, "containerMember called with null graph");
return 0;
}
if (container == null) {
Log.warn(GraphContainerUtils.class, "containerMember called with null list");
return 0;
}
if (member == null) {
Log.warn(GraphContainerUtils.class, "containerMember called with null member");
return 0;
}
if (!isContainer(graph, container, containerType)) return 0;
int count = 0;
ExtendedIterator<Triple> iter = graph.find(container, Node.ANY, member);
try {
for (; iter.hasNext(); ) {
Triple t = iter.next();
Node p = t.getPredicate();
String u = p.getURI();
if (u.matches(membershipPattern)) {
count++;
if (stopEarly) return count;
}
}
} finally {
iter.close();
}
return count;
}
/**
* this is a simple-minded implementation of containsNode that uses find up to three times to
* locate the node. Almost certainly particular graphs will be able to offer better query-handlers
* ...
*/
public boolean containsNode(Node n) {
return graph.contains(n, Node.ANY, Node.ANY)
|| graph.contains(Node.ANY, n, Node.ANY)
|| graph.contains(Node.ANY, Node.ANY, n);
}
/** Return true if the given pattern occurs somewhere in the find sequence. */
@Override
public boolean contains(TriplePattern pattern) {
return graph.contains(pattern.getSubject(), pattern.getPredicate(), pattern.getObject());
}
/**
* Basic pattern lookup interface.
*
* @param pattern a TriplePattern to be matched against the data
* @return a ClosableIterator over all Triples in the data set that match the pattern
*/
@Override
public ExtendedIterator<Triple> find(TriplePattern pattern) {
if (graph == null) return new NullIterator<Triple>();
return graph.find(pattern.asTripleMatch());
}
/** Return true iff the node can be converted to an instance of this class (Thing) */
public boolean canWrap(Node n, EnhGraph eg) {
Profile profile;
if (eg instanceof OntModel) profile = ((OntModel) eg).getProfile();
else return false;
if (!profile.isSupported(n, eg, Individual.class)) {
return false;
}
Graph graph = eg.asGraph();
return graph.contains(
n,
com.hp.hpl.jena.vocabulary.RDF.type.asNode(),
eu.lod2.nlp2rdf.schema.tools.Vocabulary.Thing.asNode())
|| graph.contains(
n,
com.hp.hpl.jena.vocabulary.RDF.type.asNode(),
eu.lod2.nlp2rdf.schema.tools.Vocabulary.String.asNode())
|| graph.contains(
n,
com.hp.hpl.jena.vocabulary.RDF.type.asNode(),
eu.lod2.nlp2rdf.schema.tools.Vocabulary.Phrase.asNode())
|| graph.contains(
n,
com.hp.hpl.jena.vocabulary.RDF.type.asNode(),
eu.lod2.nlp2rdf.schema.tools.Vocabulary.Word.asNode())
|| graph.contains(
n,
com.hp.hpl.jena.vocabulary.RDF.type.asNode(),
eu.lod2.nlp2rdf.schema.tools.Vocabulary.StopWord.asNode())
|| graph.contains(
n,
com.hp.hpl.jena.vocabulary.RDF.type.asNode(),
eu.lod2.nlp2rdf.schema.tools.Vocabulary.Sentence.asNode())
|| graph.contains(
n,
com.hp.hpl.jena.vocabulary.RDF.type.asNode(),
eu.lod2.nlp2rdf.schema.tools.Vocabulary.OffsetBasedString.asNode())
|| graph.contains(
n,
com.hp.hpl.jena.vocabulary.RDF.type.asNode(),
eu.lod2.nlp2rdf.schema.tools.Vocabulary.ContextHashBasedString.asNode())
|| graph.contains(
n,
com.hp.hpl.jena.vocabulary.RDF.type.asNode(),
eu.lod2.nlp2rdf.schema.tools.Vocabulary.Document.asNode())
|| graph.contains(
n,
com.hp.hpl.jena.vocabulary.RDF.type.asNode(),
eu.lod2.nlp2rdf.schema.tools.Vocabulary.Topic.asNode())
|| graph.contains(
n,
com.hp.hpl.jena.vocabulary.RDF.type.asNode(),
eu.lod2.nlp2rdf.schema.tools.Vocabulary.Error.asNode());
}
public static ExtendedIterator subjectsFor(Graph g, Node p, Node o) {
Set objects = CollectionFactory.createHashedSet();
ClosableIterator it = g.find(Node.ANY, p, o);
while (it.hasNext()) objects.add(((Triple) it.next()).getSubject());
return WrappedIterator.createNoRemove(objects.iterator());
}
public static ExtendedIterator predicatesFor(Graph g, Node s, Node o) {
Set predicates = CollectionFactory.createHashedSet();
ClosableIterator it = g.find(s, Node.ANY, o);
while (it.hasNext()) predicates.add(((Triple) it.next()).getPredicate());
return WrappedIterator.createNoRemove(predicates.iterator());
}