def create(self, user_token, layer):
from gbi_server.model import User
user = User.by_authproxy_token(user_token)
if not user:
raise InvalidUserToken()
result = db.session.query(WMTS, WMTS.view_coverage.transform(3857).wkt()).filter_by(name=layer).first()
if result:
wmts, view_coverage = result
if wmts and wmts.is_public:
return wkt.loads(view_coverage)
if user.is_customer:
couch_url = self.couchdb_url
couchdb = CouchDBBox(couch_url, '%s_%s' % (SystemConfig.AREA_BOX_NAME, user.id))
geom = couchdb.layer_extent(self.geometry_layer)
return optimize_geometry(geom) if geom else None
elif user.is_service_provider:
couch_url = self.couchdb_url
couchdb = CouchDBBox(couch_url, '%s_%s' % (SystemConfig.AREA_BOX_NAME, user.id))
geom = couchdb.layer_extent()
return optimize_geometry(geom) if geom else None
elif user.is_admin or user.is_consultant:
# permit access to everything
return box(-20037508.3428, -20037508.3428, 20037508.3428, 20037508.3428)
return None
def write_back(layer=None, ajax=True):
user = current_user
connection = psycopg2.connect(
database=current_app.config.get('TEMP_PG_DB'),
host=current_app.config.get('TEMP_PG_HOST'),
user=current_app.config.get('TEMP_PG_USER'),
password=current_app.config.get('TEMP_PG_PASSWORD'),
sslmode='allow',
)
couch = CouchDBBox(current_app.config.get('COUCH_DB_URL'), '%s_%s' % (SystemConfig.AREA_BOX_NAME, user.id))
schema = couch.layer_schema(layer)
extend_schema_for_couchdb(schema)
tablename = 'tmp%s%s' % (user.id, layer)
tmp_db = TempPGDB(connection=connection, tablename=tablename, schema=schema)
couch.store_features(layer, tmp_db.load_features(), delete_missing=tmp_db.imported_feature_ids())
connection.close()
# write changes back to PostGIS to prevent multiple inserts
create_wfs(user, [layer])
signals.features_updated.send(user)
if ajax:
return Response(response='success', status=200, headers=None, mimetype='application/json', content_type=None)
def wmts():
couch = CouchDBBox(current_app.config.get('COUCH_DB_URL'), '%s_%s' % (SystemConfig.AREA_BOX_NAME, current_user.id))
vector_layers = []
couch_layers = couch.get_layer_names()
for layer, title in couch_layers:
features = [feature for feature in couch.iter_layer_features(layer) if isinstance(feature['geometry'], dict)]
vector_layers.append({
'name': title,
'features': features,
'readonly': True if layer != current_app.config.get('USER_WORKON_LAYER') else False
})
wmts_layers = WMTS.query.all()
return render_template('maps/map.html', wmts_layers=wmts_layers, vector_layers=vector_layers, user=current_user)
def refresh_florlp():
user = current_user
form = RefreshFlorlpForm(request.form)
if form.validate_on_submit():
layers = [(current_app.config.get('USER_READONLY_LAYER'), current_app.config.get('USER_READONLY_LAYER_TITLE'))]
try:
florlp_session = create_florlp_session(user.florlp_name, form.data['password'])
except FLOrlpUnauthenticated:
flash(_('Invalid florlp password'), 'error')
return render_template("user/refresh_florlp.html", form=form)
try:
schema, feature_collection = latest_flursteuck_features(florlp_session)
finally:
remove_florlp_session(florlp_session)
feature_collection = transform_geojson(from_srs=current_app.config.get('FLORLP_SHP_SRS'), to_srs=3857, geojson=feature_collection)
init_user_boxes(user, current_app.config.get('COUCH_DB_URL'))
couch = CouchDBBox(current_app.config.get('COUCH_DB_URL'), '%s_%s' % (SystemConfig.AREA_BOX_NAME, user.id))
if (not couch.layer_schema(current_app.config.get('USER_WORKON_LAYER')) or not couch.layer_extent(current_app.config.get('USER_WORKON_LAYER'))) and not user.type:
layers.append((current_app.config.get('USER_WORKON_LAYER'), current_app.config.get('USER_WORKON_LAYER_TITLE')))
for layer, title in layers:
couch.clear_layer(layer)
couch.store_layer_schema(layer, schema, title=title)
couch.store_features(layer, feature_collection['features'])
signals.features_updated.send(user, layer=layer)
flash(_('Refreshed florlp data'), 'success')
return redirect(url_for(".index"))
return render_template("user/refresh_florlp.html", form=form)
def wfs_edit():
user = current_user
form = WFSEditForm()
add_layer_form = WFSAddLayerForm()
couch = CouchDBBox(current_app.config.get('COUCH_DB_URL'), '%s_%s' % (SystemConfig.AREA_BOX_NAME, user.id))
if add_layer_form.validate_on_submit():
title = add_layer_form.data.get('new_layer')
layer = re.sub(r'[^a-z0-9]*', '', title.lower())
couch = CouchDBBox(current_app.config.get('COUCH_DB_URL'), '%s_%s' % (SystemConfig.AREA_BOX_NAME, user.id))
schema = tinyows.base_schema()
if couch.layer_schema(layer):
flash(_('Layer %(title)s already exists', title=title), 'error')
else:
couch.store_layer_schema(layer, schema, title=title)
flash(_('Layer %(title)s created', title=title))
form.layer.choices = [(layer, title) for layer, title in couch.get_layer_names() if layer != current_app.config.get('USER_READONLY_LAYER')]
if form.validate_on_submit():
layer = form.data.get('layer', current_app.config.get('USER_WORKON_LAYER'))
if not int(form.data['external_editor']):
return redirect(url_for('.wfs_edit_layer', layer=layer))
else:
return redirect(url_for('.wfs_session', layer=layer))
return render_template('maps/wfs_edit.html', form=form, add_layer_form=add_layer_form, not_removable_layer=current_app.config.get('USER_WORKON_LAYER'))
def new():
form = NewUserForm()
if form.validate_on_submit():
florlp_session = False
user_type = form.data['type']
layers = [(current_app.config.get('USER_READONLY_LAYER'), current_app.config['USER_READONLY_LAYER_TITLE']), (current_app.config.get('USER_WORKON_LAYER'), current_app.config['USER_WORKON_LAYER_TITLE'])]
if user_type == User.Type.CUSTOMER:
try:
florlp_session = create_florlp_session(form.data['florlp_name'], form.data['florlp_password'])
except FLOrlpUnauthenticated:
flash(_('Invalid florlp username/password'), 'error')
return render_template("user/new.html", form=form)
user = User(form.data['email'], form.data['password'])
user.realname = form.data['realname']
user.florlp_name = form.data['florlp_name']
user.type = form.data.get('type')
user.street = form.data['street']
user.housenumber = form.data['housenumber']
user.zipcode = form.data['zipcode']
user.city = form.data['city']
user.active = user_type == User.Type.CUSTOMER
verify = EmailVerification.verify(user)
db.session.add(user)
db.session.add(verify)
db.session.commit()
send_mail(
_("Email verification mail subject"),
render_template("user/verify_mail.txt", user=user, verify=verify, _external=True),
[user.email]
)
couch_url = current_app.config.get('COUCH_DB_URL')
if user.is_service_provider or user.is_customer:
# create couch document and area boxes
# and initialize security
init_user_boxes(user, couch_url)
if florlp_session:
couch = CouchDBBox(couch_url, '%s_%s' % (SystemConfig.AREA_BOX_NAME, user.id))
try:
schema, feature_collection = latest_flursteuck_features(florlp_session)
finally:
remove_florlp_session(florlp_session)
feature_collection = transform_geojson(from_srs=current_app.config.get('FLORLP_SHP_SRS'), to_srs=3857, geojson=feature_collection)
for layer, title in layers:
couch.store_layer_schema(layer, schema, title=title)
couch.store_features(layer, feature_collection['features'])
if user.is_service_provider:
couch = CouchDBBox(couch_url, '%s_%s' % (SystemConfig.AREA_BOX_NAME, user.id))
couch.store_layer_schema(current_app.config['USER_WORKON_LAYER'], florlp.base_schema(), title=current_app.config['USER_WORKON_LAYER_TITLE'])
return redirect(url_for(".verify_wait", id=user.id))
return render_template("user/new.html", form=form, customer_id=User.Type.CUSTOMER)
def wfs_edit_layer(layer=None):
user = current_user
wfs_session = WFSSession.by_active_user_layer(layer, user)
if wfs_session:
flash(_('external edit in progress'))
return redirect(url_for('.wfs_session', layer=layer))
couch = CouchDBBox(current_app.config.get('COUCH_DB_URL'), '%s_%s' % (SystemConfig.AREA_BOX_NAME, user.id))
try:
wfs_layers, wfs_layer_token = create_wfs(user, [current_app.config.get('EXTERNAL_WFS_LAYER'), layer])
except MissingSchemaError:
flash(_('layer unknown or without schema'))
abort(404)
features = [feature for feature in couch.iter_layer_features(current_app.config.get('USER_READONLY_LAYER')) if isinstance(feature['geometry'], dict)]
data_extent = couch.layer_extent(layer)
if not data_extent:
data_extent = couch.layer_extent(current_app.config.get('USER_READONLY_LAYER'))
if not data_extent:
result = db.session.query(WMTS, WMTS.view_coverage.transform(3857).wkt()).order_by(desc(WMTS.is_background_layer)).first()
if result:
data_extent = loads(result[1])
return render_template(
'maps/wfs.html',
wfs=wfs_layers,
layers=WMTS.query.all(),
read_only_features=features,
read_only_schema=couch.layer_schema(layer)['properties'],
read_only_layer_name=current_app.config.get('USER_READONLY_LAYER_TITLE'),
editable_layer=layer,
editable_layer_name=wfs_layers[1]['name'],
search_layer_name=current_app.config.get('EXTERNAL_WFS_NAME'),
search_property=current_app.config.get('EXTERNAL_WFS_SEARCH_PROPERTY'),
search_min_length=current_app.config.get('EXTERNAL_WFS_SEARCH_MIN_LENGTH'),
search_prefix=current_app.config.get('EXTERNAL_WFS_SEARCH_PREFIX'),
data_extent=data_extent.bounds if data_extent else None,
user=current_user
)
def wfs_remove_layer(layer=None):
user = current_user
if layer in [current_app.config.get('USER_READONLY_LAYER'), current_app.config.get('USER_WORKON_LAYER')]:
flash(_('not allowed to remove this layer'))
return redirect(url_for('.wfs_edit'))
wfs_session = WFSSession.by_active_user_layer(layer, user)
if wfs_session:
flash(_('external edit in progress'))
return redirect(url_for('.wfs_session', layer=layer))
couch = CouchDBBox(current_app.config.get('COUCH_DB_URL'), '%s_%s' % (SystemConfig.AREA_BOX_NAME, user.id))
try:
couch.clear_layer(layer)
flash(_('Layer %(layer)s removed', layer=layer))
except CouchDBError:
flash(_('Could not remove layer %(layer)s', layer=layer), 'error')
return redirect(url_for('.wfs_edit'))
def wfs_remove_layer(layer=None):
user = current_user
if layer in [current_app.config.get('USER_READONLY_LAYER'), current_app.config.get('USER_WORKON_LAYER')]:
flash(_('not allowed to remove this layer'))
return redirect(url_for('.wfs_edit'))
wfs_session = WFSSession.by_active_user_layer(layer, user)
if wfs_session:
flash(_('external edit in progress'))
return redirect(url_for('.wfs_session', layer=layer))
couch = CouchDBBox(current_app.config.get('COUCH_DB_URL'), '%s_%s' % (SystemConfig.AREA_BOX_NAME, user.id))
try:
couch.clear_layer(layer)
flash(_('Layer %(layer)s removed', layer=layer))
except CouchDBError:
flash(_('Could not remove layer %(layer)s', layer=layer), 'error')
return redirect(url_for('.wfs_edit'))
def wfs_edit():
user = current_user
form = WFSEditForm()
add_layer_form = WFSAddLayerForm()
couch = CouchDBBox(current_app.config.get('COUCH_DB_URL'), '%s_%s' % (SystemConfig.AREA_BOX_NAME, user.id))
if add_layer_form.validate_on_submit():
title = add_layer_form.data.get('new_layer')
layer = re.sub(r'[^a-z0-9]*', '', title.lower())
couch = CouchDBBox(current_app.config.get('COUCH_DB_URL'), '%s_%s' % (SystemConfig.AREA_BOX_NAME, user.id))
schema = florlp.base_schema()
if couch.layer_schema(layer):
flash(_('Layer %(title)s already exists', title=title), 'error')
else:
couch.store_layer_schema(layer, schema, title=title)
flash(_('Layer %(title)s created', title=title))
form.layer.choices = [(layer, title) for layer, title in couch.get_layer_names() if layer != current_app.config.get('USER_READONLY_LAYER')]
if form.validate_on_submit():
layer = form.data.get('layer', current_app.config.get('USER_WORKON_LAYER'))
if not int(form.data['external_editor']):
return redirect(url_for('.wfs_edit_layer', layer=layer))
else:
return redirect(url_for('.wfs_session', layer=layer))
return render_template('maps/wfs_edit.html', form=form, add_layer_form=add_layer_form, not_removable_layer=current_app.config.get('USER_WORKON_LAYER'))
def wmts():
couch = CouchDBBox(
current_app.config.get('COUCH_DB_URL'),
'%s_%s' % (SystemConfig.AREA_BOX_NAME, current_user.id)
)
features = [feature for feature in couch.iter_features() if isinstance(feature['geometry'], dict)]
vector_layers = []
vector_layers.append({
'name': SystemConfig.AREA_BOX_TITLE,
'features': features,
'readonly': True,
})
wmts_layers = WMTS.query.all()
return render_template(
'maps/map.html',
wmts_layers=wmts_layers,
vector_layers=vector_layers,
user=current_user
)
def write_back(layer=None, ajax=True):
user = current_user
connection = psycopg2.connect(
database=current_app.config.get('TEMP_PG_DB'),
host=current_app.config.get('TEMP_PG_HOST'),
user=current_app.config.get('TEMP_PG_USER'),
password=current_app.config.get('TEMP_PG_PASSWORD'),
sslmode='allow',
)
couch = CouchDBBox(current_app.config.get('COUCH_DB_URL'), '%s_%s' % (SystemConfig.AREA_BOX_NAME, user.id))
schema = couch.layer_schema(layer)
extend_schema_for_couchdb(schema)
tablename = 'tmp%s%s' % (user.id, layer)
tmp_db = TempPGDB(connection=connection, tablename=tablename, schema=schema)
couch.store_features(layer, tmp_db.load_features(), delete_missing=tmp_db.imported_feature_ids())
connection.close()
signals.features_updated.send(user, layer=layer)
if ajax:
return Response(response='success', status=200, headers=None, mimetype='application/json', content_type=None)
def wfs_edit_layer(layer=None):
form = WFSSearchForm()
user = current_user
wfs_session = WFSSession.by_active_user_layer(layer, user)
if wfs_session:
flash(_('external edit in progress'))
return redirect(url_for('.wfs_session', layer=layer))
couch = CouchDBBox(current_app.config.get('COUCH_DB_URL'), '%s_%s' % (SystemConfig.AREA_BOX_NAME, user.id))
try:
wfs_layers, wfs_layer_token = create_wfs(user, editable_layers=[layer])
except MissingSchemaError:
flash(_('layer unknown or without schema'))
abort(404)
features = [feature for feature in couch.iter_layer_features(current_app.config.get('USER_READONLY_LAYER')) if isinstance(feature['geometry'], dict)]
data_extent = couch.layer_extent(layer)
if not data_extent:
data_extent = couch.layer_extent(current_app.config.get('USER_READONLY_LAYER'))
if not data_extent:
result = db.session.query(WMTS, ST_Transform(WMTS.view_coverage, 3857)).order_by(desc(WMTS.is_background_layer)).first()
if result:
data_extent = to_shape(result[1])
titles = dict(couch.get_layer_names())
return render_template(
'maps/wfs.html',
form=form,
wfs=wfs_layers,
layers=WMTS.query.all(),
read_only_features=features,
read_only_schema=couch.layer_schema(layer)['properties'],
read_only_layer_name=current_app.config.get('AREA_BOX_TITLE'),
editable_layer=layer,
editable_layer_title=titles[layer],
data_extent=data_extent.bounds if data_extent else None,
user=current_user
)
def init_couchdb(config):
user = model.User.by_email('*****@*****.**')
init_user_boxes(user, config.get('COUCH_DB_URL'))
couch = CouchDBBox(config.get('COUCH_DB_URL'), '%s_%s' % (SystemConfig.AREA_BOX_NAME, user.id))
layers = [(config.get('USER_READONLY_LAYER'), config.get('USER_READONLY_LAYER_TITLE')), (config.get('USER_WORKON_LAYER'), config.get('USER_WORKON_LAYER_TITLE'))]
print layers
florlp_session = create_florlp_session("demo", "demo")
try:
schema, feature_collection = latest_flursteuck_features(florlp_session)
finally:
remove_florlp_session(florlp_session)
feature_collection = transform_geojson(from_srs=config.get('FLORLP_SHP_SRS'), to_srs=3857, geojson=feature_collection)
for layer, title in layers:
couch.clear_layer(layer)
couch.store_layer_schema(layer, schema, title=title)
couch.store_features(layer, feature_collection['features'])
user = model.User.by_email('*****@*****.**')
init_user_boxes(user, config.get('COUCH_DB_URL'))
def create(self, user_token, layer):
from gbi_server.model import User
from gbi_server.model import WMTS
from gbi_server.extensions import db
user = User.by_authproxy_token(user_token)
if not user:
raise InvalidUserToken()
result = db.session.query(WMTS, ST_Transform(
WMTS.view_coverage, 3857)).filter_by(name=layer).first()
if result:
wmts, view_coverage = result
if wmts and wmts.is_public:
return to_shape(view_coverage)
if user.is_customer:
couch_url = self.couchdb_url
couchdb = CouchDBBox(
couch_url, '%s_%s' % (SystemConfig.AREA_BOX_NAME, user.id))
geom = couchdb.layer_extent(self.geometry_layer)
return optimize_geometry(geom) if geom else None
elif user.is_service_provider:
couch_url = self.couchdb_url
couchdb = CouchDBBox(
couch_url, '%s_%s' % (SystemConfig.AREA_BOX_NAME, user.id))
geom = couchdb.layer_extent()
return optimize_geometry(geom) if geom else None
elif user.is_admin or user.is_consultant:
# permit access to everything
return box(-20037508.3428, -20037508.3428, 20037508.3428,
20037508.3428)
return None
def create_wfs(user=None, editable_layers=None):
connection = psycopg2.connect(
database=current_app.config.get('TEMP_PG_DB'),
host=current_app.config.get('TEMP_PG_HOST'),
user=current_app.config.get('TEMP_PG_USER'),
password=current_app.config.get('TEMP_PG_PASSWORD'),
sslmode='allow',
)
couch = CouchDBBox(current_app.config.get('COUCH_DB_URL'), '%s_%s' % (SystemConfig.AREA_BOX_NAME, user.id))
wfs_layer_token = uuid.uuid4().hex
wfs = []
# create layer to edit
tinyows_layers = []
titles = dict(couch.get_layer_names())
for layer in editable_layers:
wfs_layer = {
'id': id,
'name': titles[layer],
'layer': layer,
'url': url_for('.tinyows_wfs', token=wfs_layer_token, _external=True) + '?',
'srs': 'EPSG:3857',
'geometry_field': 'geometry',
'wfs_version': '1.1.0',
'feature_ns': current_app.config.get('TINYOWS_NS_URI'),
'typename': current_app.config.get('TINYOWS_NS_PREFIX'),
'writable': False,
'display_in_layerswitcher': True,
}
schema = couch.layer_schema(layer)
if not schema or 'properties' not in schema:
raise MissingSchemaError('no schema found for layer %s' % layer)
extend_schema_for_couchdb(schema)
# tinyows layername must not contain underscores
tablename = 'tmp%s%s' % (user.id, layer)
tmp_db = TempPGDB(connection=connection, tablename=tablename, schema=schema)
tmp_db.create_table()
tmp_db.insert_features(couch.iter_layer_features(layer))
# TODO remember created table in new model, store wfs_layer_token
# and remove old tinyows configs on update
wfs_layer['layer'] = tablename
wfs_layer['writable'] = current_app.config.get('USER_READONLY_LAYER') != layer
tinyows_layers.append({
'name': tablename,
'title': wfs_layer['name'],
'writable': '1' if wfs_layer['writable'] else '0',
})
wfs.append(wfs_layer)
connection.commit()
connection.close()
ensure_dir(current_app.config.get('TINYOWS_TMP_CONFIG_DIR'))
tinyows_config = os.path.join(
current_app.config.get('TINYOWS_TMP_CONFIG_DIR'),
wfs_layer_token + '.xml')
tinyows.build_config(current_app, tinyows_layers, wfs_layer_token, tinyows_config)
# wfs_layers for search
wfs_search = db.session.query(WFS).all()
for layer in wfs_search:
wfs.append({
'id': layer.id,
'name': layer.name,
'layer': layer.layer,
'url': layer.url,
'srs': layer.srs,
'geometry_field': layer.geometry,
'wfs_version': '1.1.0',
'feature_ns': layer.ns_uri,
'typename': layer.ns_prefix,
'writable': False,
'search_property': layer.search_property,
'display_in_layerswitcher': False,
})
return wfs, wfs_layer_token
def get_context_document():
sources = db.session.query(WMTS, pg_functions.geojson(WMTS.view_coverage.transform(3857))).order_by(desc(WMTS.is_background_layer)).all()
response = {
"version": "0.1",
"wmts_sources": [],
"couchdb_sources": [],
}
couchdb = CouchDBBox(current_app.config['COUCH_DB_URL'], '%s_%s' % (SystemConfig.AREA_BOX_NAME, g.user.id))
user_geom = couchdb.layer_extent(current_app.config['USER_WORKON_LAYER'])
if user_geom:
user_geom = optimize_geometry(user_geom)
user_geom = shapely.geometry.mapping(user_geom)
for source in sources:
wmts, view_coverage = source
if wmts.is_public:
geom = json.loads(view_coverage)
elif user_geom:
geom = user_geom
else:
continue
response['wmts_sources'].append({
"name": wmts.name,
"title": wmts.title,
"url": url_for('authproxy.tile_proxy', user_token=g.user.authproxy_token, _external=True).rstrip('/') + '/',
"layer": wmts.layer,
"tile_matrix": wmts.matrix_set,
"format": wmts.format,
"baselayer": wmts.is_baselayer,
"overlay": wmts.is_overlay,
"username": wmts.username,
"password": wmts.password,
"srs": wmts.srs,
"view_restriction": {
"zoom_level_start": wmts.view_level_start,
"zoom_level_end": wmts.view_level_end,
"geometry": geom
},
"download_restriction": {
"zoom_level_start": wmts.view_level_start,
"zoom_level_end": wmts.view_level_end,
"geometry": geom
}
})
response['couchdb_sources'].append({
"name": _('area box'),
"url": current_app.config['COUCH_DB_URL'],
"dbname": '%s_%s' % (SystemConfig.AREA_BOX_NAME, g.user.id),
"username": '******' % g.user.id,
"password": g.user.authproxy_token,
"writable": True,
"dbname_user": SystemConfig.AREA_BOX_NAME_LOCAL,
})
response['couchdb_sources'].append({
"name": _('consultant box'),
"url": current_app.config['COUCH_DB_URL'],
"dbname": '%s_%s' % (SystemConfig.CONSULTANT_BOX_NAME, g.user.id),
"username": '******' % g.user.id,
"password": g.user.authproxy_token,
"writable": False,
"dbname_user": SystemConfig.CONSULTANT_BOX_NAME_LOCAL,
})
response['logging'] = {
'url': url_for('logserv.log', user_token=g.user.authproxy_token, _external=True),
}
return json.dumps(response)
def get_context_document():
init_user_boxes(g.user, current_app.config.get('COUCH_DB_URL'))
wmts_sources = db.session.query(
WMTS, ST_AsGeoJSON(ST_Transform(WMTS.view_coverage, 3857))).order_by(
desc(WMTS.is_background_layer)).all()
wms_sources = db.session.query(
WMS, ST_AsGeoJSON(ST_Transform(WMS.view_coverage, 3857))).order_by(
desc(WMS.is_background_layer)).all()
wfs_sources = db.session.query(WFS).all()
response = {
"version": "0.2",
"portal": {
"prefix": current_app.config['PORTAL_PREFIX'],
"title": current_app.config['PORTAL_TITLE'],
},
"wmts_sources": [],
"wms_sources": [],
"wfs_sources": [],
"couchdb_sources": [],
}
couchdb = CouchDBBox(current_app.config['COUCH_DB_URL'],
'%s_%s' % (SystemConfig.AREA_BOX_NAME, g.user.id))
for source in wmts_sources:
wmts, view_coverage = source
geom = json.loads(view_coverage)
response['wmts_sources'].append({
"name": wmts.name,
"title": wmts.title,
"url": wmts.client_url(external=True),
"format": wmts.format,
"overlay": wmts.is_overlay,
"username": wmts.username,
"password": wmts.password,
"is_public": wmts.is_public,
"is_protected": wmts.is_protected,
"is_background_layer": wmts.is_background_layer,
"max_tiles": wmts.max_tiles,
"view_restriction": {
"zoom_level_start": wmts.view_level_start,
"zoom_level_end": wmts.view_level_end,
"geometry": geom
},
"download_restriction": {
"zoom_level_start": wmts.view_level_start,
"zoom_level_end": wmts.view_level_end,
}
})
for source in wms_sources:
wms, view_coverage = source
geom = json.loads(view_coverage)
response['wms_sources'].append({
"name": wms.name,
"title": wms.title,
"url": wms.url,
"layer": wms.layer,
"format": wms.format,
"overlay": wms.is_overlay,
"username": wms.username,
"password": wms.password,
"is_public": wms.is_public,
"is_protected": wms.is_protected,
"srs": wms.srs,
"wms_version": wms.version,
"view_restriction": {
"zoom_level_start": wms.view_level_start,
"zoom_level_end": wms.view_level_end,
"geometry": geom
},
"download_restriction": {
"zoom_level_start": wms.view_level_start,
"zoom_level_end": wms.view_level_end,
}
})
for wfs in wfs_sources:
response['wfs_sources'].append({
'id': wfs.id,
'name': wfs.name,
'layer': wfs.layer,
'host': wfs.host,
'url': wfs.url,
'srs': wfs.srs,
'geometry_field': wfs.geometry,
'feature_ns': wfs.ns_uri,
'typename': wfs.ns_prefix,
'search_property': wfs.search_property,
'username': wfs.username,
'password': wfs.password,
'is_protected': wfs.is_protected,
})
if current_app.config['FEATURE_AREA_BOXES']:
response['couchdb_sources'].append({
"name":
_('area box'),
"url":
current_app.config['COUCH_DB_URL'],
"dbname":
'%s_%s' % (SystemConfig.AREA_BOX_NAME, g.user.id),
"username":
'******' % g.user.id,
"password":
g.user.authproxy_token,
"writable":
True,
"dbname_user":
SystemConfig.AREA_BOX_NAME_LOCAL,
})
if current_app.config['FEATURE_DOC_BOXES']:
if g.user.is_consultant:
response['couchdb_sources'].append({
"name":
_('file box'),
"url":
current_app.config['COUCH_DB_URL'],
"dbname":
'%s_%s' % (SystemConfig.FILE_BOX_NAME, g.user.id),
"username":
'******' % g.user.id,
"password":
g.user.authproxy_token,
"writable":
True,
"dbname_user":
SystemConfig.FILE_BOX_NAME_LOCAL,
})
else:
response['couchdb_sources'].append({
"name":
_('consultant box'),
"url":
current_app.config['COUCH_DB_URL'],
"dbname":
'%s_%s' % (SystemConfig.DOWNLOAD_BOX_NAME, g.user.id),
"username":
'******' % g.user.id,
"password":
g.user.authproxy_token,
"writable":
False,
"dbname_user":
SystemConfig.DOWNLOAD_BOX_NAME_LOCAL,
})
response['couchdb_sources'].append({
"name":
_('uploadbox'),
"url":
current_app.config['COUCH_DB_URL'],
"dbname":
'%s_%s' % (SystemConfig.UPLOAD_BOX_NAME, g.user.id),
"username":
'******' % g.user.id,
"password":
g.user.authproxy_token,
"writable":
True,
"dbname_user":
SystemConfig.UPLOAD_BOX_NAME_LOCAL,
})
if current_app.config['PARCEL_SEARCH_DATABASE_URI']:
response['parcel_search_url'] = url_for('search.query',
token=g.user.authproxy_token,
_external=True)
response['logging'] = {
'url':
url_for('logserv.log',
user_token=g.user.authproxy_token,
_external=True),
}
response['update_coverage'] = {
'url':
url_for('authproxy.update_download_coverage',
user_token=g.user.authproxy_token,
_external=True),
}
response['user'] = {
'email': g.user.email,
'type': g.user.type,
'type_name': g.user.type_name,
}
return json.dumps(response)
def create_wfs(user=None, layers=None):
connection = psycopg2.connect(
database=current_app.config.get('TEMP_PG_DB'),
host=current_app.config.get('TEMP_PG_HOST'),
user=current_app.config.get('TEMP_PG_USER'),
password=current_app.config.get('TEMP_PG_PASSWORD'),
sslmode='allow',
)
couch = CouchDBBox(current_app.config.get('COUCH_DB_URL'), '%s_%s' % (SystemConfig.AREA_BOX_NAME, user.id))
wfs_layer_token = uuid.uuid4().hex
wfs = []
tinyows_layers = []
titles = dict(couch.get_layer_names())
for id, layer in enumerate(layers):
title = titles[layer] if layer in titles else layer
wfs_layer = {
'id': id,
'name': title,
'layer': layer,
'url': url_for('.tinyows_wfs', token=wfs_layer_token, _external=True) + '?',
'srs': 'EPSG:3857',
'geometry_field': 'geometry',
'wfs_version': '1.1.0',
'feature_ns': current_app.config.get('TINYOWS_NS_URI'),
'typename': current_app.config.get('TINYOWS_NS_PREFIX'),
'writable': False,
'display_in_layerswitcher': True,
}
if layer == current_app.config.get('EXTERNAL_WFS_LAYER'):
wfs_layer['name'] = current_app.config.get('EXTERNAL_WFS_NAME')
wfs_layer['url'] = current_app.config.get('EXTERNAL_WFS_URL')
wfs_layer['layer'] = current_app.config.get('EXTERNAL_WFS_LAYER')
wfs_layer['srs'] = current_app.config.get('EXTERNAL_WFS_SRS')
wfs_layer['geometry_field'] = current_app.config.get('EXTERNAL_WFS_GEOMETRY')
wfs_layer['feature_ns'] = current_app.config.get('EXTERNAL_WFS_NS_URI')
wfs_layer['typename'] = current_app.config.get('EXTERNAL_WFS_NS_PREFIX')
wfs_layer['max_features'] = current_app.config.get('EXTERNAL_WFS_MAX_FEATURES')
wfs_layer['display_in_layerswitcher'] = False
else:
schema = couch.layer_schema(layer)
if not schema or 'properties' not in schema:
raise MissingSchemaError('no schema found for layer %s' % layer)
extend_schema_for_couchdb(schema)
# tinyows layername must not contain underscores
tablename = 'tmp%s%s' % (user.id, layer)
tmp_db = TempPGDB(connection=connection, tablename=tablename, schema=schema)
tmp_db.create_table()
tmp_db.insert_features(couch.iter_layer_features(layer))
# TODO remember created table in new model, store wfs_layer_token
# and remove old tinyows configs on update
wfs_layer['layer'] = tablename
wfs_layer['writable'] = current_app.config.get('USER_READONLY_LAYER') != layer
tinyows_layers.append({
'name': tablename,
'title': wfs_layer['name'],
'writable': '1' if wfs_layer['writable'] else '0',
})
wfs.append(wfs_layer)
connection.commit()
connection.close()
ensure_dir(current_app.config.get('TINYOWS_TMP_CONFIG_DIR'))
tinyows_config = os.path.join(
current_app.config.get('TINYOWS_TMP_CONFIG_DIR'),
wfs_layer_token + '.xml')
tinyows.build_config(current_app, tinyows_layers, wfs_layer_token, tinyows_config)
return wfs, wfs_layer_token
