def document_detail(request, docid): """ The view that show details of each document """ document = get_object_or_404(Document, pk=docid) if not request.user.has_perm( 'view_resourcebase', obj=document.get_self_resource()): return HttpResponse( loader.render_to_string( '401.html', RequestContext( request, { 'error_message': _("You are not allowed to view this document.")})), status=403) try: related = document.content_type.get_object_for_this_type( id=document.object_id) except: related = '' document.popular_count += 1 document.save() all_perms=ast.literal_eval(_perms_info_json(document)) user = request.user.username if request.user.is_authenticated() else get_anonymous_user().username perms_dict=all_perms['users'][user] return render_to_response( "documents/document_detail.html", RequestContext( request, { 'permissions_json': _perms_info_json(document), 'resource': document, 'imgtypes': IMGTYPES, 'related': related, 'perms_dict': perms_dict}))
def map_detail(request, mapid, snapshot=None, template='maps/map_detail.html'): ''' The view that show details of each map ''' map_obj = _resolve_map(request, mapid, 'base.view_resourcebase', _PERMISSION_MSG_VIEW) # Update count for popularity ranking, # but do not includes admins or resource owners if request.user != map_obj.owner and not request.user.is_superuser: Map.objects.filter(id=map_obj.id).update(popular_count=F('popular_count') + 1) if snapshot is None: config = map_obj.viewer_json(request.user) else: config = snapshot_config(snapshot, map_obj, request.user) config = json.dumps(config) layers = MapLayer.objects.filter(map=map_obj.id) context_dict = { 'config': config, 'resource': map_obj, 'layers': layers, 'perms_list': get_perms(request.user, map_obj.get_self_resource()), 'permissions_json': _perms_info_json(map_obj), "documents": get_related_documents(map_obj), } if settings.SOCIAL_ORIGINS: context_dict["social_links"] = build_social_links(request, map_obj) return render_to_response(template, RequestContext(request, context_dict))
def sync_geonode_layers(ignore_errors, filter, username): layers = Layer.objects.all().order_by('name') if filter: layers = layers.filter(name__icontains=filter) if username: layers = layers.filter(owner__username=username) layers_count = layers.count() count = 0 layer_errors = [] for layer in layers: try: count += 1 print 'Syncing layer %s/%s: %s' % (count, layers_count, layer.name) # sync permissions in GeoFence perm_spec = json.loads(_perms_info_json(layer)) layer.set_permissions(perm_spec) # recalculate the layer statistics set_attributes_from_geoserver(layer, overwrite=True) layer.save() except Exception: layer_errors.append(layer.alternate) exception_type, error, traceback = sys.exc_info() print exception_type, error, traceback if ignore_errors: pass else: print 'Stopping process because --ignore-errors was not set and an error was found.' return print 'There are %s layers which could not be updated because of errors' % len( layer_errors) for layer_error in layer_errors: print layer_error
def sync_geonode_layers(ignore_errors, filter, username): layers = Layer.objects.all().order_by('name') if filter: layers = layers.filter(name__icontains=filter) if username: layers = layers.filter(owner__username=username) layers_count = layers.count() count = 0 layer_errors = [] for layer in layers: try: count += 1 print 'Syncing layer %s/%s: %s' % (count, layers_count, layer.name) # sync permissions in GeoFence perm_spec = json.loads(_perms_info_json(layer)) layer.set_permissions(perm_spec) # recalculate the layer statistics set_attributes_from_geoserver(layer, overwrite=True) layer.save() except Exception: layer_errors.append(layer.alternate) exception_type, error, traceback = sys.exc_info() print exception_type, error, traceback if ignore_errors: pass else: print 'Stopping process because --ignore-errors was not set and an error was found.' return print 'There are %s layers which could not be updated because of errors' % len(layer_errors) for layer_error in layer_errors: print layer_error
def map_detail(request, mapid, snapshot=None, template='maps/map_detail.html'): ''' The view that show details of each map ''' map_obj = _resolve_map(request, mapid, 'base.view_resourcebase', _PERMISSION_MSG_VIEW) # Update count for popularity ranking, # but do not includes admins or resource owners if request.user != map_obj.owner and not request.user.is_superuser: Map.objects.filter(id=map_obj.id).update(popular_count=F('popular_count') + 1) if snapshot is None: config = map_obj.viewer_json(request.user) else: config = snapshot_config(snapshot, map_obj, request.user) config = json.dumps(config) layers = MapLayer.objects.filter(map=map_obj.id) if request.method == "POST": if 'keywords' in request.POST: keywords_form = KeywordsForm(request.POST, instance=map_obj) if keywords_form.is_valid(): keywords_form.save() new_keywords = keywords_form.cleaned_data['keywords'] map_obj.keywords.set(*new_keywords) map_obj.save() published_form = PublishStatusForm(instance=map_obj) elif 'published_submit_btn' in request.POST: published_form = PublishStatusForm(request.POST, instance=map_obj) if published_form.is_valid(): published_form.save() map_obj.is_published = published_form.cleaned_data['is_published'] map_obj.save() keywords_form = KeywordsForm(instance=map_obj) elif 'add_keyword' in request.POST: map_obj.keywords.add(request.POST['add_keyword']) map_obj.save() elif 'remove_keyword' in request.POST: map_obj.keywords.remove(request.POST['remove_keyword']) map_obj.save() else: keywords_form = KeywordsForm(instance=map_obj) published_form = PublishStatusForm(instance=map_obj) context_dict = { 'config': config, 'resource': map_obj, 'layers': layers, 'permissions_json': _perms_info_json(map_obj), "documents": get_related_documents(map_obj), "keywords_form": keywords_form, "published_form": published_form, } if settings.SOCIAL_ORIGINS: context_dict["social_links"] = build_social_links(request, map_obj) return render_to_response(template, RequestContext(request, context_dict))
def layer_detail(request, layername, template='layers/layer_detail.html'): layer = _resolve_layer(request, layername, 'layers.view_layer', _PERMISSION_MSG_VIEW) maplayer = GXPLayer(name=layer.typename, ows_url=settings.GEOSERVER_BASE_URL + "wms", layer_params=json.dumps(layer.attribute_config())) layer.srid_url = "http://www.spatialreference.org/ref/" + layer.srid.replace( ':', '/').lower() + "/" #layer.popular_count += 1 #layer.save() # center/zoom don't matter; the viewer will center on the layer bounds map_obj = GXPMap(projection="EPSG:900913") DEFAULT_BASE_LAYERS = default_map_config()[1] return render_to_response( template, RequestContext( request, { "layer": layer, "viewer": json.dumps( map_obj.viewer_json(*(DEFAULT_BASE_LAYERS + [maplayer]))), "permissions_json": _perms_info_json(layer, LAYER_LEV_NAMES), "documents": get_related_documents(layer), }))
def geoapp_edit(request, geoappid, template='apps/app_edit.html'): """ The view that returns the app composer opened to the app with the given app ID. """ try: geoapp_obj = _resolve_geoapp( request, geoappid, 'base.view_resourcebase', _PERMISSION_MSG_VIEW) except PermissionDenied: return HttpResponse(_("Not allowed"), status=403) except Exception: raise Http404(_("Not found")) if not geoapp_obj: raise Http404(_("Not found")) # Call this first in order to be sure "perms_list" is correct permissions_json = _perms_info_json(geoapp_obj) perms_list = list( geoapp_obj.get_self_resource().get_user_perms(request.user) .union(geoapp_obj.get_user_perms(request.user)) ) group = None if geoapp_obj.group: try: group = GroupProfile.objects.get(slug=geoapp_obj.group.name) except GroupProfile.DoesNotExist: group = None access_token = None if request and request.user: access_token = get_or_create_token(request.user) if access_token and not access_token.is_expired(): access_token = access_token.token else: access_token = None _data = GeoAppData.objects.filter(resource__id=geoappid).first() _config = _data.blob if _data else {} _ctx = { 'appId': geoappid, 'appType': geoapp_obj.type, 'config': _config, 'user': request.user, 'access_token': access_token, 'resource': geoapp_obj, 'group': group, 'perms_list': perms_list, "permissions_json": permissions_json, 'preview': getattr( settings, 'GEONODE_CLIENT_LAYER_PREVIEW_LIBRARY', 'mapstore') } return render(request, template, context=_ctx)
def layer_detail(request, layername, template='layers/layer_detail.html'): layer = _resolve_layer(request, layername, 'layers.view_layer', _PERMISSION_MSG_VIEW) maplayer = GXPLayer(name = layer.typename, ows_url = ogc_server_settings.public_url + "wms", layer_params=json.dumps( layer.attribute_config())) layer.srid_url = "http://www.spatialreference.org/ref/" + layer.srid.replace(':','/').lower() + "/" signals.pre_save.disconnect(geoserver_pre_save, sender=Layer) signals.post_save.disconnect(geoserver_post_save, sender=Layer) layer.popular_count += 1 layer.save() signals.pre_save.connect(geoserver_pre_save, sender=Layer) signals.post_save.connect(geoserver_post_save, sender=Layer) # center/zoom don't matter; the viewer will center on the layer bounds map_obj = GXPMap(projection="EPSG:900913") DEFAULT_BASE_LAYERS = default_map_config()[1] if layer.storeType=='dataStore': links = layer.link_set.download().filter( name__in=settings.DOWNLOAD_FORMATS_VECTOR) else: links = layer.link_set.download().filter( name__in=settings.DOWNLOAD_FORMATS_RASTER) metadata = layer.link_set.metadata().filter( name__in=settings.DOWNLOAD_FORMATS_METADATA) return render_to_response(template, RequestContext(request, { "layer": layer, "viewer": json.dumps(map_obj.viewer_json(* (DEFAULT_BASE_LAYERS + [maplayer]))), "permissions_json": _perms_info_json(layer, LAYER_LEV_NAMES), "documents": get_related_documents(layer), "links": links, "metadata": metadata, }))
def map_detail(request, mapid, snapshot=None, template='maps/map_detail.html'): ''' The view that show details of each map ''' map_obj = _resolve_map( request, mapid, 'base.view_resourcebase', _PERMISSION_MSG_VIEW) # Update count for popularity ranking, # but do not includes admins or resource owners if request.user != map_obj.owner and not request.user.is_superuser: Map.objects.filter( id=map_obj.id).update( popular_count=F('popular_count') + 1) if 'access_token' in request.session: access_token = request.session['access_token'] else: access_token = None if snapshot is None: config = map_obj.viewer_json(request.user, access_token) else: config = snapshot_config(snapshot, map_obj, request.user, access_token) config = json.dumps(config) layers = MapLayer.objects.filter(map=map_obj.id) group = None if map_obj.group: try: group = GroupProfile.objects.get(slug=map_obj.group.name) except GroupProfile.DoesNotExist: group = None context_dict = { 'config': config, 'resource': map_obj, 'group': group, 'layers': layers, 'perms_list': get_perms(request.user, map_obj.get_self_resource()), 'permissions_json': _perms_info_json(map_obj), "documents": get_related_documents(map_obj), } context_dict["preview"] = getattr( settings, 'LAYER_PREVIEW_LIBRARY', '') context_dict["crs"] = getattr( settings, 'DEFAULT_MAP_CRS', 'EPSG:900913') if settings.SOCIAL_ORIGINS: context_dict["social_links"] = build_social_links(request, map_obj) return render_to_response(template, RequestContext(request, context_dict))
def collection_permissions(request, collection_id): collection = _resolve_collection(request, collection_id) if request.method == 'POST': permission_spec = json.loads(request.body) collection.set_permissions(permission_spec) return HttpResponse( json.dumps({'success': True}), status=200, content_type='text/plain' ) elif request.method == 'GET': permission_spec = _perms_info_json(resource) return HttpResponse( json.dumps({'success': True, 'permissions': permission_spec}), status=200, content_type='text/plain' ) else: return HttpResponse( 'No methods other than get and post are allowed', status=401, content_type='text/plain')
def document_detail(request, docid): """ The view that show details of each document """ document = get_object_or_404(Document, pk=docid) if not request.user.has_perm( 'view_resourcebase', obj=document.get_self_resource()): return HttpResponse( loader.render_to_string( '401.html', RequestContext( request, { 'error_message': _("You are not allowed to view this document.")})), status=403) try: related = document.content_type.get_object_for_this_type( id=document.object_id) except: related = '' Document.objects.filter(id=document.id).update(popular_count=F('popular_count') + 1) return render_to_response( "documents/document_detail.html", RequestContext( request, { 'permissions_json': _perms_info_json(document), 'resource': document, 'imgtypes': IMGTYPES, 'related': related}))
def document_detail(request, docid): """ The view that show details of each document """ document = get_object_or_404(Document, pk=docid) if not request.user.has_perm('view_resourcebase', obj=document.get_self_resource()): return HttpResponse(loader.render_to_string( '401.html', RequestContext(request, { 'error_message': _("You are not allowed to view this document.") })), status=403) try: related = document.content_type.get_object_for_this_type( id=document.object_id) except: related = '' document.popular_count += 1 document.save() return render_to_response( "documents/document_detail.html", RequestContext( request, { 'permissions_json': _perms_info_json(document), 'resource': document, 'imgtypes': IMGTYPES, 'related': related }))
def map_detail(request, mapid, snapshot=None, template='maps/map_detail.html'): ''' The view that show details of each map ''' map_obj = _resolve_map( request, mapid, 'base.view_resourcebase', _PERMISSION_MSG_VIEW) # Update count for popularity ranking, # but do not includes admins or resource owners if request.user != map_obj.owner and not request.user.is_superuser: Map.objects.filter( id=map_obj.id).update( popular_count=F('popular_count') + 1) if snapshot is None: config = map_obj.viewer_json(request) else: config = snapshot_config(snapshot, map_obj, request) config = json.dumps(config) layers = MapLayer.objects.filter(map=map_obj.id) links = map_obj.link_set.download() group = None if map_obj.group: try: group = GroupProfile.objects.get(slug=map_obj.group.name) except GroupProfile.DoesNotExist: group = None context_dict = { 'config': config, 'resource': map_obj, 'group': group, 'layers': layers, 'perms_list': get_perms(request.user, map_obj.get_self_resource()), 'permissions_json': _perms_info_json(map_obj), "documents": get_related_documents(map_obj), 'links': links, 'preview': getattr( settings, 'GEONODE_CLIENT_LAYER_PREVIEW_LIBRARY', 'geoext'), 'crs': getattr( settings, 'DEFAULT_MAP_CRS', 'EPSG:3857') } if settings.SOCIAL_ORIGINS: context_dict["social_links"] = build_social_links(request, map_obj) if request.user.is_authenticated(): if getattr(settings, 'FAVORITE_ENABLED', False): from geonode.favorite.utils import get_favorite_info context_dict["favorite_info"] = get_favorite_info(request.user, map_obj) return render(request, template, context=context_dict)
def map_detail(request, mapid, snapshot=None, template='maps/map_detail.html'): ''' The view that show details of each map ''' map_obj = _resolve_map(request, mapid, 'base.view_resourcebase', _PERMISSION_MSG_VIEW) # Update count for popularity ranking, # but do not includes admins or resource owners if request.user != map_obj.owner and not request.user.is_superuser: Map.objects.filter(id=map_obj.id).update( popular_count=F('popular_count') + 1) if snapshot is None: config = map_obj.viewer_json(request.user) else: config = snapshot_config(snapshot, map_obj, request.user) config = json.dumps(config) layers = MapLayer.objects.filter(map=map_obj.id) context_dict = { 'config': config, 'resource': map_obj, 'layers': layers, 'perms_list': get_perms(request.user, map_obj.get_self_resource()), 'permissions_json': _perms_info_json(map_obj), "documents": get_related_documents(map_obj), } if settings.SOCIAL_ORIGINS: context_dict["social_links"] = build_social_links(request, map_obj) return render_to_response(template, RequestContext(request, context_dict))
def map_detail(request, mapid, snapshot=None, template='maps/map_detail.html'): ''' The view that show details of each map ''' map_obj = _resolve_map(request, mapid, 'base.view_resourcebase', _PERMISSION_MSG_VIEW) if request.user != map_obj.owner: Map.objects.filter(id=map_obj.id).update( popular_count=F('popular_count') + 1) if snapshot is None: config = map_obj.viewer_json(request.user) else: config = snapshot_config(snapshot, map_obj, request.user) config = json.dumps(config) layers = MapLayer.objects.filter(map=map_obj.id) return render_to_response( template, RequestContext( request, { 'config': config, 'resource': map_obj, 'layers': layers, 'permissions_json': _perms_info_json(map_obj), "documents": get_related_documents(map_obj), }))
def map_detail(request, mapid, snapshot=None, template='maps/map_detail.html'): ''' The view that show details of each map ''' if not mapid.isdigit(): map_obj = _resolve_map_custom(request, mapid, 'urlsuffix', 'base.view_resourcebase', _PERMISSION_MSG_VIEW) else: map_obj = _resolve_map(request, mapid, 'base.view_resourcebase', _PERMISSION_MSG_VIEW) map_obj.popular_count += 1 map_obj.save() if snapshot is None: config = map_obj.viewer_json(request.user) else: config = snapshot_config(snapshot, map_obj, request.user) config = json.dumps(config) layers = MapLayer.objects.filter(map=map_obj.id) return render_to_response( template, RequestContext( request, { 'config': config, 'resource': map_obj, 'layers': layers, 'permissions_json': _perms_info_json(map_obj), "documents": get_related_documents(map_obj), }))
def map_detail(request, mapid, snapshot = None, template='maps/map_detail.html'): ''' The view that show details of each map ''' if not mapid.isdigit(): map_obj = _resolve_map_custom(request, mapid, 'urlsuffix', 'base.view_resourcebase', _PERMISSION_MSG_VIEW) else: map_obj = _resolve_map(request, mapid, 'base.view_resourcebase', _PERMISSION_MSG_VIEW) map_obj.popular_count += 1 map_obj.save() if snapshot is None: config = map_obj.viewer_json(request.user) else: config = snapshot_config(snapshot, map_obj, request.user) config = json.dumps(config) layers = MapLayer.objects.filter(map=map_obj.id) return render_to_response(template, RequestContext(request, { 'config': config, 'resource': map_obj, 'layers': layers, 'permissions_json': _perms_info_json(map_obj), "documents": get_related_documents(map_obj), }))
def appinstance_detail(request, appinstanceid): """ The view that show details of each document """ appinstance = None try: appinstance = resolve_appinstance(request, appinstanceid, 'base.view_resourcebase', PERMISSION_MSG_VIEW) except Http404: return render(request, '404.html', context={}, status=404) except PermissionDenied: return render(request, '401.html', context={ 'error_message': _("You are not allowed to view this document.") }, status=403) if appinstance is None: return HttpResponse('An unknown error has occured.', mimetype="text/plain", status=401) else: if request.user != appinstance.owner and not request.user.is_superuser: AppInstance.objects.filter(id=appinstance.id).update( popular_count=F('popular_count') + 1) set_thumbnail_link = appinstance.link_set.filter( link_type='appinstance_thumbnail') context_dict = { 'perms_list': get_perms(request.user, appinstance.get_self_resource()), 'permissions_json': _perms_info_json(appinstance), 'resource': appinstance, # 'appinstance_links': appinstance_links, 'set_thumbnail_link': set_thumbnail_link # 'imgtypes': IMGTYPES, # 'related': related } if settings.SOCIAL_ORIGINS: context_dict["social_links"] = build_social_links( request, appinstance) if getattr(settings, 'EXIF_ENABLED', False): try: from geonode.contrib.exif.utils import exif_extract_dict exif = exif_extract_dict(appinstance) if exif: context_dict['exif_data'] = exif except BaseException as e: logger.error(e.args[0] + "Exif extraction failed.") return render(request, "app_manager/appinstance_detail.html", context=context_dict)
def publish(self, layername): resource = gs_catalog.get_resource(layername, store=self.store, workspace=self.workspace) if not resource: raise Exception("Cannot Find Layer In Geoserver") name = resource.name logger.error(resource.__dict__) the_store = resource.store workspace = the_store.workspace layer = None try: logger.warning("=========> Creating the Layer in Django") layer, created = Layer.objects.get_or_create( name=name, workspace=workspace.name, defaults={ "store": the_store.name, "storeType": the_store.resource_type, "alternate": "%s:%s" % (workspace.name, resource.name), "title": (resource.title or 'No title provided'), "abstract": (resource.abstract or _('No abstract provided')), "owner": self.owner, "uuid": str(uuid.uuid4()), "bbox_x0": Decimal(resource.native_bbox[0]), "bbox_x1": Decimal(resource.native_bbox[1]), "bbox_y0": Decimal(resource.native_bbox[2]), "bbox_y1": Decimal(resource.native_bbox[3]), "srid": resource.projection }) logger.warning("=========> Settting permissions") # sync permissions in GeoFence perm_spec = json.loads(_perms_info_json(layer)) layer.set_permissions(perm_spec) logger.warning("=========> Settting Attributes") # recalculate the layer statistics set_attributes_from_geoserver(layer, overwrite=True) layer.save() logger.warning("=========> Fixing Metadata Links") # Fix metadata links if the ip has changed if layer.link_set.metadata().count() > 0: if not created and settings.SITEURL \ not in layer.link_set.metadata()[0].url: layer.link_set.metadata().delete() layer.save() metadata_links = [] for link in layer.link_set.metadata(): metadata_links.append((link.mime, link.name, link.url)) resource.metadata_links = metadata_links gs_catalog.save(resource) except Exception as e: logger.error(e.message) exception_type, error, traceback = sys.exc_info() else: if layer: layer.set_default_permissions() return layer
def document_detail(request, docid): """ The view that show details of each document """ document = None try: document = _resolve_document(request, docid, 'base.view_resourcebase', _PERMISSION_MSG_VIEW) except Http404: return HttpResponse(loader.render_to_string( '404.html', RequestContext(request, {})), status=404) except PermissionDenied: return HttpResponse(loader.render_to_string( '401.html', RequestContext(request, { 'error_message': _("You are not allowed to view this document.") })), status=403) if document is None: return HttpResponse('An unknown error has occured.', mimetype="text/plain", status=401) else: try: related = document.content_type.get_object_for_this_type( id=document.object_id) except: related = '' # Update count for popularity ranking, # but do not includes admins or resource owners if request.user != document.owner and not request.user.is_superuser: Document.objects.filter(id=document.id).update( popular_count=F('popular_count') + 1) metadata = document.link_set.metadata().filter( name__in=settings.DOWNLOAD_FORMATS_METADATA) context_dict = { 'permissions_json': _perms_info_json(document), 'resource': document, 'metadata': metadata, 'imgtypes': IMGTYPES, 'related': related } if settings.SOCIAL_ORIGINS: context_dict["social_links"] = build_social_links( request, document) return render_to_response("documents/document_detail.html", RequestContext(request, context_dict))
def get_layer_config(request, typename, permission='base.view_resourcebase', msg=_PERMISSION_GENERIC, **kwargs): try: layer = _resolve_layer(request, typename, "base.view_resourcebase", _PERMISSION_VIEW ) except Exception as e: pprint("Error on resolving layer") pprint("Message: "+ e.message + "/nType: "+str(type(e))) config = layer.attribute_config() layer_bbox = layer.bbox bbox = [float(coord) for coord in list(layer_bbox[0:4])] srid = layer.srid config["srs"] = srid if srid != "EPSG:4326" else "EPSG:900913" config["bbox"] = llbbox_to_mercator([float(coord) for coord in bbox]) config["title"] = layer.title config["queryable"] = True if layer.storeType == "remoteStore": service = layer.service source_params = { "ptype": service.ptype, "remote": True, "url": service.base_url, "name": service.name} maplayer = GXPLayer( name=layer.typename, ows_url=layer.ows_url, layer_params=json.dumps(config), source_params=json.dumps(source_params)) else: maplayer = GXPLayer( name=layer.typename, ows_url=layer.ows_url, layer_params=json.dumps(config)) map_obj = GXPMap(projection="EPSG:900913") NON_WMS_BASE_LAYERS = [ la for la in default_map_config()[1] if la.ows_url is None] metadata = layer.link_set.metadata().filter( name__in=settings.DOWNLOAD_FORMATS_METADATA) context_dict = { "resource": layer, "permissions_json": _perms_info_json(layer), "metadata": metadata, "is_layer": True, "wps_enabled": settings.OGC_SERVER['default']['WPS_ENABLED'], } context_dict["viewer"] = json.dumps( map_obj.viewer_json(request.user, * (NON_WMS_BASE_LAYERS + [maplayer]))) return context_dict
def map_detail(request, mapid, snapshot=None, template='maps/map_detail.html'): ''' The view that show details of each map ''' map_obj = _resolve_map( request, mapid, 'base.view_resourcebase', _PERMISSION_MSG_VIEW) # Update count for popularity ranking, # but do not includes admins or resource owners if request.user != map_obj.owner and not request.user.is_superuser: Map.objects.filter( id=map_obj.id).update( popular_count=F('popular_count') + 1) savematrix(request=request, action='Map View Detail', resource=map_obj) if snapshot is None: config = map_obj.viewer_json(request) else: config = snapshot_config(snapshot, map_obj, request) config = json.dumps(config) layers = MapLayer.objects.filter(map=map_obj.id) links = map_obj.link_set.download() group = None if map_obj.group: try: group = GroupProfile.objects.get(slug=map_obj.group.name) except GroupProfile.DoesNotExist: group = None context_dict = { 'config': config, 'resource': map_obj, 'group': group, 'layers': layers, 'perms_list': get_perms(request.user, map_obj.get_self_resource()), 'permissions_json': _perms_info_json(map_obj), "documents": get_related_documents(map_obj), 'links': links, 'preview': getattr( settings, 'GEONODE_CLIENT_LAYER_PREVIEW_LIBRARY', 'geoext'), 'crs': getattr( settings, 'DEFAULT_MAP_CRS', 'EPSG:3857') } if settings.SOCIAL_ORIGINS: context_dict["social_links"] = build_social_links(request, map_obj) return render(request, template, context=context_dict)
def layer_detail(request, layername, template='layers/layer_detail.html'): layer = _resolve_layer(request, layername, 'layers.view_layer', _PERMISSION_MSG_VIEW) config = layer.attribute_config() if layer.storeType == "remoteStore" and "geonode.contrib.services" in settings.INSTALLED_APPS: from geonode.contrib.services.models import Service service = Service.objects.filter(layers__id=layer.id)[0] source_params = { "ptype": service.ptype, "remote": True, "url": service.base_url, "name": service.name } maplayer = GXPLayer(name=layer.typename, ows_url=layer.ows_url, layer_params=json.dumps(config), source_params=json.dumps(source_params)) else: maplayer = GXPLayer(name=layer.typename, ows_url=layer.ows_url, layer_params=json.dumps(config)) # Update count for popularity ranking. Layer.objects.filter(id=layer.id).update( popular_count=layer.popular_count + 1) # center/zoom don't matter; the viewer will center on the layer bounds map_obj = GXPMap(projection="EPSG:900913") NON_WMS_BASE_LAYERS = [ la for la in default_map_config()[1] if la.ows_url is None ] metadata = layer.link_set.metadata().filter( name__in=settings.DOWNLOAD_FORMATS_METADATA) context_dict = { "layer": layer, "permissions_json": _perms_info_json(layer, LAYER_LEV_NAMES), "documents": get_related_documents(layer), "metadata": metadata, } context_dict["viewer"] = json.dumps( map_obj.viewer_json(*(NON_WMS_BASE_LAYERS + [maplayer]))) if layer.storeType == 'dataStore': links = layer.link_set.download().filter( name__in=settings.DOWNLOAD_FORMATS_VECTOR) else: links = layer.link_set.download().filter( name__in=settings.DOWNLOAD_FORMATS_RASTER) context_dict["links"] = links return render_to_response(template, RequestContext(request, context_dict))
def harvest_resources_handle_get(request, service, handler): available_resources = handler.get_resources() is_sync = getattr(settings, "CELERY_TASK_ALWAYS_EAGER", False) errored_state = False _ = _perms_info_json(service) perms_list = list(service.get_self_resource().get_user_perms( request.user).union(service.get_user_perms(request.user))) already_harvested = HarvestJob.objects.values_list( "resource_id", flat=True).filter(service=service, status=enumerations.PROCESSED) if available_resources: not_yet_harvested = [ r for r in available_resources if str(r.id) not in already_harvested ] not_yet_harvested.sort(key=lambda resource: resource.id) else: not_yet_harvested = ['Cannot parse any resource at this time!'] errored_state = True paginator = Paginator(not_yet_harvested, getattr(settings, "CLIENT_RESULTS_LIMIT", 100)) page = request.GET.get('page') try: harvestable_resources = paginator.page(page) except PageNotAnInteger: harvestable_resources = paginator.page(1) except EmptyPage: harvestable_resources = paginator.page(paginator.num_pages) filter_row = [{}, { "id": 'id-filter', "data_key": "id" }, { "id": 'name-filter', "data_key": "title" }, { "id": 'desc-filter', "data_key": "abstract" }] result = render( request, "services/service_resources_harvest.html", { "service_handler": handler, "service": service, "importable": not_yet_harvested, "resources": harvestable_resources, "requested": request.GET.getlist("resource_list"), "is_sync": is_sync, "errored_state": errored_state, "can_add_resources": request.user.has_perm('base.add_resourcebase'), "filter_row": filter_row, "permissions_list": perms_list }) return result
def smap_detail(request, smapid): """ The view that show details of each smap """ smap = None try: smap = _resolve_smap( request, smapid, 'base.change_resourcebase', _PERMISSION_MSG_METADATA) except Http404: return HttpResponse( loader.render_to_string( '404.html', RequestContext( request, { })), status=404) except PermissionDenied: return HttpResponse( loader.render_to_string( '401.html', RequestContext( request, { 'error_message': _("You are not allowed to view this smap.")})), status=403) if smap is None: return HttpResponse( 'An unknown error has occured.', mimetype="text/plain", status=401 ) else: try: related = smap.content_type.get_object_for_this_type( id=smap.object_id) except: related = '' # Update count for popularity ranking, # but do not includes admins or resource owners if request.user != smap.owner and not request.user.is_superuser: StaticMap.objects.filter(id=smap.id).update(popular_count=F('popular_count') + 1) return render_to_response( "smap_detail.html", RequestContext( request, { 'permissions_json': _perms_info_json(smap), 'resource': smap, 'imgtypes': IMGTYPES, 'related': related}))
def map_detail(request, mapid, snapshot=None, template='maps/map_detail.html'): ''' The view that show details of each map ''' map_obj = _resolve_map(request, mapid, 'base.view_resourcebase', _PERMISSION_MSG_VIEW) # Update count for popularity ranking, # but do not includes admins or resource owners if request.user != map_obj.owner and not request.user.is_superuser: Map.objects.filter(id=map_obj.id).update( popular_count=F('popular_count') + 1) if snapshot is None: config = map_obj.viewer_json(request.user) else: config = snapshot_config(snapshot, map_obj, request.user) config = json.dumps(config) layers = MapLayer.objects.filter(map=map_obj.id) if request.method == "POST": keywords_form = KeywordsForm(request.POST, instance=map_obj) published_form = PublishStatusForm(request.POST, instance=map_obj) if published_form.is_valid(): map_obj.is_published = published_form.cleaned_data['is_published'] map_obj.save() if keywords_form.is_valid(): new_keywords = keywords_form.cleaned_data['keywords'] map_obj.keywords.clear() map_obj.keywords.add(*new_keywords) map_obj.save() return HttpResponseRedirect( reverse('map_detail', args=(map_obj.id, ))) else: keywords_form = KeywordsForm(instance=map_obj) published_form = PublishStatusForm(instance=map_obj) context_dict = { 'config': config, 'resource': map_obj, 'layers': layers, 'permissions_json': _perms_info_json(map_obj), "documents": get_related_documents(map_obj), "keywords_form": keywords_form, "published_form": published_form, } if settings.SOCIAL_ORIGINS: context_dict["social_links"] = build_social_links(request, map_obj) return render_to_response(template, RequestContext(request, context_dict))
def layer_detail(request, layername, template='layers/layer_detail.html'): layer = _resolve_layer(request, layername, 'base.view_resourcebase', _PERMISSION_MSG_VIEW) layer_bbox = layer.bbox # assert False, str(layer_bbox) bbox = list(layer_bbox[0:4]) config = layer.attribute_config() #Add required parameters for GXP lazy-loading config["srs"] = layer.srid config["title"] = layer.title config["bbox"] = [float(coord) for coord in bbox] \ if layer.srid == "EPSG:4326" else llbbox_to_mercator([float(coord) for coord in bbox]) if layer.storeType == "remoteStore": service = layer.service source_params = {"ptype":service.ptype, "remote": True, "url": service.base_url, "name": service.name} maplayer = GXPLayer(name = layer.typename, ows_url = layer.ows_url, layer_params=json.dumps( config), source_params=json.dumps(source_params)) else: maplayer = GXPLayer(name = layer.typename, ows_url = layer.ows_url, layer_params=json.dumps( config)) # Update count for popularity ranking. Layer.objects.filter(id=layer.id).update(popular_count=layer.popular_count +1) # center/zoom don't matter; the viewer will center on the layer bounds map_obj = GXPMap(projection="EPSG:900913") NON_WMS_BASE_LAYERS = [la for la in default_map_config()[1] if la.ows_url is None] metadata = layer.link_set.metadata().filter( name__in=settings.DOWNLOAD_FORMATS_METADATA) context_dict = { "resource": layer, "permissions_json": _perms_info_json(layer), "documents": get_related_documents(layer), "metadata": metadata, } context_dict["viewer"] = json.dumps(map_obj.viewer_json(request.user, * (NON_WMS_BASE_LAYERS + [maplayer]))) context_dict["preview"] = getattr(settings, 'LAYER_PREVIEW_LIBRARY', 'leaflet') if layer.storeType=='dataStore': links = layer.link_set.download().filter( name__in=settings.DOWNLOAD_FORMATS_VECTOR) else: links = layer.link_set.download().filter( name__in=settings.DOWNLOAD_FORMATS_RASTER) context_dict["links"] = links return render_to_response(template, RequestContext(request, context_dict))
def sync_geonode_layers(ignore_errors, filter, username, removeduplicates, updatepermissions, updatethumbnails, updateattributes, updatebbox): layers = Layer.objects.all().order_by('name') if filter: layers = layers.filter(name__icontains=filter) if username: layers = layers.filter(owner__username=username) layers_count = layers.count() count = 0 layer_errors = [] for layer in layers: try: count += 1 print(f"Syncing layer {count}/{layers_count}: {layer.name}") if updatepermissions: print("Syncing permissions...") # sync permissions in GeoFence perm_spec = json.loads(_perms_info_json(layer)) # re-sync GeoFence security rules layer.set_permissions(perm_spec) if updateattributes: # recalculate the layer statistics set_attributes_from_geoserver(layer, overwrite=True) if updatethumbnails: print("Regenerating thumbnails...") create_gs_thumbnail(layer, overwrite=True, check_bbox=False) if removeduplicates: # remove duplicates print("Removing duplicate links...") remove_duplicate_links(layer) if updatebbox: print("Regenerating BBOX...") sync_instance_with_geoserver(layer.id, updatemetadata=False, updatebbox=True) except (Exception, RuntimeError): layer_errors.append(layer.alternate) exception_type, error, traceback = sys.exc_info() print(exception_type, error, traceback) if ignore_errors: pass else: import traceback traceback.print_exc() print("Stopping process because --ignore-errors was not set and an error was found.") return print(f"There are {len(layer_errors)} layers which could not be updated because of errors") for layer_error in layer_errors: print(layer_error)
def service_detail(request, service_id): """This view shows the details of a service""" service = get_object_or_404(Service, pk=service_id) job_statuses = ( enumerations.QUEUED, enumerations.IN_PROCESS, enumerations.FAILED, ) resources_being_harvested = HarvestJob.objects.filter( service=service, status__in=job_statuses) already_imported_layers = Layer.objects.filter(service=service) service_list = service.service_set.all() all_resources = (list(resources_being_harvested) + list(already_imported_layers) + list(service_list)) paginator = Paginator(all_resources, getattr(settings, "CLIENT_RESULTS_LIMIT", 25), orphans=3) page = request.GET.get("page") try: resources = paginator.page(page) except PageNotAnInteger: resources = paginator.page(1) except EmptyPage: resources = paginator.page(paginator.num_pages) # pop the handler out of the session in order to free resources # - we had stored the service handler on the session in order to # speed up the register/harvest resources flow. However, for services # with many resources, keeping the handler in the session leads to degraded # performance try: request.session.pop(service.base_url) except KeyError: pass return render(request, template_name="services/service_detail.html", context={ "service": service, "layers": (r for r in resources if isinstance(r, Layer)), "services": (r for r in resources if isinstance(r, Service)), "resource_jobs": (r for r in resources if isinstance(r, HarvestJob)), "permissions_json": _perms_info_json(service), "resources": resources, "total_resources": len(all_resources), })
def document_detail(request, docid): """ The view that show details of each document """ document = None try: document = _resolve_document( request, docid, 'base.view_resourcebase', _PERMISSION_MSG_VIEW) except Http404: return HttpResponse( loader.render_to_string( '404.html', RequestContext( request, { })), status=404) except PermissionDenied: return HttpResponse( loader.render_to_string( '401.html', RequestContext( request, { 'error_message': _("You are not allowed to view this document.")})), status=403) if document is None: return HttpResponse( 'An unknown error has occured.', mimetype="text/plain", status=401 ) else: try: related = document.content_type.get_object_for_this_type( id=document.object_id) except: related = '' if request.user != document.owner: Document.objects.filter(id=document.id).update(popular_count=F('popular_count') + 1) return render_to_response( "documents/document_detail.html", RequestContext( request, { 'permissions_json': _perms_info_json(document), 'resource': document, 'imgtypes': IMGTYPES, 'related': related}))
def dispatch(self, request_type, request, **kwargs): if request.method == 'POST': out = {'success': False} user = request.user if user.is_authenticated() and user.is_manager_of_any_group: status = json.loads(request.body).get('status') resource_id = json.loads(request.body).get('resource_id') try: layer = Layer.objects.get(pk=resource_id) resource = ResourceBase.objects.get(pk=resource_id) except ResourceBase.DoesNotExist: status_code = 404 out['errors'] = 'Layer does not exist' else: if layer.group in user.group_list_all(): resource.featured = status if status == True: permissions = _perms_info_json(layer) perm_dict = json.loads(permissions) try: if 'download_resourcebase' in perm_dict[ 'users']['AnonymousUser']: perm_dict['users']['AnonymousUser'].remove( 'download_resourcebase') except: pass try: if 'download_resourcebase' in perm_dict[ 'groups']['anonymous']: perm_dict['groups']['anonymous'].remove( 'download_resourcebase') except: pass layer.set_permissions(perm_dict) resource.save() out['success'] = 'True' status_code = 200 else: out['error'] = 'Access denied' out['success'] = False status_code = 400 else: out['error'] = 'Access denied' out['success'] = False status_code = 400 return HttpResponse(json.dumps(out), content_type='application/json', status=status_code)
def smap_info_metadata(request, smapid): """ The view that show metadata smaps """ document = None try: document = _resolve_smap( request, smapid, 'base.change_resourcebase', _PERMISSION_MSG_METADATA) except Http404: return HttpResponse( loader.render_to_string( '404.html', RequestContext( request, { })), status=404) except PermissionDenied: return HttpResponse( loader.render_to_string( '401.html', RequestContext( request, { 'error_message': _("You are not allowed to view this document.")})), status=403) if document is None: return HttpResponse( 'An unknown error has occured.', mimetype="text/plain", status=401 ) else: try: related = document.content_type.get_object_for_this_type( id=document.object_id) except: related = '' StaticMap.objects.filter(id=document.id).update(popular_count=F('popular_count') + 1) return render_to_response( "smap_info_metadata.html", RequestContext( request, { 'permissions_json': _perms_info_json(document), 'resource': document, 'imgtypes': IMGTYPES, 'related': related}))
def document_detail(request, docid): """ The view that show details of each document """ document = None try: document = _resolve_document( request, docid, 'base.change_resourcebase', _PERMISSION_MSG_METADATA) except Http404: return HttpResponse( loader.render_to_string( '404.html', RequestContext( request, { })), status=404) except PermissionDenied: return HttpResponse( loader.render_to_string( '401.html', RequestContext( request, { 'error_message': _("You are not allowed to view this document.")})), status=403) if document is None: return HttpResponse( 'An unknown error has occured.', mimetype="text/plain", status=401 ) else: try: related = document.content_type.get_object_for_this_type( id=document.object_id) except: related = '' Document.objects.filter(id=document.id).update(popular_count=F('popular_count') + 1) return render_to_response( "documents/document_detail.html", RequestContext( request, { 'permissions_json': _perms_info_json(document), 'resource': document, 'imgtypes': IMGTYPES, 'related': related}))
def service_detail(request, service_id): """This view shows the details of a service""" service = get_object_or_404(Service, pk=service_id) job_statuses = ( enumerations.QUEUED, enumerations.IN_PROCESS, enumerations.FAILED, ) resources_being_harvested = HarvestJob.objects.filter( service=service, status__in=job_statuses) already_imported_layers = Layer.objects.filter(remote_service=service) service_list = service.service_set.all() all_resources = (list(resources_being_harvested) + list(already_imported_layers) + list(service_list)) paginator = Paginator( all_resources, getattr(settings, "CLIENT_RESULTS_LIMIT", 25), orphans=3 ) page = request.GET.get("page") try: resources = paginator.page(page) except PageNotAnInteger: resources = paginator.page(1) except EmptyPage: resources = paginator.page(paginator.num_pages) # pop the handler out of the session in order to free resources # - we had stored the service handler on the session in order to # speed up the register/harvest resources flow. However, for services # with many resources, keeping the handler in the session leads to degraded # performance try: request.session.pop(service.base_url) except KeyError: pass return render( request, template_name="services/service_detail.html", context={ "service": service, "layers": (r for r in resources if isinstance(r, Layer)), "services": (r for r in resources if isinstance(r, Service)), "resource_jobs": ( r for r in resources if isinstance(r, HarvestJob)), "permissions_json": _perms_info_json(service), "resources": resources, "total_resources": len(all_resources), } )
def map_detail_wm(request, mapid, snapshot=None, template='wm_extra/maps/map_detail.html'): ''' The view that show details of each map ''' map_obj = _resolve_map( request, mapid, 'base.view_resourcebase', _PERMISSION_MSG_VIEW) # Update count for popularity ranking, # but do not includes admins or resource owners if request.user != map_obj.owner and not request.user.is_superuser: Map.objects.filter( id=map_obj.id).update( popular_count=F('popular_count') + 1) if snapshot is None: config = map_obj.viewer_json(request) else: config = snapshot_config(snapshot, map_obj, request) config = json.dumps(config) layers = MapLayer.objects.filter(map=map_obj.id) links = map_obj.link_set.download() config = gxp2wm(config) context_dict = { 'config': config, 'resource': map_obj, 'layers': layers, 'perms_list': get_perms(request.user, map_obj.get_self_resource()), 'permissions_json': _perms_info_json(map_obj), "documents": get_related_documents(map_obj), 'links': links, } context_dict["preview"] = getattr( settings, 'GEONODE_CLIENT_LAYER_PREVIEW_LIBRARY', 'geoext') context_dict["crs"] = getattr( settings, 'DEFAULT_MAP_CRS', 'EPSG:900913') if settings.SOCIAL_ORIGINS: context_dict["social_links"] = build_social_links(request, map_obj) return render(request, template, context_dict)
def map_detail(request, mapid, snapshot=None, template='maps/map_detail.html'): ''' The view that show details of each map ''' map_obj = _resolve_map(request, mapid, 'base.view_resourcebase', _PERMISSION_MSG_VIEW) # Update count for popularity ranking, # but do not includes admins or resource owners if request.user != map_obj.owner and not request.user.is_superuser: Map.objects.filter(id=map_obj.id).update( popular_count=F('popular_count') + 1) if 'access_token' in request.session: access_token = request.session['access_token'] else: access_token = None if snapshot is None: config = map_obj.viewer_json(request.user, access_token) else: config = snapshot_config(snapshot, map_obj, request.user, access_token) config = json.dumps(config) layers = MapLayer.objects.filter(map=map_obj.id) group = None if map_obj.group: try: group = GroupProfile.objects.get(slug=map_obj.group.name) except GroupProfile.DoesNotExist: group = None context_dict = { 'config': config, 'resource': map_obj, 'group': group, 'layers': layers, 'perms_list': get_perms(request.user, map_obj.get_self_resource()), 'permissions_json': _perms_info_json(map_obj), "documents": get_related_documents(map_obj), } context_dict["preview"] = getattr(settings, 'LAYER_PREVIEW_LIBRARY', '') context_dict["crs"] = getattr(settings, 'DEFAULT_MAP_CRS', 'EPSG:900913') if settings.SOCIAL_ORIGINS: context_dict["social_links"] = build_social_links(request, map_obj) return render_to_response(template, RequestContext(request, context_dict))
def map_detail(request, mapid, snapshot=None, template='maps/map_detail.html'): ''' The view that show details of each map ''' try: user_role = request.GET['user_role'] except: user_role=None map_obj = _resolve_map(request, mapid, 'base.view_resourcebase', _PERMISSION_MSG_VIEW) # Update count for popularity ranking, # but do not includes admins or resource owners if request.user != map_obj.owner and not request.user.is_superuser: Map.objects.filter(id=map_obj.id).update(popular_count=F('popular_count') + 1) if snapshot is None: config = map_obj.viewer_json(request.user) else: config = snapshot_config(snapshot, map_obj, request.user) # check if any cql_filter is sent from the user # filter_map method returns config after adding filter if request.GET.get('layers'): config = filter_map(request, config) config = json.dumps(config) layers = MapLayer.objects.filter(map=map_obj.id) approve_form = ResourceApproveForm() deny_form = ResourceDenyForm() context_dict = { 'config': config, 'resource': map_obj, 'layers': layers, 'perms_list': get_perms(request.user, map_obj.get_self_resource()), 'permissions_json': _perms_info_json(map_obj), "documents": get_related_documents(map_obj), "user_role": user_role, "status": map_obj.status, "approve_form": approve_form, "deny_form": deny_form, "denied_comments": MapAuditActivity.objects.filter(map_submission_activity__map=map_obj), } if settings.SOCIAL_ORIGINS: context_dict["social_links"] = build_social_links(request, map_obj) return render_to_response(template, RequestContext(request, context_dict))
def document_detail(request, docid): """ The view that show details of each document """ document = None try: document = _resolve_document(request, docid, "base.view_resourcebase", _PERMISSION_MSG_VIEW) except Http404: return HttpResponse(loader.render_to_string("404.html", RequestContext(request, {})), status=404) except PermissionDenied: return HttpResponse( loader.render_to_string( "401.html", RequestContext(request, {"error_message": _("You are not allowed to view this document.")}) ), status=403, ) if document is None: return HttpResponse("An unknown error has occured.", mimetype="text/plain", status=401) else: try: related = document.content_type.get_object_for_this_type(id=document.object_id) except: related = "" # Update count for popularity ranking, # but do not includes admins or resource owners if request.user != document.owner and not request.user.is_superuser: Document.objects.filter(id=document.id).update(popular_count=F("popular_count") + 1) metadata = document.link_set.metadata().filter(name__in=settings.DOWNLOAD_FORMATS_METADATA) context_dict = { "perms_list": get_perms(request.user, document.get_self_resource()), "permissions_json": _perms_info_json(document), "resource": document, "metadata": metadata, "imgtypes": IMGTYPES, "related": related, } if settings.SOCIAL_ORIGINS: context_dict["social_links"] = build_social_links(request, document) return render_to_response("documents/document_detail.html", RequestContext(request, context_dict))
def dispatch(self, request_type, request, **kwargs): if request.method == 'POST': out = {'success': False} user = request.user if user.is_authenticated() and user.is_manager_of_any_group: status = json.loads(request.body).get('status') resource_id = json.loads(request.body).get('resource_id') try: layer = Layer.objects.get(pk=resource_id) resource = ResourceBase.objects.get(pk=resource_id) except ResourceBase.DoesNotExist: status_code = 404 out['errors'] = 'Layer does not exist' else: if layer.group in user.group_list_all(): resource.featured = status if status == True: permissions = _perms_info_json(layer) perm_dict = json.loads(permissions) try: if 'download_resourcebase' in perm_dict['users']['AnonymousUser']: perm_dict['users']['AnonymousUser'].remove('download_resourcebase') except: pass try: if 'download_resourcebase' in perm_dict['groups']['anonymous']: perm_dict['groups']['anonymous'].remove('download_resourcebase') except: pass layer.set_permissions(perm_dict) resource.save() out['success'] = 'True' status_code = 200 else: out['error'] = 'Access denied' out['success'] = False status_code = 400 else: out['error'] = 'Access denied' out['success'] = False status_code = 400 return HttpResponse(json.dumps(out), content_type='application/json', status=status_code)
def test_perms_info(self): """ Tests the perms_info function (which passes permissions to the response context). """ # Add test to test perms being sent to the front end. layer = Layer.objects.all()[0] perms_info = layer.get_all_level_info() # Ensure there is no group info for the layer object by default self.assertEqual(len(perms_info['groups'].keys()),0) # Add the foo group to the layer object groups layer.set_permissions({'groups':{'bar': ['view_resourcebase']}}) perms_info = _perms_info_json(layer) # Ensure foo is in the perms_info output self.assertDictEqual(json.loads(perms_info)['groups'], {'bar': ['view_resourcebase']})
def project_detail(request, docid): """ The view that show details of each document """ document = None try: document = _resolve_document_geo(request, docid, "base.change_resourcebase", _PERMISSION_MSG_METADATA) except Http404: return HttpResponse(loader.render_to_string("404.html", RequestContext(request, {})), status=404) except PermissionDenied: return HttpResponse( loader.render_to_string( "401.html", RequestContext(request, {"error_message": _("You are not allowed to view this document.")}) ), status=403, ) if document is None: return HttpResponse("An unknown error has occured.", mimetype="text/plain", status=401) else: try: related = document.content_type.get_object_for_this_type(id=document.object_id) except: related = "" # Update count for popularity ranking, # but do not includes admins or resource owners if request.user != document.owner and not request.user.is_superuser: Project.objects.filter(id=document.id).update(popular_count=F("popular_count") + 1) print related return render_to_response( "project_detail.html", RequestContext( request, { "permissions_json": _perms_info_json(document), "resource": document, "imgtypes": IMGTYPES, "related": related, }, ), )
def test_perms_info(self): """ Tests the perms_info function (which passes permissions to the response context). """ # Add test to test perms being sent to the front end. layer = Layer.objects.all()[0] layer.set_default_permissions() perms_info = layer.get_all_level_info() # Ensure there is only one group 'anonymous' by default self.assertEqual(len(perms_info["groups"].keys()), 1) # Add the foo group to the layer object groups layer.set_permissions({"groups": {"bar": ["view_resourcebase"]}}) perms_info = _perms_info_json(layer) # Ensure foo is in the perms_info output self.assertDictEqual(json.loads(perms_info)["groups"], {"bar": ["view_resourcebase"]})
def handle(self, **options): if options['layername']: layers = Layer.objects.filter(name__icontains=options['layername']) else: layers = Layer.objects.all() layers_count = layers.count() count = 0 for layer in layers: count += 1 try: print 'Synchronizing permissions for layer %s/%s: %s' % (count, layers_count, layer.alternate) perm_spec = json.loads(_perms_info_json(layer)) layer.set_permissions(perm_spec) except: print("Unexpected error:", sys.exc_info()[0]) print 'perm_spec is %s' % perm_spec
def analysis_detail(request, analysisid, template='analytics/analysis_detail.html'): """ The view that show details of each analysis. """ try: analysis_obj = _resolve_analysis(request, analysisid, 'base.view_resourcebase', _PERMISSION_MSG_VIEW) analysis_obj.popular_count += 1 analysis_obj.save() return render(request, template, { 'resource' : analysis_obj, 'documents' : get_related_documents(analysis_obj), 'permission_json' : _perms_info_json(analysis_obj), }) except PermissionDenied: if not request.user.is_authenticated(): # If the user is not authenticated raising a PermissionDenied redirects him to the login page raise PermissionDenied return HttpResponse(_PERMISSION_MSG_VIEW, status=401, mimetype='text/plain')
def test_perms_info(self): """ Tests the perms_info function (which passes permissions to the response context). """ # Add test to test perms being sent to the front end. layer = Layer.objects.all()[0] perms_info = layer.get_all_level_info() # Ensure there is only one group 'anonymous' by default self.assertEqual(len(perms_info['groups'].keys()), 1) # Add the foo group to the layer object groups layer.set_permissions({'groups': {'bar': ['view_resourcebase']}}) perms_info = _perms_info_json(layer) # Ensure foo is in the perms_info output self.assertDictEqual( json.loads(perms_info)['groups'], {'bar': ['view_resourcebase']})
def sync_geonode_layers(ignore_errors, filter, username, updatepermissions, updatethumbnails, updateattributes): layers = Layer.objects.all().order_by('name') if filter: layers = layers.filter(name__icontains=filter) if username: layers = layers.filter(owner__username=username) layers_count = layers.count() count = 0 layer_errors = [] for layer in layers: try: count += 1 print("Syncing layer {}/{}: {}".format(count, layers_count, layer.name)) if updatepermissions: print("Syncing permissions...") # sync permissions in GeoFence perm_spec = json.loads(_perms_info_json(layer)) # re-sync GeoFence security rules layer.set_permissions(perm_spec) if updateattributes: # recalculate the layer statistics set_attributes_from_geoserver(layer, overwrite=True) if updatethumbnails: print("Regenerating thumbnails...") layer.save() except Exception: layer_errors.append(layer.alternate) exception_type, error, traceback = sys.exc_info() print(exception_type, error, traceback) if ignore_errors: pass else: import traceback traceback.print_exc() print( "Stopping process because --ignore-errors was not set and an error was found." ) return print("There are {} layers which could not be updated because of errors". format(len(layer_errors))) for layer_error in layer_errors: print(layer_error)
def handle(self, **options): if options['layername']: layers = Layer.objects.filter(name__icontains=options['layername']) else: layers = Layer.objects.all() layers_count = layers.count() count = 0 for layer in layers: count += 1 try: print 'Synchronizing permissions for layer %s/%s: %s' % ( count, layers_count, layer.alternate) perm_spec = json.loads(_perms_info_json(layer)) layer.set_permissions(perm_spec) except: print("Unexpected error:", sys.exc_info()[0]) print 'perm_spec is %s' % perm_spec
def layer_detail(request, layername, template='layers/layer_detail.html'): layer = _resolve_layer(request, layername, 'layers.view_layer', _PERMISSION_MSG_VIEW) maplayer = GXPLayer(name = layer.typename, ows_url = settings.GEOSERVER_BASE_URL + "wms", layer_params=json.dumps( layer.attribute_config())) layer.srid_url = "http://www.spatialreference.org/ref/" + layer.srid.replace(':','/').lower() + "/" #layer.popular_count += 1 #layer.save() # center/zoom don't matter; the viewer will center on the layer bounds map_obj = GXPMap(projection="EPSG:900913") DEFAULT_BASE_LAYERS = default_map_config()[1] return render_to_response(template, RequestContext(request, { "layer": layer, "viewer": json.dumps(map_obj.viewer_json(* (DEFAULT_BASE_LAYERS + [maplayer]))), "permissions_json": _perms_info_json(layer, LAYER_LEV_NAMES), }))
def layer_detail(request, layername, template='layers/layer_detail.html'): layer = _resolve_layer(request, layername, 'layers.view_layer', _PERMISSION_MSG_VIEW) config = layer.attribute_config() if layer.storeType == "remoteStore" and "geonode.contrib.services" in settings.INSTALLED_APPS: from geonode.contrib.services.models import Service service = Service.objects.filter(layers__id=layer.id)[0] source_params = {"ptype":service.ptype, "remote": True, "url": service.base_url, "name": service.name} maplayer = GXPLayer(name = layer.typename, ows_url = layer.ows_url, layer_params=json.dumps( config), source_params=json.dumps(source_params)) else: maplayer = GXPLayer(name = layer.typename, ows_url = layer.ows_url, layer_params=json.dumps( config)) # Update count for popularity ranking. Layer.objects.filter(id=layer.id).update(popular_count=layer.popular_count +1) # center/zoom don't matter; the viewer will center on the layer bounds map_obj = GXPMap(projection="EPSG:900913") NON_WMS_BASE_LAYERS = [la for la in default_map_config()[1] if la.ows_url is None] metadata = layer.link_set.metadata().filter( name__in=settings.DOWNLOAD_FORMATS_METADATA) context_dict = { "layer": layer, "permissions_json": _perms_info_json(layer, LAYER_LEV_NAMES), "documents": get_related_documents(layer), "metadata": metadata, } context_dict["viewer"] = json.dumps(map_obj.viewer_json(* (NON_WMS_BASE_LAYERS + [maplayer]))) if layer.storeType=='dataStore': links = layer.link_set.download().filter( name__in=settings.DOWNLOAD_FORMATS_VECTOR) else: links = layer.link_set.download().filter( name__in=settings.DOWNLOAD_FORMATS_RASTER) context_dict["links"] = links return render_to_response(template, RequestContext(request, context_dict))
def map_detail(request, mapid, snapshot=None, template='maps/map_detail.html'): ''' The view that show details of each map ''' # ubah if (request.resolver_match.namespace == 'v2'): template = 'v2/map_detail.html' # /ubah map_obj = _resolve_map(request, mapid, 'base.view_resourcebase', _PERMISSION_MSG_VIEW) # Update count for popularity ranking, # but do not includes admins or resource owners if request.user != map_obj.owner and not request.user.is_superuser: Map.objects.filter(id=map_obj.id).update(popular_count=F('popular_count') + 1) queryset = matrix(user=request.user,resourceid=map_obj,action='View') queryset.save() if snapshot is None: config = map_obj.viewer_json(request.user) else: config = snapshot_config(snapshot, map_obj, request.user) config = json.dumps(config) layers = MapLayer.objects.filter(map=map_obj.id) layernames = [l.name for l in layers] qs_orglogos = Layer.objects.filter(typename__in=layernames, orglogo__filename__isnull=False).values('orglogo__filename').distinct() orglogos = [l['orglogo__filename'] for l in qs_orglogos] context_dict = { "orglogos": orglogos, 'config': config, 'resource': map_obj, 'layers': layers, 'permissions_json': _perms_info_json(map_obj), "documents": get_related_documents(map_obj), } if settings.SOCIAL_ORIGINS: context_dict["social_links"] = build_social_links(request, map_obj) return render_to_response(template, RequestContext(request, context_dict))
def layer_detail(request, layername, template='layers/layer_detail.html'): layer = _resolve_layer(request, layername, 'layers.view_layer', _PERMISSION_MSG_VIEW) maplayer = GXPLayer(name=layer.name, ows_url=layer.ows_url(), layer_params=json.dumps(layer.attribute_config())) # Update count for popularity ranking. Layer.objects.filter(id=layer.id).update( popular_count=layer.popular_count + 1) # center/zoom don't matter; the viewer will center on the layer bounds map_obj = GXPMap(projection="EPSG:900913") NON_WMS_BASE_LAYERS = [ la for la in default_map_config()[1] if la.ows_url is None ] metadata = layer.link_set.metadata().filter( name__in=settings.DOWNLOAD_FORMATS_METADATA) context_dict = { "layer": layer, "permissions_json": _perms_info_json(layer, LAYER_LEV_NAMES), "documents": get_related_documents(layer), "metadata": metadata, } context_dict["viewer"] = json.dumps( map_obj.viewer_json(*(NON_WMS_BASE_LAYERS + [maplayer]))) if layer.storeType == 'dataStore': links = layer.link_set.download().filter( name__in=settings.DOWNLOAD_FORMATS_VECTOR) else: links = layer.link_set.download().filter( name__in=settings.DOWNLOAD_FORMATS_RASTER) context_dict["links"] = links return render_to_response(template, RequestContext(request, context_dict))
def print_map(request): from proxy.views import proxy from layers.models import Layer permissions = {} params = json.loads(request.body) for layer in params['layers']: if ogc_server_settings.LOCATION in layer['baseURL']: for layer_name in layer['layers']: layer_obj = Layer.objects.get(typename=layer_name) permissions[layer_obj] = _perms_info_json(layer_obj) layer_obj.set_default_permissions() try: resp = proxy(request) except Exception: return HttpResponse('There was an error connecting to the printing server') finally: for layer_obj in permissions.keys(): layer_obj.set_permissions(json.loads(permissions[layer_obj])) return resp
def map_detail(request, mapid, snapshot=None, template='maps/map_detail.html'): ''' The view that show details of each map ''' map_obj = _resolve_map(request, mapid, 'base.view_resourcebase', _PERMISSION_MSG_VIEW) if request.user != map_obj.owner: Map.objects.filter(id=map_obj.id).update(popular_count=F('popular_count') + 1) if snapshot is None: config = map_obj.viewer_json(request.user) else: config = snapshot_config(snapshot, map_obj, request.user) config = json.dumps(config) layers = MapLayer.objects.filter(map=map_obj.id) return render_to_response(template, RequestContext(request, { 'config': config, 'resource': map_obj, 'layers': layers, 'permissions_json': _perms_info_json(map_obj), "documents": get_related_documents(map_obj), }))
def service_detail(request, service_id): ''' This view shows the details of a service ''' service = get_object_or_404(Service, pk=service_id) layer_list = service.layer_set.all() service_list = service.service_set.all() # Show 25 services per page service_paginator = Paginator(service_list, 25) layer_paginator = Paginator(layer_list, 25) # Show 25 services per page page = request.GET.get('page') try: layers = layer_paginator.page(page) except PageNotAnInteger: # If page is not an integer, deliver first page. layers = layer_paginator.page(1) except EmptyPage: # If page is out of range (e.g. 9999), deliver last page of results. layers = layer_paginator.page(layer_paginator.num_pages) try: services = service_paginator.page(page) except PageNotAnInteger: # If page is not an integer, deliver first page. services = service_paginator.page(1) except EmptyPage: # If page is out of range (e.g. 9999), deliver last page of results. services = service_paginator.page(service_paginator.num_pages) return render_to_response("services/service_detail.html", RequestContext(request, { 'service': service, 'layers': layers, 'services': services, 'permissions_json': _perms_info_json(service) }))