def test_tile_url(self):
"""Test to return tile format."""
filename = os.path.join(gisdata.GOOD_DATA, 'raster/test_grid.tif')
uploaded = file_upload(filename)
tile_format = tile_url_format(uploaded.name)
# Accessing this directly should return 404
response = self.client.get(tile_format)
self.assertEqual(response.status_code, 404)
qgis_tile_url = tile_url(uploaded, 11, 1576, 1054, internal=True)
parse_result = urlparse.urlparse(qgis_tile_url)
base_net_loc = urlparse.urlparse(settings.QGIS_SERVER_URL).netloc
self.assertEqual(base_net_loc, parse_result.netloc)
query_string = urlparse.parse_qs(parse_result.query)
expected_query_string = {
'SERVICE': 'WMS',
'VERSION': '1.3.0',
'REQUEST': 'GetMap',
'BBOX': '10801469.341,-606604.256471,10821037.2203,-587036.37723',
'CRS': 'EPSG:3857',
'WIDTH': '256',
'HEIGHT': '256',
'LAYERS': 'test_grid',
'STYLE': 'default',
'FORMAT': 'image/png',
'TRANSPARENT': 'true',
'DPI': '96',
'MAP_RESOLUTION': '96',
'FORMAT_OPTIONS': 'dpi:96'
}
for key, value in expected_query_string.iteritems():
# urlparse.parse_qs returned a dictionary of list
actual_value = query_string[key][0]
self.assertEqual(actual_value, value)
# Check that qgis server returns valid url
# Use python requests because the endpoint is not django
response = requests.get(qgis_tile_url)
self.assertEqual(response.status_code, 200)
self.assertEqual(response.headers.get('Content-Type'), 'image/png')
self.assertEqual(what('', h=response.content), 'png')
uploaded.delete()
def test_tile_url(self):
"""Test to return tile format."""
filename = os.path.join(gisdata.GOOD_DATA, 'raster/test_grid.tif')
uploaded = file_upload(filename)
tile_format = tile_url_format(uploaded.name)
# Accessing this directly should return 404
response = self.client.get(tile_format)
self.assertEqual(response.status_code, 404)
qgis_tile_url = tile_url(uploaded, 11, 1576, 1054, internal=True)
parse_result = urlparse.urlparse(qgis_tile_url)
base_net_loc = urlparse.urlparse(settings.QGIS_SERVER_URL).netloc
self.assertEqual(base_net_loc, parse_result.netloc)
query_string = urlparse.parse_qs(parse_result.query)
expected_query_string = {
'SERVICE': 'WMS',
'VERSION': '1.3.0',
'REQUEST': 'GetMap',
'BBOX': '10801469.341,-606604.256471,10821037.2203,-587036.37723',
'CRS': 'EPSG:3857',
'WIDTH': '256',
'HEIGHT': '256',
'LAYERS': 'test_grid',
'STYLE': 'default',
'FORMAT': 'image/png',
'TRANSPARENT': 'true',
'DPI': '96',
'MAP_RESOLUTION': '96',
'FORMAT_OPTIONS': 'dpi:96'
}
for key, value in expected_query_string.iteritems():
# urlparse.parse_qs returned a dictionary of list
actual_value = query_string[key][0]
self.assertEqual(actual_value, value)
# Check that qgis server returns valid url
# Use python requests because the endpoint is not django
response = requests.get(qgis_tile_url)
self.assertEqual(response.status_code, 200)
self.assertEqual(response.headers.get('Content-Type'), 'image/png')
self.assertEqual(what('', h=response.content), 'png')
uploaded.delete()
def tile_404(request, layername):
"""This view is used when the user try to use the raw tile URL.
When the URL contains {z}/{x}/{y}.png, display this page.
:param layername: The layer name in Geonode.
:type layername: basestring
"""
layer = get_object_or_404(Layer, name=layername)
get_object_or_404(QGISServerLayer, layer=layer)
msg = _(
'You should use a GIS software or a library which support TMS service '
'to use this URL : {url}').format(url=tile_url_format(layername))
return TemplateResponse(request, '404.html', {
'message': msg
}, status=404).render()
def tile_404(request, layername):
"""This view is used when the user try to use the raw tile URL.
When the URL contains {z}/{x}/{y}.png, display this page.
:param layername: The layer name in Geonode.
:type layername: basestring
"""
layer = get_object_or_404(Layer, name=layername)
get_object_or_404(QGISServerLayer, layer=layer)
msg = _(
'You should use a GIS software or a library which support TMS service '
'to use this URL : {url}').format(url=tile_url_format(layername))
return TemplateResponse(
request,
'404.html',
{
'message': msg
},
status=404).render()
def qgis_server_post_save(instance, sender, **kwargs):
"""Save keywords to QGIS Server.
The way keywords are implemented requires the layer to be saved to the
database before accessing them.
This hook also creates QGIS Project. Which is essentials for QGIS Server.
There are also several Geonode Links generated, like thumbnail and legends
:param instance: geonode Layer
:type instance: Layer
:param sender: geonode Layer type
:type sender: type(Layer)
"""
if not sender == Layer:
return
# TODO
# 1. Create or update associated QGISServerLayer [Done]
# 2. Create Link for the tile and legend.
logger.debug('QGIS Server Post Save')
# copy layer to QGIS Layer Directory
try:
geonode_layer_path = instance.get_base_file()[0].file.path
except AttributeError:
logger.debug('Layer does not have base file')
return
qgis_layer, created = QGISServerLayer.objects.get_or_create(
layer=instance)
logger.debug('Geonode Layer Path %s' % geonode_layer_path)
base_filename, original_ext = os.path.splitext(geonode_layer_path)
extensions = QGISServerLayer.accepted_format
is_shapefile = False
for ext in extensions:
if os.path.exists(base_filename + '.' + ext):
is_shapefile = is_shapefile or ext == 'shp'
try:
if created:
# Assuming different layer has different filename because
# geonode rename it
shutil.copy2(
base_filename + '.' + ext,
QGIS_layer_directory
)
logger.debug('Create new basefile')
else:
# If there is already a file, replace the old one
qgis_layer_base_filename = qgis_layer.qgis_layer_path_prefix
shutil.copy2(
base_filename + '.' + ext,
qgis_layer_base_filename + '.' + ext
)
logger.debug('Overwrite existing basefile')
logger.debug(
'Copying %s' % base_filename + '.' + ext + ' Success')
logger.debug('Into %s' % QGIS_layer_directory)
except IOError as e:
logger.debug(
'Copying %s' % base_filename + '.' + ext + ' FAILED ' + e)
if created:
# Only set when creating new QGISServerLayer Object
geonode_filename = os.path.basename(geonode_layer_path)
basename = os.path.splitext(geonode_filename)[0]
qgis_layer.base_layer_path = os.path.join(
QGIS_layer_directory,
basename + original_ext # Already with dot
)
qgis_layer.save()
# Set layer crs
try:
if is_shapefile:
dataset = ogr.Open(geonode_layer_path)
layer = dataset.GetLayer()
spatial_ref = layer.GetSpatialRef()
srid = spatial_ref.GetAuthorityCode(None)
if srid:
instance.srid = srid
else:
dataset = gdal.Open(geonode_layer_path)
prj = dataset.GetProjection()
srs = osr.SpatialReference(wkt=prj)
srid = srs.GetAuthorityCode(None)
if srid:
instance.srid = srid
except Exception as e:
logger.debug("Can't retrieve projection: {layer}".format(
layer=geonode_layer_path))
logger.exception(e)
# base url for geonode
base_url = settings.SITEURL
# Set Link for Download Raw in Zip File
zip_download_url = reverse(
'qgis_server:download-zip', kwargs={'layername': instance.name})
zip_download_url = urljoin(base_url, zip_download_url)
logger.debug('zip_download_url: %s' % zip_download_url)
if is_shapefile:
link_name = 'Zipped Shapefile'
link_mime = 'SHAPE-ZIP'
else:
link_name = 'Zipped All Files'
link_mime = 'ZIP'
# Zip file
Link.objects.update_or_create(
resource=instance.resourcebase_ptr,
name=link_name,
defaults=dict(
extension='zip',
mime=link_mime,
url=zip_download_url,
link_type='data'
)
)
# WMS link layer workspace
ogc_wms_url = urljoin(
settings.SITEURL,
reverse(
'qgis_server:layer-request', kwargs={'layername': instance.name}))
ogc_wms_name = 'OGC WMS: %s Service' % instance.workspace
ogc_wms_link_type = 'OGC:WMS'
Link.objects.update_or_create(
resource=instance.resourcebase_ptr,
name=ogc_wms_name,
link_type=ogc_wms_link_type,
defaults=dict(
extension='html',
url=ogc_wms_url,
mime='text/html',
link_type=ogc_wms_link_type
)
)
# QGS link layer workspace
ogc_qgs_url = urljoin(
base_url,
reverse(
'qgis_server:download-qgs',
kwargs={'layername': instance.name}))
logger.debug('qgs_download_url: %s' % ogc_qgs_url)
link_name = 'QGIS project file (.qgs)'
link_mime = 'application/xml'
Link.objects.update_or_create(
resource=instance.resourcebase_ptr,
name=link_name,
defaults=dict(
extension='qgs',
mime=link_mime,
url=ogc_qgs_url,
link_type='data'
)
)
if instance.is_vector():
# WFS link layer workspace
ogc_wfs_url = urljoin(
settings.SITEURL,
reverse(
'qgis_server:layer-request',
kwargs={'layername': instance.name}))
ogc_wfs_name = 'OGC WFS: %s Service' % instance.workspace
ogc_wfs_link_type = 'OGC:WFS'
Link.objects.update_or_create(
resource=instance.resourcebase_ptr,
name=ogc_wfs_name,
link_type=ogc_wfs_link_type,
defaults=dict(
extension='html',
url=ogc_wfs_url,
mime='text/html',
link_type=ogc_wfs_link_type
)
)
# QLR link layer workspace
ogc_qlr_url = urljoin(
base_url,
reverse(
'qgis_server:download-qlr',
kwargs={'layername': instance.name}))
logger.debug('qlr_download_url: %s' % ogc_qlr_url)
link_name = 'QGIS layer file (.qlr)'
link_mime = 'application/xml'
Link.objects.update_or_create(
resource=instance.resourcebase_ptr,
name=link_name,
defaults=dict(
extension='qlr',
mime=link_mime,
url=ogc_qlr_url,
link_type='data'
)
)
# if layer has overwrite attribute, then it probably comes from
# importlayers management command and needs to be overwritten
overwrite = getattr(instance, 'overwrite', False)
# Create the QGIS Project
response = create_qgis_project(
instance, qgis_layer.qgis_project_path, overwrite=overwrite,
internal=True)
logger.debug('Creating the QGIS Project : %s' % response.url)
if response.content != 'OK':
logger.debug('Result : %s' % response.content)
# Generate style model cache
style_list(instance, internal=False)
# Remove QML file if necessary
try:
qml_file = instance.upload_session.layerfile_set.get(name='qml')
if not os.path.exists(qml_file.file.path):
qml_file.delete()
except LayerFile.DoesNotExist:
pass
Link.objects.update_or_create(
resource=instance.resourcebase_ptr,
name="Tiles",
defaults=dict(
url=tile_url_format(instance.name),
extension='tiles',
mime='image/png',
link_type='image'
)
)
if original_ext.split('.')[-1] in QGISServerLayer.geotiff_format:
# geotiff link
geotiff_url = reverse(
'qgis_server:geotiff', kwargs={'layername': instance.name})
geotiff_url = urljoin(base_url, geotiff_url)
logger.debug('geotif_url: %s' % geotiff_url)
Link.objects.update_or_create(
resource=instance.resourcebase_ptr,
name="GeoTIFF",
defaults=dict(
extension=original_ext.split('.')[-1],
url=geotiff_url,
mime='image/tiff',
link_type='image'
)
)
# Create legend link
legend_url = reverse(
'qgis_server:legend',
kwargs={'layername': instance.name}
)
legend_url = urljoin(base_url, legend_url)
Link.objects.update_or_create(
resource=instance.resourcebase_ptr,
name='Legend',
defaults=dict(
extension='png',
url=legend_url,
mime='image/png',
link_type='image',
)
)
# Create thumbnail
create_qgis_server_thumbnail.delay(
instance, overwrite=overwrite)
# Attributes
set_attributes(instance)
# Update xml file
# Read metadata from layer that InaSAFE use.
# Some are not found: organisation, email, url
try:
new_values = {
'date': instance.date.isoformat(),
'abstract': instance.abstract,
'title': instance.title,
'license': instance.license_verbose,
}
except (TypeError, AttributeError):
new_values = {}
pass
# Get the path of the metadata file
basename, _ = os.path.splitext(qgis_layer.base_layer_path)
xml_file_path = basename + '.xml'
if os.path.exists(xml_file_path):
try:
update_xml(xml_file_path, new_values)
except (TypeError, AttributeError):
pass
# Also update xml in QGIS Server
xml_file_path = qgis_layer.qgis_layer_path_prefix + '.xml'
if os.path.exists(xml_file_path):
try:
update_xml(xml_file_path, new_values)
except (TypeError, AttributeError):
pass
# Remove existing tile caches if overwrite
if overwrite:
tiles_directory = settings.QGIS_SERVER_CONFIG['tiles_directory']
basename, _ = os.path.splitext(qgis_layer.base_layer_path)
basename = os.path.basename(basename)
tiles_cache_path = os.path.join(tiles_directory, basename)
try:
shutil.rmtree(tiles_cache_path)
except OSError:
# The path doesn't exists yet
pass
