def handle(self, *args, **options):
store = rdfstore()
for u in User.objects.filter():
user_graph_identifier = uris.uri('semantic_store_users',
username=u.username)
user_graph = Graph(store=store, identifier=user_graph_identifier)
print 'Updating user graph %s' % user_graph_identifier
for project in user_graph.objects(None, NS.perm.hasPermissionOver):
project_graph_identifier = uris.uri('semantic_store_projects',
uri=project)
project_graph = Graph(store=store,
identifier=project_graph_identifier)
if (len(
list(
project_graph.triples(
(project, NS.rdf.type, NS.ore.Aggregation))))):
with transaction.commit_on_success():
print '-Updating project graph %s' % project
project_graph.add(
(project, NS.rdf.type, NS.foaf.Project))
project_graph.add(
(project, NS.rdf.type, NS.dm.Project))
def read_project(request, project_uri):
"""Returns a HttpResponse of the cached project metadata graph"""
project_uri = URIRef(project_uri)
if request.user.is_authenticated():
if permissions.has_permission_over(project_uri, user=request.user, permission=NS.perm.mayRead):
identifier = uris.uri('semantic_store_projects', uri=project_uri)
store_metadata_graph = get_project_metadata_graph(project_uri)
ret_graph = Graph()
ret_graph += store_metadata_graph
add_is_described_bys(request, project_uri, ret_graph)
for permission in ProjectPermission.objects.filter(identifier=project_uri):
user = permission.user
user_uri = uris.uri('semantic_store_users', username=user.username)
perm_uri = permissions.PERMISSION_URIS_BY_MODEL_VALUE[permission.permission]
ret_graph += user_metadata_graph(user=user)
ret_graph.add((user_uri, NS.perm.hasPermissionOver, project_uri))
ret_graph.add((user_uri, perm_uri, project_uri))
if len(ret_graph) > 0:
return NegotiatedGraphResponse(request, ret_graph)
else:
return HttpResponseNotFound()
else:
return HttpResponseForbidden('User "%s" does not have read permissions over project "%s"' % (request.user.username, project_uri))
else:
return HttpResponse(status=401)
def read_project(request, project_uri):
"""Returns a HttpResponse of the cached project metadata graph"""
project_uri = URIRef(project_uri)
if request.user.is_authenticated():
if permissions.has_permission_over(project_uri, user=request.user, permission=NS.perm.mayRead):
identifier = uris.uri('semantic_store_projects', uri=project_uri)
store_metadata_graph = get_project_metadata_graph(project_uri)
ret_graph = Graph()
ret_graph += store_metadata_graph
add_is_described_bys(request, project_uri, ret_graph)
for permission in ProjectPermission.objects.filter(identifier=project_uri):
user = permission.user
user_uri = uris.uri('semantic_store_users', username=user.username)
perm_uri = permissions.PERMISSION_URIS_BY_MODEL_VALUE[permission.permission]
ret_graph += user_metadata_graph(user=user)
ret_graph.add((user_uri, NS.perm.hasPermissionOver, project_uri))
ret_graph.add((user_uri, perm_uri, project_uri))
if len(ret_graph) > 0:
return NegotiatedGraphResponse(request, ret_graph)
else:
return HttpResponseNotFound()
else:
return HttpResponseForbidden('User "%s" does not have read permissions over project "%s"' % (request.user.username, project_uri))
else:
return HttpResponse(status=401)
def update_project_graph(g, identifier):
"""Updates the main project graph and the metadata graph from an input graph"""
uri = uris.uri('semantic_store_projects', uri=identifier)
project_g = get_project_graph(identifier)
project_metadata_g = get_project_metadata_graph(identifier)
#Prevent duplicate metadata
if (URIRef(identifier), NS.dc.title, None) in g:
project_g.remove((URIRef(identifier), NS.dc.title, None))
project_metadata_g.remove((URIRef(identifier), NS.dc.title, None))
if (URIRef(identifier), NS.rdfs.label, None) in g:
project_g.remove((URIRef(identifier), NS.rdfs.label, None))
project_metadata_g.remove((URIRef(identifier), NS.rdfs.label, None))
if (URIRef(identifier), NS.dcterms.description, None) in g:
project_g.remove((URIRef(identifier), NS.dcterms.description, None))
project_metadata_g.remove((URIRef(identifier), NS.dcterms.description, None))
for triple in g:
project_g.add(triple)
for triple in metadata_triples(g, identifier):
project_metadata_g.add(triple)
for triple in g.triples((identifier, NS.ore.aggregates, None)):
project_metadata_g.add(triple)
aggregate_uri = triple[2]
project_metadata_g += metadata_triples(project_g, aggregate_uri)
project_metadata_g += metadata_triples(g, aggregate_uri)
def user_uri(username=None, user=None):
if user is None:
user = User.objects.get(username=username)
if username is None:
username = user.username
return URIRef(uris.uri('semantic_store_users', username=username))
def project_uris_by_title(self, user_graph, user_uri):
projectsByTitle = defaultdict(list)
bind_namespaces(user_graph)
for row in user_graph.query("""
SELECT DISTINCT ?project ?title WHERE {
?user ore:aggregates ?project .
OPTIONAL {?project dc:title ?title .}
}
""",
initNs=ns,
initBindings={'user': URIRef(user_uri)}):
project_uri = uris.uri('semantic_store_projects', uri=row[0])
project_graph = Graph(store=rdfstore(), identifier=project_uri)
project_resource = Resource(project_graph, URIRef(row[0]))
titles = list(project_resource.objects(predicate=NS.dc['title']))
if len(titles) == 0 and row[1]:
# The project graph doesn't have a title triple, but the user graph does, so use that
projectsByTitle[unicode(row[1])].append(row[0])
else:
# Use the project graph's title triples (preferred)
for title in titles:
projectsByTitle[unicode(title)].append(row[0])
return projectsByTitle
def remove_project_text(project_uri, text_uri):
# Correctly format project uri and get project graph
project_uri = uris.uri('semantic_store_projects', uri=project_uri)
project_g = Graph(rdfstore(), identifier=project_uri)
project_metadata_g = Graph(
rdfstore(), identifier=uris.project_metadata_graph_identifier(p_uri))
# Make text uri a URIRef (so Graph will understand)
text_uri = URIRef(text_uri)
with transaction.commit_on_success():
for t in specific_resources_subgraph(project_g, text_uri, project_uri):
project_g.remove(t)
for t in project_g.triples((text_uri, None, None)):
# Delete triple about text from project graph
project_g.remove(t)
project_metadata_g.remove(t)
project_g.remove((URIRef(project_uri), NS.ore.aggregates, text_uri))
for text in Text.objects.filter(identifier=text_uri,
valid=True).only('valid'):
text.valid = False
text.save()
def update_project_graph(g, identifier):
"""Updates the main project graph and the metadata graph from an input graph"""
uri = uris.uri('semantic_store_projects', uri=identifier)
project_g = get_project_graph(identifier)
project_metadata_g = get_project_metadata_graph(identifier)
#Prevent duplicate metadata
if (URIRef(identifier), NS.dc.title, None) in g:
project_g.remove((URIRef(identifier), NS.dc.title, None))
project_metadata_g.remove((URIRef(identifier), NS.dc.title, None))
if (URIRef(identifier), NS.rdfs.label, None) in g:
project_g.remove((URIRef(identifier), NS.rdfs.label, None))
project_metadata_g.remove((URIRef(identifier), NS.rdfs.label, None))
if (URIRef(identifier), NS.dcterms.description, None) in g:
project_g.remove((URIRef(identifier), NS.dcterms.description, None))
project_metadata_g.remove((URIRef(identifier), NS.dcterms.description, None))
for triple in g:
project_g.add(triple)
for triple in metadata_triples(g, identifier):
project_metadata_g.add(triple)
for triple in g.triples((identifier, NS.ore.aggregates, None)):
project_metadata_g.add(triple)
aggregate_uri = triple[2]
project_metadata_g += metadata_triples(project_g, aggregate_uri)
project_metadata_g += metadata_triples(g, aggregate_uri)
def handle(self, *args, **options):
username = options['username']
project_title = options['project_title']
res_uri = options['res_uri']
if (not (username and project_title and res_uri)):
print "Username, project, and res are required arguments."
exit(0)
user_uri = uris.uri('semantic_store_users', username=username)
user_g = Graph(store=rdfstore(), identifier=user_uri)
# Project title data is stored in the named graph for that project, so we need
# to query those graphs rather than just the user graph
projectsByTitle = self.project_uris_by_title(user_g, user_uri)
print "projectsByTitle: %s" % projectsByTitle.items()
if project_title not in projectsByTitle:
print "No such project with title '%s' found for user '%s'" % \
(project_title, username)
print "User %s has projects entitled %s" % (username,
projectsByTitle.keys())
exit(0)
project_uris = projectsByTitle[project_title]
if len(project_uris) > 1:
print "More than one project with that title exists."
exit(0)
else:
project_identifier = project_uris[0]
with transaction.commit_on_success():
uri = uris.uri('semantic_store_projects',
uri=project_identifier)
project_g = Graph(store=rdfstore(), identifier=uri)
project_g.add((project_identifier, NS.ore['aggregates'],
URIRef(res_uri)))
main_g = ConjunctiveGraph(store=rdfstore(),
identifier=default_identifier)
for t in main_g.triples(
(URIRef(res_uri), NS.dc['title'], None)):
project_g.add(t)
for t in main_g.triples(
(URIRef(res_uri), NS.ore['isDescribedBy'], None)):
project_g.add(t)
for t in main_g.triples(
(URIRef(res_uri), NS.rdf['type'], None)):
project_g.add(t)
def update_canvas_graph(project_uri, canvas_uri):
identifier = uris.uri("semantic_store_project_canvases", project_uri=project_uri, canvas_uri=canvas_uri)
canvas_graph = Graph(rdfstore(), identifier=identifier)
for t in generate_canvas_graph(project_uri, canvas_uri):
canvas_graph.add(t)
return canvas_graph
def create_project(g):
"""Creates a project in the database (and the metadata cache) from an input graph"""
print "Here 1"
query = g.query("""SELECT ?uri ?user
WHERE {
?user perm:hasPermissionOver ?uri .
?user rdf:type foaf:Agent .
}""", initNs=ns)
print "Here 2"
for uri in g.subjects(NS.rdf.type, NS.dm.Project):
print "Here 3"
user = g.value(None, NS.perm.hasPermissionOver, uri)
if user:
print "Here 3.1"
user_obj = User.objects.get(username=user.split('/')[-1])
print "Here 3.2"
project_identifier = uris.uri('semantic_store_projects', uri=uri)
print "Here 3.3"
project_g = Graph(store=rdfstore(), identifier=project_identifier)
print "Here 4"
for text_uri in g.subjects(NS.rdf.type, NS.dcmitype.Text):
text_graph = Graph()
text_graph += g.triples((text_uri, None, None))
print "Here 4.1"
if user:
project_texts.update_project_text(text_graph, uri, text_uri, user_obj)
print "Here 5"
for t in g:
project_g.add(t)
for text_uri in g.subjects(NS.rdf.type, NS.dcmitype.Text):
project_g.remove((text_uri, NS.cnt.chars, None))
url = uris.url('semantic_store_projects', uri=uri)
project_g.set((uri, NS.dcterms['created'], Literal(datetime.utcnow())))
print "before user"
if user:
print "user is true"
project_g.remove((user, None, None))
username = user.split("/")[-1]
permissions.grant_full_project_permissions(username, uri)
add_project_types(project_g, uri)
build_project_metadata_graph(uri)
print "Successfully created project with uri " + uri
def update_specific_resource(graph, project_uri, specific_resource_uri):
project_identifier = uris.uri('semantic_store_projects', uri=project_uri)
db_project_graph = Graph(store=rdfstore(), identifier=project_identifier)
for t in specific_resource_subgraph(graph, specific_resource_uri):
db_project_graph.add(t)
for selector in graph.objects(specific_resource_uri,
NS.oa.hasSelector):
for i in graph.triples((selector, None, None)):
db_project_graph.set(i)
def update_canvas(project_uri, canvas_uri, input_graph):
project_uri = URIRef(project_uri)
canvas_uri = URIRef(canvas_uri)
project_identifier = uris.uri('semantic_store_projects', uri=project_uri)
project_graph = Graph(store=rdfstore(), identifier=project_identifier)
project_metadata_g = Graph(rdfstore(), identifier=uris.project_metadata_graph_identifier(project_uri))
if (canvas_uri, NS.dc.title, None) in input_graph:
project_graph.remove((canvas_uri, NS.dc.title, None))
project_metadata_g.remove((canvas_uri, NS.dc.title, None))
if (canvas_uri, NS.rdfs.label, None) in input_graph:
project_graph.remove((canvas_uri, NS.rdfs.label, None))
project_metadata_g.remove((canvas_uri, NS.rdfs.label, None))
project_graph += input_graph
project_metadata_g += canvas_and_images_graph(input_graph, canvas_uri)
return project_graph
def update_annotation(request, dest_g, annotations_g, anno_uri):
old_anno_g = annotation_graph(dest_g, anno_uri)
for t in old_anno_g:
dest_g.remove(t)
new_anno_g = annotation_graph(annotations_g, anno_uri)
new_anno_g.add(
(anno_uri, NS.oa['annotatedAt'], Literal(datetime.utcnow())))
if request.user.is_authenticated():
user_uri = uris.uri('semantic_store_users',
username=request.user.username)
new_anno_g.add((anno_uri, NS.oa['annotatedBy'], user_uri))
new_anno_g.add((user_uri, NS.rdf['type'], NS.foaf['Person']))
new_anno_g.add(
(user_uri, NS.foaf['name'], Literal(request.user.username)))
new_anno_g.add((user_uri, NS.foaf['mbox'],
URIRef("mailto:" + request.user.email)))
for t in new_anno_g:
dest_g.add(t)
return new_anno_g
def update_project_text(g, p_uri, t_uri, user):
# Correctly format project uri and get project graph
project_uri = uris.uri('semantic_store_projects', uri=p_uri)
project_g = Graph(rdfstore(), identifier=project_uri)
project_metadata_g = Graph(rdfstore(), identifier=uris.project_metadata_graph_identifier(p_uri))
text_uri = URIRef(t_uri)
title = g.value(text_uri, NS.dc.title) or g.value(text_uri, NS.rdfs.label) or Literal("")
content_value = g.value(text_uri, NS.cnt.chars)
if content_value:
content = sanitized_content(content_value)
else:
content = ''
with transaction.commit_on_success():
for t in Text.objects.filter(identifier=t_uri, valid=True):
t.valid = False
t.save()
# While it looks like this would be better with a QuerySet update, we need to fire the save
# events to keep the search index up to date. In all forseeable cases, this should only execute
# for one Text object anyway.
text = Text.objects.create(identifier=t_uri, title=title, content=content, last_user=user, project=p_uri)
project_g.add((text_uri, NS.rdf.type, NS.dctypes.Text))
project_g.set((text_uri, NS.dc.title, title))
project_g.set((text_uri, NS.rdfs.label, title))
text_url = URIRef(uris.url('semantic_store_project_texts', project_uri=p_uri, text_uri=text_uri))
project_g.set((text_uri, NS.ore.isDescribedBy, text_url))
if (URIRef(p_uri), NS.ore.aggregates, text_uri) in project_metadata_g:
project_metadata_g.add((text_uri, NS.rdf.type, NS.dctypes.Text))
project_metadata_g.set((text_uri, NS.dc.title, title))
project_metadata_g.set((text_uri, NS.rdfs.label, title))
specific_resource_triples = specific_resources_subgraph(g, text_uri, p_uri)
for t in specific_resource_triples:
project_g.add(t)
for t in g.triples((None, NS.rdf.type, NS.oa.TextQuoteSelector)):
project_g.set(t)
def read_project_text(project_uri, text_uri):
# Correctly format project uri and get project graph
project_identifier = uris.uri('semantic_store_projects', uri=project_uri)
project_g = Graph(rdfstore(), identifier=project_identifier)
# Make text uri URIRef (so Graph will understand)
text_uri = URIRef(text_uri)
# Create an empty graph and bind namespaces
text_g = Graph()
bind_namespaces(text_g)
text_g += resource_annotation_subgraph(project_g, text_uri)
text_g += specific_resources_subgraph(project_g, text_uri, project_uri)
overwrite_text_graph_from_model(text_uri, project_uri, text_g)
# Return graph about text
return text_g
def generate_canvas_graph(project_uri, canvas_uri):
project_identifier = uris.uri('semantic_store_projects', uri=project_uri)
db_project_graph = Graph(store=rdfstore(), identifier=project_identifier)
project_graph = db_project_graph
memory_graph = Graph()
memory_graph += canvas_subgraph(project_graph, canvas_uri, project_uri)
for text in memory_graph.subjects(NS.rdf.type, NS.dcmitype.Text):
if (text, NS.ore.isDescribedBy, None) not in memory_graph:
text_url = uris.url('semantic_store_project_texts', project_uri=project_uri, text_uri=text)
memory_graph.add((text, NS.ore.isDescribedBy, text_url))
for canvas in memory_graph.subjects(NS.rdf.type, NS.sc.Canvas):
if (canvas, NS.ore.isDescribedBy, None) not in memory_graph:
canvas_url = uris.url('semantic_store_project_canvases', project_uri=project_uri, canvas_uri=canvas)
memory_graph.add((canvas, NS.ore.isDescribedBy, canvas_url))
return memory_graph
def read_specific_resource(project_uri, specific_resource, source):
specific_resource = URIRef(specific_resource)
project_identifier = uris.uri('semantic_store_projects', uri=project_uri)
db_project_graph = Graph(store=rdfstore(), identifier=project_identifier)
project_graph = db_project_graph
return_graph = Graph()
return_graph += project_graph.triples((specific_resource, None, None))
selectors = project_graph.objects(specific_resource, NS.oa.hasSelector)
for selector in selectors:
return_graph += project_graph.triples((selector, None, None))
if (URIRef(source), NS.rdf.type, NS.sc.Canvas) in project_graph:
return_graph.add(
(specific_resource, NS.ore.isDescribedBy,
URIRef(
uris.url("semantic_store_canvas_specific_resource",
project_uri=project_uri,
canvas_uri=source,
specific_resource=specific_resource))))
elif (URIRef(source), NS.rdf.type, NS.dcmitype.Text) in project_graph:
return_graph.add((specific_resource, NS.ore.isDescribedBy,
URIRef(
uris.url("semantic_store_text_specific_resource",
project_uri=project_uri,
text_uri=source,
specific_resource=specific_resource))))
return_graph += resource_annotation_subgraph(project_graph,
specific_resource)
return return_graph
def get_project_graph(project_uri):
"""Returns the database graph used to store general information about the project with the given uri"""
return Graph(store=rdfstore(), identifier=uris.uri('semantic_store_projects', uri=project_uri))
def read_canvas(request, project_uri, canvas_uri):
project_identifier = uris.uri('semantic_store_projects', uri=project_uri)
db_project_graph = Graph(store=rdfstore(), identifier=project_identifier)
return canvas_subgraph(db_project_graph, canvas_uri, project_uri)
