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 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 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)