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_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
'''
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)
}))
