def _create_layer_thumbnail(self, geonode_layer):
"""Create a thumbnail with a WMS request."""
params = {
"service": self.service_type,
"version": self.parsed_service.version,
"request": "GetMap",
"layers": geonode_layer.alternate.encode('utf-8'),
"bbox": geonode_layer.bbox_string,
"srs": "EPSG:4326",
"width": "200",
"height": "150",
"format": "image/png",
}
kvp = "&".join("{}={}".format(*item) for item in params.items())
thumbnail_remote_url = "{}?{}".format(geonode_layer.ows_url, kvp)
logger.debug("thumbnail_remote_url: {}".format(thumbnail_remote_url))
thumbnail_create_url = "{}?{}".format(
self.pki_url or geonode_layer.ows_url, kvp)
logger.debug("thumbnail_create_url: {}".format(thumbnail_create_url))
create_thumbnail(
instance=geonode_layer,
thumbnail_remote_url=thumbnail_remote_url,
thumbnail_create_url=thumbnail_create_url,
check_bbox=True,
overwrite=True,
)
def geoserver_post_save_map(instance, sender, **kwargs):
instance.set_missing_info()
local_layers = []
for layer in instance.layers:
if layer.local:
local_layers.append(layer.name)
# If the map does not have any local layers, do not create the thumbnail.
if len(local_layers) > 0:
params = {
'layers': ",".join(local_layers).encode('utf-8'),
'format': 'image/png8',
'width': 200,
'height': 150,
}
# Add the bbox param only if the bbox is different to [None, None,
# None, None]
if None not in instance.bbox:
params['bbox'] = instance.bbox_string
# 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, check_bbox=False)
def create_arcgis_links(instance):
kmz_link = instance.ows_url + '?f=kmz'
Link.objects.get_or_create(resource=instance.get_self_resource(),
url=kmz_link,
defaults=dict(
extension='kml',
name="View in Google Earth",
mime='text/xml',
link_type='data',
)
)
# Create legend.
legend_url = instance.ows_url + 'legend?f=json'
Link.objects.get_or_create(resource=instance.get_self_resource(),
url=legend_url,
defaults=dict(
extension='json',
name=_('Legend'),
url=legend_url,
mime='application/json',
link_type='json',
)
)
# Create thumbnails.
bbox = urllib.pathname2url('%s,%s,%s,%s' % (instance.bbox_x0, instance.bbox_y0, instance.bbox_x1, instance.bbox_y1))
thumbnail_remote_url = instance.ows_url + 'export?LAYERS=show%3A' + str(instance.typename) + \
'&TRANSPARENT=true&FORMAT=png&BBOX=' + bbox + '&SIZE=200%2C150&F=image&BBOXSR=4326&IMAGESR=3857'
create_thumbnail(instance, thumbnail_remote_url)
def create_arcgis_links(instance):
kmz_link = instance.ows_url + "?f=kmz"
Link.objects.get_or_create(
resource=instance.get_self_resource(),
url=kmz_link,
defaults=dict(extension="kml", name="View in Google Earth", mime="text/xml", link_type="data"),
)
# Create legend.
legend_url = instance.ows_url + "legend?f=json"
Link.objects.get_or_create(
resource=instance.get_self_resource(),
url=legend_url,
defaults=dict(extension="json", name=_("Legend"), url=legend_url, mime="application/json", link_type="json"),
)
# Create thumbnails.
bbox = urllib.pathname2url("%s,%s,%s,%s" % (instance.bbox_x0, instance.bbox_y0, instance.bbox_x1, instance.bbox_y1))
thumbnail_remote_url = (
instance.ows_url
+ "export?LAYERS=show%3A"
+ str(instance.typename)
+ "&TRANSPARENT=true&FORMAT=png&BBOX="
+ bbox
+ "&SIZE=200%2C150&F=image&BBOXSR=4326&IMAGESR=3857"
)
create_thumbnail(instance, thumbnail_remote_url)
def create_qgis_server_thumbnail(instance, overwrite=False, bbox=None):
"""Task to update thumbnails.
This task will formulate OGC url to generate thumbnail and then pass it
to geonode
:param instance: Resource instance, can be a layer or map
:type instance: Layer, Map
:param overwrite: set True to overwrite
:type overwrite: bool
:param bbox: Bounding box of thumbnail in 4 tuple format
[xmin,ymin,xmax,ymax]
:type bbox: list(float)
:return:
"""
thumbnail_remote_url = None
try:
# to make sure it is executed after the instance saved
if isinstance(instance, Layer):
thumbnail_remote_url = layer_thumbnail_url(
instance, bbox=bbox, internal=False)
elif isinstance(instance, Map):
thumbnail_remote_url = map_thumbnail_url(
instance, bbox=bbox, internal=False)
else:
# instance type does not have associated thumbnail
return True
if not thumbnail_remote_url:
return True
logger.debug('Create thumbnail for %s' % thumbnail_remote_url)
if overwrite:
# if overwrite, then delete existing thumbnail links
instance.link_set.filter(
resource=instance.get_self_resource(),
name="Remote Thumbnail").delete()
instance.link_set.filter(
resource=instance.get_self_resource(),
name="Thumbnail").delete()
create_thumbnail(
instance, thumbnail_remote_url,
overwrite=overwrite, check_bbox=False)
return True
# if it is socket exception, we should raise it, because there is
# something wrong with the url
except socket.error as e:
logger.error('Thumbnail url not accessed {url}'.format(
url=thumbnail_remote_url))
logger.exception(e)
# reraise exception with original traceback
raise
except Exception as e:
logger.exception(e)
return False
def _create_layer_thumbnail(self, geonode_layer):
"""Grab the image from the service."""
thumbnail_remote_url = "{}/info/thumbnail".format(self.url)
logger.debug("thumbnail_remote_url: {}".format(thumbnail_remote_url))
thumbnail_create_url = "{}/info/thumbnail".format(
self.pki_url or self.url)
logger.debug("thumbnail_remote_url: {}".format(thumbnail_create_url))
create_thumbnail(
instance=geonode_layer,
thumbnail_remote_url=thumbnail_remote_url,
thumbnail_create_url=thumbnail_create_url,
check_bbox=False,
overwrite=True,
)
def geoserver_post_save_map(instance, sender, **kwargs):
instance.set_missing_info()
local_layers = []
for layer in instance.layers:
if layer.local:
local_layers.append(layer.name)
# If the map does not have any local layers, do not create the thumbnail.
if len(local_layers) > 0:
params = {
'layers': ",".join(local_layers).encode('utf-8'),
'format': 'image/png8',
'width': 200,
'height': 150,
}
# Add the bbox param only if the bbox is different to [None, None,
# None, None]
if None not in instance.bbox:
params['bbox'] = instance.bbox_string
# 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, check_bbox=False)
#Assuming map thumbnail was created successfully, updating Story object here
if instance.chapter_index == 0:
instance.story.update_thumbnail(instance)
try:
# update the elastic search index for the object after post_save triggers have fired.
# TODO: this should be done asynchronously!
update_es_index(sender, sender.objects.get(id=instance.id))
update_es_index(MapStory, MapStory.objects.get(id=instance.story.id))
except:
pass
def create_arcgis_links(instance):
kmz_link = instance.ows_url + '?f=kmz'
Link.objects.get_or_create(resource= instance.resourcebase_ptr,
url=kmz_link,
defaults=dict(
extension='kml',
name="View in Google Earth",
mime='text/xml',
link_type='data',
)
)
# Create legend.
legend_url = instance.ows_url + 'legend?f=json'
Link.objects.get_or_create(resource= instance.resourcebase_ptr,
url=legend_url,
defaults=dict(
extension='json',
name=_('Legend'),
url=legend_url,
mime='application/json',
link_type='json',
)
)
mercator_bbox = llbbox_to_mercator(instance.bbox)
# Create thumbnails.
#FIXME(Ariel): Construct the bbox parameter from the above object.
# Hardcoding it for now.
bbox = '0%2C0%2C10018754.17%2C10018754.17'
thumbnail_remote_url = instance.ows_url + 'export?LAYERS=show%3A0&TRANSPARENT=true&FORMAT=png&BBOX=' + bbox + '&SIZE=200%2C150&F=image&BBOXSR=900913&IMAGESR=900913'
create_thumbnail(instance, thumbnail_remote_url)
def _create_layer_thumbnail(self, geonode_layer):
"""Create a thumbnail with a WMS request."""
params = {
"service": "WMS",
"version": self.parsed_service.version,
"request": "GetMap",
"layers": geonode_layer.alternate.encode('utf-8'),
"bbox": geonode_layer.bbox_string,
"srs": "EPSG:4326",
"width": "200",
"height": "150",
"format": "image/png",
}
kvp = "&".join("{}={}".format(*item) for item in params.items())
thumbnail_remote_url = "{}?{}".format(
geonode_layer.remote_service.service_url, kvp)
logger.debug("thumbnail_remote_url: {}".format(thumbnail_remote_url))
create_thumbnail(instance=geonode_layer,
thumbnail_remote_url=thumbnail_remote_url,
thumbnail_create_url=None,
check_bbox=False,
overwrite=True)
def geoserver_post_save_map(instance, sender, **kwargs):
instance.set_missing_info()
local_layers = []
for layer in instance.layers:
if layer.local:
local_layers.append(layer.name)
# If the map does not have any local layers, do not create the thumbnail.
if len(local_layers) > 0:
params = {
'layers': ",".join(local_layers).encode('utf-8'),
'format': 'image/png8',
'width': 200,
'height': 150,
}
# Add the bbox param only if the bbox is different to [None, None,
# None, None]
if None not in instance.bbox:
params['bbox'] = instance.bbox_string
# 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,
check_bbox=False)
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)
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?"
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)
'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)
>>>>>>> 2c522ce5efd5757f4d94e63a543e24e9ac97805b
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',
)
def create_qgis_server_thumbnail(instance, overwrite=False, bbox=None):
"""Task to update thumbnails.
This task will formulate OGC url to generate thumbnail and then pass it
to geonode
:param instance: Resource instance, can be a layer or map
:type instance: Layer, Map
:param overwrite: set True to overwrite
:type overwrite: bool
:param bbox: Bounding box of thumbnail in 4 tuple format
[xmin,ymin,xmax,ymax]
:type bbox: list(float)
:return:
"""
thumbnail_remote_url = None
try:
# to make sure it is executed after the instance saved
if isinstance(instance, Layer):
thumbnail_remote_url = layer_thumbnail_url(
instance, bbox=bbox, internal=False)
elif isinstance(instance, Map):
thumbnail_remote_url = map_thumbnail_url(
instance, bbox=bbox, internal=False)
else:
# instance type does not have associated thumbnail
return True
if not thumbnail_remote_url:
return True
logger.debug('Create thumbnail for %s' % thumbnail_remote_url)
if overwrite:
# if overwrite, then delete existing thumbnail links
instance.link_set.filter(
resource=instance.get_self_resource(),
name="Remote Thumbnail").delete()
instance.link_set.filter(
resource=instance.get_self_resource(),
name="Thumbnail").delete()
create_thumbnail(
instance, thumbnail_remote_url,
overwrite=overwrite, check_bbox=False)
return True
# if it is socket exception, we should raise it, because there is
# something wrong with the url
except socket.error as e:
logger.error('Thumbnail url not accessed {url}'.format(
url=thumbnail_remote_url))
logger.exception(e)
# reraise exception with original traceback
raise
except QGISServerLayer.DoesNotExist as e:
logger.exception(e)
# reraise exception with original traceback
raise
except Exception as e:
logger.exception(e)
return False
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 qgis_server_post_save(instance, sender, **kwargs):
"""Save keywords to QGIS Server
The way keywords are implemented requires the layer
to be saved to the database before accessing them.
"""
# TODO
# 1. Create or update associated QGISServerLayer [Done]
# 2. Create Link for the tile and legend.
logger.debug('QGIS Server Post Save')
qgis_layer, created = QGISServerLayer.objects.get_or_create(layer=instance)
# copy layer to QGIS Layer Directory
geonode_layer_path = instance.get_base_file()[0].file.path
logger.debug('Geonode Layer Path %s' % geonode_layer_path)
base_filename, original_ext = os.path.splitext(geonode_layer_path)
extensions = QGISServerLayer.accepted_format
for ext in extensions:
if os.path.exists(base_filename + '.' + ext):
logger.debug('Copying %s' % base_filename + '.' + ext)
try:
if created:
# Assuming different layer has different filename because
# geonode rename it
shutil.copy2(base_filename + '.' + ext,
QGIS_layer_directory)
else:
# If there is already a file, replace the old one
shutil.copy2(base_filename + '.' + ext,
qgis_layer.base_layer_path + '.' + ext)
logger.debug('Success')
except IOError as e:
logger.debug('Error copying file. %s' % e)
if created:
# Only set when creating new QGISServerLayer Object
geonode_filename = os.path.basename(geonode_layer_path)
basename = os.path.splitext(geonode_filename)[0]
qgis_layer.base_layer_path = os.path.join(
QGIS_layer_directory,
basename + original_ext # Already with dot
)
qgis_layer.save()
# Set Link for Download Raw in Zip File
zip_download_url = reverse('qgis-server-download-zip',
kwargs={'layername': instance.name})
logger.debug('zip_download_url: %s' % zip_download_url)
Link.objects.get_or_create(resource=instance.resourcebase_ptr,
url=zip_download_url,
defaults=dict(extension='zip',
name='Zipped Shapefile',
mime='SHAPE-ZIP',
url=zip_download_url,
link_type='data'))
tile_url = reverse('qgis-server-tile',
kwargs={
'layername': instance.name,
'x': 5678,
'y': 910,
'z': 1234
})
logger.debug('tile_url: %s' % tile_url)
tile_url = tile_url.replace('1234/5678/910', '{z}/{x}/{y}')
logger.debug('tile_url: %s' % tile_url)
Link.objects.get_or_create(resource=instance.resourcebase_ptr,
url=tile_url,
defaults=dict(extension='tiles',
name="Tiles",
mime='image/png',
link_type='image'))
# Create legend link
legend_url = reverse('qgis-server-legend',
kwargs={'layername': instance.name})
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',
))
# Create thumbnail
thumbnail_remote_url = settings.GEONODE_BASE_URL[:-1]
thumbnail_remote_url += reverse('qgis-server-thumbnail',
kwargs={'layername': instance.name})
logger.debug(thumbnail_remote_url)
create_thumbnail(instance, thumbnail_remote_url, ogc_client=http_client)
# Attributes
set_attributes(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 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
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)
# 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
# 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)
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',
))
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.
"""
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',
)
)
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',
)
)
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()
# 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(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)
