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()