def create_dict_group(cls):
print 'Create Dicts group resource...'
adminusr = User.filter_by(keyname='administrator').one()
admingrp = Group.filter_by(keyname='administrators').one()
everyone = User.filter_by(keyname='everyone').one()
try:
ResourceGroup.filter_by(keyname=DICTIONARY_GROUP_KEYNAME).one()
print 'Group already exists...'
except NoResultFound:
obj0 = ResourceGroup.filter_by(id=0).one()
obj = ResourceGroup(owner_user=adminusr,
display_name='Справочники',
keyname=DICTIONARY_GROUP_KEYNAME,
parent=obj0
)
obj.acl.append(ACLRule(
principal=admingrp,
action='allow'))
obj.acl.append(ACLRule(
principal=everyone,
scope='data',
permission='read',
action='allow',
propagate=True))
obj.persist()
def frtc(ngw_resource_group):
with transaction.manager:
layer = RasterLayer(
parent_id=ngw_resource_group,
display_name='test-render-layer',
owner_user=User.by_keyname('administrator'),
srs=SRS.filter_by(id=3857).one(),
xsize=100,
ysize=100,
dtype='Byte',
band_count=3,
).persist()
style = RasterStyle(
parent=layer,
display_name='test-render-style',
owner_user=User.by_keyname('administrator'),
).persist()
result = ResourceTileCache(resource=style, ).persist()
result.async_writing = True
DBSession.flush()
result.initialize()
yield result
with transaction.manager:
DBSession.delete(
ResourceTileCache.filter_by(resource_id=result.resource_id).one())
DBSession.delete(RasterStyle.filter_by(id=style.id).one())
DBSession.delete(RasterLayer.filter_by(id=layer.id).one())
def load_dicts(cls, force=False):
print 'Loading default dicts...'
# get principals
adminusr = User.filter_by(keyname='administrator').one()
admingrp = Group.filter_by(keyname='administrators').one()
everyone = User.filter_by(keyname='everyone').one()
# get root resource
try:
root_res = ResourceGroup.filter_by(keyname=DICTIONARY_GROUP_KEYNAME).one()
except NoResultFound:
raise Exception('Need dictionaries group resource!')
# upload dicts
for dict_keyname, dict_values in DEFAULT_COMPULINK_DICTS.iteritems():
try:
dict_res = LookupTable.filter_by(keyname=dict_keyname).one()
if not force:
print ' Dictionary "%s" already exists' % dict_keyname
continue
else:
print ' Dictionary "%s" already exists and will be recreated' % dict_keyname
except NoResultFound:
dict_res = LookupTable(owner_user=adminusr,
display_name=dict_values['display_name'],
keyname=dict_keyname,
parent=root_res)
dict_res.acl.append(ACLRule(
principal=admingrp,
action='allow'))
dict_res.val = dict_values['items']
dict_res.persist()
def service_id(ngw_resource_group):
with transaction.manager:
res_vl = VectorLayer(
parent_id=ngw_resource_group, display_name='test_vector_layer',
owner_user=User.by_keyname('administrator'),
srs=SRS.filter_by(id=3857).one(),
tbl_uuid=six.text_type(uuid4().hex),
).persist()
geojson = {
'type': 'FeatureCollection',
'crs': {'type': 'name', 'properties': {'name': 'urn:ogc:def:crs:EPSG::3857'}},
'features': [{
'type': 'Feature',
'properties': {'name': 'feature1'},
'geometry': {'type': 'Point', 'coordinates': [0, 0]}
}, {
'type': 'Feature',
'properties': {'price': -1},
'geometry': {'type': 'Point', 'coordinates': [10, 10]}
}]
}
dsource = ogr.Open(json.dumps(geojson))
layer = dsource.GetLayer(0)
res_vl.setup_from_ogr(layer, lambda x: x)
res_vl.load_from_ogr(layer, lambda x: x)
DBSession.flush()
res_wfs = WFSService(
parent_id=ngw_resource_group, display_name='test_wfsserver_service',
owner_user=User.by_keyname('administrator'),
).persist()
res_wfs.layers.append(WFSLayer(
resource=res_vl, keyname='test',
display_name='test', maxfeatures=1000,
))
DBSession.flush()
DBSession.expunge(res_vl)
DBSession.expunge(res_wfs)
yield res_wfs.id
with transaction.manager:
DBSession.delete(VectorLayer.filter_by(id=res_vl.id).one())
DBSession.delete(WFSService.filter_by(id=res_wfs.id).one())
def user_with_webmap(ngw_env, ngw_resource_group):
with transaction.manager:
user = User(
keyname=TEST_USER_KEYNAME,
display_name='Test User',
).persist()
test_root_resource = ResourceGroup.filter_by(id=0).one()
append_acl(test_root_resource, 'allow', user, 'resource', 'read',
ResourceGroup.identity)
test_resource_group = ResourceGroup.filter_by(
id=ngw_resource_group).one()
append_acl(test_resource_group, 'allow', user, 'resource', 'read',
ResourceGroup.identity)
webmap = WebMap(parent_id=ngw_resource_group,
display_name=__name__,
owner_user=User.by_keyname(TEST_USER_KEYNAME),
root_item=WebMapItem(item_type='root')).persist()
append_acl(webmap, 'allow', user, 'resource', 'read', WebMap.identity)
append_acl(webmap, 'allow', user, 'webmap', 'annotation_read',
WebMap.identity)
append_acl(webmap, 'allow', user, 'webmap', 'annotation_write',
WebMap.identity)
webmap.persist()
user_admin_id = User.by_keyname('administrator').id
make_annotation(webmap, public=True, user_id=user_admin_id)
make_annotation(webmap, public=False, user_id=user_admin_id)
make_annotation(webmap, public=True, user_id=user.id)
make_annotation(webmap, public=False, user_id=user.id)
DBSession.flush()
yield user, webmap
with transaction.manager:
user = User.filter_by(keyname=TEST_USER_KEYNAME).one()
webmap = WebMap.filter_by(owner_user_id=user.id).one()
DBSession.query(ResourceACLRule).filter(
ResourceACLRule.principal_id == user.id).delete()
DBSession.query(User).filter(
User.keyname == TEST_USER_KEYNAME).delete()
DBSession.query(WebMapAnnotation).filter(
WebMapAnnotation.webmap_id == webmap.id).delete()
DBSession.delete(WebMap.filter_by(owner_user_id=user.id).one())
def vector_layer_id(ngw_resource_group):
with transaction.manager:
obj = VectorLayer(
parent_id=ngw_resource_group,
display_name='vector_layer',
owner_user=User.by_keyname('administrator'),
srs=SRS.filter_by(id=3857).one(),
tbl_uuid=uuid4().hex,
).persist()
geojson = {
'type': 'FeatureCollection',
'features': get_features_for_orderby_test()
}
dsource = ogr.Open(json.dumps(geojson))
layer = dsource.GetLayer(0)
obj.setup_from_ogr(layer)
obj.load_from_ogr(layer)
DBSession.flush()
DBSession.expunge(obj)
yield obj.id
with transaction.manager:
DBSession.delete(VectorLayer.filter_by(id=obj.id).one())
def test_from_fields(ngw_resource_group, ngw_txn):
res = VectorLayer(
parent_id=ngw_resource_group,
display_name='from_fields',
owner_user=User.by_keyname('administrator'),
geometry_type='POINT',
srs=SRS.filter_by(id=3857).one(),
tbl_uuid=six.text_type(uuid4().hex),
)
res.setup_from_fields([
dict(keyname='integer', datatype=FIELD_TYPE.INTEGER),
dict(keyname='bigint', datatype=FIELD_TYPE.BIGINT),
dict(keyname='real', datatype=FIELD_TYPE.REAL),
dict(keyname='string', datatype=FIELD_TYPE.STRING, label_field=True),
dict(keyname='date', datatype=FIELD_TYPE.DATE),
dict(keyname='time', datatype=FIELD_TYPE.TIME),
dict(keyname='datetime', datatype=FIELD_TYPE.DATETIME),
])
res.persist()
assert res.feature_label_field.keyname == 'string'
DBSession.flush()
def svg_lib(ngw_env, ngw_resource_group):
with transaction.manager:
svg_lib = SVGMarkerLibrary(
parent_id=ngw_resource_group,
display_name='test_marker_lib',
owner_user=User.by_keyname('administrator')).persist()
DBSession.flush()
fileobj1 = FileObj(component='svg_marker_library').persist()
fileobj2 = FileObj(component='svg_marker_library').persist()
SVGMarker(svg_marker_library_id=svg_lib.id,
fileobj=fileobj1,
name='marker1').persist()
marker2 = SVGMarker(svg_marker_library_id=svg_lib.id,
fileobj=fileobj2,
name='marker2').persist()
DBSession.flush()
yield svg_lib
with transaction.manager:
DBSession.delete(marker2)
DBSession.delete(fileobj1)
DBSession.delete(fileobj2)
DBSession.delete(svg_lib)
def test_fid(fid_source, fid_field, id_expect, ngw_resource_group, ngw_txn):
src = Path(__file__).parent / 'data' / 'type.geojson'
dataset = ogr.Open(str(src))
assert dataset is not None, gdal.GetLastErrorMsg()
layer = dataset.GetLayer(0)
assert layer is not None, gdal.GetLastErrorMsg()
res = VectorLayer(parent_id=ngw_resource_group,
display_name='test_fid',
owner_user=User.by_keyname('administrator'),
srs=SRS.filter_by(id=3857).one(),
tbl_uuid=uuid4().hex)
res.persist()
res.setup_from_ogr(layer,
fid_params=dict(fid_source=fid_source,
fid_field=fid_field))
res.load_from_ogr(layer)
DBSession.flush()
query = res.feature_query()
query.filter_by(id=id_expect)
assert query().total_count == 1
def type_layer(ngw_resource_group):
with transaction.manager:
vl_type = VectorLayer(
parent_id=ngw_resource_group,
display_name='type',
owner_user=User.by_keyname('administrator'),
srs=SRS.filter_by(id=3857).one(),
tbl_uuid=uuid4().hex,
).persist()
import nextgisweb.vector_layer.test
path = Path(
nextgisweb.vector_layer.test.__file__).parent / 'data/type.geojson'
ogrds = ogr.Open(str(path))
ogrlayer = ogrds.GetLayer(0)
vl_type.setup_from_ogr(ogrlayer)
vl_type.load_from_ogr(ogrlayer)
DBSession.flush()
DBSession.expunge(vl_type)
yield vl_type.id
with transaction.manager:
DBSession.delete(VectorLayer.filter_by(id=vl_type.id).one())
def test_from_ogr(data, ngw_resource_group, ngw_txn):
src = os.path.join(DATA_PATH, data)
dsource = ogr.Open('/vsizip/' + src)
layer = dsource.GetLayer(0)
res = VectorLayer(
parent_id=ngw_resource_group,
display_name='from_ogr',
owner_user=User.by_keyname('administrator'),
srs=SRS.filter_by(id=3857).one(),
tbl_uuid=six.text_type(uuid4().hex),
)
res.persist()
res.setup_from_ogr(layer, lambda x: x)
res.load_from_ogr(layer, lambda x: x)
DBSession.flush()
features = list(res.feature_query()())
assert len(features) == 1
feature = features[0]
assert feature.id == 1
fields = feature.fields
assert fields['int'] == -1
# TODO: Date, time and datetime tests fails on shapefile
# assert fields['date'] == date(2001, 1, 1)
# assert fields['time'] == time(23, 59, 59)
# assert fields['datetime'] == datetime(2001, 1, 1, 23, 59, 0)
assert fields['string'] == "Foo bar"
assert fields[
'unicode'] == 'Значимость этих проблем настолько очевидна, что реализация намеченных плановых заданий требуют определения и уточнения.' # NOQA: E501
def test_size_limit(size_limit, width, height, band_count, datatype, ok, ngw_env, ngw_resource_group):
res = RasterLayer(
parent_id=ngw_resource_group, display_name='test-raster-limit',
owner_user=User.by_keyname('administrator'),
srs=SRS.filter_by(id=3857).one(),
).persist()
driver = gdal.GetDriverByName('GTiff')
proj = res.srs.to_osr()
proj_wkt = proj.ExportToWkt()
with ngw_env.raster_layer.options.override(dict(size_limit=size_limit)):
with NamedTemporaryFile('w') as f:
ds = driver.Create(f.name, width, height, band_count, datatype)
ds.SetProjection(proj_wkt)
ds.FlushCache()
ds = None
f.flush()
if ok:
res.load_file(f.name, ngw_env)
else:
with pytest.raises(ValidationError):
res.load_file(f.name, ngw_env)
DBSession.expunge(res)
def test_load_file(
source, band_count, srs_id, ngw_env, ngw_txn, ngw_resource_group, cog
):
res = RasterLayer(
parent_id=ngw_resource_group, display_name='test:{}'.format(source),
owner_user=User.by_keyname('administrator'),
srs=SRS.filter_by(id=srs_id).one(),
).persist()
res.load_file(
os.path.join(os.path.split(__file__)[0], "data", source),
ngw_env,
cog,
)
assert res.band_count == band_count
fn_data = ngw_env.file_storage.filename(res.fileobj)
assert not os.path.islink(fn_data)
fn_work = ngw_env.raster_layer.workdir_filename(res.fileobj)
assert os.path.islink(fn_work) and os.path.realpath(fn_work) == fn_data
warnings, errors, _ = validate(fn_work, full_check=True)
if cog:
assert len(errors) == 0
if not cog:
assert len(errors) == 1
def test_id_field(data, ngw_resource_group):
res = VectorLayer(parent_id=ngw_resource_group,
display_name=f'test-{data}',
owner_user=User.by_keyname('administrator'),
srs=SRS.filter_by(id=3857).one(),
tbl_uuid=uuid4().hex).persist()
src = os.path.join(DATA_PATH, f'{data}.geojson')
ds = ogr.Open(src)
layer = ds.GetLayer(0)
with pytest.raises(ValidationError):
res.setup_from_ogr(layer)
fid_params = dict(fid_source=FID_SOURCE.FIELD, fid_field=['id'])
with pytest.raises(ValidationError):
res.setup_from_ogr(layer, fid_params=fid_params)
res.setup_from_ogr(layer, fix_errors=ERROR_FIX.SAFE, fid_params=fid_params)
res.load_from_ogr(layer)
DBSession.flush()
query = res.feature_query()
feature = query().one()
assert feature.id == 1
assert list(feature.fields.keys()) == ['id_1']
def disable_users():
active_uids = []
with transaction.manager:
for user in User.filter(
db.and_(User.keyname != 'administrator',
db.not_(User.disabled), db.not_(User.system))).all():
user.disabled = True
active_uids.append(user.id)
DBSession.flush()
yield
with transaction.manager:
for user in User.filter(User.id.in_(active_uids)).all():
user.disabled = False
DBSession.flush()
def vector_layer_id(ngw_resource_group):
with transaction.manager:
obj = VectorLayer(
parent_id=ngw_resource_group, display_name='vector_layer',
owner_user=User.by_keyname('administrator'),
srs=SRS.filter_by(id=3857).one(),
tbl_uuid=uuid4().hex,
).persist()
geojson = {
"type": "FeatureCollection",
"name": "polygon_extent",
"crs": {"type": "name", "properties": {"name": "urn:ogc:def:crs:EPSG::3857"}},
"features": [
{
"type": "Feature",
"properties": {"name": "west"},
"geometry": {
"type": "Polygon",
"coordinates": [[
[5542180, 8799167],
[6191082, 7551279],
[4668659, 7126998],
[5542180, 8799167],
]],
},
},
{
"type": "Feature",
"properties": {"name": "east"},
"geometry": {
"type": "Polygon",
"coordinates": [[
[15100999, 10396463],
[16498633, 10546209],
[16673337, 9223449],
[15175872, 8948913],
[15100999, 10396463],
]],
},
},
],
}
dsource = ogr.Open(json.dumps(geojson))
layer = dsource.GetLayer(0)
obj.setup_from_ogr(layer)
obj.load_from_ogr(layer)
DBSession.flush()
DBSession.expunge(obj)
yield obj.id
with transaction.manager:
DBSession.delete(VectorLayer.filter_by(id=obj.id).one())
def wfs_service_path(ngw_resource_group, ngw_httptest_app):
with transaction.manager:
vl_type = VectorLayer(
parent_id=ngw_resource_group,
display_name='type',
owner_user=User.by_keyname('administrator'),
srs=SRS.filter_by(id=3857).one(),
tbl_uuid=six.text_type(uuid4().hex),
).persist()
dsource = type_geojson_dataset('type.geojson')
layer = dsource.GetLayer(0)
vl_type.setup_from_ogr(layer, lambda x: x)
vl_type.load_from_ogr(layer, lambda x: x)
DBSession.flush()
# NOTE: GDAL doesn't support time fields in GML / WFS. It completely breaks
# XSD schema parsing. Delete the time field to pass tests.
DBSession.delete(vl_type.field_by_keyname('time'))
wfs_service = WFSService(
parent_id=ngw_resource_group,
display_name='test_wfsserver_service',
owner_user=User.by_keyname('administrator'),
).persist()
wfs_service.layers.append(
WFS_Service_Layer(resource=vl_type,
keyname='type',
display_name='type',
maxfeatures=1000))
DBSession.flush()
DBSession.expunge(vl_type)
DBSession.expunge(wfs_service)
path = '{}/api/resource/{}/wfs'.format(ngw_httptest_app.base_url,
wfs_service.id)
yield path
with transaction.manager:
DBSession.delete(VectorLayer.filter_by(id=vl_type.id).one())
DBSession.delete(WFSService.filter_by(id=wfs_service.id).one())
def test_last_activity(ngw_env, ngw_webtest_app):
epsilon = timedelta(milliseconds=500)
with ngw_env.auth.options.override(activity_delta=timedelta(seconds=0)):
ngw_webtest_app.get('/resource/0', status='*')
last_activity = User.by_keyname('guest').last_activity
assert datetime.utcnow() - last_activity < epsilon
with ngw_env.auth.options.override(activity_delta=timedelta(seconds=100)):
ngw_webtest_app.get('/resource/0', status='*')
assert User.by_keyname('guest').last_activity == last_activity
with ngw_env.auth.options.override(activity_delta=timedelta(seconds=0)):
ngw_webtest_app.authorization = ('Basic', ('administrator', 'admin'))
ngw_webtest_app.get('/resource/0', status='*')
admin_last_activity = User.by_keyname('administrator').last_activity
assert datetime.utcnow() - admin_last_activity < epsilon
assert User.by_keyname('guest').last_activity == last_activity
def vlayer_id(ngw_resource_group):
with transaction.manager:
res_vl = VectorLayer(
parent_id=ngw_resource_group,
display_name='test_cyrillic',
owner_user=User.by_keyname('administrator'),
srs=SRS.filter_by(id=3857).one(),
tbl_uuid=uuid4().hex,
).persist()
geojson = {
'type':
'FeatureCollection',
'crs': {
'type': 'name',
'properties': {
'name': 'urn:ogc:def:crs:EPSG::3857'
}
},
'features': [{
'type': 'Feature',
'properties': {
'field1': 1,
'поле2': 'значение1',
'!field3': '!@#$%^&*()значение1'
},
'geometry': {
'type': 'Point',
'coordinates': [0, 0]
}
}, {
'type': 'Feature',
'properties': {
'field1': 2,
'поле2': 'значение2',
'!field3': '!@#$%^&*()значение2'
},
'geometry': {
'type': 'Point',
'coordinates': [10, 10]
}
}]
}
dsource = ogr.Open(json.dumps(geojson))
layer = dsource.GetLayer(0)
res_vl.setup_from_ogr(layer)
res_vl.load_from_ogr(layer)
DBSession.flush()
DBSession.expunge(res_vl)
yield res_vl.id
with transaction.manager:
DBSession.delete(VectorLayer.filter_by(id=res_vl.id).one())
def test_same_display_name(ngw_txn, ngw_resource_group):
margs = dict(
parent_id=ngw_resource_group, display_name='display name',
owner_user=User.by_keyname('administrator'))
with pytest.raises(IntegrityError, match='"resource_parent_id_display_name_key"'):
ResourceGroup(**margs).persist()
ResourceGroup(**margs).persist()
DBSession.flush()
def test_create(filename, options, checks, ngw_resource_group, ngw_txn):
obj = VectorLayer(parent_id=ngw_resource_group,
display_name='vector_layer',
owner_user=User.by_keyname('administrator'),
srs=SRS.filter_by(id=3857).one(),
tbl_uuid=six.text_type(uuid4().hex)).persist()
src = str(path / filename)
ds = ogr.Open(src)
layer = ds.GetLayer(0)
geom_cast_params = dict(geometry_type=options.get('geometry_type'),
is_multi=options.get('is_multi'),
has_z=options.get('has_z'))
def setup_and_load():
setup_kwargs = dict()
load_kwargs = dict()
if 'skip_other_geometry_types' in options:
setup_kwargs['skip_other_geometry_types'] = options[
'skip_other_geometry_types']
load_kwargs['skip_other_geometry_types'] = options[
'skip_other_geometry_types']
if 'fix_errors' in options:
load_kwargs['fix_errors'] = options['fix_errors']
if 'skip_errors' in options:
load_kwargs['skip_errors'] = options['skip_errors']
obj.setup_from_ogr(layer,
geom_cast_params=geom_cast_params,
**setup_kwargs)
obj.load_from_ogr(layer, **load_kwargs)
if 'exception' in checks:
with pytest.raises(checks['exception']):
setup_and_load()
DBSession.expunge(obj)
else:
setup_and_load()
DBSession.flush()
if 'geometry_type' in checks:
exp_geometry_type = checks['geometry_type']
assert obj.geometry_type == exp_geometry_type, \
"Expected geometry type was {} but actually got {}".format(
exp_geometry_type, obj.geometry_type)
if 'feature_count' in checks:
exp_feature_count = checks['feature_count']
query = obj.feature_query()
feature_count = query().total_count
assert feature_count == exp_feature_count, \
"Expected feature count was {} but got {}".format(
exp_feature_count, feature_count)
def service(ngw_resource_group):
with transaction.manager:
res_vl = VectorLayer(
parent_id=ngw_resource_group,
display_name='test_vector_layer',
owner_user=User.by_keyname('administrator'),
srs=SRS.filter_by(id=3857).one(),
tbl_uuid=six.text_type(uuid4().hex),
).persist()
dsource = type_geojson_dataset()
layer = dsource.GetLayer(0)
res_vl.setup_from_ogr(layer, lambda x: x)
res_vl.load_from_ogr(layer, lambda x: x)
DBSession.flush()
res_wfs = WFSService(
parent_id=ngw_resource_group,
display_name='test_wfsserver_service',
owner_user=User.by_keyname('administrator'),
).persist()
res_wfs.layers.append(
WFSLayer(
resource=res_vl,
keyname='test',
display_name='test',
maxfeatures=1000,
))
DBSession.flush()
DBSession.expunge(res_vl)
DBSession.expunge(res_wfs)
yield res_wfs.id
with transaction.manager:
DBSession.delete(VectorLayer.filter_by(id=res_vl.id).one())
DBSession.delete(WFSService.filter_by(id=res_wfs.id).one())
def vector_layer_id(ngw_resource_group):
with transaction.manager:
obj = VectorLayer(
parent_id=ngw_resource_group,
display_name='vector_layer',
owner_user=User.by_keyname('administrator'),
srs=SRS.filter_by(id=3857).one(),
tbl_uuid=uuid4().hex,
).persist()
geojson = {
'type':
'FeatureCollection',
'crs': {
'type': 'name',
'properties': {
'name': 'urn:ogc:def:crs:EPSG::3857'
}
},
'features': [{
'type': 'Feature',
'properties': {
'price': -1,
'name': 'feature1'
},
'geometry': {
'type': 'Point',
'coordinates': [0, 0]
}
}, {
'type': 'Feature',
'properties': {
'price': -2,
'name': 'feature2'
},
'geometry': {
'type': 'Point',
'coordinates': [0, 0]
}
}]
}
dsource = ogr.Open(json.dumps(geojson))
layer = dsource.GetLayer(0)
obj.setup_from_ogr(layer)
obj.load_from_ogr(layer)
DBSession.flush()
DBSession.expunge(obj)
yield obj.id
with transaction.manager:
DBSession.delete(VectorLayer.filter_by(id=obj.id).one())
def ngw_resource_group(ngw_env):
with transaction.manager:
res = ResourceGroup(
parent_id=0, owner_user=User.by_keyname('administrator'),
display_name='Test resource group ({})'.format(datetime.now().isoformat()),
).persist()
yield res.id
with transaction.manager:
DBSession.delete(ResourceGroup.filter_by(id=res.id).one())
def vector_layer(display_name, parent_id):
res = VectorLayer(
parent_id=parent_id,
display_name=display_name,
owner_user=User.by_keyname('administrator'),
srs=SRS.filter_by(id=3857).one(),
geometry_type='POINT',
tbl_uuid=six.text_type(uuid4().hex),
).persist()
res.setup_from_fields([])
return res
def make_layer_style(ngw_resource_group, num):
layer = RasterLayer(
parent_id=ngw_resource_group,
display_name=f'test-render-layer-{num}',
owner_user=User.by_keyname('administrator'),
srs=SRS.filter_by(id=3857).one(),
xsize=100,
ysize=100,
dtype='Byte',
band_count=3,
).persist()
style = RasterStyle(
parent=layer,
display_name=f'test-render-style-{num}',
owner_user=User.by_keyname('administrator'),
).persist()
DBSession.flush()
DBSession.expunge(style)
return layer.id, style.id
def ngw_resource_group_sub(ngw_resource_group, ngw_env):
with transaction.manager:
res = ResourceGroup(
parent_id=ngw_resource_group, owner_user=User.by_keyname('administrator'),
display_name=str(uuid4()),
).persist()
yield res.id
with transaction.manager:
with DBSession.no_autoflush:
delete_recursive(ResourceGroup.filter_by(id=res.id).one())
def webmap(ngw_env, ngw_resource_group):
with transaction.manager:
obj = WebMap(parent_id=ngw_resource_group,
display_name=__name__,
owner_user=User.by_keyname('administrator'),
root_item=WebMapItem(item_type='root')).persist()
DBSession.flush()
DBSession.expunge(obj)
yield obj
with transaction.manager:
DBSession.delete(WebMap.filter_by(id=obj.id).one())
def webmap_with_items(ngw_resource_group, fixt_layers_styles):
with transaction.manager:
webmap = WebMap(parent_id=ngw_resource_group,
display_name=__name__,
owner_user=User.by_keyname('administrator'),
root_item=WebMapItem(item_type='root'))
webmap.from_dict(make_webmap_items(fixt_layers_styles))
webmap.persist()
yield webmap, fixt_layers_styles
with transaction.manager:
DBSession.delete(WebMap.filter_by(id=webmap.id).one())
def test_type_geojson(ngw_resource_group, ngw_txn):
src = Path(__file__).parent / 'data' / 'type.geojson'
dataset = ogr.Open(str(src))
assert dataset is not None, gdal.GetLastErrorMsg()
layer = dataset.GetLayer(0)
assert layer is not None, gdal.GetLastErrorMsg()
res = VectorLayer(parent_id=ngw_resource_group,
display_name='from_ogr',
owner_user=User.by_keyname('administrator'),
srs=SRS.filter_by(id=3857).one(),
tbl_uuid=six.text_type(uuid4().hex))
res.persist()
res.setup_from_ogr(layer, lambda x: x)
res.load_from_ogr(layer, lambda x: x)
layer.ResetReading()
DBSession.flush()
def field_as(f, n, t):
fidx = f.GetFieldIndex(n)
if f.IsFieldNull(fidx):
return None
attr = getattr(f, 'GetFieldAs' + t)
result = attr(fidx)
if t in ('Date', 'Time', 'DateTime'):
result = [int(v) for v in result]
if t == 'String' and six.PY2:
result = result.decode('utf-8')
return result
for feat, ref in zip(res.feature_query()(), layer):
fields = feat.fields
assert fields['null'] == field_as(ref, 'null', None)
assert fields['int'] == field_as(ref, 'int', 'Integer')
assert fields['real'] == field_as(ref, 'real', 'Double')
assert fields['date'] == date(*field_as(ref, 'date', 'DateTime')[0:3])
assert fields['time'] == time(*field_as(ref, 'time', 'DateTime')[3:6])
assert fields['datetime'] == datetime(
*field_as(ref, 'datetime', 'DateTime')[0:6])
assert fields['string'] == field_as(ref, 'string', 'String')
assert fields['unicode'] == field_as(ref, 'unicode', 'String')
def resource_id(ngw_resource_group):
with transaction.manager:
res = ResourceGroup(
parent_id=ngw_resource_group,
display_name='test-resource-group',
owner_user=User.by_keyname('administrator')).persist()
DBSession.flush()
DBSession.expunge(res)
yield res.id
with transaction.manager:
DBSession.delete(res)
def rstyle_id(ngw_env, rlayer_id):
with transaction.manager:
obj = RasterStyle(
parent_id=rlayer_id,
display_name='test-wms-rstyle',
owner_user=User.by_keyname('administrator')).persist()
DBSession.flush()
DBSession.expunge(obj)
yield obj.id
with transaction.manager:
DBSession.delete(RasterStyle.filter_by(id=obj.id).one())
def load_shape_dicts(cls, force=False):
print 'Loading shapes...'
shape_dicts = {
FEDERAL_KEYNAME: ('federal_districts.zip',
'Федеральные округа',
{
FEDERAL_ID_FIELD: 'Идентификатор',
FEDERAL_NAME_FIELD: 'Наименование',
FEDERAL_SHORT_NAME_FIELD: 'Короткое название',
}
),
REGIONS_KEYNAME: ('regions.zip',
'Регионы РФ',
{
REGIONS_ID_FIELD: 'Идентификатор',
REGIONS_NAME_FIELD: 'Наименование',
}
),
DISTRICT_KEYNAME: ('districts.zip',
'Районы',
{
DISTRICT_ID_FIELD: 'Идентификатор',
DISTRICT_NAME_FIELD: 'Наименование',
DISTRICT_PARENT_ID_FIELD: 'Ид. родительского региона',
DISTRICT_SHORT_NAME_FIELD: 'Короткое название'
}
),
}
# get principals
adminusr = User.filter_by(keyname='administrator').one()
admingrp = Group.filter_by(keyname='administrators').one()
everyone = User.filter_by(keyname='everyone').one()
# get root resource
try:
root_res = ResourceGroup.filter_by(keyname=DICTIONARY_GROUP_KEYNAME).one()
except NoResultFound:
raise Exception('Need dictionaries group resource!')
# create shapes
for (dict_keyname, (dict_file, dict_display_name, dict_fields)) in shape_dicts.iteritems():
try:
vec_res = VectorLayer.filter_by(keyname=dict_keyname).one()
print ' Dictionary "%s" already exists' % dict_keyname
if force:
print ' Force recreate "%s"' % dict_keyname
# try to drop old table
try:
VectorLayerUpdater.drop_vector_layer_table(vec_res.tbl_uuid)
except:
pass
else:
continue
except NoResultFound:
vec_res = VectorLayer(owner_user=adminusr,
display_name=dict_display_name,
keyname=dict_keyname,
parent=root_res)
vec_res.acl.append(ACLRule(
principal=admingrp,
action='allow'))
vec_res.srs = SRS.filter_by(id=3857).one()
datafile = path.join(BASE_PATH, dict_file)
encoding = 'utf-8'
iszip = zipfile.is_zipfile(datafile)
try:
#open ogr ds
if iszip:
ogrfn = tempfile.mkdtemp()
zipfile.ZipFile(datafile, 'r').extractall(path=ogrfn)
else:
ogrfn = datafile
with _set_encoding(encoding) as sdecode:
ogrds = ogr.Open(ogrfn)
recode = sdecode
if ogrds is None:
raise VE("Библиотеке OGR не удалось открыть файл")
drivername = ogrds.GetDriver().GetName()
if drivername not in ('ESRI Shapefile', ):
raise VE("Неподдерживаемый драйвер OGR: %s" % drivername)
# check datasource
if ogrds.GetLayerCount() < 1:
raise VE("Набор данных не содержит слоёв.")
if ogrds.GetLayerCount() > 1:
raise VE("Набор данных содержит более одного слоя.")
# open ogrlayer
ogrlayer = ogrds.GetLayer(0)
if ogrlayer is None:
raise VE("Не удалось открыть слой.")
# check layer
if ogrlayer.GetSpatialRef() is None:
raise VE("Не указана система координат слоя.")
feat = ogrlayer.GetNextFeature()
while feat:
geom = feat.GetGeometryRef()
if geom is None:
raise VE("Объект %d не содержит геометрии." % feat.GetFID())
feat = ogrlayer.GetNextFeature()
ogrlayer.ResetReading()
vec_res.tbl_uuid = uuid.uuid4().hex
with DBSession.no_autoflush:
vec_res.setup_from_ogr(ogrlayer, recode)
vec_res.load_from_ogr(ogrlayer, recode)
finally:
if iszip:
shutil.rmtree(ogrfn)
# display names for fields
for field_keyname, field_dispname in dict_fields.iteritems():
VectorLayerUpdater.change_field_display_name(vec_res, field_keyname, field_dispname)
vec_res.persist()