def test_post_mapstory_detail_keyword_post(self):
# Should create add a keyword
test_mapstory = create_mapstory(testUser, 'Testing Map 02')
self.client.login(username=testUser.username, password="******")
response = self.client.post(
reverse('mapstory_detail', kwargs={"slug": test_mapstory.slug}),
{'add_keyword': 'test_keyword'})
self.assertEquals(response.status_code, 200)
# Should remove the keyword
response = self.client.post(
reverse('mapstory_detail', kwargs={"slug": test_mapstory.slug}),
{'remove_keyword': 'test_keyword'})
self.assertEquals(response.status_code, 200)
# Should handle Keywords form post
form_data = {
'keywords': ['testKeyword01', 'testKeyword02', 'testKeyword03']
}
form = KeywordsForm(data=form_data)
self.assertTrue(form.is_valid())
response = self.client.post(
reverse('mapstory_detail', kwargs={"slug": test_mapstory.slug}),
form_data)
self.assertEquals(response.status_code, 200)
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 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 test_post_mapstory_detail_keyword_post(self):
# Should create add a keyword
test_mapstory = create_mapstory(testUser, 'Testing Map 02')
self.client.login(username=testUser.username, password="******")
response = self.client.post(reverse('mapstory_detail', kwargs={
"slug": test_mapstory.slug}), {'add_keyword': 'test_keyword'})
self.assertEquals(response.status_code, 200)
# Should remove the keyword
response = self.client.post(reverse('mapstory_detail', kwargs={"slug": test_mapstory.slug}),
{'remove_keyword': 'test_keyword'})
self.assertEquals(response.status_code, 200)
# Should handle Keywords form post
form_data = {'keywords': ['testKeyword01',
'testKeyword02', 'testKeyword03']}
form = KeywordsForm(data=form_data)
self.assertTrue(form.is_valid())
response = self.client.post(reverse('mapstory_detail', kwargs={
"slug": test_mapstory.slug}), form_data)
self.assertEquals(response.status_code, 200)
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:
MapStory.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)
chapters = map_obj.chapters
layers = []
for chapter in chapters:
layers = layers + list(chapter.local_layers)
print layers
if request.method == "POST":
keywords_form = KeywordsForm(request.POST, instance=map_obj)
published_form = PublishStatusForm(instance=map_obj)
if 'keywords' in request.POST:
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,
'base.view_resourcebase',
_PERMISSION_MSG_VIEW)
# assert False, str(layer_bbox)
config = layer.attribute_config()
# TODO (Mapstory): This has been commented out to force the client to make a getCapabilities request in order
# to pull in the time dimension data. Ideally we would cache time data just like the srs and bbox data to prevent
# making the getCapabilities request.
# Add required parameters for GXP lazy-loading
#layer_bbox = layer.bbox
#bbox = [float(coord) for coord in list(layer_bbox[0:4])]
#srid = layer.srid
# Transform WGS84 to Mercator.
#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.name,
ows_url=layer.ows_url,
layer_params=json.dumps(config))
# Update count for popularity ranking,
# but do not includes admins or resource owners
if request.user != layer.owner and not request.user.is_superuser:
Layer.objects.filter(
id=layer.id).update(popular_count=F('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)
if request.method == "POST":
keywords_form = KeywordsForm(request.POST, instance=layer)
metadata_form = MetadataForm(instance=layer)
if 'keywords' in request.POST:
if keywords_form.is_valid():
keywords_form.save()
new_keywords = keywords_form.cleaned_data['keywords']
layer.keywords.set(*new_keywords)
layer.save()
metadata_form = MetadataForm(instance=layer)
published_form = PublishStatusForm(instance=layer)
elif 'title' in request.POST:
metadata_form = MetadataForm(request.POST, instance=layer)
if metadata_form.is_valid():
metadata_form.save()
# update all the metadata
if metadata_form.cleaned_data['category'] is not None:
new_category = TopicCategory.objects.get(id=metadata_form.cleaned_data['category'].id)
Layer.objects.filter(id=layer.id).update(category=new_category)
layer.title = metadata_form.cleaned_data['title']
layer.language = metadata_form.cleaned_data['language']
layer.distribution_url = metadata_form.cleaned_data['distribution_url']
layer.data_quality_statement = metadata_form.cleaned_data['data_quality_statement']
layer.purpose = metadata_form.cleaned_data['purpose']
layer.is_published = metadata_form.cleaned_data['is_published']
layer.save()
keywords_form = KeywordsForm(instance=layer)
elif 'add_keyword' in request.POST:
layer.keywords.add(request.POST['add_keyword'])
layer.save()
elif 'remove_keyword' in request.POST:
layer.keywords.remove(request.POST['remove_keyword'])
layer.save()
else:
keywords_form = KeywordsForm(instance=layer)
metadata_form = MetadataForm(instance=layer)
content_moderators = Group.objects.filter(name='content_moderator').first()
context_dict = {
"resource": layer,
"permissions_json": _perms_info_json(layer),
"documents": get_related_documents(layer),
"metadata": metadata,
"is_layer": True,
"wps_enabled": settings.OGC_SERVER['default']['WPS_ENABLED'],
"keywords_form": keywords_form,
"metadata_form": metadata_form,
"content_moderators": content_moderators,
}
context_dict["viewer"] = json.dumps(
map_obj.viewer_json(request.user, * (NON_WMS_BASE_LAYERS + [maplayer])))
context_dict["preview"] = getattr(
settings,
'LAYER_PREVIEW_LIBRARY')
if request.user.has_perm('download_resourcebase', layer.get_self_resource()):
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
layer_property_names = []
for attrib in layer.attributes:
if attrib.attribute not in settings.SCHEMA_DOWNLOAD_EXCLUDE and not (attrib.attribute.endswith('_xd') or attrib.attribute.endswith('_parsed')):
layer_property_names.append(attrib.attribute)
layer_attrib_string = ','.join(layer_property_names)
shapefile_link = layer.link_set.download().filter(mime='SHAPE-ZIP').first()
if shapefile_link is not None:
shapefile_link = shapefile_link.url + '&featureID=fakeID' + '&propertyName=' + layer_attrib_string
context_dict["shapefile_link"] = shapefile_link
csv_link = layer.link_set.download().filter(mime='csv').first()
if csv_link is not None:
csv_link = csv_link.url + '&featureID=fakeID' + '&propertyName=' + layer_attrib_string
context_dict["csv_link"] = csv_link
if settings.SOCIAL_ORIGINS:
context_dict["social_links"] = build_social_links(request, layer)
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)
# assert False, str(layer_bbox)
config = layer.attribute_config()
# Add required parameters for GXP lazy-loading
layer_bbox = layer.bbox[0:4]
bbox = layer_bbox[:]
bbox[0] = float(layer_bbox[0])
bbox[1] = float(layer_bbox[2])
bbox[2] = float(layer_bbox[1])
bbox[3] = float(layer_bbox[3])
def decimal_encode(bbox):
import decimal
_bbox = []
for o in [float(coord) for coord in bbox]:
if isinstance(o, decimal.Decimal):
o = (str(o) for o in [o])
_bbox.append(o)
# Must be in the form : [x0, x1, y0, y1
return [_bbox[0], _bbox[2], _bbox[1], _bbox[3]]
def sld_definition(style):
from urllib import quote
_sld = {
"title": style.sld_title or style.name,
"legend": {
"height":
"40",
"width":
"22",
"href":
layer.ows_url +
"?service=wms&request=GetLegendGraphic&format=image%2Fpng&width=20&height=20&layer="
+ quote(layer.service_typename, safe=''),
"format":
"image/png"
},
"name": style.name
}
return _sld
if hasattr(layer, 'srid'):
config['crs'] = {'type': 'name', 'properties': layer.srid}
# Add required parameters for GXP lazy-loading
attribution = "%s %s" % (
layer.owner.first_name, layer.owner.last_name
) if layer.owner.first_name or layer.owner.last_name else str(layer.owner)
srs = getattr(settings, 'DEFAULT_MAP_CRS', 'EPSG:3857')
srs_srid = int(srs.split(":")[1]) if srs != "EPSG:900913" else 3857
config[
"attribution"] = "<span class='gx-attribution-title'>%s</span>" % attribution
config["format"] = getattr(settings, 'DEFAULT_LAYER_FORMAT', 'image/png')
config["title"] = layer.title
config["wrapDateLine"] = True
config["visibility"] = True
config["srs"] = srs
config["bbox"] = decimal_encode(
bbox_to_projection([float(coord) for coord in layer_bbox] + [
layer.srid,
],
target_srid=int(srs.split(":")[1]))[:4])
config["capability"] = {
"abstract":
layer.abstract,
"name":
layer.alternate,
"title":
layer.title,
"queryable":
True,
"storeType":
layer.storeType,
"bbox": {
layer.srid: {
"srs": layer.srid,
"bbox": decimal_encode(bbox)
},
srs: {
"srs":
srs,
"bbox":
decimal_encode(
bbox_to_projection([float(coord)
for coord in layer_bbox] + [
layer.srid,
],
target_srid=srs_srid)[:4])
},
"EPSG:4326": {
"srs":
"EPSG:4326",
"bbox":
decimal_encode(bbox)
if layer.srid == 'EPSG:4326' else decimal_encode(
bbox_to_projection([float(coord)
for coord in layer_bbox] + [
layer.srid,
],
target_srid=4326)[:4])
},
"EPSG:900913": {
"srs":
"EPSG:900913",
"bbox":
decimal_encode(bbox)
if layer.srid == 'EPSG:900913' else decimal_encode(
bbox_to_projection([float(coord)
for coord in layer_bbox] + [
layer.srid,
],
target_srid=3857)[:4])
}
},
"srs": {
srs: True
},
"formats": [
"image/png", "application/atom xml", "application/atom+xml",
"application/json;type=utfgrid", "application/openlayers",
"application/pdf", "application/rss xml", "application/rss+xml",
"application/vnd.google-earth.kml",
"application/vnd.google-earth.kml xml",
"application/vnd.google-earth.kml+xml",
"application/vnd.google-earth.kml+xml;mode=networklink",
"application/vnd.google-earth.kmz",
"application/vnd.google-earth.kmz xml",
"application/vnd.google-earth.kmz+xml",
"application/vnd.google-earth.kmz;mode=networklink", "atom",
"image/geotiff", "image/geotiff8", "image/gif",
"image/gif;subtype=animated", "image/jpeg", "image/png8",
"image/png; mode=8bit", "image/svg", "image/svg xml",
"image/svg+xml", "image/tiff", "image/tiff8", "image/vnd.jpeg-png",
"kml", "kmz", "openlayers", "rss", "text/html; subtype=openlayers",
"utfgrid"
],
"attribution": {
"title": attribution
},
"infoFormats": [
"text/plain", "application/vnd.ogc.gml", "text/xml",
"application/vnd.ogc.gml/3.1.1", "text/xml; subtype=gml/3.1.1",
"text/html", "application/json"
],
"styles": [sld_definition(s) for s in layer.styles.all()],
"prefix":
layer.alternate.split(":")[0] if ":" in layer.alternate else "",
"keywords":
[k.name for k in layer.keywords.all()] if layer.keywords else [],
"llbbox":
decimal_encode(bbox) if layer.srid == 'EPSG:4326' else decimal_encode(
bbox_to_projection([float(coord) for coord in layer_bbox] + [
layer.srid,
],
target_srid=4326)[:4])
}
all_times = None
if check_ogc_backend(geoserver.BACKEND_PACKAGE):
from geonode.geoserver.views import get_capabilities
workspace, layername = layer.alternate.split(
":") if ":" in layer.alternate else (None, layer.alternate)
# WARNING Please make sure to have enabled DJANGO CACHE as per
# https://docs.djangoproject.com/en/2.0/topics/cache/#filesystem-caching
wms_capabilities_resp = get_capabilities(request,
layer.id,
tolerant=True)
if wms_capabilities_resp.status_code >= 200 and wms_capabilities_resp.status_code < 400:
wms_capabilities = wms_capabilities_resp.getvalue()
if wms_capabilities:
import xml.etree.ElementTree as ET
e = ET.fromstring(wms_capabilities)
for atype in e.findall("./[Name='%s']/Extent[@name='time']" %
(layername)):
dim_name = atype.get('name')
if dim_name:
dim_name = str(dim_name).lower()
if dim_name == 'time':
dim_values = atype.text
if dim_values:
all_times = dim_values.split(",")
break
if all_times:
config["capability"]["dimensions"] = {
"time": {
"name": "time",
"units": "ISO8601",
"unitsymbol": None,
"nearestVal": False,
"multipleVal": False,
"current": False,
"default": "current",
"values": all_times
}
}
if layer.storeType == "remoteStore":
service = layer.remote_service
source_params = {}
if service.type in ('REST_MAP', 'REST_IMG'):
source_params = {
"ptype": service.ptype,
"remote": True,
"url": service.service_url,
"name": service.name,
"title": "[R] %s" % service.title
}
maplayer = GXPLayer(name=layer.alternate,
ows_url=layer.ows_url,
layer_params=json.dumps(config),
source_params=json.dumps(source_params))
else:
maplayer = GXPLayer(name=layer.alternate,
ows_url=layer.ows_url,
layer_params=json.dumps(config))
# Update count for popularity ranking,
# but do not includes admins or resource owners
layer.view_count_up(request.user)
# center/zoom don't matter; the viewer will center on the layer bounds
map_obj = GXPMap(sender=Layer,
projection=getattr(settings, 'DEFAULT_MAP_CRS',
'EPSG:3857'))
NON_WMS_BASE_LAYERS = [
la for la in default_map_config(request)[1] if la.ows_url is None
]
metadata = layer.link_set.metadata().filter(
name__in=settings.DOWNLOAD_FORMATS_METADATA)
granules = None
all_granules = None
all_times = None
filter = None
if layer.is_mosaic:
try:
cat = gs_catalog
cat._cache.clear()
store = cat.get_store(layer.name)
coverages = cat.mosaic_coverages(store)
filter = None
try:
if request.GET["filter"]:
filter = request.GET["filter"]
except BaseException:
pass
offset = 10 * (request.page - 1)
granules = cat.mosaic_granules(
coverages['coverages']['coverage'][0]['name'],
store,
limit=10,
offset=offset,
filter=filter)
all_granules = cat.mosaic_granules(
coverages['coverages']['coverage'][0]['name'],
store,
filter=filter)
except BaseException:
granules = {"features": []}
all_granules = {"features": []}
if check_ogc_backend(geoserver.BACKEND_PACKAGE):
from geonode.geoserver.views import get_capabilities
workspace, layername = layer.alternate.split(
":") if ":" in layer.alternate else (None, layer.alternate)
# WARNING Please make sure to have enabled DJANGO CACHE as per
# https://docs.djangoproject.com/en/2.0/topics/cache/#filesystem-caching
wms_capabilities_resp = get_capabilities(request,
layer.id,
tolerant=True)
if wms_capabilities_resp.status_code >= 200 and wms_capabilities_resp.status_code < 400:
wms_capabilities = wms_capabilities_resp.getvalue()
if wms_capabilities:
import xml.etree.ElementTree as ET
e = ET.fromstring(wms_capabilities)
for atype in e.findall("./[Name='%s']/Extent[@name='time']" %
(layername)):
dim_name = atype.get('name')
if dim_name:
dim_name = str(dim_name).lower()
if dim_name == 'time':
dim_values = atype.text
if dim_values:
all_times = dim_values.split(",")
break
group = None
if layer.group:
try:
group = GroupProfile.objects.get(slug=layer.group.name)
except GroupProfile.DoesNotExist:
group = None
# a flag to be used for qgis server
show_popup = False
if 'show_popup' in request.GET and request.GET["show_popup"]:
show_popup = True
###
# MapStory Specific Changes
###
keywords = json.dumps([tag.name for tag in layer.keywords.all()])
if request.method == "POST":
keywords_form = KeywordsForm(request.POST, instance=layer)
metadata_form = MetadataForm(instance=layer)
distributionurl_form = DistributionUrlForm(request.POST,
instance=layer)
if 'keywords' in request.POST:
if keywords_form.is_valid():
keywords_form.save()
new_keywords = keywords_form.cleaned_data['keywords']
layer.keywords.set(*new_keywords)
layer.save()
metadata_form = MetadataForm(instance=layer)
elif 'title' in request.POST:
metadata_form = MetadataForm(request.POST, instance=layer)
if metadata_form.is_valid():
metadata_form.save()
# update all the metadata
if metadata_form.cleaned_data['category'] is not None:
new_category = TopicCategory.objects.get(
id=metadata_form.cleaned_data['category'].id)
Layer.objects.filter(id=layer.id).update(
category=new_category)
layer.title = metadata_form.cleaned_data['title']
layer.language = metadata_form.cleaned_data['language']
layer.data_quality_statement = metadata_form.cleaned_data[
'data_quality_statement']
layer.purpose = metadata_form.cleaned_data['purpose']
layer.is_published = metadata_form.cleaned_data['is_published']
layer.save()
if distributionurl_form.is_valid():
layer.distribution_url = distributionurl_form.cleaned_data[
'distribution_url']
keywords_form = KeywordsForm(instance=layer)
if 'add_keyword' in request.POST:
layer.keywords.add(request.POST['add_keyword'])
layer.save()
if 'remove_keyword' in request.POST:
layer.keywords.remove(request.POST['remove_keyword'])
layer.save()
else:
keywords_form = KeywordsForm(instance=layer)
metadata_form = MetadataForm(instance=layer)
distributionurl_form = DistributionUrlForm(instance=layer)
content_moderators = Group.objects.filter(name='content_moderator').first()
thumbnail = layer.get_thumbnail_url
# This will get URL encoded later and is used for the social media share URL
share_url = "https://%s/layers/%s" % (request.get_host(), layer.typename)
share_title = "%s by %s." % (layer.title, layer.owner)
share_description = layer.abstract
# Get membership buttons ready:
admin_memberships = []
# Check if user is admin in one of those organizations
users_org_memberships = OrganizationMembership.objects.filter(
user_id=request.user.pk)
for membership in users_org_memberships.all():
# We have permission if we own the layer, or if we are an organization's admin.
if (layer.owner == request.user) or membership.is_admin:
admin_memberships.append(membership)
if len(admin_memberships) < 1:
admin_memberships = None
ini_memberships = []
# Checks if user is admin for Inititives
user_ini_memberships = InitiativeMembership.objects.filter(
user_id=request.user.pk)
for membership in user_ini_memberships.all():
if (layer.owner == request.user) or membership.is_admin:
ini_memberships.append(membership)
if len(ini_memberships) < 1:
ini_memberships = None
shapefile_link = layer.link_set.download().filter(mime='SHAPE-ZIP').first()
if shapefile_link is not None:
shapefile_link = shapefile_link.url + '&featureID=fakeID' + '&maxFeatures=1'
request.session['shp_name'] = layer.typename
request.session['shp_link'] = shapefile_link
csv_link = layer.link_set.download().filter(mime='csv').first()
if csv_link is not None:
csv_link = csv_link.url + '&featureID=fakeID' + '&maxFeatures=1'
request.session['csv_name'] = layer.typename
request.session['csv_link'] = csv_link
###
# End MapStory Specific Changes
###
context_dict = {
'resource': layer,
'group': group,
'perms_list': get_perms(request.user, layer.get_self_resource()),
"permissions_json": _perms_info_json(layer),
"documents": get_related_documents(layer),
"metadata": metadata,
"is_layer": True,
"wps_enabled": settings.OGC_SERVER['default']['WPS_ENABLED'],
"granules": granules,
"all_granules": all_granules,
"all_times": all_times,
"show_popup": show_popup,
"filter": filter,
"storeType": layer.storeType,
# MapStory Specific Additions
"keywords": keywords,
"keywords_form": keywords_form,
"metadata_form": metadata_form,
"distributionurl_form": distributionurl_form,
"content_moderators": content_moderators,
"thumbnail": thumbnail,
"share_url": share_url,
"share_title": share_title,
"share_description": share_description,
"organizations": admin_memberships,
"initiatives": ini_memberships
# "online": (layer.remote_service.probe == 200) if layer.storeType == "remoteStore" else True
}
if request and 'access_token' in request.session:
access_token = request.session['access_token']
else:
u = uuid.uuid1()
access_token = u.hex
context_dict["viewer"] = json.dumps(
map_obj.viewer_json(request, *(NON_WMS_BASE_LAYERS + [maplayer])))
context_dict["preview"] = getattr(settings,
'GEONODE_CLIENT_LAYER_PREVIEW_LIBRARY',
'geoext')
context_dict["crs"] = getattr(settings, 'DEFAULT_MAP_CRS', 'EPSG:3857')
# provide bbox in EPSG:4326 for leaflet
if context_dict["preview"] == 'leaflet':
srid, wkt = layer.geographic_bounding_box.split(';')
srid = re.findall(r'\d+', srid)
geom = GEOSGeometry(wkt, srid=int(srid[0]))
geom.transform(4326)
context_dict["layer_bbox"] = ','.join([str(c) for c in geom.extent])
if layer.storeType == 'dataStore':
links = layer.link_set.download().filter(
Q(name__in=settings.DOWNLOAD_FORMATS_VECTOR)
| Q(link_type='original'))
else:
links = layer.link_set.download().filter(
Q(name__in=settings.DOWNLOAD_FORMATS_RASTER)
| Q(link_type='original'))
links_view = [
item for idx, item in enumerate(links)
if item.url and 'wms' in item.url or 'gwc' in item.url
]
links_download = [
item for idx, item in enumerate(links)
if item.url and 'wms' not in item.url and 'gwc' not in item.url
]
for item in links_view:
if item.url and access_token and 'access_token' not in item.url:
params = {'access_token': access_token}
item.url = Request('GET', item.url, params=params).prepare().url
for item in links_download:
if item.url and access_token and 'access_token' not in item.url:
params = {'access_token': access_token}
item.url = Request('GET', item.url, params=params).prepare().url
if request.user.has_perm('view_resourcebase', layer.get_self_resource()):
context_dict["links"] = links_view
if request.user.has_perm('download_resourcebase',
layer.get_self_resource()):
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_download"] = links_download
if settings.SOCIAL_ORIGINS:
context_dict["social_links"] = build_social_links(request, layer)
layers_names = layer.alternate
try:
if settings.DEFAULT_WORKSPACE and settings.DEFAULT_WORKSPACE in layers_names:
workspace, name = layers_names.split(':', 1)
else:
name = layers_names
except BaseException:
logger.error("Can not identify workspace type and layername")
context_dict["layer_name"] = json.dumps(layers_names)
try:
# get type of layer (raster or vector)
if layer.storeType == 'coverageStore':
context_dict["layer_type"] = "raster"
elif layer.storeType == 'dataStore':
if layer.has_time:
context_dict["layer_type"] = "vector_time"
else:
context_dict["layer_type"] = "vector"
location = "{location}{service}".format(
**{
'location': settings.OGC_SERVER['default']['LOCATION'],
'service': 'wms',
})
# get schema for specific layer
username = settings.OGC_SERVER['default']['USER']
password = settings.OGC_SERVER['default']['PASSWORD']
schema = get_schema(location,
name,
username=username,
password=password)
# get the name of the column which holds the geometry
if 'the_geom' in schema['properties']:
schema['properties'].pop('the_geom', None)
elif 'geom' in schema['properties']:
schema['properties'].pop("geom", None)
# filter the schema dict based on the values of layers_attributes
layer_attributes_schema = []
for key in schema['properties'].keys():
layer_attributes_schema.append(key)
filtered_attributes = layer_attributes_schema
context_dict["schema"] = schema
context_dict["filtered_attributes"] = filtered_attributes
except BaseException:
logger.error(
"Possible error with OWSLib. Turning all available properties to string"
)
if settings.GEOTIFF_IO_ENABLED:
from geonode.contrib.geotiffio import create_geotiff_io_url
context_dict["link_geotiff_io"] = create_geotiff_io_url(
layer, access_token)
# maps owned by user needed to fill the "add to existing map section" in template
if request.user.is_authenticated():
context_dict["maps"] = Map.objects.filter(owner=request.user)
return TemplateResponse(request, template, context=context_dict)
def layer_detail(request, layername, template='layers/layer_detail.html'):
layer = _resolve_layer(
request,
layername,
'base.view_resourcebase',
_PERMISSION_MSG_VIEW)
# assert False, str(layer_bbox)
config = layer.attribute_config()
# TODO (Mapstory): This has been commented out to force the client to make a getCapabilities request in order
# to pull in the time dimension data. Ideally we would cache time data just like the srs and bbox data to prevent
# making the getCapabilities request.
# Add required parameters for GXP lazy-loading
#layer_bbox = layer.bbox
#bbox = [float(coord) for coord in list(layer_bbox[0:4])]
#srid = layer.srid
# Transform WGS84 to Mercator.
#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.name,
ows_url=layer.ows_url,
layer_params=json.dumps(config))
# Update count for popularity ranking,
# but do not includes admins or resource owners
if request.user != layer.owner and not request.user.is_superuser:
Layer.objects.filter(
id=layer.id).update(popular_count=F('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)
if request.method == "POST":
if 'keywords' in request.POST:
keywords_form = KeywordsForm(request.POST, instance=layer)
if keywords_form.is_valid():
keywords_form.save()
new_keywords = keywords_form.cleaned_data['keywords']
layer.keywords.set(*new_keywords)
layer.save()
metadata_form = MetadataForm(instance=layer)
published_form = PublishStatusForm(instance=layer)
elif 'title' in request.POST:
metadata_form = MetadataForm(request.POST, instance=layer)
if metadata_form.is_valid():
metadata_form.save()
# update all the metadata
if metadata_form.cleaned_data['category'] is not None:
new_category = TopicCategory.objects.get(id=metadata_form.cleaned_data['category'].id)
Layer.objects.filter(id=layer.id).update(category=new_category)
layer.title = metadata_form.cleaned_data['title']
layer.language = metadata_form.cleaned_data['language']
layer.distribution_url = metadata_form.cleaned_data['distribution_url']
layer.data_quality_statement = metadata_form.cleaned_data['data_quality_statement']
layer.purpose = metadata_form.cleaned_data['purpose']
layer.is_published = metadata_form.cleaned_data['is_published']
layer.save()
keywords_form = KeywordsForm(instance=layer)
elif 'add_keyword' in request.POST:
layer.keywords.add(request.POST['add_keyword'])
layer.save()
elif 'remove_keyword' in request.POST:
layer.keywords.remove(request.POST['remove_keyword'])
layer.save()
else:
keywords_form = KeywordsForm(instance=layer)
metadata_form = MetadataForm(instance=layer)
content_moderators = Group.objects.filter(name='content_moderator').first()
context_dict = {
"resource": layer,
"permissions_json": _perms_info_json(layer),
"documents": get_related_documents(layer),
"metadata": metadata,
"is_layer": True,
"wps_enabled": settings.OGC_SERVER['default']['WPS_ENABLED'],
"keywords_form": keywords_form,
"metadata_form": metadata_form,
"content_moderators": content_moderators,
}
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 request.user.has_perm('download_resourcebase', layer.get_self_resource()):
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
shapefile_link = layer.link_set.download().filter(mime='SHAPE-ZIP').first()
if shapefile_link is not None:
shapefile_link = shapefile_link.url + '&featureID=fakeID'
context_dict["shapefile_link"] = shapefile_link
csv_link = layer.link_set.download().filter(mime='csv').first()
if csv_link is not None:
csv_link = csv_link.url + '&featureID=fakeID'
context_dict["csv_link"] = csv_link
if settings.SOCIAL_ORIGINS:
context_dict["social_links"] = build_social_links(request, layer)
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)
# 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:
MapStory.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)
chapters = map_obj.chapters
layers = []
for chapter in chapters:
layers = layers + list(chapter.local_layers)
print layers
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,
'base.view_resourcebase',
_PERMISSION_MSG_VIEW)
# assert False, str(layer_bbox)
config = layer.attribute_config()
# Add required parameters for GXP lazy-loading
layer_bbox = layer.bbox[0:4]
bbox = layer_bbox[:]
bbox[0] = float(layer_bbox[0])
bbox[1] = float(layer_bbox[2])
bbox[2] = float(layer_bbox[1])
bbox[3] = float(layer_bbox[3])
def decimal_encode(bbox):
import decimal
_bbox = []
for o in [float(coord) for coord in bbox]:
if isinstance(o, decimal.Decimal):
o = (str(o) for o in [o])
_bbox.append(o)
# Must be in the form : [x0, x1, y0, y1
return [_bbox[0], _bbox[2], _bbox[1], _bbox[3]]
def sld_definition(style):
from urllib import quote
_sld = {
"title": style.sld_title or style.name,
"legend": {
"height": "40",
"width": "22",
"href": layer.ows_url +
"?service=wms&request=GetLegendGraphic&format=image%2Fpng&width=20&height=20&layer=" +
quote(layer.service_typename, safe=''),
"format": "image/png"
},
"name": style.name
}
return _sld
if hasattr(layer, 'srid'):
config['crs'] = {
'type': 'name',
'properties': layer.srid
}
# Add required parameters for GXP lazy-loading
attribution = "%s %s" % (layer.owner.first_name,
layer.owner.last_name) if layer.owner.first_name or layer.owner.last_name else str(
layer.owner)
srs = getattr(settings, 'DEFAULT_MAP_CRS', 'EPSG:3857')
srs_srid = int(srs.split(":")[1]) if srs != "EPSG:900913" else 3857
config["attribution"] = "<span class='gx-attribution-title'>%s</span>" % attribution
config["format"] = getattr(
settings, 'DEFAULT_LAYER_FORMAT', 'image/png')
config["title"] = layer.title
config["wrapDateLine"] = True
config["visibility"] = True
config["srs"] = srs
config["bbox"] = decimal_encode(
bbox_to_projection([float(coord) for coord in layer_bbox] + [layer.srid, ],
target_srid=int(srs.split(":")[1]))[:4])
config["capability"] = {
"abstract": layer.abstract,
"name": layer.alternate,
"title": layer.title,
"queryable": True,
"storeType": layer.storeType,
"bbox": {
layer.srid: {
"srs": layer.srid,
"bbox": decimal_encode(bbox)
},
srs: {
"srs": srs,
"bbox": decimal_encode(
bbox_to_projection([float(coord) for coord in layer_bbox] + [layer.srid, ],
target_srid=srs_srid)[:4])
},
"EPSG:4326": {
"srs": "EPSG:4326",
"bbox": decimal_encode(bbox) if layer.srid == 'EPSG:4326' else
decimal_encode(bbox_to_projection(
[float(coord) for coord in layer_bbox] + [layer.srid, ], target_srid=4326)[:4])
},
"EPSG:900913": {
"srs": "EPSG:900913",
"bbox": decimal_encode(bbox) if layer.srid == 'EPSG:900913' else
decimal_encode(bbox_to_projection(
[float(coord) for coord in layer_bbox] + [layer.srid, ], target_srid=3857)[:4])
}
},
"srs": {
srs: True
},
"formats": ["image/png", "application/atom xml", "application/atom+xml", "application/json;type=utfgrid",
"application/openlayers", "application/pdf", "application/rss xml", "application/rss+xml",
"application/vnd.google-earth.kml", "application/vnd.google-earth.kml xml",
"application/vnd.google-earth.kml+xml", "application/vnd.google-earth.kml+xml;mode=networklink",
"application/vnd.google-earth.kmz", "application/vnd.google-earth.kmz xml",
"application/vnd.google-earth.kmz+xml", "application/vnd.google-earth.kmz;mode=networklink",
"atom", "image/geotiff", "image/geotiff8", "image/gif", "image/gif;subtype=animated",
"image/jpeg", "image/png8", "image/png; mode=8bit", "image/svg", "image/svg xml",
"image/svg+xml", "image/tiff", "image/tiff8", "image/vnd.jpeg-png",
"kml", "kmz", "openlayers", "rss", "text/html; subtype=openlayers", "utfgrid"],
"attribution": {
"title": attribution
},
"infoFormats": ["text/plain", "application/vnd.ogc.gml", "text/xml", "application/vnd.ogc.gml/3.1.1",
"text/xml; subtype=gml/3.1.1", "text/html", "application/json"],
"styles": [sld_definition(s) for s in layer.styles.all()],
"prefix": layer.alternate.split(":")[0] if ":" in layer.alternate else "",
"keywords": [k.name for k in layer.keywords.all()] if layer.keywords else [],
"llbbox": decimal_encode(bbox) if layer.srid == 'EPSG:4326' else
decimal_encode(bbox_to_projection(
[float(coord) for coord in layer_bbox] + [layer.srid, ], target_srid=4326)[:4])
}
all_times = None
if check_ogc_backend(geoserver.BACKEND_PACKAGE):
from geonode.geoserver.views import get_capabilities
workspace, layername = layer.alternate.split(
":") if ":" in layer.alternate else (None, layer.alternate)
# WARNING Please make sure to have enabled DJANGO CACHE as per
# https://docs.djangoproject.com/en/2.0/topics/cache/#filesystem-caching
wms_capabilities_resp = get_capabilities(
request, layer.id, tolerant=True)
if wms_capabilities_resp.status_code >= 200 and wms_capabilities_resp.status_code < 400:
wms_capabilities = wms_capabilities_resp.getvalue()
if wms_capabilities:
import xml.etree.ElementTree as ET
e = ET.fromstring(wms_capabilities)
for atype in e.findall(
"./[Name='%s']/Extent[@name='time']" % (layername)):
dim_name = atype.get('name')
if dim_name:
dim_name = str(dim_name).lower()
if dim_name == 'time':
dim_values = atype.text
if dim_values:
all_times = dim_values.split(",")
break
if all_times:
config["capability"]["dimensions"] = {
"time": {
"name": "time",
"units": "ISO8601",
"unitsymbol": None,
"nearestVal": False,
"multipleVal": False,
"current": False,
"default": "current",
"values": all_times
}
}
if layer.storeType == "remoteStore":
service = layer.remote_service
source_params = {}
if service.type in ('REST_MAP', 'REST_IMG'):
source_params = {
"ptype": service.ptype,
"remote": True,
"url": service.service_url,
"name": service.name,
"title": "[R] %s" % service.title}
maplayer = GXPLayer(
name=layer.alternate,
ows_url=layer.ows_url,
layer_params=json.dumps(config),
source_params=json.dumps(source_params)
)
else:
maplayer = GXPLayer(
name=layer.alternate,
ows_url=layer.ows_url,
layer_params=json.dumps(config)
)
# Update count for popularity ranking,
# but do not includes admins or resource owners
layer.view_count_up(request.user)
# center/zoom don't matter; the viewer will center on the layer bounds
map_obj = GXPMap(
sender=Layer,
projection=getattr(
settings,
'DEFAULT_MAP_CRS',
'EPSG:3857'))
NON_WMS_BASE_LAYERS = [
la for la in default_map_config(request)[1] if la.ows_url is None]
metadata = layer.link_set.metadata().filter(
name__in=settings.DOWNLOAD_FORMATS_METADATA)
granules = None
all_granules = None
all_times = None
filter = None
if layer.is_mosaic:
try:
cat = gs_catalog
cat._cache.clear()
store = cat.get_store(layer.name)
coverages = cat.mosaic_coverages(store)
filter = None
try:
if request.GET["filter"]:
filter = request.GET["filter"]
except BaseException:
pass
offset = 10 * (request.page - 1)
granules = cat.mosaic_granules(
coverages['coverages']['coverage'][0]['name'],
store,
limit=10,
offset=offset,
filter=filter)
all_granules = cat.mosaic_granules(
coverages['coverages']['coverage'][0]['name'], store, filter=filter)
except BaseException:
granules = {"features": []}
all_granules = {"features": []}
if check_ogc_backend(geoserver.BACKEND_PACKAGE):
from geonode.geoserver.views import get_capabilities
workspace, layername = layer.alternate.split(
":") if ":" in layer.alternate else (None, layer.alternate)
# WARNING Please make sure to have enabled DJANGO CACHE as per
# https://docs.djangoproject.com/en/2.0/topics/cache/#filesystem-caching
wms_capabilities_resp = get_capabilities(
request, layer.id, tolerant=True)
if wms_capabilities_resp.status_code >= 200 and wms_capabilities_resp.status_code < 400:
wms_capabilities = wms_capabilities_resp.getvalue()
if wms_capabilities:
import xml.etree.ElementTree as ET
e = ET.fromstring(wms_capabilities)
for atype in e.findall(
"./[Name='%s']/Extent[@name='time']" % (layername)):
dim_name = atype.get('name')
if dim_name:
dim_name = str(dim_name).lower()
if dim_name == 'time':
dim_values = atype.text
if dim_values:
all_times = dim_values.split(",")
break
group = None
if layer.group:
try:
group = GroupProfile.objects.get(slug=layer.group.name)
except GroupProfile.DoesNotExist:
group = None
# a flag to be used for qgis server
show_popup = False
if 'show_popup' in request.GET and request.GET["show_popup"]:
show_popup = True
###
# MapStory Specific Changes
###
keywords = json.dumps([tag.name for tag in layer.keywords.all()])
if request.method == "POST":
keywords_form = KeywordsForm(request.POST, instance=layer)
metadata_form = MetadataForm(instance=layer)
distributionurl_form = DistributionUrlForm(
request.POST, instance=layer)
if 'keywords' in request.POST:
if keywords_form.is_valid():
keywords_form.save()
new_keywords = keywords_form.cleaned_data['keywords']
layer.keywords.set(*new_keywords)
layer.save()
metadata_form = MetadataForm(instance=layer)
elif 'title' in request.POST:
metadata_form = MetadataForm(request.POST, instance=layer)
if metadata_form.is_valid():
metadata_form.save()
# update all the metadata
if metadata_form.cleaned_data['category'] is not None:
new_category = TopicCategory.objects.get(
id=metadata_form.cleaned_data['category'].id)
Layer.objects.filter(id=layer.id).update(
category=new_category)
layer.title = metadata_form.cleaned_data['title']
layer.language = metadata_form.cleaned_data['language']
layer.data_quality_statement = metadata_form.cleaned_data['data_quality_statement']
layer.purpose = metadata_form.cleaned_data['purpose']
layer.is_published = metadata_form.cleaned_data['is_published']
layer.save()
if distributionurl_form.is_valid():
layer.distribution_url = distributionurl_form.cleaned_data['distribution_url']
keywords_form = KeywordsForm(instance=layer)
if 'add_keyword' in request.POST:
layer.keywords.add(request.POST['add_keyword'])
layer.save()
if 'remove_keyword' in request.POST:
layer.keywords.remove(request.POST['remove_keyword'])
layer.save()
else:
keywords_form = KeywordsForm(instance=layer)
metadata_form = MetadataForm(instance=layer)
distributionurl_form = DistributionUrlForm(instance=layer)
content_moderators = Group.objects.filter(name='content_moderator').first()
thumbnail = layer.get_thumbnail_url
# This will get URL encoded later and is used for the social media share URL
share_url = "https://%s/layers/%s" % (request.get_host(), layer.typename)
share_title = "%s by %s." % (layer.title, layer.owner)
share_description = layer.abstract
# Get membership buttons ready:
admin_memberships = []
# Check if user is admin in one of those organizations
users_org_memberships = OrganizationMembership.objects.filter(
user_id=request.user.pk)
for membership in users_org_memberships.all():
# We have permission if we own the layer, or if we are an organization's admin.
if (layer.owner == request.user) or membership.is_admin:
admin_memberships.append(membership)
if len(admin_memberships) < 1:
admin_memberships = None
ini_memberships = []
# Checks if user is admin for Inititives
user_ini_memberships = InitiativeMembership.objects.filter(
user_id=request.user.pk)
for membership in user_ini_memberships.all():
if(layer.owner == request.user) or membership.is_admin:
ini_memberships.append(membership)
if len(ini_memberships) < 1:
ini_memberships = None
shapefile_link = layer.link_set.download().filter(mime='SHAPE-ZIP').first()
if shapefile_link is not None:
shapefile_link = shapefile_link.url + '&featureID=fakeID' + '&maxFeatures=1'
request.session['shp_name'] = layer.typename
request.session['shp_link'] = shapefile_link
csv_link = layer.link_set.download().filter(mime='csv').first()
if csv_link is not None:
csv_link = csv_link.url + '&featureID=fakeID' + '&maxFeatures=1'
request.session['csv_name'] = layer.typename
request.session['csv_link'] = csv_link
###
# End MapStory Specific Changes
###
context_dict = {
'resource': layer,
'group': group,
'perms_list': get_perms(request.user, layer.get_self_resource()),
"permissions_json": _perms_info_json(layer),
"documents": get_related_documents(layer),
"metadata": metadata,
"is_layer": True,
"wps_enabled": settings.OGC_SERVER['default']['WPS_ENABLED'],
"granules": granules,
"all_granules": all_granules,
"all_times": all_times,
"show_popup": show_popup,
"filter": filter,
"storeType": layer.storeType,
# MapStory Specific Additions
"keywords": keywords,
"keywords_form": keywords_form,
"metadata_form": metadata_form,
"distributionurl_form": distributionurl_form,
"content_moderators": content_moderators,
"thumbnail": thumbnail,
"share_url": share_url,
"share_title": share_title,
"share_description": share_description,
"organizations": admin_memberships,
"initiatives": ini_memberships
# "online": (layer.remote_service.probe == 200) if layer.storeType == "remoteStore" else True
}
if request and 'access_token' in request.session:
access_token = request.session['access_token']
else:
u = uuid.uuid1()
access_token = u.hex
context_dict["viewer"] = json.dumps(map_obj.viewer_json(
request, * (NON_WMS_BASE_LAYERS + [maplayer])))
context_dict["preview"] = getattr(
settings,
'GEONODE_CLIENT_LAYER_PREVIEW_LIBRARY',
'geoext')
context_dict["crs"] = getattr(
settings,
'DEFAULT_MAP_CRS',
'EPSG:3857')
# provide bbox in EPSG:4326 for leaflet
if context_dict["preview"] == 'leaflet':
srid, wkt = layer.geographic_bounding_box.split(';')
srid = re.findall(r'\d+', srid)
geom = GEOSGeometry(wkt, srid=int(srid[0]))
geom.transform(4326)
context_dict["layer_bbox"] = ','.join([str(c) for c in geom.extent])
if layer.storeType == 'dataStore':
links = layer.link_set.download().filter(
Q(name__in=settings.DOWNLOAD_FORMATS_VECTOR) |
Q(link_type='original'))
else:
links = layer.link_set.download().filter(
Q(name__in=settings.DOWNLOAD_FORMATS_RASTER) |
Q(link_type='original'))
links_view = [item for idx, item in enumerate(links) if
item.url and 'wms' in item.url or 'gwc' in item.url]
links_download = [item for idx, item in enumerate(
links) if item.url and 'wms' not in item.url and 'gwc' not in item.url]
for item in links_view:
if item.url and access_token and 'access_token' not in item.url:
params = {'access_token': access_token}
item.url = Request('GET', item.url, params=params).prepare().url
for item in links_download:
if item.url and access_token and 'access_token' not in item.url:
params = {'access_token': access_token}
item.url = Request('GET', item.url, params=params).prepare().url
if request.user.has_perm('view_resourcebase', layer.get_self_resource()):
context_dict["links"] = links_view
if request.user.has_perm(
'download_resourcebase',
layer.get_self_resource()):
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_download"] = links_download
if settings.SOCIAL_ORIGINS:
context_dict["social_links"] = build_social_links(request, layer)
layers_names = layer.alternate
try:
if settings.DEFAULT_WORKSPACE and settings.DEFAULT_WORKSPACE in layers_names:
workspace, name = layers_names.split(':', 1)
else:
name = layers_names
except BaseException:
logger.error("Can not identify workspace type and layername")
context_dict["layer_name"] = json.dumps(layers_names)
try:
# get type of layer (raster or vector)
if layer.storeType == 'coverageStore':
context_dict["layer_type"] = "raster"
elif layer.storeType == 'dataStore':
if layer.has_time:
context_dict["layer_type"] = "vector_time"
else:
context_dict["layer_type"] = "vector"
location = "{location}{service}".format(** {
'location': settings.OGC_SERVER['default']['LOCATION'],
'service': 'wms',
})
# get schema for specific layer
username = settings.OGC_SERVER['default']['USER']
password = settings.OGC_SERVER['default']['PASSWORD']
schema = get_schema(
location,
name,
username=username,
password=password)
# get the name of the column which holds the geometry
if 'the_geom' in schema['properties']:
schema['properties'].pop('the_geom', None)
elif 'geom' in schema['properties']:
schema['properties'].pop("geom", None)
# filter the schema dict based on the values of layers_attributes
layer_attributes_schema = []
for key in schema['properties'].keys():
layer_attributes_schema.append(key)
filtered_attributes = layer_attributes_schema
context_dict["schema"] = schema
context_dict["filtered_attributes"] = filtered_attributes
except BaseException:
logger.error(
"Possible error with OWSLib. Turning all available properties to string")
if settings.GEOTIFF_IO_ENABLED:
from geonode.contrib.geotiffio import create_geotiff_io_url
context_dict["link_geotiff_io"] = create_geotiff_io_url(
layer, access_token)
# maps owned by user needed to fill the "add to existing map section" in template
if request.user.is_authenticated():
context_dict["maps"] = Map.objects.filter(owner=request.user)
return TemplateResponse(
request, template, context=context_dict)
def map_detail(request, slug, snapshot=None, template='maps/map_detail.html'):
'''
The view that show details of each map
'''
# MapStory specific change from mapid parameter to slug parameter
map_obj = _resolve_map(
request, slug, '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, 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)
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
###
# MapStory Specific Changes
###
chapters = map_obj.chapters
# Overwrite the layers list so that we can add all layers from all chapters.
layers = []
for chapter in chapters:
layers = layers + list(chapter.local_layers)
keywords = json.dumps([tag.name for tag in map_obj.keywords.all()])
if request.method == "POST":
keywords_form = KeywordsForm(request.POST, instance=map_obj)
published_form = PublishStatusForm(instance=map_obj)
if 'keywords' in request.POST:
if keywords_form.is_valid():
new_keywords = keywords_form.cleaned_data['keywords']
map_obj.keywords.add(*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)
map_thumbnail = map_obj.get_thumbnail_url
update_es_index(MapStory, MapStory.objects.get(id=map_obj.id))
# This will get URL encoded later and is used for the social media share URL
share_url = "https://%s/story/%s" % (request.get_host(), map_obj.slug)
share_title = "%s by %s." % (map_obj.title, map_obj.owner)
share_description = map_obj.abstract
# Check if user is admin in one of those organizations
org_admin_memberships = []
memberships = OrganizationMembership.objects.filter(
user_id=request.user.pk)
for membership in memberships.all():
if membership.is_admin:
org_admin_memberships.append(membership)
if len(org_admin_memberships) < 1:
org_admin_memberships = None
ini_memberships = InitiativeMembership.objects.filter(
user_id=request.user.pk)
ini_admin_memberships = []
for m in ini_memberships.all():
if m.is_admin:
ini_admin_memberships.append(m)
if len(ini_admin_memberships) < 1:
ini_admin_memberships = None
###
# End MapStory Specific Changes
###
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,
# MapStory Specific Additions
'keywords': keywords,
'keywords_form': keywords_form,
'published_form': published_form,
'thumbnail': map_thumbnail,
'share_url': share_url,
'share_title': share_title,
'share_description': share_description,
'organizations': org_admin_memberships,
'initiatives': ini_admin_memberships,
}
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)
# Favorites
if request.user.is_authenticated():
context_dict["favorite_info"] = get_favorite_info(
request.user, map_obj)
return render(request, template, context=context_dict)
def map_detail(request, slug, snapshot=None, template='maps/map_detail.html'):
'''
The view that show details of each map
'''
# MapStory specific change from mapid parameter to slug parameter
map_obj = _resolve_map(request, slug, '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, 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)
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
###
# MapStory Specific Changes
###
chapters = map_obj.chapters
# Overwrite the layers list so that we can add all layers from all chapters.
layers = []
for chapter in chapters:
layers = layers + list(chapter.local_layers)
keywords = json.dumps([tag.name for tag in map_obj.keywords.all()])
if request.method == "POST":
keywords_form = KeywordsForm(request.POST, instance=map_obj)
published_form = PublishStatusForm(instance=map_obj)
if 'keywords' in request.POST:
if keywords_form.is_valid():
new_keywords = keywords_form.cleaned_data['keywords']
map_obj.keywords.add(*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)
map_thumbnail = map_obj.get_thumbnail_url
update_es_index(MapStory, MapStory.objects.get(id=map_obj.id))
# This will get URL encoded later and is used for the social media share URL
share_url = "https://%s/story/%s" % (request.get_host(), map_obj.slug)
share_title = "%s by %s." % (map_obj.title, map_obj.owner)
share_description = map_obj.abstract
# Check if user is admin in one of those organizations
org_admin_memberships = []
memberships = OrganizationMembership.objects.filter(
user_id=request.user.pk)
for membership in memberships.all():
if membership.is_admin:
org_admin_memberships.append(membership)
if len(org_admin_memberships) < 1:
org_admin_memberships = None
ini_memberships = InitiativeMembership.objects.filter(
user_id=request.user.pk)
ini_admin_memberships = []
for m in ini_memberships.all():
if m.is_admin:
ini_admin_memberships.append(m)
if len(ini_admin_memberships) < 1:
ini_admin_memberships = None
###
# End MapStory Specific Changes
###
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,
# MapStory Specific Additions
'keywords': keywords,
'keywords_form': keywords_form,
'published_form': published_form,
'thumbnail': map_thumbnail,
'share_url': share_url,
'share_title': share_title,
'share_description': share_description,
'organizations': org_admin_memberships,
'initiatives': ini_admin_memberships,
}
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)
# Favorites
if request.user.is_authenticated():
context_dict["favorite_info"] = get_favorite_info(
request.user, map_obj)
return render(request, template, context=context_dict)
def layer_detail(request, layername, template='layers/layer_detail.html'):
layer = _resolve_layer(
request,
layername,
'base.view_resourcebase',
_PERMISSION_MSG_VIEW)
# assert False, str(layer_bbox)
config = layer.attribute_config()
# only owners and admins can view unpublished layers
if not layer.is_published:
if request.user != layer.owner and not request.user.is_superuser:
return HttpResponse(_PERMISSION_MSG_VIEW, status=403, content_type="text/plain")
# TODO (Mapstory): This has been commented out to force the client to make a getCapabilities request in order
# to pull in the time dimension data. Ideally we would cache time data just like the srs and bbox data to prevent
# making the getCapabilities request.
# Add required parameters for GXP lazy-loading
#layer_bbox = layer.bbox
#bbox = [float(coord) for coord in list(layer_bbox[0:4])]
#srid = layer.srid
# Transform WGS84 to Mercator.
#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.name,
ows_url=layer.ows_url,
layer_params=json.dumps(config))
# Update count for popularity ranking,
# but do not includes admins or resource owners
if request.user != layer.owner and not request.user.is_superuser:
Layer.objects.filter(
id=layer.id).update(popular_count=F('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)
keywords = json.dumps([tag.name for tag in layer.keywords.all()])
if request.method == "POST":
keywords_form = KeywordsForm(request.POST, instance=layer)
metadata_form = MetadataForm(instance=layer)
if 'keywords' in request.POST:
if keywords_form.is_valid():
keywords_form.save()
new_keywords = keywords_form.cleaned_data['keywords']
layer.keywords.set(*new_keywords)
layer.save()
metadata_form = MetadataForm(instance=layer)
published_form = PublishStatusForm(instance=layer)
elif 'title' in request.POST:
metadata_form = MetadataForm(request.POST, instance=layer)
if metadata_form.is_valid():
metadata_form.save()
# update all the metadata
if metadata_form.cleaned_data['category'] is not None:
new_category = TopicCategory.objects.get(id=metadata_form.cleaned_data['category'].id)
Layer.objects.filter(id=layer.id).update(category=new_category)
layer.title = metadata_form.cleaned_data['title']
layer.language = metadata_form.cleaned_data['language']
layer.distribution_url = metadata_form.cleaned_data['distribution_url']
layer.data_quality_statement = metadata_form.cleaned_data['data_quality_statement']
layer.purpose = metadata_form.cleaned_data['purpose']
layer.is_published = metadata_form.cleaned_data['is_published']
layer.save()
keywords_form = KeywordsForm(instance=layer)
elif 'add_keyword' in request.POST:
layer.keywords.add(request.POST['add_keyword'])
layer.save()
elif 'remove_keyword' in request.POST:
layer.keywords.remove(request.POST['remove_keyword'])
layer.save()
else:
keywords_form = KeywordsForm(instance=layer)
metadata_form = MetadataForm(instance=layer)
content_moderators = Group.objects.filter(name='content_moderator').first()
thumbnail_dir = os.path.join(settings.MEDIA_ROOT, 'thumbs')
default_thumbnail_array = layer.get_thumbnail_url().split('/')
default_thumbnail_name = default_thumbnail_array[
len(default_thumbnail_array) - 1
]
default_thumbnail = os.path.join(thumbnail_dir, default_thumbnail_name)
if request.method == 'POST':
thumb_form = ThumbnailImageForm(request.POST, request.FILES)
if thumb_form.is_valid():
new_img = ThumbnailImage(
thumbnail_image=request.FILES['thumbnail_image']
)
new_img.save()
user_upload_thumbnail = ThumbnailImage.objects.all()[0]
user_upload_thumbnail_filepath = str(
user_upload_thumbnail.thumbnail_image
)
# only create backup for original thumbnail
if os.path.isfile(default_thumbnail + '.bak') is False:
os.rename(default_thumbnail, default_thumbnail + '.bak')
os.rename(user_upload_thumbnail_filepath, default_thumbnail)
else:
thumb_form = ThumbnailImageForm()
thumbnail = layer.get_thumbnail_url
context_dict = {
"resource": layer,
"permissions_json": _perms_info_json(layer),
"documents": get_related_documents(layer),
"metadata": metadata,
"keywords": keywords,
"is_layer": True,
"wps_enabled": settings.OGC_SERVER['default']['WPS_ENABLED'],
"keywords_form": keywords_form,
"metadata_form": metadata_form,
"content_moderators": content_moderators,
"thumbnail": thumbnail,
"thumb_form": thumb_form
}
context_dict["viewer"] = json.dumps(
map_obj.viewer_json(request.user, * (NON_WMS_BASE_LAYERS + [maplayer])))
context_dict["preview"] = getattr(
settings,
'LAYER_PREVIEW_LIBRARY')
if request.user.has_perm('download_resourcebase', layer.get_self_resource()):
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
layer_property_names = []
for attrib in layer.attributes:
if attrib.attribute not in settings.SCHEMA_DOWNLOAD_EXCLUDE and not (attrib.attribute.endswith('_xd') or attrib.attribute.endswith('_parsed')):
layer_property_names.append(attrib.attribute)
layer_attrib_string = ','.join(layer_property_names)
shapefile_link = layer.link_set.download().filter(mime='SHAPE-ZIP').first()
if shapefile_link is not None:
shapefile_link = shapefile_link.url + '&featureID=fakeID' + '&propertyName=' + layer_attrib_string
context_dict["shapefile_link"] = shapefile_link
csv_link = layer.link_set.download().filter(mime='csv').first()
if csv_link is not None:
csv_link = csv_link.url + '&featureID=fakeID' + '&propertyName=' + layer_attrib_string
context_dict["csv_link"] = csv_link
if settings.SOCIAL_ORIGINS:
context_dict["social_links"] = build_social_links(request, layer)
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)
# 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:
MapStory.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)
chapters = map_obj.chapters
layers = []
for chapter in chapters:
layers = layers + list(chapter.local_layers)
keywords = json.dumps([tag.name for tag in map_obj.keywords.all()])
if request.method == "POST":
keywords_form = KeywordsForm(request.POST, instance=map_obj)
published_form = PublishStatusForm(instance=map_obj)
if 'keywords' in request.POST:
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)
map_thumbnail_dir = os.path.join(settings.MEDIA_ROOT, 'thumbs')
map_default_thumbnail_array = map_obj.get_thumbnail_url().split('/')
map_default_thumbnail_name = 'map' + str(mapid) + '.jpg'
map_default_thumbnail = os.path.join(map_thumbnail_dir,
map_default_thumbnail_name)
# TODO: create function to handle map and layer thumbs
if request.method == 'POST':
map_thumb_form = ThumbnailImageForm(request.POST, request.FILES)
if map_thumb_form.is_valid():
map_new_img = ThumbnailImage(
thumbnail_image=request.FILES['thumbnail_image']
)
map_new_img.save()
map_obj.save_thumbnail(map_default_thumbnail_name, map_new_img)
map_user_upload_thumbnail = ThumbnailImage.objects.all()[0]
map_user_upload_thumbnail_filepath = str(
map_user_upload_thumbnail.thumbnail_image
)
os.rename(map_user_upload_thumbnail_filepath,
map_default_thumbnail)
else:
map_thumb_form = ThumbnailImageForm()
map_thumbnail = map_obj.get_thumbnail_url
update_es_index(MapStory, MapStory.objects.get(id=map_obj.id))
context_dict = {
'config': config,
'resource': map_obj,
'layers': layers,
'keywords': keywords,
'permissions_json': _perms_info_json(map_obj),
'documents': get_related_documents(map_obj),
'keywords_form': keywords_form,
'published_form': published_form,
'thumbnail': map_thumbnail,
'thumb_form': map_thumb_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 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:
MapStory.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)
chapters = map_obj.chapters
layers = []
for chapter in chapters:
layers = layers + list(chapter.local_layers)
keywords = json.dumps([tag.name for tag in map_obj.keywords.all()])
if request.method == "POST":
keywords_form = KeywordsForm(request.POST, instance=map_obj)
published_form = PublishStatusForm(instance=map_obj)
if 'keywords' in request.POST:
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)
map_thumbnail_dir = os.path.join(settings.MEDIA_ROOT, 'thumbs')
map_default_thumbnail_array = map_obj.get_thumbnail_url().split('/')
map_default_thumbnail_name = 'map' + str(mapid) + '.jpg'
map_default_thumbnail = os.path.join(map_thumbnail_dir,
map_default_thumbnail_name)
# TODO: create function to handle map and layer thumbs
if request.method == 'POST':
map_thumb_form = ThumbnailImageForm(request.POST, request.FILES)
if map_thumb_form.is_valid():
map_new_img = ThumbnailImage(
thumbnail_image=request.FILES['thumbnail_image'])
map_new_img.save()
map_obj.save_thumbnail(map_default_thumbnail_name, map_new_img)
map_user_upload_thumbnail = ThumbnailImage.objects.all()[0]
map_user_upload_thumbnail_filepath = str(
map_user_upload_thumbnail.thumbnail_image)
os.rename(map_user_upload_thumbnail_filepath,
map_default_thumbnail)
else:
map_thumb_form = ThumbnailImageForm()
map_thumbnail = map_obj.get_thumbnail_url
update_es_index(MapStory, MapStory.objects.get(id=map_obj.id))
context_dict = {
'config': config,
'resource': map_obj,
'layers': layers,
'keywords': keywords,
'permissions_json': _perms_info_json(map_obj),
'documents': get_related_documents(map_obj),
'keywords_form': keywords_form,
'published_form': published_form,
'thumbnail': map_thumbnail,
'thumb_form': map_thumb_form
}
if settings.SOCIAL_ORIGINS:
context_dict["social_links"] = build_social_links(request, map_obj)
return render_to_response(template, RequestContext(request, context_dict))
