def get_context_data(self, **kwargs): context = super(NaveDocumentTemplateView, self).get_context_data(**kwargs) absolute_uri = self.request.build_absolute_uri() target_uri = RDFRecord.get_internal_rdf_base_uri(absolute_uri) if "detail/foldout/" in target_uri: slug = self.kwargs.get('slug') record = ElasticSearchRDFRecord(hub_id=slug) graph = record.get_graph_by_id(self.kwargs.get('slug')) if graph is not None: target_uri = record.source_uri else: logger.warn("Unable to find source_uri for slug: {}".format(slug)) else: target_uri = RDFRecord.get_internal_rdf_base_uri(absolute_uri) record = ElasticSearchRDFRecord(hub_id=self.kwargs.get('slug')) graph = record.get_graph_by_source_uri(target_uri) if graph is None: raise UnknownGraph("URI {} is not known in our graph store".format(target_uri)) if "/resource/cache/" in target_uri: target_uri = target_uri.rstrip('/') cache_resource = CacheResource.objects.filter(document_uri=target_uri) if cache_resource.exists(): graph = cache_resource.first().get_graph() elif settings.RDF_USE_LOCAL_GRAPH: mode = self.request.REQUEST.get('mode', 'default') acceptance = True if mode == 'acceptance' else False context['acceptance'] = acceptance elif '/resource/aggregation' in target_uri: target_named_graph = "{}/graph".format(target_uri.rstrip('/')) graph, nr_levels = RDFModel.get_context_graph(store=rdfstore.get_rdfstore(), named_graph=target_named_graph) else: graph, nr_levels = RDFModel.get_context_graph( store=rdfstore.get_rdfstore(), target_uri=target_uri ) # todo: remove: should no longer be necessary with the addition of common.middleware.ForceLangMiddleware language = self.request.GET.get('lang', None) if language: activate(language) bindings = GraphBindings( about_uri=target_uri, graph=graph, excluded_properties=settings.RDF_EXCLUDED_PROPERTIES ) context['resources'] = bindings context['absolute_uri'] = RDFRecord.get_external_rdf_url(target_uri, self.request) for rdf_type in bindings.get_about_resource().get_types(): search_label = rdf_type.search_label.lower() content_template = settings.RDF_CONTENT_FOLDOUTS.get(search_label) if content_template: self.template_name = content_template break context['points'] = RDFModel.get_geo_points(graph) return context
def get(self, request, *args, **kwargs): target_uri = os.path.splitext(request.build_absolute_uri())[0].replace('/data/', '/resource/') if not self.request.path.startswith("/data"): target_uri = re.sub('/[a-z]{2}/resource/', '/resource/', target_uri, count=1) if target_uri.endswith('graph'): target_uri = re.sub("/graph", "", target_uri) extension_ = self.kwargs.get('extension') rdf_format = mime_to_extension(get_lod_mime_type(extension_, self.request)) if rdf_format == "rdf": rdf_format = "xml" resolved_uri = RDFRecord.get_internal_rdf_base_uri(target_uri) if "/resource/cache/" in target_uri: # old lookup rdfstore.get_rdfstore().get_cached_source_uri(target_uri) target_uri = target_uri.split('/resource/cache/')[-1] if 'geonames.org' in target_uri: target_uri = '{}/'.format(target_uri) if CacheResource.objects.filter(document_uri=target_uri).exists(): cache_object = CacheResource.objects.filter(document_uri=target_uri).first() content = cache_object.get_graph().serialize(format=rdf_format) else: raise UnknownGraph("URI {} is not known in our graph store".format(target_uri)) elif settings.RDF_USE_LOCAL_GRAPH: mode = self.request.REQUEST.get('mode', 'default') acceptance = True if mode == 'acceptance' else False local_object = ElasticSearchRDFRecord(source_uri=resolved_uri) local_object.get_graph_by_source_uri(uri=resolved_uri) if not local_object.exists(): # todo: temporary work around for EDMRecords not saved with subjects logger.warn("Unable to find graph for: {}".format(resolved_uri)) raise UnknownGraph("URI {} is not known in our graph store".format(resolved_uri)) mode = self.get_mode(request) if mode in ['context', 'api', 'api-flat']: # get_graph(with_mappings=True, include_mapping_target=True, acceptance=acceptance) content = local_object.get_context_graph(with_mappings=True, include_mapping_target=True) if mode in ['api', 'api-flat']: bindings = GraphBindings(about_uri=resolved_uri, graph=content) index_doc = bindings.to_index_doc() if mode == 'api' else bindings.to_flat_index_doc() content = json.dumps(index_doc) rdf_format = 'json-ld' else: content = content.serialize(format=rdf_format) else: content = local_object.get_graph() content = content.serialize(format=rdf_format) elif self.store.ask(uri=resolved_uri): target_uri = resolved_uri content = self.get_content(target_uri, rdf_format, request) return HttpResponse( content, content_type='{}; charset=utf8'.format(result_extension_to_mime(rdf_format)) )
def get_context_data(self, **kwargs): context = super(NaveDocumentDetailView, self).get_context_data(**kwargs) target_uri = self.object.document_uri if "/resource/cache/" in target_uri: target_uri = target_uri.rstrip('/') cache_resource = CacheResource.objects.filter(document_uri=target_uri) if cache_resource.exists(): graph = cache_resource.first().get_graph() elif settings.RDF_USE_LOCAL_GRAPH: mode = self.request.REQUEST.get('mode', 'default') acceptance = True if mode == 'acceptance' else False context['acceptance'] = acceptance if isinstance(self.object, EDMRecord): graph = self.object.get_graph(with_mappings=True, include_mapping_target=True, acceptance=acceptance) else: graph = self.object.get_graph(acceptance=acceptance) elif '/resource/aggregation' in target_uri: target_named_graph = "{}/graph".format(target_uri.rstrip('/')) graph, nr_levels = RDFModel.get_context_graph(store=rdfstore.get_rdfstore(), named_graph=target_named_graph) else: graph, nr_levels = RDFModel.get_context_graph( store=rdfstore.get_rdfstore(), target_uri=target_uri ) # todo: remove: should no longer be necessary with the addition of common.middleware.ForceLangMiddleware language = self.request.GET.get('lang', None) if language: activate(language) bindings = GraphBindings( about_uri=target_uri, graph=graph, excluded_properties=settings.RDF_EXCLUDED_PROPERTIES ) context['resources'] = bindings for rdf_type in bindings.get_about_resource().get_types(): search_label = rdf_type.search_label.lower() content_template = settings.RDF_CONTENT_FOLDOUTS.get(search_label) if content_template: self.template_name = content_template break context['points'] = RDFModel.get_geo_points(graph) return context
def get_content(self, target_uri, rdf_format, request): if '/resource/aggregation' in target_uri: target_named_graph = "{}/graph".format(target_uri.rstrip('/')) mode = self.get_mode(request, 'graph') describe = self.get_graph(mode=mode, named_graph=target_named_graph) else: mode = self.get_mode(request, "describe") describe = self.get_graph(mode=mode, uri=target_uri) if not describe: logger.warn("Unable to find graph for: {}".format(target_uri)) raise Http404() if mode in ['api', 'api-flat']: bindings = GraphBindings(about_uri=target_uri, graph=describe) index_doc = bindings.to_index_doc() if mode == 'api' else bindings.to_flat_index_doc() content = json.dumps(index_doc) rdf_format = 'json' else: content = describe.serialize(format=rdf_format) return content, rdf_format
def create_es_action(self, action="index", record_type=None, index=settings.SITE_NAME, store=None, doc_type=None, context=True, flat=True, exclude_fields=None, acceptance=False): if doc_type is None: doc_type = self._generate_doc_type() if record_type is None: record_type = self.get_rdf_type() if not store: store = rdfstore.get_rdfstore() if acceptance: index = "{}_acceptance".format(index) if record_type == "http://www.openarchives.org/ore/terms/Aggregation": record_type = "mdr" if action == "delete": return { '_op_type': action, '_index': index, '_type': doc_type, '_id': self.hub_id } graph = None if not context: graph = self.get_graph() else: graph, nr_levels = self.get_context_graph(store=store, named_graph=self.named_graph) graph.namespace_manager = namespace_manager bindings = GraphBindings( about_uri=self.source_uri, graph=graph ) index_doc = bindings.to_flat_index_doc() if flat else bindings.to_index_doc() if exclude_fields: index_doc = {k: v for k, v in index_doc.items() if k not in exclude_fields} # add delving spec for default searchability index_doc["delving_spec"] = [ {'@type': "Literal", 'value': self.get_spec_name(), 'raw': self.get_spec_name(), 'lang': None} ] logger.debug(index_doc) mapping = { '_op_type': action, '_index': index, '_type': doc_type, '_id': self.hub_id, '_source': index_doc } thumbnail = bindings.get_about_thumbnail mapping['_source']['system'] = { 'slug': self.hub_id, 'spec': self.get_spec_name(), 'thumbnail': thumbnail if thumbnail else "", 'preview': "detail/foldout/{}/{}".format(doc_type, self.hub_id), 'caption': bindings.get_about_caption if bindings.get_about_caption else "", 'about_uri': self.document_uri, 'source_uri': self.source_uri, 'graph_name': self.named_graph, 'created_at': datetime.datetime.now().isoformat(), 'modified_at': datetime.datetime.now().isoformat(), 'source_graph': graph.serialize(format='nt', encoding="utf-8").decode(encoding="utf-8"), 'proxy_resource_graph': None, 'web_resource_graph': None, # 'about_type': [rdf_type.qname for rdf_type in bindings.get_about_resource().get_types()] # 'collections': None, todo find a way to add collections via link } data_owner = self.dataset.data_owner if hasattr(self, 'dataset') else None dataset_name = self.dataset.name if hasattr(self, 'dataset') else None mapping['_source']['legacy'] = { 'delving_hubId': self.hub_id, 'delving_recordType': record_type, 'delving_spec': self.get_spec_name(), 'delving_owner': data_owner, 'delving_orgId': settings.ORG_ID, 'delving_collection': dataset_name, 'delving_title': self.get_first_literal(DC.title, graph), 'delving_creator': self.get_first_literal(DC.creator, graph), 'delving_description': self.get_first_literal(DC.description, graph), 'delving_provider': index_doc.get('edm_provider')[0].get('value') if 'edm_provider' in index_doc else None, 'delving_hasGeoHash': "true" if bindings.has_geo() else "false", 'delving_hasDigitalObject': "true" if thumbnail else "false", 'delving_hasLandingePage': "true" if 'edm_isShownAt' in index_doc else "false", 'delving_hasDeepZoom': "true" if 'nave_deepZoom' in index_doc else "false", } return mapping
def get_context_data(self, **kwargs): target_uri = "http://*****:*****@tonsmitshuis.nl" } }, { "thumbnail": "", "deepzoom": "", "mime_type": "audio/wav", "source_uri": "media/189467__speedenza__poem-darkness-voice.wav", "metadata": { "dc_title": "Poem: Darkness (Voice)", "dc_creator": "Speedenza (freesound.org)", "dc_rights": "freesound.org" } }, { "thumbnail": "", "deepzoom": "", "mime_type": "video/mp4", "source_uri": "media/NuclearExplosionwww.keepvid.com.mp4", "metadata": { "dc_title": "Nuclear explosion", "dc_creator": "Oppenheimer", "dc_rights": "Destructive Commons" } } ] # Todo add search results # * build query on uri or property # * add facets from configuration + property facet # * get NaveResponse # * add to context as data return context
def get_context_data(self, **kwargs): # todo later add acceptance mode target_uri = self.request.build_absolute_uri().replace('/page/', '/resource/') if "?" in target_uri: target_uri = re.sub("\?.*$", '', target_uri) # target_uri = target_uri.split('?')[:-1] if not self.request.path.startswith("/page"): target_uri = re.sub('/[a-z]{2}/resource/', '/resource/', target_uri, count=1) if target_uri.endswith('graph'): target_uri = re.sub("/graph$", "", target_uri) context = super(LoDHTMLView, self).get_context_data(**kwargs) # default and test mode mode = self.request.REQUEST.get('mode', 'default') acceptance = True if mode == 'acceptance' else False if not acceptance: acceptance = self.request.COOKIES.get('NAVE_ACCEPTANCE_MODE', False) object_local_cache = None cached = False context['about'] = target_uri context['ugc'] = None if "/resource/cache/" in target_uri: # lookup solution # rdfstore.get_rdfstore().get_cached_source_uri(target_uri) cached = True target_uri = target_uri.split('/resource/cache/')[-1] if target_uri.endswith("about.rdf"): target_uri = re.sub('about.rdf$', '', target_uri) else: target_uri = target_uri.rstrip('/') resolved_uri = RDFRecord.get_internal_rdf_base_uri(target_uri) if UserGeneratedContent.objects.filter(source_uri=resolved_uri).exists(): context['ugc'] = UserGeneratedContent.objects.filter(source_uri=resolved_uri) if settings.RDF_USE_LOCAL_GRAPH: object_local_cache = ElasticSearchRDFRecord(source_uri=resolved_uri) object_local_cache.get_graph_by_source_uri(uri=resolved_uri) if not object_local_cache.exists(): context['source_uri'] = target_uri context['unknown_graph'] = True return context target_uri = resolved_uri elif self.store.ask(uri=resolved_uri): target_uri = resolved_uri context['source_uri'] = target_uri context['about_label'] = target_uri.split('/')[-1] context['about_spec'] = target_uri.split('/')[-2] context['cached'] = cached # special query for skos def is_skos(): return self.store.ask( query="where {{<{subject}> <{predicate}> <{object}>}}".format( subject=target_uri, predicate=RDF.type, object=SKOS.Concept)) if object_local_cache: # todo: add code to retrieve proxyresources # (with_mappings=True, include_mapping_target=True, acceptance=acceptance) graph = object_local_cache.get_context_graph(with_mappings=True, include_mapping_target=True) nr_levels = 4 elif cached: if CacheResource.objects.filter(document_uri=target_uri).exists(): cache_object = CacheResource.objects.filter(document_uri=target_uri).first() graph = cache_object.get_graph() nr_levels = 3 else: context['unknown_graph'] = True return context elif is_skos(): graph, nr_levels = RDFModel.get_skos_context_graph(store=self.store, target_uri=target_uri) # nav_tree = RDFModel.get_nav_tree(target_uri=target_uri, store=self.store) # todo finish the nav tree implementation if 'skos_nav' in self.request.GET: return context elif '/resource/aggregation' in target_uri: target_named_graph = "{}/graph".format(target_uri.rstrip('/')) graph, nr_levels = RDFModel.get_context_graph(store=self.store, named_graph=target_named_graph) else: graph, nr_levels = RDFModel.get_context_graph(target_uri=target_uri, store=self.store) graph_contains_target = graph.query("""ASK {{ <{}> ?p ?o }} """.format(target_uri)).askAnswer if not graph_contains_target or len(graph) == 0: context['unknown_graph'] = True return context if context['about'].endswith('/'): context['about'] = context['about'].rstrip('/') context['graph'] = graph context['nr_levels'] = nr_levels context['namespaces'] = [(prefix, uri) for prefix, uri in graph.namespaces()] graph_bindings = GraphBindings(target_uri, graph, excluded_properties=settings.RDF_EXCLUDED_PROPERTIES) context['skos_links'], context['skos_filter'] = graph_bindings.get_all_skos_links() context['resources'] = graph_bindings resource = graph_bindings.get_about_resource() context['items'] = resource.get_items(as_tuples=True) rdf_type = graph_bindings.get_about_resource().get_type() context['rdf_type'] = rdf_type context['content_template'] = self.get_content_type_template(rdf_type.search_label) context['graph_stats'] = RDFModel.get_graph_statistics(graph) context['alt'] = "" context['points'] = RDFModel.get_geo_points(graph) # DEEPZOOM VALUE(S) zooms = graph_bindings.get_list('nave_deepZoomUrl') if zooms: context['deepzoom_count'] = len(zooms) context['deepzoom_urls'] = [zoom.value for zoom in zooms] # EXPERT MODE expert_mode = self.request.COOKIES.get('NAVE_DETAIL_EXPERT_MODE', False) if expert_mode: # do expert mode stuff like more like this context['expert_mode'] = True if settings.MLT_DETAIL_ENABLE and object_local_cache: context['data'] = {'items': object_local_cache.get_more_like_this()} if settings.MLT_BANNERS and isinstance(settings.MLT_BANNERS, dict) and object_local_cache: from collections import OrderedDict context['data'] = {"mlt_banners": OrderedDict()} for name, config in settings.MLT_BANNERS.items(): mlt_fields = config.get("fields", None) if mlt_fields and any(".raw" in field for field in mlt_fields): # .raw fields don't work with MORE LIKE THIS queries so are # queried directly. context['data']['mlt_banners'][name] = object_local_cache.get_raw_related( query_fields=mlt_fields, filter_query=config.get("filter_query", None), graph_bindings=graph_bindings ) else: context['data']['mlt_banners'][name] = object_local_cache.get_more_like_this( mlt_count=10, mlt_fields=mlt_fields, filter_query=config.get("filter_query", None) ) view_modes = { 'properties': "rdf/_rdf_properties.html" } display_mode = self.request.GET.get('display') if display_mode: self.template_name = view_modes.get(display_mode, self.template_name) return context
def retrieve(self, request, pk=None, format=None, *args, **kwargs): def get_mode(default=None): params = request.GET return params.get('schema', default) self._clean_callback(request) query = NaveESQuery( index_name=self.get_index_name, doc_types=self.doc_types, default_facets=self.facets, cluster_geo=False, size=1, converter=self.get_converter() ) try: query = query.build_item_query(query, request.query_params, pk) except ValueError as ve: logger.error("Unable to build request because: {}".format(ve)) # todo display error message when bad/unknown hubId is given return HttpResponseBadRequest() mlt = True if request.query_params.get('mlt', 'false') == "true" else False mlt_count = int(request.query_params.get('mlt.count', 5)) mlt_filter_queries = request.query_params.getlist('mlt.qf', []) mlt_fq_dict = {} for fq in mlt_filter_queries: if ":" in fq: k, v = fq.split(":", maxsplit=1) mlt_fq_dict[k] = v record = ElasticSearchRDFRecord(hub_id=pk) record.get_graph_by_id(hub_id=pk) response = NaveItemResponse( query, self, index=self.get_index_name, mlt=mlt, mlt_count=mlt_count, mlt_filter_query=mlt_fq_dict, rdf_record=record ) renderer_format = request.accepted_renderer.format if renderer_format in list(EXTENSION_TO_MIME_TYPE.keys()) and renderer_format not in ['xml', 'json']: graph = record.get_graph() graph_string = graph.serialize(format=renderer_format).decode('utf-8') mime_type = EXTENSION_TO_MIME_TYPE.get(renderer_format) return Response(data=graph_string, content_type=mime_type) target_uri = record.document_uri if settings.RDF_USE_LOCAL_GRAPH: graph = record.get_graph() else: store = rdfstore.get_rdfstore() graph, _ = RDFModel.get_context_graph(store, named_graph=record.named_graph) if not graph: from django.http import HttpResponseNotFound return HttpResponseNotFound() mode = get_mode(self.default_converter) bindings = GraphBindings(about_uri=target_uri, graph=graph) delving_fields = False if request.GET.get("delving_fields") == 'false' else True converter = None if mode in ['api', 'api-flat']: index_doc = bindings.to_index_doc() if mode == 'api' else bindings.to_flat_index_doc() elif mode in REGISTERED_CONVERTERS.keys(): converter = REGISTERED_CONVERTERS.get(mode) index_doc = converter( bindings=bindings, graph=graph, about_uri=bindings.about_uri() ).convert(add_delving_fields=delving_fields) elif self.default_converter in REGISTERED_CONVERTERS.keys(): converter = REGISTERED_CONVERTERS.get(self.default_converter) index_doc = converter( bindings=bindings, graph=graph, about_uri=bindings.about_uri() ).convert(add_delving_fields=delving_fields) else: logger.warn("unable to convert results to schema {}".format(mode)) index_doc = bindings.to_index_doc() layout_fields = OrderedDict() layout_fields['layout'] = converter().get_layout_fields() if converter else [] if response.get_mlt(): mlt = {"item": [NaveESItemSerializer(item).data for item in response.get_mlt()]} else: mlt = "" result = {'result': { 'layout': layout_fields, 'item': {'fields': index_doc}, "relatedItems": mlt}} return Response(result)