/** * Returns the identifier of an LSRN-typed Resource * * @param lsrnNode * @return the identifier */ public static String getID(Resource lsrnNode) { Set<String> namespaces = new HashSet<String>(); for (Iterator<Resource> types = RdfUtils.getTypes(lsrnNode); types.hasNext(); ) { Resource type = types.next(); if (type.isURIResource()) { String ns = getNamespaceFromLSRNTypeURI(type.getURI()); if (ns != null) namespaces.add(ns); } } Iterator<Resource> ids = RdfUtils.getPropertyValues(lsrnNode, SIO.has_identifier, null) .andThen(RdfUtils.getPropertyValues(lsrnNode, SIO.has_attribute, null)); while (ids.hasNext()) { Resource identifier = ids.next(); for (Iterator<Resource> types = RdfUtils.getTypes(identifier); types.hasNext(); ) { Resource type = types.next(); if (type.isURIResource()) { String ns = getNamespaceFromLSRNIdentifierTypeURI(type.getURI()); if (ns != null && namespaces.contains(ns)) { Statement s = identifier.getProperty(SIO.has_value); if (s != null) { return s.getString(); } } } } } return null; }
private void updateAddRemoveDataGetterStatements( OntModel displayModel, Model removeStatements, Model addStatements, Resource oldType, Resource newType) { log.debug("Old type: " + oldType.getURI() + " - newType: " + newType.getURI()); removeStatements.add(displayModel.listStatements(null, RDF.type, oldType)); StmtIterator oldStatements = displayModel.listStatements(null, RDF.type, oldType); while (oldStatements.hasNext()) { Statement stmt = oldStatements.nextStatement(); addStatements.add(stmt.getSubject(), RDF.type, newType); } // Print out remove and add statements here StringWriter sw = new StringWriter(); try { log.debug( "Adding statements with old data getter types to remove statements, remove statements is now"); removeStatements.write(sw, "N3"); log.debug(sw.toString()); sw.close(); sw = new StringWriter(); log.debug( "Adding statements with new data getter types to add statements, add statements is now"); addStatements.write(sw, "N3"); log.debug(sw.toString()); sw.close(); } catch (Exception ex) { log.error("Error occurred in writing out remove and statements for data getter types", ex); } }
private List<OntClass> listNamedClasses() { List<OntClass> result = new ArrayList<OntClass>(); StmtIterator classes = model.listStatements(null, RDF.type, OWL.Class); while (classes.hasNext()) { Resource type = classes.next().getSubject(); String uri = type.getURI(); if (uri == null || manager.getDatatypeByUri(uri) != null) continue; if (!isStandard(uri)) { result.add(type.as(OntClass.class)); } } classes = model.listStatements(null, RDF.type, RDFS.Class); while (classes.hasNext()) { Resource type = classes.next().getSubject(); String uri = type.getURI(); if (uri == null || manager.getDatatypeByUri(uri) != null) continue; if (!isStandard(uri)) { result.add(type.as(OntClass.class)); } } List<Resource> rdfsClassList = model.listResourcesWithProperty(RDF.type, RDFS.Class).toList(); for (Resource r : rdfsClassList) { if (r.canAs(OntClass.class) && r.getURI() != null && !isStandard(r.getURI()) && manager.getDatatypeByUri(r.getURI()) == null) { result.add(r.as(OntClass.class)); } } return result; }
private Model execute(Model inputModel, String endpoint) { Model cube = createModel(); Resource dataset; Calendar calendar = Calendar.getInstance(TimeZone.getDefault()); dataset = cube.createResource( GK.uri + "Properties_per_Class" + calendar.getTimeInMillis(), QB.Dataset); dataset.addLiteral(RDFS.comment, "Properties per class"); dataset.addLiteral(DCTerms.date, cube.createTypedLiteral(calendar)); dataset.addLiteral(DCTerms.publisher, "R & D, Unister GmbH, Geoknow"); dataset.addProperty(QB.structure, cube.createResource(STRUCTURE)); QueryExecution qExec; if (inputModel != null) { qExec = QueryExecutionFactory.create(INSTANCES, inputModel); } else { qExec = QueryExecutionFactory.sparqlService(endpoint, INSTANCES, defaultGraphs, defaultGraphs); } ResultSet result = qExec.execSelect(); int i = 0; while (result.hasNext()) { Resource owlClass = result.next().getResource("class"); NUMBER_OF_PROPERTIES.setIri("class", owlClass.getURI()); QueryExecution propertiesQexec; if (inputModel != null) { propertiesQexec = QueryExecutionFactory.create(NUMBER_OF_PROPERTIES.asQuery(), inputModel); } else { propertiesQexec = QueryExecutionFactory.sparqlService( endpoint, NUMBER_OF_PROPERTIES.asQuery(), defaultGraphs, defaultGraphs); System.out.println(NUMBER_OF_PROPERTIES.asQuery()); } try { ResultSet propertiesResult = propertiesQexec.execSelect(); if (propertiesResult.hasNext()) { System.out.println(i); Resource obs = cube.createResource( "http://www.geoknow.eu/data-cube/metric2/observation" + i, QB.Observation); obs.addProperty(QB.dataset, dataset); obs.addProperty(GK.DIM.Class, owlClass); obs.addLiteral(GK.MEASURE.PropertyCount, propertiesResult.next().getLiteral("count")); i++; } } catch (Exception e) { System.out.println(i); Resource obs = cube.createResource( "http://www.geoknow.eu/data-cube/metric2/observation" + i, QB.Observation); obs.addProperty(QB.dataset, dataset); obs.addProperty(GK.DIM.Class, owlClass); obs.addLiteral(GK.MEASURE.PropertyCount, -1); obs.addLiteral(RDFS.comment, e.getMessage()); i++; } } return cube; }
/** @todo Add Documentation. */ @Override public boolean isFedoraGraphSubject(Resource subject) { checkArgument(subject != null, "null cannot be a Fedora object!"); assert (subject != null); return subject.isURIResource() && subject.getURI().startsWith("info:fedora/"); }
public void testCreateAnonResourceWithNull() { final Resource r = model.createResource((String) null); Assert.assertTrue(r.isAnon()); Assert.assertNull(r.getURI()); Assert.assertNull(r.getNameSpace()); Assert.assertNull(r.getLocalName()); }
public Resource getIdentity(Resource resource) { if (!_model.contains(resource, Vertere.identity)) { throw new RuntimeException( "Resource " + resource.getURI() + " does not contain an identity so cannot be created."); } return _model.getProperty(resource, Vertere.identity).getResource(); }
public List<ReMSerialisation> getReMSerialisations() throws OREException { try { List<ReMSerialisation> serialisations = new ArrayList<ReMSerialisation>(); StmtIterator itr = res.listProperties(ORE.isDescribedBy); while (itr.hasNext()) { Statement statement = itr.nextStatement(); Resource resource = (Resource) statement.getObject(); StmtIterator itr2 = resource.listProperties(DC.format); StmtIterator itr3 = resource.listProperties(OREX.isAuthoritativeFor); String mime = "application/octet-stream"; if (itr2.hasNext()) { Statement stmt = itr2.nextStatement(); mime = ((Literal) stmt.getObject()).getLexicalForm(); } boolean authoritative = false; if (itr3.hasNext()) { authoritative = true; } ReMSerialisation serialisation = new ReMSerialisation(mime, new URI(resource.getURI())); serialisation.setAuthoritative(authoritative); serialisations.add(serialisation); } return serialisations; } catch (URISyntaxException e) { throw new OREException(e); } }
private static Set<Property> getPermissions(String userPrefix, String username, String uri) { Set<Property> permissions = new HashSet<Property>(); Resource resource = configModel.createResource(uri); Resource user; if (username == null) user = PERM.Public; else user = configModel.createResource(userPrefix + username); StmtIterator stmts = configModel.listStatements(user, null, resource); while (stmts.hasNext()) permissions.add(stmts.next().getPredicate()); String queryString = ""; queryString += "PREFIX perm: <http://vocab.ox.ac.uk/perm#>\n"; queryString += "SELECT ?perm ?regex WHERE {\n"; queryString += " <" + user.getURI() + "> ?perm ?rm ."; queryString += " ?rm a perm:ResourceMatch ;"; queryString += " perm:matchExpression ?regex }"; com.hp.hpl.jena.query.Query query = QueryFactory.create(queryString); QueryExecution qexec = QueryExecutionFactory.create(query, configModel); ResultSet results = qexec.execSelect(); while (results.hasNext()) { QuerySolution sol = results.next(); if (uri.matches(((Literal) sol.get("regex")).getLexicalForm())) permissions.add(configModel.createProperty(((Resource) sol.get("perm")).getURI())); } if (username != null) permissions.addAll(getPermissions(userPrefix, null, uri)); return permissions; }
/** * Adds the LSRN SIO identifier structure to an LSRN-typed Resource. Attempts to use the URL of * the Resource to determine the ID. * * @param lsrnNode */ public static void addIdentifier(Resource lsrnNode) { if (lsrnNode.isURIResource()) { Matcher idMatcher = ID_PATTERN.matcher(lsrnNode.getURI()); if (idMatcher.find()) { String id = idMatcher.group(1); for (Resource type : RdfUtils.getTypes(lsrnNode).toList()) { if (!type.isURIResource()) continue; Matcher typeMatcher = TYPE_PATTERN.matcher(type.getURI()); if (typeMatcher.find()) { String idTypeURI = OUTPUT_ID_TYPE_PATTERN.replace("$NS", typeMatcher.group(1)); SIOUtils.createAttribute( lsrnNode, SIO.has_identifier, ResourceFactory.createResource(idTypeURI), id); } } } } }
public Property getRelationshipProperty(Resource relationship) { if (_model.contains(relationship, Vertere.property)) { Resource resource = _model.getProperty(relationship, Vertere.property).getResource(); return ResourceFactory.createProperty(resource.getURI()); } else { return null; } }
/** Adds a random Observable to any Activities that are missing Observables */ public void fillInObservables() { for (Resource r : process.getActivities()) { if (process.getObservables(r).size() < 1) { String obsUri = String.format("%1$s_OBSERVABLE", r.getURI()); addObservable(r, createObservable(obsUri)); } } }
private String printAsClass(VClassDao vcDao, Resource res) { String UNKNOWN = "???"; try { VClass vClass = vcDao.getVClassByURI(res.getURI()); return (vClass.getName() != null) ? vClass.getName() : UNKNOWN; } catch (Exception e) { return UNKNOWN; } }
/** * Returns the main rdf:type of the given Thing. * * @param t is thing object * @return URI reference of value for rdf:type property */ public static String getClosestRDFType(Thing t) { try { Class clazz = t.getClass(); Resource r = (Resource) clazz.getField("TYPE").get(t); return r.getURI(); } catch (Exception e) { throw new RuntimeException(e); } }
public RDFDatatype getDatatype(Resource attribute) { if (_model.contains(attribute, Vertere.datatype)) { Resource resource = _model.getProperty(attribute, Vertere.datatype).getResource(); RDFDatatype datatype = new BaseDatatype(resource.getURI()); return datatype; } else { return null; } }
protected void initPatternList(Resource lsrnIdentifierType) { List<Pattern> uriPatterns = new ArrayList<Pattern>(); // add default LSRN URI pattern String lsrnNamespace = getNamespaceFromLSRNIdentifierTypeURI(lsrnIdentifierType.getURI()); uriPatterns.add(Pattern.compile(String.format("http://lsrn\\.org/%s:(.+)", lsrnNamespace))); // add failsafe URI pattern (must always be last in list) uriPatterns.add(DEFAULT_FAILSAFE_URI_PATTERN); lsrnIdTypeToUriPattern.put(lsrnIdentifierType, uriPatterns); }
private boolean isAbstract(OntProperty p) { List<RDFNode> list = p.listPropertyValues(RDF.type).toList(); for (RDFNode node : list) { if (node.canAs(Resource.class)) { Resource r = node.asResource(); if (BindVocabulary.AbstractProperty.getURI().equals(r.getURI())) return true; } } return false; }
// add page list sparql query private void addPageListDisplayModel( OntModel displayModel, Model addStatements, Model removeStatements, UpdateSettings settings) { OntModel newDisplayModel = settings.getNewDisplayModelFromFile(); // Get all statements about pageListPage and pageListData Resource pageList = newDisplayModel.getResource(DisplayVocabulary.DISPLAY_NS + "pageListPage"); Resource pageListData = newDisplayModel.getResource(DisplayVocabulary.DISPLAY_NS + "pageListData"); addStatements.add(newDisplayModel.listStatements(pageList, null, (RDFNode) null)); addStatements.add(newDisplayModel.listStatements(pageListData, null, (RDFNode) null)); StringWriter sw = new StringWriter(); try { if (pageList != null) { log.debug("Page list uri is " + pageList.getURI()); } else { log.debug("Page list uri is null for some reason"); } log.debug("New Display model from file is "); newDisplayModel.write(sw, "N3"); log.debug(sw.toString()); sw.close(); sw = new StringWriter(); log.debug("Added statements now include "); addStatements.write(sw, "N3"); log.debug(sw.toString()); sw.close(); } catch (Exception ex) { log.error("Exception occurred in writing out new display model", ex); } log.debug("Checking: AFTER adding pageList resource, what do we have for pageList page"); Resource testResource = ResourceFactory.createResource(DisplayVocabulary.DISPLAY_NS + "pageListPage"); StmtIterator testIt = addStatements.listStatements(testResource, null, (RDFNode) null); if (!testIt.hasNext()) { log.debug( "Add statements does not have the page list page resource " + testResource.getURI()); } while (testIt.hasNext()) { log.debug("Statement for page list resource: " + testIt.nextStatement().toString()); } }
ProcessProfile(Resource device) { myARPReader.setProperty("WARN_RESOLVING_URI_AGAINST_EMPTY_BASE", "EM_IGNORE"); myARPReader.setErrorHandler( new RDFErrorHandler() { // ARP parser error handling routines public void warning(Exception e) { outputMsg("RDF parser warning:" + e.getMessage()); } public void error(Exception e) { outputMsg("RDF parser error:" + e.getMessage()); profileValidFlag = false; } public void fatalError(Exception e) { e.printStackTrace(); error(e); } }); this.deviceURI = device.getURI(); try { profile = UrlUtils.getURL(deviceURI).trim(); if (profile.contains("<html") || profile.contains("<head>")) { // this is HTML not a UAProf profile device.removeProperties(); } else if (!profile.contains("rdf") && !profile.contains("RDF")) { device.removeProperties(); } else if (!profile.contains("uaprof") && !profile.contains("UAPROF")) { device.removeProperties(); } else if (!profile.contains("openmobilealliance") && !profile.contains("wapforum")) { device.removeProperties(); } else { validate(device); profiles.fixMetadata(device, profile); } } catch (IOException io) { outputMsg("Could not retrieve " + device.getURI()); device.removeProperties(); unreachableProfiles++; } System.out.println(messages.toString()); }
/** * Implementación del servicio * * @param __inbean Parámetro de entrada al servicio: * @param __outbean Parámetro de salida del servicio: * @param context Objeto context necesario en el servicio * @throws Exception Excepción producida en la ejecución del servicio en la clase hija */ public void execute( CreateResource_req __inbean, CreateResource_resp __outbean, ServletContext context) throws Exception { // Get the Feed API QualiPSoFeedAPI model = AdvancedDocModel.getFeedAPI(context); // Invoke core API Resource newResource = model.createResource(__inbean.getResourceUri()); // Output __outbean.setResourceUri(newResource.getURI()); }
public static String algorithmResourceToString(Resource algorithmResource) throws InvalidSPDXAnalysisException { String uri = algorithmResource.getURI(); if (!algorithmResource.isURIResource()) { throw (new InvalidSPDXAnalysisException("Algorithm resource must be a URI")); } String retval = URI_TO_ALGORITHM.get(uri); if (retval == null) { throw (new InvalidSPDXAnalysisException("Invalid algorithm resource.")); } return retval; }
/** * Returns a Resource in the specified model that is an instance of the specified type with the * specified ID. The Resource will be created with an appropriate URI (@link {@link * #OUTPUT_URI_PATTERN}). * * @param model the model in which to create the new Resource * @param type the type (class) of the new instance * @param id the id of the new instance * @return a Resource view of the new instance */ public static Resource createInstance(Model model, Resource type, String id) { Matcher matcher = TYPE_PATTERN.matcher(type.getURI()); if (matcher.find()) { String namespace = matcher.group(1); String uri = getURI(namespace, id); Resource lsrnNode = model.createResource(uri, type); SIOUtils.createAttribute(lsrnNode, SIO.has_identifier, getIdentifierClass(namespace), id); return lsrnNode; } else { throw new IllegalArgumentException( "at present this method only works with LSRN database record classes"); } }
public List<URI> getRights() throws OREException { try { List<URI> rights = new ArrayList<URI>(); StmtIterator itr = res.listProperties(DC.rights); while (itr.hasNext()) { Statement statement = itr.nextStatement(); Resource right = (Resource) statement.getObject(); rights.add(new URI(right.getURI())); } return rights; } catch (URISyntaxException e) { throw new OREException(e); } }
public List<URI> getSimilarTo() throws OREException { try { List<URI> similars = new ArrayList<URI>(); StmtIterator itr = res.listProperties(ORE.similarTo); while (itr.hasNext()) { Statement statement = itr.nextStatement(); Resource node = (Resource) statement.getObject(); similars.add(new URI(node.getURI())); } return similars; } catch (URISyntaxException e) { throw new OREException(e); } }
private void handlePropertySubclassOf(OntProperty p) { List<RDFNode> list = p.listPropertyValues(RDFS.subClassOf).toList(); for (RDFNode node : list) { if (!node.canAs(Resource.class)) continue; Resource resource = node.asResource(); Resource onPropertyValue = resource.getPropertyResourceValue(OWL.onProperty); if (!RDFS.domain.equals(onPropertyValue)) continue; Resource someValuesFrom = resource.getPropertyResourceValue(OWL.someValuesFrom); if (someValuesFrom == null) continue; String uri = someValuesFrom.getURI(); if (uri != null) { OntResource type = someValuesFrom.as(OntResource.class); addField(type, p, null); } else { Resource unionList = someValuesFrom.getPropertyResourceValue(OWL.unionOf); while (unionList != null) { Resource first = unionList.getPropertyResourceValue(RDF.first); if (first != null) { String typeURI = first.getURI(); if (typeURI == null) { logger.warn( "Cannot handle union that contains an anonymous class in the domain of " + p.getURI()); } else { OntResource type = first.as(OntResource.class); addField(type, p, null); } } unionList = unionList.getPropertyResourceValue(RDF.rest); if (RDF.nil.equals(unionList)) { break; } } } } }
private String getURIStr(Resource res) { String URIStr; if (res == null) { URIStr = OWL.Thing .getURI(); // TODO: rdf:Resource if using RDF model; or option to turn off entirely } else { if (res.isAnon()) { URIStr = PSEUDO_BNODE_NS + res.getId().toString(); } else { URIStr = res.getURI(); } } return URIStr; }
protected synchronized Map<Pattern, String> buildUrlPatternToURI() { OntModel displayModel = (OntModel) getServletContext().getAttribute("displayOntModel"); Map<Pattern, String> map = new HashMap<Pattern, String>(); StmtIterator stmts = displayModel.listStatements(null, DisplayVocabulary.URL_MAPPING, (Literal) null); while (stmts.hasNext()) { Statement stmt = stmts.nextStatement(); if (stmt.getSubject().isURIResource() && stmt.getObject().isLiteral()) { Resource r = (Resource) stmt.getSubject().as(Resource.class); Pattern regex = Pattern.compile(stmt.getLiteral().getLexicalForm()); map.put(regex, r.getURI()); } } return map; }
/* (non-Javadoc) * @see org.sadiframework.client.Registry#findServicesByConnectedClass(com.hp.hpl.jena.rdf.model.Resource) */ @Override public Collection<? extends Service> findServicesByConnectedClass(Resource clazz) throws SADIException { Set<String> classURIs = new HashSet<String>(); if (clazz.isURIResource()) classURIs.add(clazz.getURI()); if (clazz.canAs(OntClass.class)) { for (Iterator<? extends OntClass> i = clazz.as(OntClass.class).listSubClasses(); i.hasNext(); ) { OntClass c = i.next(); if (c.isURIResource()) classURIs.add(c.getURI()); } } return findServicesByConnectedClass(classURIs); // TODO // return findServices(RegistrySearchCriteria.findService().addConnectedClass(clazz)); }
public Individual fillExistingDataPropertyStatementsForIndividual( Individual entity /*, boolean allowAnyNameSpace*/) { if (entity.getURI() == null) { return entity; } else { OntModel ontModel = getOntModelSelector().getABoxModel(); ontModel.enterCriticalSection(Lock.READ); try { Resource ind = ontModel.getResource(entity.getURI()); List<DataPropertyStatement> edList = new ArrayList<DataPropertyStatement>(); StmtIterator stmtIt = ind.listProperties(); while (stmtIt.hasNext()) { Statement st = (Statement) stmtIt.next(); boolean addToList = /*allowAnyNameSpace ? st.getObject().canAs(Literal.class) :*/ st.getObject().isLiteral() && ((RDF.value.equals(st.getPredicate()) || VitroVocabulary.value.equals(st.getPredicate().getURI())) || !(NONUSER_NAMESPACES.contains(st.getPredicate().getNameSpace()))); if (addToList) { /* now want to expose Cornellemailnetid and potentially other properties so can at least control whether visible boolean isExternalId = false; ClosableIterator externalIdStmtIt = getOntModel().listStatements(st.getPredicate(), DATAPROPERTY_ISEXTERNALID, (Literal)null); try { if (externalIdStmtIt.hasNext()) { isExternalId = true; } } finally { externalIdStmtIt.close(); } if (!isExternalId) { */ DataPropertyStatement ed = new DataPropertyStatementImpl(); Literal lit = (Literal) st.getObject(); fillDataPropertyStatementWithJenaLiteral(ed, lit); ed.setDatapropURI(st.getPredicate().getURI()); ed.setIndividualURI(ind.getURI()); ed.setIndividual(entity); edList.add(ed); /* } */ } } entity.setDataPropertyStatements(edList); return entity; } finally { ontModel.leaveCriticalSection(); } } }
public static void main(String[] args) throws IOException { Model model = ModelFactory.createDefaultModel(); try (InputStream is = new BZip2CompressorInputStream(new URL(DBPEDIA_SCHEMA_DOWNLOAD_URL).openStream())) { // model = FileManager.get().loadModel("input/dbpedia_3.9.owl"); model.read(is, null, "RDF/XML"); } System.out.println(model.size() + " triples loaded."); Set<Resource> classes = subjects(model, RDF.type, OWL.Class); Set<Resource> objectProperties = subjects(model, RDF.type, OWL.ObjectProperty); Set<Resource> dataProperties = subjects(model, RDF.type, OWL.DatatypeProperty); Map<Set<Resource>, String> setToName = new HashMap<>(); setToName.put(classes, "classes"); setToName.put(objectProperties, "objectproperties"); setToName.put(dataProperties, "dataproperties"); FieldType stringType = new FieldType(StringField.TYPE_STORED); stringType.setStoreTermVectors(false); FieldType textType = new FieldType(TextField.TYPE_STORED); textType.setStoreTermVectors(false); for (Set<Resource> set : setToName.keySet()) { IndexWriter writer = createWriter(setToName.get(set)); Set<Document> documents = new HashSet<>(); for (Resource resource : set) { for (RDFNode object : model.listObjectsOfProperty(resource, RDFS.label).toSet()) { String label = object.asLiteral().getLexicalForm(); Document luceneDocument = new Document(); luceneDocument.add(new Field("uri", resource.getURI(), stringType)); // luceneDocument.add(new Field("dbpediaUri", indexDocument.getCanonicalDBpediaUri(), // stringType)); luceneDocument.add(new Field("label", label, textType)); // documents.add(luceneDocument); writer.addDocument(luceneDocument); } } writer.addDocuments(documents); writer.commit(); writer.close(); } }