def new_linked_map(request, smapid, snapshot=None, template='maps/map_view.html'):
"""
The view that returns the map composer opened to
the map with the given map ID.
"""
smap=StaticMap.objects.filter(id=smapid)
DEFAULT_MAP_CONFIG, DEFAULT_BASE_LAYERS = default_map_config()
m = Map()
user = request.user
m.owner = user
m.title = 'GISMap_%s' % smap[0].title
m.abstract = DEFAULT_ABSTRACT
m.projection = "EPSG:900913"
m.zoom = 0
m.center_x = 0
m.center_y = 0
m.save()
smap.update(linked_map=m.id)
if snapshot is None:
config = m.viewer_json(request.user, *DEFAULT_BASE_LAYERS)
else:
config = snapshot_config(snapshot, m, request.user)
return render_to_response(template, RequestContext(request, {
'config': json.dumps(config),
'map': m
}))
def ncWms_detail(request, layerpart1, layerpart2,
template='layers/ncWMS_layer_details.html'):
"""Handle Layer Details and Time Series Playback"""
layer = layerpart1+ '/' + layerpart2
wms1 = request.session['wms']
w_url = request.session['url']
wms_times = wms1[layer].timepositions
times = [time.strip() for time in wms_times]
wms_name = wms1.identification.title
#for downloading layer
download_links = ['full dataset', 'spatial subset', 'temporal subset', 'spatio-temporal subset' ]
links = opendap_links()
map_obj = GXPMap(projection="EPSG:900913")
DEFAULT_BASE_LAYERS = default_map_config()[1]
return render_to_response(template, RequestContext(request, {
"w_name": wms_name,
"w_url": w_url,
"layer": layer,
"w_times": json.dumps(times),
"links_" : download_links,
"links" : links,
"viewer": json.dumps(map_obj.viewer_json(* (DEFAULT_BASE_LAYERS + []))),
}))
def map_embed(
request,
mapid=None,
snapshot=None,
template='maps/map_embed.html'):
if mapid is None:
config = default_map_config()[0]
else:
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)
if snapshot is None:
config = map_obj.viewer_json(request.user)
else:
config = snapshot_config(snapshot, map_obj, request.user)
return render_to_response(template, RequestContext(request, {
'config': json.dumps(config)
}))
def map_embed(
request,
mapid=None,
snapshot=None,
template='maps/map_embed.html'):
if mapid is None:
config = default_map_config(request)[0]
else:
map_obj = _resolve_map(
request,
mapid,
'base.view_resourcebase',
_PERMISSION_MSG_VIEW)
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)
return render_to_response(template, RequestContext(request, {
'config': json.dumps(config)
}))
def layer_edit(request, layername, template='layers/layer_edit.html'):
"""
The view that returns the map composer opened to
a map with the given layername.
"""
user = get_valid_user()
ogc_server_settings.DATASTORE = request.user.profile.user.username
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]
config = map_obj.viewer_json(* (DEFAULT_BASE_LAYERS + [maplayer]))
return render_to_response(template, RequestContext(request, {
'config': json.dumps(config),
'map': map_obj
}))
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_embed(request, mapid=None, template="maps/map_embed.html"):
if mapid is None:
config = default_map_config()[0]
else:
map_obj = _resolve_map(request, mapid, "maps.view_map")
config = map_obj.viewer_json()
return render_to_response(template, RequestContext(request, {"config": json.dumps(config)}))
def create_from_layer_list(self, user, layers, title, abstract):
self.owner = user
self.title = title
self.abstract = abstract
self.projection = getattr(settings, 'DEFAULT_MAP_CRS', 'EPSG:3857')
self.zoom = 0
self.center_x = 0
self.center_y = 0
if self.uuid is None or self.uuid == '':
self.uuid = str(uuid.uuid1())
DEFAULT_MAP_CONFIG, DEFAULT_BASE_LAYERS = default_map_config(None)
_layers = []
for layer in layers:
if not isinstance(layer, Layer):
try:
layer = Layer.objects.get(alternate=layer)
except ObjectDoesNotExist:
raise Exception(
'Could not find layer with name %s' %
layer)
if not user.has_perm(
'base.view_resourcebase',
obj=layer.resourcebase_ptr):
# invisible layer, skip inclusion or raise Exception?
logger.error(
'User %s tried to create a map with layer %s without having premissions' %
(user, layer))
else:
_layers.append(layer)
# Set bounding box based on all layers extents.
# bbox format: [xmin, xmax, ymin, ymax]
bbox = self.get_bbox_from_layers(_layers)
self.set_bounds_from_bbox(bbox, self.projection)
# Save the map in order to create an id in the database
# used below for the maplayers.
self.save()
if _layers and len(_layers) > 0:
index = 0
for layer in _layers:
MapLayer.objects.create(
map=self,
name=layer.alternate,
ows_url=layer.get_ows_url(),
stack_order=index,
visibility=True
)
index += 1
# Save again to persist the zoom and bbox changes and
# to generate the thumbnail.
self.set_missing_info()
self.save()
def create_from_layer_list(self, user, layers, title, abstract):
self.owner = user
self.title = title
self.abstract = abstract
self.projection="EPSG:900913"
self.zoom = 0
self.center_x = 0
self.center_y = 0
map_layers = []
bbox = None
index = 0
DEFAULT_MAP_CONFIG, DEFAULT_BASE_LAYERS = default_map_config()
layer_objects = []
for layer in layers:
try:
layer = Layer.objects.get(typename=layer)
except ObjectDoesNotExist:
continue # Raise exception?
if not user.has_perm('maps.view_layer', obj=layer):
# invisible layer, skip inclusion or raise Exception?
continue # Raise Exception
layer_objects.append(layer)
map_layers.append(MapLayer(
map = self,
name = layer.typename,
ows_url = settings.GEOSERVER_BASE_URL + "wms",
stack_order = index,
visibility = True
))
bbox = self.set_bounds_from_layers(layer_objects)
if bbox is not None:
minx, maxx, miny, maxy = [float(c) for c in bbox]
x = (minx + maxx) / 2
y = (miny + maxy) / 2
(self.center_x,self.center_y) = forward_mercator((x,y))
width_zoom = math.log(360 / (maxx - minx), 2)
height_zoom = math.log(360 / (maxy - miny), 2)
self.zoom = math.ceil(min(width_zoom, height_zoom))
index += 1
self.save()
for bl in DEFAULT_BASE_LAYERS:
bl.map = self
#bl.save()
for ml in map_layers:
ml.map = self # update map_id after saving map
ml.save()
self.set_default_permissions()
def test_new_map_config(self):
"""Test that new map config can be properly assigned
"""
c = Client()
c.login(username='******', password='******')
# Test successful new map creation
m = Map()
admin_user = User.objects.get(username='******')
layer_name = Layer.objects.all()[0].typename
m.create_from_layer_list(admin_user, [layer_name], "title", "abstract")
map_id = m.id
c = Client()
url = reverse('new_map_json')
# Test GET method with COPY
response = c.get(url,{'copy': map_id})
self.assertEquals(response.status_code,200)
map_obj = Map.objects.get(id=map_id)
config_map = map_obj.viewer_json()
response_config_dict = json.loads(response.content)
self.assertEquals(config_map['map']['layers'],response_config_dict['map']['layers'])
# Test GET method no COPY and no layer in params
response = c.get(url)
self.assertEquals(response.status_code,200)
config_default = default_map_config()[0]
response_config_dict = json.loads(response.content)
self.assertEquals(config_default['about']['abstract'],response_config_dict['about']['abstract'])
self.assertEquals(config_default['about']['title'],response_config_dict['about']['title'])
# Test GET method no COPY but with layer in params
response = c.get(url,{'layer':layer_name})
self.assertEquals(response.status_code,200)
response_dict = json.loads(response.content)
self.assertEquals(response_dict['fromLayer'],True)
# Test POST method without authentication
response = c.post(url,{'layer':layer_name})
self.assertEquals(response.status_code,401)
# Test POST method with authentication and a layer in params
c.login(username='******', password='******')
response = c.post(url,{'layer':layer_name})
# Should not accept the request
self.assertEquals(response.status_code,400)
# Test POST method with map data in json format
response = c.post(url, data=self.viewer_config,content_type="text/json")
self.assertEquals(response.status_code,200)
map_id = int(json.loads(response.content)['id'])
# Test methods other than GET or POST and no layer in params
response = c.put(url)
self.assertEquals(response.status_code,405)
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_embed(request, mapid=None, template='maps/map_embed.html'):
if mapid is None:
config = default_map_config()[0]
else:
map_obj = _resolve_map(request, mapid, 'base.view_resourcebase')
config = map_obj.viewer_json(request.user)
return render_to_response(template, RequestContext(request, {
'config': json.dumps(config)
}))
def create_from_layer_list(self, user, layers, title, abstract):
self.owner = user
self.title = title
self.abstract = abstract
self.projection = getattr(settings, 'DEFAULT_MAP_CRS', 'EPSG:900913')
self.zoom = 0
self.center_x = 0
self.center_y = 0
bbox = None
index = 0
DEFAULT_MAP_CONFIG, DEFAULT_BASE_LAYERS = default_map_config()
# Save the map in order to create an id in the database
# used below for the maplayers.
self.save()
for layer in layers:
if not isinstance(layer, Layer):
try:
layer = Layer.objects.get(typename=layer)
except ObjectDoesNotExist:
raise Exception(
'Could not find layer with name %s' %
layer)
if not user.has_perm(
'base.view_resourcebase',
obj=layer.resourcebase_ptr):
# invisible layer, skip inclusion or raise Exception?
raise Exception(
'User %s tried to create a map with layer %s without having premissions' %
(user, layer))
MapLayer.objects.create(
map=self,
name=layer.typename,
ows_url=layer.get_ows_url(),
stack_order=index,
visibility=True
)
index += 1
# Set bounding box based on all layers extents.
bbox = self.get_bbox_from_layers(self.local_layers)
self.set_bounds_from_bbox(bbox)
self.set_missing_info()
# Save again to persist the zoom and bbox changes and
# to generate the thumbnail.
self.save()
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 test_map_embed(self):
"""Test that map can be properly embedded
"""
# first create a map
c = Client()
# Test successful new map creation
c.login(username=self.user, password=self.passwd)
new_map = reverse('new_map_json')
response = c.post(
new_map,
data=self.viewer_config,
content_type="text/json")
self.assertEquals(response.status_code, 200)
map_id = int(json.loads(response.content)['id'])
c.logout()
url = reverse('map_embed', args=(map_id,))
url_no_id = reverse('map_embed')
# Now test with a map id
c.login(username=self.user, password=self.passwd)
response = c.get(url)
self.assertEquals(response.status_code, 200)
# The embedded map is exempt from X-FRAME-OPTIONS restrictions.
if hasattr(response, 'xframe_options_exempt'):
self.assertTrue(response.xframe_options_exempt)
# Config equals to that of the map whose id is given
map_obj = Map.objects.get(id=map_id)
config_map = map_obj.viewer_json(None)
response_config_dict = json.loads(response.context['config'])
self.assertEquals(
config_map['about']['abstract'],
response_config_dict['about']['abstract'])
self.assertEquals(
config_map['about']['title'],
response_config_dict['about']['title'])
# Now test without a map id
response = c.get(url_no_id)
self.assertEquals(response.status_code, 200)
# Config equals to that of the default map
config_default = default_map_config()[0]
response_config_dict = json.loads(response.context['config'])
self.assertEquals(
config_default['about']['abstract'],
response_config_dict['about']['abstract'])
self.assertEquals(
config_default['about']['title'],
response_config_dict['about']['title'])
def new_map_config(request):
'''
View that creates a new map.
If the query argument 'copy' is given, the initial map is
a copy of the map with the id specified, otherwise the
default map configuration is used. If copy is specified
and the map specified does not exist a 404 is returned.
'''
DEFAULT_MAP_CONFIG, DEFAULT_BASE_LAYERS = default_map_config(request)
if 'access_token' in request.session:
access_token = request.session['access_token']
else:
access_token = None
if request.method == 'GET' and 'copy' in request.GET:
mapid = request.GET['copy']
map_obj = _resolve_map(request, mapid, 'base.view_resourcebase')
map_obj.abstract = DEFAULT_ABSTRACT
map_obj.title = DEFAULT_TITLE
if request.user.is_authenticated():
map_obj.owner = request.user
config = map_obj.viewer_json(request.user, access_token)
map_obj.handle_moderated_uploads()
del config['id']
else:
if request.method == 'GET':
params = request.GET
elif request.method == 'POST':
params = request.POST
else:
return HttpResponse(status=405)
if 'layer' in params:
map_obj = Map(projection=getattr(settings, 'DEFAULT_MAP_CRS',
'EPSG:900913'))
config = add_layers_to_map_config(request, map_obj, params.getlist('layer'))
else:
config = DEFAULT_MAP_CONFIG
return json.dumps(config)
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 layer_search_page(request, template='layers/layer_search.html'):
DEFAULT_BASE_LAYERS = default_map_config()[1]
# for non-ajax requests, render a generic search page
if request.method == 'GET':
params = request.GET
elif request.method == 'POST':
params = request.POST
else:
return HttpResponse(status=405)
map_obj = GXPMap(projection="EPSG:900913", zoom = 1, center_x = 0, center_y = 0)
return render_to_response(template, RequestContext(request, {
'init_search': json.dumps(params or {}),
'viewer_config': json.dumps(map_obj.viewer_json(*DEFAULT_BASE_LAYERS)),
"site" : settings.SITEURL,
"search_api": reverse("layer_search_api"),
"search_action": reverse("layer_search_page"),
"search_type": "layer",
}))
def map_embed(
request,
mapid=None,
snapshot=None,
template='maps/map_embed.html'):
if mapid is None:
config = default_map_config(request)[0]
else:
map_obj = _resolve_map(
request,
mapid,
'base.view_resourcebase',
_PERMISSION_MSG_VIEW)
if snapshot is None:
config = map_obj.viewer_json(request)
else:
config = snapshot_config(
snapshot, map_obj, request)
return render(request, template, context={
'config': json.dumps(config)
})
def test_map_embed(self):
"""Test that map can be properly embedded
"""
# first create a map
c = Client()
# Test successful new map creation
c.login(username=self.user, password=self.passwd)
new_map = reverse("new_map_json")
response = c.post(new_map, data=self.viewer_config, content_type="text/json")
self.assertEquals(response.status_code, 200)
map_id = int(json.loads(response.content)["id"])
c.logout()
url = reverse("map_embed", args=(map_id,))
url_no_id = reverse("map_embed")
# Now test with a map id
c.login(username=self.user, password=self.passwd)
response = c.get(url)
self.assertEquals(response.status_code, 200)
# Config equals to that of the map whose id is given
map_obj = Map.objects.get(id=map_id)
config_map = map_obj.viewer_json(None)
response_config_dict = json.loads(response.context["config"])
self.assertEquals(config_map["about"]["abstract"], response_config_dict["about"]["abstract"])
self.assertEquals(config_map["about"]["title"], response_config_dict["about"]["title"])
# Now test without a map id
response = c.get(url_no_id)
self.assertEquals(response.status_code, 200)
# Config equals to that of the default map
config_default = default_map_config()[0]
response_config_dict = json.loads(response.context["config"])
self.assertEquals(config_default["about"]["abstract"], response_config_dict["about"]["abstract"])
self.assertEquals(config_default["about"]["title"], response_config_dict["about"]["title"])
def pdf_metadata_layer(request, layername, template='layers/pdf_metadata_layer.html'):
layer = _resolve_layer(
request,
layername,
'base.view_resourcebase',
_PERMISSION_MSG_VIEW)
layer_attribute_set = inlineformset_factory(
Layer,
Attribute,
extra=0,
form=LayerAttributeForm,
)
topic_category = layer.category
# assert False, str(layer_bbox)
config = layer.attribute_config()
# 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
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))
# 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,
"is_layer": True,
}
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
html = render_to_string('layers/pdf_metadata_layer.html', {
'pagesize': 'A4',
'resource': layer,
}, context_instance=RequestContext(request))
return generar_pdf(html)
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 layer_detail(request, layername, template='layers/layer_detail.html'):
layer = _resolve_layer(request, layername, 'base.view_resourcebase',
_("You are not permitted to view this layer"))
# assert False, str(layer_bbox)
config = layer.attribute_config()
# Add required parameters for GXP lazy-loading
layer_bbox = layer.bbox
bbox = [float(coord) for coord in list(layer_bbox[0:4])]
config["srs"] = getattr(settings, 'DEFAULT_MAP_CRS', 'EPSG:900913')
config["bbox"] = bbox if config["srs"] != 'EPSG:900913' \
else llbbox_to_mercator([float(coord) for coord in bbox])
config["title"] = layer.title
config["queryable"] = True
if layer.default_style:
config["styles"] = layer.default_style.name
if layer.storeType == "remoteStore":
source_srid = None
# Only grab the service proj/bbox if it is valid
if None not in layer.service.bbox[0:4]:
bbox = [float(coord) for coord in list(layer.service.bbox[0:4])]
source_srid = layer.service.srid
# Otherwise try the service directly
# This is needed since previous services registered
# did not store the bbox/srid in the model
else:
try:
service_handler = get_service_handler(
base_url=layer.service.base_url,
service_type=layer.service.type)
if getattr(service_handler.parsed_service, 'initialExtent',
None):
bbox[0] = service_handler.parsed_service.initialExtent[
'xmin']
bbox[1] = service_handler.parsed_service.initialExtent[
'ymin']
bbox[2] = service_handler.parsed_service.initialExtent[
'xmax']
bbox[3] = service_handler.parsed_service.initialExtent[
'ymax']
else:
logger.info(
'Could not retrieve extent from service: {0}'.format(
layer.service))
if getattr(service_handler.parsed_service, 'spatialReference',
None):
source_srid = \
service_handler.parsed_service.spatialReference[
'latestWkid']
else:
logger.info(
'Could not retrieve srid from service: {0}'.format(
layer.service))
except Exception as e:
logger.info('Failed to access service endpoint: {0}'.format(
layer.service.base_url))
logger.info('Caught error: {0}'.format(e))
if source_srid is None:
source_srid = layer.srid
target_srid = 3857 if config["srs"] == 'EPSG:900913' else config["srs"]
reprojected_bbox = bbox_to_projection(bbox,
source_srid=source_srid,
target_srid=target_srid)
bbox = reprojected_bbox[:4]
config['bbox'] = [float(coord) for coord in bbox]
service = layer.service
source_url = service.base_url
use_proxy = (callable(uses_proxy_route)
and uses_proxy_route(service.base_url))
components = urlsplit(service.base_url)
query_params = None
if components.query:
query_params = OrderedDict(
parse_qsl(components.query, keep_blank_values=True))
removed_query = [
components.scheme, components.netloc, components.path, None,
components.fragment
]
source_url = urlunsplit(removed_query)
source_params = {
"ptype": service.ptype,
"remote": True,
"url": source_url,
"name": service.name,
"use_proxy": use_proxy
}
if query_params is not None:
source_params["params"] = query_params
if layer.alternate is not None:
config["layerid"] = layer.alternate
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,
# 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=getattr(settings, 'DEFAULT_MAP_CRS', 'EPSG:900913'))
metadata = layer.link_set.metadata().filter(
name__in=settings.DOWNLOAD_FORMATS_METADATA)
granules = None
all_granules = 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:
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:
granules = {"features": []}
all_granules = {"features": []}
context_dict = {
"resource": layer,
'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,
"filter": filter,
}
if 'access_token' in request.session:
access_token = request.session['access_token']
else:
u = uuid.uuid1()
access_token = u.hex
if bbox is not None:
minx, miny, maxx, maxy = [float(coord) for coord in bbox]
x = (minx + maxx) / 2
y = (miny + maxy) / 2
if layer.is_remote or getattr(settings, 'DEFAULT_MAP_CRS',
'EPSG:900913') == "EPSG:4326":
center = list((x, y))
else:
center = list(forward_mercator((x, y)))
if center[1] == float('-inf'):
center[1] = 0
BBOX_DIFFERENCE_THRESHOLD = 1e-5
# Check if the bbox is invalid
valid_x = (maxx - minx)**2 > BBOX_DIFFERENCE_THRESHOLD
valid_y = (maxy - miny)**2 > BBOX_DIFFERENCE_THRESHOLD
if valid_x:
width_zoom = math.log(360 / abs(maxx - minx), 2)
else:
width_zoom = 15
if valid_y:
height_zoom = math.log(360 / abs(maxy - miny), 2)
else:
height_zoom = 15
map_obj.center_x = center[0]
map_obj.center_y = center[1]
map_obj.zoom = math.ceil(min(width_zoom, height_zoom))
context_dict["viewer"] = json.dumps(
map_obj.viewer_json(request.user, access_token,
*(default_map_config(request)[1] + [maplayer])))
context_dict["preview"] = getattr(settings, 'LAYER_PREVIEW_LIBRARY',
'leaflet')
context_dict["crs"] = getattr(settings, 'DEFAULT_MAP_CRS', 'EPSG:900913')
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)
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:
item.url = "%s&access_token=%s&time=%s" % \
(item.url, access_token, "0/9999")
for item in links_download:
if item.url and access_token:
item.url = "%s&access_token=%s" % (item.url, access_token)
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)
return render_to_response(template, RequestContext(request, context_dict))
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(
projection=getattr(
settings,
'DEFAULT_MAP_CRS',
'EPSG:900913'))
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
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
def layer_metadata(request,
layername,
template='layers/layer_metadata.html',
ajax=True):
layer = _resolve_layer(request, layername,
'base.change_resourcebase_metadata',
_PERMISSION_MSG_METADATA)
layer_attribute_set = inlineformset_factory(
Layer,
Attribute,
extra=0,
form=LayerAttributeForm,
)
topic_category = layer.category
poc = layer.poc
metadata_author = layer.metadata_author
# assert False, str(layer_bbox)
config = layer.attribute_config()
# Add required parameters for GXP lazy-loading
layer_bbox = layer.bbox
bbox = [float(coord) for coord in list(layer_bbox[0:4])]
if hasattr(layer, 'srid'):
config['crs'] = {'type': 'name', 'properties': layer.srid}
config["srs"] = getattr(settings, 'DEFAULT_MAP_CRS', 'EPSG:900913')
config["bbox"] = bbox if config["srs"] != 'EPSG:900913' \
else 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.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
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=getattr(settings, 'DEFAULT_MAP_CRS', 'EPSG:900913'))
NON_WMS_BASE_LAYERS = [
la for la in default_map_config(request)[1] if la.ows_url is None
]
if request.method == "POST":
if layer.metadata_uploaded_preserve: # layer metadata cannot be edited
out = {
'success': False,
'errors': METADATA_UPLOADED_PRESERVE_ERROR
}
return HttpResponse(json.dumps(out),
content_type='application/json',
status=400)
layer_form = LayerForm(request.POST, instance=layer, prefix="resource")
attribute_form = layer_attribute_set(
request.POST,
instance=layer,
prefix="layer_attribute_set",
queryset=Attribute.objects.order_by('display_order'))
category_form = CategoryForm(
request.POST,
prefix="category_choice_field",
initial=int(request.POST["category_choice_field"])
if "category_choice_field" in request.POST else None)
tkeywords_form = TKeywordForm(request.POST, prefix="tkeywords")
else:
layer_form = LayerForm(instance=layer, prefix="resource")
attribute_form = layer_attribute_set(
instance=layer,
prefix="layer_attribute_set",
queryset=Attribute.objects.order_by('display_order'))
category_form = CategoryForm(
prefix="category_choice_field",
initial=topic_category.id if topic_category else None)
# Keywords from THESAURI management
layer_tkeywords = layer.tkeywords.all()
tkeywords_list = ''
lang = 'en' # TODO: use user's language
if layer_tkeywords and len(layer_tkeywords) > 0:
tkeywords_ids = layer_tkeywords.values_list('id', flat=True)
if hasattr(settings, 'THESAURI'):
for el in settings.THESAURI:
thesaurus_name = el['name']
try:
t = Thesaurus.objects.get(identifier=thesaurus_name)
for tk in t.thesaurus.filter(pk__in=tkeywords_ids):
tkl = tk.keyword.filter(lang=lang)
if len(tkl) > 0:
tkl_ids = ",".join(
map(str, tkl.values_list('id', flat=True)))
tkeywords_list += "," + \
tkl_ids if len(
tkeywords_list) > 0 else tkl_ids
except BaseException:
tb = traceback.format_exc()
logger.error(tb)
tkeywords_form = TKeywordForm(prefix="tkeywords",
initial={'tkeywords': tkeywords_list})
if request.method == "POST" and layer_form.is_valid(
) and attribute_form.is_valid() and category_form.is_valid(
) and tkeywords_form.is_valid():
new_poc = layer_form.cleaned_data['poc']
new_author = layer_form.cleaned_data['metadata_author']
if new_poc is None:
if poc is None:
poc_form = ProfileForm(request.POST,
prefix="poc",
instance=poc)
else:
poc_form = ProfileForm(request.POST, prefix="poc")
if poc_form.is_valid():
if len(poc_form.cleaned_data['profile']) == 0:
# FIXME use form.add_error in django > 1.7
errors = poc_form._errors.setdefault(
'profile', ErrorList())
errors.append(
_('You must set a point of contact for this resource'))
poc = None
if poc_form.has_changed and poc_form.is_valid():
new_poc = poc_form.save()
if new_author is None:
if metadata_author is None:
author_form = ProfileForm(request.POST,
prefix="author",
instance=metadata_author)
else:
author_form = ProfileForm(request.POST, prefix="author")
if author_form.is_valid():
if len(author_form.cleaned_data['profile']) == 0:
# FIXME use form.add_error in django > 1.7
errors = author_form._errors.setdefault(
'profile', ErrorList())
errors.append(
_('You must set an author for this resource'))
metadata_author = None
if author_form.has_changed and author_form.is_valid():
new_author = author_form.save()
new_category = TopicCategory.objects.get(
id=category_form.cleaned_data['category_choice_field'])
for form in attribute_form.cleaned_data:
la = Attribute.objects.get(id=int(form['id'].id))
la.description = form["description"]
la.attribute_label = form["attribute_label"]
la.visible = form["visible"]
la.display_order = form["display_order"]
la.save()
if new_poc is not None or new_author is not None:
if new_poc is not None:
layer.poc = new_poc
if new_author is not None:
layer.metadata_author = new_author
new_keywords = [x.strip() for x in layer_form.cleaned_data['keywords']]
if new_keywords is not None:
layer.keywords.clear()
layer.keywords.add(*new_keywords)
try:
the_layer = layer_form.save()
except BaseException:
tb = traceback.format_exc()
if tb:
logger.debug(tb)
the_layer = layer
up_sessions = UploadSession.objects.filter(layer=the_layer.id)
if up_sessions.count() > 0 and up_sessions[0].user != the_layer.owner:
up_sessions.update(user=the_layer.owner)
if new_category is not None:
Layer.objects.filter(id=the_layer.id).update(category=new_category)
if getattr(settings, 'SLACK_ENABLED', False):
try:
from geonode.contrib.slack.utils import build_slack_message_layer, send_slack_messages
send_slack_messages(
build_slack_message_layer("layer_edit", the_layer))
except BaseException:
print "Could not send slack message."
if not ajax:
return HttpResponseRedirect(
reverse('layer_detail', args=(layer.service_typename, )))
message = layer.alternate
try:
# Keywords from THESAURI management
tkeywords_to_add = []
tkeywords_cleaned = tkeywords_form.clean()
if tkeywords_cleaned and len(tkeywords_cleaned) > 0:
tkeywords_ids = []
for i, val in enumerate(tkeywords_cleaned):
try:
cleaned_data = [
value
for key, value in tkeywords_cleaned[i].items()
if 'tkeywords-tkeywords' in key.lower()
and 'autocomplete' not in key.lower()
]
tkeywords_ids.extend(map(int, cleaned_data[0]))
except BaseException:
pass
if hasattr(settings, 'THESAURI'):
for el in settings.THESAURI:
thesaurus_name = el['name']
try:
t = Thesaurus.objects.get(
identifier=thesaurus_name)
for tk in t.thesaurus.all():
tkl = tk.keyword.filter(pk__in=tkeywords_ids)
if len(tkl) > 0:
tkeywords_to_add.append(tkl[0].keyword_id)
except BaseException:
tb = traceback.format_exc()
logger.error(tb)
layer.tkeywords.add(*tkeywords_to_add)
except BaseException:
tb = traceback.format_exc()
logger.error(tb)
return HttpResponse(json.dumps({'message': message}))
if settings.ADMIN_MODERATE_UPLOADS:
if not request.user.is_superuser:
layer_form.fields['is_published'].widget.attrs.update(
{'disabled': 'true'})
if not request.user.is_superuser and not request.user.is_staff:
can_change_metadata = request.user.has_perm(
'change_resourcebase_metadata', layer.get_self_resource())
try:
is_manager = request.user.groupmember_set.all().filter(
role='manager').exists()
except:
is_manager = False
if not is_manager or not can_change_metadata:
layer_form.fields['is_approved'].widget.attrs.update(
{'disabled': 'true'})
if poc is not None:
layer_form.fields['poc'].initial = poc.id
poc_form = ProfileForm(prefix="poc")
poc_form.hidden = True
else:
poc_form = ProfileForm(prefix="poc")
poc_form.hidden = False
if metadata_author is not None:
layer_form.fields['metadata_author'].initial = metadata_author.id
author_form = ProfileForm(prefix="author")
author_form.hidden = True
else:
author_form = ProfileForm(prefix="author")
author_form.hidden = False
if 'access_token' in request.session:
access_token = request.session['access_token']
else:
u = uuid.uuid1()
access_token = u.hex
viewer = json.dumps(
map_obj.viewer_json(request.user, access_token,
*(NON_WMS_BASE_LAYERS + [maplayer])))
metadataxsl = False
if "geonode.contrib.metadataxsl" in settings.INSTALLED_APPS:
metadataxsl = True
metadata_author_groups = []
if request.user.is_superuser or request.user.is_staff:
metadata_author_groups = GroupProfile.objects.all()
else:
all_metadata_author_groups = chain(
request.user.group_list_all().distinct(),
GroupProfile.objects.exclude(access="private").exclude(
access="public-invite"))
[
metadata_author_groups.append(item)
for item in all_metadata_author_groups
if item not in metadata_author_groups
]
return render_to_response(
template,
RequestContext(
request, {
"resource":
layer,
"layer":
layer,
"layer_form":
layer_form,
"poc_form":
poc_form,
"author_form":
author_form,
"attribute_form":
attribute_form,
"category_form":
category_form,
"tkeywords_form":
tkeywords_form,
"viewer":
viewer,
"preview":
getattr(settings, 'LAYER_PREVIEW_LIBRARY', 'leaflet'),
"crs":
getattr(settings, 'DEFAULT_MAP_CRS', 'EPSG:900913'),
"metadataxsl":
metadataxsl,
"freetext_readonly":
getattr(settings, 'FREETEXT_KEYWORDS_READONLY', False),
"metadata_author_groups":
metadata_author_groups,
"GROUP_MANDATORY_RESOURCES":
getattr(settings, 'GROUP_MANDATORY_RESOURCES', False),
}))
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
bbox = [float(coord) for coord in list(layer_bbox[0:4])]
config["srs"] = getattr(settings, 'DEFAULT_MAP_CRS', 'EPSG:900913')
config["bbox"] = bbox if config["srs"] != 'EPSG:900913' \
else 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))
# 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=getattr(settings, 'DEFAULT_MAP_CRS', 'EPSG:900913'))
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
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:
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:
granules = {"features": []}
all_granules = {"features": []}
context_dict = {
"resource": layer,
'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,
"filter": filter,
}
if '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.user, access_token, * (NON_WMS_BASE_LAYERS + [maplayer])))
context_dict["preview"] = getattr(
settings,
'LAYER_PREVIEW_LIBRARY',
'leaflet')
context_dict["crs"] = getattr(
settings,
'DEFAULT_MAP_CRS',
'EPSG:900913')
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)
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:
item.url = "%s&access_token=%s" % (item.url, access_token)
for item in links_download:
if item.url and access_token:
item.url = "%s&access_token=%s" % (item.url, access_token)
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)
return render_to_response(template, RequestContext(request, context_dict))
def data_request_detail(request, pk, template='datarequests/data_detail.html'):
data_request = get_object_or_404(DataRequest, pk=pk)
if not request.user.is_superuser and not data_request.profile == request.user:
return HttpResponseRedirect('/forbidden')
context_dict={"data_request": data_request}
context_dict['data_types'] = data_request.data_type.names()
context_dict['sucs']=data_request.suc.names()
context_dict['max_ftp_size']=settings.MAX_FTP_SIZE
pprint(context_dict ['sucs'])
pprint("dr.pk="+str(data_request.pk))
if data_request.profile:
context_dict['profile'] = data_request.profile
if data_request.profile_request:
context_dict['profile_request'] = data_request.profile_request
if data_request.jurisdiction_shapefile:
layer = data_request.jurisdiction_shapefile
# assert False, str(layer_bbox)
config = layer.attribute_config()
# 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.typename,
ows_url=layer.ows_url,
layer_params=json.dumps(config))
# 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
context_dict ["permissions_json"] = _perms_info_json(layer)
context_dict ["documents"] = get_related_documents(layer)
context_dict ["metadata"] = metadata
context_dict ["is_layer"] = True
context_dict ["wps_enabled"] = settings.OGC_SERVER['default']['WPS_ENABLED'],
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
context_dict["request_reject_form"]= DataRequestRejectForm(instance=data_request)
return render_to_response(template, RequestContext(request, context_dict))
def test_map_embed(self):
"""Test that map can be properly embedded
"""
# first create a map
# Test successful new map creation
self.client.login(username=self.user, password=self.passwd)
new_map = reverse('new_map_json')
response = self.client.post(new_map,
data=self.viewer_config,
content_type="text/json")
self.assertEqual(response.status_code, 200)
map_id = int(json.loads(response.content)['id'])
self.client.logout()
url = reverse('map_embed', args=(map_id, ))
url_no_id = reverse('map_embed')
# Now test with a map id
self.client.login(username=self.user, password=self.passwd)
response = self.client.get(url)
self.assertEqual(response.status_code, 200)
# The embedded map is exempt from X-FRAME-OPTIONS restrictions.
if hasattr(response, 'xframe_options_exempt'):
self.assertTrue(response.xframe_options_exempt)
# Config equals to that of the map whose id is given
map_obj = Map.objects.get(id=map_id)
config_map = map_obj.viewer_json(None)
response_config_dict = json.loads(response.context['config'])
self.assertEqual(config_map['about']['abstract'],
response_config_dict['about']['abstract'])
self.assertEqual(config_map['about']['title'],
response_config_dict['about']['title'])
# Now test without a map id
response = self.client.get(url_no_id)
self.assertEqual(response.status_code, 200)
# Config equals to that of the default map
config_default = default_map_config(None)[0]
response_config_dict = json.loads(response.context['config'])
self.assertEqual(config_default['about']['abstract'],
response_config_dict['about']['abstract'])
self.assertEqual(config_default['about']['title'],
response_config_dict['about']['title'])
map_obj.update_from_viewer(config_map, context={})
title = config_map['title'] if 'title' in config_map else config_map[
'about']['title']
abstract = config_map[
'abstract'] if 'abstract' in config_map else config_map['about'][
'abstract']
center = config_map['map']['center'] if 'center' in config_map[
'map'] else settings.DEFAULT_MAP_CENTER
zoom = config_map['map']['zoom'] if 'zoom' in config_map[
'map'] else settings.DEFAULT_MAP_ZOOM
projection = config_map['map']['projection']
self.assertEqual(map_obj.title, title)
self.assertEqual(map_obj.abstract, abstract)
self.assertEqual(
map_obj.center_x,
center['x'] if isinstance(center, dict) else center[0])
self.assertEqual(
map_obj.center_y,
center['y'] if isinstance(center, dict) else center[1])
self.assertEqual(map_obj.zoom, zoom)
self.assertEqual(map_obj.projection, projection)
def test_new_map_config(self):
"""Test that new map config can be properly assigned
"""
self.client.login(username='******', password='******')
# Test successful new map creation
m = Map()
admin_user = get_user_model().objects.get(username='******')
layer_name = Layer.objects.all().first().alternate
m.create_from_layer_list(admin_user, [layer_name], "title", "abstract")
map_id = m.id
url = reverse('new_map_json')
# Test GET method with COPY
response = self.client.get(url, {'copy': map_id})
self.assertEquals(response.status_code, 200)
map_obj = Map.objects.get(id=map_id)
config_map = map_obj.viewer_json(None)
response_config_dict = json.loads(response.content)
self.assertEquals(config_map['map']['layers'],
response_config_dict['map']['layers'])
# Test GET method no COPY and no layer in params
response = self.client.get(url)
self.assertEquals(response.status_code, 200)
config_default = default_map_config(None)[0]
response_config_dict = json.loads(response.content)
self.assertEquals(config_default['about']['abstract'],
response_config_dict['about']['abstract'])
self.assertEquals(config_default['about']['title'],
response_config_dict['about']['title'])
# Test GET method no COPY but with layer in params
response = self.client.get(url, {'layer': layer_name})
self.assertEquals(response.status_code, 200)
response_dict = json.loads(response.content)
self.assertEquals(response_dict['fromLayer'], True)
# Test POST method without authentication
self.client.logout()
response = self.client.post(url, {'layer': layer_name})
self.assertEquals(response.status_code, 401)
# Test POST method with authentication and a layer in params
self.client.login(username='******', password='******')
response = self.client.post(url, {'layer': layer_name})
# Should not accept the request
self.assertEquals(response.status_code, 400)
# Test POST method with map data in json format
response = self.client.post(url,
data=self.viewer_config,
content_type="text/json")
self.assertEquals(response.status_code, 200)
map_id = int(json.loads(response.content)['id'])
# Check new map saved
map_obj = Map.objects.get(id=map_id)
# Check
# BBox format: [xmin, xmax, ymin, ymax
bbox_str = [
'-90.193207913954200', '-79.206792062465500', '9.059219904470890',
'16.540780092025600', 'EPSG:4326'
]
self.assertEqual(bbox_str, [str(c) for c in map_obj.bbox])
bbox_long_str = '-90.193207913954200,9.059219904470890,' \
'-79.206792062465500,16.540780092025600'
self.assertEqual(bbox_long_str, map_obj.bbox_string)
# Test methods other than GET or POST and no layer in params
response = self.client.put(url)
self.assertEquals(response.status_code, 405)
def get_layer_config(request,
typename,
permission='base.view_resourcebase',
msg=_PERMISSION_GENERIC,
**kwargs):
layer = False
try:
pprint(typename)
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)))
if layer is False:
raise Http404()
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 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
bbox = [float(coord) for coord in list(layer_bbox[0:4])]
config["srs"] = getattr(settings, 'DEFAULT_MAP_CRS', 'EPSG:900913')
config["bbox"] = bbox if config["srs"] != 'EPSG:900913' \
else 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))
# 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=getattr(settings, 'DEFAULT_MAP_CRS', 'EPSG:900913'))
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
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:
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:
granules = {"features": []}
all_granules = {"features": []}
context_dict = {
"resource": layer,
'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,
"filter": filter,
}
if '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.user, access_token,
*(NON_WMS_BASE_LAYERS + [maplayer])))
context_dict["preview"] = getattr(settings, 'LAYER_PREVIEW_LIBRARY',
'leaflet')
context_dict["crs"] = getattr(settings, 'DEFAULT_MAP_CRS', 'EPSG:900913')
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)
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:
item.url = "%s&access_token=%s" % (item.url, access_token)
for item in links_download:
if item.url and access_token:
item.url = "%s&access_token=%s" % (item.url, access_token)
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)
return render_to_response(template, RequestContext(request, context_dict))
def test_new_map_config(self):
"""Test that new map config can be properly assigned
"""
self.client.login(username='******', password='******')
# Test successful new map creation
m = Map()
admin_user = get_user_model().objects.get(username='******')
layer_name = Layer.objects.all()[0].alternate
m.create_from_layer_list(admin_user, [layer_name], "title", "abstract")
map_id = m.id
url = reverse('new_map_json')
# Test GET method with COPY
response = self.client.get(url, {'copy': map_id})
self.assertEquals(response.status_code, 200)
map_obj = Map.objects.get(id=map_id)
config_map = map_obj.viewer_json(None, None)
response_config_dict = json.loads(response.content)
self.assertEquals(
config_map['map']['layers'],
response_config_dict['map']['layers'])
# Test GET method no COPY and no layer in params
response = self.client.get(url)
self.assertEquals(response.status_code, 200)
config_default = default_map_config(None)[0]
response_config_dict = json.loads(response.content)
self.assertEquals(
config_default['about']['abstract'],
response_config_dict['about']['abstract'])
self.assertEquals(
config_default['about']['title'],
response_config_dict['about']['title'])
# Test GET method no COPY but with layer in params
response = self.client.get(url, {'layer': layer_name})
self.assertEquals(response.status_code, 200)
response_dict = json.loads(response.content)
self.assertEquals(response_dict['fromLayer'], True)
# Test POST method without authentication
self.client.logout()
response = self.client.post(url, {'layer': layer_name})
self.assertEquals(response.status_code, 401)
# Test POST method with authentication and a layer in params
self.client.login(username='******', password='******')
response = self.client.post(url, {'layer': layer_name})
# Should not accept the request
self.assertEquals(response.status_code, 400)
# Test POST method with map data in json format
response = self.client.post(
url,
data=self.viewer_config,
content_type="text/json")
self.assertEquals(response.status_code, 200)
map_id = int(json.loads(response.content)['id'])
# Check new map saved
map_obj = Map.objects.get(id=map_id)
# Check
# BBox format: [xmin, xmax, ymin, ymax
bbox_str = [
'-90.1932079140', '-79.2067920625',
'9.0592199045', '16.5407800920', 'EPSG:4326']
self.assertEqual(
bbox_str,
[str(c) for c in map_obj.bbox])
bbox_long_str = '-90.1932079140,9.0592199045,' \
'-79.2067920625,16.5407800920'
self.assertEqual(bbox_long_str, map_obj.bbox_string)
# Test methods other than GET or POST and no layer in params
response = self.client.put(url)
self.assertEquals(response.status_code, 405)
def add_layers_to_map_config(request, map_obj, layer_names, add_base_layers=True):
DEFAULT_MAP_CONFIG, DEFAULT_BASE_LAYERS = default_map_config(request)
if 'access_token' in request.session:
access_token = request.session['access_token']
else:
access_token = None
bbox = None
layers = []
for layer_name in layer_names:
try:
layer = _resolve_layer(request, layer_name)
except ObjectDoesNotExist:
# bad layer, skip
continue
if not layer.is_published:
# invisible layer, skip inclusion
continue
if not request.user.has_perm(
'view_resourcebase',
obj=layer.get_self_resource()):
# invisible layer, skip inclusion
continue
layer_bbox = layer.bbox
# assert False, str(layer_bbox)
if bbox is None:
bbox = list(layer_bbox[0:4])
else:
bbox[0] = min(bbox[0], layer_bbox[0])
bbox[1] = max(bbox[1], layer_bbox[1])
bbox[2] = min(bbox[2], layer_bbox[2])
bbox[3] = max(bbox[3], layer_bbox[3])
config = layer.attribute_config()
if hasattr(layer, 'srid'):
config['crs'] = {
'type': 'name',
'properties': layer.srid
}
# Add required parameters for GXP lazy-loading
config["title"] = layer.title
config["queryable"] = True
config["wrapDateLine"] = True
config["srs"] = getattr(
settings, 'DEFAULT_MAP_CRS', 'EPSG:900913')
config["bbox"] = bbox if config["srs"] != 'EPSG:900913' \
else llbbox_to_mercator([float(coord) for coord in bbox])
if layer.storeType == "remoteStore":
service = layer.service
# Probably not a good idea to send the access token to every remote service.
# This should never match, so no access token should be
# sent to remote services.
ogc_server_url = urlparse.urlsplit(
ogc_server_settings.PUBLIC_LOCATION).netloc
service_url = urlparse.urlsplit(service.base_url).netloc
if access_token and ogc_server_url == service_url and 'access_token' not in service.base_url:
url = service.base_url + '?access_token=' + access_token
else:
url = service.base_url
maplayer = MapLayer(map=map_obj,
name=layer.alternate,
ows_url=layer.ows_url,
layer_params=json.dumps(config),
visibility=True,
source_params=json.dumps({
"ptype": service.ptype,
"remote": True,
"url": url,
"name": service.name}))
else:
ogc_server_url = urlparse.urlsplit(
ogc_server_settings.PUBLIC_LOCATION).netloc
layer_url = urlparse.urlsplit(layer.ows_url).netloc
if access_token and ogc_server_url == layer_url and 'access_token' not in layer.ows_url:
url = layer.ows_url + '?access_token=' + access_token
else:
url = layer.ows_url
maplayer = MapLayer(
map=map_obj,
name=layer.alternate,
ows_url=url,
# use DjangoJSONEncoder to handle Decimal values
layer_params=json.dumps(config, cls=DjangoJSONEncoder),
visibility=True
)
layers.append(maplayer)
if bbox is not None:
minx, maxx, miny, maxy = [float(coord) for coord in bbox]
x = (minx + maxx) / 2
y = (miny + maxy) / 2
if getattr(
settings,
'DEFAULT_MAP_CRS',
'EPSG:900913') == "EPSG:4326":
center = list((x, y))
else:
center = list(forward_mercator((x, y)))
if center[1] == float('-inf'):
center[1] = 0
BBOX_DIFFERENCE_THRESHOLD = 1e-5
# Check if the bbox is invalid
valid_x = (maxx - minx) ** 2 > BBOX_DIFFERENCE_THRESHOLD
valid_y = (maxy - miny) ** 2 > BBOX_DIFFERENCE_THRESHOLD
if valid_x:
width_zoom = math.log(360 / abs(maxx - minx), 2)
else:
width_zoom = 15
if valid_y:
height_zoom = math.log(360 / abs(maxy - miny), 2)
else:
height_zoom = 15
map_obj.center_x = center[0]
map_obj.center_y = center[1]
map_obj.zoom = math.ceil(min(width_zoom, height_zoom))
map_obj.handle_moderated_uploads()
if add_base_layers:
layers_to_add = DEFAULT_BASE_LAYERS + layers
else:
layers_to_add = layers
config = map_obj.viewer_json(
request.user, access_token, *layers_to_add)
config['fromLayer'] = True
return config
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
bbox = [float(coord) for coord in list(layer_bbox[0:4])]
config["srs"] = getattr(settings, 'DEFAULT_MAP_CRS', 'EPSG:900913')
config["bbox"] = bbox if config["srs"] != 'EPSG:900913' \
else 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))
# 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=getattr(settings, 'DEFAULT_MAP_CRS', '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,
'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'],
}
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
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'):
try:
user_role = request.GET['user_role']
except:
user_role=None
layer = _resolve_layer(
request,
layername,
'base.view_resourcebase',
_PERMISSION_MSG_VIEW)
user = request.user
edit_permit = False
if layer.owner == user and layer.status in ['DRAFT', 'ACTIVE', 'DENIED']:
edit_permit = True
elif user in layer.group.get_managers() and layer.status in ['PENDING', 'ACTIVE', 'DENIED']:
edit_permit = True
if not edit_permit and layer.status=='ACTIVE':
edit_permit = True
# if the edit request is not valid then just return from here
if not edit_permit:
return HttpResponse(
loader.render_to_string(
'401.html', RequestContext(
request, {
'error_message': _("You dont have permission to edit this layer.")})), status=401)
# return HttpResponse('You dont have permission to edit this layer')
# assert False, str(layer_bbox)
config = layer.attribute_config()
# Add required parameters for GXP lazy-loading
layer_bbox = layer.bbox
bbox = [float(coord) for coord in list(layer_bbox[0:4])]
config["srs"] = getattr(settings, 'DEFAULT_MAP_CRS', 'EPSG:900913')
config["bbox"] = bbox if config["srs"] != 'EPSG:900913' \
else 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))
# 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=getattr(settings, 'DEFAULT_MAP_CRS', '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)
granules = None
all_granules = 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:
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:
granules = {"features": []}
all_granules = {"features": []}
approve_form = ResourceApproveForm()
deny_form = ResourceDenyForm()
metadata_field_list = ['owner', 'title', 'date', 'date_type', 'edition', 'abstract', 'purpose',
'maintenance_frequency', 'regions', 'restriction_code_type', 'constraints_other', 'license',
'language', 'spatial_representation_type', 'resource_type', 'temporal_extent_start',
'temporal_extent_end', 'supplemental_information', 'data_quality_statement', 'thumbnail_url',
'elevation_regex', 'time_regex', 'keywords',
'category']
if request.user == layer.owner or request.user in layer.group.get_managers():
if not layer.attributes:
messages.info(request, 'Please update layer metadata, missing some informations')
elif not layer.metadata_author:
messages.info(request, 'Please update layer metadata, missing some informations')
else:
for field in metadata_field_list:
if not getattr(layer, layer._meta.get_field(field).name):
messages.info(request, 'Please update layer metadata, missing some informations')
break
# layer_name = layer.service_typename
# geoserver_user = OGC_SERVER['default']['USER']
# geoserver_password = OGC_SERVER['default']['PASSWORD']
# style_url = OGC_SERVER['default']['PUBLIC_LOCATION'] + "rest/layers/" + layer_name + ".json"
# response1 = requests.get(style_url, auth=HTTPBasicAuth(geoserver_user, geoserver_password))
# sld_file_name_url = response1.json()['layer']['defaultStyle']['href']
# response2 = requests.get(sld_file_name_url, auth=HTTPBasicAuth(geoserver_user, geoserver_password))
# file_name = response2.json()['style']['filename']
# sld_file_url = OGC_SERVER['default']['PUBLIC_LOCATION'] + "rest/styles/" + file_name
# sld_content = requests.get(sld_file_url, auth=HTTPBasicAuth(geoserver_user, geoserver_password)).content
#
# xlink = ''
# try:
# dict1 = xmltodict.parse(sld_content)
# dict2 = dict1['sld:StyledLayerDescriptor']['sld:NamedLayer']['sld:UserStyle']['sld:FeatureTypeStyle']\
# ['sld:Rule']['sld:PointSymbolizer']
# xlink = dict2['sld:Graphic']['sld:ExternalGraphic']['sld:OnlineResource']['@xlink:href']
# except:
# pass
xlink = style_chart_legend_color(layer)
context_dict = {
"resource": layer,
'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,
"filter": filter,
"user_role": user_role,
"approve_form": approve_form,
"deny_form": deny_form,
"denied_comments": LayerAuditActivity.objects.filter(layer_submission_activity__layer=layer),
"status": layer.status,
"chart_link" : xlink
}
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
if settings.SOCIAL_ORIGINS:
context_dict["social_links"] = build_social_links(request, layer)
return render_to_response(template, RequestContext(request, context_dict))
def get_context_data(self, **kwargs):
request = self.request
if request and 'access_token' in request.session:
access_token = request.session['access_token']
else:
access_token = None
snapshot = self.kwargs.get('snapshot')
DEFAULT_MAP_CONFIG, DEFAULT_BASE_LAYERS = default_map_config(request)
layers = Layer.objects.all()
if request.method == 'GET' and 'copy' in request.GET:
"""Prepare context data."""
request = self.request
mapid = self.request.GET['copy']
map_obj = _resolve_map(request, mapid, 'base.view_resourcebase',
_PERMISSION_MSG_VIEW)
if snapshot is None:
config = map_obj.viewer_json(request)
else:
config = snapshot_config(snapshot, map_obj, request)
# list all required layers
map_layers = MapLayer.objects.filter(
map_id=mapid).order_by('stack_order')
context = {
'config':
json.dumps(config),
'create':
False,
'layers':
layers,
'map':
map_obj,
'map_layers':
map_layers,
'preview':
getattr(settings, 'GEONODE_CLIENT_LAYER_PREVIEW_LIBRARY', '')
}
return context
else:
if request.method == 'GET':
params = request.GET
elif request.method == 'POST':
params = request.POST
else:
return self.render_to_response(status=405)
if 'layer' in params:
bbox = None
map_obj = Map(projection=getattr(settings, 'DEFAULT_MAP_CRS',
'EPSG:3857'))
for layer_name in params.getlist('layer'):
try:
layer = _resolve_layer(request, layer_name)
except ObjectDoesNotExist:
# bad layer, skip
continue
if not request.user.has_perm(
'view_resourcebase',
obj=layer.get_self_resource()):
# invisible layer, skip inclusion
continue
layer_bbox = layer.bbox
# assert False, str(layer_bbox)
if bbox is None:
bbox = list(layer_bbox[0:4])
else:
bbox[0] = min(bbox[0], layer_bbox[0])
bbox[1] = min(bbox[1], layer_bbox[1])
bbox[2] = max(bbox[2], layer_bbox[2])
bbox[3] = max(bbox[3], layer_bbox[3])
config = layer.attribute_config()
# Add required parameters for GXP lazy-loading
config["title"] = layer.title
config["queryable"] = True
config["srs"] = getattr(settings, 'DEFAULT_MAP_CRS',
'EPSG:3857')
config["bbox"] = bbox if config["srs"] != 'EPSG:3857' \
else llbbox_to_mercator(
[float(coord) for coord in bbox])
if layer.storeType == "remoteStore":
service = layer.remote_service
# Probably not a good idea to send the access token to every remote service.
# This should never match, so no access token should be sent to remote services.
ogc_server_url = urlsplit(
ogc_server_settings.PUBLIC_LOCATION).netloc
service_url = urlsplit(service.base_url).netloc
if access_token and ogc_server_url == service_url and \
'access_token' not in service.base_url:
url = '%s?access_token=%s' % (service.base_url,
access_token)
else:
url = service.base_url
map_layers = MapLayer(map=map_obj,
name=layer.typename,
ows_url=layer.ows_url,
layer_params=json.dumps(config),
visibility=True,
source_params=json.dumps({
"ptype":
service.ptype,
"remote":
True,
"url":
url,
"name":
service.name,
"title":
"[R] %s" % service.title
}))
else:
ogc_server_url = urlsplit(
ogc_server_settings.PUBLIC_LOCATION).netloc
layer_url = urlsplit(layer.ows_url).netloc
if access_token and ogc_server_url == layer_url and \
'access_token' not in layer.ows_url:
url = layer.ows_url + '?access_token=' + \
access_token
else:
url = layer.ows_url
map_layers = MapLayer(
map=map_obj,
name=layer.typename,
ows_url=url,
# use DjangoJSONEncoder to handle Decimal values
layer_params=json.dumps(config,
cls=DjangoJSONEncoder),
visibility=True)
if bbox and len(bbox) >= 4:
minx, miny, maxx, maxy = [float(coord) for coord in bbox]
x = (minx + maxx) / 2
y = (miny + maxy) / 2
if getattr(settings, 'DEFAULT_MAP_CRS',
'EPSG:3857') == "EPSG:4326":
center = list((x, y))
else:
center = list(forward_mercator((x, y)))
if center[1] == float('-inf'):
center[1] = 0
BBOX_DIFFERENCE_THRESHOLD = 1e-5
# Check if the bbox is invalid
valid_x = (maxx - minx)**2 > BBOX_DIFFERENCE_THRESHOLD
valid_y = (maxy - miny)**2 > BBOX_DIFFERENCE_THRESHOLD
if valid_x:
width_zoom = math.log(360 / abs(maxx - minx), 2)
else:
width_zoom = 15
if valid_y:
height_zoom = math.log(360 / abs(maxy - miny), 2)
else:
height_zoom = 15
map_obj.center_x = center[0]
map_obj.center_y = center[1]
map_obj.zoom = math.ceil(min(width_zoom, height_zoom))
map_obj.handle_moderated_uploads()
if snapshot is None:
config = map_obj.viewer_json(request)
else:
config = snapshot_config(snapshot, map_obj, request)
config['fromLayer'] = True
context = {
'config':
json.dumps(config),
'create':
True,
'layers':
layers,
'map':
map_obj,
'map_layers':
map_layers,
'preview':
getattr(settings, 'GEONODE_CLIENT_LAYER_PREVIEW_LIBRARY',
'')
}
else:
# list all required layers
layers = Layer.objects.all()
context = {'create': True, 'layers': layers}
return context
def layer_detail(request, layername, template='layers/layer_detail.html'):
# tile shapefile ng settings.tile
layer = _resolve_layer(request, layername, 'base.view_resourcebase',
_PERMISSION_MSG_VIEW)
# check if problematic in geoserver
cat = gs_catalog
try:
gs_layer = cat.get_layer(layername)
gs_layer.resource.latlon_bbox
except:
print 'GEOSERVER LAYER ERROR'
return HttpResponse(loader.render_to_string(
'layers/layer_error.html',
RequestContext(request, {'error_message': _("Error in layer.")})),
status=404)
# return HttpResponse(status=404)
# assert False, str(layer_bbox)
config = layer.attribute_config()
# print layername
# Add required parameters for GXP lazy-loading
layer_bbox = layer.bbox
bbox = [float(coord) for coord in list(layer_bbox[0:4])]
config["srs"] = getattr(settings, 'DEFAULT_MAP_CRS', 'EPSG:900913')
config["bbox"] = bbox if config["srs"] != 'EPSG:900913' \
else 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))
# 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=getattr(settings, 'DEFAULT_MAP_CRS', '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,
'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'],
}
context_dict["phillidar2keyword"] = "PhilLiDAR2"
context_dict["phillidar1keyword"] = "UPD"
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')
#pprint('CONTEXT DICTIONARY')
#pprint(context_dict)
#pprint('END')
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
if settings.SOCIAL_ORIGINS:
context_dict["social_links"] = build_social_links(request, layer)
if request.method == 'POST':
#pprint(request.POST)
form = AnonDownloaderForm(request.POST)
out = {}
if form.is_valid():
#pprint(form)
out['success'] = True
anondownload = form.save()
anondownload.anon_layer = Layer.objects.get(
typename=layername).typename
anondownload.save()
else:
#pprint(form)
errormsgs = []
for e in form.errors.values():
errormsgs.extend([escape(v) for v in e])
out['success'] = False
out['errors'] = form.errors
out['errormsgs'] = errormsgs
if out['success']:
status_code = 200
else:
status_code = 400
# Handle form
pprint(status_code)
return HttpResponse(status=status_code)
else:
# Render form
form = AnonDownloaderForm()
context_dict["anon_form"] = form
context_dict["layername"] = layername
return render_to_response(template, RequestContext(request, context_dict))
def new_map_config(request):
'''
View that creates a new map.
If the query argument 'copy' is given, the inital map is
a copy of the map with the id specified, otherwise the
default map configuration is used. If copy is specified
and the map specified does not exist a 404 is returned.
'''
DEFAULT_MAP_CONFIG, DEFAULT_BASE_LAYERS = default_map_config()
if request.method == 'GET' and 'copy' in request.GET:
mapid = request.GET['copy']
map_obj = _resolve_map(request, mapid, 'maps.view_map')
map_obj.abstract = DEFAULT_ABSTRACT
map_obj.title = DEFAULT_TITLE
if request.user.is_authenticated(): map_obj.owner = request.user
config = map_obj.viewer_json()
del config['id']
else:
if request.method == 'GET':
params = request.GET
elif request.method == 'POST':
params = request.POST
else:
return HttpResponse(status=405)
if 'layer' in params:
bbox = None
map_obj = Map(projection="EPSG:900913")
layers = []
for layer_name in params.getlist('layer'):
try:
layer = Layer.objects.get(typename=layer_name)
except ObjectDoesNotExist:
# bad layer, skip
continue
if not request.user.has_perm('layers.view_layer', obj=layer):
# invisible layer, skip inclusion
continue
layer_bbox = layer.bbox
# assert False, str(layer_bbox)
if bbox is None:
bbox = list(layer_bbox[0:4])
else:
bbox[0] = min(bbox[0], layer_bbox[0])
bbox[1] = max(bbox[1], layer_bbox[1])
bbox[2] = min(bbox[2], layer_bbox[2])
bbox[3] = max(bbox[3], layer_bbox[3])
layers.append(MapLayer(
map = map_obj,
name = layer.typename,
ows_url = settings.OGC_SERVER['default']['LOCATION'] + "wms",
layer_params=json.dumps( layer.attribute_config()),
visibility = True
))
if bbox is not None:
minx, miny, maxx, maxy = [float(c) for c in bbox]
x = (minx + maxx) / 2
y = (miny + maxy) / 2
center = forward_mercator((x, y))
if center[1] == float('-inf'):
center[1] = 0
if maxx == minx:
width_zoom = 15
else:
width_zoom = math.log(360 / (maxx - minx), 2)
if maxy == miny:
height_zoom = 15
else:
height_zoom = math.log(360 / (maxy - miny), 2)
map_obj.center_x = center[0]
map_obj.center_y = center[1]
map_obj.zoom = math.ceil(min(width_zoom, height_zoom))
config = map_obj.viewer_json(*(DEFAULT_BASE_LAYERS + layers))
config['fromLayer'] = True
else:
config = DEFAULT_MAP_CONFIG
return json.dumps(config)
def new_map_config(request):
'''
View that creates a new map.
If the query argument 'copy' is given, the initial map is
a copy of the map with the id specified, otherwise the
default map configuration is used. If copy is specified
and the map specified does not exist a 404 is returned.
'''
DEFAULT_MAP_CONFIG, DEFAULT_BASE_LAYERS = default_map_config(request)
if 'access_token' in request.session:
access_token = request.session['access_token']
else:
access_token = None
if request.method == 'GET' and 'copy' in request.GET:
mapid = request.GET['copy']
map_obj = _resolve_map(request, mapid, 'base.view_resourcebase')
map_obj.abstract = DEFAULT_ABSTRACT
map_obj.title = DEFAULT_TITLE
if request.user.is_authenticated():
map_obj.owner = request.user
config = map_obj.viewer_json(request.user, access_token)
map_obj.handle_moderated_uploads()
del config['id']
else:
if request.method == 'GET':
params = request.GET
elif request.method == 'POST':
params = request.POST
else:
return HttpResponse(status=405)
if 'layer' in params:
bbox = None
map_obj = Map(
projection=getattr(settings, 'DEFAULT_MAP_CRS', 'EPSG:900913'))
if request.user.is_authenticated():
map_obj.owner = request.user
else:
map_obj.owner = get_anonymous_user()
layers = []
for layer_name in params.getlist('layer'):
try:
layer = _resolve_layer(request, layer_name)
except ObjectDoesNotExist:
# bad layer, skip
continue
if not request.user.has_perm('view_resourcebase',
obj=layer.get_self_resource()):
# invisible layer, skip inclusion
continue
layer_bbox = layer.bbox
# assert False, str(layer_bbox)
if bbox is None:
bbox = list(layer_bbox[0:4])
else:
bbox[0] = min(bbox[0], layer_bbox[0])
bbox[1] = max(bbox[1], layer_bbox[1])
bbox[2] = min(bbox[2], layer_bbox[2])
bbox[3] = max(bbox[3], layer_bbox[3])
config = layer.attribute_config()
# Add required parameters for GXP lazy-loading
config["title"] = layer.title
config["queryable"] = True
config["srs"] = getattr(settings, 'DEFAULT_MAP_CRS',
'EPSG:900913')
config["bbox"] = bbox if config["srs"] != 'EPSG:900913' \
else llbbox_to_mercator([float(coord) for coord in bbox])
if layer.storeType == "remoteStore":
service = layer.service
# Probably not a good idea to send the access token to every remote service.
# This should never match, so no access token should be
# sent to remote services.
ogc_server_url = urlparse.urlsplit(
ogc_server_settings.PUBLIC_LOCATION).netloc
service_url = urlparse.urlsplit(service.base_url).netloc
if access_token and ogc_server_url == service_url and 'access_token' not in service.base_url:
url = service.base_url + '?access_token=' + access_token
else:
url = service.base_url
maplayer = MapLayer(map=map_obj,
name=layer.alternate,
ows_url=layer.ows_url,
layer_params=json.dumps(config),
visibility=True,
source_params=json.dumps({
"ptype":
service.ptype,
"remote":
True,
"url":
url,
"name":
service.name
}))
else:
ogc_server_url = urlparse.urlsplit(
ogc_server_settings.PUBLIC_LOCATION).netloc
layer_url = urlparse.urlsplit(layer.ows_url).netloc
if access_token and ogc_server_url == layer_url and 'access_token' not in layer.ows_url:
url = layer.ows_url + '?access_token=' + access_token
else:
url = layer.ows_url
maplayer = MapLayer(
map=map_obj,
name=layer.alternate,
ows_url=url,
# use DjangoJSONEncoder to handle Decimal values
layer_params=json.dumps(config, cls=DjangoJSONEncoder),
visibility=True)
layers.append(maplayer)
if bbox is not None:
minx, maxx, miny, maxy = [float(coord) for coord in bbox]
x = (minx + maxx) / 2
y = (miny + maxy) / 2
if getattr(settings, 'DEFAULT_MAP_CRS',
'EPSG:900913') == "EPSG:4326":
center = list((x, y))
else:
center = list(forward_mercator((x, y)))
if center[1] == float('-inf'):
center[1] = 0
BBOX_DIFFERENCE_THRESHOLD = 1e-5
# Check if the bbox is invalid
valid_x = (maxx - minx)**2 > BBOX_DIFFERENCE_THRESHOLD
valid_y = (maxy - miny)**2 > BBOX_DIFFERENCE_THRESHOLD
if valid_x:
width_zoom = math.log(360 / abs(maxx - minx), 2)
else:
width_zoom = 15
if valid_y:
height_zoom = math.log(360 / abs(maxy - miny), 2)
else:
height_zoom = 15
map_obj.center_x = center[0]
map_obj.center_y = center[1]
map_obj.zoom = math.ceil(min(width_zoom, height_zoom))
map_obj.handle_moderated_uploads()
config = map_obj.viewer_json(request.user, access_token,
*(DEFAULT_BASE_LAYERS + layers))
config['fromLayer'] = True
else:
config = DEFAULT_MAP_CONFIG
return json.dumps(config)
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
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.typename,
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)
#^^ start check if layer's dbf file is within limits for conversion
print 'debug'
MAX_CONVERT_MB = settings.MAX_DOCUMENT_SIZE
try:
layer_dbf = LayerFile.objects.get(upload_session=layer.upload_session, name='dbf')
layer_dbf_path = settings.PROJECT_ROOT + layer_dbf.file.url
print layer_dbf_path
if (os.path.getsize(layer_dbf_path) / 1024 / 1024) > MAX_CONVERT_MB:
layer_dbf = None
except LayerFile.DoesNotExist:
layer_dbf = None
#^^ end
context_dict = {
"resource": layer,
'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'],
'layer_dbf': layer_dbf #^^
}
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
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
bbox = [float(coord) for coord in list(layer_bbox[0:4])]
if hasattr(layer, 'srid'):
config['crs'] = {'type': 'name', 'properties': layer.srid}
config["srs"] = getattr(settings, 'DEFAULT_MAP_CRS', 'EPSG:900913')
config["bbox"] = bbox if config["srs"] != 'EPSG:900913' \
else 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.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(
projection=getattr(settings, 'DEFAULT_MAP_CRS', 'EPSG:900913'))
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
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": []}
group = None
if layer.group:
try:
group = GroupProfile.objects.get(slug=layer.group.name)
except GroupProfile.DoesNotExist:
group = None
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,
"filter": filter,
}
if '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.user, access_token,
*(NON_WMS_BASE_LAYERS + [maplayer])))
context_dict["preview"] = getattr(settings, 'LAYER_PREVIEW_LIBRARY',
'leaflet')
context_dict["crs"] = getattr(settings, 'DEFAULT_MAP_CRS', 'EPSG:900913')
# 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(
name__in=settings.DOWNLOAD_FORMATS_VECTOR)
else:
links = layer.link_set.download().filter(
name__in=settings.DOWNLOAD_FORMATS_RASTER)
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 'geonode' in layers_names:
workspace, name = layers_names.split(':', 1)
else:
name = layers_names
except:
print "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':
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:
print "Possible error with OWSLib. Turning all available properties to string"
# 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,
RequestContext(request, context_dict))
def new_map_config(request):
'''
View that creates a new map.
If the query argument 'copy' is given, the initial map is
a copy of the map with the id specified, otherwise the
default map configuration is used. If copy is specified
and the map specified does not exist a 404 is returned.
'''
DEFAULT_MAP_CONFIG, DEFAULT_BASE_LAYERS = default_map_config(request)
if 'access_token' in request.session:
access_token = request.session['access_token']
else:
access_token = None
if request.method == 'GET' and 'copy' in request.GET:
mapid = request.GET['copy']
map_obj = _resolve_map(request, mapid, 'base.view_resourcebase')
map_obj.abstract = DEFAULT_ABSTRACT
map_obj.title = DEFAULT_TITLE
if request.user.is_authenticated():
map_obj.owner = request.user
config = map_obj.viewer_json(request.user, access_token)
del config['id']
else:
if request.method == 'GET':
params = request.GET
elif request.method == 'POST':
params = request.POST
else:
return HttpResponse(status=405)
if 'layer' in params:
bbox = None
map_obj = Map(projection=getattr(settings, 'DEFAULT_MAP_CRS',
'EPSG:900913'))
layers = []
for layer_name in params.getlist('layer'):
try:
layer = _resolve_layer(request, layer_name)
except ObjectDoesNotExist:
# bad layer, skip
continue
if not request.user.has_perm(
'view_resourcebase',
obj=layer.get_self_resource()):
# invisible layer, skip inclusion
continue
layer_bbox = layer.bbox
# assert False, str(layer_bbox)
if bbox is None:
bbox = list(layer_bbox[0:4])
else:
bbox[0] = min(bbox[0], layer_bbox[0])
bbox[1] = max(bbox[1], layer_bbox[1])
bbox[2] = min(bbox[2], layer_bbox[2])
bbox[3] = max(bbox[3], layer_bbox[3])
config = layer.attribute_config()
# Add required parameters for GXP lazy-loading
config["title"] = layer.title
config["queryable"] = True
config["srs"] = getattr(settings, 'DEFAULT_MAP_CRS', 'EPSG:900913')
config["bbox"] = bbox if config["srs"] != 'EPSG:900913' \
else llbbox_to_mercator([float(coord) for coord in bbox])
if layer.storeType == "remoteStore":
service = layer.service
# Probably not a good idea to send the access token to every remote service.
# This should never match, so no access token should be sent to remote services.
ogc_server_url = urlparse.urlsplit(ogc_server_settings.PUBLIC_LOCATION).netloc
service_url = urlparse.urlsplit(service.base_url).netloc
if access_token and ogc_server_url == service_url and 'access_token' not in service.base_url:
url = service.base_url+'?access_token='+access_token
else:
url = service.base_url
maplayer = MapLayer(map=map_obj,
name=layer.typename,
ows_url=layer.ows_url,
layer_params=json.dumps(config),
visibility=True,
source_params=json.dumps({
"ptype": service.ptype,
"remote": True,
"url": url,
"name": service.name}))
else:
ogc_server_url = urlparse.urlsplit(ogc_server_settings.PUBLIC_LOCATION).netloc
layer_url = urlparse.urlsplit(layer.ows_url).netloc
if access_token and ogc_server_url == layer_url and 'access_token' not in layer.ows_url:
url = layer.ows_url+'?access_token='+access_token
else:
url = layer.ows_url
maplayer = MapLayer(
map=map_obj,
name=layer.typename,
ows_url=url,
# use DjangoJSONEncoder to handle Decimal values
layer_params=json.dumps(config, cls=DjangoJSONEncoder),
visibility=True
)
layers.append(maplayer)
if bbox is not None:
minx, miny, maxx, maxy = [float(coord) for coord in bbox]
x = (minx + maxx) / 2
y = (miny + maxy) / 2
if getattr(settings, 'DEFAULT_MAP_CRS', 'EPSG:900913') == "EPSG:4326":
center = list((x, y))
else:
center = list(forward_mercator((x, y)))
if center[1] == float('-inf'):
center[1] = 0
BBOX_DIFFERENCE_THRESHOLD = 1e-5
# Check if the bbox is invalid
valid_x = (maxx - minx) ** 2 > BBOX_DIFFERENCE_THRESHOLD
valid_y = (maxy - miny) ** 2 > BBOX_DIFFERENCE_THRESHOLD
if valid_x:
width_zoom = math.log(360 / abs(maxx - minx), 2)
else:
width_zoom = 15
if valid_y:
height_zoom = math.log(360 / abs(maxy - miny), 2)
else:
height_zoom = 15
map_obj.center_x = center[0]
map_obj.center_y = center[1]
map_obj.zoom = math.ceil(min(width_zoom, height_zoom))
config = map_obj.viewer_json(
request.user, access_token, *(DEFAULT_BASE_LAYERS + layers))
config['fromLayer'] = True
else:
config = DEFAULT_MAP_CONFIG
return json.dumps(config)
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 add_layers_to_map_config(
request, map_obj, layer_names, add_base_layers=True):
DEFAULT_MAP_CONFIG, DEFAULT_BASE_LAYERS = default_map_config(request)
bbox = []
layers = []
for layer_name in layer_names:
try:
layer = _resolve_layer(request, layer_name)
except ObjectDoesNotExist:
# bad layer, skip
continue
except Http404:
# can't find the layer, skip it.
continue
if not request.user.has_perm(
'view_resourcebase',
obj=layer.get_self_resource()):
# invisible layer, skip inclusion
continue
layer_bbox = layer.bbox[0:4]
bbox = layer_bbox[:]
bbox[0] = layer_bbox[0]
bbox[1] = layer_bbox[2]
bbox[2] = layer_bbox[1]
bbox[3] = layer_bbox[3]
# assert False, str(layer_bbox)
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
config = layer.attribute_config()
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
namespaces = {'wms': 'http://www.opengis.net/wms',
'xlink': 'http://www.w3.org/1999/xlink',
'xsi': 'http://www.w3.org/2001/XMLSchema-instance'}
e = ET.fromstring(wms_capabilities)
for atype in e.findall(
"./[wms:Name='%s']/wms:Dimension[@name='time']" % (layer.alternate), namespaces):
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 = MapLayer(map=map_obj,
name=layer.alternate,
ows_url=layer.ows_url,
layer_params=json.dumps(config),
visibility=True,
source_params=json.dumps(source_params)
)
else:
ogc_server_url = urlparse.urlsplit(
ogc_server_settings.PUBLIC_LOCATION).netloc
layer_url = urlparse.urlsplit(layer.ows_url).netloc
access_token = request.session['access_token'] if request and 'access_token' in request.session else None
if access_token and ogc_server_url == layer_url and 'access_token' not in layer.ows_url:
url = '%s?access_token=%s' % (layer.ows_url, access_token)
else:
url = layer.ows_url
maplayer = MapLayer(
map=map_obj,
name=layer.alternate,
ows_url=url,
# use DjangoJSONEncoder to handle Decimal values
layer_params=json.dumps(config, cls=DjangoJSONEncoder),
visibility=True
)
layers.append(maplayer)
if bbox and len(bbox) >= 4:
minx, maxx, miny, maxy = [float(coord) for coord in bbox]
x = (minx + maxx) / 2
y = (miny + maxy) / 2
if getattr(
settings,
'DEFAULT_MAP_CRS',
'EPSG:3857') == "EPSG:4326":
center = list((x, y))
else:
center = list(forward_mercator((x, y)))
if center[1] == float('-inf'):
center[1] = 0
BBOX_DIFFERENCE_THRESHOLD = 1e-5
# Check if the bbox is invalid
valid_x = (maxx - minx) ** 2 > BBOX_DIFFERENCE_THRESHOLD
valid_y = (maxy - miny) ** 2 > BBOX_DIFFERENCE_THRESHOLD
if valid_x:
width_zoom = math.log(360 / abs(maxx - minx), 2)
else:
width_zoom = 15
if valid_y:
height_zoom = math.log(360 / abs(maxy - miny), 2)
else:
height_zoom = 15
map_obj.center_x = center[0]
map_obj.center_y = center[1]
map_obj.zoom = math.ceil(min(width_zoom, height_zoom))
map_obj.handle_moderated_uploads()
if add_base_layers:
layers_to_add = DEFAULT_BASE_LAYERS + layers
else:
layers_to_add = layers
config = map_obj.viewer_json(
request, *layers_to_add)
config['fromLayer'] = True
return config
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(request.POST, instance=layer)
published_form = PublishStatusForm(request.POST, instance=layer)
if keywords_form.is_valid():
new_keywords = keywords_form.cleaned_data['keywords']
layer.keywords.clear()
layer.keywords.add(*new_keywords)
if metadata_form.is_valid():
# 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)
new_language = metadata_form.cleaned_data['language']
new_distribution_url = metadata_form.cleaned_data[
'distribution_url']
new_data_quality_statement = metadata_form.cleaned_data[
'data_quality_statement']
new_purpose = metadata_form.cleaned_data['purpose']
layer.language = new_language
layer.distribution_url = new_distribution_url
layer.data_quality_statement = new_data_quality_statement
layer.purpose = new_purpose
layer.save()
if published_form.is_valid():
layer.is_published = published_form.cleaned_data['is_published']
layer.save()
else:
keywords_form = KeywordsForm(instance=layer)
metadata_form = MetadataForm(instance=layer)
published_form = PublishStatusForm(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,
"published_form": published_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
if settings.SOCIAL_ORIGINS:
context_dict["social_links"] = build_social_links(request, layer)
return render_to_response(template, RequestContext(request, context_dict))
def add_layers_to_map_config(
request, map_obj, layer_names, add_base_layers=True):
DEFAULT_MAP_CONFIG, DEFAULT_BASE_LAYERS = default_map_config(request)
bbox = []
layers = []
for layer_name in layer_names:
try:
layer = _resolve_layer(request, layer_name)
except ObjectDoesNotExist:
# bad layer, skip
continue
except Http404:
# can't find the layer, skip it.
continue
if not request.user.has_perm(
'view_resourcebase',
obj=layer.get_self_resource()):
# invisible layer, skip inclusion
continue
layer_bbox = layer.bbox[0:4]
bbox = layer_bbox[:]
bbox[0] = layer_bbox[0]
bbox[1] = layer_bbox[2]
bbox[2] = layer_bbox[1]
bbox[3] = layer_bbox[3]
# assert False, str(layer_bbox)
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):
_sld = {
"title": style.sld_title or style.name,
"legend": {
"height": "40",
"width": "22",
"href": f"{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
config = layer.attribute_config()
if hasattr(layer, 'srid'):
config['crs'] = {
'type': 'name',
'properties': layer.srid
}
# Add required parameters for GXP lazy-loading
attribution = f"{layer.owner.first_name} {layer.owner.last_name}" if layer.owner.first_name or layer.owner.last_name else str(layer.owner) # noqa
srs = getattr(settings, 'DEFAULT_MAP_CRS', 'EPSG:3857')
srs_srid = int(srs.split(":")[1]) if srs != "EPSG:900913" else 3857
config["attribution"] = f"<span class='gx-attribution-title'>{attribution}</span>"
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,
"store": layer.store,
"name": layer.alternate,
"title": layer.title,
"style": '',
"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
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
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
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):
if layer.has_time:
from geonode.geoserver.views import get_capabilities
# 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:
from owslib.etree import etree as dlxml
namespaces = {'wms': 'http://www.opengis.net/wms',
'xlink': 'http://www.w3.org/1999/xlink',
'xsi': 'http://www.w3.org/2001/XMLSchema-instance'}
e = dlxml.fromstring(wms_capabilities)
for atype in e.findall(
f"./[wms:Name='{layer.alternate}']/wms:Dimension[@name='time']", namespaces):
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 in ['tileStore', 'remote']:
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": f"[R] {service.title}"}
maplayer = MapLayer(map=map_obj,
name=layer.alternate,
ows_url=layer.ows_url,
layer_params=json.dumps(config),
visibility=True,
source_params=json.dumps(source_params)
)
else:
ogc_server_url = urlsplit(
ogc_server_settings.PUBLIC_LOCATION).netloc
layer_url = urlsplit(layer.ows_url).netloc
access_token = request.session['access_token'] if request and 'access_token' in request.session else None
if access_token and ogc_server_url == layer_url and 'access_token' not in layer.ows_url:
url = f'{layer.ows_url}?access_token={access_token}'
else:
url = layer.ows_url
maplayer = MapLayer(
map=map_obj,
name=layer.alternate,
ows_url=url,
# use DjangoJSONEncoder to handle Decimal values
layer_params=json.dumps(config, cls=DjangoJSONEncoder),
visibility=True
)
layers.append(maplayer)
if bbox and len(bbox) >= 4:
minx, maxx, miny, maxy = [float(coord) for coord in bbox]
x = (minx + maxx) / 2
y = (miny + maxy) / 2
if getattr(
settings,
'DEFAULT_MAP_CRS',
'EPSG:3857') == "EPSG:4326":
center = list((x, y))
else:
center = list(forward_mercator((x, y)))
if center[1] == float('-inf'):
center[1] = 0
BBOX_DIFFERENCE_THRESHOLD = 1e-5
# Check if the bbox is invalid
valid_x = (maxx - minx) ** 2 > BBOX_DIFFERENCE_THRESHOLD
valid_y = (maxy - miny) ** 2 > BBOX_DIFFERENCE_THRESHOLD
if valid_x:
width_zoom = math.log(360 / abs(maxx - minx), 2)
else:
width_zoom = 15
if valid_y:
height_zoom = math.log(360 / abs(maxy - miny), 2)
else:
height_zoom = 15
map_obj.center_x = center[0]
map_obj.center_y = center[1]
map_obj.zoom = math.ceil(min(width_zoom, height_zoom))
map_obj.handle_moderated_uploads()
if add_base_layers:
layers_to_add = DEFAULT_BASE_LAYERS + layers
else:
layers_to_add = layers
config = map_obj.viewer_json(
request, *layers_to_add)
config['fromLayer'] = True
return config
def test_new_map_config(self):
"""Test that new map config can be properly assigned
"""
self.client.login(username='******', password='******')
# Test successful new map creation
m = Map()
admin_user = get_user_model().objects.get(username='******')
layer_name = Layer.objects.all()[0].typename
m.create_from_layer_list(admin_user, [layer_name], "title", "abstract")
map_id = m.id
url = reverse('new_map_json')
# Test GET method with COPY
response = self.client.get(url, {'copy': map_id})
self.assertEquals(response.status_code, 200)
map_obj = Map.objects.get(id=map_id)
config_map = map_obj.viewer_json(None, None)
response_config_dict = json.loads(response.content)
self.assertEquals(config_map['map']['layers'],
response_config_dict['map']['layers'])
# Test GET method no COPY and no layer in params
response = self.client.get(url)
self.assertEquals(response.status_code, 200)
config_default = default_map_config(None)[0]
response_config_dict = json.loads(response.content)
self.assertEquals(config_default['about']['abstract'],
response_config_dict['about']['abstract'])
self.assertEquals(config_default['about']['title'],
response_config_dict['about']['title'])
# Test GET method no COPY but with layer in params
response = self.client.get(url, {'layer': layer_name})
self.assertEquals(response.status_code, 200)
response_dict = json.loads(response.content)
self.assertEquals(response_dict['fromLayer'], True)
# Test POST method without authentication
self.client.logout()
response = self.client.post(url, {'layer': layer_name})
self.assertEquals(response.status_code, 401)
# Test POST method with authentication and a layer in params
self.client.login(username='******', password='******')
response = self.client.post(url, {'layer': layer_name})
# Should not accept the request
self.assertEquals(response.status_code, 400)
# Test POST method with map data in json format
response = self.client.post(url,
data=self.viewer_config,
content_type="text/json")
self.assertEquals(response.status_code, 200)
map_id = int(json.loads(response.content)['id'])
# Test methods other than GET or POST and no layer in params
response = self.client.put(url)
self.assertEquals(response.status_code, 405)
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
bbox = [float(coord) for coord in list(layer_bbox[0:4])]
config["srs"] = getattr(settings, 'DEFAULT_MAP_CRS', 'EPSG:900913')
config["bbox"] = bbox if config["srs"] != 'EPSG:900913' \
else 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))
# 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=getattr(settings, 'DEFAULT_MAP_CRS', '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,
'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'],
}
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
if settings.SOCIAL_ORIGINS:
context_dict["social_links"] = build_social_links(request, layer)
return render_to_response(template, RequestContext(request, context_dict))
def new_map_config(request):
'''
View that creates a new map.
If the query argument 'copy' is given, the initial map is
a copy of the map with the id specified, otherwise the
default map configuration is used. If copy is specified
and the map specified does not exist a 404 is returned.
'''
DEFAULT_MAP_CONFIG, DEFAULT_BASE_LAYERS = default_map_config()
if request.method == 'GET' and 'copy' in request.GET:
mapid = request.GET['copy']
map_obj = _resolve_map(request, mapid, 'base.view_resourcebase')
map_obj.abstract = DEFAULT_ABSTRACT
map_obj.title = DEFAULT_TITLE
if request.user.is_authenticated():
map_obj.owner = request.user
config = map_obj.viewer_json(request.user)
del config['id']
else:
if request.method == 'GET':
params = request.GET
elif request.method == 'POST':
params = request.POST
else:
return HttpResponse(status=405)
if 'layer' in params:
bbox = None
map_obj = Map(projection="EPSG:900913")
layers = []
for layer_name in params.getlist('layer'):
try:
layer = _resolve_layer(request, layer_name)
except ObjectDoesNotExist:
# bad layer, skip
continue
if not request.user.has_perm(
'view_resourcebase',
obj=layer.get_self_resource()):
# invisible layer, skip inclusion
continue
layer_bbox = layer.bbox
# assert False, str(layer_bbox)
if bbox is None:
bbox = list(layer_bbox[0:4])
else:
bbox[0] = min(bbox[0], layer_bbox[0])
bbox[1] = max(bbox[1], layer_bbox[1])
bbox[2] = min(bbox[2], layer_bbox[2])
bbox[3] = max(bbox[3], layer_bbox[3])
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])
config["queryable"] = True
if layer.storeType == "remoteStore":
service = layer.service
maplayer = MapLayer(map=map_obj,
name=layer.typename,
ows_url=layer.ows_url,
layer_params=json.dumps(config),
visibility=True,
source_params=json.dumps({
"ptype": service.ptype,
"remote": True,
"url": service.base_url,
"name": service.name}))
else:
maplayer = MapLayer(
map=map_obj,
name=layer.typename,
ows_url=layer.ows_url,
layer_params=json.dumps(config),
visibility=True
)
layers.append(maplayer)
if bbox is not None:
minx, miny, maxx, maxy = [float(c) for c in bbox]
x = (minx + maxx) / 2
y = (miny + maxy) / 2
center = list(forward_mercator((x, y)))
if center[1] == float('-inf'):
center[1] = 0
BBOX_DIFFERENCE_THRESHOLD = 1e-5
# Check if the bbox is invalid
valid_x = (maxx - minx) ** 2 > BBOX_DIFFERENCE_THRESHOLD
valid_y = (maxy - miny) ** 2 > BBOX_DIFFERENCE_THRESHOLD
if valid_x:
width_zoom = math.log(360 / abs(maxx - minx), 2)
else:
width_zoom = 15
if valid_y:
height_zoom = math.log(360 / abs(maxy - miny), 2)
else:
height_zoom = 15
map_obj.center_x = center[0]
map_obj.center_y = center[1]
map_obj.zoom = math.ceil(min(width_zoom, height_zoom))
config = map_obj.viewer_json(
request.user, *(DEFAULT_BASE_LAYERS + layers))
config['fromLayer'] = True
else:
config = DEFAULT_MAP_CONFIG
return json.dumps(config)
def new_map_config(request):
'''
View that creates a new map.
If the query argument 'copy' is given, the initial map is
a copy of the map with the id specified, otherwise the
default map configuration is used. If copy is specified
and the map specified does not exist a 404 is returned.
'''
DEFAULT_MAP_CONFIG, DEFAULT_BASE_LAYERS = default_map_config()
if request.method == 'GET' and 'copy' in request.GET:
mapid = request.GET['copy']
map_obj = _resolve_map(request, mapid, 'base.view_resourcebase')
map_obj.abstract = DEFAULT_ABSTRACT
map_obj.title = DEFAULT_TITLE
if request.user.is_authenticated():
map_obj.owner = request.user
config = map_obj.viewer_json(request.user)
del config['id']
else:
if request.method == 'GET':
params = request.GET
elif request.method == 'POST':
params = request.POST
else:
return HttpResponse(status=405)
if 'layer' in params:
bbox = None
map_obj = Map(projection="EPSG:900913")
layers = []
for layer_name in params.getlist('layer'):
try:
layer = _resolve_layer(request, layer_name)
except ObjectDoesNotExist:
# bad layer, skip
continue
if not request.user.has_perm(
'view_resourcebase',
obj=layer.get_self_resource()):
# invisible layer, skip inclusion
continue
layer_bbox = layer.bbox
# assert False, str(layer_bbox)
if bbox is None:
bbox = list(layer_bbox[0:4])
else:
bbox[0] = min(bbox[0], layer_bbox[0])
bbox[1] = max(bbox[1], layer_bbox[1])
bbox[2] = min(bbox[2], layer_bbox[2])
bbox[3] = max(bbox[3], layer_bbox[3])
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])
config["queryable"] = True
if layer.storeType == "remoteStore":
service = layer.service
maplayer = MapLayer(map=map_obj,
name=layer.typename,
ows_url=layer.ows_url,
layer_params=json.dumps(config),
visibility=True,
source_params=json.dumps({
"ptype": service.ptype,
"remote": True,
"url": service.base_url,
"name": service.name}))
else:
maplayer = MapLayer(
map=map_obj,
name=layer.typename,
ows_url=layer.ows_url,
layer_params=json.dumps(config),
visibility=True
)
layers.append(maplayer)
if bbox is not None:
minx, miny, maxx, maxy = [float(c) for c in bbox]
x = (minx + maxx) / 2
y = (miny + maxy) / 2
center = list(forward_mercator((x, y)))
if center[1] == float('-inf'):
center[1] = 0
BBOX_DIFFERENCE_THRESHOLD = 1e-5
# Check if the bbox is invalid
valid_x = (maxx - minx) ** 2 > BBOX_DIFFERENCE_THRESHOLD
valid_y = (maxy - miny) ** 2 > BBOX_DIFFERENCE_THRESHOLD
if valid_x:
width_zoom = math.log(360 / abs(maxx - minx), 2)
else:
width_zoom = 15
if valid_y:
height_zoom = math.log(360 / abs(maxy - miny), 2)
else:
height_zoom = 15
map_obj.center_x = center[0]
map_obj.center_y = center[1]
map_obj.zoom = math.ceil(min(width_zoom, height_zoom))
config = map_obj.viewer_json(
request.user, *(DEFAULT_BASE_LAYERS + layers))
config['fromLayer'] = True
else:
config = DEFAULT_MAP_CONFIG
return json.dumps(config)
def layer_detail(request, layername, template='layers/layer_detail.html'):
try:
user_role = request.GET['user_role']
except:
user_role = None
layer = _resolve_layer(request, layername, 'base.view_resourcebase',
_PERMISSION_MSG_VIEW)
user = request.user
edit_permit = False
if layer.owner == user and layer.status in ['DRAFT', 'ACTIVE', 'DENIED']:
edit_permit = True
elif user in layer.group.get_managers() and layer.status in [
'PENDING', 'ACTIVE', 'DENIED'
]:
edit_permit = True
if not edit_permit and layer.status == 'ACTIVE':
edit_permit = True
# if the edit request is not valid then just return from here
if not edit_permit:
return HttpResponse(loader.render_to_string(
'401.html',
RequestContext(request, {
'error_message':
_("You dont have permission to edit this layer.")
})),
status=401)
# return HttpResponse('You dont have permission to edit this layer')
# assert False, str(layer_bbox)
config = layer.attribute_config()
# Add required parameters for GXP lazy-loading
layer_bbox = layer.bbox
bbox = [float(coord) for coord in list(layer_bbox[0:4])]
config["srs"] = getattr(settings, 'DEFAULT_MAP_CRS', 'EPSG:900913')
config["bbox"] = bbox if config["srs"] != 'EPSG:900913' \
else 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))
# 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=getattr(settings, 'DEFAULT_MAP_CRS', '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)
granules = None
all_granules = 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:
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:
granules = {"features": []}
all_granules = {"features": []}
approve_form = ResourceApproveForm()
deny_form = ResourceDenyForm()
metadata_field_list = [
'owner', 'title', 'date', 'date_type', 'edition', 'abstract',
'purpose', 'maintenance_frequency', 'regions', 'restriction_code_type',
'constraints_other', 'license', 'language',
'spatial_representation_type', 'resource_type',
'temporal_extent_start', 'temporal_extent_end',
'supplemental_information', 'data_quality_statement', 'thumbnail_url',
'elevation_regex', 'time_regex', 'keywords', 'category'
]
if request.user == layer.owner or request.user in layer.group.get_managers(
):
if not layer.attributes:
messages.info(
request,
'Please update layer metadata, missing some informations')
elif not layer.metadata_author:
messages.info(
request,
'Please update layer metadata, missing some informations')
else:
for field in metadata_field_list:
if not getattr(layer, layer._meta.get_field(field).name):
messages.info(
request,
'Please update layer metadata, missing some informations'
)
break
# layer_name = layer.service_typename
# geoserver_user = OGC_SERVER['default']['USER']
# geoserver_password = OGC_SERVER['default']['PASSWORD']
# style_url = OGC_SERVER['default']['PUBLIC_LOCATION'] + "rest/layers/" + layer_name + ".json"
# response1 = requests.get(style_url, auth=HTTPBasicAuth(geoserver_user, geoserver_password))
# sld_file_name_url = response1.json()['layer']['defaultStyle']['href']
# response2 = requests.get(sld_file_name_url, auth=HTTPBasicAuth(geoserver_user, geoserver_password))
# file_name = response2.json()['style']['filename']
# sld_file_url = OGC_SERVER['default']['PUBLIC_LOCATION'] + "rest/styles/" + file_name
# sld_content = requests.get(sld_file_url, auth=HTTPBasicAuth(geoserver_user, geoserver_password)).content
#
# xlink = ''
# try:
# dict1 = xmltodict.parse(sld_content)
# dict2 = dict1['sld:StyledLayerDescriptor']['sld:NamedLayer']['sld:UserStyle']['sld:FeatureTypeStyle']\
# ['sld:Rule']['sld:PointSymbolizer']
# xlink = dict2['sld:Graphic']['sld:ExternalGraphic']['sld:OnlineResource']['@xlink:href']
# except:
# pass
xlink = style_chart_legend_color(layer)
context_dict = {
"resource":
layer,
'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,
"filter":
filter,
"user_role":
user_role,
"approve_form":
approve_form,
"deny_form":
deny_form,
"denied_comments":
LayerAuditActivity.objects.filter(
layer_submission_activity__layer=layer),
"status":
layer.status,
"chart_link":
xlink
}
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
if settings.SOCIAL_ORIGINS:
context_dict["social_links"] = build_social_links(request, layer)
return render_to_response(template, RequestContext(request, context_dict))
