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 Interface, LayerWMS, RestrictionArea, Role
from c2cgeoportal_commons.models.static import User
setup_db()
user1 = User(username="******", password="******")
role1 = Role(name="__test_role1", description="__test_role1")
user1.roles = [role1]
user1.email = "Tarenpion"
user2 = User(username="******", password="******")
role2 = Role(name="__test_role2", description="__test_role2")
user2.roles = [role2]
user2.email = "Tarenpion"
ogc_server_internal = create_default_ogcserver()
main = Interface(name="main")
layer1 = LayerWMS("layer_1", public=False)
layer1.layer = "layer_1"
layer1.ogc_server = ogc_server_internal
layer1.interfaces = [main]
layer2 = LayerWMS("layer_2", public=False)
layer2.layer = "layer_2"
layer2.ogc_server = ogc_server_internal
layer2.interfaces = [main]
layer3 = LayerWMS("layer_3", public=False)
layer3.layer = "layer_3"
layer3.ogc_server = ogc_server_internal
layer3.interfaces = [main]
area = "POLYGON((-100 30, -100 50, 100 50, 100 30, -100 30))"
area = WKTElement(area, srid=21781)
restricted_area1 = RestrictionArea("__test_ra1",
"", [layer1, layer2], [role1],
area,
readwrite=True)
area = "POLYGON((-100 0, -100 20, 100 20, 100 0, -100 0))"
area = WKTElement(area, srid=21781)
restricted_area2 = RestrictionArea("__test_ra2", "",
[layer1, layer2, layer3], [role2],
area)
DBSession.add_all(
[user1, user2, role1, role2, restricted_area1, restricted_area2])
transaction.commit()
def setup_method(self, _):
from c2cgeoportal_commons.models import DBSession
from c2cgeoportal_commons.models.main import Role, LayerWMS, RestrictionArea, Interface
from c2cgeoportal_commons.models.static import User
ogc_server_internal = create_default_ogcserver()
role1 = Role(name="__test_role1", description="__test_role1")
user1 = User(username="******",
password="******",
settings_role=role1,
roles=[role1])
user1.email = "Tarenpion"
main = Interface(name="main")
layer1 = LayerWMS("testpoint_group_name", public=False)
layer1.layer = "testpoint_group"
layer1.ogc_server = ogc_server_internal
layer1.interfaces = [main]
layer2 = LayerWMS("testpoint_protected_2_name", public=False)
layer2.layer = "testpoint_protected_2"
layer2.ogc_server = ogc_server_internal
layer2.interfaces = [main]
area = "POLYGON((-100 30, -100 50, 100 50, 100 30, -100 30))"
area = WKTElement(area, srid=21781)
restricted_area1 = RestrictionArea("__test_ra1", "", [layer1, layer2],
[role1], area)
DBSession.add_all([user1, role1, layer1, layer2, restricted_area1])
DBSession.flush()
transaction.commit()
def roles_test_data(dbsession, transact):
del transact
from c2cgeoportal_commons.models.main import Role, Functionality, RestrictionArea
from c2cgeoportal_commons.models.static import User
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)
restrictionareas = []
for i in range(0, 5):
restrictionarea = RestrictionArea(
name='restrictionarea_{}'.format(i))
dbsession.add(restrictionarea)
restrictionareas.append(restrictionarea)
roles = []
for i in range(0, 23):
role = Role('secretary_' + str(i))
role.functionalities = [
functionalities['default_basemap'][0],
functionalities['location'][0],
functionalities['location'][1]]
role.restrictionareas = [
restrictionareas[0],
restrictionareas[1]]
role.extent = from_shape(box(485869.5728, 76443.1884, 837076.5648, 299941.7864),
srid=21781)
dbsession.add(role)
roles.append(role)
# Users roles must not be broken with role name changes
users = []
for i in range(0, 23):
user = User("babar_" + str(i),
email='mail' + str(i),
settings_role=roles[i],
roles=[roles[i]])
user.password = '******'
user.is_password_changed = i % 2 == 1
users.append(user)
dbsession.add(user)
dbsession.flush()
yield {
'functionalities': functionalities,
'restrictionareas': restrictionareas,
'users': users,
'roles': roles
}
def factory_build_layers(layer_builder, dbsession, add_dimension=True):
from c2cgeoportal_commons.models.main import \
RestrictionArea, LayergroupTreeitem, \
Interface, Dimension, Metadata, LayerGroup
restrictionareas = [RestrictionArea(name='restrictionarea_{}'.format(i))
for i in range(0, 5)]
interfaces = [Interface(name) for name in ['desktop', 'mobile', 'edit', 'routing']]
dimensions_protos = [('Date', '2017'),
('Date', '2018'),
('Date', '1988'),
('CLC', 'all'), ]
metadatas_protos = [('copyable', 'true'),
('disclaimer', '© le momo'),
('snappingConfig', '{"tolerance": 50}')]
groups = [LayerGroup(name='layer_group_{}'.format(i)) for i in range(0, 5)]
layers = []
for i in range(0, 25):
layer = layer_builder(i)
if add_dimension:
layer.dimensions = [Dimension(name=dimensions_protos[id][0],
value=dimensions_protos[id][1],
layer=layer)
for id in [i % 3, (i + 2) % 4, (i + 3) % 4]]
layer.metadatas = [Metadata(name=metadatas_protos[id][0],
value=metadatas_protos[id][1])
for id in [i % 3, (i + 2) % 3]]
for metadata in layer.metadatas:
metadata.item = layer
if i % 10 != 1:
layer.interfaces = [interfaces[i % 4], interfaces[(i + 2) % 4]]
layer.restrictionareas = [restrictionareas[i % 5], restrictionareas[(i + 2) % 5]]
dbsession.add(LayergroupTreeitem(group=groups[i % 5],
item=layer,
ordering=len(groups[i % 5].children_relation)))
dbsession.add(LayergroupTreeitem(group=groups[(i + 3) % 5],
item=layer,
ordering=len(groups[(i + 3) % 5].children_relation)))
dbsession.add(layer)
layers.append(layer)
return {
'restrictionareas': restrictionareas,
'layers': layers,
'interfaces': interfaces
}
def roles_test_data(dbsession, transact):
del transact
from c2cgeoportal_commons.models.main import Functionality, RestrictionArea, Role
from c2cgeoportal_commons.models.static import User
# Note that "default_basemap" is not relevant for roles
functionalities = {}
for name in ("default_basemap", "default_theme", "print_template"):
functionalities[name] = []
for v in range(0, 4):
functionality = Functionality(name=name, value=f"value_{v}")
dbsession.add(functionality)
functionalities[name].append(functionality)
restrictionareas = []
for i in range(0, 5):
restrictionarea = RestrictionArea(name=f"restrictionarea_{i}")
dbsession.add(restrictionarea)
restrictionareas.append(restrictionarea)
roles = []
for i in range(0, 23):
role = Role("secretary_" + str(i))
role.functionalities = [
functionalities["default_theme"][0],
functionalities["print_template"][0],
functionalities["print_template"][1],
]
role.restrictionareas = [restrictionareas[0], restrictionareas[1]]
role.extent = from_shape(box(485869.5728, 76443.1884, 837076.5648,
299941.7864),
srid=21781)
dbsession.add(role)
roles.append(role)
# Users roles must not be broken with role name changes
users = []
for i in range(0, 23):
user = User("babar_" + str(i),
email="mail" + str(i),
settings_role=roles[i],
roles=[roles[i]])
user.password = "******"
user.is_password_changed = i % 2 == 1
users.append(user)
dbsession.add(user)
dbsession.flush()
yield {
"functionalities": functionalities,
"restrictionareas": restrictionareas,
"users": users,
"roles": roles,
}
def restriction_area_test_data(dbsession, transact):
del transact
from c2cgeoportal_commons.models.main import RestrictionArea, Role
roles = []
for i in range(0, 4):
roles.append(Role("secretary_" + str(i)))
dbsession.add(roles[i])
restrictionareas = []
for i in range(0, 4):
restrictionarea = RestrictionArea(name='restrictionarea_{}'.format(i))
restrictionarea.area = \
from_shape(box(485869.5728, 76443.1884, 837076.5648, 299941.7864), srid=21781)
restrictionarea.description = 'description_{}'.format(i)
restrictionarea.roles = [roles[i % 4], roles[(i + 2) % 4]]
dbsession.add(restrictionarea)
restrictionareas.append(restrictionarea)
dbsession.flush()
yield {'restriction_areas': restrictionareas, 'roles': roles}
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 _create_layer(
self,
public=False,
none_area=False,
attr_list=False,
exclude_properties=False,
metadatas=None,
geom_type=False,
):
"""This function is central for this test class. It creates
a layer with two features, and associates a restriction area
to it."""
import transaction
from geoalchemy2 import Geometry, WKTElement
from sqlalchemy import CheckConstraint, Column, ForeignKey, Table, types
from sqlalchemy.ext.declarative import declarative_base
from c2cgeoportal_commons.models import DBSession
from c2cgeoportal_commons.models.main import LayerWMS, OGCServer, RestrictionArea
if self._tables is None:
self._tables = []
self.__class__._table_index += 1
id = self.__class__._table_index
engine = DBSession.c2c_rw_bind
connection = engine.connect()
if not self.metadata:
self.metadata = declarative_base(bind=engine).metadata
tablename = "table_{0:d}".format(id)
table1 = Table(
"{0!s}_child".format(tablename),
self.metadata,
Column("id", types.Integer, primary_key=True),
Column("name", types.Unicode),
schema="public",
)
if geom_type:
table1.append_column(Column("geom", Geometry("POINT", srid=21781)))
else:
table1.append_column(Column("geom", Geometry(srid=21781)))
self._tables.append(table1)
table2 = Table(
tablename,
self.metadata,
Column("id", types.Integer, primary_key=True),
Column("child_id", types.Integer,
ForeignKey("public.{0!s}_child.id".format(tablename))),
Column("name", types.Unicode),
Column(
"email",
types.Unicode,
CheckConstraint(
"""email ~* '^[A-Za-z0-9._%%-]
+@[A-Za-z0-9.-]+[.][A-Za-z]+$'""",
name="proper_email",
),
),
Column("last_update_user", types.Unicode),
Column("last_update_date", types.DateTime),
schema="public",
)
if geom_type:
table2.append_column(Column("geom", Geometry("POINT", srid=21781)))
else:
table2.append_column(Column("geom", Geometry(srid=21781)))
self._tables.append(table2)
table1.drop(checkfirst=True)
table2.drop(checkfirst=True)
table1.create()
table2.create()
ins = table1.insert().values(name="c1é")
c1_id = connection.execute(ins).inserted_primary_key[0]
ins = table1.insert().values(name="c2é")
c2_id = connection.execute(ins).inserted_primary_key[0]
ins = table2.insert().values(child_id=c1_id,
name="foo",
geom=WKTElement("POINT(5 45)", 21781))
connection.execute(ins)
ins = table2.insert().values(child_id=c2_id,
name="bar",
geom=WKTElement("POINT(6 46)", 21781))
connection.execute(ins)
if attr_list:
ins = table2.insert().values(child_id=c2_id,
name="aaa,bbb,foo",
geom=WKTElement("POINT(6 46)", 21781))
connection.execute(ins)
ogc_server = DBSession.query(OGCServer).filter(
OGCServer.name == "__test_ogc_server").one()
layer = LayerWMS()
layer.id = id
layer.name = str(id)
layer.ogc_server = ogc_server
layer.geo_table = tablename
layer.public = public
layer.interface = [self.main]
if exclude_properties:
layer.exclude_properties = "name"
if metadatas:
layer.metadatas = metadatas
DBSession.add(layer)
if not public:
ra = RestrictionArea()
ra.name = "__test_ra"
ra.layers = [layer]
ra.roles = [self.role]
ra.readwrite = True
if not none_area:
poly = "POLYGON((4 44, 4 46, 6 46, 6 44, 4 44))"
ra.area = WKTElement(poly, srid=21781)
DBSession.add(ra)
transaction.commit()
self.layer_ids.append(id)
return id
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 setUp(self): # noqa
# Always see the diff
# https://docs.python.org/2/library/unittest.html#unittest.TestCase.maxDiff
self.maxDiff = None
self.clean()
from c2cgeoportal_commons.models import DBSession
from c2cgeoportal_commons.models.static import User
from c2cgeoportal_commons.models.main import \
Theme, LayerGroup, Interface, LayerWMS, LayerWMTS, Role, RestrictionArea
main = Interface(name=u"desktop")
role = Role(name=u"__test_role")
user = User(username=u"__test_user",
password=u"__test_user",
role=role)
user.email = "*****@*****.**"
ogc_server_internal, _ = create_default_ogcserver()
layer_wms = LayerWMS(name=u"__test_layer_wms", public=True)
layer_wms.layer = "__test_public_layer"
layer_wms.interfaces = [main]
layer_wms.ogc_server = ogc_server_internal
layer_wms_private = LayerWMS(name=u"__test_layer_wms_private",
public=True)
layer_wms_private.layer = "__test_private_layer"
layer_wms_private.public = False
layer_wms_private.interfaces = [main]
layer_wms_private.ogc_server = ogc_server_internal
layer_wmts = LayerWMTS(name=u"__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_wmts_private = LayerWMTS(name=u"__test_layer_wmts_private",
public=True)
layer_wmts_private.url = "http://example.com/1.0.0/WMTSCapabilities.xml"
layer_wmts_private.layer = "map"
layer_wmts_private.public = False
layer_wmts_private.interfaces = [main]
layer_group = LayerGroup(name=u"__test_layer_group")
layer_group.children = [
layer_wms, layer_wms_private, layer_wmts, layer_wmts_private
]
theme = Theme(name=u"__test_theme")
theme.interfaces = [main]
theme.children = [layer_group]
restriction_area = RestrictionArea(
name=u"__test_ra1",
layers=[layer_wms_private, layer_wmts_private],
roles=[role])
DBSession.add_all([theme, restriction_area, user])
transaction.commit()
def setup_method(self, _):
# Always see the diff
# https://docs.python.org/2/library/unittest.html#unittest.TestCase.maxDiff
self.maxDiff = None
self._tables = []
from c2cgeoportal_geoportal.lib import functionality
functionality.FUNCTIONALITIES_TYPES = None
from c2cgeoportal_commons.models import DBSession
from c2cgeoportal_commons.models.main import Role, \
RestrictionArea, TreeItem, Theme, LayerGroup, Interface, LayerWMS
from c2cgeoportal_commons.models.static import User
from sqlalchemy import Column, Table, types
from sqlalchemy.ext.declarative import declarative_base
from geoalchemy2 import Geometry
for o in DBSession.query(RestrictionArea).all():
DBSession.delete(o)
for o in DBSession.query(Role).all():
DBSession.delete(o)
for o in DBSession.query(User).all():
DBSession.delete(o)
for o in DBSession.query(TreeItem).all():
DBSession.delete(o)
ogcserver = create_default_ogcserver()
role1 = Role(name="__test_role1")
role1.id = 999
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="main")
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()
private_layer = LayerWMS(name="__test_private_layer", public=False)
private_layer.layer = "__test_private_layer"
private_layer.geo_table = "geodata.a_geo_table"
private_layer.interfaces = [main]
private_layer.ogc_server = ogcserver
group = LayerGroup(name="__test_layer_group")
group.children = [private_layer]
theme = Theme(name="__test_theme")
theme.children = [group]
theme.interfaces = [main]
DBSession.add(RestrictionArea(
name="__test_ra1", description="", layers=[private_layer],
roles=[role1],
))
DBSession.add(RestrictionArea(
name="__test_ra2", description="", layers=[private_layer],
roles=[role2], readwrite=True,
))
DBSession.add_all([
user1, user2, role1, role2, theme, group, private_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 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 _create_layer(self,
exclude_properties=False,
metadatas=None,
geom_type=False):
""" This function is central for this test class. It creates
a layer with two features, and associates a restriction area
to it. """
import transaction
from sqlalchemy import Column, Table, types, ForeignKey
from sqlalchemy.ext.declarative import declarative_base
from geoalchemy2 import Geometry
from c2cgeoportal_commons.models import DBSession
from c2cgeoportal_commons.models.main import RestrictionArea, LayerWMS
self.__class__._table_index += 1
id = self.__class__._table_index
engine = DBSession.c2c_rw_bind
connection = engine.connect()
if not self.metadata:
self.metadata = declarative_base(bind=engine).metadata
tablename = "geo_table_{0:d}".format(id)
schemaname = "geodata"
table1 = Table(
"{0!s}_child".format(tablename),
self.metadata,
Column("id", types.Integer, primary_key=True),
Column("name", types.Unicode),
schema=schemaname,
)
self._tables.append(table1)
table2 = Table(
tablename,
self.metadata,
Column("id", types.Integer, primary_key=True),
Column(
"child_id", types.Integer,
ForeignKey("{0!s}.{1!s}_child.id".format(
schemaname, tablename))),
Column("name", types.Unicode, nullable=False),
Column("deleted", types.Boolean),
Column("last_update_user", types.Unicode),
Column("last_update_date", types.DateTime),
Column("date", types.Date),
Column("start_time", types.Time),
# Column("interval", Interval()),
Column("short_name1", types.String, nullable=True),
Column("short_name2", types.String(50), nullable=True),
Column("short_number", types.Integer, nullable=True),
Column("double_number", types.Float(precision=4)),
Column("large_binary", types.LargeBinary(length=60),
nullable=True),
Column("value",
types.Enum("one", "two", "three", name="an_enum_value")),
Column("numeric",
types.Numeric(precision=5, scale=2),
nullable=True),
Column("numeric2", types.Numeric(), nullable=True),
schema=schemaname,
)
if geom_type:
table2.append_column(Column("geom", Geometry("POINT", srid=21781)))
else:
table2.append_column(Column("geom", Geometry(srid=21781)))
self._tables.append(table2)
table2.drop(checkfirst=True)
table1.drop(checkfirst=True)
table1.create()
table2.create()
ins = table1.insert().values(name="c1é")
connection.execute(ins).inserted_primary_key[0]
ins = table1.insert().values(name="c2é")
connection.execute(ins).inserted_primary_key[0]
layer = LayerWMS(name="test_WMS_1", public=True)
layer.layer = "test_wms"
layer.id = id
layer.geo_table = "{0!s}.{1!s}".format(schemaname, tablename)
layer.interfaces = [self.main]
layer.ogc_server = self.ogc_server
if exclude_properties:
layer.exclude_properties = "name"
if metadatas:
layer.metadatas = metadatas
DBSession.add(self.layer_group_1)
self.layer_group_1.children = self.layer_group_1.children + [layer]
DBSession.add(self.layer_group_1)
ra = RestrictionArea()
ra.name = "__test_ra"
ra.layers = [layer]
ra.roles = [self.role]
ra.readwrite = True
DBSession.add(ra)
transaction.commit()
self.layer_ids.append(id)
return id
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 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 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 _create_layer(self, exclude_properties=False, metadatas=None, geom_type=False):
""" This function is central for this test class. It creates
a layer with two features, and associates a restriction area
to it. """
import transaction
from sqlalchemy import Column, Table, types, ForeignKey
from sqlalchemy.ext.declarative import declarative_base
from geoalchemy2 import Geometry
from c2cgeoportal_commons.models import DBSession
from c2cgeoportal_commons.models.main import RestrictionArea, LayerWMS
self.__class__._table_index += 1
id = self.__class__._table_index
engine = DBSession.c2c_rw_bind
connection = engine.connect()
if not self.metadata:
self.metadata = declarative_base(bind=engine).metadata
tablename = "geo_table_{0:d}".format(id)
schemaname = "geodata"
table1 = Table(
"{0!s}_child".format(tablename), self.metadata,
Column("id", types.Integer, primary_key=True),
Column("name", types.Unicode),
schema=schemaname
)
self._tables.append(table1)
table2 = Table(
tablename, self.metadata,
Column("id", types.Integer, primary_key=True),
Column("child_id", types.Integer,
ForeignKey("{0!s}.{1!s}_child.id".format(schemaname, tablename))),
Column("name", types.Unicode, nullable=False),
Column("deleted", types.Boolean),
Column("last_update_user", types.Unicode),
Column("last_update_date", types.DateTime),
Column("date", types.Date),
Column("start_time", types.Time),
# Column("interval", Interval()),
Column("short_name1", types.String, nullable=True),
Column("short_name2", types.String(50), nullable=True),
Column("short_number", types.Integer, nullable=True),
Column("double_number", types.Float(precision=4)),
Column("large_binary", types.LargeBinary(length=60), nullable=True),
Column("value", types.Enum("one", "two", "three", name="an_enum_value")),
Column("numeric", types.Numeric(precision=5, scale=2), nullable=True),
Column("numeric2", types.Numeric(), nullable=True),
schema=schemaname
)
if geom_type:
table2.append_column(
Column("geom", Geometry("POINT", srid=21781))
)
else:
table2.append_column(
Column("geom", Geometry(srid=21781))
)
self._tables.append(table2)
table2.drop(checkfirst=True)
table1.drop(checkfirst=True)
table1.create()
table2.create()
ins = table1.insert().values(name="c1é")
connection.execute(ins).inserted_primary_key[0]
ins = table1.insert().values(name="c2é")
connection.execute(ins).inserted_primary_key[0]
layer = LayerWMS(name="test_WMS_1", public=True)
layer.layer = "test_wms"
layer.id = id
layer.geo_table = "{0!s}.{1!s}".format(schemaname, tablename)
layer.interfaces = [self.main]
layer.ogc_server = self.ogc_server
if exclude_properties:
layer.exclude_properties = "name"
if metadatas:
layer.metadatas = metadatas
DBSession.add(self.layer_group_1)
self.layer_group_1.children = self.layer_group_1.children + [layer]
DBSession.add(self.layer_group_1)
ra = RestrictionArea()
ra.name = "__test_ra"
ra.layers = [layer]
ra.roles = [self.role]
ra.readwrite = True
DBSession.add(ra)
transaction.commit()
self.layer_ids.append(id)
return id
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 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,
}
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 factory_build_layers(layer_builder, dbsession, add_dimension=True):
from c2cgeoportal_commons.models.main import (
Dimension,
Interface,
LayerGroup,
LayergroupTreeitem,
Metadata,
RestrictionArea,
)
restrictionareas = [
RestrictionArea(name=f"restrictionarea_{i}") for i in range(0, 5)
]
interfaces = [
Interface(name) for name in ["desktop", "mobile", "edit", "routing"]
]
dimensions_protos = [("Date", "2017"), ("Date", "2018"), ("Date", "1988"),
("CLC", "all")]
metadatas_protos = [
("copyable", "true"),
("disclaimer", "© le momo"),
("snappingConfig", '{"tolerance": 50}'),
]
groups = [LayerGroup(name=f"layer_group_{i}") for i in range(0, 5)]
layers = []
for i in range(0, 25):
layer = layer_builder(i)
if add_dimension:
layer.dimensions = [
Dimension(name=dimensions_protos[id][0],
value=dimensions_protos[id][1],
layer=layer)
for id in [i % 3, (i + 2) % 4, (i + 3) % 4]
]
layer.metadatas = [
Metadata(name=metadatas_protos[id][0],
value=metadatas_protos[id][1])
for id in [i % 3, (i + 2) % 3]
]
for metadata in layer.metadatas:
metadata.item = layer
if i % 10 != 1:
layer.interfaces = [interfaces[i % 4], interfaces[(i + 2) % 4]]
layer.restrictionareas = [
restrictionareas[i % 5], restrictionareas[(i + 2) % 5]
]
dbsession.add(
LayergroupTreeitem(group=groups[i % 5],
item=layer,
ordering=len(groups[i % 5].children_relation)))
dbsession.add(
LayergroupTreeitem(group=groups[(i + 3) % 5],
item=layer,
ordering=len(groups[(i + 3) %
5].children_relation)))
dbsession.add(layer)
layers.append(layer)
return {
"restrictionareas": restrictionareas,
"layers": layers,
"interfaces": interfaces
}
