protected DataPropertyStatement fillDataPropertyStatementWithJenaLiteral( DataPropertyStatement dataPropertyStatement, Literal l) { dataPropertyStatement.setData(l.getLexicalForm()); dataPropertyStatement.setDatatypeURI(l.getDatatypeURI()); dataPropertyStatement.setLanguage(l.getLanguage()); return dataPropertyStatement; }
public static Method create(QuerySolution qs) throws Exception { Resource id = (Resource) qs.get("x"); Literal fullPath = (Literal) qs.get("fullPath"); Literal name = (Literal) qs.get("name"); Literal accessModifier = (Literal) qs.get("accessModifier"); Literal lineStart = (Literal) qs.get("line_start"); Literal lineEnd = (Literal) qs.get("line_end"); Resource returnType = (Resource) qs.get("returnType"); Resource hasParameter = (Resource) qs.get("hasParameter"); Resource throwsException = (Resource) qs.get("throwsException"); Resource belongsTo = (Resource) qs.get("belongsTo"); Method meth = new Method(id.toString(), name.getValue().toString()); meth.setAccessModifier(accessModifier.getValue().toString()); meth.setFullPath(fullPath.getValue().toString()); meth.setLineStart(lineStart.getInt()); meth.setLineEnd(lineEnd.getInt()); meth.setReturnType(returnType.toString()); if (hasParameter != null) { meth.setHasParameter(hasParameter.toString()); } if (throwsException != null) { meth.setThrowsException(throwsException.toString()); } meth.setBelongsTo(belongsTo.toString()); return meth; }
/** * 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; }
/** * Converts a JENA API Literal object into an OWL API OWLLiteral object. * * @param lit * @return */ protected OWLLiteral convertLiteral(Literal lit) { String datatypeURI = lit.getDatatypeURI(); OWLLiteral owlLiteral; if (datatypeURI == null) { // rdf:PlainLiteral owlLiteral = df.getOWLLiteral(lit.getLexicalForm(), lit.getLanguage()); } else { owlLiteral = df.getOWLLiteral(lit.getLexicalForm(), df.getOWLDatatype(IRI.create(datatypeURI))); } return owlLiteral; }
private URL getURL(Literal literalURL) { URL url = null; try { url = new URL(literalURL.getString()); } catch (Exception e) { e.printStackTrace(); } return url; }
public int[] getSourceColumns(Resource resource) { if (_model.contains(resource, Vertere.source_column)) { Statement sourceColumn = _model.getProperty(resource, Vertere.source_column); return new int[] {sourceColumn.getInt()}; } else if (_model.contains(resource, Vertere.source_columns)) { Statement sourceColumns = _model.getProperty(resource, Vertere.source_columns); Resource listResource = sourceColumns.getResource(); RDFList list = listResource.as(RDFList.class); List<RDFNode> javalist = list.asJavaList(); int[] sourceColumnNumbers = new int[javalist.size()]; for (int i = 0; i < javalist.size(); i++) { RDFNode node = javalist.get(i); Literal value = node.asLiteral(); sourceColumnNumbers[i] = value.getInt(); } return sourceColumnNumbers; } else { return new int[0]; } }
@Test public void shouldSortTriplesForDisplay() { final Model model = createDefaultModel(); model.setNsPrefix("prefix", "namespace"); final Property propertyA = model.createProperty("namespace", "a"); final Property propertyB = model.createProperty("namespace", "b"); final Property propertyC = model.createProperty("c"); final Literal literalA = model.createLiteral("a"); final Literal literalB = model.createLiteral("b"); final Resource resourceB = model.createResource("b"); model.add(resourceB, propertyA, literalA); final Resource a = model.createResource("a"); model.add(a, propertyC, literalA); model.add(a, propertyB, literalA); model.add(a, propertyA, literalA); model.add(a, propertyA, literalB); final Iterator<Quad> iterator = DatasetFactory.create(model).asDatasetGraph().find(); final List<Quad> sortedTriples = testObj.getSortedTriples(model, iterator); sortedTriples.get(0).matches(ANY, a.asNode(), propertyA.asNode(), literalA.asNode()); sortedTriples.get(1).matches(ANY, a.asNode(), propertyA.asNode(), literalB.asNode()); sortedTriples.get(2).matches(ANY, a.asNode(), propertyB.asNode(), literalA.asNode()); sortedTriples.get(3).matches(ANY, a.asNode(), propertyC.asNode(), literalA.asNode()); sortedTriples.get(4).matches(ANY, resourceB.asNode(), propertyC.asNode(), literalA.asNode()); }
private boolean checkAlreadyAgreed() { // System.err.println(license); if (license.exists() && user != null && !user.equals("")) { try { model.read(new FileInputStream(license), null); QueryExecution qexec = QueryExecutionFactory.create(queryString, model); try { ResultSet results = qexec.execSelect(); while (results.hasNext()) { QuerySolution soln = results.nextSolution(); try { Literal u = soln.getLiteral("user"); // System.err.println("user: "******"software"); // System.err.println("software: "+s); Calendar d = ((XSDDateTime) soln.getLiteral("date").getValue()).asCalendar(); // System.err.println("date: "+d); if (u.getString().equals(user) && s.getString().equals(software) && d.before(Calendar.getInstance())) { return true; } } catch (JenaException e) { // ignore } catch (ClassCastException e) { System.err.println(e.getMessage()); } } } finally { qexec.close(); } } catch (FileNotFoundException e) { } } return false; }
public void doCleanLiterals(Model model) { Model retractionsModel = ModelFactory.createDefaultModel(); Model additionsModel = ModelFactory.createDefaultModel(); model.enterCriticalSection(Lock.WRITE); try { ClosableIterator<Statement> closeIt = model.listStatements(); try { for (Iterator<Statement> stmtIt = closeIt; stmtIt.hasNext(); ) { Statement stmt = stmtIt.next(); if (stmt.getObject().isLiteral()) { Literal lit = (Literal) stmt.getObject(); String lex = lit.getLexicalForm(); char[] chars = lex.toCharArray(); char[] cleanChars = new char[chars.length]; int cleanPos = 0; boolean badChar = false; for (int i = 0; i < chars.length; i++) { if (java.lang.Character.getNumericValue(chars[i]) > 31 && java.lang.Character.isDefined(chars[i])) { cleanChars[cleanPos] = chars[i]; cleanPos++; } else { log.error("Bad char in " + lex); log.error("Numeric value " + java.lang.Character.getNumericValue(chars[i])); badChar = true; } } String cleanLex = new String(cleanChars); if (badChar) { retractionsModel.add(stmt); Literal newLit = null; if (lit.getLanguage() != null && lit.getLanguage().length() > 0) { newLit = additionsModel.createLiteral(cleanLex, lit.getLanguage()); } else if (lit.getDatatype() != null) { newLit = additionsModel.createTypedLiteral(cleanLex, lit.getDatatype()); } else { newLit = additionsModel.createLiteral(cleanLex); } additionsModel.add(stmt.getSubject(), stmt.getPredicate(), newLit); } } } } finally { closeIt.close(); } model.remove(retractionsModel); model.add(additionsModel); log.debug("Cleaned " + additionsModel.size() + " literals"); } finally { model.leaveCriticalSection(); } }
public void teste() { // String name = this.getName(); String title = ""; String service = "http://dblp.rkbexplorer.com/sparql"; String query = "PREFIX akt: <http://www.aktors.org/ontology/portal#> " + "PREFIX akt: <http://www.aktors.org/ontology/portal#> " + " SELECT DISTINCT ?name ?title " + " WHERE " + " { " + " ?auth akt:full-name " + "\"" + nameAuthorField + "\"" + " . " + " ?pub a akt:Publication-Reference ;" + " akt:has-title ?title ;" + " akt:has-author ?auth ." + " } "; QueryExecution queryExecution = QueryExecutionFactory.sparqlService(service, query); try { ResultSet results = queryExecution.execSelect(); while (results.hasNext()) { QuerySolution querySolution = results.nextSolution(); // consume title Literal literal = querySolution.getLiteral("title"); title = ("" + literal.getValue()); // add titulo a lista tituloPublicacao this.tituloPublicacao.add(title); } } catch (QueryExceptionHTTP e) { System.out.println(service + " is DOWN"); } finally { queryExecution.close(); } }
@Test public void testInfoStamp() { String versionString = "E3.14159", commentString = "gloopSmurfale"; String resourceString = "_x eye:assumed 'ABC'; _x eye:checked 'DEF'; _x eye:version '%v'; _x eye:comment '%c'" .replaceAll("%v", versionString) .replaceAll("%c", commentString); InfoStamp i = new InfoStamp(resourceInModel(resourceString)); Calendar now = Calendar.getInstance(); Resource root = i.stamp(now); Model stamp = root.getModel(); Literal dateLiteral = ModelFactory.createDefaultModel().createTypedLiteral(now); String dateString = "'" + dateLiteral.getLexicalForm() + "'" + dateLiteral.getDatatypeURI(); String expectedFormat = "[eye:assumed 'ABC' & eye:checked 'DEF' & eye:dated <date>" + " & eye:comment '<comment>' & eye:version '<version>']"; String expectedString = expectedFormat .replaceAll("<date>", dateString) .replaceAll("<version>", versionString) .replaceAll("<comment>", commentString); Model expected = model(expectedString); assertIsoModels(expected, stamp); }
/** * Create a JCR value from an RDF node with the given JCR type * * @param valueFactory * @param data * @param type * @return * @throws RepositoryException */ public Value createValue(final ValueFactory valueFactory, final RDFNode data, final int type) throws RepositoryException { assert (valueFactory != null); if (data.isURIResource() && (type == REFERENCE || type == WEAKREFERENCE)) { // reference to another node (by path) final Node nodeFromGraphSubject = session.getNode(graphSubjects.getPathFromSubject(data.asResource())); return valueFactory.createValue(nodeFromGraphSubject, type == WEAKREFERENCE); } else if (data.isURIResource() || type == URI) { // some random opaque URI return valueFactory.createValue(data.toString(), PropertyType.URI); } else if (data.isResource()) { // a non-URI resource (e.g. a blank node) return valueFactory.createValue(data.toString(), UNDEFINED); } else if (data.isLiteral() && type == UNDEFINED) { // the JCR schema doesn't know what this should be; so introspect // the RDF and try to figure it out final Literal literal = data.asLiteral(); final RDFDatatype dataType = literal.getDatatype(); final Object rdfValue = literal.getValue(); if (rdfValue instanceof Boolean) { return valueFactory.createValue((Boolean) rdfValue); } else if (rdfValue instanceof Byte || (dataType != null && dataType.getJavaClass() == Byte.class)) { return valueFactory.createValue(literal.getByte()); } else if (rdfValue instanceof Double) { return valueFactory.createValue((Double) rdfValue); } else if (rdfValue instanceof Float) { return valueFactory.createValue((Float) rdfValue); } else if (rdfValue instanceof Long || (dataType != null && dataType.getJavaClass() == Long.class)) { return valueFactory.createValue(literal.getLong()); } else if (rdfValue instanceof Short || (dataType != null && dataType.getJavaClass() == Short.class)) { return valueFactory.createValue(literal.getShort()); } else if (rdfValue instanceof Integer) { return valueFactory.createValue((Integer) rdfValue); } else if (rdfValue instanceof XSDDateTime) { return valueFactory.createValue(((XSDDateTime) rdfValue).asCalendar()); } else { return valueFactory.createValue(literal.getString(), STRING); } } else { LOGGER.debug("Using default JCR value creation for RDF literal: {}", data); return valueFactory.createValue(data.asLiteral().getString(), type); } }
public String toString() { return literal.getString(); }
@Override public Model open(Assembler a, Resource root, Mode mode) { Resource rootModel = getUniqueResource(root, BASE_MODEL); if (rootModel == null) { throw new AssemblerException(root, String.format(NO_X_PROVIDED, BASE_MODEL, root)); } Model baseModel = a.openModel(rootModel, mode); Literal modelName = getUniqueLiteral(root, JA.modelName); if (modelName == null) { throw new AssemblerException(root, String.format(NO_X_PROVIDED, JA.modelName, root)); } Literal factoryName = getUniqueLiteral(root, EVALUATOR_FACTORY); if (factoryName == null) { throw new AssemblerException(root, String.format(NO_X_PROVIDED, EVALUATOR_FACTORY, root)); } SecurityEvaluator securityEvaluator = null; try { Class<?> factoryClass = Class.forName(factoryName.getString()); Method method = factoryClass.getMethod("getInstance"); if (!SecurityEvaluator.class.isAssignableFrom(method.getReturnType())) { throw new AssemblerException( root, String.format( "%s (found at %s for %s) getInstance() must return an instance of SecurityEvaluator", factoryName, EVALUATOR_FACTORY, root)); } if (!Modifier.isStatic(method.getModifiers())) { throw new AssemblerException( root, String.format( "%s (found at %s for %s) getInstance() must be a static method", factoryName, EVALUATOR_FACTORY, root)); } securityEvaluator = (SecurityEvaluator) method.invoke(null); } catch (SecurityException e) { throw new AssemblerException( root, String.format(ERROR_FINDING_FACTORY, factoryName, e.getMessage()), e); } catch (IllegalArgumentException e) { throw new AssemblerException( root, String.format(ERROR_FINDING_FACTORY, factoryName, e.getMessage()), e); } catch (ClassNotFoundException e) { throw new AssemblerException( root, String.format( "Class %s (found at %s for %s) could not be loaded", factoryName, EVALUATOR_FACTORY, root)); } catch (NoSuchMethodException e) { throw new AssemblerException( root, String.format( "%s (found at %s for %s) must implement a static getInstance() that returns an instance of SecurityEvaluator", factoryName, EVALUATOR_FACTORY, root)); } catch (IllegalAccessException e) { throw new AssemblerException( root, String.format(ERROR_FINDING_FACTORY, factoryName, e.getMessage()), e); } catch (InvocationTargetException e) { throw new AssemblerException( root, String.format(ERROR_FINDING_FACTORY, factoryName, e.getMessage()), e); } return Factory.getInstance(securityEvaluator, modelName.asLiteral().getString(), baseModel); }
/** * Test that two literals are semantically equivalent. In some cases this may be the sames as * equals, in others equals is stricter. For example, two xsd:int literals with the same value but * different language tag are semantically equivalent but distinguished by the java equality * function in order to support round tripping. */ public boolean sameValueAs(Literal other) { return asNode().sameValueAs(other.asNode()); }
private static void doLang(StringBuffer json, Literal literal) { String language = literal.getLanguage(); if (!language.equals("")) { json.append(", \"xml:lang\": \"" + language + "\""); } }
private static void doDatatype(StringBuffer json, Literal literal) { String datatype = literal.getDatatypeURI(); if (datatype != null) { json.append(", \"datatype\": \"" + datatype + "\""); } }
public void doProcessStrings(VitroRequest vreq) { try { String className = vreq.getParameter("className"); String methodName = vreq.getParameter("methodName"); String propertyName = vreq.getParameter("propertyName"); String newPropertyName = vreq.getParameter("newPropertyName"); // for now, we'll make the destination and source models the same Model destination = getModel(vreq.getParameter("destinationModelName"), vreq); String processModel = vreq.getParameter("processModel"); Model savedAdditionsModel = null; Model savedRetractionsModel = null; String additionsModelStr = vreq.getParameter("additionsModel"); if ((additionsModelStr != null) && (additionsModelStr.length() > 0)) { savedAdditionsModel = getModel(additionsModelStr, vreq); } String retractionsModelStr = vreq.getParameter("retractionsModel"); if ((retractionsModelStr != null) && (retractionsModelStr.length() > 0)) { savedRetractionsModel = getModel(retractionsModelStr, vreq); } Model additionsModel = ModelFactory.createDefaultModel(); Model retractionsModel = ModelFactory.createDefaultModel(); Class<?> stringProcessorClass = Class.forName(className); Object processor = stringProcessorClass.newInstance(); Class<?>[] methArgs = {String.class}; Method meth = stringProcessorClass.getMethod(methodName, methArgs); Property prop = ResourceFactory.createProperty(propertyName); Property newProp = ResourceFactory.createProperty(newPropertyName); destination.enterCriticalSection(Lock.READ); try { ClosableIterator<Statement> closeIt = destination.listStatements((Resource) null, prop, (RDFNode) null); for (Iterator<Statement> stmtIt = closeIt; stmtIt.hasNext(); ) { Statement stmt = stmtIt.next(); if (stmt.getObject().isLiteral()) { Literal lit = (Literal) stmt.getObject(); String lex = lit.getLexicalForm(); Object[] args = {lex}; String newLex = ""; try { newLex = (String) meth.invoke(processor, args); } catch (InvocationTargetException e) { throw new RuntimeException(e); } if (!newLex.equals(lex)) { retractionsModel.add(stmt); if (newLex.length() > 0) { Literal newLit = null; if (lit.getLanguage() != null && lit.getLanguage().length() > 0) { newLit = additionsModel.createLiteral(newLex, lit.getLanguage()); } else if (lit.getDatatype() != null) { newLit = additionsModel.createTypedLiteral(newLex, lit.getDatatype()); } else { newLit = additionsModel.createLiteral(newLex); } additionsModel.add(stmt.getSubject(), newProp, newLit); } } } } if (processModel != null) { destination.add(additionsModel); destination.remove(retractionsModel); } if (savedAdditionsModel != null) { savedAdditionsModel.add(additionsModel); } if (savedRetractionsModel != null) { savedRetractionsModel.add(retractionsModel); } } finally { destination.leaveCriticalSection(); } } catch (Exception e) { throw new RuntimeException(e); } }
private void updateModel( HttpServletRequest req, HttpServletResponse resp, Property[] permissions, ModelUpdater modelUpdater) throws ServletException, IOException { Query query = getQuery(req, resp); ServletContext context = getServletContext(); if (query == null) return; if (performPermissionsCheck(context, query, resp, permissions)) return; String uri = query.getURI(); AbstractSerializer as = serializer.get(query.getContentType()); if (as == null || !(as instanceof JenaSerializer)) { resp.setStatus( query.negotiatedContentType() ? HttpServletResponse.SC_BAD_REQUEST : HttpServletResponse.SC_NOT_FOUND); return; } Model model = ModelFactory.createDefaultModel(); model.read(req.getInputStream(), query.getURI(), ((JenaSerializer) as).getSerialization()); Model target = dataset.getNamedModel(uri); Set<Statement> before = target.listStatements().toSet(); modelUpdater.updateModel(model, uri); Set<Statement> after = target.listStatements().toSet(); Set<Statement> intersection = new HashSet<Statement>(before); intersection.retainAll(after); before.removeAll(intersection); // All those removed after.removeAll(intersection); // All those added Model changesetModel = ModelFactory.createDefaultModel(); Resource changeset = changesetModel.createResource(); Literal date = changesetModel.createTypedLiteral( dateFormat.format(new Date()), new BaseDatatype(XSD.date.getURI())); changeset .addProperty(Namespaces.rdf.p("type"), CS.ChangeSet) .addProperty(Namespaces.dc.p("date"), date) .addProperty(CS.subjectOfChange, changesetModel.createResource(query.getURI())) .addProperty(DC.creator, query.getUser()); for (Statement statement : before) changeset.addProperty(Namespaces.cs.p("removal"), statement.createReifiedStatement()); for (Statement statement : after) changeset.addProperty(Namespaces.cs.p("addition"), statement.createReifiedStatement()); String filename = query.getURL().getPath() + "/" + date.getLexicalForm() + ".n3"; File file = new File(logDirectory, filename); file.getParentFile().mkdirs(); FileWriter ow = new FileWriter(new File(logDirectory.getPath(), filename)); changesetModel.write(ow, "N3"); ow.close(); resp.setStatus(200); }