def to_data(x) -> Data:
"""Convert a value to a Data. If the argument is a Data object, return it."""
if is_data_object(x):
return x
if is_dict(x):
return gws.Data(x)
return gws.Data()
def props_for(self, user):
return gws.Data(
rules=[
gws.Data(
name=r.name,
editable=r.editable,
editor=r.editor,
title=r.title,
type=r.type,
) for r in self.rules
],
geometryType=self.geometry_type,
crs=self.geometry_crs,
)
def test_update_stored_session(auth):
user = auth.authenticate(auth.methods[0], gws.Data(login='******'))
sess1 = auth.new_stored_session('test', auth.methods[0], user)
sess1.set('foo', 'bar')
auth.save_stored_session(sess1)
sess2 = auth.find_stored_session(sess1.uid)
assert sess2.get('foo') == 'bar'
def _read_object(self, val, spec):
val = _ensure(val, dict)
if not self.with_strict_mode:
val = {k.lower(): v for k, v in val.items()}
props = spec['props']
res = {}
for prop_name, prop_key in props.items():
prop_val = val.get(
prop_name if self.with_strict_mode else prop_name.lower())
self.push([prop_val, prop_name])
res[prop_name] = self._read_property(prop_val, prop_key)
self.pop()
unknown = []
for k in val:
if k not in props:
if self.with_internal_objects:
res[k] = val[k]
elif self.with_strict_mode:
unknown.append(k)
if unknown:
raise Error(
'ERR_UNKNOWN_PROP',
f"unknown keys: {_comma(unknown)}, expected: {_comma(props)}",
val)
return gws.Data(res)
def _new_request(self, shape):
self._prepare_request_table()
features = self.alkis.db.select(
gws.SqlSelectArgs({
'shape':
shape,
'table':
self.alkis.db.configure_table(
gws.Data(name=self.alkis.index_schema + '.' +
_INDEX_TABLE_NAME, ))
}))
if not features:
return None
request_id = _rand_id()
data = []
for f in features:
d = {
a.name: a.value
for a in f.attributes if a.name in self._data_fields
}
d['request_id'] = request_id
d['selection'] = shape.transformed_to(self.alkis.crs).ewkb_hex
d['ts'] = gws.lib.date.now()
data.append(d)
with self.alkis.db.connect() as conn:
for d in data:
conn.insert_one(self.request_table_name, 'request_id', d)
return request_id
def configure(self):
# with reqSize=1 MP will request the same tile multiple times
# reqSize=4 is more efficient, however, reqSize=1 yields the first tile faster
# which is crucial when browsing non-cached low resoltions
# so, let's use 1 as default, overridable in the config
#
# @TODO make MP cache network requests
self.grid.reqSize = self.grid.reqSize or 1
self.url = self.var('url')
p = self.var('service', default=gws.Data())
self.service = Service(crs=gws.gis.crs.get(p.crs)
or gws.gis.crs.get3857(),
origin=p.origin,
tile_size=p.tileSize,
extent=p.extent)
if not self.service.extent:
if self.service.crs.srid == gws.gis.crs.c3857:
self.service.extent = gws.gis.crs.c3857_extent
else:
raise gws.Error(
f'service extent required for crs {self.service.crs.srid!r}'
)
def configure(self):
self.project = self.get_closest('gws.base.project')
self.metadata = self.configure_metadata()
self.root_layer_uid = self.var('rootLayer')
self.supported_crs = [gws.gis.crs.require(s) for s in self.var('supportedCrs', default=[])]
self.update_sequence = self.var('updateSequence')
self.with_inspire_meta = self.var('withInspireMeta')
self.with_strict_params = self.var('withStrictParams')
self.templates = gws.base.template.bundle.create(
self.root,
items=self.var('templates'),
defaults=self.default_templates,
parent=self)
self.layer_options = []
for cfg in self.var('layerConfig', default=[]):
lo = LayerOptions()
apply = cfg.applyTo or gws.Data()
lo.uids = set(apply.uids or [])
lo.level = apply.level
lo.pattern = apply.pattern
lo.enabled = cfg.enabled
lo.layer_name = cfg.layerName
lo.feature_name = cfg.featureName
self.layer_options.append(lo)
def props_for(self, user):
return gws.Data(
uid=self.full_uid,
attributes=self.attributes,
shape=self.shape,
style=self.style or (self.layer.style if self.layer else None),
elements=self.elements,
layerUid=self.layer.uid if self.layer else None,
)
def default_metadata(self):
return gws.Data(
inspireDegreeOfConformity='notEvaluated',
inspireMandatoryKeyword='humanCatalogueViewer',
inspireResourceType='service',
inspireSpatialDataServiceType='discovery',
isoScope='dataset',
isoSpatialRepresentationType='vector',
)
def default_metadata(self):
return gws.Data(
inspireDegreeOfConformity='notEvaluated',
inspireMandatoryKeyword='infoMapAccessService',
inspireResourceType='service',
inspireSpatialDataServiceType='view',
isoScope='dataset',
isoSpatialRepresentationType='vector',
)
def props_for(self, user):
return gws.Data(
dataModel=self.data_model,
mapSize=self.map_size,
pageSize=self.page_size,
qualityLevels=self.quality_levels,
title=self.title,
uid=self.uid,
)
def make_features(name, geom_type, columns, crs, xy, rows, cols, gap):
features = []
sx, sy = xy
for r in range(rows):
for c in range(cols):
uid = r * cols + (c + 1)
atts = []
for k, v in columns.items():
val = ''
if v == 'int':
val = uid * 100
if v == 'float':
val = uid * 200.0
if v in ('varchar', 'text'):
val = f"{name}/{uid}"
if v == 'date':
val = datetime.datetime(
2019, 1, 1) + datetime.timedelta(days=uid - 1)
atts.append(gws.Attribute(name=k, value=val))
x = sx + c * gap
y = sy + r * gap
geom = None
if geom_type == 'point':
geom = {'type': 'Point', 'coordinates': [x, y]}
if geom_type == 'square':
w = h = gap / 2
geom = {
'type':
'Polygon',
'coordinates': [[
[x, y],
[x + w, y],
[x + w, y + h],
[x, y + h],
[x, y],
]]
}
features.append(
gws.gis.feature.from_props(
gws.Data(uid=uid,
attributes=atts,
shape={
'crs': crs,
'geometry': geom
} if geom else None)))
return features
def props_for(self, user):
return gws.Data(
abstract=self.values.abstract or '',
attribution=self.values.attribution or '',
dateCreated=self.values.dateCreated,
dateUpdated=self.values.dateUpdated,
keywords=self.values.keywords or [],
language=self.values.language or '',
title=self.values.title or '',
)
def __init__(self, root: gws.IRoot, rec):
self.root = root
self.uid = rec['uid']
self.user = self._get_user(rec)
self.worker = rec['worker']
self.payload = gws.Data(
gws.lib.json2.from_string(rec.get('payload', '')))
self.state = rec['state']
self.error = rec['error']
def render(self, tri, notify=None):
fn = self.compile()
ctx = self.prepare_context(tri.context)
if isinstance(ctx, dict):
ctx = gws.Data(ctx)
try:
return fn(ctx)
except Exception as exc:
gws.log.exception()
raise gws.Error(f'py error: {exc!r} path={self.path!r}') from exc
def create(
root: gws.IRoot,
items: t.List[core.Config],
parent: gws.INode,
shared=False,
defaults: t.Optional[t.List[core.Config]] = None,
) -> Object:
cfg = gws.Data(
items=items,
defaults=defaults or [],
)
return root.create_object(Object, cfg, parent, shared)
def props_for(self, user):
return gws.Data(
crs=self.crs.epsg,
crsDef=self.crs.proj4text,
coordinatePrecision=self.coordinate_precision,
extent=self.extent,
center=self.center,
initResolution=self.init_resolution,
layers=self.layers,
resolutions=self.resolutions,
title=self.title,
)
def props_for(self, user):
ico = self.values.icon
if ico and isinstance(ico, icon.ParsedIcon):
ico = icon.to_data_url(ico)
else:
# NB if icon is not parsed, don't give it back
ico = ''
return gws.Data(
values=gws.merge(self.values, icon=ico),
name=self.name or '',
selector=self.selector or '',
)
def shape_to_element(shape: gws.IShape,
precision=0,
axis: gws.Axis = gws.AXIS_XY,
crs_format: gws.CrsFormat = gws.CrsFormat.URN,
with_ns='gml') -> gws.XmlElement:
"""Convert a Shape to a GML3 geometry element."""
geom: shapely.geometry.base.BaseGeometry = getattr(shape, 'geom')
srs = shape.crs.to_string(crs_format)
ns = (with_ns + ':') if with_ns else ''
opts = gws.Data(precision=precision, axis=axis, ns=ns)
return xml2.tag(*_tag(geom, opts), srsName=srs)
def props_for(self, user):
app_api = self.root.application.api
actions = self.api.actions_for(
user, app_api) if self.api else app_api.actions_for(user)
return gws.Data(
actions=list(actions.values()),
client=self.client or self.root.application.client,
description=self.description,
map=self.map,
metadata=self.metadata,
overviewMap=self.overview_map,
printer=self.printer,
title=self.title,
uid=self.uid,
)
def _load_gekos_data(self):
recs = []
for source in self.var('sources'):
options = gws.Data(crs=self.crs,
url=source.url,
params=source.params,
position=self.var('position'))
gr = request.GekosRequest(options,
source.instance,
cache_lifetime=0)
rs = gr.run()
gws.log.info(f'loaded {len(rs)} records from {source.instance!r}')
recs.extend(rs)
return recs
def test_stored_session_expiration(auth):
user = auth.authenticate(auth.methods[0], gws.Data(login='******'))
dead = auth.new_stored_session('test', auth.methods[0], user)
live = auth.new_stored_session('test', auth.methods[0], user)
time.sleep(1)
auth.save_stored_session(live)
time.sleep(1)
auth.save_stored_session(live)
time.sleep(1)
dead2 = auth.find_stored_session(dead.uid)
live2 = auth.find_stored_session(live.uid)
assert dead2 is None
assert live2.uid == live.uid
def open_session(self, auth, req):
if self.secure and not req.is_secure:
return
login_pass = _parse_header(req)
if not login_pass:
return
user = auth.authenticate(
self, gws.Data(username=login_pass[0], password=login_pass[1]))
if user:
return t.cast(manager.Object, auth).new_session('http-basic',
method=self,
user=user)
# if the header is provided, it has to be correct
raise error.LoginNotFound()
def config_from_source_layers(source_layers: t.List[gws.SourceLayer]):
min_scale = max_scale = None
for sl in source_layers:
# if one of the layers has no scale range, the whole group has no range
if not sl.scale_range:
return None
min_scale = min(sl.scale_range[0], min_scale or 1e20)
max_scale = max(sl.scale_range[1], max_scale or 0)
zoom = {}
if min_scale is not None:
zoom['minScale'] = min_scale
if max_scale is not None:
zoom['maxScale'] = max_scale
return gws.Data(zoom) if zoom else None
def parse_args(argv):
args = []
kwargs = {}
key = None
for a in argv:
if a.startswith('--'):
key = camelize(a[2:])
kwargs[key] = True
elif a.startswith('-'):
key = camelize(a[1:])
kwargs[key] = True
elif key:
kwargs[key] = a
key = None
else:
args.append(a)
return args, gws.Data(kwargs)
def test_destroy_stored_session(auth):
user = auth.authenticate(auth.methods[0], gws.Data(login='******'))
sess1 = auth.new_stored_session('test', auth.methods[0], user)
auth.destroy_stored_session(sess1)
sess2 = auth.find_stored_session(sess1.uid)
assert sess2 is None
def service_link(self):
if self.project:
return gws.Data(url=self.service_url_path(self.project),
scheme='OGC:WCS',
function='search')
def web_request():
user = test.root().find(
klass='gws.ext.auth.provider.system.Object').users['system']
return gws.Data(user=user)
def props_for(self, user):
return gws.Data(
options=self.options,
elements=self.elements)
def props_for(self, user):
return gws.Data(tag=self.var('tag'))
