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.
"""
if instance.storeType == "remoteStore":
#Save layer attributes
set_attributes(instance)
return
url = ogc_server_settings.internal_rest
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',
))
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, 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)
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")
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, 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_gen_level(ANONYMOUS_USERS, permissions["anonymous"])
instance.set_gen_level(AUTHENTICATED_USERS, permissions["authenticated"])
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)
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 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"),
)
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_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)
