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 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 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 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_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 _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(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 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 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, _): 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 \ 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 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_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, _): # 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 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 }