def _get_feature_info_for_popup(request, params, isExtended=False, isIframe=False):
feature, vector_model = next(_get_features(params))
layerModel = get_bod_model(params.lang)
# TODO Remove this ugly hack
layer = next(get_layers_metadata_for_params(
params,
request.db.query(layerModel),
layerModel,
layerIds=[params.layerId if params.layerId != 'ch.bfs.gebaeude_wohnungs_register_preview' else 'ch.bfs.gebaeude_wohnungs_register']
))
options = {}
if 'feature' in feature:
options.update(feature.pop('feature'))
else:
options.update(feature)
# Regular html popup don't return a geometry
if 'properties' in options:
if hasattr(options, 'extra'):
options['properties'].update(options['properties'].extra)
options['bbox'] = options.extra['bbox']
options['attributes'] = options.pop('properties')
options.update({
'featureId': options.get('featureId') or options.get('id'), # For grid layer
'attributes': options['attributes'],
'scale': options.get('scale'),
'attribution': layer.get('attributes')['dataOwner'],
'fullName': layer.get('fullName'),
'vector_model': vector_model,
'isExtended': isExtended,
'isIframe': isIframe
})
return options
def legend(request):
params = LayersParams(request)
layerId = request.matchdict.get('layerId')
model = get_bod_model(params.lang)
query = params.request.db.query(model)
layerMetadata = next(get_layers_metadata_for_params(
params,
query,
model,
layerIds=[layerId]
))
# FIXME datenstand if not defined
# should be available in view_bod_layer_info
if 'attributes' in layerMetadata:
if 'dataStatus' in layerMetadata['attributes']:
status = layerMetadata['attributes']['dataStatus']
if status == u'bgdi_created':
layerMetadata['attributes']['dataStatus'] = params.translate('None') + params.translate('Datenstand')
legend = {
'layer': layerMetadata,
'hasLegend': _has_legend(layerId, params.lang)
}
response = render_to_response(
'chsdi:templates/legend.mako',
{'legend': legend},
request=request
)
if params.cbName is None:
return response
return response.body
def _identify(request):
params = _get_features_params(request)
if params.layers == 'all':
model = get_bod_model(params.lang)
query = params.request.db.query(model)
layerIds = []
for layer in get_layers_metadata_for_params(params, query, model):
layerIds.append(layer['layerBodId'])
else:
layerIds = params.layers
models = [
models_from_name(layerId) for layerId in layerIds
if models_from_name(layerId) is not None
]
if models is None:
raise exc.HTTPBadRequest('No GeoTable was found for %s' %
' '.join(layerIds))
maxFeatures = 50
features = []
for feature in _get_features_for_extent(params,
models,
maxFeatures=maxFeatures):
f = _process_feature(feature, params)
features.append(f)
if len(features) > maxFeatures:
break
return {'results': features}
def _identify(request):
params = FeaturesParams(request)
if params.layers == 'all':
model = get_bod_model(params.lang)
query = params.request.db.query(model)
layerIds = []
for layer in _get_layers_metadata_for_params(params, query, model):
layerIds.append(layer['idBod'])
else:
layerIds = params.layers
models = [
models_from_name(layerId) for
layerId in layerIds
if models_from_name(layerId) is not None
]
if models is None:
raise exc.HTTPBadRequest('No GeoTable was found for %s' % ' '.join(layerIds))
maxFeatures = 50
features = []
for feature in _get_features_for_extent(params, models, maxFeatures=maxFeatures):
f = feature.__geo_interface__ if params.returnGeometry else feature.__interface__
if hasattr(f, 'extra'):
layerBodId = f.extra['layerBodId']
f.extra['layerName'] = params.translate(layerBodId)
else:
layerBodId = f.get('layerBodId')
f['layerName'] = params.translate(layerBodId)
features.append(f)
if len(features) > maxFeatures:
break
return {'results': features}
def _identify(request):
params = _get_features_params(request)
if params.layers == 'all':
model = get_bod_model(params.lang)
query = params.request.db.query(model)
layerIds = []
for layer in get_layers_metadata_for_params(params, query, model):
layerIds.append(layer['layerBodId'])
else:
layerIds = params.layers
models = [
models_from_name(layerId) for
layerId in layerIds
if models_from_name(layerId) is not None
]
if models is None:
raise exc.HTTPBadRequest('No GeoTable was found for %s' % ' '.join(layerIds))
maxFeatures = 50
features = []
for feature in _get_features_for_extent(params, models, maxFeatures=maxFeatures):
f = _process_feature(feature, params)
features.append(f)
if len(features) > maxFeatures:
break
return {'results': features}
def legend(request):
params = LayersParams(request)
layerId = request.matchdict.get('layerId')
model = get_bod_model(params.lang)
query = params.request.db.query(model)
layerMetadata = next(get_layers_metadata_for_params(
params,
query,
model,
layerIds=[layerId]
))
# FIXME datenstand if not defined
# should be available in view_bod_layer_info
if 'attributes' in layerMetadata:
if 'dataStatus' in layerMetadata['attributes']:
status = layerMetadata['attributes']['dataStatus']
if status == u'bgdi_created':
layerMetadata['attributes']['dataStatus'] = params.translate('None') + params.translate('Datenstand')
legend = {
'layer': layerMetadata,
'hasLegend': _has_legend(layerId, params.lang)
}
response = render_to_response(
'chsdi:templates/legend.mako',
{'legend': legend},
request=request
)
if params.cbName is None:
return response
return response.body
def extendedhtmlpopup(request):
params = FeatureParams(request)
params.returnGeometry = False
models = models_from_name(params.layerId)
if models is None:
raise exc.HTTPBadRequest('No Vector Table was found for %s' % params.layerId)
feature, template, hasExtendedInfo = _get_feature(
params,
models,
params.layerId,
params.featureId,
extended=True)
modelLayer = get_bod_model(params.lang)
layer = next(_get_layers_metadata_for_params(
params,
request.db.query(modelLayer),
modelLayer,
layerIds=[params.layerId]
))
feature.update({'attribution': layer.get('attributes')['dataOwner']})
feature.update({'fullName': layer.get('fullName')})
feature.update({'extended': True})
response = render_to_response(
template,
{
'feature': feature,
'hasExtendedInfo': hasExtendedInfo
},
request=request)
if params.cbName is None:
return response
return response.body
def metadata(self):
model = get_bod_model(self.lang)
results = computeHeader(self.mapName)
query = self.request.db.query(model).filter(model.maps.ilike('%%%s%%' % self.mapName))
query = self._geodata_staging_filter(query, model.staging)
query = self._full_text_search(query, [model.fullTextSearch])
layers = [layer.layerMetadata() for layer in query]
results['layers'].append(layers)
return results
def _get_layer_list_from_map(self):
model = get_bod_model(self.lang)
query = self.request.db.query(model)
query = self._map_name_filter(query, model.maps)
# only return layers which have geometries
layerList = [
q.idBod for
q in query
if models_from_name(q.idBod) is not None
]
return layerList
def metadata(request):
params = LayersParams(request)
model = get_bod_model(params.lang)
query = params.request.db.query(model)
query = _filter_on_chargeable_attr(params, query, model)
if params.searchText is not None:
query = full_text_search(query, [model.fullTextSearch, model.layerBodId, model.idGeoCat], params.searchText)
results = computeHeader(params.mapName)
for layer in get_layers_metadata_for_params(params, query, model):
results["layers"].append(layer)
return results
def _get_layer_list_from_map(self):
model = get_bod_model(self.lang)
query = self.request.db.query(model).filter(
model.maps.ilike('%%%s%%' % self.mapName)
)
# only return layers which have a model
layerList = [
q.idBod for
q in query
if models_from_name(q.idBod) is not None
]
return layerList
def _identify(request):
params = IdentifyServiceValidation(request)
response = {'results': []}
# Determine layer types
# Grid layers are serverless
layersDB = []
layersGrid = []
isScaleDependent = has_buffer(params.imageDisplay, params.mapExtent,
params.tolerance)
scale = get_scale(params.imageDisplay,
params.mapExtent) if isScaleDependent else None
if params.layers == 'all':
model = get_bod_model(params.lang)
query = params.request.db.query(model)
for layer in get_layers_metadata_for_params(params, query, model):
layerBodId = layer['layerBodId']
models = models_from_bodid(layerBodId,
scale=scale,
srid=params.srid)
if models:
layersDB.append({layerBodId: models})
else:
gridSpec = get_grid_spec(layerBodId)
if gridSpec and params.geometryType == 'esriGeometryPoint':
layersGrid.append({layerBodId: gridSpec})
else:
for layerBodId in params.layers:
gridSpec = get_grid_spec(layerBodId)
if gridSpec:
if params.geometryType not in ('esriGeometryPoint',
'esriGeometryEnvelope'):
raise exc.HTTPBadRequest(
'Only esriGeometryPoint or esriGeometryEnvelope'
'are supported for geometryType parameter for grid like data'
)
layersGrid.append({layerBodId: gridSpec})
else:
models = models_from_bodid(layerBodId,
scale=scale,
srid=params.srid)
# The layer has a model but not at the right scale
if models is not None and len(models) == 0:
return response
# There is no model for this layer
elif models is None:
raise exc.HTTPBadRequest('No GeoTable was found for %s' %
layerBodId)
layersDB.append({layerBodId: models})
featuresGrid = _identify_grid(params, layersGrid)
featuresDB = _identify_db(params, layersDB)
response['results'] = featuresGrid + featuresDB
return response
def metadata(request):
params = BaseLayersValidation(request)
model = get_bod_model(params.lang)
query = params.request.db.query(model)
query = _filter_on_chargeable_attr(params, query, model)
if params.searchText is not None:
query = full_text_search(
query, [model.fullTextSearch, model.layerBodId, model.idGeoCat],
params.searchText)
results = computeHeader(params.mapName, params.srid)
for layer in get_layers_metadata_for_params(params, query, model):
results['layers'].append(layer)
return results
def getlegend(self):
from pyramid.renderers import render_to_response
idlayer = self.request.matchdict.get('idlayer')
model = get_bod_model(self.lang)
query = self.request.db.query(model).filter(model.maps.ilike('%%%s%%' % self.mapName))
query = query.filter(model.idBod==idlayer)
for layer in query:
legend = {'layer': layer.layerMetadata()}
response = render_to_response('chsdi:templates/legend.mako', legend, request = self.request)
if self.cbName is None:
return response
else:
return response.body
def mapservice(self):
model = get_bod_model(self.lang)
results = computeHeader(self.mapName)
query = self.request.db.query(model)
query = self._map_name_filter(query, model.maps)
query = self._geodata_staging_filter(query, model.staging)
query = self._full_text_search(query, [
model.fullTextSearch,
model.idBod,
model.idGeoCat
])
for q in query:
layer = q.layerMetadata()
results['layers'].append(layer)
return results
def _get_layer_resource(self, idlayer):
model = get_bod_model(self.lang)
query = self.request.db.query(model)
query = self._map_name_filter(query, model.maps)
query = query.filter(model.idBod == idlayer)
try:
layer = query.one()
except NoResultFound:
raise exc.HTTPNotFound('No layer with id %s' % idlayer)
except MultipleResultsFound:
raise exc.HTTPInternalServerError()
layer = layer.layerMetadata()
return layer
def legend(request):
params = LayersParams(request)
layerId = request.matchdict.get("layerId")
model = get_bod_model(params.lang)
query = params.request.db.query(model)
layerMetadata = next(get_layers_metadata_for_params(params, query, model, layerIds=[layerId]))
# FIXME datenstand if not defined
# should be available in view_bod_layer_info
if "attributes" in layerMetadata:
if "dataStatus" in layerMetadata["attributes"]:
status = layerMetadata["attributes"]["dataStatus"]
if status == u"bgdi_created":
layerMetadata["attributes"]["dataStatus"] = params.translate("None") + params.translate("Datenstand")
legend = {"layer": layerMetadata, "hasLegend": _has_legend(layerId, params.lang)}
response = render_to_response("chsdi:templates/legend.mako", {"legend": legend}, request=request)
if params.cbName is None:
return response
return response.body
def _get_feature_info_for_popup(request,
params,
isExtended=False,
isIframe=False):
feature, vector_model = next(_get_features(params))
layerModel = get_bod_model(params.lang)
# TODO Remove this ugly hack
layer = next(
get_layers_metadata_for_params(
params,
request.db.query(layerModel),
layerModel,
layerIds=[
params.layerId if
params.layerId != 'ch.bfs.gebaeude_wohnungs_register_preview'
else 'ch.bfs.gebaeude_wohnungs_register'
]))
options = {}
if 'feature' in feature:
options.update(feature.pop('feature'))
else:
options.update(feature)
# Regular html popup don't return a geometry
if 'properties' in options:
if hasattr(options, 'extra'):
options['properties'].update(options['properties'].extra)
options['bbox'] = options.extra['bbox']
options['attributes'] = options.pop('properties')
options.update({
'featureId': options.get('featureId')
or options.get('id'), # For grid layer
'attributes': options['attributes'],
'scale': options.get('scale'),
'attribution': layer.get('attributes')['dataOwner'],
'fullName': layer.get('fullName'),
'vector_model': vector_model,
'isExtended': isExtended,
'isIframe': isIframe,
'time': params.time
})
return options
def _identify(request):
params = IdentifyServiceValidation(request)
response = {'results': []}
# Determine layer types
# Grid layers are serverless
layersDB = []
layersGrid = []
isScaleDependent = has_buffer(params.imageDisplay, params.mapExtent, params.tolerance)
scale = get_scale(params.imageDisplay, params.mapExtent) if isScaleDependent else None
if params.layers == 'all':
model = get_bod_model(params.lang)
query = params.request.db.query(model)
for layer in get_layers_metadata_for_params(params, query, model):
layerBodId = layer['layerBodId']
models = models_from_bodid(layerBodId, scale=scale, srid=params.srid)
if models:
layersDB.append({layerBodId: models})
else:
gridSpec = get_grid_spec(layerBodId)
if gridSpec and params.geometryType == 'esriGeometryPoint':
layersGrid.append({layerBodId: gridSpec})
else:
for layerBodId in params.layers:
gridSpec = get_grid_spec(layerBodId)
if gridSpec:
if params.geometryType not in ('esriGeometryPoint', 'esriGeometryEnvelope'):
raise exc.HTTPBadRequest(
'Only esriGeometryPoint or esriGeometryEnvelope'
'are supported for geometryType parameter for grid like data')
layersGrid.append({layerBodId: gridSpec})
else:
models = models_from_bodid(layerBodId, scale=scale, srid=params.srid)
# The layer has a model but not at the right scale
if models is not None and len(models) == 0:
return response
# There is no model for this layer
elif models is None:
raise exc.HTTPBadRequest('No GeoTable was found for %s' % layerBodId)
layersDB.append({layerBodId: models})
featuresGrid = _identify_grid(params, layersGrid)
featuresDB = _identify_db(params, layersDB)
response['results'] = featuresGrid + featuresDB
return response
def _identify(request):
params = _get_features_params(request)
if params.layers == 'all':
model = get_bod_model(params.lang)
query = params.request.db.query(model)
layerIds = []
for layer in get_layers_metadata_for_params(params, query, model):
layerIds.append(layer['layerBodId'])
else:
layerIds = params.layers
models = [
models_from_bodid(layerId) for layerId in layerIds
if models_from_bodid(layerId) is not None
]
if models is None:
raise exc.HTTPBadRequest('No GeoTable was found for %s' %
' '.join(layerIds))
maxFeatures = 201
features = []
feature_gen = _get_features_for_filters(params,
models,
maxFeatures=maxFeatures,
where=params.where)
while True:
try:
feature = next(feature_gen)
except InternalError as e:
raise exc.HTTPBadRequest(
'Your request generated the following database error: %s' % e)
except StopIteration:
break
else:
f = _process_feature(feature, params)
features.append(f)
if len(features) >= maxFeatures:
break
return {'results': features}
def extendedhtmlpopup(request):
params = _get_feature_params(request)
params.returnGeometry = True
feature, vectorModel = next(_get_features(params))
layerModel = get_bod_model(params.lang)
layer = next(
get_layers_metadata_for_params(params,
request.db.query(layerModel),
layerModel,
layerIds=[params.layerId]))
feature.update({'attribution': layer.get('attributes')['dataOwner']})
feature.update({'fullName': layer.get('fullName')})
feature.update({'extended': True})
response = _render_feature_template(vectorModel, feature, request, True)
if params.cbName is None:
return response
return response.body
def extendedhtmlpopup(request):
params = _get_feature_params(request)
params.returnGeometry = True
feature, vectorModel = next(_get_features(params))
layerModel = get_bod_model(params.lang)
layer = next(get_layers_metadata_for_params(
params,
request.db.query(layerModel),
layerModel,
layerIds=[params.layerId]
))
feature.update({'attribution': layer.get('attributes')['dataOwner']})
feature.update({'fullName': layer.get('fullName')})
feature.update({'extended': True})
response = _render_feature_template(vectorModel, feature, request, True)
if params.cbName is None:
return response
return response.body
def _identify(request):
params = _get_features_params(request)
if params.layers == 'all':
model = get_bod_model(params.lang)
query = params.request.db.query(model)
layerIds = []
for layer in get_layers_metadata_for_params(params, query, model):
layerIds.append(layer['layerBodId'])
else:
layerIds = params.layers
models = [
models_from_bodid(layerId) for
layerId in layerIds
if models_from_bodid(layerId) is not None
]
if models is None:
raise exc.HTTPBadRequest('No GeoTable was found for %s' % ' '.join(layerIds))
maxFeatures = 201
features = []
feature_gen = _get_features_for_filters(params, models, maxFeatures=maxFeatures, where=params.where)
while True:
try:
feature = next(feature_gen)
except InternalError as e:
raise exc.HTTPBadRequest('Your request generated the following database error: %s' % e)
except StopIteration:
break
else:
f = _process_feature(feature, params)
features.append(f)
if len(features) >= maxFeatures:
break
return {'results': features}
def legend(request):
params = LayersParams(request)
layerId = request.matchdict.get('layerId')
model = get_bod_model(params.lang)
layerMetadata = next(
_get_layers_metadata_for_params(
params,
params.request.db.query(model),
model,
layerIds=[layerId]
))
legends_dir = os.path.join(os.path.dirname(__file__), '../static/images/legends')
image = "%s_%s.png" % (layerId, params.lang)
image_full_path = os.path.abspath(os.path.join(legends_dir, image))
hasLegend = os.path.exists(image_full_path)
# FIXME datenstand if not defined
# should be available in view_bod_layer_info
if 'attributes' in layerMetadata.keys():
if 'dataStatus' in layerMetadata['attributes'].keys():
status = layerMetadata['attributes']['dataStatus']
if status == u'bgdi_created':
layerMetadata['attributes']['dataStatus'] = params.translate('None') + params.translate('Datenstand')
legend = {
'layer': layerMetadata,
'hasLegend': hasLegend
}
response = render_to_response(
'chsdi:templates/legend.mako',
{
'legend': legend
},
request=request
)
if params.cbName is None:
return response
return response.body
