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