def test_add_delete_style(self):
"""Test add new style using qgis_server views."""
filename = os.path.join(gisdata.GOOD_DATA, 'raster/test_grid.tif')
layer = file_upload(filename)
""":type: geonode.layers.models.Layer"""
self.client.login(username='******', password='******')
qml_path = self.data_path('test_grid.qml')
add_style_url = reverse('qgis_server:upload-qml',
kwargs={'layername': layer.name})
with open(qml_path) as file_handle:
form_data = {
'name': 'new_style',
'title': 'New Style',
'qml': file_handle
}
response = self.client.post(add_style_url, data=form_data)
self.assertEqual(response.status_code, 201)
actual_list_style = style_list(layer, internal=False)
if actual_list_style:
expected_list_style = ['default', 'new_style']
self.assertEqual(set(expected_list_style),
set([style.name for style in actual_list_style]))
# Test delete request
delete_style_url = reverse('qgis_server:remove-qml',
kwargs={
'layername': layer.name,
'style_name': 'default'
})
response = self.client.delete(delete_style_url)
self.assertEqual(response.status_code, 200)
actual_list_style = style_list(layer, internal=False)
if actual_list_style:
expected_list_style = ['new_style']
self.assertEqual(set(expected_list_style),
set([style.name for style in actual_list_style]))
# Check new default
default_style_url = reverse('qgis_server:default-qml',
kwargs={'layername': layer.name})
response = self.client.get(default_style_url)
self.assertEqual(response.status_code, 200)
expected_default_style_retval = {
'name': 'new_style',
}
actual_default_style_retval = json.loads(response.content)
for key, value in expected_default_style_retval.iteritems():
self.assertEqual(actual_default_style_retval[key], value)
layer.delete()
def legend(request, layername, layertitle=False, style=None):
"""Get the legend from a layer.
:param layername: The layer name in Geonode.
:type layername: basestring
:param layertitle: Add the layer title in the legend. Default to False.
:type layertitle: bool
:param style: Layer style to choose
:type style: str
:return: The HTTPResponse with a PNG.
"""
layer = get_object_or_404(Layer, name=layername)
qgis_layer = get_object_or_404(QGISServerLayer, layer=layer)
# get default style name
if not style:
# generate style cache
if not qgis_layer.default_style:
try:
style_list(layer, internal=False)
except Exception:
logger.warning("Failed to fetch styles")
# refresh values
qgis_layer.refresh_from_db()
if qgis_layer.default_style:
style = qgis_layer.default_style.name
tiles_directory = QGIS_SERVER_CONFIG['tiles_directory']
legend_path = QGIS_SERVER_CONFIG['legend_path']
legend_filename = legend_path % (qgis_layer.qgis_layer_name, style)
# GOOD -- Verify with normalised version of path
legend_filename = os.path.normpath(legend_filename)
if not legend_filename.startswith(tiles_directory):
return HttpResponseServerError()
if not os.path.exists(legend_filename):
if not os.path.exists(os.path.dirname(legend_filename)):
os.makedirs(os.path.dirname(legend_filename))
url = legend_url(layer, layertitle, style=style, internal=True)
result = cache_request.apply_async((url, legend_filename))
# Attempt to run task synchronously
if not result.get():
# If not succeded, provides error message.
return HttpResponseServerError('Failed to fetch legend.')
if image_format(legend_filename) != 'png':
logger.error('%s is not valid PNG.' % legend_filename)
os.remove(legend_filename)
if not os.path.exists(legend_filename):
return HttpResponse('The legend could not be found.', status=409)
with open(legend_filename, 'rb') as f:
return HttpResponse(f.read(), content_type='image/png')
def legend(request, layername, layertitle=False, style=None):
"""Get the legend from a layer.
:param layername: The layer name in Geonode.
:type layername: basestring
:param layertitle: Add the layer title in the legend. Default to False.
:type layertitle: bool
:param style: Layer style to choose
:type style: str
:return: The HTTPResponse with a PNG.
"""
layer = get_object_or_404(Layer, name=layername)
qgis_layer = get_object_or_404(QGISServerLayer, layer=layer)
# get default style name
if not style:
# generate style cache
if not qgis_layer.default_style:
try:
style_list(layer, internal=False)
except BaseException:
print 'Failed to fetch styles'
# refresh values
qgis_layer.refresh_from_db()
if qgis_layer.default_style:
style = qgis_layer.default_style.name
legend_path = QGIS_SERVER_CONFIG['legend_path']
legend_filename = legend_path % (qgis_layer.qgis_layer_name, style)
if not os.path.exists(legend_filename):
if not os.path.exists(os.path.dirname(legend_filename)):
os.makedirs(os.path.dirname(legend_filename))
url = legend_url(layer, layertitle, style=style, internal=True)
result = cache_request.delay(url, legend_filename)
# Attempt to run task synchronously
if not result.get():
# If not succeded, provides error message.
return HttpResponseServerError('Failed to fetch legend.')
if image_format(legend_filename) != 'png':
logger.error('%s is not valid PNG.' % legend_filename)
os.remove(legend_filename)
if not os.path.exists(legend_filename):
return HttpResponse('The legend could not be found.', status=409)
with open(legend_filename, 'rb') as f:
return HttpResponse(f.read(), content_type='image/png')
def test_list_style(self):
"""Test querying list of styles from QGIS Server."""
filename = os.path.join(gisdata.GOOD_DATA, 'raster/test_grid.tif')
layer = file_upload(filename)
""":type: geonode.layers.models.Layer"""
actual_list_style = style_list(layer, internal=False)
expected_list_style = ['default']
# There will be a default style
self.assertEqual(
set(expected_list_style),
set([style.name for style in actual_list_style]))
style_list_url = reverse(
'qgis_server:download-qml',
kwargs={
'layername': layer.name
})
response = self.client.get(style_list_url)
self.assertEqual(response.status_code, 200)
actual_list_style = json.loads(response.content)
# There will be a default style
self.assertEqual(
set(expected_list_style),
set([style['name'] for style in actual_list_style]))
layer.delete()
def test_list_style(self):
"""Test querying list of styles from QGIS Server."""
filename = os.path.join(gisdata.GOOD_DATA, 'raster/test_grid.tif')
layer = file_upload(filename)
""":type: geonode.layers.models.Layer"""
actual_list_style = style_list(layer, internal=False)
expected_list_style = ['default']
# There will be a default style
if actual_list_style:
self.assertEqual(
set(expected_list_style),
set([style.name for style in actual_list_style]))
style_list_url = reverse(
'qgis_server:download-qml',
kwargs={
'layername': layer.name
})
response = self.client.get(style_list_url)
self.assertEqual(response.status_code, 200)
content = ensure_string(response.content)
if isinstance(content, bytes):
content = content.decode('UTF-8')
actual_list_style = json.loads(content)
# There will be a default style
self.assertEqual(
set(expected_list_style),
set([style['name'] for style in actual_list_style]))
layer.delete()
def handle(self, *args, **options):
layers = Layer.objects.all()
for l in layers:
try:
l.qgis_layer
except Exception:
print("Layer {} has no associated qgis_layer".format(l.name))
continue
if l.qgis_layer:
print("Fetching styles for layer %s".format(l.name))
try:
styles = style_list(l, internal=False)
except Exception:
print("Failed to fetch styles")
continue
print("Successfully fetch %d style(s)\n".format(len(styles)))
def handle(self, *args, **options):
layers = Layer.objects.all()
for l in layers:
try:
l.qgis_layer
except:
print 'Layer %s has no associated qgis_layer' % l.name
continue
if l.qgis_layer:
print 'Fetching styles for layer %s' % l.name
try:
styles = style_list(l, internal=False)
except:
print 'Failed to fetch styles'
continue
print 'Successfully fetch %d style(s)' % len(styles)
print ''
def qml_style(request, layername, style_name=None):
"""Update/Retrieve QML style of a given QGIS Layer.
:param layername: The layer name in Geonode.
:type layername: basestring
:param style_name: The style name recognized by QGIS Server
:type style_name: str
"""
layer = get_object_or_404(Layer, name=layername)
if request.method == 'GET':
# Request QML from QGIS server
if not style_name:
# If no style name provided, then it is a List request
styles_obj = None
try:
styles_obj = style_list(layer, internal=False)
except BaseException:
print 'Failed to fetch styles'
styles_dict = []
if styles_obj:
styles_dict = [model_to_dict(s) for s in styles_obj]
# If no style returned by GetCapabilities, this is a bug in QGIS
# Attempt to generate default style name
if not styles_dict:
style_url = style_get_url(layer, 'default')
response = requests.get(style_url)
if response.status_code == 200:
style_url = style_add_url(layer, 'default')
with open(layer.qgis_layer.qml_path, 'w') as f:
f.write(response.content)
response = requests.get(style_url)
if response.status_code == 200:
styles_obj = style_list(layer, internal=False)
styles_dict = [model_to_dict(s) for s in styles_obj]
response = HttpResponse(
json.dumps(styles_dict), content_type='application/json')
return response
# Return XML file of the style
style_url = style_get_url(layer, style_name, internal=False)
response = requests.get(style_url)
if response.status_code == 200:
response = HttpResponse(
response.content, content_type='text/xml')
response[
'Content-Disposition'] = 'attachment; filename=%s.qml' % (
style_name, )
else:
response = HttpResponse(
response.content, status=response.status_code)
return response
elif request.method == 'POST':
# For people who uses API request
if not request.user.has_perm(
'change_resourcebase', layer.get_self_resource()):
return HttpResponse(
'User does not have permission to change QML style.',
status=403)
# Request about adding new QML style
form = QGISLayerStyleUploadForm(request.POST, request.FILES)
if not form.is_valid():
return TemplateResponse(
request,
'qgis_server/forms/qml_style.html',
{
'resource': layer,
'style_upload_form': form
},
status=400).render()
try:
uploaded_qml = request.FILES['qml']
# update qml in uploaded media folder
# check upload session, is qml file exists?
layerfile_set = layer.upload_session.layerfile_set
try:
qml_layer_file = layerfile_set.get(name='qml')
# if it is exists, we need to delete it, because it won't be
# managed by geonode
qml_layer_file.delete()
except LayerFile.DoesNotExist:
pass
# update qml in QGIS Layer folder
content = uploaded_qml.read()
qgis_layer = get_object_or_404(QGISServerLayer, layer=layer)
with open(qgis_layer.qml_path, mode='w') as f:
f.write(content)
# construct URL to post new QML
style_name = request.POST['name']
style_title = request.POST['title']
if not style_name:
# Assign default name
name_format = 'style_%Y%m%d%H%M%S'
current_time = datetime.datetime.utcnow()
style_name = current_time.strftime(name_format)
# Add new style
style_url = style_add_url(layer, style_name)
response = requests.get(style_url)
if not (response.status_code == 200 and response.content == 'OK'):
try:
style_list(layer, internal=False)
except BaseException:
print 'Failed to fetch styles'
return TemplateResponse(
request,
'qgis_server/forms/qml_style.html',
{
'resource': layer,
'style_upload_form': QGISLayerStyleUploadForm(),
'alert': True,
'alert_message': response.content,
'alert_class': 'alert-danger'
},
status=response.status_code).render()
# We succeeded on adding new style
# Refresh style models
try:
style_list(layer, internal=False)
qgis_style = layer.qgis_layer.styles.get(name=style_name)
qgis_style.title = style_title
qgis_style.save()
alert_message = 'Successfully add style %s' % style_name
except BaseException:
alert_message = 'Failed to fetch styles'
return TemplateResponse(
request,
'qgis_server/forms/qml_style.html',
{
'resource': layer,
'style_upload_form': form,
'alert': True,
'alert_class': 'alert-success',
'alert_message': alert_message
},
status=201).render()
except Exception as e:
logger.exception(e)
return HttpResponseServerError()
elif request.method == 'DELETE':
# Request to delete particular QML Style
if not style_name:
# Style name should exists
return HttpResponseBadRequest('Style name not provided.')
# Handle removing tile-style cache
try:
style = layer.qgis_layer.styles.get(name=style_name)
shutil.rmtree(style.style_tile_cache_path)
except BaseException:
pass
style_url = style_remove_url(layer, style_name)
response = requests.get(style_url)
if not (response.status_code == 200 and response.content == 'OK'):
alert_message = response.content
if 'NAME is NOT an existing style.' in response.content:
alert_message = '%s is not an existing style' % style_name
try:
style_list(layer, internal=False)
except BaseException:
print 'Failed to fetch styles'
return TemplateResponse(
request,
'qgis_server/forms/qml_style.html',
{
'resource': layer,
'style_upload_form': QGISLayerStyleUploadForm(),
'alert': True,
'alert_message': alert_message,
'alert_class': 'alert-danger'
},
status=response.status_code).render()
# Successfully removed styles
# Handle when default style is deleted.
# Will be handled by style_list method
try:
style_list(layer, internal=False)
alert_message = 'Successfully deleted style %s' % style_name
except BaseException:
alert_message = 'Failed to fetch styles'
return TemplateResponse(
request,
'qgis_server/forms/qml_style.html',
{
'resource': layer,
'style_upload_form': QGISLayerStyleUploadForm(),
'alert': True,
'alert_message': alert_message,
'alert_class': 'alert-success'
},
status=200).render()
return HttpResponseBadRequest()
def tile(request, layername, z, x, y, style=None):
"""Get the tile from a layer.
:param layername: The layer name in Geonode.
:type layername: basestring
:param z: TMS coordinate, zoom parameter
:type z: int, str
:param x: TMS coordinate, longitude parameter
:type x: int, str
:param y: TMS coordinate, latitude parameter
:type y: int, str
:param style: Layer style to choose
:type style: str
:return: The HTTPResponse with a PNG.
"""
x = int(x)
y = int(y)
z = int(z)
layer = get_object_or_404(Layer, name=layername)
qgis_layer = get_object_or_404(QGISServerLayer, layer=layer)
# get default style name
if not style:
# generate style cache
if not qgis_layer.default_style:
try:
style_list(layer, internal=False)
except BaseException:
print 'Failed to fetch styles'
# refresh values
qgis_layer.refresh_from_db()
if qgis_layer.default_style:
style = qgis_layer.default_style.name
tile_path = QGIS_SERVER_CONFIG['tile_path']
tile_filename = tile_path % (qgis_layer.qgis_layer_name, style, z, x, y)
if not os.path.exists(tile_filename):
if not os.path.exists(os.path.dirname(tile_filename)):
os.makedirs(os.path.dirname(tile_filename))
# Use internal url
url = tile_url(layer, z, x, y, style=style, internal=True)
result = cache_request.delay(url, tile_filename)
# Attempt to run task synchronously
if not result.get():
# If not succeded, provides error message.
return HttpResponseServerError('Failed to fetch tile.')
if image_format(tile_filename) != 'png':
logger.error('%s is not valid PNG.' % tile_filename)
os.remove(tile_filename)
if not os.path.exists(tile_filename):
return HttpResponse('The tile could not be found.', status=409)
with open(tile_filename, 'rb') as f:
return HttpResponse(f.read(), content_type='image/png')
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
def test_style_management_url(self):
"""Test QGIS Server style management url construction."""
filename = os.path.join(gisdata.GOOD_DATA, 'raster/test_grid.tif')
uploaded = file_upload(filename)
# Get default style
# There will always be a default style when uploading a layer
style_url = style_get_url(uploaded, 'default', internal=True)
response = requests.get(style_url)
self.assertEqual(response.status_code, 200)
self.assertEqual(response.headers.get('Content-Type'), 'text/xml')
# it has to contains qgis tags
style_xml = dlxml.fromstring(response.content)
self.assertTrue('qgis' in style_xml.tag)
# Add new style
# change default style slightly
self.assertTrue('WhiteToBlack' not in response.content)
self.assertTrue('BlackToWhite' in response.content)
new_style_xml = dlxml.fromstring(
response.content.replace('BlackToWhite', 'WhiteToBlack'))
new_xml_content = etree.tostring(new_style_xml, pretty_print=True)
# save it to qml file, accessible by qgis server
qgis_layer = QGISServerLayer.objects.get(layer=uploaded)
with open(qgis_layer.qml_path, mode='w') as f:
f.write(new_xml_content)
style_url = style_add_url(uploaded, 'new_style', internal=True)
response = requests.get(style_url)
self.assertEqual(response.status_code, 200)
self.assertEqual(response.content, 'OK')
# Get style list
qml_styles = style_list(uploaded, internal=False)
if qml_styles:
expected_style_names = ['default', 'new_style']
actual_style_names = [s.name for s in qml_styles]
self.assertEqual(set(expected_style_names),
set(actual_style_names))
# Get new style
style_url = style_get_url(uploaded, 'new_style', internal=True)
response = requests.get(style_url)
self.assertEqual(response.status_code, 200)
self.assertEqual(response.headers.get('Content-Type'), 'text/xml')
self.assertTrue('WhiteToBlack' in response.content)
# Set default style
style_url = style_set_default_url(uploaded, 'new_style', internal=True)
response = requests.get(style_url)
self.assertEqual(response.status_code, 200)
self.assertEqual(response.content, 'OK')
# Remove style
style_url = style_remove_url(uploaded, 'new_style', internal=True)
response = requests.get(style_url)
self.assertEqual(response.status_code, 200)
self.assertEqual(response.content, 'OK')
# Cleanup
uploaded.delete()
def test_add_delete_style(self):
"""Test add new style using qgis_server views."""
filename = os.path.join(gisdata.GOOD_DATA, 'raster/test_grid.tif')
layer = file_upload(filename)
""":type: geonode.layers.models.Layer"""
self.client.login(username='******', password='******')
qml_path = self.data_path('test_grid.qml')
add_style_url = reverse(
'qgis_server:upload-qml',
kwargs={
'layername': layer.name})
with open(qml_path) as file_handle:
form_data = {
'name': 'new_style',
'title': 'New Style',
'qml': file_handle
}
response = self.client.post(
add_style_url,
data=form_data)
self.assertEqual(response.status_code, 201)
actual_list_style = style_list(layer, internal=False)
expected_list_style = ['default', 'new_style']
self.assertEqual(
set(expected_list_style),
set([style.name for style in actual_list_style]))
# Test delete request
delete_style_url = reverse(
'qgis_server:remove-qml',
kwargs={
'layername': layer.name,
'style_name': 'default'})
response = self.client.delete(delete_style_url)
self.assertEqual(response.status_code, 200)
actual_list_style = style_list(layer, internal=False)
expected_list_style = ['new_style']
self.assertEqual(
set(expected_list_style),
set([style.name for style in actual_list_style]))
# Check new default
default_style_url = reverse(
'qgis_server:default-qml',
kwargs={
'layername': layer.name})
response = self.client.get(default_style_url)
self.assertEqual(response.status_code, 200)
expected_default_style_retval = {
'name': 'new_style',
}
actual_default_style_retval = json.loads(response.content)
for key, value in expected_default_style_retval.iteritems():
self.assertEqual(actual_default_style_retval[key], value)
layer.delete()
def test_style_management_url(self):
"""Test QGIS Server style management url construction."""
filename = os.path.join(gisdata.GOOD_DATA, 'raster/test_grid.tif')
uploaded = file_upload(filename)
# Get default style
# There will always be a default style when uploading a layer
style_url = style_get_url(uploaded, 'default', internal=True)
response = requests.get(style_url)
self.assertEqual(response.status_code, 200)
self.assertEqual(response.headers.get('Content-Type'), 'text/xml')
# it has to contains qgis tags
style_xml = etree.fromstring(response.content)
self.assertTrue('qgis' in style_xml.tag)
# Add new style
# change default style slightly
self.assertTrue('WhiteToBlack' not in response.content)
self.assertTrue('BlackToWhite' in response.content)
new_style_xml = etree.fromstring(
response.content.replace('BlackToWhite', 'WhiteToBlack'))
new_xml_content = etree.tostring(new_style_xml, pretty_print=True)
# save it to qml file, accessible by qgis server
qgis_layer = QGISServerLayer.objects.get(layer=uploaded)
with open(qgis_layer.qml_path, mode='w') as f:
f.write(new_xml_content)
style_url = style_add_url(uploaded, 'new_style', internal=True)
response = requests.get(style_url)
self.assertEqual(response.status_code, 200)
self.assertEqual(response.content, 'OK')
# Get style list
qml_styles = style_list(uploaded, internal=False)
expected_style_names = ['default', 'new_style']
actual_style_names = [s.name for s in qml_styles]
self.assertEqual(set(expected_style_names), set(actual_style_names))
# Get new style
style_url = style_get_url(uploaded, 'new_style', internal=True)
response = requests.get(style_url)
self.assertEqual(response.status_code, 200)
self.assertEqual(response.headers.get('Content-Type'), 'text/xml')
self.assertTrue('WhiteToBlack' in response.content)
# Set default style
style_url = style_set_default_url(
uploaded, 'new_style', internal=True)
response = requests.get(style_url)
self.assertEqual(response.status_code, 200)
self.assertEqual(response.content, 'OK')
# Remove style
style_url = style_remove_url(uploaded, 'new_style', internal=True)
response = requests.get(style_url)
self.assertEqual(response.status_code, 200)
self.assertEqual(response.content, 'OK')
# Cleanup
uploaded.delete()
