def graph_member(self, ldp_root, c_id, obj=None):
if not obj:
obj = self.member()
node = URIRef(ldp_root + encoder.encode(c_id) + "/member/" +
encoder.encode(obj.id))
mappings = URIRef(node + "#mappings")
g = Graph(identifier=node)
g.add((node, RDF.type, RDA.Member))
g.add((node, DCTERMS.identifier, Literal(obj.id)))
g.add((node, RDA.location, Literal(obj.location)))
if hasattr(obj, 'datatype'):
g.add((node, RDA.datatype, Literal(obj.datatype)))
if hasattr(obj, 'ontology'):
g.add((node, RDA.ontology, Literal(obj.ontology)))
if hasattr(obj, 'mappings'):
g.add((node, RDA.mappings, mappings))
mp = obj.mappings
if hasattr(mp, 'role'):
g.add((mappings, RDA.role, URIRef(obj.mappings.role)))
if hasattr(mp, 'index'):
g.add((mappings, RDA.itemIndex, Literal(obj.mappings.index)))
if hasattr(mp, 'dateAdded'):
g.add(
(mappings, RDA.dateAdded, Literal(obj.mappings.dateAdded)))
return g
def set_member(self, c_id, m_obj):
if isinstance(m_obj, Model):
m_obj = [m_obj]
elif not isinstance(m_obj, list):
raise ParseError()
c_ldp_id = self.marmotta.ldp(encoder.encode(c_id))
collection = self.get_collection(c_id).pop() # 404 if collection not found
if len(set([m.id for m in m_obj])) is not len(m_obj):
raise ForbiddenError()
if not collection.capabilities.membershipIsMutable:
raise ForbiddenError()
if collection.capabilities.restrictedToType:
for m in m_obj:
if not(hasattr(m,"datatype") and m.datatype in collection.capabilities.restrictedToType):
raise ForbiddenError()
if collection.capabilities.maxLength >= 0:
size = self.sparql.size(c_ldp_id).bindings.pop().get(Variable('size'))
if int(size) > collection.capabilities.maxLength-len(m_obj):
raise ForbiddenError()#"Operation forbidden. Collection of maximum size {} is full.".format(collection.capabilities.maxLength))
ds = Dataset()
ldp = ds.graph(identifier=LDP.ns)
for m in m_obj:
m_id = self.marmotta.ldp(encoder.encode(c_id)+"/member/"+encoder.encode(m.id))
member = ds.graph(identifier=m_id)
member += self.RDA.object_to_graph(member.identifier,m)
ldp += LDP.add_contains(c_ldp_id+"/member",m_id,False)
res = self.sparql.insert(ds)
if res.status_code is not 200:
raise DBError()
return m_obj
def get_collection(self, c_id=None, filter=[]):
# todo: ASK and check if collection exists
if c_id is not None:
result = self.sparql.select(self.marmotta.ldp(encoder.encode(c_id)))
graph = result.toDataset().graph(self.marmotta.ldp(encoder.encode(c_id)))
contents = self.RDA.graph_to_object(graph)
if len(contents) is 0:
raise NotFoundError()
else:
binds = [Bind(Variable('s'), self.marmotta.ldp()), Bind(Variable('p'), LDP.ns.contains)]
filters = [
Filter(s=Variable('o'),p=URIRef(v.get('label')) if k.type is RDA.Collection else LDP.contains/LDP.contains/URIRef(v.get('label')),
o=v.get('rdf', Literal)(k.value)) for v,k in [
(access(self.RDA.dictionary.get(f.type).inverted, f.path), f) for f in filter
]
]
result = self.sparql.list(binds, filters)
collections = [dct[Variable('o')] for dct in result.bindings]
contents = []
if len(collections):
result = self.sparql.select(collections)
ds = result.toDataset()
graphs = [ds.graph(collection) for collection in collections]
for graph in graphs:
contents += self.RDA.graph_to_object(graph)
return contents
def del_member(self, c_id, m_id):
collection = self.get_collection(c_id).pop() # 404 if collection not found
if not collection.capabilities.membershipIsMutable:
raise ForbiddenError()
id = self.marmotta.ldp(encoder.encode(c_id)+"/member/"+encoder.encode(m_id))
if self.sparql.ask(id, self.RDA.ns.Member).askAnswer:
self.sparql.delete(id)
return True
else:
raise NotFoundError()
def test_db_create_member(self):
with app.app_context():
c_obj = self.mock.collection()
m_obj = self.mock.member()
id = self.db.marmotta.ldp(
encoder.encode(c_obj.id) + "/member/" +
encoder.encode(m_obj.id))
self.db.set_collection(c_obj)
self.db.set_member(c_obj.id, m_obj)
response = self.db.sparql.select(id)
r_obj = self.db.RDA.graph_to_object(
response.toDataset().graph(id)).pop()
self.assertDictEqual(m_obj.dict(), r_obj.dict())
def test_encode_round(self):
text = ''.join(
random.choice(string.ascii_letters)
for _ in range(random.randint(3, 10)))
binary = encoder.encode(text)
result = encoder.decode(binary)
self.assertEqual(text, result)
def test_ldp_access_with_ldp(self):
with app.app_context():
# todo: post collection to sparql, retrieve via LDP and compare
c_obj = self.mock.collection()
self.db.set_collection(c_obj)
g = Dataset().parse(self.db.marmotta.ldp(encoder.encode(c_obj.id)),
format="n3")
r_obj = self.db.RDA.graph_to_object(g).pop()
self.assertDictEqual(c_obj.dict(), r_obj.dict())
def test_ldp_create_collection(self):
with app.app_context():
c_obj = self.mock.collection()
id = self.db.marmotta.ldp(encoder.encode(c_obj.id))
self.db.set_collection(c_obj)
response = self.db.sparql.select(
id) # todo: figure out if using db.sparql or sparql
#print(response.json())
r_obj = self.db.RDA.graph_to_object(
response.toDataset().graph(id)).pop()
self.assertDictEqual(c_obj.dict(), r_obj.dict())
def get_member(self, c_id, m_id=None, filter=[]):
# todo: ASK and check if member exists
if m_id is not None:
if not isinstance(m_id, list):
m_id = [m_id]
members = [self.marmotta.ldp(encoder.encode(c_id)+"/member/"+encoder.encode(id)) for id in m_id]
# ds = self.sparql.select(ids).toDataset()
# contents = [self.RDA.graph_to_member(ds.graph(id)) for id in ids]
else:
id = self.marmotta.ldp(encoder.encode(c_id))
if not self.sparql.ask(id, self.RDA.ns.Collection).askAnswer:
raise NotFoundError
lst = self.sparql.list([Bind(Variable('s'), self.marmotta.ldp(encoder.encode(c_id)+"/member")), Bind(Variable('p'), LDP.ns.contains)])
members = [dct[Variable('o')] for dct in lst.bindings]
contents=[]
if len(members):
dataset = self.sparql.select(members).toDataset()
graphs = [dataset.graph(member) for member in members]
for graph in graphs:
contents += self.RDA.graph_to_object(graph)
if m_id is not None and len(contents) is 0:
raise NotFoundError()
return contents
def graph_collection(self, ldp_root, obj=None):
if not obj:
obj = self.collection()
node = URIRef(ldp_root + encoder.encode(obj.id))
capabilities = URIRef(node + "#capabilities")
properties = URIRef(node + "#properties")
g = Graph(identifier=node)
g.add((node, RDF.type, RDA.Collection))
g.add((node, DCTERMS.identifier, Literal(obj.id)))
g.add((node, RDA.hasCapabilities, capabilities))
g.add((node, RDA.hasProperties, properties))
g.add(
(capabilities, RDA.isOrdered, Literal(obj.capabilities.isOrdered)))
g.add((capabilities, RDA.appendsToEnd,
Literal(obj.capabilities.appendsToEnd)))
g.add(
(capabilities, RDA.maxLength, Literal(obj.capabilities.maxLength)))
g.add((capabilities, RDA.membershipIsMutable,
Literal(obj.capabilities.membershipIsMutable)))
g.add((capabilities, RDA.propertiesAreMutable,
Literal(obj.capabilities.propertiesAreMutable)))
g.add((capabilities, RDA.restrictedToType,
Literal(obj.capabilities.restrictedToType)))
g.add((capabilities, RDA.supportsRoles,
Literal(obj.capabilities.supportsRoles)))
g.add((properties, RDA.memberOf, RDF.nil))
g.add((properties, RDA.modelType, Literal(obj.properties.modelType)))
g.add((properties, RDA.descriptionOntology,
Literal(obj.properties.descriptionOntology)))
g.add((properties, DCTERMS.license, Literal(obj.properties.license)))
g.add((properties, DCTERMS.rightsHolder,
URIRef(obj.properties.ownership)))
g.add((properties, RDA.hasAccessRestrictions,
Literal(obj.properties.hasAccessRestrictions)))
g.add(
(properties, RDA.dateCreated, Literal(obj.properties.dateCreated)))
if hasattr(obj, "description") and isinstance(obj.description, dict):
description = URIRef(node + "#description")
g.add((node, DCTERMS.description, description))
if len(obj.description.items()) is 0:
g.add((description, RDF.type, OWL.Nothing))
for key, value in obj.description.items():
g.add((description, URIRef(description + "@" + key),
Literal(obj.description[key])))
return g
def set_collection(self, c_obj, over_write=False):
if isinstance(c_obj, Model):
c_obj = [c_obj]
elif not isinstance(c_obj, list):
raise ParseError()
# create LD collection and declare as ldp:BasicContainer
ds = Dataset()
ldp = ds.graph(identifier=LDP.ns)
for c in c_obj:
c_id = encoder.encode(c.id)
collection = ds.graph(identifier=self.marmotta.ldp(c_id))
collection += self.RDA.object_to_graph(collection.identifier, c)
ldp += LDP.add_contains(self.marmotta.ldp(), collection.identifier)
member = ds.graph(identifier=self.marmotta.ldp(c_id+'/member'))
ldp += LDP.add_contains(collection.identifier, member.identifier)
ins = self.sparql.insert(ds)
if ins.status_code is 200:
return c_obj
else:
raise DBError()
def test_encoder_input(self):
with self.assertRaises(TypeError) as context:
encoder.encode(1000)
with self.assertRaises(TypeError) as context:
encoder.decode(1111)
def collection_result(self,
obj=None,
ldp_root="http://localhost:8080/marmotta/ldp/"):
if not obj:
obj = self.collection()
ldp = ldp_root + encoder.encode(obj.id)
return JSONResult(
json.loads("""
{{
"head" : {{
"vars" : [ "g", "s", "p", "o" ]
}},
"results" : {{
"bindings" : [ {{
"o" : {{
"type" : "uri",
"value" : "http://www.w3.org/ns/ldp#Resource"
}},
"g" : {{
"type" : "uri",
"value" : "http://www.w3.org/ns/ldp#"
}},
"s" : {{
"type" : "uri",
"value" : "{ldp}"
}},
"p" : {{
"type" : "uri",
"value" : "http://www.w3.org/1999/02/22-rdf-syntax-ns#type"
}}
}}, {{
"o" : {{
"type" : "uri",
"value" : "http://www.w3.org/ns/ldp#RDFSource"
}},
"g" : {{
"type" : "uri",
"value" : "http://www.w3.org/ns/ldp#"
}},
"s" : {{
"type" : "uri",
"value" : "{ldp}"
}},
"p" : {{
"type" : "uri",
"value" : "http://www.w3.org/1999/02/22-rdf-syntax-ns#type"
}}
}}, {{
"o" : {{
"type" : "uri",
"value" : "http://www.w3.org/ns/ldp#Container"
}},
"g" : {{
"type" : "uri",
"value" : "http://www.w3.org/ns/ldp#"
}},
"s" : {{
"type" : "uri",
"value" : "{ldp}"
}},
"p" : {{
"type" : "uri",
"value" : "http://www.w3.org/ns/ldp#interactionModel"
}}
}}, {{
"o" : {{
"type" : "uri",
"value" : "http://www.w3.org/ns/ldp#Container"
}},
"g" : {{
"type" : "uri",
"value" : "http://www.w3.org/ns/ldp#"
}},
"s" : {{
"type" : "uri",
"value" : "{ldp}"
}},
"p" : {{
"type" : "uri",
"value" : "http://www.w3.org/1999/02/22-rdf-syntax-ns#type"
}}
}}, {{
"o" : {{
"type" : "uri",
"value" : "http://www.w3.org/ns/ldp#BasicContainer"
}},
"g" : {{
"type" : "uri",
"value" : "http://www.w3.org/ns/ldp#"
}},
"s" : {{
"type" : "uri",
"value" : "{ldp}"
}},
"p" : {{
"type" : "uri",
"value" : "http://www.w3.org/1999/02/22-rdf-syntax-ns#type"
}}
}}, {{
"o" : {{
"datatype" : "http://www.w3.org/2001/XMLSchema#dateTime",
"type" : "literal",
"value" : "2017-05-25T11:18:11.000Z"
}},
"g" : {{
"type" : "uri",
"value" : "http://www.w3.org/ns/ldp#"
}},
"s" : {{
"type" : "uri",
"value" : "{ldp}"
}},
"p" : {{
"type" : "uri",
"value" : "http://purl.org/dc/terms/created"
}}
}}, {{
"o" : {{
"datatype" : "http://www.w3.org/2001/XMLSchema#dateTime",
"type" : "literal",
"value" : "2017-05-25T11:18:11.000Z"
}},
"g" : {{
"type" : "uri",
"value" : "http://www.w3.org/ns/ldp#"
}},
"s" : {{
"type" : "uri",
"value" : "{ldp}"
}},
"p" : {{
"type" : "uri",
"value" : "http://purl.org/dc/terms/modified"
}}
}}, {{
"o" : {{
"type" : "uri",
"value" : "{ldp}"
}},
"g" : {{
"type" : "uri",
"value" : "http://www.w3.org/ns/ldp#"
}},
"s" : {{
"type" : "uri",
"value" : "{ldp_root}"
}},
"p" : {{
"type" : "uri",
"value" : "http://www.w3.org/ns/ldp#contains"
}}
}}, {{
"o" : {{
"type" : "uri",
"value" : "http://rd-alliance.org/ns/collections#Collection"
}},
"g" : {{
"type" : "uri",
"value" : "{ldp}"
}},
"s" : {{
"type" : "uri",
"value" : "{ldp}"
}},
"p" : {{
"type" : "uri",
"value" : "http://www.w3.org/1999/02/22-rdf-syntax-ns#type"
}}
}}, {{
"o" : {{
"type" : "uri",
"value" : "{ldp}#capabilities"
}},
"g" : {{
"type" : "uri",
"value" : "{ldp}"
}},
"s" : {{
"type" : "uri",
"value" : "{ldp}"
}},
"p" : {{
"type" : "uri",
"value" : "http://rd-alliance.org/ns/collections#hasCapabilities"
}}
}}, {{
"o" : {{
"type" : "uri",
"value" : "{ldp}#properties"
}},
"g" : {{
"type" : "uri",
"value" : "{ldp}"
}},
"s" : {{
"type" : "uri",
"value" : "{ldp}"
}},
"p" : {{
"type" : "uri",
"value" : "http://rd-alliance.org/ns/collections#hasProperties"
}}
}}, {{
"o" : {{
"type" : "uri",
"value" : "{obj.id}"
}},
"g" : {{
"type" : "uri",
"value" : "{ldp}"
}},
"s" : {{
"type" : "uri",
"value" : "{ldp}"
}},
"p" : {{
"type" : "uri",
"value" : "http://purl.org/dc/terms/identifier"
}}
}}, {{
"o" : {{
"type" : "uri",
"value" : "{ldp}#description"
}},
"g" : {{
"type" : "uri",
"value" : "{ldp}"
}},
"s" : {{
"type" : "uri",
"value" : "{ldp}"
}},
"p" : {{
"type" : "uri",
"value" : "http://purl.org/dc/terms/description"
}}
}}, {{
"o" : {{
"type" : "uri",
"value" : "http://rd-alliance.org/ns/collections#Capabilities"
}},
"g" : {{
"type" : "uri",
"value" : "{ldp}"
}},
"s" : {{
"type" : "uri",
"value" : "{ldp}#capabilities"
}},
"p" : {{
"type" : "uri",
"value" : "http://www.w3.org/1999/02/22-rdf-syntax-ns#type"
}}
}}, {{
"o" : {{
"datatype" : "http://www.w3.org/2001/XMLSchema#boolean",
"type" : "literal",
"value" : "false"
}},
"g" : {{
"type" : "uri",
"value" : "{ldp}"
}},
"s" : {{
"type" : "uri",
"value" : "{ldp}#capabilities"
}},
"p" : {{
"type" : "uri",
"value" : "http://rd-alliance.org/ns/collections#isOrdered"
}}
}}, {{
"o" : {{
"datatype" : "http://www.w3.org/2001/XMLSchema#boolean",
"type" : "literal",
"value" : "false"
}},
"g" : {{
"type" : "uri",
"value" : "{ldp}"
}},
"s" : {{
"type" : "uri",
"value" : "{ldp}#capabilities"
}},
"p" : {{
"type" : "uri",
"value" : "http://rd-alliance.org/ns/collections#appendsToEnd"
}}
}}, {{
"o" : {{
"datatype" : "http://www.w3.org/2001/XMLSchema#boolean",
"type" : "literal",
"value" : "false"
}},
"g" : {{
"type" : "uri",
"value" : "{ldp}"
}},
"s" : {{
"type" : "uri",
"value" : "{ldp}#capabilities"
}},
"p" : {{
"type" : "uri",
"value" : "http://rd-alliance.org/ns/collections#supportsRoles"
}}
}}, {{
"o" : {{
"datatype" : "http://www.w3.org/2001/XMLSchema#boolean",
"type" : "literal",
"value" : "false"
}},
"g" : {{
"type" : "uri",
"value" : "{ldp}"
}},
"s" : {{
"type" : "uri",
"value" : "{ldp}#capabilities"
}},
"p" : {{
"type" : "uri",
"value" : "http://rd-alliance.org/ns/collections#membershipIsMutable"
}}
}}, {{
"o" : {{
"datatype" : "http://www.w3.org/2001/XMLSchema#boolean",
"type" : "literal",
"value" : "false"
}},
"g" : {{
"type" : "uri",
"value" : "{ldp}"
}},
"s" : {{
"type" : "uri",
"value" : "{ldp}#capabilities"
}},
"p" : {{
"type" : "uri",
"value" : "http://rd-alliance.org/ns/collections#metadataIsMutable"
}}
}}, {{
"o" : {{
"type" : "literal",
"value" : ""
}},
"g" : {{
"type" : "uri",
"value" : "{ldp}"
}},
"s" : {{
"type" : "uri",
"value" : "{ldp}#capabilities"
}},
"p" : {{
"type" : "uri",
"value" : "http://rd-alliance.org/ns/collections#restrictedToType"
}}
}}, {{
"o" : {{
"datatype" : "http://www.w3.org/2001/XMLSchema#integer",
"type" : "literal",
"value" : "-1"
}},
"g" : {{
"type" : "uri",
"value" : "{ldp}"
}},
"s" : {{
"type" : "uri",
"value" : "{ldp}#capabilities"
}},
"p" : {{
"type" : "uri",
"value" : "http://rd-alliance.org/ns/collections#maxLength"
}}
}}, {{
"o" : {{
"type" : "uri",
"value" : "http://rd-alliance.org/ns/collections#Properties"
}},
"g" : {{
"type" : "uri",
"value" : "{ldp}"
}},
"s" : {{
"type" : "uri",
"value" : "{ldp}#properties"
}},
"p" : {{
"type" : "uri",
"value" : "http://www.w3.org/1999/02/22-rdf-syntax-ns#type"
}}
}}, {{
"o" : {{
"type" : "literal",
"value" : ""
}},
"g" : {{
"type" : "uri",
"value" : "{ldp}"
}},
"s" : {{
"type" : "uri",
"value" : "{ldp}#properties"
}},
"p" : {{
"type" : "uri",
"value" : "http://rd-alliance.org/ns/collections#ownership"
}}
}}, {{
"o" : {{
"type" : "literal",
"value" : ""
}},
"g" : {{
"type" : "uri",
"value" : "{ldp}"
}},
"s" : {{
"type" : "uri",
"value" : "{ldp}#properties"
}},
"p" : {{
"type" : "uri",
"value" : "http://purl.org/dc/terms/license"
}}
}}, {{
"o" : {{
"type" : "literal",
"value" : ""
}},
"g" : {{
"type" : "uri",
"value" : "{ldp}"
}},
"s" : {{
"type" : "uri",
"value" : "{ldp}#properties"
}},
"p" : {{
"type" : "uri",
"value" : "http://rd-alliance.org/ns/collections#modelType"
}}
}}, {{
"o" : {{
"datatype" : "http://www.w3.org/2001/XMLSchema#boolean",
"type" : "literal",
"value" : "false"
}},
"g" : {{
"type" : "uri",
"value" : "{ldp}"
}},
"s" : {{
"type" : "uri",
"value" : "{ldp}#properties"
}},
"p" : {{
"type" : "uri",
"value" : "http://rd-alliance.org/ns/collections#hasAccessRestrictions"
}}
}}, {{
"o" : {{
"type" : "uri",
"value" : "http://www.w3.org/1999/02/22-rdf-syntax-ns#nil"
}},
"g" : {{
"type" : "uri",
"value" : "{ldp}"
}},
"s" : {{
"type" : "uri",
"value" : "{ldp}#properties"
}},
"p" : {{
"type" : "uri",
"value" : "http://rd-alliance.org/ns/collections#memberOf"
}}
}}, {{
"o" : {{
"type" : "literal",
"value" : "{obj.properties.descriptionOntology}"
}},
"g" : {{
"type" : "uri",
"value" : "{ldp}"
}},
"s" : {{
"type" : "uri",
"value" : "{ldp}#properties"
}},
"p" : {{
"type" : "uri",
"value" : "http://rd-alliance.org/ns/collections#descriptionOntology"
}}
}}, {{
"o" : {{
"type" : "literal",
"value" : "{obj.properties.dateCreated}"
}},
"g" : {{
"type" : "uri",
"value" : "{ldp}"
}},
"s" : {{
"type" : "uri",
"value" : "{ldp}#properties"
}},
"p" : {{
"type" : "uri",
"value" : "http://rd-alliance.org/ns/collections#dateCreated"
}}
}} ]
}}
}}
""".format(obj=obj, ldp=ldp, ldp_root=ldp_root)))
def ask_collection(self, c_id):
if not isinstance(c_id, list):
c_id = [c_id]
ids = [self.marmotta.ldp(encoder.encode(id)) for id in c_id]
result = self.sparql.find(ids,self.RDA.ns.Collection)
return float(result.bindings.pop().get(Variable('size')))/len(c_id)
def ask_member(self, c_id, m_id):
if not isinstance(m_id, list):
m_id = [m_id]
ids = [self.marmotta.ldp(encoder.encode(c_id)+"/member/"+encoder.encode(m)) for m in m_id]
result = self.sparql.find(ids,self.RDA.ns.Member)
return float(result.bindings.pop().get(Variable('size')))/len(m_id)
def del_collection(self, c_id):
if self.sparql.ask(self.marmotta.ldp(encoder.encode(c_id)), self.RDA.ns.Collection).askAnswer:
self.sparql.delete(self.marmotta.ldp(encoder.encode(c_id)))
return True
else:
raise NotFoundError()