def remove_cached(self, typename):
import geonode.geoserver.helpers as helpers
try:
logger.warning("Clearing Layer Cache")
helpers._invalidate_geowebcache_layer(typename)
# the following line for compatiblilty 2.8rc11 and 2.8
try:
helpers._stylefilterparams_geowebcache_layer(typename)
except BaseException:
pass
logger.warning("Layer Cache Cleared")
except BaseException as e:
logger.error(e.message)
def geoserver_post_save_local(instance, *args, **kwargs):
"""Send information to geoserver.
The attributes sent include:
* Title
* Abstract
* Name
* Keywords
* Metadata Links,
* Point of Contact name and url
"""
instance.refresh_from_db()
# Don't run this signal if is a Layer from a remote service
if getattr(instance, "remote_service", None) is not None:
return
# Don't run this signal handler if it is a tile layer or a remote store (Service)
# Currently only gpkg files containing tiles will have this type & will be served via MapProxy.
if hasattr(instance, 'storeType') and getattr(instance, 'storeType') in ['tileStore', 'remoteStore']:
return instance
gs_resource = None
values = None
_tries = 0
_max_tries = getattr(ogc_server_settings, "MAX_RETRIES", 2)
# If the store in None then it's a new instance from an upload,
# only in this case run the geoserver_upload method
if not instance.store or getattr(instance, 'overwrite', False):
base_file, info = instance.get_base_file()
# There is no need to process it if there is not file.
if base_file is None:
return
gs_name, workspace, values, gs_resource = geoserver_upload(instance,
base_file.file.path,
instance.owner,
instance.name,
overwrite=True,
title=instance.title,
abstract=instance.abstract,
# keywords=instance.keywords,
charset=instance.charset)
def fetch_gs_resource(values, tries):
try:
gs_resource = gs_catalog.get_resource(
name=instance.name,
store=instance.store,
workspace=instance.workspace)
except Exception:
try:
gs_resource = gs_catalog.get_resource(
name=instance.alternate,
store=instance.store,
workspace=instance.workspace)
except Exception:
try:
gs_resource = gs_catalog.get_resource(
name=instance.alternate or instance.typename)
except Exception:
gs_resource = None
if gs_resource:
gs_resource.title = instance.title or ""
gs_resource.abstract = instance.abstract or ""
gs_resource.name = instance.name or ""
if not values:
values = dict(store=gs_resource.store.name,
storeType=gs_resource.store.resource_type,
alternate=gs_resource.store.workspace.name + ':' + gs_resource.name,
title=gs_resource.title or gs_resource.store.name,
abstract=gs_resource.abstract or '',
owner=instance.owner)
else:
msg = "There isn't a geoserver resource for this layer: %s" % instance.name
logger.exception(msg)
if tries >= _max_tries:
# raise GeoNodeException(msg)
return (values, None)
gs_resource = None
sleep(3.00)
return (values, gs_resource)
while not gs_resource and _tries < _max_tries:
values, gs_resource = fetch_gs_resource(values, _tries)
_tries += 1
# Get metadata links
metadata_links = []
for link in instance.link_set.metadata():
metadata_links.append((link.mime, link.name, link.url))
if gs_resource:
logger.debug("Found geoserver resource for this layer: %s" % instance.name)
gs_resource.metadata_links = metadata_links
# gs_resource should only be called if
# ogc_server_settings.BACKEND_WRITE_ENABLED == True
if getattr(ogc_server_settings, "BACKEND_WRITE_ENABLED", True):
try:
gs_catalog.save(gs_resource)
except geoserver.catalog.FailedRequestError as e:
msg = ('Error while trying to save resource named %s in GeoServer, '
'try to use: "%s"' % (gs_resource, str(e)))
e.args = (msg,)
logger.exception(e)
# Update Attribution link
if instance.poc:
# gsconfig now utilizes an attribution dictionary
gs_resource.attribution = {'title': str(instance.poc),
'width': None,
'height': None,
'href': None,
'url': None,
'type': None}
profile = get_user_model().objects.get(username=instance.poc.username)
site_url = settings.SITEURL.rstrip('/') if settings.SITEURL.startswith('http') else settings.SITEURL
gs_resource.attribution_link = site_url + profile.get_absolute_url()
# gs_resource should only be called if
# ogc_server_settings.BACKEND_WRITE_ENABLED == True
if getattr(ogc_server_settings, "BACKEND_WRITE_ENABLED", True):
try:
gs_catalog.save(gs_resource)
except geoserver.catalog.FailedRequestError as e:
msg = ('Error while trying to save layer named %s in GeoServer, '
'try to use: "%s"' % (gs_resource, str(e)))
e.args = (msg,)
logger.exception(e)
else:
msg = "There isn't a geoserver resource for this layer: %s" % instance.name
logger.warn(msg)
if isinstance(instance, ResourceBase):
if hasattr(instance, 'layer'):
instance = instance.layer
else:
return
# Save layer attributes
set_attributes_from_geoserver(instance)
# Save layer styles
set_styles(instance, gs_catalog)
# Invalidate GeoWebCache for the updated resource
try:
_stylefilterparams_geowebcache_layer(instance.alternate)
_invalidate_geowebcache_layer(instance.alternate)
except Exception:
pass
if instance.storeType == "remoteStore":
return
if gs_resource:
"""Get information from geoserver.
The attributes retrieved include:
* Bounding Box
* SRID
* Download links (WMS, WCS or WFS and KML)
* Styles (SLD)
"""
try:
instance.abstract = gs_resource.abstract or ''
except Exception as e:
logger.exception(e)
instance.abstract = ''
instance.workspace = gs_resource.store.workspace.name
instance.store = gs_resource.store.name
try:
bbox = gs_resource.native_bbox
# Set bounding box values
instance.bbox_x0 = bbox[0]
instance.bbox_x1 = bbox[1]
instance.bbox_y0 = bbox[2]
instance.bbox_y1 = bbox[3]
instance.srid = bbox[4]
except Exception as e:
logger.exception(e)
if instance.srid:
instance.srid_url = "http://www.spatialreference.org/ref/" + \
instance.srid.replace(':', '/').lower() + "/"
elif instance.bbox_x0 and instance.bbox_x1 and instance.bbox_y0 and instance.bbox_y1:
# Guessing 'EPSG:4326' by default
instance.srid = 'EPSG:4326'
else:
raise GeoNodeException("Invalid Projection. Layer is missing CRS!")
# Iterate over values from geoserver.
if gs_resource:
for key in ['alternate', 'store', 'storeType']:
# attr_name = key if 'typename' not in key else 'alternate'
# print attr_name
setattr(instance, key, values[key])
if gs_resource:
try:
if settings.RESOURCE_PUBLISHING:
if instance.is_published != gs_resource.advertised:
if getattr(ogc_server_settings, "BACKEND_WRITE_ENABLED", True):
gs_resource.advertised = 'true'
gs_catalog.save(gs_resource)
if not settings.FREETEXT_KEYWORDS_READONLY:
# AF: Warning - this won't allow people to have empty keywords on GeoNode
if len(instance.keyword_list()) == 0 and gs_resource.keywords:
for keyword in gs_resource.keywords:
if keyword not in instance.keyword_list():
instance.keywords.add(keyword)
if any(instance.keyword_list()):
keywords = instance.keyword_list()
gs_resource.keywords = [kw for kw in list(set(keywords))]
# gs_resource should only be called if
# ogc_server_settings.BACKEND_WRITE_ENABLED == True
if getattr(ogc_server_settings, "BACKEND_WRITE_ENABLED", True):
gs_catalog.save(gs_resource)
except Exception as e:
msg = ('Error while trying to save resource named %s in GeoServer, '
'try to use: "%s"' % (gs_resource, str(e)))
e.args = (msg,)
logger.exception(e)
to_update = {
'title': instance.title or instance.name,
'abstract': instance.abstract or "",
'alternate': instance.alternate,
'bbox_x0': instance.bbox_x0,
'bbox_x1': instance.bbox_x1,
'bbox_y0': instance.bbox_y0,
'bbox_y1': instance.bbox_y1,
'srid': instance.srid
}
# Update ResourceBase
resources = ResourceBase.objects.filter(id=instance.resourcebase_ptr.id)
resources.update(**to_update)
# to_update['name'] = instance.name,
to_update['workspace'] = instance.workspace
to_update['store'] = instance.store
to_update['storeType'] = instance.storeType
to_update['typename'] = instance.alternate
# Save all the modified information in the instance without triggering signals.
Layer.objects.filter(id=instance.id).update(**to_update)
# Refresh from DB
instance.refresh_from_db()
# Updating the Catalogue
catalogue_post_save(instance=instance, sender=instance.__class__)
# store the resource to avoid another geoserver call in the post_save
if gs_resource:
instance.gs_resource = gs_resource
# some thumbnail generators will update thumbnail_url. If so, don't
# immediately re-generate the thumbnail here. use layer#save(update_fields=['thumbnail_url'])
if gs_resource:
logger.debug("... Creating Default Resource Links for Layer [%s]" % (instance.alternate))
set_resource_default_links(instance, instance, prune=True)
if 'update_fields' in kwargs and kwargs['update_fields'] is not None and \
'thumbnail_url' in kwargs['update_fields']:
logger.debug("... Creating Thumbnail for Layer [%s]" % (instance.alternate))
create_gs_thumbnail(instance, overwrite=True)
# Updating HAYSTACK Indexes if needed
if settings.HAYSTACK_SEARCH:
from django.core.management import call_command
call_command('update_index')
def geoserver_post_save_local(instance, *args, **kwargs):
"""Send information to geoserver.
The attributes sent include:
* Title
* Abstract
* Name
* Keywords
* Metadata Links,
* Point of Contact name and url
"""
# Don't run this signal if is a Layer from a remote service
if getattr(instance, "remote_service", None) is not None:
return
# Don't run this signal handler if it is a tile layer or a remote store (Service)
# Currently only gpkg files containing tiles will have this type & will be served via MapProxy.
if hasattr(instance, 'storeType') and getattr(
instance, 'storeType') in ['tileStore', 'remoteStore']:
return instance
gs_resource = None
values = None
# If the store in None then it's a new instance from an upload,
# only in this case run the geoserver_upload method
if not instance.store or getattr(instance, 'overwrite', False):
base_file, info = instance.get_base_file()
# There is no need to process it if there is not file.
if base_file is None:
return
gs_name, workspace, values, gs_resource = geoserver_upload(
instance,
base_file.file.path,
instance.owner,
instance.name,
overwrite=True,
title=instance.title,
abstract=instance.abstract,
# keywords=instance.keywords,
charset=instance.charset)
if not gs_resource:
gs_resource = gs_catalog.get_resource(instance.name,
store=instance.store,
workspace=instance.workspace)
if not gs_resource:
gs_resource = gs_catalog.get_resource(instance.alternate)
if gs_resource:
gs_resource.title = instance.title or ""
gs_resource.abstract = instance.abstract or ""
gs_resource.name = instance.name or ""
if not values:
values = dict(store=gs_resource.store.name,
storeType=gs_resource.store.resource_type,
alternate=gs_resource.store.workspace.name + ':' +
gs_resource.name,
title=gs_resource.title or gs_resource.store.name,
abstract=gs_resource.abstract or '',
owner=instance.owner)
else:
msg = "There isn't a geoserver resource for this layer: %s" % instance.name
logger.exception(msg)
raise Exception(msg)
# Get metadata links
metadata_links = []
for link in instance.link_set.metadata():
metadata_links.append((link.mime, link.name, link.url))
gs_resource.metadata_links = metadata_links
# gs_resource should only be called if
# ogc_server_settings.BACKEND_WRITE_ENABLED == True
if getattr(ogc_server_settings, "BACKEND_WRITE_ENABLED", True):
try:
gs_catalog.save(gs_resource)
except geoserver.catalog.FailedRequestError as e:
msg = (
'Error while trying to save resource named %s in GeoServer, '
'try to use: "%s"' % (gs_resource, str(e)))
e.args = (msg, )
logger.exception(e)
# Update Attribution link
if instance.poc:
# gsconfig now utilizes an attribution dictionary
gs_resource.attribution = {
'title': str(instance.poc),
'width': None,
'height': None,
'href': None,
'url': None,
'type': None
}
profile = Profile.objects.get(username=instance.poc.username)
site_url = settings.SITEURL.rstrip('/') if settings.SITEURL.startswith(
'http') else settings.SITEURL
gs_resource.attribution_link = site_url + profile.get_absolute_url()
# gs_resource should only be called if
# ogc_server_settings.BACKEND_WRITE_ENABLED == True
if getattr(ogc_server_settings, "BACKEND_WRITE_ENABLED", True):
try:
gs_catalog.save(gs_resource)
except geoserver.catalog.FailedRequestError as e:
msg = (
'Error while trying to save layer named %s in GeoServer, '
'try to use: "%s"' % (gs_resource, str(e)))
e.args = (msg, )
logger.exception(e)
if isinstance(instance, ResourceBase):
if hasattr(instance, 'layer'):
instance = instance.layer
else:
return
# Save layer attributes
set_attributes_from_geoserver(instance)
# Save layer styles
set_styles(instance, gs_catalog)
# set SLD
sld = instance.default_style.sld_body if instance.default_style else None
if sld:
set_layer_style(instance, instance.alternate, sld)
# Invalidate GeoWebCache for the updated resource
try:
_stylefilterparams_geowebcache_layer(instance.alternate)
_invalidate_geowebcache_layer(instance.alternate)
except BaseException:
pass
if instance.storeType == "remoteStore":
# Save layer attributes
set_attributes_from_geoserver(instance)
return
"""Get information from geoserver.
The attributes retrieved include:
* Bounding Box
* SRID
* Download links (WMS, WCS or WFS and KML)
* Styles (SLD)
"""
# instance.name = instance.name or gs_resource.name
# instance.title = instance.title or gs_resource.title
instance.abstract = gs_resource.abstract or ''
instance.workspace = gs_resource.store.workspace.name
instance.store = gs_resource.store.name
bbox = gs_resource.native_bbox
# Set bounding box values
instance.bbox_x0 = bbox[0]
instance.bbox_x1 = bbox[1]
instance.bbox_y0 = bbox[2]
instance.bbox_y1 = bbox[3]
instance.srid = bbox[4]
if instance.srid:
instance.srid_url = "http://www.spatialreference.org/ref/" + \
instance.srid.replace(':', '/').lower() + "/"
else:
raise GeoNodeException("Invalid Projection. Layer is missing CRS!")
# Iterate over values from geoserver.
for key in ['alternate', 'store', 'storeType']:
# attr_name = key if 'typename' not in key else 'alternate'
# print attr_name
setattr(instance, key, values[key])
if settings.RESOURCE_PUBLISHING:
if instance.is_published != gs_resource.advertised:
if getattr(ogc_server_settings, "BACKEND_WRITE_ENABLED", True):
gs_resource.advertised = 'true' if instance.is_published else 'false'
gs_catalog.save(gs_resource)
if not settings.FREETEXT_KEYWORDS_READONLY:
if len(instance.keyword_list()) == 0 and gs_resource.keywords:
for keyword in gs_resource.keywords:
if keyword not in instance.keyword_list():
instance.keywords.add(keyword)
if any(instance.keyword_list()):
keywords = instance.keyword_list()
gs_resource.keywords = list(set(keywords))
# gs_resource should only be called if
# ogc_server_settings.BACKEND_WRITE_ENABLED == True
if getattr(ogc_server_settings, "BACKEND_WRITE_ENABLED", True):
try:
gs_catalog.save(gs_resource)
except geoserver.catalog.FailedRequestError as e:
msg = (
'Error while trying to save resource named %s in GeoServer, '
'try to use: "%s"' % (gs_resource, str(e)))
e.args = (msg, )
logger.exception(e)
to_update = {
'title': instance.title or instance.name,
'abstract': instance.abstract or "",
'alternate': instance.alternate,
'bbox_x0': instance.bbox_x0,
'bbox_x1': instance.bbox_x1,
'bbox_y0': instance.bbox_y0,
'bbox_y1': instance.bbox_y1,
'srid': instance.srid
}
# Update ResourceBase
resources = ResourceBase.objects.filter(id=instance.resourcebase_ptr.id)
resources.update(**to_update)
# to_update['name'] = instance.name,
to_update['workspace'] = instance.workspace
to_update['store'] = instance.store
to_update['storeType'] = instance.storeType
to_update['typename'] = instance.alternate
# Save all the modified information in the instance without triggering signals.
Layer.objects.filter(id=instance.id).update(**to_update)
# Refresh from DB
instance.refresh_from_db()
# store the resource to avoid another geoserver call in the post_save
instance.gs_resource = gs_resource
bbox = gs_resource.native_bbox
dx = float(bbox[1]) - float(bbox[0])
dy = float(bbox[3]) - float(bbox[2])
dataAspect = 1 if dy == 0 else dx / dy
height = 550
width = int(height * dataAspect)
# Parse Layer BBOX and SRID
srid = instance.srid if instance.srid else getattr(
settings, 'DEFAULT_MAP_CRS', 'EPSG:4326')
if srid and instance.bbox_x0:
bbox = ','.join(
str(x) for x in [
instance.bbox_x0, instance.bbox_y0, instance.bbox_x1,
instance.bbox_y1
])
# Create Raw Data download link
path = gs_resource.dom.findall('nativeName')
download_url = urljoin(settings.SITEURL,
reverse('download', args=[instance.id]))
Link.objects.get_or_create(resource=instance.resourcebase_ptr,
url=download_url,
defaults=dict(
extension='zip',
name='Original Dataset',
mime='application/octet-stream',
link_type='original',
))
# Set download links for WMS, WCS or WFS and KML
links = wms_links(ogc_server_settings.public_url + 'wms?',
instance.alternate.encode('utf-8'), bbox, srid, height,
width)
for ext, name, mime, wms_url in links:
Link.objects.get_or_create(resource=instance.resourcebase_ptr,
name=ugettext(name),
defaults=dict(
extension=ext,
url=wms_url,
mime=mime,
link_type='image',
))
if instance.storeType == "dataStore":
links = wfs_links(
ogc_server_settings.public_url + 'wfs?',
instance.alternate.encode('utf-8'),
bbox=
None, # bbox filter should be set at runtime otherwise conflicting with CQL
srid=srid)
for ext, name, mime, wfs_url in links:
if mime == 'SHAPE-ZIP':
name = 'Zipped Shapefile'
Link.objects.get_or_create(resource=instance.resourcebase_ptr,
url=wfs_url,
defaults=dict(
extension=ext,
name=name,
mime=mime,
url=wfs_url,
link_type='data',
))
gs_store_type = gs_resource.store.type.lower(
) if gs_resource.store.type else None
geogig_repository = gs_resource.store.connection_parameters.get(
'geogig_repository', '')
geogig_repo_name = geogig_repository.replace('geoserver://', '')
if gs_store_type == 'geogig' and geogig_repo_name:
repo_url = '{url}geogig/repos/{repo_name}'.format(
url=ogc_server_settings.public_url, repo_name=geogig_repo_name)
path = gs_resource.dom.findall('nativeName')
if path:
path = 'path={path}'.format(path=path[0].text)
Link.objects.get_or_create(resource=instance.resourcebase_ptr,
url=repo_url,
defaults=dict(extension='html',
name='Clone in GeoGig',
mime='text/xml',
link_type='html'))
def command_url(command):
return "{repo_url}/{command}.json?{path}".format(
repo_url=repo_url, path=path, command=command)
Link.objects.get_or_create(resource=instance.resourcebase_ptr,
url=command_url('log'),
defaults=dict(extension='json',
name='GeoGig log',
mime='application/json',
link_type='html'))
Link.objects.get_or_create(resource=instance.resourcebase_ptr,
url=command_url('statistics'),
defaults=dict(extension='json',
name='GeoGig statistics',
mime='application/json',
link_type='html'))
elif instance.storeType == 'coverageStore':
links = wcs_links(ogc_server_settings.public_url + 'wcs?',
instance.alternate.encode('utf-8'), bbox, srid)
for ext, name, mime, wcs_url in links:
Link.objects.get_or_create(resource=instance.resourcebase_ptr,
url=wcs_url,
defaults=dict(
extension=ext,
name=name,
mime=mime,
link_type='data',
))
kml_reflector_link_download = ogc_server_settings.public_url + "wms/kml?" + \
urllib.urlencode({'layers': instance.alternate.encode('utf-8'), 'mode': "download"})
Link.objects.get_or_create(resource=instance.resourcebase_ptr,
url=kml_reflector_link_download,
defaults=dict(
extension='kml',
name="KML",
mime='text/xml',
link_type='data',
))
kml_reflector_link_view = ogc_server_settings.public_url + "wms/kml?" + \
urllib.urlencode({'layers': instance.alternate.encode('utf-8'), 'mode': "refresh"})
Link.objects.get_or_create(resource=instance.resourcebase_ptr,
url=kml_reflector_link_view,
defaults=dict(
extension='kml',
name="View in Google Earth",
mime='text/xml',
link_type='data',
))
site_url = settings.SITEURL.rstrip('/') if settings.SITEURL.startswith(
'http') else settings.SITEURL
html_link_url = '%s%s' % (site_url, instance.get_absolute_url())
Link.objects.get_or_create(resource=instance.resourcebase_ptr,
url=html_link_url,
defaults=dict(
extension='html',
name=instance.alternate,
mime='text/html',
link_type='html',
))
# some thumbnail generators will update thumbnail_url. If so, don't
# immediately re-generate the thumbnail here. use layer#save(update_fields=['thumbnail_url'])
if not ('update_fields' in kwargs and kwargs['update_fields'] is not None
and 'thumbnail_url' in kwargs['update_fields']):
logger.info("... Creating Thumbnail for Layer [%s]" %
(instance.alternate))
create_gs_thumbnail(instance, overwrite=True)
legend_url = ogc_server_settings.PUBLIC_LOCATION + \
'wms?request=GetLegendGraphic&format=image/png&WIDTH=20&HEIGHT=20&LAYER=' + \
instance.alternate + '&legend_options=fontAntiAliasing:true;fontSize:12;forceLabels:on'
Link.objects.get_or_create(resource=instance.resourcebase_ptr,
url=legend_url,
defaults=dict(
extension='png',
name='Legend',
url=legend_url,
mime='image/png',
link_type='image',
))
# ogc_wms_path = '%s/ows' % instance.workspace
ogc_wms_path = 'ows'
ogc_wms_url = urljoin(ogc_server_settings.public_url, ogc_wms_path)
ogc_wms_name = 'OGC WMS: %s Service' % instance.workspace
Link.objects.get_or_create(resource=instance.resourcebase_ptr,
url=ogc_wms_url,
defaults=dict(
extension='html',
name=ogc_wms_name,
url=ogc_wms_url,
mime='text/html',
link_type='OGC:WMS',
))
if instance.storeType == "dataStore":
# ogc_wfs_path = '%s/wfs' % instance.workspace
ogc_wfs_path = 'wfs'
ogc_wfs_url = urljoin(ogc_server_settings.public_url, ogc_wfs_path)
ogc_wfs_name = 'OGC WFS: %s Service' % instance.workspace
Link.objects.get_or_create(resource=instance.resourcebase_ptr,
url=ogc_wfs_url,
defaults=dict(
extension='html',
name=ogc_wfs_name,
url=ogc_wfs_url,
mime='text/html',
link_type='OGC:WFS',
))
if instance.storeType == "coverageStore":
# ogc_wcs_path = '%s/wcs' % instance.workspace
ogc_wcs_path = 'wcs'
ogc_wcs_url = urljoin(ogc_server_settings.public_url, ogc_wcs_path)
ogc_wcs_name = 'OGC WCS: %s Service' % instance.workspace
Link.objects.get_or_create(resource=instance.resourcebase_ptr,
url=ogc_wcs_url,
defaults=dict(
extension='html',
name=ogc_wcs_name,
url=ogc_wcs_url,
mime='text/html',
link_type='OGC:WCS',
))
# remove links that belong to and old address
for link in instance.link_set.all():
if not urlparse(settings.SITEURL).hostname == urlparse(
link.url).hostname and not urlparse(
ogc_server_settings.public_url).hostname == urlparse(
link.url).hostname:
link.delete()
# Define the link after the cleanup, we should use this more rather then remove
# potential parasites
tile_url = ('%sgwc/service/gmaps?' % ogc_server_settings.public_url +
'layers=%s' % instance.alternate.encode('utf-8') +
'&zoom={z}&x={x}&y={y}' + '&format=image/png8')
link, created = Link.objects.get_or_create(
resource=instance.resourcebase_ptr,
extension='tiles',
name="Tiles",
mime='image/png',
link_type='image',
)
if created:
Link.objects.filter(pk=link.pk).update(url=tile_url)
# NOTTODO by simod: we should not do this!
# need to be removed when fixing #2015
catalogue_post_save(instance, Layer)
# Updating HAYSTACK Indexes if needed
if settings.HAYSTACK_SEARCH:
from django.core.management import call_command
call_command('update_index')
def layer_upload(request, template='upload/layer_upload.html'):
if request.method == 'GET':
mosaics = Layer.objects.filter(is_mosaic=True).order_by('name')
ctx = {
'mosaics': mosaics,
'charsets': CHARSETS,
'is_layer': True,
}
return render_to_response(template, RequestContext(request, ctx))
elif request.method == 'POST':
form = NewLayerUploadForm(request.POST, request.FILES)
tempdir = None
errormsgs = []
out = {'success': False}
if form.is_valid():
title = form.cleaned_data["layer_title"]
# Replace dots in filename - GeoServer REST API upload bug
# and avoid any other invalid characters.
# Use the title if possible, otherwise default to the filename
if title is not None and len(title) > 0:
name_base = title
else:
name_base, __ = os.path.splitext(
form.cleaned_data["base_file"].name)
title = slugify(name_base.replace(".", "_"))
name = slugify(name_base.replace(".", "_"))
if form.cleaned_data["abstract"] is not None and len(
form.cleaned_data["abstract"]) > 0:
abstract = form.cleaned_data["abstract"]
else:
abstract = "No abstract provided."
try:
# Moved this inside the try/except block because it can raise
# exceptions when unicode characters are present.
# This should be followed up in upstream Django.
tempdir, base_file = form.write_files()
if not form.cleaned_data["style_upload_form"]:
saved_layer = file_upload(
base_file,
name=name,
user=request.user,
overwrite=False,
charset=form.cleaned_data["charset"],
abstract=abstract,
title=title,
metadata_uploaded_preserve=form.
cleaned_data["metadata_uploaded_preserve"],
metadata_upload_form=form.
cleaned_data["metadata_upload_form"])
else:
saved_layer = Layer.objects.get(alternate=title)
if not saved_layer:
msg = 'Failed to process. Could not find matching layer.'
raise Exception(msg)
sld = open(base_file).read()
# Check SLD is valid
extract_name_from_sld(gs_catalog, sld, sld_file=base_file)
match = None
styles = list(saved_layer.styles.all()) + [
saved_layer.default_style
]
for style in styles:
if style and style.name == saved_layer.name:
match = style
break
cat = gs_catalog
layer = cat.get_layer(title)
if match is None:
try:
cat.create_style(saved_layer.name, sld, raw=True)
style = cat.get_style(saved_layer.name)
if layer and style:
layer.default_style = style
cat.save(layer)
saved_layer.default_style = save_style(style)
except Exception as e:
logger.exception(e)
else:
style = cat.get_style(saved_layer.name)
# style.update_body(sld)
try:
cat.create_style(saved_layer.name,
sld,
overwrite=True,
raw=True)
style = cat.get_style(saved_layer.name)
if layer and style:
layer.default_style = style
cat.save(layer)
saved_layer.default_style = save_style(style)
except Exception as e:
logger.exception(e)
# Invalidate GeoWebCache for the updated resource
_invalidate_geowebcache_layer(saved_layer.alternate)
except Exception as e:
exception_type, error, tb = sys.exc_info()
logger.exception(e)
out['success'] = False
out['errors'] = str(error)
# Assign the error message to the latest UploadSession from
# that user.
latest_uploads = UploadSession.objects.filter(
user=request.user).order_by('-date')
if latest_uploads.count() > 0:
upload_session = latest_uploads[0]
upload_session.error = str(error)
upload_session.traceback = traceback.format_exc(tb)
upload_session.context = log_snippet(CONTEXT_LOG_FILE)
upload_session.save()
out['traceback'] = upload_session.traceback
out['context'] = upload_session.context
out['upload_session'] = upload_session.id
else:
out['success'] = True
if hasattr(saved_layer, 'info'):
out['info'] = saved_layer.info
out['url'] = reverse('layer_detail',
args=[saved_layer.service_typename])
if hasattr(saved_layer, 'bbox_string'):
out['bbox'] = saved_layer.bbox_string
if hasattr(saved_layer, 'srid'):
out['crs'] = {
'type': 'name',
'properties': saved_layer.srid
}
out['ogc_backend'] = settings.OGC_SERVER['default']['BACKEND']
upload_session = saved_layer.upload_session
if upload_session:
upload_session.processed = True
upload_session.save()
permissions = form.cleaned_data["permissions"]
if permissions is not None and len(permissions.keys()) > 0:
saved_layer.set_permissions(permissions)
saved_layer.handle_moderated_uploads()
finally:
if tempdir is not None:
shutil.rmtree(tempdir)
else:
for e in form.errors.values():
errormsgs.extend([escape(v) for v in e])
out['errors'] = form.errors
out['errormsgs'] = errormsgs
if out['success']:
status_code = 200
else:
status_code = 400
if settings.MONITORING_ENABLED:
request.add_resource(
'layer', saved_layer.alternate if saved_layer else name)
return HttpResponse(json.dumps(out),
content_type='application/json',
status=status_code)
def layer_upload(request, template='upload/layer_upload.html'):
if request.method == 'GET':
mosaics = Layer.objects.filter(is_mosaic=True).order_by('name')
ctx = {
'mosaics': mosaics,
'charsets': CHARSETS,
'is_layer': True,
}
return render_to_response(template, RequestContext(request, ctx))
elif request.method == 'POST':
form = NewLayerUploadForm(request.POST, request.FILES)
tempdir = None
errormsgs = []
out = {'success': False}
if form.is_valid():
title = form.cleaned_data["layer_title"]
# Replace dots in filename - GeoServer REST API upload bug
# and avoid any other invalid characters.
# Use the title if possible, otherwise default to the filename
if title is not None and len(title) > 0:
name_base = title
else:
name_base, __ = os.path.splitext(
form.cleaned_data["base_file"].name)
title = slugify(name_base.replace(".", "_"))
name = slugify(name_base.replace(".", "_"))
if form.cleaned_data["abstract"] is not None and len(form.cleaned_data["abstract"]) > 0:
abstract = form.cleaned_data["abstract"]
else:
abstract = "No abstract provided."
try:
# Moved this inside the try/except block because it can raise
# exceptions when unicode characters are present.
# This should be followed up in upstream Django.
tempdir, base_file = form.write_files()
if not form.cleaned_data["style_upload_form"]:
saved_layer = file_upload(
base_file,
name=name,
user=request.user,
overwrite=False,
charset=form.cleaned_data["charset"],
abstract=abstract,
title=title,
metadata_uploaded_preserve=form.cleaned_data[
"metadata_uploaded_preserve"],
metadata_upload_form=form.cleaned_data["metadata_upload_form"])
else:
saved_layer = Layer.objects.get(alternate=title)
if not saved_layer:
msg = 'Failed to process. Could not find matching layer.'
raise Exception(msg)
sld = open(base_file).read()
# Check SLD is valid
extract_name_from_sld(gs_catalog, sld, sld_file=base_file)
match = None
styles = list(saved_layer.styles.all()) + [
saved_layer.default_style]
for style in styles:
if style and style.name == saved_layer.name:
match = style
break
cat = gs_catalog
layer = cat.get_layer(title)
if match is None:
try:
cat.create_style(saved_layer.name, sld, raw=True)
style = cat.get_style(saved_layer.name)
if layer and style:
layer.default_style = style
cat.save(layer)
saved_layer.default_style = save_style(style)
except Exception as e:
logger.exception(e)
else:
style = cat.get_style(saved_layer.name)
# style.update_body(sld)
try:
cat.create_style(saved_layer.name, sld, overwrite=True, raw=True)
style = cat.get_style(saved_layer.name)
if layer and style:
layer.default_style = style
cat.save(layer)
saved_layer.default_style = save_style(style)
except Exception as e:
logger.exception(e)
# Invalidate GeoWebCache for the updated resource
_invalidate_geowebcache_layer(saved_layer.alternate)
except Exception as e:
exception_type, error, tb = sys.exc_info()
logger.exception(e)
out['success'] = False
out['errors'] = str(error)
# Assign the error message to the latest UploadSession from
# that user.
latest_uploads = UploadSession.objects.filter(
user=request.user).order_by('-date')
if latest_uploads.count() > 0:
upload_session = latest_uploads[0]
upload_session.error = str(error)
upload_session.traceback = traceback.format_exc(tb)
upload_session.context = log_snippet(CONTEXT_LOG_FILE)
upload_session.save()
out['traceback'] = upload_session.traceback
out['context'] = upload_session.context
out['upload_session'] = upload_session.id
else:
out['success'] = True
if hasattr(saved_layer, 'info'):
out['info'] = saved_layer.info
out['url'] = reverse(
'layer_detail', args=[
saved_layer.service_typename])
if hasattr(saved_layer, 'bbox_string'):
out['bbox'] = saved_layer.bbox_string
if hasattr(saved_layer, 'srid'):
out['crs'] = {
'type': 'name',
'properties': saved_layer.srid
}
out['ogc_backend'] = settings.OGC_SERVER['default']['BACKEND']
upload_session = saved_layer.upload_session
if upload_session:
upload_session.processed = True
upload_session.save()
permissions = form.cleaned_data["permissions"]
if permissions is not None and len(permissions.keys()) > 0:
saved_layer.set_permissions(permissions)
saved_layer.handle_moderated_uploads()
finally:
if tempdir is not None:
shutil.rmtree(tempdir)
else:
for e in form.errors.values():
errormsgs.extend([escape(v) for v in e])
out['errors'] = form.errors
out['errormsgs'] = errormsgs
if out['success']:
status_code = 200
else:
status_code = 400
if settings.MONITORING_ENABLED:
request.add_resource('layer', saved_layer.alternate if saved_layer else name)
return HttpResponse(
json.dumps(out),
content_type='application/json',
status=status_code)
def geoserver_post_save_local(instance, *args, **kwargs):
"""Send information to geoserver.
The attributes sent include:
* Title
* Abstract
* Name
* Keywords
* Metadata Links,
* Point of Contact name and url
"""
# Don't run this signal if is a Layer from a remote service
if getattr(instance, "remote_service", None) is not None:
return
# Don't run this signal handler if it is a tile layer or a remote store (Service)
# Currently only gpkg files containing tiles will have this type & will be served via MapProxy.
if hasattr(instance, 'storeType') and getattr(instance, 'storeType') in ['tileStore', 'remoteStore']:
return instance
gs_resource = None
values = None
# If the store in None then it's a new instance from an upload,
# only in this case run the geoserver_upload method
if not instance.store or getattr(instance, 'overwrite', False):
base_file, info = instance.get_base_file()
# There is no need to process it if there is not file.
if base_file is None:
return
gs_name, workspace, values, gs_resource = geoserver_upload(instance,
base_file.file.path,
instance.owner,
instance.name,
overwrite=True,
title=instance.title,
abstract=instance.abstract,
# keywords=instance.keywords,
charset=instance.charset)
if not gs_resource:
gs_resource = gs_catalog.get_resource(
instance.name,
store=instance.store,
workspace=instance.workspace)
if not gs_resource:
gs_resource = gs_catalog.get_resource(instance.alternate)
if gs_resource:
gs_resource.title = instance.title or ""
gs_resource.abstract = instance.abstract or ""
gs_resource.name = instance.name or ""
if not values:
values = dict(store=gs_resource.store.name,
storeType=gs_resource.store.resource_type,
alternate=gs_resource.store.workspace.name + ':' + gs_resource.name,
title=gs_resource.title or gs_resource.store.name,
abstract=gs_resource.abstract or '',
owner=instance.owner)
else:
msg = "There isn't a geoserver resource for this layer: %s" % instance.name
logger.exception(msg)
raise Exception(msg)
# Get metadata links
metadata_links = []
for link in instance.link_set.metadata():
metadata_links.append((link.mime, link.name, link.url))
gs_resource.metadata_links = metadata_links
# gs_resource should only be called if
# ogc_server_settings.BACKEND_WRITE_ENABLED == True
if getattr(ogc_server_settings, "BACKEND_WRITE_ENABLED", True):
try:
gs_catalog.save(gs_resource)
except geoserver.catalog.FailedRequestError as e:
msg = ('Error while trying to save resource named %s in GeoServer, '
'try to use: "%s"' % (gs_resource, str(e)))
e.args = (msg,)
logger.exception(e)
# Update Attribution link
if instance.poc:
# gsconfig now utilizes an attribution dictionary
gs_resource.attribution = {'title': str(instance.poc),
'width': None,
'height': None,
'href': None,
'url': None,
'type': None}
profile = Profile.objects.get(username=instance.poc.username)
site_url = settings.SITEURL.rstrip('/') if settings.SITEURL.startswith('http') else settings.SITEURL
gs_resource.attribution_link = site_url + profile.get_absolute_url()
# gs_resource should only be called if
# ogc_server_settings.BACKEND_WRITE_ENABLED == True
if getattr(ogc_server_settings, "BACKEND_WRITE_ENABLED", True):
try:
gs_catalog.save(gs_resource)
except geoserver.catalog.FailedRequestError as e:
msg = ('Error while trying to save layer named %s in GeoServer, '
'try to use: "%s"' % (gs_resource, str(e)))
e.args = (msg,)
logger.exception(e)
if isinstance(instance, ResourceBase):
if hasattr(instance, 'layer'):
instance = instance.layer
else:
return
# Save layer attributes
set_attributes_from_geoserver(instance)
# Save layer styles
set_styles(instance, gs_catalog)
# set SLD
sld = instance.default_style.sld_body if instance.default_style else None
if sld:
set_layer_style(instance, instance.alternate, sld)
# Invalidate GeoWebCache for the updated resource
try:
_stylefilterparams_geowebcache_layer(instance.alternate)
_invalidate_geowebcache_layer(instance.alternate)
except BaseException:
pass
if instance.storeType == "remoteStore":
# Save layer attributes
set_attributes_from_geoserver(instance)
return
"""Get information from geoserver.
The attributes retrieved include:
* Bounding Box
* SRID
* Download links (WMS, WCS or WFS and KML)
* Styles (SLD)
"""
# instance.name = instance.name or gs_resource.name
# instance.title = instance.title or gs_resource.title
instance.abstract = gs_resource.abstract or ''
instance.workspace = gs_resource.store.workspace.name
instance.store = gs_resource.store.name
try:
bbox = gs_resource.native_bbox
# Set bounding box values
instance.bbox_x0 = bbox[0]
instance.bbox_x1 = bbox[1]
instance.bbox_y0 = bbox[2]
instance.bbox_y1 = bbox[3]
instance.srid = bbox[4]
except BaseException:
pass
if instance.srid:
instance.srid_url = "http://www.spatialreference.org/ref/" + \
instance.srid.replace(':', '/').lower() + "/"
else:
raise GeoNodeException("Invalid Projection. Layer is missing CRS!")
# Iterate over values from geoserver.
for key in ['alternate', 'store', 'storeType']:
# attr_name = key if 'typename' not in key else 'alternate'
# print attr_name
setattr(instance, key, values[key])
if settings.RESOURCE_PUBLISHING:
if instance.is_published != gs_resource.advertised:
if getattr(ogc_server_settings, "BACKEND_WRITE_ENABLED", True):
gs_resource.advertised = 'true' if instance.is_published else 'false'
gs_catalog.save(gs_resource)
if not settings.FREETEXT_KEYWORDS_READONLY:
try:
if len(instance.keyword_list()) == 0 and gs_resource.keywords:
for keyword in gs_resource.keywords:
if keyword not in instance.keyword_list():
instance.keywords.add(keyword)
except BaseException:
pass
if any(instance.keyword_list()):
keywords = instance.keyword_list()
gs_resource.keywords = [kw.decode("utf-8", "replace") for kw in list(set(keywords))]
# gs_resource should only be called if
# ogc_server_settings.BACKEND_WRITE_ENABLED == True
if getattr(ogc_server_settings, "BACKEND_WRITE_ENABLED", True):
try:
gs_catalog.save(gs_resource)
except geoserver.catalog.FailedRequestError as e:
msg = ('Error while trying to save resource named %s in GeoServer, '
'try to use: "%s"' % (gs_resource, str(e)))
e.args = (msg,)
logger.exception(e)
to_update = {
'title': instance.title or instance.name,
'abstract': instance.abstract or "",
'alternate': instance.alternate,
'bbox_x0': instance.bbox_x0,
'bbox_x1': instance.bbox_x1,
'bbox_y0': instance.bbox_y0,
'bbox_y1': instance.bbox_y1,
'srid': instance.srid
}
# Update ResourceBase
resources = ResourceBase.objects.filter(id=instance.resourcebase_ptr.id)
resources.update(**to_update)
# to_update['name'] = instance.name,
to_update['workspace'] = instance.workspace
to_update['store'] = instance.store
to_update['storeType'] = instance.storeType
to_update['typename'] = instance.alternate
# Save all the modified information in the instance without triggering signals.
Layer.objects.filter(id=instance.id).update(**to_update)
# Refresh from DB
instance.refresh_from_db()
# store the resource to avoid another geoserver call in the post_save
instance.gs_resource = gs_resource
try:
bbox = gs_resource.native_bbox
except BaseException:
bbox = instance.bbox
dx = float(bbox[1]) - float(bbox[0])
dy = float(bbox[3]) - float(bbox[2])
dataAspect = 1 if dy == 0 else dx / dy
height = 550
width = int(height * dataAspect)
# Parse Layer BBOX and SRID
srid = instance.srid if instance.srid else getattr(settings, 'DEFAULT_MAP_CRS', 'EPSG:4326')
if srid and instance.bbox_x0:
bbox = ','.join(str(x) for x in [instance.bbox_x0, instance.bbox_y0,
instance.bbox_x1, instance.bbox_y1])
# Create Raw Data download link
try:
path = gs_resource.dom.findall('nativeName')
except BaseException:
path = instance.alternate
download_url = urljoin(settings.SITEURL,
reverse('download', args=[instance.id]))
Link.objects.get_or_create(resource=instance.resourcebase_ptr,
url=download_url,
defaults=dict(extension='zip',
name='Original Dataset',
mime='application/octet-stream',
link_type='original',
)
)
# Set download links for WMS, WCS or WFS and KML
links = wms_links(ogc_server_settings.public_url + 'wms?',
instance.alternate.encode('utf-8'),
bbox,
srid,
height,
width)
for ext, name, mime, wms_url in links:
Link.objects.get_or_create(resource=instance.resourcebase_ptr,
name=ugettext(name),
defaults=dict(
extension=ext,
url=wms_url,
mime=mime,
link_type='image',
)
)
if instance.storeType == "dataStore":
links = wfs_links(ogc_server_settings.public_url + 'wfs?',
instance.alternate.encode('utf-8'),
bbox=None, # bbox filter should be set at runtime otherwise conflicting with CQL
srid=srid)
for ext, name, mime, wfs_url in links:
if mime == 'SHAPE-ZIP':
name = 'Zipped Shapefile'
Link.objects.get_or_create(resource=instance.resourcebase_ptr,
url=wfs_url,
defaults=dict(
extension=ext,
name=name,
mime=mime,
url=wfs_url,
link_type='data',
)
)
gs_store_type = gs_resource.store.type.lower() if gs_resource.store.type else None
geogig_repository = gs_resource.store.connection_parameters.get('geogig_repository', '')
geogig_repo_name = geogig_repository.replace('geoserver://', '')
if gs_store_type == 'geogig' and geogig_repo_name:
repo_url = '{url}geogig/repos/{repo_name}'.format(
url=ogc_server_settings.public_url,
repo_name=geogig_repo_name)
try:
path = gs_resource.dom.findall('nativeName')
except BaseException:
path = instance.alternate
if path:
path = 'path={path}'.format(path=path[0].text)
Link.objects.get_or_create(resource=instance.resourcebase_ptr,
url=repo_url,
defaults=dict(extension='html',
name='Clone in GeoGig',
mime='text/xml',
link_type='html'
)
)
def command_url(command):
return "{repo_url}/{command}.json?{path}".format(repo_url=repo_url,
path=path,
command=command)
Link.objects.get_or_create(resource=instance.resourcebase_ptr,
url=command_url('log'),
defaults=dict(extension='json',
name='GeoGig log',
mime='application/json',
link_type='html'
)
)
Link.objects.get_or_create(resource=instance.resourcebase_ptr,
url=command_url('statistics'),
defaults=dict(extension='json',
name='GeoGig statistics',
mime='application/json',
link_type='html'
)
)
elif instance.storeType == 'coverageStore':
links = wcs_links(ogc_server_settings.public_url + 'wcs?',
instance.alternate.encode('utf-8'),
bbox,
srid)
for ext, name, mime, wcs_url in links:
Link.objects.get_or_create(resource=instance.resourcebase_ptr,
url=wcs_url,
defaults=dict(
extension=ext,
name=name,
mime=mime,
link_type='data',
)
)
kml_reflector_link_download = ogc_server_settings.public_url + "wms/kml?" + \
urllib.urlencode({'layers': instance.alternate.encode('utf-8'), 'mode': "download"})
Link.objects.get_or_create(resource=instance.resourcebase_ptr,
url=kml_reflector_link_download,
defaults=dict(
extension='kml',
name="KML",
mime='text/xml',
link_type='data',
)
)
kml_reflector_link_view = ogc_server_settings.public_url + "wms/kml?" + \
urllib.urlencode({'layers': instance.alternate.encode('utf-8'), 'mode': "refresh"})
Link.objects.get_or_create(resource=instance.resourcebase_ptr,
url=kml_reflector_link_view,
defaults=dict(
extension='kml',
name="View in Google Earth",
mime='text/xml',
link_type='data',
)
)
site_url = settings.SITEURL.rstrip('/') if settings.SITEURL.startswith('http') else settings.SITEURL
html_link_url = '%s%s' % (
site_url, instance.get_absolute_url())
Link.objects.get_or_create(resource=instance.resourcebase_ptr,
url=html_link_url,
defaults=dict(
extension='html',
name=instance.alternate,
mime='text/html',
link_type='html',
)
)
# some thumbnail generators will update thumbnail_url. If so, don't
# immediately re-generate the thumbnail here. use layer#save(update_fields=['thumbnail_url'])
if 'update_fields' in kwargs and kwargs['update_fields'] is not None and \
'thumbnail_url' in kwargs['update_fields']:
logger.info("... Creating Thumbnail for Layer [%s]" % (instance.alternate))
create_gs_thumbnail(instance, overwrite=True)
try:
Link.objects.filter(resource=instance.resourcebase_ptr, name='Legend').delete()
except BaseException:
pass
for style in instance.styles.all():
legend_url = ogc_server_settings.PUBLIC_LOCATION + \
'wms?request=GetLegendGraphic&format=image/png&WIDTH=20&HEIGHT=20&LAYER=' + \
instance.alternate + '&STYLE=' + style.name + \
'&legend_options=fontAntiAliasing:true;fontSize:12;forceLabels:on'
Link.objects.get_or_create(resource=instance.resourcebase_ptr,
url=legend_url,
defaults=dict(
extension='png',
name='Legend',
url=legend_url,
mime='image/png',
link_type='image',
)
)
# ogc_wms_path = '%s/ows' % instance.workspace
ogc_wms_path = 'ows'
ogc_wms_url = urljoin(ogc_server_settings.public_url, ogc_wms_path)
ogc_wms_name = 'OGC WMS: %s Service' % instance.workspace
Link.objects.get_or_create(resource=instance.resourcebase_ptr,
url=ogc_wms_url,
defaults=dict(
extension='html',
name=ogc_wms_name,
url=ogc_wms_url,
mime='text/html',
link_type='OGC:WMS',
)
)
if instance.storeType == "dataStore":
# ogc_wfs_path = '%s/wfs' % instance.workspace
ogc_wfs_path = 'wfs'
ogc_wfs_url = urljoin(ogc_server_settings.public_url, ogc_wfs_path)
ogc_wfs_name = 'OGC WFS: %s Service' % instance.workspace
Link.objects.get_or_create(resource=instance.resourcebase_ptr,
url=ogc_wfs_url,
defaults=dict(
extension='html',
name=ogc_wfs_name,
url=ogc_wfs_url,
mime='text/html',
link_type='OGC:WFS',
)
)
if instance.storeType == "coverageStore":
# ogc_wcs_path = '%s/wcs' % instance.workspace
ogc_wcs_path = 'wcs'
ogc_wcs_url = urljoin(ogc_server_settings.public_url, ogc_wcs_path)
ogc_wcs_name = 'OGC WCS: %s Service' % instance.workspace
Link.objects.get_or_create(resource=instance.resourcebase_ptr,
url=ogc_wcs_url,
defaults=dict(
extension='html',
name=ogc_wcs_name,
url=ogc_wcs_url,
mime='text/html',
link_type='OGC:WCS',
)
)
# remove links that belong to and old address
for link in instance.link_set.all():
if not urlparse(
settings.SITEURL).hostname == urlparse(
link.url).hostname and not urlparse(
ogc_server_settings.public_url).hostname == urlparse(
link.url).hostname:
link.delete()
# Define the link after the cleanup, we should use this more rather then remove
# potential parasites
tile_url = ('%sgwc/service/gmaps?' % ogc_server_settings.public_url +
'layers=%s' % instance.alternate.encode('utf-8') +
'&zoom={z}&x={x}&y={y}' +
'&format=image/png8'
)
link, created = Link.objects.get_or_create(resource=instance.resourcebase_ptr,
extension='tiles',
name="Tiles",
mime='image/png',
link_type='image',
)
if created:
Link.objects.filter(pk=link.pk).update(url=tile_url)
# NOTTODO by simod: we should not do this!
# need to be removed when fixing #2015
catalogue_post_save(instance, Layer)
# Updating HAYSTACK Indexes if needed
if settings.HAYSTACK_SEARCH:
from django.core.management import call_command
call_command('update_index')
def geoserver_post_save_local(instance, *args, **kwargs):
"""Send information to geoserver.
The attributes sent include:
* Title
* Abstract
* Name
* Keywords
* Metadata Links,
* Point of Contact name and url
"""
# Don't run this signal if is a Layer from a remote service
if getattr(instance, "remote_service", None) is not None:
return
# Don't run this signal handler if it is a tile layer or a remote store (Service)
# Currently only gpkg files containing tiles will have this type & will be served via MapProxy.
if hasattr(instance, 'storeType') and getattr(instance, 'storeType') in ['tileStore', 'remoteStore']:
return instance
gs_resource = None
values = None
# If the store in None then it's a new instance from an upload,
# only in this case run the geoserver_upload method
if not instance.store or getattr(instance, 'overwrite', False):
base_file, info = instance.get_base_file()
# There is no need to process it if there is not file.
if base_file is None:
return
gs_name, workspace, values, gs_resource = geoserver_upload(instance,
base_file.file.path,
instance.owner,
instance.name,
overwrite=True,
title=instance.title,
abstract=instance.abstract,
# keywords=instance.keywords,
charset=instance.charset)
if not gs_resource:
gs_resource = gs_catalog.get_resource(
instance.name,
store=instance.store,
workspace=instance.workspace)
if not gs_resource:
gs_resource = gs_catalog.get_resource(instance.alternate)
if gs_resource:
gs_resource.title = instance.title or ""
gs_resource.abstract = instance.abstract or ""
gs_resource.name = instance.name or ""
if not values:
values = dict(store=gs_resource.store.name,
storeType=gs_resource.store.resource_type,
alternate=gs_resource.store.workspace.name + ':' + gs_resource.name,
title=gs_resource.title or gs_resource.store.name,
abstract=gs_resource.abstract or '',
owner=instance.owner)
else:
msg = "There isn't a geoserver resource for this layer: %s" % instance.name
logger.exception(msg)
raise Exception(msg)
# Get metadata links
metadata_links = []
for link in instance.link_set.metadata():
metadata_links.append((link.mime, link.name, link.url))
gs_resource.metadata_links = metadata_links
# gs_resource should only be called if
# ogc_server_settings.BACKEND_WRITE_ENABLED == True
if getattr(ogc_server_settings, "BACKEND_WRITE_ENABLED", True):
try:
gs_catalog.save(gs_resource)
except geoserver.catalog.FailedRequestError as e:
msg = ('Error while trying to save resource named %s in GeoServer, '
'try to use: "%s"' % (gs_resource, str(e)))
e.args = (msg,)
logger.exception(e)
# Update Attribution link
if instance.poc:
# gsconfig now utilizes an attribution dictionary
gs_resource.attribution = {'title': str(instance.poc),
'width': None,
'height': None,
'href': None,
'url': None,
'type': None}
profile = Profile.objects.get(username=instance.poc.username)
site_url = settings.SITEURL.rstrip('/') if settings.SITEURL.startswith('http') else settings.SITEURL
gs_resource.attribution_link = site_url + profile.get_absolute_url()
# gs_resource should only be called if
# ogc_server_settings.BACKEND_WRITE_ENABLED == True
if getattr(ogc_server_settings, "BACKEND_WRITE_ENABLED", True):
try:
gs_catalog.save(gs_resource)
except geoserver.catalog.FailedRequestError as e:
msg = ('Error while trying to save layer named %s in GeoServer, '
'try to use: "%s"' % (gs_resource, str(e)))
e.args = (msg,)
logger.exception(e)
if isinstance(instance, ResourceBase):
if hasattr(instance, 'layer'):
instance = instance.layer
else:
return
# Save layer attributes
set_attributes_from_geoserver(instance)
# Save layer styles
set_styles(instance, gs_catalog)
# set SLD
sld = instance.default_style.sld_body if instance.default_style else None
if sld:
set_layer_style(instance, instance.alternate, sld)
# Invalidate GeoWebCache for the updated resource
try:
_stylefilterparams_geowebcache_layer(instance.alternate)
_invalidate_geowebcache_layer(instance.alternate)
except BaseException:
pass
if instance.storeType == "remoteStore":
# Save layer attributes
set_attributes_from_geoserver(instance)
return
"""Get information from geoserver.
The attributes retrieved include:
* Bounding Box
* SRID
* Download links (WMS, WCS or WFS and KML)
* Styles (SLD)
"""
# instance.name = instance.name or gs_resource.name
# instance.title = instance.title or gs_resource.title
instance.abstract = gs_resource.abstract or ''
instance.workspace = gs_resource.store.workspace.name
instance.store = gs_resource.store.name
try:
logger.debug(" -------------------------------------------------- ")
bbox = gs_resource.native_bbox
logger.debug(bbox)
logger.debug(" -------------------------------------------------- ")
# Set bounding box values
instance.bbox_x0 = bbox[0]
instance.bbox_x1 = bbox[1]
instance.bbox_y0 = bbox[2]
instance.bbox_y1 = bbox[3]
instance.srid = bbox[4]
except BaseException:
pass
if instance.srid:
instance.srid_url = "http://www.spatialreference.org/ref/" + \
instance.srid.replace(':', '/').lower() + "/"
elif instance.bbox_x0 and instance.bbox_x1 and instance.bbox_y0 and instance.bbox_y1:
# Guessing 'EPSG:4326' by default
instance.srid = 'EPSG:4326'
else:
raise GeoNodeException("Invalid Projection. Layer is missing CRS!")
# Iterate over values from geoserver.
for key in ['alternate', 'store', 'storeType']:
# attr_name = key if 'typename' not in key else 'alternate'
# print attr_name
setattr(instance, key, values[key])
if settings.RESOURCE_PUBLISHING:
if instance.is_published != gs_resource.advertised:
if getattr(ogc_server_settings, "BACKEND_WRITE_ENABLED", True):
gs_resource.advertised = 'true'
gs_catalog.save(gs_resource)
if not settings.FREETEXT_KEYWORDS_READONLY:
try:
if len(instance.keyword_list()) == 0 and gs_resource.keywords:
for keyword in gs_resource.keywords:
if keyword not in instance.keyword_list():
instance.keywords.add(keyword)
except BaseException:
pass
if any(instance.keyword_list()):
keywords = instance.keyword_list()
gs_resource.keywords = [kw for kw in list(set(keywords))]
# gs_resource should only be called if
# ogc_server_settings.BACKEND_WRITE_ENABLED == True
if getattr(ogc_server_settings, "BACKEND_WRITE_ENABLED", True):
try:
gs_catalog.save(gs_resource)
except geoserver.catalog.FailedRequestError as e:
msg = ('Error while trying to save resource named %s in GeoServer, '
'try to use: "%s"' % (gs_resource, str(e)))
e.args = (msg,)
logger.exception(e)
to_update = {
'title': instance.title or instance.name,
'abstract': instance.abstract or "",
'alternate': instance.alternate,
'bbox_x0': instance.bbox_x0,
'bbox_x1': instance.bbox_x1,
'bbox_y0': instance.bbox_y0,
'bbox_y1': instance.bbox_y1,
'srid': instance.srid
}
# Update ResourceBase
resources = ResourceBase.objects.filter(id=instance.resourcebase_ptr.id)
resources.update(**to_update)
# to_update['name'] = instance.name,
to_update['workspace'] = instance.workspace
to_update['store'] = instance.store
to_update['storeType'] = instance.storeType
to_update['typename'] = instance.alternate
# Save all the modified information in the instance without triggering signals.
Layer.objects.filter(id=instance.id).update(**to_update)
# Refresh from DB
instance.refresh_from_db()
# store the resource to avoid another geoserver call in the post_save
instance.gs_resource = gs_resource
# Refresh and create the instance default links
layer = Layer.objects.get(id=instance.id)
set_resource_default_links(instance, layer, prune=True)
# some thumbnail generators will update thumbnail_url. If so, don't
# immediately re-generate the thumbnail here. use layer#save(update_fields=['thumbnail_url'])
if 'update_fields' in kwargs and kwargs['update_fields'] is not None and \
'thumbnail_url' in kwargs['update_fields']:
logger.info("... Creating Thumbnail for Layer [%s]" % (instance.alternate))
create_gs_thumbnail(instance, overwrite=True)
# NOTTODO by simod: we should not do this!
# need to be removed when fixing #2015
catalogue_post_save(instance, Layer)
# Updating HAYSTACK Indexes if needed
if settings.HAYSTACK_SEARCH:
from django.core.management import call_command
call_command('update_index')
