def setup_method(self, _):
import transaction
from c2cgeoportal_commons.models import DBSession
from c2cgeoportal_commons.models.main import Role, Functionality
from c2cgeoportal_commons.models.static import User
create_default_ogcserver()
role1 = Role(name="__test_role1")
user1 = User(
username="******",
password="******",
role=role1
)
role2 = Role(name="__test_role2")
user2 = User(
username="******",
password="******",
role=role2
)
functionality1 = Functionality("__test_s", "db")
functionality2 = Functionality("__test_a", "db1")
functionality3 = Functionality("__test_a", "db2")
role2.functionalities = [functionality1, functionality2, functionality3]
DBSession.add_all([user1, user2, role1, role2])
transaction.commit()
def roles_test_data(dbsession):
from c2cgeoportal_commons.models.main import Role, Functionality, RestrictionArea
dbsession.begin_nested()
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)
dbsession.flush()
yield {
'functionalities': functionalities,
'restrictionareas': restrictionareas,
'roles': roles
}
dbsession.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")
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 setup_method(self, _):
# Always see the diff
# https://docs.python.org/2/library/unittest.html#unittest.TestCase.maxDiff
self.maxDiff = None
self._tables = []
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, ogcserver_external = create_default_ogcserver()
role1 = Role(name="__test_role1")
role1.id = 999
user1 = User(username="******",
password="******",
role=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="******",
role=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 (
OGCSERVER_AUTH_STANDARD,
OGCSERVER_TYPE_MAPSERVER,
Interface,
LayerWMS,
OGCServer,
RestrictionArea,
Role,
)
from c2cgeoportal_commons.models.static import User
setup_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="******",
settings_role=role,
roles=[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 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="desktop")
role = Role(name="__test_role")
user = User(username="******",
password="******",
settings_role=role,
roles=[role])
user.email = "*****@*****.**"
role2 = Role(name="__test_role2")
user2 = User(username="******",
password="******",
settings_role=role,
roles=[role, role2])
user2.email = "*****@*****.**"
ogc_server_internal = create_default_ogcserver()
layer_wms = LayerWMS(name="__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="__test_layer_wms_private",
public=False)
layer_wms_private.layer = "testpoint_protected"
layer_wms_private.interfaces = [main]
layer_wms_private.ogc_server = ogc_server_internal
layer_wms_private2 = LayerWMS(name="__test_layer_wms_private2",
public=False)
layer_wms_private2.layer = "__test_private_layer2"
layer_wms_private2.interfaces = [main]
layer_wms_private2.ogc_server = ogc_server_internal
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_wmts_private = LayerWMTS(name="__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="__test_layer_group")
layer_group.children = [
layer_wms,
layer_wms_private,
layer_wms_private2,
layer_wmts,
layer_wmts_private,
]
theme = Theme(name="__test_theme")
theme.interfaces = [main]
theme.children = [layer_group]
restriction_area = RestrictionArea(
name="__test_ra1",
layers=[layer_wms_private, layer_wmts_private],
roles=[role])
restriction_area2 = RestrictionArea(name="__test_ra2",
layers=[layer_wms_private2],
roles=[role2])
DBSession.add_all([theme, restriction_area, restriction_area2, user])
transaction.commit()
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 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 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 # pylint: disable=invalid-name
self._tables = []
from geoalchemy2 import Geometry
from sqlalchemy import Column, Table, func, types
from sqlalchemy.ext.declarative import declarative_base
from c2cgeoportal_commons.models import DBSession
from c2cgeoportal_commons.models.main import (
OGCSERVER_AUTH_GEOSERVER,
OGCSERVER_TYPE_GEOSERVER,
FullTextSearch,
Functionality,
Interface,
LayerGroup,
LayerWMS,
OGCServer,
RestrictionArea,
Role,
Theme,
)
from c2cgeoportal_commons.models.static import User
setup_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="testpoint_unprotected",
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 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,
url="http://qgis?MAP=qgisserver1",
image_type="image/png",
auth=OGCSERVER_AUTH_STANDARD,
)
ogc_server2 = OGCServer(
name="qgisserver2",
type_=OGCSERVER_TYPE_QGISSERVER,
url="http://qgis",
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())
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()