def query_features(lang, layers, query):
features = []
max_features_pro_layer = int(10 / len(layers))
terms = query.split()
terms1 = ' & '.join([term + ('' if term.isdigit() else ':*') for term in terms])
if lang == 'fr' or lang == 'it':
bodsearch = BodLayerFr
else:
bodsearch = BodLayerDe
c.baseUrl = ''
c.lang = lang
c.path_url = ''
for layer in layers:
bodlayer = Session.query(bodsearch).get(layer)
for model in models_from_name(layer):
if hasattr(model, '__queryable_attributes__'):
ftsFilter = 'to_tsvector(\'english\',' + ' || \' \' || '.join(["coalesce(%s::text,'') " % s for s in
model.__queryable_attributes__]) + ") @@ to_tsquery('english','%s')" % terms1
for feature in Session.query(model).filter(ftsFilter).limit(max_features_pro_layer).all():
feature.compute_attribute()
feature.compute_template(layer, bodlayer)
layername = _(layer)
html = '<b>%s </b><br>%s' % (layername[0:35]+'...' if len(layername) > 35 else layername,
feature.preview)
feature.attributes['html'] = html
feature.layer_id = layer
features.append(feature)
return features
def index(self, format='html'):
"""GET /wmts: GetCapabilities document"""
response.headers['Content-Type'] = 'text/xml'
response.headers['Pragma'] = 'public'
response.headers['Expires'] = '0'
response.headers['Cache-Control'] = 'no-cache'
response.charset = 'utf-8'
http_host = request.environ.get("HTTP_HOST")
request_uri = request.environ.get("REQUEST_URI", "")
if request_uri.find("1.0.0"): # new bucket WMTS
onlineressource = "%s://wmts.geo.admin.ch" % c.scheme
else:
onlineressource = "%s://api.geo.admin.ch/wmts" % c.scheme
# for ssWMTS
c.is_swisstopowmts = request.params.get('mode', '') == 'swisstopowmts'
if c.is_swisstopowmts:
c.layers = Session.query(self.GetCap).filter_by(sswmts=True).all()
onlineressource = "%s://wmts.swistopo.admin.ch" % c.scheme
c.service_metadata = Session.query(self.ServiceMetadata).filter(self.ServiceMetadata.pk_map_name.like('%wmts-swisstopo%')).first()
else:
c.layers = Session.query(self.GetCap).all()
c.service_metadata = Session.query(self.ServiceMetadata).filter(self.ServiceMetadata.pk_map_name.like('%wmts-bgdi%')).first()
c.onlineressource = onlineressource
c.themes = Session.query(self.GetCapThemes).all()
c.lang = self.lang
if c.layers is None or c.themes is None:
abort(404)
return render('/WMTSCapabilities.mako')
def decode(self, id=None):
if id is None or id == 'robots.txt':
abort(400, 'A short url is required')
else:
query = Session.query(ShortUrl)
query = query.filter(ShortUrl.url_short == '' + id)
for r in query:
url = r.url
redirect(url)
def shorten(myUrl):
# Check that myUrl is not already in the database
query1 = Session.query(ShortUrl)
query1 = query1.filter(ShortUrl.url == myUrl)
dontExist = True
for r1 in query1:
dontExist = False
shorturl = r1.url_short
break
# The current time is hashed and then, only the seven first characters are used.
if dontExist:
try:
shorturl = hashlib.md5(str(datetime.now())).hexdigest()[:8]
shortUrlObject = ShortUrl(url_short=shorturl, url=myUrl)
Session.add(shortUrlObject)
Session.commit()
except Exception, e:
mail("*****@*****.**", "Error in ShortenerController", "Database insert error", "")
raise Exception('Error by database insert in Shortener')
def decode(self, id=None):
url = None
if id is None or id == 'robots.txt':
abort(400, 'A short url is required')
else:
query = Session.query(ShortUrl)
query = query.filter(ShortUrl.url_short == '' + id)
for r in query:
url = r.url
if url is not None:
redirect(url)
abort(404, 'No long url correspond to given short url.')
def layers(self):
p = request.params.get("project") or "mf-chsdi"
query = Session.query(self.BodLayer)
query = query.filter(self.BodLayer.projekte.op("~")(p + "[,]?"))
swissimage = [{"id": "ch.swisstopo.swissimage", "description": "Swissimage"}]
pixelmap = [{"id": "ch.swisstopo.pixelkarte-farbe", "description": "Pixelmap Color"}]
pixelmap_gray = [{"id": "ch.swisstopo.pixelkarte-grau", "description": "Pixelmap Gray"}]
res = [r.json_layer() for r in query]
res.extend(swissimage)
res.extend(pixelmap)
res.extend(pixelmap_gray)
return {"results": res}
def layers(self):
p = request.params.get('project') or 'mf-chsdi'
query = Session.query(self.BodLayer)
query = query.filter(self.BodLayer.projekte.op('~')(p+'[,]?'))
swissimage = [{'id': 'ch.swisstopo.swissimage', 'description': 'Swissimage'}]
pixelmap = [{'id': 'ch.swisstopo.pixelkarte-farbe', 'description': 'Pixelmap Color'}]
pixelmap_gray = [{'id': 'ch.swisstopo.pixelkarte-grau', 'description': 'Pixelmap Gray'}]
res = [r.json_layer() for r in query]
res.extend(swissimage)
res.extend(pixelmap)
res.extend(pixelmap_gray)
return {'results': res}
def get_features(layer, ids):
features = []
for model in models_from_name(layer):
for fid in ids:
if len(features) < MAX_FEATURES:
try:
feature = Session.query(model).get(fid)
if feature:
features.append(feature)
except exc.SQLAlchemyError:
pass
else:
break
return features
def datenstand(self, layer_id, datenstand):
"""
if the value in bod.dataset.datenstand == TAG_DATENSTAND, return the most recent date of the data table,
else return the regular value datenstand.
"""
if datenstand == self.TAG_DATENSTAND:
try:
for model in models_from_name(layer_id):
modified = Session.query(func.max(model.bgdi_created))
return modified.first()[0].strftime("%Y%m%d")
except:
return datenstand
else:
return datenstand
def details(self, id=None):
c.host = request.params.get('h', '')
c.full = True
c.hilight = ''
c.layer = Session.query(self.BodLayer).get(id)
if c.layer is None:
abort(404)
c.legend = Session.query(self.BodLayer).get(id)
if c.legend is None:
abort(404)
c.legend.datenstand = self.datenstand(c.layer.bod_layer_id, c.legend.datenstand)
if 'print' in request.params:
return render('/bod-details-print.mako')
else:
if self.rawjson:
output = {}
legend = {}
for col in c.layer.__table__.columns:
output[col.name] = getattr(c.layer,col.name)
for col in c.legend.__table__.columns:
legend[col.name] = getattr(c.legend,col.name)
output['legend'] = legend
output = simplejson.dumps(output)
else:
output = simplejson.dumps(render('/bod-details.mako'))
cb_name = request.params.get('cb')
if cb_name is not None:
response.headers['Content-Type'] = 'text/javascript'
return str(cb_name) + '(' + output + ');'
else:
response.headers['Content-Type'] = 'application/json'
return output
def details(self, id=None):
c.host = request.params.get("h", "")
c.full = True
c.hilight = ""
c.layer = Session.query(self.BodLayer).get(id)
if c.layer is None:
abort(404)
c.legend = Session.query(self.BodLayer).get(id)
if c.legend is None:
abort(404)
c.legend.datenstand = self.datenstand(c.layer.bod_layer_id, c.legend.datenstand)
if "print" in request.params:
return render("/bod-details-print.mako")
else:
if self.rawjson:
output = {}
legend = {}
for col in c.layer.__table__.columns:
output[col.name] = getattr(c.layer, col.name)
for col in c.legend.__table__.columns:
legend[col.name] = getattr(c.legend, col.name)
output["legend"] = legend
output = simplejson.dumps(output)
else:
output = simplejson.dumps(render("/bod-details.mako"))
cb_name = request.params.get("cb")
if cb_name is not None:
response.headers["Content-Type"] = "text/javascript"
return str(cb_name) + "(" + output + ");"
else:
response.headers["Content-Type"] = "application/json"
return output
def compute_template(self, layer_id, bodlayer):
c.feature = self
c.layer_bezeichnung = bodlayer.bezeichnung if hasattr(bodlayer, 'bezeichnung') else ''
c.layer_datenherr = bodlayer.datenherr if hasattr(bodlayer, 'datenherr') else ''
c.layer_id = layer_id
if bodlayer.datenstand == 'bgdi_created':
for model in models_from_name(layer_id):
modified = Session.query(func.max(model.bgdi_created))
c.datenstand = modified.first()[0].strftime("%d.%m.%Y")
else:
c.datenstand = bodlayer.datenstand
c.stable_id = c.feature.stable_id
self.layer_id= layer_id
c.html_type = 'full'
self.html = render(self.__template__)
c.html_type = 'preview'
self.preview = render(self.__template__).strip()
def search(self):
q = request.params.get('query')
if q is None:
abort(400, "missing 'query' parameter")
p = request.params.get('project') or 'mf-geoadmin2'
# Filter by staging attribute
query = Session.query(self.BodLayer).order_by(self.BodLayer.kurzbezeichnung).order_by(self.BodLayer.bezeichnung).order_by(self.BodLayer.geobasisdatensatz_name)
if 'integration' in self.Geodata_staging:
query = query.filter(or_(self.BodLayer.staging == 'integration', self.BodLayer.staging == 'prod'))
elif 'prod' in self.Geodata_staging:
query = query.filter(self.BodLayer.staging == 'prod')
query = query.filter(self.BodLayer.volltextsuche.ilike('%' + q + '%')).filter(self.BodLayer.projekte.op('~')(p + '(,|\s|$)'))
return {'results': [r.json(q, self.rawjson) for r in query]}
def index(self):
layers = []
format = request.params.get('format','json')
query = Session.query(self.BodGrid)
for layer in query:
layers.append(layer)
c.layers = layers
results = {'results': [l.toDict() for l in layers]}
response.headers['Cache-Control'] = 'no-cache'
if 'callback' in request.params:
response.headers['Content-Type'] = 'text/javascript; charset=utf-8'
return request.params['callback'] + '(' + json_dumps(results) + ');'
else:
response.headers['Content-Type'] = 'application/json'
return json_dumps(results)
def reversegeocoding(self):
lon = request.params.get('easting')
if lon is None:
abort(400, "missing 'easting' parameter")
try:
lon = float(lon)
except:
abort(400, "parameter 'easting' is not a number")
lat = request.params.get('northing')
if lat is None:
abort(400, "missing 'northing' parameter")
try:
lat = float(lat)
except:
abort(400, "parameter 'northing' is not a number")
tolerance = request.params.get('tolerance')
if tolerance is None:
tolerance = 10
try:
tolerance = float(tolerance)
except:
abort(400, "parameter 'tolerance' is not a number")
# search for everything except sn25 data (who did not have 'the_geom_poly' geom)
gfilter_poly = SwissSearch.within_filter(lon, lat, tolerance=tolerance, column='the_geom_poly')
# now search for sn25 data
gfilter_point = SwissSearch.within_filter(lon, lat, tolerance=tolerance, column='the_geom_point')
query = Session.query(SwissSearch)
query = query.filter(or_(gfilter_poly, gfilter_point))
# remove the translated results
query = query.filter(SwissSearch.translated == False)
if self.origins:
query = query.filter(SwissSearch.origin.in_(self.origins))
query = query.limit(MAX_FEATURES_REVERSEGEOCODING)
if self.rawjson:
return FeatureCollection(list(self.getRawFeatures(query)))
else:
return [f.json(rawjson=False, nogeom=self.no_geom) for f in query.all()]
def search(self):
q = request.params.get("query")
if q is None:
abort(400, "missing 'query' parameter")
p = request.params.get("project") or "mf-geoadmin2"
# Filter by staging attribute
query = (
Session.query(self.BodLayer)
.order_by(self.BodLayer.kurzbezeichnung)
.order_by(self.BodLayer.bezeichnung)
.order_by(self.BodLayer.geobasisdatensatz_name)
)
if "test_integration" not in self.Geodata_staging:
query = query.filter(self.BodLayer.staging == "prod")
query = query.filter(self.BodLayer.volltextsuche.ilike("%" + q + "%")).filter(
self.BodLayer.projekte.op("~")(p + "(,|\s|$)")
)
return {"results": [r.json(q, self.rawjson) for r in query]}
def index(self):
layers = []
format = request.params.get('format','json')
# any better way to detect layer group ?
query = Session.query(self.klass).filter(self.klass.kurzbezeichnung != None).order_by(self.klass.kurzbezeichnung)
if 'inspire_id' in request.params:
inspire_id = request.params.get('inspire_id')
query = query.filter(self.klass.inspire_id == inspire_id)
for layer in query:
layers.append(layer)
c.layers = layers
results = {'results': [l.toDict() for l in layers]}
response.headers['Cache-Control'] = 'no-cache'
if 'callback' in request.params:
response.headers['Content-Type'] = 'text/javascript; charset=utf-8'
return request.params['callback'] + '(' + json_dumps(results) + ');'
else:
response.headers['Content-Type'] = 'application/json'
return json_dumps(results)
def index(self):
lon = request.params.get('easting')
if lon is None:
abort(400, "missing 'easting' parameter")
try:
lon = float(lon)
except:
abort(400, "parameter 'easting' is not a number")
lat = request.params.get('northing')
if lat is None:
abort(400, "missing 'northing' parameter")
try:
lat = float(lat)
except:
abort(400, "parameter 'northing' is not a number")
# Manage scale dependent view
mymodel = Zeitreihen_Metadata_15
tolerance = 500
if c.scale > 50005 and c.scale <= 100005:
mymodel = Zeitreihen_Metadata_20
tolerance = c.scale/100
if c.scale > 25005 and c.scale <= 50005:
mymodel = Zeitreihen_Metadata_21
tolerance = c.scale/100
if c.scale > 1 and c.scale <= 25005:
mymodel = Zeitreihen_Metadata_22
tolerance = c.scale/100
query = Session.query(mymodel)
spatialFilter = mymodel.within_filter(lon, lat, tolerance=tolerance, column='the_geom')
query = query.filter(spatialFilter)
#Default timestamp
timestamps = ['1938','1950','1960','1970','1980','1990','2000','2010']
counter = 0
minYear = 2020
minTimestamp = 1844
# Fill the array in time descending direction
for f in query.all():
if counter == 0:
timestamps = []
counter = 1
for x in f.release_year:
if int(x) < minYear and int(x) >= minTimestamp:
timestamps.append(str(x))
minYear = x
if int(x) < minTimestamp:
timestamps.append(str(minTimestamp))
# Remove duplicate items
timestamps = list(set(timestamps))
counter = 0
for value in timestamps:
# TODO: 1231 will be modified if we recreate tiles for some layers
day = '1231'
# Example
if timestamps[counter] == '1938':
day = '1231'
timestamps[counter] = int(str(str(timestamps[counter])+day))
counter = counter+1
timestamps.sort()
counter = 0
for value in timestamps:
timestamps[counter] = str(timestamps[counter])
counter = counter+1
myjson = json_dumps(timestamps)
response.headers['Cache-Control'] = 'no-cache'
if 'cb' in request.params:
response.headers['Content-Type'] = 'text/javascript; charset=utf-8'
return request.params['cb'] + '(' + myjson + ');'
else:
response.headers['Content-Type'] = 'application/json'
return myjson
def index(self):
# if a list of layers was provided the first layer in the
# list will be taken
layer = c.layers[0]
features = []
urlContent = request.url.split("?")
id = urlContent[0].split("/")[len(urlContent[0].split("/")) - 1]
# extended infos
if '.html' in id:
id = id.strip('.html')
ids = id.split(',')
if len(ids) > 1:
innerHtml = ''
for model in models_from_name(layer):
items_nb = len(ids)
item_count = 0
for fid in ids:
feature = Session.query(model).get(fid)
bodlayer = Session.query(self.bodsearch).get(layer)
if feature is not None:
feature.compute_template(layer, bodlayer)
feature.compute_attribute()
c.html_type = 'extended'
c.feature = feature
item_count = item_count + 1
if items_nb == item_count:
c.last = True
else:
c.last = False
innerHtml = innerHtml + render(feature.__template__)
else:
abort(404, 'One of the id you provided is not valid')
feature.html = innerHtml
body_tooltip = render('/tooltips/extended_tooltips.mako')
feature.html = body_tooltip.encode('utf8')
else:
c.last = True
for model in models_from_name(layer):
if len(features) < MAX_FEATURES:
feature = Session.query(model).get(id)
bodlayer = Session.query(self.bodsearch).get(layer)
if feature is not None:
properties = {}
feature.compute_template(layer, bodlayer)
feature.compute_attribute()
properties = feature.attributes
c.html_type = 'extended'
feature.html = render(feature.__template__)
body_tooltip = render('/tooltips/extended_tooltips.mako')
feature.html = body_tooltip.encode('utf8')
if (self.no_geom):
features.append(Feature(id=feature.id,
bbox=feature.geometry.bounds,
properties=feature.attributes))
else:
features.append(feature)
response.headers['Content-Type'] = 'text/html'
return feature.html
else:
abort(404, 'One of the id you provided is not valid')
else:
break
response.headers['Content-Type'] = 'text/html'
return feature.html
# not extended info
for model in models_from_name(layer):
if len(features) < MAX_FEATURES:
feature = Session.query(model).get(id)
if feature:
properties = {}
if self.format =='html':
bodlayer = Session.query(self.bodsearch).get(layer)
feature.compute_template(layer, bodlayer)
c.html_type = 'full'
feature.html = render(feature.__template__)
properties['html'] = feature.html
else:
feature.compute_attribute()
properties = feature.attributes
if (self.no_geom):
features.append(Feature(id=feature.id,
bbox=feature.geometry.bounds,
properties=properties))
else:
features.append(feature)
else:
break
output = simplejson.dumps(FeatureCollection(features), cls=MapFishEncoder)
cb_name = request.params.get('cb')
if cb_name is not None:
response.headers['Content-Type'] = 'text/javascript'
return str(cb_name) + '(' + output + ');'
else:
response.headers['Content-Type'] = 'application/json'
return output
def search(self):
# optional paramater "extent"
# Get current map extent or calculate a 'sensitive' default based on available information (scale !)
extent = request.params.get('extent')
if extent is not None:
try:
extent = map(float, extent.split(','))
except ValueError:
abort(400, "Parameter 'extent' is invalid. Use extent=656430,254350,657930,25585 for instance.")
else:
resolution = 1 / ((1 / (c.scale > 0 or 1000.0)) * 39.3701 * 72)
meters = 300 * resolution
cx, cy = c.bbox[0:2]
extent = (cx - meters, cy - meters, cx + meters, cy + meters)
c.extent = Polygon(((extent[0], extent[1]), (extent[0], extent[3]),
(extent[2], extent[3]), (extent[2], extent[1]),
(extent[0], extent[1])))
c.baseUrl = request.params.get('baseUrl') or ''
# Request features
features = []
layerCounter = 0
for layer_name in c.layers:
layerCounter = layerCounter + 1
for model in models_from_name(layer_name):
geom_filter = model.bbox_filter(c.scale, c.bbox)
if c.timestamps is not None:
time_filter = model.time_filter(c.timestamps[layerCounter-1])
else:
time_filter = None
if geom_filter is not None:
query = Session.query(model).filter(geom_filter)
if time_filter is not None:
query = query.filter(time_filter)
bodlayer = Session.query(self.bodsearch).get(layer_name)
for feature in query.limit(MAX_FEATURES).all():
properties = {}
feature.compute_template(layer_name, bodlayer)
if self.format == 'raw':
feature.compute_attribute()
properties = feature.attributes
properties['html'] = feature.html
properties['layer_id'] = feature.layer_id
properties['preview'] = feature.preview
if (self.no_geom or layer_name == 'ch.kantone.cadastralwebmap-farbe') and 'print' not in request.params:
features.append(Feature(id=feature.id,
bbox=feature.geometry.bounds,
properties=properties))
else:
features.append(feature)
# Send features back
if 'print' in request.params:
c.features = features
return render('/tooltips/_print.mako')
else:
output = simplejson.dumps(FeatureCollection(features), cls=MapFishEncoder)
cb_name = request.params.get('cb')
if cb_name is not None:
response.headers['Content-Type'] = 'text/javascript'
return str(cb_name) + '(' + output + ');'
else:
response.headers['Content-Type'] = 'application/json'
return output
def index(self):
q = request.params.get('query')
egid = request.params.get('egid')
if q is None:
if egid is None:
abort(400, "missing 'query' or 'egid' parameter")
# layers are used for the advanced search
layers = request.params.get('layers')
if layers is not None and len(layers) > 0:
layers = layers.split(',')
else:
layers = None
bfsnr = request.params.get('bfsnr')
if bfsnr is None:
bfsnr = request.params.get('citynr')
onlyOneTerm = False
if egid is not None:
query = Session.query(SwissSearch).filter(SwissSearch.egid == '' + egid)
ftsOrderBy = "egid"
else:
# order addresses by 1/gid instead of similarity, addresses (gid) are sorted in import table by house number, street etc.
# otherwise limit 20 is truncating important results (e.g. Kirchweg Glis -> there is no kirchweg 11 or kirchweg 15)
ftsOrderBy = "rank asc, CASE WHEN origin = 'address' THEN 1/gid::float WHEN origin = 'parcel' THEN 1/SUBSTRING(name FROM '([0-9]+)')::float ELSE similarity(search_name,'%(query)s') END desc" % {'query': q.replace("'","''").replace('"','\"') }
terms = q.split()
if len(terms) == 1:
onlyOneTerm = True
terms1 = ' & '.join([term + ('' if term.isdigit() else ':*') for term in terms])
tsvector = 'to_tsvector(\'english\',search_name)'
terms1 = terms1.replace("'", "''").replace('"', '\"')
ftsFilter = "%(tsvector)s @@ to_tsquery('english', remove_accents('%(terms1)s'))" %{'tsvector': tsvector, 'terms1': terms1}
query = Session.query(SwissSearch).filter(ftsFilter)
# Try to optimize search if initial search doesn't return something. It results in an additional query
# Remove all numbers with more than 3 characters (in order to solve the postcode issue)
if query.count() == 0:
terms2 = ' '.join([('' if term.isdigit() and len(term) > 3 else term+('' if term.isdigit() else ':*')) for term in terms])
terms2 = terms2.split()
if len(terms2) == 1:
onlyOneTerm = True
terms2 = ' & '.join([term for term in terms2])
terms2 = terms2.replace("'", "''").replace('"', '\"')
ftsFilter = "%(tsvector)s @@ to_tsquery('english', remove_accents('%(terms2)s'))" %{'tsvector': tsvector, 'terms2': terms2}
query = Session.query(SwissSearch).filter(ftsFilter)
# Remove all strings starting with a number
if query.count() == 0:
terms3 = ' '.join([('' if term[0].isdigit() else term+('' if term.isdigit() else ':*')) for term in terms])
terms3 = terms3.split()
if len(terms3) == 1:
onlyOneTerm = True
terms3 = ' & '.join([term for term in terms3])
terms3 = terms3.replace("'", "''").replace('"', '\"')
ftsFilter = "%(tsvector)s @@ to_tsquery('english', remove_accents('%(terms3)s'))" %{'tsvector': tsvector, 'terms3': terms3}
query = Session.query(SwissSearch).filter(ftsFilter)
# If only one search term is used, this can't be a parcel or an address
if onlyOneTerm:
query = query.filter(SwissSearch.origin != 'parcel')
# FIXME Address search is only for some allowed referers (see list in production.ini.in)
# For "awk.ch", see email from lttsb from 18.nov. 2011
# cadastre.ch see ticket #3695
# rollstuhlparkplatz.ch see ticket #3846
referer = request.headers.get('referer', '')
allowed_referers = config['address_search_referers'].split(',')
if not any([ref in referer for ref in allowed_referers]):
if not self.no_geom:
self.origins = [o for o in self.origins if o != 'address']
query = query.filter(SwissSearch.origin.in_(self.origins))
if bfsnr is not None:
query = query.filter(SwissSearch.bfsnr == '' + bfsnr)
maxFeaturesGeocoding = MAX_FEATURES_GEOCODING
if layers:
maxFeaturesGeocoding = MAX_FEATURES_GEOCODING - 10
features = list(query_features(self.lang, layers, q))
allfeatures = list(self.getLayerFeatures(features))
query = query.order_by(ftsOrderBy).limit(maxFeaturesGeocoding)
if self.rawjson:
if layers:
return FeatureCollection(allfeatures.append(self.getRawFeatures(query)))
else:
return FeatureCollection(list(self.getRawFeatures(query)))
else:
# Put in the good order...
allfeatures = query.all()
if layers:
allfeatures += features
return {'results': [f.json(rawjson=False, nogeom=self.no_geom) for f in allfeatures]}
def index(self, id=None):
##----------------------------------------Session----------------------------------------##
# Define which view are taken into account
if self.mode in ['all','legend','bodsearch','preview','mobile']:
query = Session.query(self.BodLayer)
# Global variable defined in the config files
Geodata_staging = config['geodata_staging'].split(',')
# Query only view_bod_wmts_getcapabilities_{lang}
elif self.mode == 'wmts':
query = Session.query(self.GetCap)
self.BodLayer = self.GetCap
# random variable so that no filter is applied
Geodata_staging = ['geodata_staging']
else:
abort(400, 'The parameter provided for mode is not valid')
##----------------------------------------Properties----------------------------------------##
# Per default all the properties are returned
properties = request.params.get('properties','all')
if properties == 'all':
# Create a list with all the properties
properties = []
# Create a list with all the properties of the selected table(s)
for key in self.map_properties.keys():
# Populate the list of the properties with all the available keys
properties.append(key)
else:
properties = properties.split(',')
# Check if the property exists
for prop in properties:
if prop not in self.map_properties.keys():
abort(400, 'The property(-ies) you provided is not valid')
if not isinstance(properties,list):
abort(400, 'An error occured while parsing the properties')
##----------------------------------------Project----------------------------------------##
# Per default the project api is selected
if self.mode == 'legend':
project = ['all']
else:
project = request.params.get('project','api')
project = project.split(',')
if not isinstance(project,list):
abort(400, 'An error occured while parsing the projects')
##----------------------------------------Layer_id----------------------------------------##
if id is None:
# Per default all layers are taken into account
layer_id = request.params.get('layer','all')
layer_id = layer_id.split(',')
if not isinstance(layer_id,list):
abort(400, 'An error occured while parsing the layer Id(s)')
else:
layer_id = id
layer_id = layer_id.split(',')
if not isinstance(layer_id,list):
abort(400, 'An error occured while parsing the layer Id(s)')
##----------------------------------------SecureWMTS----------------------------------------##
# This parameter is only used in mode = wmts
##----------------------------------------QueryString----------------------------------------##
# Per default no query string are applied
query_string = request.params.get('query')
##----------------------------------------Filters----------------------------------------##
# Filter by staging attribute
# If one if these 3 layers are in the list do not filter by staging mode
if 'ch.swisstopo.pixelkarte-farbe' in layer_id or 'ch.swisstopo.pixelkarte-grau' in layer_id or 'ch.swisstopo.tml3d-hintergrund-karte' in layer_id and self.mode == 'legend':
pass
elif self.mode in ['all','legend','bodsearch','preview','mobile']:
if 'integration' in Geodata_staging:
query = query.filter(or_(self.BodLayer.staging == 'integration', self.BodLayer.staging == 'prod'))
elif 'prod' in Geodata_staging:
query = query.filter(self.BodLayer.staging == 'prod')
if self.mode in ['bodsearch']:
query = query.filter(self.BodLayer.bodsearch == 'true')
# Filter by layer_id
if layer_id[0] != 'all':
list_layers = []
for l_id in layer_id:
list_layers.append(self.BodLayer.bod_layer_id == l_id)
query = query.filter(or_(*list_layers))
# Filter by project
if project[0] != 'all':
list_projects = []
for proj in project:
list_projects.append(self.BodLayer.projekte.ilike('%%%s%%' % proj))
query = query.filter(or_(*list_projects))
# Filter by query string
if query_string is not None:
columns = []
# Iterate on the properties we are intrested in
for prop in properties:
columns.append(column_from_name(prop, self.map_properties).ilike('%%%s%%' % query_string))
# Full text search
query = query.filter(or_(*columns))
##----------------------------------------ResultsPreparation----------------------------------------##
if self.mode == 'bodsearch':
if query_string is None:
abort(400, 'Please provide a query parameter')
# Order the results
query = query.order_by(self.BodLayer.kurzbezeichnung).order_by(self.BodLayer.bezeichnung).order_by(self.BodLayer.geobasisdatensatz_name)
results = [r.json(query_string) for r in query]
elif self.mode == 'legend':
c.host = request.params.get('h', '%s://api.geo.admin.ch' % c.scheme)
c.full = True
c.hilight = ''
for r in query:
c.layer = r
c.legend = r
# If value in bod.dataset.datenstand == bgdi_created, return the most recent date of the data table
if c.legend.datenstand == 'bgdi_created':
for model in models_from_name(c.layer.bod_layer_id):
modified = Session.query(func.max(model.bgdi_created))
c.legend.datenstand = modified.first()[0].strftime("%Y%m%d")
elif self.mode == 'mobile':
results = [r.json(query_string) for r in query]
elif self.mode == 'wmts':
c.layers = query
c.themes = Session.query(self.GetCapThemes).all()
# Per default the parameter secure wmts is set to false
c.is_swisstopowmts = False
c.service_metadata = Session.query(self.ServiceMetadata).filter(self.ServiceMetadata.pk_map_name.like('%wmts-bgdi%')).first()
request_uri = request.environ.get("REQUEST_URI", "")
if request_uri.find("1.0.0"): # new bucket WMTS
c.onlineressource = "%s://wmts.geo.admin.ch" % c.scheme
else:
c.onlineressource = "%s://api.geo.admin.ch/wmts" % c.scheme
elif self.mode == 'all':
results = [q.layers_results(properties) for q in query]
elif self.mode == 'preview':
result = [q.layers_results(['bod_layer_id']) for q in query]
##----------------------------------------Results----------------------------------------##
cb_name = request.params.get('cb')
print_legend = request.params.get('print', False)
#self.format = request.params.get('format','json')
if self.mode == 'bodsearch' or self.mode == 'mobile':
if cb_name is not None:
response.headers['Content-Type'] = 'text/javascript'
results = simplejson.dumps({"results": results})
return str(cb_name) + '(' + results + ');'
else:
response.headers['Content-Type'] = 'application/json'
return simplejson.dumps({'results': results})
elif self.mode == 'legend':
# Query only one layer at a time in legend mode
if len(layer_id) != 1 or layer_id[0] == 'all':
abort(400, "Please provide only one layer at a time")
if not hasattr(c, 'layer'):
abort(400, "The parameters you provided didn't return any layer")
if print_legend == "true":
return render('/bod-details-print.mako')
else:
response.headers['Content-Type'] = 'text/javascript'
results = simplejson.dumps(render('/bod-details.mako'))
if cb_name is not None:
return str(cb_name) + '(' + results + ');'
else:
return results
elif self.mode == 'wmts':
response.headers['Content-Type'] = 'text/xml'
response.headers['Pragma'] = 'public'
response.headers['Expires'] = '0'
response.headers['Cache-Control'] = 'no-cache'
response.charset = 'utf-8'
return render('/WMTSCapabilities.mako')
elif self.mode == 'all':
if cb_name is not None:
response.headers['Content-Type'] = 'text/javascript'
results = simplejson.dumps({"results": results})
return str(cb_name) + '(' + results + ');'
else:
response.headers['Content-Type'] = 'application/json'
return simplejson.dumps({'results': results})
elif self.mode == 'preview':
c.layers = []
for object in result:
for id,bodLayerId in object.iteritems():
if bodLayerId not in c.layers:
c.layers.append(bodLayerId)
response.headers['Content-Type'] = mimetypes.types_map['.html']
response.charset = 'utf8'
map_width = request.params.get('width',250)
c.map_width = map_width
return render('/layersPreview.mako')
