def layer_wmts_test_data(dbsession, transact):
del transact
from c2cgeoportal_commons.models.main import LayerWMTS, OGCServer
server = OGCServer(name='server_1')
server.url = 'http://wms.geo.admin.ch_1'
server.image_type = 'image/png'
def layer_builder(i):
name = 'layer_wmts_{}'.format(i)
layer = LayerWMTS(name=name)
layer.layer = name
layer.url = 'https:///wms.geo.admin.ch_{}.org?service=wms&request=GetCapabilities'.format(
i)
layer.public = 1 == i % 2
layer.geo_table = 'geotable_{}'.format(i)
layer.image_type = 'image/jpeg'
layer.style = 'décontrasté'
return layer
datas = factory_build_layers(layer_builder, dbsession)
datas['default'] = get_test_default_layers(dbsession, server)
dbsession.flush()
yield datas
def layer_wmts_test_data(dbsession, transact):
del transact
from c2cgeoportal_commons.models.main import LayerWMTS, OGCServer
server = OGCServer(name="server_1")
server.url = "http://wms.geo.admin.ch_1"
server.image_type = "image/png"
def layer_builder(i):
name = f"layer_wmts_{i}"
layer = LayerWMTS(name=name)
layer.layer = name
layer.url = f"https:///wms.geo.admin.ch_{i}.org?service=wms&request=GetCapabilities"
layer.public = 1 == i % 2
layer.geo_table = f"geotable_{i}"
layer.image_type = "image/jpeg"
layer.style = "décontrasté"
return layer
data = factory_build_layers(layer_builder, dbsession)
data["default"] = get_test_default_layers(dbsession, server)
dbsession.flush()
yield data
def create_default_ogcserver():
from c2cgeoportal_commons.models import DBSession
from c2cgeoportal_commons.models.main import OGCServer
transaction.commit()
ogcserver = OGCServer(name="__test_ogc_server")
ogcserver.url = mapserv_url
DBSession.add(ogcserver)
transaction.commit()
caching.invalidate_region()
return ogcserver
def interface_test_data(dbsession, transact):
del transact
from c2cgeoportal_commons.models.main import Interface, LayerWMS, OGCServer, Theme
themes = []
for i in range(0, 5):
theme = Theme(name=f"theme_{i}", ordering=1)
themes.append(theme)
servers = [OGCServer(name=f"server_{i}") for i in range(0, 4)]
layers = []
for i in range(0, 15):
layer = LayerWMS(name=f"layer_wms_{i}")
layer.public = 1 == i % 2
layer.ogc_server = servers[i % 4]
dbsession.add(layer)
layers.append(layer)
interfaces = []
for i in range(0, 5):
interface = Interface(name=f"interface_{i}", description=f"description_{i}")
interface.themes = [themes[i % 2], themes[(i + 5) % 5]]
interface.layers = [layers[i % 2], layers[(i + 4) % 5]]
dbsession.add(interface)
interfaces.append(interface)
dbsession.flush()
yield {"interfaces": interfaces}
def layer_vectortiles_test_data(dbsession, transact):
del transact
from c2cgeoportal_commons.models.main import LayerVectorTiles, OGCServer
servers = [OGCServer(name="server_{}".format(i)) for i in range(0, 4)]
for i, server in enumerate(servers):
server.url = "http://wms.geo.admin.ch_{}".format(i)
server.image_type = "image/jpeg" if i % 2 == 0 else "image/png"
def layer_builder(i):
name = "layer_vectortiles_{}".format(i)
layer = LayerVectorTiles(name=name)
layer.layer = name
layer.public = 1 == i % 2
layer.style = "https://vectortiles-staging.geoportail.lu/styles/roadmap/style.json"
layer.xyz = "https://vectortiles-staging.geoportail.lu/styles/roadmap/{z}/{x}/{y}.png"
return layer
datas = factory_build_layers(layer_builder, dbsession)
datas["default"] = get_test_default_layers(dbsession, server)
dbsession.flush()
yield datas
def restriction_area_test_data(dbsession, transact):
del transact
from c2cgeoportal_commons.models.main import LayerWMS, OGCServer, RestrictionArea, Role
roles = []
for i in range(0, 4):
roles.append(Role("secretary_" + str(i)))
dbsession.add_all(roles)
ogc_server = OGCServer(name="test_server")
layers = []
for i in range(0, 4):
layer = LayerWMS(name=f"layer_{i}", layer=f"layer_{i}", public=False)
layer.ogc_server = ogc_server
layers.append(layer)
dbsession.add_all(layers)
restrictionareas = []
for i in range(0, 4):
restrictionarea = RestrictionArea(name=f"restrictionarea_{i}")
restrictionarea.area = from_shape(box(485869.5728, 76443.1884,
837076.5648, 299941.7864),
srid=21781)
restrictionarea.description = f"description_{i}"
restrictionarea.roles = [roles[i % 4], roles[(i + 2) % 4]]
restrictionarea.layers = [layers[i % 4], layers[(i + 2) % 4]]
dbsession.add(restrictionarea)
restrictionareas.append(restrictionarea)
dbsession.flush()
yield {
"layers": layers,
"restriction_areas": restrictionareas,
"roles": roles,
}
def layer_wms_test_data(dbsession, transact):
del transact
from c2cgeoportal_commons.models.main import LayerWMS, OGCServer
servers = [OGCServer(name="server_{}".format(i)) for i in range(0, 4)]
for i, server in enumerate(servers):
server.url = "http://wms.geo.admin.ch_{}".format(i)
server.image_type = "image/jpeg" if i % 2 == 0 else "image/png"
def layer_builder(i):
layer = LayerWMS(name="layer_wms_{}".format(i))
layer.layer = "layer_{}".format(i)
layer.public = 1 == i % 2
layer.geo_table = "geotable_{}".format(i)
layer.ogc_server = servers[i % 4]
layer.style = "décontrasté"
return layer
datas = factory_build_layers(layer_builder, dbsession)
datas["servers"] = servers
datas["default"] = get_test_default_layers(dbsession, servers[1])
dbsession.flush()
yield datas
def setup_method(self, _):
# Always see the diff
# https://docs.python.org/2/library/unittest.html#unittest.TestCase.maxDiff
self.maxDiff = None
from c2cgeoportal_commons.models import DBSession
from c2cgeoportal_commons.models.main import OGCServer
setup_db()
ogcserver = OGCServer(name="MixedCaseOGCServer")
ogcserver.url = "http://mapserver:8080/"
DBSession.add(ogcserver)
DBSession.flush()
transaction.commit()
def ogc_server_test_data(dbsession, transact):
del transact
from c2cgeoportal_commons.models.main import OGCServer
auth = ["No auth", "Standard auth", "Geoserver auth", "Proxy"]
servers = []
for i in range(0, 8):
server = OGCServer(name=f"server_{i}", description=f"description_{i}")
server.url = f"https://somebasicurl_{i}.com"
server.image_type = "image/jpeg" if i % 2 == 0 else "image/png"
server.auth = auth[i % 4]
dbsession.add(server)
servers.append(server)
dbsession.flush()
yield {"ogc_servers": servers}
def ogc_server_test_data(dbsession, transact):
del transact
from c2cgeoportal_commons.models.main import OGCServer
auth = ['No auth', 'Standard auth', 'Geoserver auth', 'Proxy']
servers = []
for i in range(0, 8):
server = OGCServer(name='server_{}'.format(i),
description='description_{}'.format(i))
server.url = 'https://somebasicurl_{}.com'.format(i)
server.image_type = 'image/jpeg' if i % 2 == 0 else 'image/png'
server.auth = auth[i % 4]
dbsession.add(server)
servers.append(server)
dbsession.flush()
yield {'ogc_servers': servers}
def ogc_server_test_data(dbsession):
from c2cgeoportal_commons.models.main import OGCServer
dbsession.begin_nested()
auth = ['No auth', 'Standard auth', 'Geoserver auth', 'Proxy']
servers = []
for i in range(0, 8):
server = OGCServer(
name='server_{}'.format(i),
description='description_{}'.format(i))
server.url = 'https://somebasicurl_{}.com'.format(i)
server.image_type = 'image/jpeg' if i % 2 == 0 else 'image/png'
server.auth = auth[i % 4]
dbsession.add(server)
servers.append(server)
yield {
'ogc_servers': servers
}
dbsession.rollback()
def metadatas_test_data(dbsession, transact):
del transact
from c2cgeoportal_commons.models.main import \
LayerWMS, LayerWMTS, LayerV1, OGCServer, Metadata, Theme, LayerGroup
ogc_server = OGCServer(name='ogc_server')
layer_wms = LayerWMS(name='layer_wms')
layer_wms.layer = 'wms_layer'
layer_wms.ogc_server = ogc_server
layer_wms.metadatas = [
Metadata(name, value) for name, value in
[('_string',
'ceci est un test'), ('_liste',
'valeur1,valeur2'), ('_boolean',
'true'), ('_int', '1'),
('_float',
'2.5'), ('_url',
'https://localhost/test.html'), ('_json',
'{"key":"value"}'),
('_color', '#FFFFFF'), ('_unknown', 'This is a unknown format')]
]
for metadata in layer_wms.metadatas:
metadata.item = layer_wms
dbsession.add(layer_wms)
layer_wmts = LayerWMTS(name='layer_wmts')
layer_wmts.url = 'https://localhost'
layer_wmts.layer = 'wmts_layer'
dbsession.add(layer_wmts)
layer_v1 = LayerV1(name='layer_v1')
dbsession.add(layer_v1)
theme = Theme(name='theme')
dbsession.add(theme)
group = LayerGroup(name='groups')
dbsession.add(group)
dbsession.flush()
yield {
'ogc_server': ogc_server,
'layer_wms': layer_wms,
'layer_wmts': layer_wmts,
'layer_v1': layer_v1,
'theme': theme,
'group': group
}
def metadatas_test_data(dbsession, transact):
del transact
from c2cgeoportal_commons.models.main import LayerWMS, LayerWMTS, OGCServer, Metadata, Theme, LayerGroup
ogc_server = OGCServer(name="ogc_server")
layer_wms = LayerWMS(name="layer_wms")
layer_wms.layer = "wms_layer"
layer_wms.ogc_server = ogc_server
layer_wms.metadatas = [
Metadata(name, value)
for name, value in [
("_string", "ceci est un test"),
("_liste", "valeur1,valeur2"),
("_boolean", "true"),
("_int", "1"),
("_float", "2.5"),
("_url", "https://localhost/test.html"),
("_json", '{"key":"value"}'),
("_color", "#FFFFFF"),
("_unknown", "This is a unknown format"),
]
]
for metadata in layer_wms.metadatas:
metadata.item = layer_wms
dbsession.add(layer_wms)
layer_wmts = LayerWMTS(name="layer_wmts")
layer_wmts.url = "https://localhost"
layer_wmts.layer = "wmts_layer"
dbsession.add(layer_wmts)
theme = Theme(name="theme")
dbsession.add(theme)
group = LayerGroup(name="groups")
dbsession.add(group)
dbsession.flush()
yield {
"ogc_server": ogc_server,
"layer_wms": layer_wms,
"layer_wmts": layer_wmts,
"theme": theme,
"group": group,
}
def create_default_ogcserver():
import transaction
from c2cgeoportal_commons.models import DBSession
from c2cgeoportal_commons.models.main import OGCServer
transaction.commit()
ogcserver = OGCServer(name="__test_ogc_server")
ogcserver.url = mapserv_url
ogcserver_external = OGCServer(name="__test_external_ogc_server")
ogcserver_external.url = mapserv_url + "?external=true&"
DBSession.add_all([ogcserver, ogcserver_external])
transaction.commit()
return ogcserver, ogcserver_external
def layertree_test_data(dbsession, transact):
del transact
from c2cgeoportal_commons.models.main import (
LayerGroup,
LayergroupTreeitem,
LayerWMS,
LayerWMTS,
OGCServer,
Theme,
)
layers_wms = []
ogc_server = OGCServer(name="ogc_server")
dbsession.add(ogc_server)
for i in range(0, 10):
layer_wms = LayerWMS(name="layer_wms_{}".format(i))
layer_wms.ogc_server = ogc_server
layers_wms.append(layer_wms)
dbsession.add(layer_wms)
layers_wmts = []
for i in range(0, 10):
layer_wmts = LayerWMTS(name="layer_wmts_{}".format(i))
layer_wmts.url = "http://localhost/wmts"
layer_wmts.layer = layer_wmts.name
layers_wmts.append(layer_wmts)
dbsession.add(layer_wmts)
groups = []
for i in range(0, 10):
group = LayerGroup(name="layer_group_{}".format(i))
groups.append(group)
dbsession.add(group)
for j, items in enumerate((layers_wms, layers_wmts)):
dbsession.add(LayergroupTreeitem(group=group, item=items[i], ordering=j))
# a group in a group
dbsession.add(LayergroupTreeitem(group=groups[9], item=groups[8], ordering=3))
themes = []
for i in range(0, 5):
theme = Theme(name="theme_{}".format(i))
themes.append(theme)
dbsession.add(theme)
dbsession.add(LayergroupTreeitem(group=theme, item=groups[i], ordering=0))
dbsession.add(LayergroupTreeitem(group=theme, item=groups[i + 5], ordering=1))
themes[0].ordering = 1
themes[3].ordering = 2
themes[1].ordering = 3
themes[2].ordering = 4
themes[4].ordering = 5
dbsession.flush()
yield (
{
"themes": themes,
"groups": groups,
"layers_wms": layers_wms,
"layers_wmts": layers_wmts,
"ogc_servers": [ogc_server],
}
)
def setup_method(self, _):
# Always see the diff
# https://docs.python.org/2/library/unittest.html#unittest.TestCase.maxDiff
self.maxDiff = None
from c2cgeoportal_commons.models import DBSession
from c2cgeoportal_commons.models.main import Theme, LayerGroup, Interface, OGCServer, LayerWMS, LayerWMTS
main = Interface(name="main")
ogc_server_internal = create_default_ogcserver()
ogc_server_external = OGCServer(name="__test_ogc_server_external", url="http://wms.geo.admin.ch/", image_type="image/jpeg")
layer_internal_wms = LayerWMS(name="__test_layer_internal_wms", public=True)
layer_internal_wms.layer = "__test_layer_internal_wms"
layer_internal_wms.interfaces = [main]
layer_internal_wms.ogc_server = ogc_server_internal
layer_external_wms = LayerWMS(name="__test_layer_external_wms", layer="ch.swisstopo.dreiecksvermaschung", public=True)
layer_external_wms.interfaces = [main]
layer_external_wms.ogc_server = ogc_server_external
layer_wmts = LayerWMTS(name="__test_layer_wmts", public=True)
layer_wmts.url = "http://example.com/1.0.0/WMTSCapabilities.xml"
layer_wmts.layer = "map"
layer_wmts.interfaces = [main]
layer_group_1 = LayerGroup(name="__test_layer_group_1")
layer_group_1.children = [layer_internal_wms]
layer_group_2 = LayerGroup(name="__test_layer_group_2")
layer_group_2.children = [layer_external_wms]
layer_group_3 = LayerGroup(name="__test_layer_group_3")
layer_group_3.children = [layer_wmts]
layer_group_4 = LayerGroup(name="__test_layer_group_4")
layer_group_4.children = [layer_group_1, layer_group_2]
layer_group_5 = LayerGroup(name="__test_layer_group_5")
layer_group_5.children = [layer_group_1, layer_group_3]
layer_group_6 = LayerGroup(name="__test_layer_group_6")
layer_group_6.children = [layer_internal_wms]
layer_group_7 = LayerGroup(name="__test_layer_group_7")
layer_group_7.children = [layer_group_1, layer_group_6]
layer_group_8 = LayerGroup(name="__test_layer_group_8")
layer_group_8.children = [layer_group_2, layer_group_6]
theme = Theme(name="__test_theme")
theme.interfaces = [main]
theme.children = [
layer_group_1, layer_group_2, layer_group_3,
layer_group_4, layer_group_5,
layer_group_7, layer_group_8,
]
DBSession.add(theme)
transaction.commit()
def edit_url_test_data(dbsession, transact):
del transact
from c2cgeoportal_commons.models.main import \
LayerWMTS, RestrictionArea, Interface, Role, \
LayerWMS, LayerGroup, Theme, OGCServer, Functionality
restrictionareas = [
RestrictionArea(name='restrictionarea_{}'.format(i))
for i in range(0, 5)
]
functionalities = {}
for name in ('default_basemap', 'location'):
functionalities[name] = []
for v in range(0, 4):
functionality = Functionality(name=name,
value='value_{}'.format(v))
dbsession.add(functionality)
functionalities[name].append(functionality)
interfaces = [
Interface(name) for name in ['desktop', 'mobile', 'edit', 'routing']
]
ogc_server = OGCServer(name='ogc_server')
layers_wmts = []
for i in range(0, 5):
name = 'layer_wmts_{}'.format(i)
layer_wmts = LayerWMTS(name=name)
layer_wmts.layer = name
layer_wmts.url = 'https://server{}.net/wmts'.format(i)
layer_wmts.restrictionareas = [
restrictionareas[i % 5], restrictionareas[(i + 2) % 5]
]
if i % 10 != 1:
layer_wmts.interfaces = [
interfaces[i % 4], interfaces[(i + 2) % 4]
]
layer_wmts.public = 1 == i % 2
layer_wmts.image_type = 'image/jpeg'
dbsession.add(layer_wmts)
layers_wmts.append(layer_wmts)
layers_wms = []
for i in range(0, 5):
layer_wms = LayerWMS(name='layer_wms_{}'.format(i))
layer_wms.layer = 'wms_layer_{}'.format(i)
layer_wms.ogc_server = ogc_server
layers_wms.append(layer_wms)
dbsession.add(layer_wms)
layers_wms.append(layer_wms)
roles = []
for i in range(0, 5):
role = Role('secretary_' + str(i))
role.functionalities = [
functionalities['default_basemap'][0],
functionalities['location'][0], functionalities['location'][1]
]
role.restrictionareas = [restrictionareas[0], restrictionareas[1]]
dbsession.add(role)
roles.append(role)
dbsession.flush()
group = LayerGroup(name='groups')
dbsession.add(group)
theme = Theme(name='theme')
dbsession.add(theme)
dbsession.flush()
yield {
'ogc_server': ogc_server,
'layers_wmts': layers_wmts,
'layers_wms': layers_wms,
'restrictionareas': restrictionareas,
'interfaces': interfaces,
'themes': [theme],
'group': group,
'roles': roles
}
def setup_method(self, _):
# Always see the diff
# https://docs.python.org/2/library/unittest.html#unittest.TestCase.maxDiff
self.maxDiff = None
from c2cgeoportal_commons.models import DBSession
from c2cgeoportal_commons.models.main import \
Theme, LayerGroup, Functionality, Interface, OGCServer, LayerWMS, LayerWMTS, \
Metadata, Dimension, OGCSERVER_AUTH_NOAUTH
main = Interface(name="desktop")
mobile = Interface(name="mobile")
min_levels = Interface(name="min_levels")
ogc_server_internal, _ = create_default_ogcserver()
ogc_server_external = OGCServer(name="__test_ogc_server_chtopo",
url="http://wms.geo.admin.ch/",
image_type="image/jpeg",
auth=OGCSERVER_AUTH_NOAUTH)
ogc_server_external.wfs_support = False
layer_internal_wms = LayerWMS(name="__test_layer_internal_wms",
public=True)
layer_internal_wms.layer = "__test_layer_internal_wms"
layer_internal_wms.interfaces = [main, min_levels]
layer_internal_wms.metadatas = [Metadata("test", "internal_wms")]
layer_internal_wms.ogc_server = ogc_server_internal
layer_external_wms = LayerWMS(name="__test_layer_external_wms",
layer="ch.swisstopo.dreiecksvermaschung",
public=True)
layer_external_wms.interfaces = [main]
layer_external_wms.metadatas = [Metadata("test", "external_wms")]
layer_external_wms.ogc_server = ogc_server_external
layer_wmts = LayerWMTS(name="__test_layer_wmts", public=True)
layer_wmts.url = "http://example.com/1.0.0/WMTSCapabilities.xml"
layer_wmts.layer = "map"
layer_wmts.interfaces = [main, mobile]
layer_wmts.metadatas = [Metadata("test", "wmts")]
layer_wmts.dimensions = [Dimension("year", "2015")]
layer_group_1 = LayerGroup(name="__test_layer_group_1")
layer_group_1.children = [
layer_internal_wms, layer_external_wms, layer_wmts
]
layer_group_1.metadatas = [Metadata("test", "group_1")]
layer_group_2 = LayerGroup(name="__test_layer_group_2")
layer_group_2.children = [
layer_wmts, layer_internal_wms, layer_external_wms
]
layer_group_3 = LayerGroup(name="__test_layer_group_3")
layer_group_3.children = [
layer_wmts, layer_internal_wms, layer_external_wms
]
layer_group_4 = LayerGroup(name="__test_layer_group_4")
layer_group_4.children = [layer_group_2]
theme = Theme(name="__test_theme")
theme.interfaces = [main, mobile]
theme.metadatas = [Metadata("test", "theme")]
theme.children = [layer_group_1, layer_group_2]
theme_layer = Theme(name="__test_theme_layer")
theme_layer.interfaces = [min_levels]
theme_layer.children = [layer_internal_wms]
functionality1 = Functionality(name="test_name", value="test_value_1")
functionality2 = Functionality(name="test_name", value="test_value_2")
theme.functionalities = [functionality1, functionality2]
DBSession.add_all([theme, theme_layer])
transaction.commit()
def setup_method(self, _):
# Always see the diff
# https://docs.python.org/2/library/unittest.html#unittest.TestCase.maxDiff
self.maxDiff = None
from c2cgeoportal_commons.models import DBSession
from c2cgeoportal_commons.models.main import \
Theme, LayerGroup, Functionality, Interface, \
LayerV1, OGCServer, LayerWMS, LayerWMTS, \
Metadata, Dimension, OGCSERVER_AUTH_NOAUTH
main = Interface(name="desktop")
mobile = Interface(name="mobile")
min_levels = Interface(name="min_levels")
layer_v1 = LayerV1(name="__test_layer_v1", public=True)
layer_v1.interfaces = [main]
layer_v1.metadatas = [Metadata("test", "v1")]
ogc_server_internal, _ = create_default_ogcserver()
ogc_server_external = OGCServer(
name="__test_ogc_server_chtopo", url="http://wms.geo.admin.ch/",
image_type="image/jpeg", auth=OGCSERVER_AUTH_NOAUTH
)
ogc_server_external.wfs_support = False
layer_internal_wms = LayerWMS(name="__test_layer_internal_wms", public=True)
layer_internal_wms.layer = "__test_layer_internal_wms"
layer_internal_wms.interfaces = [main, min_levels]
layer_internal_wms.metadatas = [Metadata("test", "internal_wms")]
layer_internal_wms.ogc_server = ogc_server_internal
layer_external_wms = LayerWMS(name="__test_layer_external_wms", layer="ch.swisstopo.dreiecksvermaschung", public=True)
layer_external_wms.interfaces = [main]
layer_external_wms.metadatas = [Metadata("test", "external_wms")]
layer_external_wms.ogc_server = ogc_server_external
layer_wmts = LayerWMTS(name="__test_layer_wmts", public=True)
layer_wmts.url = "http://example.com/1.0.0/WMTSCapabilities.xml"
layer_wmts.layer = "map"
layer_wmts.interfaces = [main, mobile]
layer_wmts.metadatas = [Metadata("test", "wmts")]
layer_wmts.dimensions = [Dimension("year", "2015")]
layer_group_1 = LayerGroup(name="__test_layer_group_1")
layer_group_1.children = [layer_v1, layer_internal_wms, layer_external_wms, layer_wmts]
layer_group_1.metadatas = [Metadata("test", "group_1")]
layer_group_2 = LayerGroup(name="__test_layer_group_2")
layer_group_2.children = [layer_wmts, layer_internal_wms, layer_external_wms]
layer_group_3 = LayerGroup(name="__test_layer_group_3")
layer_group_3.children = [layer_wmts, layer_internal_wms, layer_external_wms]
layer_group_4 = LayerGroup(name="__test_layer_group_4")
layer_group_4.children = [layer_group_2]
theme = Theme(name="__test_theme")
theme.interfaces = [main, mobile]
theme.metadatas = [Metadata("test", "theme")]
theme.children = [
layer_group_1, layer_group_2
]
theme_layer = Theme(name="__test_theme_layer")
theme_layer.interfaces = [min_levels]
theme_layer.children = [
layer_internal_wms
]
functionality1 = Functionality(name="test_name", value="test_value_1")
functionality2 = Functionality(name="test_name", value="test_value_2")
theme.functionalities = [functionality1, functionality2]
DBSession.add_all([theme, theme_layer])
transaction.commit()
def setup_method(self, _):
self.maxDiff = None
from c2cgeoportal_commons.models import DBSession
from c2cgeoportal_commons.models.main import Role, LayerWMS, RestrictionArea, Interface, \
OGCServer, OGCSERVER_TYPE_MAPSERVER, OGCSERVER_AUTH_STANDARD
from c2cgeoportal_commons.models.static import User
cleanup_db()
create_default_ogcserver()
ogcserver_jpeg = OGCServer(name="__test_ogc_server_jpeg")
ogcserver_jpeg.url = mapserv_url
ogcserver_jpeg.image_type = "image/jpeg"
ogcserver_jpeg.type = OGCSERVER_TYPE_MAPSERVER
ogcserver_jpeg.auth = OGCSERVER_AUTH_STANDARD
ogcserver_png = OGCServer(name="__test_ogc_server_png")
ogcserver_png.url = mapserv_url
ogcserver_png.image_type = "image/png"
ogcserver_png.type = OGCSERVER_TYPE_MAPSERVER
ogcserver_png.auth = OGCSERVER_AUTH_STANDARD
ogcserver_wfs1 = OGCServer(name="__test_ogc_server_wfs1")
ogcserver_wfs1.url = mapserv_url
ogcserver_wfs1.url_wfs = "config://srv"
ogcserver_wfs1.image_type = "image/png"
ogcserver_wfs1.type = OGCSERVER_TYPE_MAPSERVER
ogcserver_wfs1.auth = OGCSERVER_AUTH_STANDARD
ogcserver_wfs2 = OGCServer(name="__test_ogc_server_wfs2")
ogcserver_wfs2.url = "config://srv"
ogcserver_wfs2.url_wfs = mapserv_url
ogcserver_wfs2.image_type = "image/png"
ogcserver_wfs2.type = OGCSERVER_TYPE_MAPSERVER
ogcserver_wfs2.auth = OGCSERVER_AUTH_STANDARD
role = Role(name="__test_role", description="__test_role")
user = User(username="******", password="******")
user.role_name = "__test_role"
main = Interface(name="main")
layer1 = LayerWMS("__test_layer1", public=False)
layer1.layer = "__test_private_layer1"
layer1.ogc_server = ogcserver_jpeg
layer1.interfaces = [main]
layer2 = LayerWMS("__test_layer2", public=False)
layer2.layer = "__test_private_layer2"
layer2.ogc_server = ogcserver_png
layer2.interfaces = [main]
layer3 = LayerWMS("__test_layer3", public=False)
layer3.layer = "__test_private_layer3"
layer3.ogc_server = ogcserver_wfs1
layer3.interfaces = [main]
layer4 = LayerWMS("__test_layer4", public=False)
layer4.layer = "__test_private_layer4"
layer4.ogc_server = ogcserver_wfs2
layer4.interfaces = [main]
restricted_area = RestrictionArea("__test_ra", "",
[layer1, layer2, layer3, layer4],
[role])
DBSession.add_all([user, restricted_area])
transaction.commit()
def main():
app_config = "production.ini"
app_name = "app"
if not os.path.isfile(app_config):
"Cannot find config file: {0!s}".format(app_config) + 0
# Ignores pyramid deprecation warnings
warnings.simplefilter("ignore", DeprecationWarning)
session = get_session(app_config, app_name)
from c2cgeoportal_commons.models import DBSession, main, static
from c2cgeoportal_commons.models.main import OGCSERVER_TYPE_MAPSERVER, \
OGCSERVER_TYPE_GEOSERVER,OGCSERVER_AUTH_NOAUTH, OGCServer, Metadata, \
TreeItem, TreeGroup, LayerGroup, LayerWMS, RestrictionArea, Interface
from geoportailv3_geoportal.models import LuxLayerInternalWMS
# Restriction area must have a name.
for r_area in session.query(RestrictionArea).all():
if r_area.name is None:
r_area.name = 'restrictionarea-{}'.format(r_area.id)
session.add(r_area)
###### select * from geov3.restrictionarea where name is null or name = '';
###### do we need a unique name?
transaction.commit()
# Create new ogc_server if not already exists based on url in LuxLayerInternalWMS.
for luxwms in session.query(LuxLayerInternalWMS).distinct(LuxLayerInternalWMS.url).all():
url = luxwms.url
if url is not None:
type = OGCSERVER_TYPE_GEOSERVER if 'arcgis' in url else OGCSERVER_TYPE_MAPSERVER
already_exists = session.query(OGCServer).filter(OGCServer.url == url).one_or_none()
if already_exists is None:
ogc_server = OGCServer(
name=url,
description='Generated during migration to GMF 2.3',
url=url,
type_=type,
image_type='image/png',
auth=OGCSERVER_AUTH_NOAUTH,
)
session.add(ogc_server)
transaction.commit()
# Set correct ogc_server for LuxLayerInternalWMS with url.
for luxwms in session.query(LuxLayerInternalWMS).all():
url = luxwms.url
if url is not None:
ogc_server = session.query(OGCServer).filter(OGCServer.url == url).one()
layer_wms = session.query(LayerWMS).filter(LayerWMS.id == luxwms.id).one()
layer_wms.ogc_server_id = ogc_server.id
session.add(layer_wms)
transaction.commit()
def setup_method(self, _):
# Always see the diff
# https://docs.python.org/2/library/unittest.html#unittest.TestCase.maxDiff
self.maxDiff = None # pylint: disable=invalid-name
self._tables = []
from c2cgeoportal_commons.models import DBSession
from c2cgeoportal_commons.models.main import Role, \
RestrictionArea, Theme, LayerGroup, Functionality, Interface, \
LayerWMS, OGCServer, FullTextSearch, OGCSERVER_TYPE_GEOSERVER, OGCSERVER_AUTH_GEOSERVER
from c2cgeoportal_commons.models.static import User
from sqlalchemy import Column, Table, types, func
from sqlalchemy.ext.declarative import declarative_base
from geoalchemy2 import Geometry
cleanup_db()
role1 = Role(name="__test_role1")
user1 = User(username="******",
password="******",
settings_role=role1,
roles=[role1])
user1.email = "*****@*****.**"
role2 = Role(name="__test_role2",
extent=WKTElement("POLYGON((1 2, 1 4, 3 4, 3 2, 1 2))",
srid=21781))
user2 = User(username="******",
password="******",
settings_role=role2,
roles=[role2])
main = Interface(name="desktop")
mobile = Interface(name="mobile")
engine = DBSession.c2c_rw_bind
engine.connect()
a_geo_table = Table("a_geo_table",
declarative_base(bind=engine).metadata,
Column("id", types.Integer, primary_key=True),
Column("geom", Geometry("POINT", srid=21781)),
schema="geodata")
self._tables = [a_geo_table]
a_geo_table.drop(checkfirst=True)
a_geo_table.create()
ogcserver = create_default_ogcserver()
private_layer_edit = LayerWMS(name="__test_private_layer_edit",
public=False)
private_layer_edit.layer = "__test_private_layer"
private_layer_edit.geo_table = "a_schema.a_geo_table"
private_layer_edit.interfaces = [main, mobile]
private_layer_edit.ogc_server = ogcserver
public_layer2 = LayerWMS(name="__test_public_layer",
layer="__test_public_layer_bis",
public=True)
public_layer2.interfaces = [main, mobile]
public_layer2.ogc_server = ogcserver
private_layer = LayerWMS(name="__test_private_layer",
layer="__test_private_layer_bis",
public=False)
private_layer.interfaces = [main, mobile]
private_layer.ogc_server = ogcserver
interface_not_in_mapfile = Interface(name="interface_not_in_mapfile")
public_layer_not_in_mapfile = LayerWMS(
name="__test_public_layer_not_in_mapfile",
layer="__test_public_layer_not_in_mapfile",
public=True)
public_layer_not_in_mapfile.interfaces = [interface_not_in_mapfile]
public_layer_not_in_mapfile.ogc_server = ogcserver
interface_notmapfile = Interface(name="interface_notmapfile")
ogcserver_notmapfile = OGCServer(name="__test_ogc_server_notmapfile")
ogcserver_notmapfile.url = mapserv_url + "?map=not_a_mapfile"
public_layer_not_mapfile = LayerWMS(
name="__test_public_layer_notmapfile",
layer="__test_public_layer_notmapfile",
public=True)
public_layer_not_mapfile.interfaces = [interface_notmapfile]
public_layer_not_mapfile.ogc_server = ogcserver_notmapfile
interface_geoserver = Interface(name="interface_geoserver")
ogcserver_geoserver = OGCServer(name="__test_ogc_server_geoserver")
ogcserver_geoserver.url = mapserv_url
ogcserver_geoserver.type = OGCSERVER_TYPE_GEOSERVER
ogcserver_geoserver.auth = OGCSERVER_AUTH_GEOSERVER
public_layer_geoserver = LayerWMS(
name="__test_public_layer_geoserver",
layer="__test_public_layer_geoserver",
public=True)
public_layer_geoserver.interfaces = [interface_geoserver]
public_layer_geoserver.ogc_server = ogcserver_geoserver
interface_no_layers = Interface(name="interface_no_layers")
public_layer_no_layers = LayerWMS(name="__test_public_layer_no_layers",
public=True)
public_layer_no_layers.interfaces = [interface_no_layers]
public_layer_no_layers.ogc_server = ogcserver
group = LayerGroup(name="__test_layer_group")
group.children = [
private_layer_edit, public_layer2, public_layer_not_in_mapfile,
public_layer_not_mapfile, public_layer_geoserver,
public_layer_no_layers, private_layer
]
theme = Theme(name="__test_theme")
theme.children = [group]
theme.interfaces = [
main, interface_not_in_mapfile, interface_notmapfile,
interface_geoserver, interface_no_layers
]
functionality1 = Functionality(name="test_name", value="test_value_1")
functionality2 = Functionality(name="test_name", value="test_value_2")
theme.functionalities = [functionality1, functionality2]
poly = "POLYGON((-100 0, -100 20, 100 20, 100 0, -100 0))"
area = WKTElement(poly, srid=21781)
RestrictionArea(name="__test_ra1",
description="",
layers=[private_layer_edit, private_layer],
roles=[role1],
area=area)
area = WKTElement(poly, srid=21781)
RestrictionArea(name="__test_ra2",
description="",
layers=[private_layer_edit, private_layer],
roles=[role2],
area=area,
readwrite=True)
entry1 = FullTextSearch()
entry1.label = "label1"
entry1.layer_name = "layer1"
entry1.ts = func.to_tsvector("french", "soleil travail")
entry1.the_geom = WKTElement("POINT(-90 -45)", 21781)
entry1.public = True
entry2 = FullTextSearch()
entry2.label = "label1"
entry2.layer_name = "layer1"
entry2.ts = func.to_tsvector("french", "soleil travail")
entry2.the_geom = WKTElement("POINT(-90 -45)", 21781)
entry2.public = True
entry3 = FullTextSearch()
entry3.label = "label1"
entry3.layer_name = None
entry3.ts = func.to_tsvector("french", "soleil travail")
entry3.the_geom = WKTElement("POINT(-90 -45)", 21781)
entry3.public = True
DBSession.add_all([user1, user2, theme, entry1, entry2, entry3])
DBSession.flush()
self.role1_id = role1.id
transaction.commit()
def setup_method(self, _):
# Always see the diff
# https://docs.python.org/2/library/unittest.html#unittest.TestCase.maxDiff
self.maxDiff = None
from c2cgeoportal_commons.models import DBSession
from c2cgeoportal_commons.models.main import Role, LayerWMS, RestrictionArea, \
Functionality, Interface, OGCServer, OGCSERVER_TYPE_GEOSERVER, OGCSERVER_AUTH_GEOSERVER
from c2cgeoportal_commons.models.static import User
cleanup_db()
ogc_server_internal, _ = create_default_ogcserver()
ogcserver_geoserver = OGCServer(name="__test_ogc_server_geoserver")
ogcserver_geoserver.url = mapserv_url
ogcserver_geoserver.type = OGCSERVER_TYPE_GEOSERVER
ogcserver_geoserver.auth = OGCSERVER_AUTH_GEOSERVER
PointTest.__table__.create(bind=DBSession.bind, checkfirst=True)
geom = WKTElement("POINT(599910 199955)", srid=21781)
p1 = PointTest(geom=geom, name="foo", city="Lausanne", country="Swiss")
geom = WKTElement("POINT(599910 200045)", srid=21781)
p2 = PointTest(geom=geom, name="bar", city="Chambéry", country="France")
geom = WKTElement("POINT(600090 200045)", srid=21781)
p3 = PointTest(geom=geom, name="éàè", city="Paris", country="France")
geom = WKTElement("POINT(600090 199955)", srid=21781)
p4 = PointTest(geom=geom, name="123", city="Londre", country="UK")
pt1 = Functionality(name="print_template", value="1 Wohlen A4 portrait")
pt2 = Functionality(name="print_template", value="2 Wohlen A3 landscape")
user1 = User(username="******", password="******")
role1 = Role(name="__test_role1", description="__test_role1", functionalities=[pt1, pt2])
user1.role_name = role1.name
user1.email = "Tarenpion"
user2 = User(username="******", password="******")
role2 = Role(name="__test_role2", description="__test_role2", functionalities=[pt1, pt2])
user2.role_name = role2.name
user2.email = "Tarenpion"
user3 = User(username="******", password="******")
role3 = Role(name="__test_role3", description="__test_role3", functionalities=[pt1, pt2])
user3.role_name = role3.name
main = Interface(name="main")
layer2 = LayerWMS("testpoint_protected", public=False)
layer2.layer = "testpoint_protected"
layer2.ogc_server = ogc_server_internal
layer2.interfaces = [main]
layer3 = LayerWMS("testpoint_protected_query_with_collect", public=False)
layer3.layer = "testpoint_protected_query_with_collect"
layer3.ogc_server = ogc_server_internal
layer3.interfaces = [main]
area = "POLYGON((599900 200030, 599900 200050, 600100 200050, 600100 200030, 599900 200030))"
area = WKTElement(area, srid=21781)
restricted_area1 = RestrictionArea("__test_ra1", "", [layer2, layer3], [role1], area)
area = "POLYGON((599900 200000, 599900 200020, 600100 200020, 600100 200000, 599900 200000))"
area = WKTElement(area, srid=21781)
restricted_area2 = RestrictionArea("__test_ra2", "", [layer2, layer3], [role2, role3], area)
area = "POLYGON((599905 200043, 599905 200047, 600095 200047, 600095 200043, 599905 200043))"
area = WKTElement(area, srid=21781)
restricted_area3 = RestrictionArea("__test_ra3", "", [layer3], [role3], area, readwrite=True)
DBSession.add_all([
p1, p2, p3, p4, user1, user2, user3, role1, role2, role3,
restricted_area1, restricted_area2, restricted_area3, ogcserver_geoserver
])
DBSession.flush()
self.id_lausanne = p1.id
self.id_paris = p3.id
self.ogc_server_id = ogc_server_internal.id
self.role1_id = role1.id
self.role2_id = role2.id
self.role3_id = role3.id
transaction.commit()
def ogc_server(session, settings):
from c2cgeoportal_commons.models.main import LayerV1, OGCServer, \
OGCSERVER_TYPE_QGISSERVER, OGCSERVER_TYPE_GEOSERVER, OGCSERVER_TYPE_OTHER, \
OGCSERVER_AUTH_GEOSERVER, OGCSERVER_AUTH_NOAUTH
qgis_re = []
geoserver_re = []
other_re = []
for e in settings.get("themev1tov2_qgis_res", "").split(","):
if e.strip() != "":
qgis_re.append(re.compile(e))
for e in settings.get("themev1tov2_geoserver_res", "").split(","):
if e.strip() != "":
geoserver_re.append(re.compile(e))
for e in settings.get("themev1tov2_other_res", "").split(","):
if e.strip() != "":
other_re.append(re.compile(e))
servers_v1 = session.query(
LayerV1.url, LayerV1.image_type, LayerV1.is_single_tile
).group_by(
LayerV1.url, LayerV1.image_type, LayerV1.is_single_tile
).filter(LayerV1.layer_type != "WMTS").all()
# get existing list of ogc_server
servers_ogc = session.query(OGCServer).all()
unique_servers = {
(
server.url,
server.image_type,
True if server.is_single_tile is None else server.is_single_tile
)
for server in servers_ogc
}
# add new ogc_server
for url, image_type, is_single_tile in servers_v1:
# default image_type
if image_type is None:
image_type = "image/png"
if is_single_tile is None:
is_single_tile = False
if url is None:
url = "config://internal/mapserv"
name = "source for {}".format(image_type)
else:
name = "source for {} {}".format(url, image_type)
if is_single_tile:
name += " with single_tile"
identifier = (url, image_type, is_single_tile)
if identifier not in unique_servers:
unique_servers.add(identifier)
new_ogc_server = OGCServer()
new_ogc_server.url = url
new_ogc_server.image_type = image_type
new_ogc_server.is_single_tile = is_single_tile
new_ogc_server.name = name
for e in qgis_re:
if e.search(url) is not None:
new_ogc_server.type = OGCSERVER_TYPE_QGISSERVER
break
for e in geoserver_re:
if e.search(url) is not None:
new_ogc_server.type = OGCSERVER_TYPE_GEOSERVER
new_ogc_server.auth = OGCSERVER_AUTH_GEOSERVER
break
for e in other_re:
if e.search(url) is not None:
new_ogc_server.type = OGCSERVER_TYPE_OTHER
new_ogc_server.auth = OGCSERVER_AUTH_NOAUTH
break
session.add(new_ogc_server)
transaction.commit()
def theme_test_data(dbsession, transact):
del transact
from c2cgeoportal_commons.models.main import \
Theme, Role, Functionality, LayergroupTreeitem, \
Interface, Metadata, LayerGroup, LayerWMS, OGCServer
interfaces = [
Interface(name) for name in ['desktop', 'mobile', 'edit', 'routing']
]
groups = [LayerGroup(name='layer_group_{}'.format(i)) for i in range(0, 5)]
layer = LayerWMS(name='layer_wms')
layer.ogc_server = OGCServer(name='server')
dbsession.add(layer)
layers = [layer]
functionalities = [
Functionality(name=name, value='value_{}'.format(v))
for name in ('default_basemap', 'location') for v in range(0, 4)
]
roles = [Role('secretary_' + str(i)) for i in range(0, 4)]
metadatas_protos = [('copyable', 'true'), ('disclaimer', '© le momo'),
('snappingConfig', '{"tolerance": 50}')]
themes = []
for i in range(0, 25):
theme = Theme(name='theme_{}'.format(i),
ordering=1,
icon='icon_{}'.format(i))
theme.public = 1 == i % 2
theme.interfaces = [interfaces[i % 4], interfaces[(i + 2) % 4]]
theme.metadatas = [
Metadata(name=metadatas_protos[id][0],
value=metadatas_protos[id][1])
for id in [i % 3, (i + 2) % 3]
]
for metadata in theme.metadatas:
metadata.item = theme
theme.functionalities = [
functionalities[i % 8], functionalities[(i + 3) % 8]
]
theme.restricted_roles = [roles[i % 4], roles[(i + 2) % 4]]
dbsession.add(
LayergroupTreeitem(group=theme,
item=groups[i % 5],
ordering=len(groups[i % 5].children_relation)))
dbsession.add(
LayergroupTreeitem(group=theme,
item=groups[(i + 3) % 5],
ordering=len(groups[(i + 3) %
5].children_relation)))
dbsession.add(theme)
themes.append(theme)
dbsession.flush()
yield {
'themes': themes,
'interfaces': interfaces,
'groups': groups,
'layers': layers,
'functionalities': functionalities,
'roles': roles,
}
def test_data(clean_dbsession):
from c2cgeoportal_commons.models.main import (
OGCSERVER_AUTH_STANDARD,
OGCSERVER_TYPE_QGISSERVER,
LayerWMS,
OGCServer,
RestrictionArea,
Role,
)
from c2cgeoportal_commons.models.static import User
DBSession = clean_dbsession # noqa: ignore=N806
dbsession = DBSession()
ogc_server1 = OGCServer(
name="qgisserver1",
type_=OGCSERVER_TYPE_QGISSERVER,
image_type="image/png",
auth=OGCSERVER_AUTH_STANDARD,
)
ogc_server2 = OGCServer(
name="qgisserver2",
type_=OGCSERVER_TYPE_QGISSERVER,
image_type="image/png",
auth=OGCSERVER_AUTH_STANDARD,
)
dbsession.add_all((ogc_server1, ogc_server2))
role1 = Role("role1")
role2 = Role("role2")
dbsession.add_all((role1, role2))
root = User("root")
root.id = 0
user1 = User("user1", roles=[role1])
user2 = User("user12", roles=[role1, role2])
dbsession.add_all((root, user1, user2))
project = QgsProject.instance()
for node in [{
"name":
"root",
"type":
"group",
"children": [
{
"name": "public_group",
"type": "group",
"children": [{
"name": "public_layer",
"type": "layer"
}],
},
{
"name": "private_group1",
"type": "group",
"children": [{
"name": "private_layer1",
"type": "layer"
}],
},
{
"name": "private_group2",
"type": "group",
"children": [{
"name": "private_layer2",
"type": "layer"
}],
},
# For group and layer short names
{
"name":
"private_group3",
"type":
"group",
"shortName":
"pg3",
"children": [{
"name": "private_layer3",
"type": "layer",
"shortName": "pl3"
}],
},
],
}]:
add_node_in_qgis_project(project, project.layerTreeRoot(), node)
public_group = LayerWMS(name="public_group",
layer="public_group",
public=True)
public_group.ogc_server = ogc_server1
public_layer = LayerWMS(name="public_layer",
layer="public_layer",
public=True)
public_layer.ogc_server = ogc_server1
private_layer1 = LayerWMS(name="private_layer1",
layer="private_layer1",
public=False)
private_layer1.ogc_server = ogc_server1
private_layer2 = LayerWMS(name="private_layer2",
layer="private_layer2",
public=False)
private_layer2.ogc_server = ogc_server1
private_group3 = LayerWMS(name="private_group3", layer="pg3", public=False)
private_group3.ogc_server = ogc_server1
private_layer3 = LayerWMS(name="private_layer3", layer="pl3", public=False)
private_layer3.ogc_server = ogc_server1
dbsession.add_all((
public_group,
public_layer,
private_layer1,
private_layer2,
private_group3,
private_layer3,
))
ra1 = RestrictionArea(
"restriction_area1",
layers=[private_layer1, private_layer3],
roles=[role1],
area=from_shape(area1, srid=21781),
)
ra2 = RestrictionArea("restriction_area2",
layers=[private_layer2],
roles=[role2],
readwrite=True)
dbsession.add_all((ra1, ra2))
dbsession.flush()
users = {
user.username: {
"id": user.id,
"role_ids": [r.id for r in user.roles]
}
for user in (root, user1, user2)
}
roles = {role.name: {"id": role.id} for role in (role1, role2)}
dbsession.commit()
dbsession.close()
yield {
# "ogc_servers": ogc_servers,
"roles": roles,
"users": users,
# "layers": layers,
# "restriction_areas": restriction_areas,
"project": project,
}
def test_data(dbsession):
from c2cgeoportal_commons.models.main import (
LayerWMS,
OGCServer,
OGCSERVER_TYPE_QGISSERVER,
OGCSERVER_AUTH_STANDARD,
RestrictionArea,
Role,
)
from c2cgeoportal_commons.models.static import User
ogc_server1 = OGCServer(
name="qgisserver1",
type_=OGCSERVER_TYPE_QGISSERVER,
image_type="image/png",
auth=OGCSERVER_AUTH_STANDARD,
)
ogc_server2 = OGCServer(
name="qgisserver2",
type_=OGCSERVER_TYPE_QGISSERVER,
image_type="image/png",
auth=OGCSERVER_AUTH_STANDARD,
)
ogc_servers = {
ogc_server.name: ogc_server
for ogc_server in (ogc_server1, ogc_server2)
}
dbsession.add_all(ogc_servers.values())
role1 = Role("role1")
role2 = Role("role2")
roles = {role.name: role for role in (role1, role2)}
dbsession.add_all(roles.values())
root = User("root")
root.id = 0
user1 = User("user1", roles=[role1])
user2 = User("user12", roles=[role1, role2])
users = {user.username: user for user in (root, user1, user2)}
dbsession.add_all(users.values())
project = QgsProject.instance()
def add_node(parent_node, node_def):
if node_def["type"] == "layer":
vlayer = QgsVectorLayer("Point", node_def["name"], "memory")
if "shortName" in node_def:
vlayer.setShortName(node_def["shortName"])
project.addMapLayer(vlayer)
node = project.layerTreeRoot().findLayer(vlayer)
clone = node.clone()
parent_node.addChildNode(clone)
node.parent().takeChild(node)
if node_def["type"] == "group":
node = parent_node.addGroup(node_def["name"])
if "shortName" in node_def:
node.setCustomProperty("wmsShortName", node_def["shortName"])
for child_def in node_def["children"]:
add_node(node, child_def)
for node in [{
"name":
"root",
"type":
"group",
"children": [
{
"name": "public_group",
"type": "group",
"children": [{
"name": "public_layer",
"type": "layer"
}],
},
{
"name": "private_group1",
"type": "group",
"children": [{
"name": "private_layer1",
"type": "layer"
}],
},
{
"name": "private_group2",
"type": "group",
"children": [{
"name": "private_layer2",
"type": "layer"
}],
},
# For group and layer short names
{
"name":
"private_group3",
"type":
"group",
"shortName":
"pg3",
"children": [{
"name": "private_layer3",
"type": "layer",
"shortName": "pl3"
}],
},
],
}]:
add_node(project.layerTreeRoot(), node)
public_group = LayerWMS(name="public_group",
layer="public_group",
public=True)
public_group.ogc_server = ogc_server1
public_layer = LayerWMS(name="public_layer",
layer="public_layer",
public=True)
public_layer.ogc_server = ogc_server1
private_layer1 = LayerWMS(name="private_layer1",
layer="private_layer1",
public=False)
private_layer1.ogc_server = ogc_server1
private_layer2 = LayerWMS(name="private_layer2",
layer="private_layer2",
public=False)
private_layer2.ogc_server = ogc_server1
private_group3 = LayerWMS(name="private_group3", layer="pg3", public=False)
private_group3.ogc_server = ogc_server1
private_layer3 = LayerWMS(name="private_layer3", layer="pl3", public=False)
private_layer3.ogc_server = ogc_server1
layers = {
layer.name: layer
for layer in (
public_group,
public_layer,
private_layer1,
private_layer2,
private_group3,
private_layer3,
)
}
dbsession.add_all(layers.values())
ra1 = RestrictionArea(
"restriction_area1",
layers=[private_layer1, private_layer3],
roles=[role1],
area=from_shape(area1, srid=21781),
)
ra2 = RestrictionArea("restriction_area2",
layers=[private_layer2],
roles=[role2],
readwrite=True)
restriction_areas = {ra.name: ra for ra in (ra1, ra2)}
dbsession.add_all(restriction_areas.values())
t = dbsession.begin_nested()
dbsession.flush()
yield {
"ogc_servers": ogc_servers,
"roles": roles,
"users": users,
"layers": layers,
"restriction_areas": restriction_areas,
}
t.rollback()
def ogc_server(session, settings):
from c2cgeoportal_commons.models.main import LayerV1, OGCServer, \
OGCSERVER_TYPE_QGISSERVER, OGCSERVER_TYPE_GEOSERVER, OGCSERVER_TYPE_OTHER, \
OGCSERVER_AUTH_GEOSERVER, OGCSERVER_AUTH_NOAUTH
qgis_re = []
geoserver_re = []
other_re = []
for e in settings.get("themev1tov2_qgis_res", "").split(","):
if e.strip() != "":
qgis_re.append(re.compile(e))
for e in settings.get("themev1tov2_geoserver_res", "").split(","):
if e.strip() != "":
geoserver_re.append(re.compile(e))
for e in settings.get("themev1tov2_other_res", "").split(","):
if e.strip() != "":
other_re.append(re.compile(e))
servers_v1 = session.query(
LayerV1.url, LayerV1.image_type, LayerV1.is_single_tile).group_by(
LayerV1.url, LayerV1.image_type,
LayerV1.is_single_tile).filter(LayerV1.layer_type != "WMTS").all()
# get existing list of ogc_server
servers_ogc = session.query(OGCServer).all()
unique_servers = {
(server.url, server.image_type,
True if server.is_single_tile is None else server.is_single_tile)
for server in servers_ogc
}
# add new ogc_server
for url, image_type, is_single_tile in servers_v1:
# default image_type
if image_type is None:
image_type = "image/png"
if is_single_tile is None:
is_single_tile = False
if url is None:
url = "config://internal/mapserv"
name = "source for {}".format(image_type)
else:
name = "source for {} {}".format(url, image_type)
if is_single_tile:
name += " with single_tile"
identifier = (url, image_type, is_single_tile)
if identifier not in unique_servers:
unique_servers.add(identifier)
new_ogc_server = OGCServer()
new_ogc_server.url = url
new_ogc_server.image_type = image_type
new_ogc_server.is_single_tile = is_single_tile
new_ogc_server.name = name
for e in qgis_re:
if e.search(url) is not None:
new_ogc_server.type = OGCSERVER_TYPE_QGISSERVER
break
for e in geoserver_re:
if e.search(url) is not None:
new_ogc_server.type = OGCSERVER_TYPE_GEOSERVER
new_ogc_server.auth = OGCSERVER_AUTH_GEOSERVER
break
for e in other_re:
if e.search(url) is not None:
new_ogc_server.type = OGCSERVER_TYPE_OTHER
new_ogc_server.auth = OGCSERVER_AUTH_NOAUTH
break
session.add(new_ogc_server)
transaction.commit()
def theme_test_data(dbsession, transact):
del transact
from c2cgeoportal_commons.models.main import (
Functionality,
Interface,
LayerGroup,
LayergroupTreeitem,
LayerWMS,
Metadata,
OGCServer,
Role,
Theme,
)
interfaces = [
Interface(name) for name in ["desktop", "mobile", "edit", "routing"]
]
groups = [LayerGroup(name="layer_group_{}".format(i)) for i in range(0, 5)]
layer = LayerWMS(name="layer_wms")
layer.ogc_server = OGCServer(name="server")
dbsession.add(layer)
layers = [layer]
functionalities = [
Functionality(name=name, value="value_{}".format(v))
for name in ("default_basemap", "location") for v in range(0, 4)
]
roles = [Role("secretary_" + str(i)) for i in range(0, 4)]
metadatas_protos = [
("copyable", "true"),
("disclaimer", "© le momo"),
("snappingConfig", '{"tolerance": 50}'),
]
themes = []
for i in range(0, 25):
theme = Theme(name="theme_{}".format(i),
ordering=1,
icon="icon_{}".format(i))
theme.public = 1 == i % 2
theme.interfaces = [interfaces[i % 4], interfaces[(i + 2) % 4]]
theme.metadatas = [
Metadata(name=metadatas_protos[id][0],
value=metadatas_protos[id][1])
for id in [i % 3, (i + 2) % 3]
]
for metadata in theme.metadatas:
metadata.item = theme
theme.functionalities = [
functionalities[i % 8], functionalities[(i + 3) % 8]
]
theme.restricted_roles = [roles[i % 4], roles[(i + 2) % 4]]
dbsession.add(
LayergroupTreeitem(group=theme,
item=groups[i % 5],
ordering=len(groups[i % 5].children_relation)))
dbsession.add(
LayergroupTreeitem(group=theme,
item=groups[(i + 3) % 5],
ordering=len(groups[(i + 3) %
5].children_relation)))
dbsession.add(theme)
themes.append(theme)
dbsession.flush()
yield {
"themes": themes,
"interfaces": interfaces,
"groups": groups,
"layers": layers,
"functionalities": functionalities,
"roles": roles,
}
def setup_method(self, _):
# Always see the diff
# https://docs.python.org/2/library/unittest.html#unittest.TestCase.maxDiff
self.maxDiff = None
from c2cgeoportal_commons.models import DBSession
from c2cgeoportal_commons.models.main import Role, LayerWMS, RestrictionArea, \
Functionality, Interface, OGCServer, OGCSERVER_TYPE_GEOSERVER, OGCSERVER_AUTH_GEOSERVER
from c2cgeoportal_commons.models.static import User
cleanup_db()
ogc_server_internal, _ = create_default_ogcserver()
ogcserver_geoserver = OGCServer(name="__test_ogc_server_geoserver")
ogcserver_geoserver.url = mapserv_url
ogcserver_geoserver.type = OGCSERVER_TYPE_GEOSERVER
ogcserver_geoserver.auth = OGCSERVER_AUTH_GEOSERVER
PointTest.__table__.create(bind=DBSession.bind, checkfirst=True)
geom = WKTElement("POINT(599910 199955)", srid=21781)
p1 = PointTest(geom=geom, name="foo", city="Lausanne", country="Swiss")
geom = WKTElement("POINT(599910 200045)", srid=21781)
p2 = PointTest(geom=geom,
name="bar",
city="Chambéry",
country="France")
geom = WKTElement("POINT(600090 200045)", srid=21781)
p3 = PointTest(geom=geom, name="éàè", city="Paris", country="France")
geom = WKTElement("POINT(600090 199955)", srid=21781)
p4 = PointTest(geom=geom, name="123", city="Londre", country="UK")
pt1 = Functionality(name="print_template",
value="1 Wohlen A4 portrait")
pt2 = Functionality(name="print_template",
value="2 Wohlen A3 landscape")
role1 = Role(name="__test_role1",
description="__test_role1",
functionalities=[pt1, pt2])
user1 = User(username="******",
password="******",
roles=[role1])
user1.email = "Tarenpion"
role2 = Role(name="__test_role2",
description="__test_role2",
functionalities=[pt1, pt2])
user2 = User(username="******",
password="******",
settings_role=role2,
roles=[role2])
user2.email = "Tarenpion"
role3 = Role(name="__test_role3",
description="__test_role3",
functionalities=[pt1, pt2])
user3 = User(username="******",
password="******",
settings_role=role3,
roles=[role3])
role4 = Role(name="__test_role4",
description="__test_role4",
functionalities=[pt1, pt2])
role5 = Role(name="__test_role5",
description="__test_role5",
functionalities=[pt1, pt2])
user4 = User(username="******",
password="******",
settings_role=role3,
roles=[role4, role5])
main = Interface(name="main")
layer2 = LayerWMS("testpoint_protected", public=False)
layer2.layer = "testpoint_protected"
layer2.ogc_server = ogc_server_internal
layer2.interfaces = [main]
layer3 = LayerWMS("testpoint_protected_query_with_collect",
public=False)
layer3.layer = "testpoint_protected_query_with_collect"
layer3.ogc_server = ogc_server_internal
layer3.interfaces = [main]
area = "POLYGON((599900 200030, 599900 200050, 600100 200050, 600100 200030, 599900 200030))"
area = WKTElement(area, srid=21781)
restricted_area1 = RestrictionArea("__test_ra1", "", [layer2, layer3],
[role1], area)
area = "POLYGON((599900 200000, 599900 200020, 600100 200020, 600100 200000, 599900 200000))"
area = WKTElement(area, srid=21781)
restricted_area2 = RestrictionArea("__test_ra2", "", [layer2, layer3],
[role2, role3], area)
area = "POLYGON((599905 200043, 599905 200047, 600095 200047, 600095 200043, 599905 200043))"
area = WKTElement(area, srid=21781)
restricted_area3 = RestrictionArea("__test_ra3",
"", [layer3], [role3],
area,
readwrite=True)
area = "POLYGON((599909 199954, 599911 199954, 599911 199956, 599909 199956, 599909 199954))"
area = WKTElement(area, srid=21781)
restricted_area4 = RestrictionArea("__test_ra4",
"", [layer2], [role4],
area,
readwrite=True)
area = "POLYGON((599909 200044, 599911 200044, 599911 200046, 599909 200046, 599909 200044))"
area = WKTElement(area, srid=21781)
restricted_area5 = RestrictionArea("__test_ra5",
"", [layer2], [role5],
area,
readwrite=True)
DBSession.add_all([
p1,
p2,
p3,
p4,
user1,
user2,
user3,
user4,
role1,
role2,
role3,
ogcserver_geoserver,
restricted_area1,
restricted_area2,
restricted_area3,
restricted_area4,
restricted_area5,
])
DBSession.flush()
self.id_lausanne = p1.id
self.id_paris = p3.id
self.ogc_server_id = ogc_server_internal.id
self.user1_id = user1.id
self.user2_id = user2.id
self.user3_id = user3.id
transaction.commit()
def test_data(dbsession):
from c2cgeoportal_commons.models.main import (
LayerWMS,
OGCServer,
OGCSERVER_TYPE_QGISSERVER,
OGCSERVER_AUTH_STANDARD,
RestrictionArea,
Role,
)
from c2cgeoportal_commons.models.static import User
ogc_server1 = OGCServer(name='qgisserver1',
type_=OGCSERVER_TYPE_QGISSERVER,
image_type='image/png',
auth=OGCSERVER_AUTH_STANDARD)
ogc_server2 = OGCServer(name='qgisserver2',
type_=OGCSERVER_TYPE_QGISSERVER,
image_type='image/png',
auth=OGCSERVER_AUTH_STANDARD)
ogc_servers = {
ogc_server.name: ogc_server
for ogc_server in (ogc_server1, ogc_server2)
}
dbsession.add_all(ogc_servers.values())
role1 = Role('role1')
role2 = Role('role2')
roles = {role.name: role for role in (role1, role2)}
dbsession.add_all(roles.values())
user1 = User('user1', roles=[role1])
user2 = User('user12', roles=[role1, role2])
users = {user.username: user for user in (user1, user2)}
dbsession.add_all(users.values())
project = QgsProject.instance()
def add_node(parent_node, node_def):
if node_def['type'] == 'layer':
vlayer = QgsVectorLayer("Point", node_def['name'], 'memory')
project.addMapLayer(vlayer)
node = project.layerTreeRoot().findLayer(vlayer)
clone = node.clone()
parent_node.addChildNode(clone)
node.parent().takeChild(node)
if node_def['type'] == 'group':
node = parent_node.addGroup(node_def['name'])
for child_def in node_def['children']:
add_node(node, child_def)
for node in [{
'name':
'root',
'type':
'group',
'children': [
{
'name': 'public_group',
'type': 'group',
'children': [{
'name': 'public_layer',
'type': 'layer'
}]
},
{
'name': 'private_group1',
'type': 'group',
'children': [{
'name': 'private_layer1',
'type': 'layer'
}]
},
{
'name': 'private_group2',
'type': 'group',
'children': [{
'name': 'private_layer2',
'type': 'layer'
}]
},
]
}]:
add_node(project.layerTreeRoot(), node)
public_group = LayerWMS(name='public_group',
layer='public_group',
public=True)
public_group.ogc_server = ogc_server1
public_layer = LayerWMS(name='public_layer',
layer='public_layer',
public=True)
public_layer.ogc_server = ogc_server1
private_layer1 = LayerWMS(name='private_layer1',
layer='private_layer1',
public=False)
private_layer1.ogc_server = ogc_server1
private_layer2 = LayerWMS(name='private_layer2',
layer='private_layer2',
public=False)
private_layer2.ogc_server = ogc_server1
layers = {
layer.name: layer
for layer in (public_group, public_layer, private_layer1,
private_layer2)
}
dbsession.add_all(layers.values())
ra1 = RestrictionArea('restriction_area1',
layers=[private_layer1],
roles=[role1],
area=from_shape(area1, srid=21781))
ra2 = RestrictionArea('restriction_area2',
layers=[private_layer2],
roles=[role2],
readwrite=True)
restriction_areas = {ra.name: ra for ra in (ra1, ra2)}
dbsession.add_all(restriction_areas.values())
t = dbsession.begin_nested()
dbsession.flush()
yield {
'ogc_servers': ogc_servers,
'roles': roles,
'users': users,
'layers': layers,
'restriction_areas': restriction_areas,
}
t.rollback()
def test_data2(clean_dbsession):
from c2cgeoportal_commons.models.main import (
OGCSERVER_AUTH_STANDARD,
OGCSERVER_TYPE_QGISSERVER,
LayerWMS,
OGCServer,
RestrictionArea,
Role,
TreeItem,
)
from c2cgeoportal_commons.models.static import User
DBSession = clean_dbsession # noqa: ignore=N806
dbsession = DBSession()
for r in dbsession.query(TreeItem).all():
print(r.id)
ogc_server1 = OGCServer(
name="qgisserver",
type_=OGCSERVER_TYPE_QGISSERVER,
image_type="image/png",
auth=OGCSERVER_AUTH_STANDARD,
)
dbsession.add(ogc_server1)
role1 = Role("role_no_access")
role2 = Role("role_full_access")
role3 = Role("role_area_access")
dbsession.add_all((role1, role2, role3))
user_no_access = User("user_no_access", roles=[role1])
user_full_access = User("user_full_access", roles=[role2])
user_area_access = User("user_area_access", roles=[role3])
dbsession.add_all((user_no_access, user_full_access, user_area_access))
project = QgsProject.instance()
for node in [
{
"name":
"root",
"type":
"group",
"children": [
{
"name": "private_group",
"type": "group",
"children": [{
"name": "private_layer",
"type": "layer"
}],
},
],
},
]:
add_node_in_qgis_project(project, project.layerTreeRoot(), node)
private_layer = LayerWMS(name="private_layer",
layer="private_layer",
public=False)
private_layer.ogc_server = ogc_server1
dbsession.add(private_layer)
ra1 = RestrictionArea("restriction_area_no",
layers=[private_layer],
roles=[role1])
ra2 = RestrictionArea("restriction_area_full",
layers=[private_layer],
roles=[role2],
readwrite=True)
ra3 = RestrictionArea(
"restriction_area_area",
layers=[private_layer],
roles=[role3],
readwrite=True,
area=from_shape(area1, srid=21781),
)
dbsession.add_all((ra1, ra2, ra3))
dbsession.flush()
roles = {role.name: {"id": role.id} for role in (role1, role2, role3)}
users = {
user.username: {
"id": user.id,
"role_ids": [r.id for r in user.roles]
}
for user in (user_no_access, user_full_access, user_area_access)
}
dbsession.commit()
dbsession.close()
yield {
"users": users,
"roles": roles,
"project": project,
}
def setup_method(self, _):
self.maxDiff = None
from c2cgeoportal_commons.models import DBSession
from c2cgeoportal_commons.models.main import Role, LayerWMS, RestrictionArea, Interface, \
OGCServer, OGCSERVER_TYPE_MAPSERVER, OGCSERVER_AUTH_STANDARD
from c2cgeoportal_commons.models.static import User
cleanup_db()
create_default_ogcserver()
ogcserver_jpeg = OGCServer(name="__test_ogc_server_jpeg")
ogcserver_jpeg.url = mapserv_url
ogcserver_jpeg.image_type = "image/jpeg"
ogcserver_jpeg.type = OGCSERVER_TYPE_MAPSERVER
ogcserver_jpeg.auth = OGCSERVER_AUTH_STANDARD
ogcserver_png = OGCServer(name="__test_ogc_server_png")
ogcserver_png.url = mapserv_url
ogcserver_png.image_type = "image/png"
ogcserver_png.type = OGCSERVER_TYPE_MAPSERVER
ogcserver_png.auth = OGCSERVER_AUTH_STANDARD
ogcserver_wfs1 = OGCServer(name="__test_ogc_server_wfs1")
ogcserver_wfs1.url = mapserv_url
ogcserver_wfs1.url_wfs = "config://srv"
ogcserver_wfs1.image_type = "image/png"
ogcserver_wfs1.type = OGCSERVER_TYPE_MAPSERVER
ogcserver_wfs1.auth = OGCSERVER_AUTH_STANDARD
ogcserver_wfs2 = OGCServer(name="__test_ogc_server_wfs2")
ogcserver_wfs2.url = "config://srv"
ogcserver_wfs2.url_wfs = mapserv_url
ogcserver_wfs2.image_type = "image/png"
ogcserver_wfs2.type = OGCSERVER_TYPE_MAPSERVER
ogcserver_wfs2.auth = OGCSERVER_AUTH_STANDARD
role = Role(name="__test_role", description="__test_role")
user = User(username="******", password="******")
user.role_name = "__test_role"
main = Interface(name="main")
layer1 = LayerWMS("__test_layer1", public=False)
layer1.layer = "__test_private_layer1"
layer1.ogc_server = ogcserver_jpeg
layer1.interfaces = [main]
layer2 = LayerWMS("__test_layer2", public=False)
layer2.layer = "__test_private_layer2"
layer2.ogc_server = ogcserver_png
layer2.interfaces = [main]
layer3 = LayerWMS("__test_layer3", public=False)
layer3.layer = "__test_private_layer3"
layer3.ogc_server = ogcserver_wfs1
layer3.interfaces = [main]
layer4 = LayerWMS("__test_layer4", public=False)
layer4.layer = "__test_private_layer4"
layer4.ogc_server = ogcserver_wfs2
layer4.interfaces = [main]
restricted_area = RestrictionArea("__test_ra", "", [layer1, layer2, layer3, layer4], [role])
DBSession.add_all([
user, restricted_area
])
transaction.commit()
def edit_url_test_data(dbsession, transact):
del transact
from c2cgeoportal_commons.models.main import (
Functionality,
Interface,
LayerGroup,
LayerWMS,
LayerWMTS,
OGCServer,
RestrictionArea,
Role,
Theme,
)
restrictionareas = [
RestrictionArea(name=f"restrictionarea_{i}") for i in range(0, 5)
]
functionalities = {}
for name in ("default_basemap", "default_theme"):
functionalities[name] = []
for v in range(0, 4):
functionality = Functionality(name=name, value=f"value_{v}")
dbsession.add(functionality)
functionalities[name].append(functionality)
interfaces = [
Interface(name) for name in ["desktop", "mobile", "edit", "routing"]
]
ogc_server = OGCServer(name="ogc_server")
layers_wmts = []
for i in range(0, 5):
name = f"layer_wmts_{i}"
layer_wmts = LayerWMTS(name=name)
layer_wmts.layer = name
layer_wmts.url = f"https://server{i}.net/wmts"
layer_wmts.restrictionareas = [
restrictionareas[i % 5], restrictionareas[(i + 2) % 5]
]
if i % 10 != 1:
layer_wmts.interfaces = [
interfaces[i % 4], interfaces[(i + 2) % 4]
]
layer_wmts.public = 1 == i % 2
layer_wmts.image_type = "image/jpeg"
dbsession.add(layer_wmts)
layers_wmts.append(layer_wmts)
layers_wms = []
for i in range(0, 5):
layer_wms = LayerWMS(name=f"layer_wms_{i}")
layer_wms.layer = f"wms_layer_{i}"
layer_wms.ogc_server = ogc_server
layers_wms.append(layer_wms)
dbsession.add(layer_wms)
layers_wms.append(layer_wms)
roles = []
for i in range(0, 5):
role = Role("secretary_" + str(i))
role.functionalities = [
functionalities["default_theme"][0],
]
role.restrictionareas = [restrictionareas[0], restrictionareas[1]]
dbsession.add(role)
roles.append(role)
dbsession.flush()
group = LayerGroup(name="groups")
dbsession.add(group)
theme = Theme(name="theme")
dbsession.add(theme)
dbsession.flush()
yield {
"ogc_server": ogc_server,
"layers_wmts": layers_wmts,
"layers_wms": layers_wms,
"restrictionareas": restrictionareas,
"interfaces": interfaces,
"themes": [theme],
"group": group,
"roles": roles,
}
