def set_default_style(layer, style):
# Save to GeoServer
cat = gs_catalog
gs_layer = cat.get_layer(layer.name)
gs_layer.default_style = style.name
styles = [style.name]
gs_layer.styles = styles
cat.save(gs_layer)
# Save to Django
layer = set_styles(layer, cat)
def save_style(request, layer_name, style_name):
layer = _resolve_layer(
request,
layer_name,
'layers.change_layer_style',
_PERMISSION_MSG_MODIFY)
workspace_name = layer_name.split(":")[0]
# get style of geoserver
style_func = repeat_every()(gs_catalog.get_style)
style = style_func(style_name, workspace_name)
# check if new style
new = style is None
xml = request.body
gs_catalog.create_style(style_name, xml, True, workspace=layer_name.split(":")[0])
if new:
gs_layer = gs_catalog.get_layer(layer_name)
style_func = repeat_every()(gs_catalog.get_style)
style = style_func(style_name, workspace_name)
gs_layer.styles += [style, ]
gs_catalog.save(gs_layer)
set_styles(layer, gs_catalog)
return JsonResponse({"success": True}, status=200)
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()
#Save layer attributes
set_attributes(instance)
#Save layer styles
set_styles(instance, gs_catalog)
def geoserver_pre_save_maplayer(instance, sender, **kwargs):
# If this object was saved via fixtures,
# do not do post processing.
if kwargs.get('raw', False):
return
try:
instance.local = isinstance(gs_catalog.get_layer(instance.name),
GsLayer)
except EnvironmentError, e:
if e.errno == errno.ECONNREFUSED:
msg = 'Could not connect to catalog to verify if layer %s was local' % instance.name
logger.warn(msg, e)
def geoserver_post_save(instance, sender, **kwargs):
"""Save keywords to GeoServer
The way keywords are implemented requires the layer
to be saved to the database before accessing them.
"""
if type(instance) is ResourceBase:
if hasattr(instance, 'layer'):
instance = instance.layer
else:
return
if instance.storeType == "remoteStore":
# Save layer attributes
set_attributes(instance)
return
if not getattr(instance, 'gs_resource', None):
try:
gs_resource = gs_catalog.get_resource(
instance.name,
store=instance.store,
workspace=instance.workspace)
except socket_error as serr:
if serr.errno != errno.ECONNREFUSED:
# Not the error we are looking for, re-raise
raise serr
# If the connection is refused, take it easy.
return
else:
gs_resource = instance.gs_resource
if gs_resource is None:
return
if settings.RESOURCE_PUBLISHING:
if instance.is_published != gs_resource.advertised:
if getattr(ogc_server_settings, "BACKEND_WRITE_ENABLED", True):
gs_resource.advertised = instance.is_published
gs_catalog.save(gs_resource)
if any(instance.keyword_list()):
gs_resource.keywords = instance.keyword_list()
# 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)
bbox = gs_resource.latlon_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)
# Set download links for WMS, WCS or WFS and KML
links = wms_links(ogc_server_settings.public_url + 'wms?',
instance.typename.encode('utf-8'), instance.bbox_string,
instance.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.typename.encode('utf-8'))
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',
)
)
if gs_resource.store.type and gs_resource.store.type.lower() == 'geogig' and \
gs_resource.store.connection_parameters.get('geogig_repository'):
repo_url = '{url}geogig/{geogig_repository}'.format(
url=ogc_server_settings.public_url,
geogig_repository=gs_resource.store.connection_parameters.get('geogig_repository'))
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.typename.encode('utf-8'))
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.typename.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.typename.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',
)
)
tile_url = ('%sgwc/service/gmaps?' % ogc_server_settings.public_url +
'layers=%s' % instance.typename.encode('utf-8') +
'&zoom={z}&x={x}&y={y}' +
'&format=image/png8'
)
Link.objects.get_or_create(resource=instance.resourcebase_ptr,
url=tile_url,
defaults=dict(
extension='tiles',
name="Tiles",
mime='image/png',
link_type='image',
)
)
html_link_url = '%s%s' % (
settings.SITEURL[:-1], instance.get_absolute_url())
Link.objects.get_or_create(resource=instance.resourcebase_ptr,
url=html_link_url,
defaults=dict(
extension='html',
name=instance.typename,
mime='text/html',
link_type='html',
)
)
params = {
'layers': instance.typename.encode('utf-8'),
'format': 'image/png8',
'width': 200,
'height': 150,
'TIME': '-99999999999-01-01T00:00:00.0Z/99999999999-01-01T00:00:00.0Z'
}
# Avoid using urllib.urlencode here because it breaks the url.
# commas and slashes in values get encoded and then cause trouble
# with the WMS parser.
p = "&".join("%s=%s" % item for item in params.items())
thumbnail_remote_url = ogc_server_settings.PUBLIC_LOCATION + \
"wms/reflect?" + p
thumbnail_create_url = ogc_server_settings.LOCATION + \
"wms/reflect?" + p
create_thumbnail(instance, thumbnail_remote_url, thumbnail_create_url, ogc_client=http_client)
legend_url = ogc_server_settings.PUBLIC_LOCATION + \
'wms?request=GetLegendGraphic&format=image/png&WIDTH=20&HEIGHT=20&LAYER=' + \
instance.typename + '&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/wms' % instance.workspace
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_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_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()
# Save layer attributes
set_attributes(instance)
# Save layer styles
set_styles(instance, gs_catalog)
# NOTTODO by simod: we should not do this!
# need to be removed when fixing #2015
from geonode.catalogue.models import catalogue_post_save
from geonode.layers.models import Layer
catalogue_post_save(instance, Layer)
def geoserver_post_save(instance, sender, **kwargs):
"""Save keywords to GeoServer
The way keywords are implemented requires the layer
to be saved to the database before accessing them.
"""
if type(instance) is ResourceBase:
if hasattr(instance, 'layer'):
instance = instance.layer
else:
return
if instance.storeType == "remoteStore":
# Save layer attributes
set_attributes(instance)
return
try:
gs_resource = gs_catalog.get_resource(instance.name,
store=instance.store,
workspace=instance.workspace)
except socket_error as serr:
if serr.errno != errno.ECONNREFUSED:
# Not the error we are looking for, re-raise
raise serr
# If the connection is refused, take it easy.
return
if gs_resource is None:
return
if settings.RESOURCE_PUBLISHING:
if instance.is_published != gs_resource.advertised:
if getattr(ogc_server_settings, "BACKEND_WRITE_ENABLED", True):
gs_resource.advertised = instance.is_published
gs_catalog.save(gs_resource)
if any(instance.keyword_list()):
gs_resource.keywords = instance.keyword_list()
# 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)
bbox = gs_resource.latlon_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)
# Set download links for WMS, WCS or WFS and KML
links = wms_links(ogc_server_settings.public_url + 'wms?',
instance.typename.encode('utf-8'), instance.bbox_string,
instance.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.typename.encode('utf-8'))
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',
))
if gs_resource.store.type and gs_resource.store.type.lower() == 'geogig' and \
gs_resource.store.connection_parameters.get('geogig_repository'):
repo_url = '{url}geogig/{geogig_repository}'.format(
url=ogc_server_settings.public_url,
geogig_repository=gs_resource.store.connection_parameters.get(
'geogig_repository'))
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'))
command_url = lambda command: "{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':
# FIXME(Ariel): This works for public layers, does it work for restricted too?
# would those end up with no geotiff links, like, forever?
permissions = instance.get_all_level_info()
instance.set_permissions(
{'users': {
'AnonymousUser': ['view_resourcebase']
}})
try:
# Potentially 3 dimensions can be returned by the grid if there is a z
# axis. Since we only want width/height, slice to the second
# dimension
covWidth, covHeight = get_coverage_grid_extent(instance)[:2]
except GeoNodeException as e:
msg = _('Could not create a download link for layer.')
logger.warn(msg, e)
else:
links = wcs_links(ogc_server_settings.public_url + 'wcs?',
instance.typename.encode('utf-8'),
bbox=gs_resource.native_bbox[:-1],
crs=gs_resource.native_bbox[-1],
height=str(covHeight),
width=str(covWidth))
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',
))
instance.set_permissions(permissions)
kml_reflector_link_download = ogc_server_settings.public_url + "wms/kml?" + \
urllib.urlencode({'layers': instance.typename.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.typename.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',
))
tile_url = ('%sgwc/service/gmaps?' % ogc_server_settings.public_url +
'layers=%s' % instance.typename.encode('utf-8') +
'&zoom={z}&x={x}&y={y}' + '&format=image/png8')
Link.objects.get_or_create(resource=instance.resourcebase_ptr,
url=tile_url,
defaults=dict(
extension='tiles',
name=_("Tiles"),
mime='image/png',
link_type='image',
))
html_link_url = '%s%s' % (settings.SITEURL[:-1],
instance.get_absolute_url())
Link.objects.get_or_create(resource=instance.resourcebase_ptr,
url=html_link_url,
defaults=dict(
extension='html',
name=instance.typename,
mime='text/html',
link_type='html',
))
params = {
'layers': instance.typename.encode('utf-8'),
'format': 'image/png8',
'width': 200,
'height': 150,
}
# Avoid using urllib.urlencode here because it breaks the url.
# commas and slashes in values get encoded and then cause trouble
# with the WMS parser.
p = "&".join("%s=%s" % item for item in params.items())
thumbnail_remote_url = ogc_server_settings.PUBLIC_LOCATION + \
"wms/reflect?" + p
thumbnail_create_url = ogc_server_settings.LOCATION + \
"wms/reflect?" + p
create_thumbnail(instance,
thumbnail_remote_url,
thumbnail_create_url,
ogc_client=http_client)
legend_url = ogc_server_settings.PUBLIC_LOCATION + \
'wms?request=GetLegendGraphic&format=image/png&WIDTH=20&HEIGHT=20&LAYER=' + \
instance.typename + '&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/wms' % instance.workspace
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_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_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()
# Save layer attributes
set_attributes(instance)
# Save layer styles
set_styles(instance, gs_catalog)
def geoserver_post_save(instance, sender, **kwargs):
"""Save keywords to GeoServer
The way keywords are implemented requires the layer
to be saved to the database before accessing them.
"""
url = ogc_server_settings.internal_rest
try:
gs_resource= gs_catalog.get_resource(instance.name)
except socket_error as serr:
if serr.errno != errno.ECONNREFUSED:
# Not the error we are looking for, re-raise
raise serr
# If the connection is refused, take it easy.
return
if any(instance.keyword_list()):
gs_resource.keywords = instance.keyword_list()
#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)
bbox = gs_resource.latlon_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)
# Set download links for WMS, WCS or WFS and KML
links = wms_links(ogc_server_settings.public_url + 'wms?',
instance.typename.encode('utf-8'), instance.bbox_string,
instance.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.typename.encode('utf-8'))
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',
)
)
elif instance.storeType == 'coverageStore':
#FIXME(Ariel): This works for public layers, does it work for restricted too?
# would those end up with no geotiff links, like, forever?
permissions = {}
permissions['anonymous'] = instance.get_gen_level(ANONYMOUS_USERS)
permissions['authenticated'] = instance.get_gen_level(AUTHENTICATED_USERS)
instance.set_gen_level(ANONYMOUS_USERS,'layer_readonly')
#Potentially 3 dimensions can be returned by the grid if there is a z
#axis. Since we only want width/height, slice to the second dimension
covWidth, covHeight = get_coverage_grid_extent(instance)[:2]
links = wcs_links(ogc_server_settings.public_url + 'wcs?', instance.typename.encode('utf-8'),
bbox=gs_resource.native_bbox[:-1],
crs=gs_resource.native_bbox[-1],
height=str(covHeight), width=str(covWidth))
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',
)
)
instance.set_gen_level(ANONYMOUS_USERS,permissions['anonymous'])
instance.set_gen_level(AUTHENTICATED_USERS,permissions['authenticated'])
kml_reflector_link_download = ogc_server_settings.public_url + "wms/kml?" + urllib.urlencode({
'layers': instance.typename.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.typename.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',
)
)
tile_url = ('%sgwc/service/gmaps?' % ogc_server_settings.public_url +
'layers=%s' % instance.typename.encode('utf-8') +
'&zoom={z}&x={x}&y={y}' +
'&format=image/png8'
)
Link.objects.get_or_create(resource= instance.resourcebase_ptr,
url=tile_url,
defaults=dict(
extension='tiles',
name=_("Tiles"),
mime='image/png',
link_type='image',
)
)
wms_path = '%s/%s/wms' % (instance.workspace, instance.name)
ows_url = urljoin(ogc_server_settings.public_url, wms_path)
Link.objects.get_or_create(resource= instance.resourcebase_ptr,
url=ows_url,
defaults=dict(
extension='html',
name=_("OWS"),
url=ows_url,
mime='text/html',
link_type='OGC:WMS',
)
)
html_link_url = '%s%s' % (settings.SITEURL[:-1], instance.get_absolute_url())
Link.objects.get_or_create(resource= instance.resourcebase_ptr,
url=html_link_url,
defaults=dict(
extension='html',
name=instance.typename,
mime='text/html',
link_type='html',
)
)
params = {
'layers': instance.typename.encode('utf-8'),
'format': 'image/png8',
'width': 200,
'height': 150,
}
# Avoid using urllib.urlencode here because it breaks the url.
# commas and slashes in values get encoded and then cause trouble
# with the WMS parser.
p = "&".join("%s=%s"%item for item in params.items())
thumbnail_remote_url = ogc_server_settings.PUBLIC_LOCATION + "wms/reflect?" + p
create_thumbnail(instance, thumbnail_remote_url)
legend_url = ogc_server_settings.PUBLIC_LOCATION +'wms?request=GetLegendGraphic&format=image/png&WIDTH=20&HEIGHT=20&LAYER='+instance.typename+'&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_url = ogc_server_settings.public_url + 'wms?'
Link.objects.get_or_create(resource= instance.resourcebase_ptr,
url=ogc_wms_url,
defaults=dict(
extension='html',
name=instance.name,
url=ogc_wms_url,
mime='text/html',
link_type='OGC:WMS',
)
)
if instance.storeType == "dataStore":
ogc_wfs_url = ogc_server_settings.public_url + 'wfs?'
Link.objects.get_or_create(resource= instance.resourcebase_ptr,
url=ogc_wfs_url,
defaults=dict(
extension='html',
name=instance.name,
url=ogc_wfs_url,
mime='text/html',
link_type='OGC:WFS',
)
)
if instance.storeType == "coverageStore":
ogc_wcs_url = ogc_server_settings.public_url + 'wcs?'
Link.objects.get_or_create(resource= instance.resourcebase_ptr,
url=ogc_wcs_url,
defaults=dict(
extension='html',
name=instance.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()
#Save layer attributes
set_attributes(instance)
#Save layer styles
set_styles(instance, gs_catalog)
def geoserver_post_save(instance, sender, **kwargs):
"""Save keywords to GeoServer
The way keywords are implemented requires the layer
to be saved to the database before accessing them.
"""
url = ogc_server_settings.internal_rest
try:
gs_resource = gs_catalog.get_resource(instance.name)
except socket_error as serr:
if serr.errno != errno.ECONNREFUSED:
# Not the error we are looking for, re-raise
raise serr
# If the connection is refused, take it easy.
return
if any(instance.keyword_list()):
gs_resource.keywords = instance.keyword_list()
#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)
bbox = gs_resource.latlon_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)
# Set download links for WMS, WCS or WFS and KML
links = wms_links(ogc_server_settings.public_url + 'wms?',
instance.typename.encode('utf-8'), instance.bbox_string,
instance.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.typename.encode('utf-8'))
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',
))
elif instance.storeType == 'coverageStore':
#FIXME(Ariel): This works for public layers, does it work for restricted too?
# would those end up with no geotiff links, like, forever?
permissions = {}
permissions['anonymous'] = instance.get_gen_level(ANONYMOUS_USERS)
permissions['authenticated'] = instance.get_gen_level(
AUTHENTICATED_USERS)
instance.set_gen_level(ANONYMOUS_USERS, 'layer_readonly')
#Potentially 3 dimensions can be returned by the grid if there is a z
#axis. Since we only want width/height, slice to the second dimension
covWidth, covHeight = get_coverage_grid_extent(instance)[:2]
links = wcs_links(ogc_server_settings.public_url + 'wcs?',
instance.typename.encode('utf-8'),
bbox=gs_resource.native_bbox[:-1],
crs=gs_resource.native_bbox[-1],
height=str(covHeight),
width=str(covWidth))
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',
))
instance.set_gen_level(ANONYMOUS_USERS, permissions['anonymous'])
instance.set_gen_level(AUTHENTICATED_USERS,
permissions['authenticated'])
kml_reflector_link_download = ogc_server_settings.public_url + "wms/kml?" + urllib.urlencode(
{
'layers': instance.typename.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.typename.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',
))
tile_url = ('%sgwc/service/gmaps?' % ogc_server_settings.public_url +
'layers=%s' % instance.typename.encode('utf-8') +
'&zoom={z}&x={x}&y={y}' + '&format=image/png8')
Link.objects.get_or_create(resource=instance.resourcebase_ptr,
url=tile_url,
defaults=dict(
extension='tiles',
name=_("Tiles"),
mime='image/png',
link_type='image',
))
wms_path = '%s/%s/wms' % (instance.workspace, instance.name)
ows_url = urljoin(ogc_server_settings.public_url, wms_path)
Link.objects.get_or_create(resource=instance.resourcebase_ptr,
url=ows_url,
defaults=dict(
extension='html',
name=_("OWS"),
url=ows_url,
mime='text/html',
link_type='OGC:WMS',
))
html_link_url = '%s%s' % (settings.SITEURL[:-1],
instance.get_absolute_url())
Link.objects.get_or_create(resource=instance.resourcebase_ptr,
url=html_link_url,
defaults=dict(
extension='html',
name=instance.typename,
mime='text/html',
link_type='html',
))
params = {
'layers': instance.typename.encode('utf-8'),
'format': 'image/png8',
'width': 200,
'height': 150,
}
# Avoid using urllib.urlencode here because it breaks the url.
# commas and slashes in values get encoded and then cause trouble
# with the WMS parser.
p = "&".join("%s=%s" % item for item in params.items())
thumbnail_remote_url = ogc_server_settings.PUBLIC_LOCATION + "wms/reflect?" + p
create_thumbnail(instance, thumbnail_remote_url)
legend_url = ogc_server_settings.PUBLIC_LOCATION + 'wms?request=GetLegendGraphic&format=image/png&WIDTH=20&HEIGHT=20&LAYER=' + instance.typename + '&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_url = ogc_server_settings.public_url + 'wms?'
Link.objects.get_or_create(resource=instance.resourcebase_ptr,
url=ogc_wms_url,
defaults=dict(
extension='html',
name=instance.name,
url=ogc_wms_url,
mime='text/html',
link_type='OGC:WMS',
))
if instance.storeType == "dataStore":
ogc_wfs_url = ogc_server_settings.public_url + 'wfs?'
Link.objects.get_or_create(resource=instance.resourcebase_ptr,
url=ogc_wfs_url,
defaults=dict(
extension='html',
name=instance.name,
url=ogc_wfs_url,
mime='text/html',
link_type='OGC:WFS',
))
if instance.storeType == "coverageStore":
ogc_wcs_url = ogc_server_settings.public_url + 'wcs?'
Link.objects.get_or_create(resource=instance.resourcebase_ptr,
url=ogc_wcs_url,
defaults=dict(
extension='html',
name=instance.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()
#Save layer attributes
set_attributes(instance)
#Save layer styles
set_styles(instance, gs_catalog)
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)
gs_layer = gs_catalog.get_layer(instance.name)
if not gs_layer:
gs_layer = gs_catalog.get_layer(instance.alternate)
if gs_layer and instance.poc:
# gsconfig now utilizes an attribution dictionary
gs_layer.attribution = {
'title': str(instance.poc),
'width': None,
'height': None,
'href': None,
'url': None,
'type': None
}
profile = Profile.objects.get(username=instance.poc.username)
gs_layer.attribution_link = settings.SITEURL[:
-1] + profile.get_absolute_url(
)
# gs_layer 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_layer)
except geoserver.catalog.FailedRequestError as e:
msg = (
'Error while trying to save layer named %s in GeoServer, '
'try to use: "%s"' % (gs_layer, str(e)))
e.args = (msg, )
logger.exception(e)
if type(instance) is ResourceBase:
if hasattr(instance, 'layer'):
instance = instance.layer
else:
return
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_layer.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 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)
# Set download links for WMS, WCS or WFS and KML
links = wms_links(ogc_server_settings.public_url + 'wms?',
instance.alternate.encode('utf-8'), instance.bbox_string,
instance.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'))
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'),
','.join(str(x) for x in instance.bbox[0:4]),
instance.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',
))
html_link_url = '%s%s' % (settings.SITEURL[:-1],
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_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_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_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)
# Save layer attributes
set_attributes_from_geoserver(instance)
# Save layer styles
set_styles(instance, gs_catalog)
# NOTTODO by simod: we should not do this!
# need to be removed when fixing #2015
catalogue_post_save(instance, Layer)
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 layer_style_manage(req, layername):
layer = _resolve_layer(req, layername, 'layers.change_layer',
_PERMISSION_MSG_MODIFY)
if req.method == 'GET':
try:
cat = Layer.objects.gs_catalog
# First update the layer style info from GS to GeoNode's DB
set_styles(layer, cat)
all_available_gs_styles = cat.get_styles()
gs_styles = []
for style in all_available_gs_styles:
gs_styles.append(style.name)
current_layer_styles = layer.styles.all()
layer_styles = []
for style in current_layer_styles:
layer_styles.append(style.name)
# Render the form
return render_to_response(
'layers/layer_style_manage.html',
RequestContext(
req, {
"layer": layer,
"gs_styles": gs_styles,
"layer_styles": layer_styles,
"default_style": layer.default_style.name
}))
except (FailedRequestError, EnvironmentError) as e:
msg = ('Could not connect to geoserver at "%s"'
'to manage style information for layer "%s"' %
(ogc_server_settings.LOCATION, layer.name))
logger.warn(msg, e)
# If geoserver is not online, return an error
return render_to_response(
'layers/layer_style_manage.html',
RequestContext(req, {
"layer": layer,
"error": msg
}))
elif req.method == 'POST':
try:
selected_styles = req.POST.getlist('style-select')
default_style = req.POST['default_style']
# Save to GeoServer
cat = Layer.objects.gs_catalog
gs_layer = cat.get_layer(layer.name)
gs_layer.default_style = default_style
styles = []
for style in selected_styles:
# styles.append(type('style',(object,),{'name' : style}))
styles.append(style)
gs_layer.styles = styles
cat.save(gs_layer)
# Save to Django
layer = set_styles(layer, cat)
layer.save()
return HttpResponseRedirect(
reverse('layer_detail', args=(layer.typename, )))
except (FailedRequestError, EnvironmentError,
MultiValueDictKeyError) as e:
msg = ('Error Saving Styles for Layer "%s"' % (layer.name))
logger.warn(msg, e)
return render_to_response(
'layers/layer_style_manage.html',
RequestContext(req, {
"layer": layer,
"error": msg
}))
def geoserver_post_save2(layer_id):
"""Save keywords to GeoServer
The way keywords are implemented requires the layer
to be saved to the database before accessing them.
"""
"""Send information to geoserver.
The attributes sent include:
* Title
* Abstract
* Name
* Keywords
* Metadata Links,
* Point of Contact name and url
"""
from geonode.layers.models import Layer
instance = Layer.objects.get(id=layer_id)
# Don't run this signal if is a Layer from a remote service
if getattr(instance, "service", None) is not None:
return instance
# 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
# If the store in None then it's a new instance from an upload,
# only in this case run the geonode_uplaod 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 instance
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)
# Set fields obtained via the geoserver upload.
instance.name = gs_name
instance.workspace = workspace
instance.store = values['store']
# Iterate over values from geoserver.
for key in ['typename', 'store', 'storeType']:
setattr(instance, key, values[key])
instance.save()
if not gs_resource:
gs_resource = gs_catalog.get_resource(
instance.name,
store=instance.store,
workspace=instance.workspace)
if gs_resource:
gs_resource.title = instance.title if instance.title else ""
gs_resource.abstract = instance.abstract if instance.abstract else ""
gs_resource.name = instance.name if instance.name else ""
# Get metadata links
metadata_links = []
for link in instance.link_set.metadata():
metadata_links.append((link.mime, link.name, link.url))
if gs_resource:
gs_resource.metadata_links = metadata_links
# gs_resource should only be called if
# ogc_server_settings.BACKEND_WRITE_ENABLED == True
if gs_resource and getattr(ogc_server_settings, "BACKEND_WRITE_ENABLED",
True):
gs_catalog.save(gs_resource)
gs_layer = gs_catalog.get_layer(instance.name)
if instance.poc and instance.poc:
# gsconfig now utilizes an attribution dictionary
gs_layer.attribution = {'title': str(instance.poc),
'width': None,
'height': None,
'href': None,
'url': None,
'type': None}
profile = Profile.objects.get(username=instance.poc.username)
gs_layer.attribution_link = settings.SITEURL[
:-1] + profile.get_absolute_url()
# gs_layer 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_layer)
"""Get information from geoserver.
The attributes retrieved include:
* Bounding Box
* SRID
* Download links (WMS, WCS or WFS and KML)
* Styles (SLD)
"""
if gs_resource:
bbox = gs_resource.latlon_bbox
# FIXME(Ariel): Correct srid setting below
# self.srid = gs_resource.src
instance.srid_url = "http://www.spatialreference.org/ref/" + \
instance.srid.replace(':', '/').lower() + "/"
# Set bounding box values
instance.bbox_x0 = bbox[0]
instance.bbox_x1 = bbox[1]
instance.bbox_y0 = bbox[2]
instance.bbox_y1 = bbox[3]
# store the resource to avoid another geoserver call in the post_save
instance.gs_resource = gs_resource
instance.save()
if type(instance) is ResourceBase:
if hasattr(instance, 'layer'):
instance = instance.layer
else:
return instance
if instance.storeType == "remoteStore":
# Save layer attributes
set_attributes_from_geoserver(instance)
return instance
if not getattr(instance, 'gs_resource', None):
try:
gs_resource = gs_catalog.get_resource(
instance.name,
store=instance.store,
workspace=instance.workspace)
except socket_error as serr:
if serr.errno != errno.ECONNREFUSED:
# Not the error we are looking for, re-raise
raise serr
# If the connection is refused, take it easy.
return instance
else:
gs_resource = instance.gs_resource
if gs_resource is None:
return instance
if settings.RESOURCE_PUBLISHING:
if instance.is_published != gs_resource.advertised:
if getattr(ogc_server_settings, "BACKEND_WRITE_ENABLED", True):
gs_resource.advertised = instance.is_published
gs_catalog.save(gs_resource)
if any(instance.keyword_list()):
gs_resource.keywords = instance.keyword_list()
# 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)
bbox = gs_resource.latlon_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)
# Set download links for WMS, WCS or WFS and KML
links = wms_links(ogc_server_settings.public_url + 'wms?',
instance.typename.encode('utf-8'), instance.bbox_string,
instance.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.typename.encode('utf-8'))
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.typename.encode('utf-8'))
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.typename.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.typename.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',
)
)
html_link_url = '%s%s' % (
settings.SITEURL[:-1], instance.get_absolute_url())
Link.objects.get_or_create(resource=instance.resourcebase_ptr,
url=html_link_url,
defaults=dict(
extension='html',
name=instance.typename,
mime='text/html',
link_type='html',
)
)
create_gs_thumbnail(instance, overwrite=False)
legend_url = ogc_server_settings.PUBLIC_LOCATION + \
'wms?request=GetLegendGraphic&format=image/png&WIDTH=20&HEIGHT=20&LAYER=' + \
instance.typename + '&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/wms' % instance.workspace
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_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_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.typename.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)
# Save layer attributes
set_attributes_from_geoserver(instance)
# Save layer styles
set_styles(instance, gs_catalog)
# NOTTODO by simod: we should not do this!
# need to be removed when fixing #2015
from geonode.catalogue.models import catalogue_post_save
from geonode.layers.models import Layer
catalogue_post_save(instance, Layer)
return instance
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')
def geoserver_post_save(instance, sender, **kwargs):
"""Save keywords to GeoServer
The way keywords are implemented requires the layer
to be saved to the database before accessing them.
"""
if type(instance) is ResourceBase:
if hasattr(instance, "layer"):
instance = instance.layer
else:
return
if instance.storeType == "remoteStore":
# Save layer attributes
set_attributes(instance)
return
if not getattr(instance, "gs_resource", None):
try:
gs_resource = gs_catalog.get_resource(instance.name, store=instance.store, workspace=instance.workspace)
except socket_error as serr:
if serr.errno != errno.ECONNREFUSED:
# Not the error we are looking for, re-raise
raise serr
# If the connection is refused, take it easy.
return
else:
gs_resource = instance.gs_resource
if gs_resource is None:
return
if settings.RESOURCE_PUBLISHING:
if instance.is_published != gs_resource.advertised:
if getattr(ogc_server_settings, "BACKEND_WRITE_ENABLED", True):
gs_resource.advertised = instance.is_published
gs_catalog.save(gs_resource)
if any(instance.keyword_list()):
gs_resource.keywords = instance.keyword_list()
# 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)
bbox = gs_resource.latlon_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)
# Set download links for WMS, WCS or WFS and KML
links = wms_links(
ogc_server_settings.public_url + "wms?",
instance.typename.encode("utf-8"),
instance.bbox_string,
instance.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.typename.encode("utf-8"))
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"),
)
if (
gs_resource.store.type
and gs_resource.store.type.lower() == "geogig"
and gs_resource.store.connection_parameters.get("geogig_repository")
):
repo_url = "{url}geogig/{geogig_repository}".format(
url=ogc_server_settings.public_url,
geogig_repository=gs_resource.store.connection_parameters.get("geogig_repository"),
)
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":
# FIXME(Ariel): This works for public layers, does it work for restricted too?
# would those end up with no geotiff links, like, forever?
permissions = instance.get_all_level_info()
instance.set_permissions({"users": {"AnonymousUser": ["view_resourcebase"]}})
try:
# Potentially 3 dimensions can be returned by the grid if there is a z
# axis. Since we only want width/height, slice to the second
# dimension
covWidth, covHeight = get_coverage_grid_extent(instance)[:2]
except GeoNodeException as e:
msg = _("Could not create a download link for layer.")
try:
# HACK: The logger on signals throws an exception
logger.warn(msg, e)
except:
pass
else:
links = wcs_links(
ogc_server_settings.public_url + "wcs?",
instance.typename.encode("utf-8"),
bbox=gs_resource.native_bbox[:-1],
crs=gs_resource.native_bbox[-1],
height=str(covHeight),
width=str(covWidth),
)
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"),
)
instance.set_permissions(permissions)
kml_reflector_link_download = (
ogc_server_settings.public_url
+ "wms/kml?"
+ urllib.urlencode({"layers": instance.typename.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.typename.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"),
)
tile_url = (
"%sgwc/service/gmaps?" % ogc_server_settings.public_url
+ "layers=%s" % instance.typename.encode("utf-8")
+ "&zoom={z}&x={x}&y={y}"
+ "&format=image/png8"
)
Link.objects.get_or_create(
resource=instance.resourcebase_ptr,
url=tile_url,
defaults=dict(extension="tiles", name="Tiles", mime="image/png", link_type="image"),
)
html_link_url = "%s%s" % (settings.SITEURL[:-1], instance.get_absolute_url())
Link.objects.get_or_create(
resource=instance.resourcebase_ptr,
url=html_link_url,
defaults=dict(extension="html", name=instance.typename, mime="text/html", link_type="html"),
)
params = {"layers": instance.typename.encode("utf-8"), "format": "image/png8", "width": 200, "height": 150}
# Avoid using urllib.urlencode here because it breaks the url.
# commas and slashes in values get encoded and then cause trouble
# with the WMS parser.
p = "&".join("%s=%s" % item for item in params.items())
thumbnail_remote_url = ogc_server_settings.PUBLIC_LOCATION + "wms/reflect?" + p
thumbnail_create_url = ogc_server_settings.LOCATION + "wms/reflect?" + p
create_thumbnail(instance, thumbnail_remote_url, thumbnail_create_url, ogc_client=http_client)
legend_url = (
ogc_server_settings.PUBLIC_LOCATION
+ "wms?request=GetLegendGraphic&format=image/png&WIDTH=20&HEIGHT=20&LAYER="
+ instance.typename
+ "&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/wms" % instance.workspace
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_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_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()
# Save layer attributes
set_attributes(instance)
# Save layer styles
set_styles(instance, gs_catalog)
# NOTTODO by simod: we should not do this!
# need to be removed when fixing #2015
from geonode.catalogue.models import catalogue_post_save
from geonode.layers.models import Layer
catalogue_post_save(instance, Layer)
def geoserver_post_save2(layer_id):
"""Save keywords to GeoServer
The way keywords are implemented requires the layer
to be saved to the database before accessing them.
"""
"""Send information to geoserver.
The attributes sent include:
* Title
* Abstract
* Name
* Keywords
* Metadata Links,
* Point of Contact name and url
"""
from geonode.layers.models import Layer
instance = Layer.objects.get(id=layer_id)
# Don't run this signal if is a Layer from a remote service
if getattr(instance, "service", None) is not None:
return instance
# Don't run this signal handler if it is a tile layer
# Currently only gpkg files containing tiles will have this type & will be served via MapProxy.
if hasattr(instance, 'storeType') and getattr(instance,
'storeType') == 'tileStore':
return instance
gs_resource = None
# If the store in None then it's a new instance from an upload,
# only in this case run the geonode_uplaod 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 instance
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)
# Set fields obtained via the geoserver upload.
instance.name = gs_name
instance.workspace = workspace
instance.store = values['store']
# Iterate over values from geoserver.
for key in ['typename', 'store', 'storeType']:
setattr(instance, key, values[key])
instance.save()
if not gs_resource:
gs_resource = gs_catalog.get_resource(instance.name,
store=instance.store,
workspace=instance.workspace)
if gs_resource:
gs_resource.title = instance.title if instance.title else ""
gs_resource.abstract = instance.abstract if instance.abstract else ""
gs_resource.name = instance.name if instance.name else ""
# Get metadata links
metadata_links = []
for link in instance.link_set.metadata():
metadata_links.append((link.mime, link.name, link.url))
if gs_resource:
gs_resource.metadata_links = metadata_links
# gs_resource should only be called if
# ogc_server_settings.BACKEND_WRITE_ENABLED == True
if gs_resource and getattr(ogc_server_settings, "BACKEND_WRITE_ENABLED",
True):
gs_catalog.save(gs_resource)
gs_layer = gs_catalog.get_layer(instance.name)
if instance.poc and instance.poc:
# gsconfig now utilizes an attribution dictionary
gs_layer.attribution = {
'title': str(instance.poc),
'width': None,
'height': None,
'href': None,
'url': None,
'type': None
}
profile = Profile.objects.get(username=instance.poc.username)
gs_layer.attribution_link = settings.SITEURL[:
-1] + profile.get_absolute_url(
)
# gs_layer 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_layer)
"""Get information from geoserver.
The attributes retrieved include:
* Bounding Box
* SRID
* Download links (WMS, WCS or WFS and KML)
* Styles (SLD)
"""
if gs_resource:
bbox = gs_resource.latlon_bbox
# FIXME(Ariel): Correct srid setting below
# self.srid = gs_resource.src
instance.srid_url = "http://www.spatialreference.org/ref/" + \
instance.srid.replace(':', '/').lower() + "/"
# Set bounding box values
instance.bbox_x0 = bbox[0]
instance.bbox_x1 = bbox[1]
instance.bbox_y0 = bbox[2]
instance.bbox_y1 = bbox[3]
# store the resource to avoid another geoserver call in the post_save
instance.gs_resource = gs_resource
instance.save()
if type(instance) is ResourceBase:
if hasattr(instance, 'layer'):
instance = instance.layer
else:
return instance
if instance.storeType == "remoteStore":
# Save layer attributes
set_attributes_from_geoserver(instance)
return instance
if not getattr(instance, 'gs_resource', None):
try:
gs_resource = gs_catalog.get_resource(instance.name,
store=instance.store,
workspace=instance.workspace)
except socket_error as serr:
if serr.errno != errno.ECONNREFUSED:
# Not the error we are looking for, re-raise
raise serr
# If the connection is refused, take it easy.
return instance
else:
gs_resource = instance.gs_resource
if gs_resource is None:
return instance
if settings.RESOURCE_PUBLISHING:
if instance.is_published != gs_resource.advertised:
if getattr(ogc_server_settings, "BACKEND_WRITE_ENABLED", True):
gs_resource.advertised = instance.is_published
gs_catalog.save(gs_resource)
if any(instance.keyword_list()):
gs_resource.keywords = instance.keyword_list()
# 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)
bbox = gs_resource.latlon_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)
# Set download links for WMS, WCS or WFS and KML
links = wms_links(ogc_server_settings.public_url + 'wms?',
instance.typename.encode('utf-8'), instance.bbox_string,
instance.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.typename.encode('utf-8'))
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.typename.encode('utf-8'))
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.typename.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.typename.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',
))
html_link_url = '%s%s' % (settings.SITEURL[:-1],
instance.get_absolute_url())
Link.objects.get_or_create(resource=instance.resourcebase_ptr,
url=html_link_url,
defaults=dict(
extension='html',
name=instance.typename,
mime='text/html',
link_type='html',
))
create_gs_thumbnail(instance, overwrite=False)
legend_url = ogc_server_settings.PUBLIC_LOCATION + \
'wms?request=GetLegendGraphic&format=image/png&WIDTH=20&HEIGHT=20&LAYER=' + \
instance.typename + '&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/wms' % instance.workspace
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_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_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.typename.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)
# Save layer attributes
set_attributes_from_geoserver(instance)
# Save layer styles
set_styles(instance, gs_catalog)
# NOTTODO by simod: we should not do this!
# need to be removed when fixing #2015
from geonode.catalogue.models import catalogue_post_save
from geonode.layers.models import Layer
catalogue_post_save(instance, Layer)
return instance
def geoserver_post_save(instance, sender, **kwargs):
"""Save keywords to GeoServer
The way keywords are implemented requires the layer
to be saved to the database before accessing them.
"""
if instance.storeType == "remoteStore":
# Save layer attributes
set_attributes(instance)
return
try:
gs_resource = gs_catalog.get_resource(
instance.name,
store=instance.store,
workspace=instance.workspace)
except socket_error as serr:
if serr.errno != errno.ECONNREFUSED:
# Not the error we are looking for, re-raise
raise serr
# If the connection is refused, take it easy.
return
if gs_resource is None:
return
if any(instance.keyword_list()):
gs_resource.keywords = instance.keyword_list()
# 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)
bbox = gs_resource.latlon_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)
# Set download links for WMS, WCS or WFS and KML
links = wms_links(ogc_server_settings.public_url + 'wms?',
instance.typename.encode('utf-8'), instance.bbox_string,
instance.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.typename.encode('utf-8'))
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',
)
)
if gs_resource.store.type.lower() == 'geogit':
repo_url = '{url}geogit/{workspace}:{store}'.format(
url=ogc_server_settings.public_url,
workspace=instance.workspace,
store=instance.store)
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 GeoGit',
mime='text/xml',
link_type='html'
)
)
command_url = lambda command: "{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='GeoGit 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='GeoGit statistics',
mime='application/json',
link_type='html'
)
)
elif instance.storeType == 'coverageStore':
# FIXME(Ariel): This works for public layers, does it work for restricted too?
# would those end up with no geotiff links, like, forever?
permissions = instance.get_all_level_info()
instance.set_permissions(
{'users': {'AnonymousUser': ['view_resourcebase']}})
try:
# Potentially 3 dimensions can be returned by the grid if there is a z
# axis. Since we only want width/height, slice to the second
# dimension
covWidth, covHeight = get_coverage_grid_extent(instance)[:2]
except GeoNodeException as e:
msg = _('Could not create a download link for layer.')
logger.warn(msg, e)
else:
links = wcs_links(ogc_server_settings.public_url + 'wcs?',
instance.typename.encode('utf-8'),
bbox=gs_resource.native_bbox[:-1],
crs=gs_resource.native_bbox[-1],
height=str(covHeight),
width=str(covWidth))
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',
)
)
instance.set_permissions(permissions)
kml_reflector_link_download = ogc_server_settings.public_url + "wms/kml?" + \
urllib.urlencode({'layers': instance.typename.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.typename.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',
)
)
tile_url = ('%sgwc/service/gmaps?' % ogc_server_settings.public_url +
'layers=%s' % instance.typename.encode('utf-8') +
'&zoom={z}&x={x}&y={y}' +
'&format=image/png8'
)
Link.objects.get_or_create(resource=instance.resourcebase_ptr,
url=tile_url,
defaults=dict(
extension='tiles',
name=_("Tiles"),
mime='image/png',
link_type='image',
)
)
wms_path = '%s/%s/wms' % (instance.workspace, instance.name)
ows_url = urljoin(ogc_server_settings.public_url, wms_path)
Link.objects.get_or_create(resource=instance.resourcebase_ptr,
url=ows_url,
defaults=dict(
extension='html',
name=_("OWS"),
url=ows_url,
mime='text/html',
link_type='OGC:WMS',
)
)
html_link_url = '%s%s' % (
settings.SITEURL[:-1], instance.get_absolute_url())
Link.objects.get_or_create(resource=instance.resourcebase_ptr,
url=html_link_url,
defaults=dict(
extension='html',
name=instance.typename,
mime='text/html',
link_type='html',
)
)
params = {
'layers': instance.typename.encode('utf-8'),
'format': 'image/png8',
'width': 200,
'height': 150,
}
# Avoid using urllib.urlencode here because it breaks the url.
# commas and slashes in values get encoded and then cause trouble
# with the WMS parser.
p = "&".join("%s=%s" % item for item in params.items())
thumbnail_remote_url = ogc_server_settings.PUBLIC_LOCATION + \
"wms/reflect?" + p
thumbail_create_url = ogc_server_settings.LOCATION + \
"wms/reflect?" + p
# This is a workaround for development mode where cookies are not shared and the layer is not public so
# not visible through geoserver
if settings.DEBUG:
from geonode.security.views import _perms_info_json
current_perms = _perms_info_json(instance.get_self_resource())
instance.set_default_permissions()
create_thumbnail(instance, thumbnail_remote_url, thumbail_create_url)
if settings.DEBUG:
instance.set_permissions(json.loads(current_perms))
legend_url = ogc_server_settings.PUBLIC_LOCATION + 'wms?request=GetLegendGraphic&format=image/png&WIDTH=20&HEIGHT=20&LAYER=' + \
instance.typename + '&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_url = ogc_server_settings.public_url + 'wms?'
Link.objects.get_or_create(resource=instance.resourcebase_ptr,
url=ogc_wms_url,
defaults=dict(
extension='html',
name=instance.name,
url=ogc_wms_url,
mime='text/html',
link_type='OGC:WMS',
)
)
if instance.storeType == "dataStore":
ogc_wfs_url = ogc_server_settings.public_url + 'wfs?'
Link.objects.get_or_create(resource=instance.resourcebase_ptr,
url=ogc_wfs_url,
defaults=dict(
extension='html',
name=instance.name,
url=ogc_wfs_url,
mime='text/html',
link_type='OGC:WFS',
)
)
if instance.storeType == "coverageStore":
ogc_wcs_url = ogc_server_settings.public_url + 'wcs?'
Link.objects.get_or_create(resource=instance.resourcebase_ptr,
url=ogc_wcs_url,
defaults=dict(
extension='html',
name=instance.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()
# Save layer attributes
set_attributes(instance)
# Save layer styles
set_styles(instance, gs_catalog)
def test_save_and_delete_signals(self):
"""Test that GeoServer Signals methods work as espected"""
layers = Layer.objects.all()[:2].values_list('id', flat=True)
test_perm_layer = Layer.objects.get(id=layers[0])
self.client.login(username='******', password='******')
if check_ogc_backend(geoserver.BACKEND_PACKAGE):
from geonode.geoserver.signals import (geoserver_pre_delete,
geoserver_post_save,
geoserver_post_save_local)
# Handle Layer Save and Upload Signals
geoserver_post_save(test_perm_layer, sender=Layer)
geoserver_post_save_local(test_perm_layer)
# Check instance bbox and links
self.assertIsNotNone(test_perm_layer.bbox)
self.assertIsNotNone(test_perm_layer.srid)
self.assertIsNotNone(test_perm_layer.link_set)
self.assertEquals(len(test_perm_layer.link_set.all()), 7)
# Layer Manipulation
from geonode.geoserver.upload import geoserver_upload
from geonode.geoserver.signals import gs_catalog
from geonode.geoserver.helpers import (
check_geoserver_is_up, get_sld_for, fixup_style,
set_layer_style, get_store, set_attributes_from_geoserver,
set_styles, create_gs_thumbnail, cleanup)
check_geoserver_is_up()
admin_user = get_user_model().objects.get(username="******")
saved_layer = geoserver_upload(
test_perm_layer,
os.path.join(gisdata.VECTOR_DATA,
"san_andres_y_providencia_poi.shp"),
admin_user,
test_perm_layer.name,
overwrite=True)
self.assertIsNotNone(saved_layer)
_log(saved_layer)
workspace, name = test_perm_layer.alternate.split(':')
self.assertIsNotNone(workspace)
self.assertIsNotNone(name)
ws = gs_catalog.get_workspace(workspace)
self.assertIsNotNone(ws)
store = get_store(gs_catalog, name, workspace=ws)
_log("1. ------------ %s " % store)
self.assertIsNotNone(store)
# Save layer attributes
set_attributes_from_geoserver(test_perm_layer)
# Save layer styles
set_styles(test_perm_layer, gs_catalog)
# set SLD
sld = test_perm_layer.default_style.sld_body if test_perm_layer.default_style else None
if sld:
_log("2. ------------ %s " % sld)
set_layer_style(test_perm_layer, test_perm_layer.alternate,
sld)
fixup_style(gs_catalog, test_perm_layer.alternate, None)
self.assertIsNone(get_sld_for(gs_catalog, test_perm_layer))
_log("3. ------------ %s " %
get_sld_for(gs_catalog, test_perm_layer))
create_gs_thumbnail(test_perm_layer, overwrite=True)
self.assertIsNotNone(test_perm_layer.get_thumbnail_url())
self.assertTrue(test_perm_layer.has_thumbnail())
# Handle Layer Delete Signals
geoserver_pre_delete(test_perm_layer, sender=Layer)
# Check instance has been removed from GeoServer also
from geonode.geoserver.views import get_layer_capabilities
self.assertIsNone(get_layer_capabilities(test_perm_layer))
# Cleaning Up
test_perm_layer.delete()
cleanup(test_perm_layer.name, test_perm_layer.uuid)
def geoserver_post_save(instance, sender, **kwargs):
"""Save keywords to GeoServer
The way keywords are implemented requires the layer
to be saved to the database before accessing them.
"""
url = ogc_server_settings.internal_rest
try:
gs_resource = gs_catalog.get_resource(instance.name)
except (FailedRequestError, EnvironmentError) as e:
msg = ('Could not connect to geoserver at "%s"'
'to save information for layer "%s"' %
(ogc_server_settings.LOCATION, instance.name.encode('utf-8')))
logger.warn(msg, e)
# If geoserver is not online, there is no need to continue
return
# If there is no resource returned it could mean one of two things:
# a) There is a synchronization problem in geoserver
# b) The unit tests are running and another geoserver is running in the
# background.
# For both cases it is sensible to stop processing the layer
if gs_resource is None:
logger.warn('Could not get geoserver resource for %s' % instance)
return
gs_resource.keywords = instance.keyword_list()
#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)
bbox = gs_resource.latlon_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)
# Set download links for WMS, WCS or WFS and KML
links = wms_links(ogc_server_settings.public_url + 'wms?',
instance.typename.encode('utf-8'), instance.bbox_string,
instance.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.typename.encode('utf-8'))
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',
))
elif instance.storeType == 'coverageStore':
#FIXME(Ariel): This works for public layers, does it work for restricted too?
# would those end up with no geotiff links, like, forever?
permissions = {}
permissions['anonymous'] = instance.get_gen_level(ANONYMOUS_USERS)
permissions['authenticated'] = instance.get_gen_level(
AUTHENTICATED_USERS)
instance.set_gen_level(ANONYMOUS_USERS, 'layer_readonly')
#Potentially 3 dimensions can be returned by the grid if there is a z
#axis. Since we only want width/height, slice to the second dimension
covWidth, covHeight = get_coverage_grid_extent(instance)[:2]
links = wcs_links(ogc_server_settings.public_url + 'wcs?',
instance.typename.encode('utf-8'),
bbox=gs_resource.native_bbox[:-1],
crs=gs_resource.native_bbox[-1],
height=str(covHeight),
width=str(covWidth))
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',
))
instance.set_gen_level(ANONYMOUS_USERS, permissions['anonymous'])
instance.set_gen_level(AUTHENTICATED_USERS,
permissions['authenticated'])
kml_reflector_link_download = ogc_server_settings.public_url + "wms/kml?" + urllib.urlencode(
{
'layers': instance.typename.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.typename.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',
))
tile_url = ('%sgwc/service/gmaps?' % ogc_server_settings.public_url +
'layers=%s' % instance.typename.encode('utf-8') +
'&zoom={z}&x={x}&y={y}' + '&format=image/png8')
Link.objects.get_or_create(resource=instance.resourcebase_ptr,
url=tile_url,
defaults=dict(
extension='tiles',
name=_("Tiles"),
mime='image/png',
link_type='image',
))
wms_path = '%s/%s/wms' % (instance.workspace, instance.name)
ows_url = urljoin(ogc_server_settings.public_url, wms_path)
Link.objects.get_or_create(resource=instance.resourcebase_ptr,
url=ows_url,
defaults=dict(
extension='html',
name=_("OWS"),
url=ows_url,
mime='text/html',
link_type='OGC:WMS',
))
html_link_url = '%s%s' % (settings.SITEURL[:-1],
instance.get_absolute_url())
Link.objects.get_or_create(resource=instance.resourcebase_ptr,
url=html_link_url,
defaults=dict(
extension='html',
name=instance.typename,
mime='text/html',
link_type='html',
))
params = {
'layers': instance.typename.encode('utf-8'),
'format': 'image/png8',
'width': 200,
'height': 150,
}
# Avoid using urllib.urlencode here because it breaks the url.
# commas and slashes in values get encoded and then cause trouble
# with the WMS parser.
p = "&".join("%s=%s" % item for item in params.items())
thumbnail_url = ogc_server_settings.LOCATION + "wms/reflect?" + p
Link.objects.get_or_create(resource=instance.resourcebase_ptr,
url=thumbnail_url,
defaults=dict(
extension='png',
name=_("Remote Thumbnail"),
mime='image/png',
link_type='image',
))
# Download thumbnail and save it locally.
resp, image = http_client.request(thumbnail_url)
if 'ServiceException' in image or resp.status < 200 or resp.status > 299:
msg = 'Unable to obtain thumbnail: %s' % image
logger.debug(msg)
# Replace error message with None.
image = None
if image is not None:
#Clean any orphan Thumbnail before
Thumbnail.objects.filter(resourcebase__id=None).delete()
thumbnail, created = Thumbnail.objects.get_or_create(
resourcebase__id=instance.id)
thumbnail.thumb_spec = thumbnail_url
thumbnail.save_thumb(image, instance._thumbnail_path())
Link.objects.get_or_create(resource=instance.resourcebase_ptr,
url=settings.SITEURL +
instance._thumbnail_path(),
defaults=dict(
extension='png',
name=_("Thumbnail"),
mime='image/png',
link_type='image',
))
ogc_wms_url = ogc_server_settings.public_url + 'wms?'
Link.objects.get_or_create(resource=instance.resourcebase_ptr,
url=ogc_wms_url,
defaults=dict(
extension='html',
name=instance.name,
url=ogc_wms_url,
mime='text/html',
link_type='OGC:WMS',
))
if instance.storeType == "dataStore":
ogc_wfs_url = ogc_server_settings.public_url + 'wfs?'
Link.objects.get_or_create(resource=instance.resourcebase_ptr,
url=ogc_wfs_url,
defaults=dict(
extension='html',
name=instance.name,
url=ogc_wfs_url,
mime='text/html',
link_type='OGC:WFS',
))
if instance.storeType == "coverageStore":
ogc_wcs_url = ogc_server_settings.public_url + 'wcs?'
Link.objects.get_or_create(resource=instance.resourcebase_ptr,
url=ogc_wcs_url,
defaults=dict(
extension='html',
name=instance.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()
#Save layer attributes
set_attributes(instance)
#Save layer styles
set_styles(instance, gs_catalog)
)
# 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()
# Save layer attributes
set_attributes(instance)
# Save layer styles
set_styles(instance, gs_catalog)
def geoserver_pre_save_maplayer(instance, sender, **kwargs):
# If this object was saved via fixtures,
# do not do post processing.
if kwargs.get("raw", False):
return
try:
instance.local = isinstance(gs_catalog.get_layer(instance.name), GsLayer)
except EnvironmentError, e:
if e.errno == errno.ECONNREFUSED:
msg = "Could not connect to catalog to verify if layer %s was local" % instance.name
logger.warn(msg, e)
else:
def geoserver_post_save(instance, sender, **kwargs):
"""Save keywords to GeoServer
The way keywords are implemented requires the layer
to be saved to the database before accessing them.
"""
# Don't run this signal handler if it is a tile layer
# Currently only gpkg files containing tiles will have this type & will be served via MapProxy.
if hasattr(instance, 'storeType') and getattr(instance,
'storeType') == 'tileStore':
return
if type(instance) is ResourceBase:
if hasattr(instance, 'layer'):
instance = instance.layer
else:
return
if instance.storeType == "remoteStore":
# Save layer attributes
set_attributes_from_geoserver(instance)
return
if not getattr(instance, 'gs_resource', None):
try:
gs_resource = gs_catalog.get_resource(instance.name,
store=instance.store,
workspace=instance.workspace)
except socket_error as serr:
if serr.errno != errno.ECONNREFUSED:
# Not the error we are looking for, re-raise
raise serr
# If the connection is refused, take it easy.
return
else:
gs_resource = instance.gs_resource
if gs_resource is None:
return
if settings.RESOURCE_PUBLISHING:
if instance.is_published != gs_resource.advertised:
if getattr(ogc_server_settings, "BACKEND_WRITE_ENABLED", True):
gs_resource.advertised = instance.is_published
gs_catalog.save(gs_resource)
if any(instance.keyword_list()):
gs_resource.keywords = instance.keyword_list()
# 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)
bbox = gs_resource.latlon_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)
# Set download links for WMS, WCS or WFS and KML
links = wms_links(ogc_server_settings.public_url + 'wms?',
instance.typename.encode('utf-8'), instance.bbox_string,
instance.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.typename.encode('utf-8'))
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.typename.encode('utf-8'))
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.typename.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.typename.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',
))
html_link_url = '%s%s' % (settings.SITEURL[:-1],
instance.get_absolute_url())
Link.objects.get_or_create(resource=instance.resourcebase_ptr,
url=html_link_url,
defaults=dict(
extension='html',
name=instance.typename,
mime='text/html',
link_type='html',
))
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.typename + '&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/wms' % instance.workspace
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_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_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.typename.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)
# Save layer attributes
set_attributes_from_geoserver(instance)
# Save layer styles
set_styles(instance, gs_catalog)
# NOTTODO by simod: we should not do this!
# need to be removed when fixing #2015
from geonode.catalogue.models import catalogue_post_save
from geonode.layers.models import Layer
catalogue_post_save(instance, Layer)
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 test_save_and_delete_signals(self):
"""Test that GeoServer Signals methods work as espected"""
layers = Layer.objects.all()[:2].values_list('id', flat=True)
test_perm_layer = Layer.objects.get(id=layers[0])
self.client.login(username='******', password='******')
if check_ogc_backend(geoserver.BACKEND_PACKAGE):
from geonode.geoserver.signals import (geoserver_pre_delete,
geoserver_post_save,
geoserver_post_save_local)
# Handle Layer Save and Upload Signals
geoserver_post_save(test_perm_layer, sender=Layer)
geoserver_post_save_local(test_perm_layer)
# Check instance bbox and links
self.assertIsNotNone(test_perm_layer.bbox)
self.assertIsNotNone(test_perm_layer.srid)
self.assertIsNotNone(test_perm_layer.link_set)
self.assertEquals(len(test_perm_layer.link_set.all()), 9)
# Layer Manipulation
from geonode.geoserver.upload import geoserver_upload
from geonode.geoserver.signals import gs_catalog
from geonode.geoserver.helpers import (check_geoserver_is_up,
get_sld_for,
fixup_style,
set_layer_style,
get_store,
set_attributes_from_geoserver,
set_styles,
create_gs_thumbnail,
cleanup)
check_geoserver_is_up()
admin_user = get_user_model().objects.get(username="******")
saved_layer = geoserver_upload(
test_perm_layer,
os.path.join(
gisdata.VECTOR_DATA,
"san_andres_y_providencia_poi.shp"),
admin_user,
test_perm_layer.name,
overwrite=True
)
self.assertIsNotNone(saved_layer)
_log(saved_layer)
workspace, name = test_perm_layer.alternate.split(':')
self.assertIsNotNone(workspace)
self.assertIsNotNone(name)
ws = gs_catalog.get_workspace(workspace)
self.assertIsNotNone(ws)
store = get_store(gs_catalog, name, workspace=ws)
_log("1. ------------ %s " % store)
self.assertIsNotNone(store)
# Save layer attributes
set_attributes_from_geoserver(test_perm_layer)
# Save layer styles
set_styles(test_perm_layer, gs_catalog)
# set SLD
sld = test_perm_layer.default_style.sld_body if test_perm_layer.default_style else None
if sld:
_log("2. ------------ %s " % sld)
set_layer_style(test_perm_layer, test_perm_layer.alternate, sld)
fixup_style(gs_catalog, test_perm_layer.alternate, None)
self.assertIsNone(get_sld_for(gs_catalog, test_perm_layer))
_log("3. ------------ %s " % get_sld_for(gs_catalog, test_perm_layer))
create_gs_thumbnail(test_perm_layer, overwrite=True)
self.assertIsNotNone(test_perm_layer.get_thumbnail_url())
self.assertTrue(test_perm_layer.has_thumbnail())
# Handle Layer Delete Signals
geoserver_pre_delete(test_perm_layer, sender=Layer)
# Check instance has been removed from GeoServer also
from geonode.geoserver.views import get_layer_capabilities
self.assertIsNone(get_layer_capabilities(test_perm_layer))
# Cleaning Up
test_perm_layer.delete()
cleanup(test_perm_layer.name, test_perm_layer.uuid)