def test_nodes_connection(self):
try:
geodata_staging = self.testapp.app.registry.settings[
'geodata_staging']
session = scoped_session(sessionmaker())
topics = self.testapp.get('/rest/services', status=200)
for t in topics.json['topics']:
topic = t.get('id')
query = session.query(Catalog).filter(Catalog.topic == topic)\
.order_by(Catalog.orderKey)
query = filter_by_geodata_staging(query, Catalog.staging,
geodata_staging)
rows = query.all()
if (rows):
graph, meta, root_id = create_digraph(rows, 'fr')
nodes = graph.nodes()
if len(nodes) != len(rows):
for row in rows:
if row.id not in nodes:
raise Exception(
'%s %s %s is unconnected leaf' %
(topic, row.category, row.layerBodId))
finally:
if session:
session.close()
def get_layers_config_for_params(params, query, model):
''' Returns a generator function that yields
layer config dictionaries. '''
model = LayersConfig
query = filter_by_map_name(query, model, params.mapName)
query = filter_by_geodata_staging(query, model.staging,
params.geodataStaging)
for q in query:
yield q.layerConfig(params)
def getTopics():
session = getSession()
model = Topics
showCatalog = True
query = session.query(model).filter(model.showCatalog == showCatalog).order_by(model.id)
query = filter_by_geodata_staging(query, model.staging, STAGING)
results = [q.id for q in query]
session.close()
return results
def get_layers_metadata_for_params(params, query, model, layerIds=None):
""" Returns a generator function that yields
layer metadata dictionaries. """
query = filter_by_map_name(query, model, params.mapName)
query = filter_by_geodata_staging(query, model.staging, params.geodataStaging)
if layerIds is not None:
for layerId in layerIds:
layer = get_layer(query, model, layerId)
yield layer.layerMetadata()
for q in query:
yield q.layerMetadata()
def catalog(self):
model = Catalog
query = self.request.db.query(model)\
.filter(model.topic.like('%%%s%%' % self.mapName.lower()))\
.order_by(model.depth)\
.order_by(model.orderKey)\
.order_by(remove_accents(model.get_name_from_lang(self.lang)))
rows = filter_by_geodata_staging(query, model.staging, self.staging).all()
if len(rows) == 0:
raise HTTPNotFound('No catalog with id %s is available' % self.mapName)
return {'results': self.tree(rows)}
def get_layers_metadata_for_params(params, query, model, layerIds=None):
''' Returns a generator function that yields
layer metadata dictionaries. '''
query = filter_by_map_name(query, model, params.mapName)
query = filter_by_geodata_staging(query, model.staging,
params.geodataStaging)
if layerIds is not None:
for layerId in layerIds:
layer = get_layer(query, model, layerId)
yield layer.layerMetadata()
for q in query:
yield q.layerMetadata()
def catalog(self):
model = Catalog
query = self.request.db.query(model)\
.filter(model.topic.like('%%%s%%' % self.mapName.lower()))\
.order_by(model.depth)\
.order_by(model.orderKey)\
.order_by(remove_accents(model.get_name_from_lang(self.lang)))
rows = filter_by_geodata_staging(query, model.staging,
self.staging).all()
if len(rows) == 0:
raise HTTPNotFound('No catalog with id %s is available' %
self.mapName)
return {'results': self.tree(rows)}
def topics(request):
model = Topics
geodataStaging = request.registry.settings['geodata_staging']
showCatalog = True
query = request.db.query(model).filter(model.showCatalog == showCatalog).order_by(model.orderKey)
query = filter_by_geodata_staging(query, model.staging, geodataStaging)
results = [{
'id': q.id,
'langs': q.availableLangs,
'showCatalog': q.showCatalog,
'backgroundLayers': q.backgroundLayers,
'selectedLayers': q.selectedLayers
} for q in query]
return {'topics': results}
def wmtscapabilities(self):
from pyramid.renderers import render_to_response
scheme = self.request.headers.get(
'X-Forwarded-Proto',
self.request.scheme)
staging = self.request.registry.settings['geodata_staging']
host = self.request.headers.get(
'X-Forwarded-Host', self.request.host)
mapproxyHost = self.request.registry.settings['mapproxyhost']
apache_base_path = self.request.registry.settings['apache_base_path']
apache_entry_point = '/' if (apache_base_path == 'main' or 'localhost' in host) else '/' + apache_base_path
# Default ressource
s3_url = sanitize_url("%s://wmts.geo.admin.ch/" % scheme)
mapproxy_url = sanitize_url("%s://%s%s/" % (scheme, mapproxyHost, apache_entry_point))
onlineressources = {'mapproxy': mapproxy_url, 's3': s3_url}
layers_query = self.request.db.query(self.models['GetCap'])
layers_query = filter_by_geodata_staging(
layers_query,
self.models['GetCap'].staging,
staging
)
if self.mapName != 'all':
layers_query = filter_by_map_name(layers_query, self.models['GetCap'], self.mapName)
layers = layers_query.all()
if hasattr(self.models['GetCapThemes'], 'oberthema_id'):
themes = self.request.db.query(self.models['GetCapThemes']).order_by(self.models['GetCapThemes'].oberthema_id).all()
else:
themes = self.request.db.query(self.models['GetCapThemes']).all()
metadata = self.request.db.query(self.models['ServiceMetadata'])\
.filter(self.models['ServiceMetadata']
.pk_map_name.like('%wmts-bgdi%')).first()
wmts = {
'layers': layers,
'themes': themes,
'metadata': metadata,
'scheme': scheme,
'onlineressources': onlineressources,
'tilematrixset': self.tileMatrixSet,
'tilematrixsetDefs': DEFAULT_TILEMATRIXSET
}
response = render_to_response(
'chsdi:templates/wmtscapabilities.mako',
wmts,
request=self.request)
response.content_type = 'text/xml'
return response
def layers(params):
buildlink = lambda x: '?topic=' + topic['id'] + '&layers=' + x.layerBodId
session = params.request.db
paths = []
topics = getTopics(params)
for topic in topics:
query = (session.query(Catalog)
.filter(Catalog.topic.ilike('%%%s%%' % topic['id']))
.filter(Catalog.category.ilike('%%layer%%')))
query = filter_by_geodata_staging(query, Catalog.staging, params.staging)
layerlinks = map(buildlink, query.all())
paths.extend(toAllLanguages(topic['langs'].split(','), layerlinks, '&', ''))
return asXml(params, paths)
def layers(params):
buildlink = lambda x: '?topic=' + topic['id'] + '&layers=' + x.layerBodId
session = params.request.db
paths = []
topics = getTopics(params)
for topic in topics:
query = (session.query(Catalog)
.filter(Catalog.topic.ilike('%%%s%%' % topic['id']))
.filter(Catalog.category.ilike(u'%%layer%%')))
query = filter_by_geodata_staging(query, Catalog.staging, params.staging)
layerlinks = map(buildlink, query.all())
paths.extend(toAllLanguages(params.langs, layerlinks, '&', ''))
return asXml(params, paths, params.geoadminhost)
def topics(request):
model = Topics
geodataStaging = request.registry.settings['geodata_staging']
showCatalog = True
query = request.db.query(model).filter(
model.showCatalog == showCatalog).order_by(model.orderKey)
query = filter_by_geodata_staging(query, model.staging, geodataStaging)
results = [{
'id': q.id,
'langs': q.availableLangs,
'showCatalog': q.showCatalog,
'backgroundLayers': q.backgroundLayers,
'selectedLayers': q.selectedLayers
} for q in query]
return {'topics': results}
def wmtscapabilities(self):
from pyramid.renderers import render_to_response
scheme = self.request.headers.get('X-Forwarded-Proto',
self.request.scheme)
staging = self.request.registry.settings['geodata_staging']
mapproxyHost = self.request.registry.settings['mapproxyhost']
# Default ressource
s3_url = sanitize_url("%s://wmts.geo.admin.ch/" % scheme)
mapproxy_url = sanitize_url("%s://%s/" % (scheme, mapproxyHost))
onlineressources = {'mapproxy': mapproxy_url, 's3': s3_url}
layers_query = self.request.db.query(self.models['GetCap'])
layers_query = filter_by_geodata_staging(layers_query,
self.models['GetCap'].staging,
staging)
if self.mapName != 'all':
layers_query = filter_by_map_name(layers_query,
self.models['GetCap'],
self.mapName)
layers = layers_query.all()
if hasattr(self.models['GetCapThemes'], 'oberthema_id'):
themes = self.request.db.query(
self.models['GetCapThemes']).order_by(
self.models['GetCapThemes'].oberthema_id).all()
else:
themes = self.request.db.query(self.models['GetCapThemes']).all()
metadata = self.request.db.query(self.models['ServiceMetadata'])\
.filter(self.models['ServiceMetadata']
.pk_map_name.like('%wmts-bgdi%')).first()
wmts = {
'layers': layers,
'themes': themes,
'metadata': metadata,
'scheme': scheme,
'onlineressources': onlineressources,
'tilematrixset': self.tileMatrixSet,
'tilematrixsetDefs': DEFAULT_TILEMATRIXSET
}
response = render_to_response(
'chsdi:templates/wmtscapabilities/wmtscapabilities.mako',
wmts,
request=self.request)
response.content_type = 'text/xml'
return response
def wmtscapabilities(self):
from pyramid.renderers import render_to_response
scheme = self.request.headers.get('X-Forwarded-Proto',
self.request.scheme)
staging = self.request.registry.settings['geodata_staging']
wmts_public_host = self.request.registry.settings['wmts_public_host']
# Default ressource
onlineressource = sanitize_url("%s://%s/" % (scheme, wmts_public_host))
layers_query = self.request.db.query(self.models['GetCap'])
layers_query = filter_by_geodata_staging(layers_query,
self.models['GetCap'].staging,
staging)
if self.mapName != 'all':
layers_query = filter_by_map_name(layers_query,
self.models['GetCap'],
self.mapName)
layers = layers_query.all()
zoom_levels = getLayersZoomLevelSet(self.tileMatrixSet, layers)
if hasattr(self.models['GetCapThemes'], 'oberthema_id'):
themes = self.request.db.query(
self.models['GetCapThemes']).order_by(
self.models['GetCapThemes'].oberthema_id).all()
else:
themes = self.request.db.query(self.models['GetCapThemes']).all()
metadata = self.request.db.query(self.models['ServiceMetadata'])\
.filter(self.models['ServiceMetadata']
.pk_map_name.like(u'%wmts-bgdi%')).first()
wmts = {
'layers': layers,
'zoomlevels': zoom_levels,
'themes': themes,
'metadata': metadata,
'scheme': scheme,
'onlineressource': onlineressource,
'tilematrixset': self.tileMatrixSet,
'tilematrixsetDefs': getDefaultTileMatrixSet(self.tileMatrixSet)
}
response = render_to_response(
'chsdi:templates/wmtscapabilities/wmtscapabilities.mako',
wmts,
request=self.request)
response.content_type = 'text/xml'
return response
def getLayersConfigs():
engine = engine_from_config(settings, 'sqlalchemy.bod.')
DBSession = scoped_session(sessionmaker())
DBSession.configure(bind=engine)
models = get_wmts_models(LANG)
layers_query = DBSession.query(models['GetCap'])
layers_query = layers_query.filter(models['GetCap'].maps.ilike('%%%s%%' % 'api'))
layers_query = filter_by_geodata_staging(
layers_query,
models['GetCap'].staging,
STAGING
)
DBSession.close()
return [q for q in layers_query.all()]
def catalog(self):
model = Catalog
query = self.request.db.query(model)\
.filter(model.topic.like('%%%s%%' % self.mapName.lower()))
rows = filter_by_geodata_staging(query, model.staging, self.staging).all()
if len(rows) == 0:
raise HTTPNotFound('No catalog with id %s is available' % self.mapName)
G, meta, root_id = create_digraph(rows, self.lang)
if len(rows) != len(G.nodes()):
raise HTTPInternalServerError('Catalog tree for topic %s has unconnected leaves' % self.mapName)
data = tree_data(G, root_id, {'children': 'children', 'id': 'id'}, meta)
data['category'] = meta[root_id]['category']
data['staging'] = meta[root_id]['staging']
data = {'results': {'root': data}}
return data
def wmtscapabilities(self):
from pyramid.renderers import render_to_response
scheme = self.request.headers.get(
'X-Forwarded-Proto',
self.request.scheme)
staging = self.request.registry.settings['geodata_staging']
wmts_public_host = self.request.registry.settings['wmts_public_host']
# Default ressource
onlineressource = sanitize_url("%s://%s/" % (scheme, wmts_public_host))
layers_query = self.request.db.query(self.models['GetCap'])
layers_query = filter_by_geodata_staging(
layers_query,
self.models['GetCap'].staging,
staging
)
if self.mapName != 'all':
layers_query = filter_by_map_name(layers_query, self.models['GetCap'], self.mapName)
layers = layers_query.all()
zoom_levels = getLayersZoomLevelSet(self.tileMatrixSet, layers)
if hasattr(self.models['GetCapThemes'], 'oberthema_id'):
themes = self.request.db.query(self.models['GetCapThemes']).order_by(self.models['GetCapThemes'].oberthema_id).all()
else:
themes = self.request.db.query(self.models['GetCapThemes']).all()
metadata = self.request.db.query(self.models['ServiceMetadata'])\
.filter(self.models['ServiceMetadata']
.pk_map_name.like(u'%wmts-bgdi%')).first()
wmts = {
'layers': layers,
'zoomlevels': zoom_levels,
'themes': themes,
'metadata': metadata,
'scheme': scheme,
'onlineressource': onlineressource,
'tilematrixset': self.tileMatrixSet,
'tilematrixsetDefs': getDefaultTileMatrixSet(self.tileMatrixSet)
}
response = render_to_response(
'chsdi:templates/wmtscapabilities/wmtscapabilities.mako',
wmts,
request=self.request)
response.content_type = 'text/xml'
return response
def get_layers_config_for_params(params, query, model):
''' Returns a generator function that yields
layer config dictionaries. '''
model = LayersConfig
query = filter_by_map_name(
query,
model,
params.mapName
)
query = filter_by_geodata_staging(
query,
model.staging,
params.geodataStaging
)
for q in query:
yield q.layerConfig(params)
def getLayersConfigs(topics=topics):
session = getSession()
models = get_wmts_models(LANG)
conditions = []
for topic in topics:
conditions.append(models['GetCap'].maps.ilike('%{}%'.format(topic)))
layers_query = session.query(models['GetCap'])
layers_query = layers_query.filter(or_(*conditions))
layers_query = filter_by_geodata_staging(
layers_query,
models['GetCap'].staging,
STAGING
)
session.close()
return [q for q in layers_query.all()]
def topics(request):
model = Topics
geodataStaging = request.registry.settings['geodata_staging']
showCatalog = True
query = request.db.query(model).filter(model.showCatalog == showCatalog) \
.order_by(model.groupId)
query = filter_by_geodata_staging(query, model.staging, geodataStaging)
results = [{
'id': q.id,
'defaultBackground': q.defaultBackground,
'backgroundLayers': q.backgroundLayers,
'selectedLayers': q.selectedLayers,
'activatedLayers': q.activatedLayers,
'plConfig': q.plconf,
'groupId': q.groupId
} for q in query]
return {'topics': results}
def test_nodes_connection(self):
try:
geodata_staging = self.testapp.app.registry.settings['geodata_staging']
session = scoped_session(sessionmaker())
topics = self.testapp.get('/rest/services', status=200)
for t in topics.json['topics']:
topic = t.get('id')
query = session.query(Catalog).filter(Catalog.topic == topic)\
.order_by(Catalog.orderKey)
query = filter_by_geodata_staging(query, Catalog.staging, geodata_staging)
rows = query.all()
if (rows):
graph, meta, root_id = create_digraph(rows, 'fr')
nodes = graph.nodes()
if len(nodes) != len(rows):
for row in rows:
if row.id not in nodes:
raise Exception('%s %s %s is unconnected leaf' % (topic, row.category, row.layerBodId))
finally:
if session:
session.close()
def catalog(self):
model = Catalog
query = self.request.db.query(model)\
.filter(model.topic.like('%%%s%%' % self.mapName.lower()))
rows = filter_by_geodata_staging(query, model.staging,
self.staging).all()
if len(rows) == 0:
raise HTTPNotFound('No catalog with id %s is available' %
self.mapName)
G, meta, root_id = create_digraph(rows, self.lang)
if len(rows) != len(G.nodes()):
raise HTTPInternalServerError(
'Catalog tree for topic %s has unconnected leaves' %
self.mapName)
data = tree_data(G, root_id, {
'children': 'children',
'id': 'id'
}, meta)
data['category'] = meta[root_id]['category']
data['staging'] = meta[root_id]['staging']
data = {'results': {'root': data}}
return data
