def setUp(self): import transaction import sqlahelper from sqlalchemy import Column, types, ForeignKey from sqlalchemy.orm import relationship from sqlalchemy.ext.declarative import declarative_base from c2cgeoportal.models import DBSession from c2cgeoportal.lib.dbreflection import _association_proxy engine = sqlahelper.get_engine() Base = declarative_base(bind=engine) class Child(Base): __tablename__ = 'child' id = Column(types.Integer, primary_key=True) name = Column(types.Unicode) def __init__(self, name): self.name = name class Parent(Base): __tablename__ = 'parent' id = Column(types.Integer, primary_key=True) child1_id = Column(types.Integer, ForeignKey('child.id')) child2_id = Column(types.Integer, ForeignKey('child.id')) child1_ = relationship(Child, primaryjoin=(child1_id==Child.id)) child1 = _association_proxy('child1_', 'name') child2_ = relationship(Child, primaryjoin=(child2_id==Child.id)) child2 = _association_proxy('child2_', 'name') Base.metadata.create_all() DBSession.add_all([Child('foo'), Child('bar')]) transaction.commit() self.metadata = Base.metadata self.cls = Parent
def setUp(self): # noqa # Always see the diff # https://docs.python.org/2/library/unittest.html#unittest.TestCase.maxDiff self.maxDiff = None from c2cgeoportal.models import DBSession, \ Theme, LayerGroup, Interface, LayerWMS main = Interface(name=u"desktop") ogc_server, _ = create_default_ogcserver() layer_wms = LayerWMS(name=u"__test_layer_wms", public=True) layer_wms.layer = "testpoint_unprotected" layer_wms.interfaces = [main] layer_wms.ogc_server = ogc_server layer_group = LayerGroup(name=u"__test_layer_group") layer_group.children = [layer_wms] theme = Theme(name=u"__test/theme") theme.interfaces = [main] theme.children = [ layer_group ] DBSession.add(theme) transaction.commit()
def setUp(self): import sqlahelper import transaction from c2cgeoportal.models import DBSession, Role, User, Functionality from c2cgeoportal.lib.dbreflection import init role1 = Role(name=u'__test_role1') user1 = User( username=u'__test_user1', password=u'__test_user1', role=role1 ) role2 = Role(name=u'__test_role2') user2 = User( username=u'__test_user2', password=u'__test_user2', role=role2 ) functionality1 = Functionality(u'__test_s', u'db') functionality2 = Functionality(u'__test_a', u'db1') functionality3 = Functionality(u'__test_a', u'db2') user2.functionalities = [functionality1, functionality2, functionality3] DBSession.add(user1) DBSession.add(user2) transaction.commit() engine = sqlahelper.get_engine() init(engine)
def main(): parser = argparse.ArgumentParser(description="Create and populate the database tables.") parser.add_argument("-i", "--iniconfig", default="production.ini", help="project .ini config file") parser.add_argument("-n", "--app-name", default="app", help='The application name (optional, default is "app")') options = parser.parse_args() # read the configuration get_app(options.iniconfig, options.app_name) from c2cgeoportal.models import DBSession, Interface, OGCServer, Theme, LayerGroup, LayerWMS session = DBSession() interfaces = session.query(Interface).all() ogc_server = session.query(OGCServer).filter(OGCServer.name == u"source for image/png").one() layer_borders = LayerWMS(u"Borders", u"borders") layer_borders.interfaces = interfaces layer_borders.ogc_server = ogc_server layer_density = LayerWMS(u"Density", u"density") layer_density.interfaces = interfaces layer_density.ogc_server = ogc_server group = LayerGroup(u"Demo") group.children = [layer_borders, layer_density] theme = Theme(u"Demo") theme.children = [group] theme.interfaces = interfaces transaction.commit()
def setUp(self): # noqa from c2cgeoportal.models import User, Role, LayerV1, RestrictionArea, \ Interface, DBSession create_default_ogcserver() user1 = User(username=u"__test_user1", password=u"__test_user1") role1 = Role(name=u"__test_role1", description=u"__test_role1") user1.role_name = role1.name user1.email = u"Tarenpion" main = Interface(name=u"main") layer1 = LayerV1(u"testpoint_group", public=False) layer1.interfaces = [main] layer2 = LayerV1(u"testpoint_protected_2", public=False) layer2.interfaces = [main] area = "POLYGON((-100 30, -100 50, 100 50, 100 30, -100 30))" area = WKTElement(area, srid=21781) restricted_area1 = RestrictionArea(u"__test_ra1", u"", [layer1, layer2], [role1], area) DBSession.add_all([user1, role1, layer1, layer2, restricted_area1]) DBSession.flush() transaction.commit()
def setUp(self): # noqa # Always see the diff # https://docs.python.org/2/library/unittest.html#unittest.TestCase.maxDiff self.maxDiff = None from c2cgeoportal.models import DBSession, \ Theme, LayerGroup, Interface, OGCServer, LayerWMS, LayerWMTS main = Interface(name=u"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=u"__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=u"__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=u"__test_layer_wmts", public=True) layer_wmts.interfaces = [main] layer_group_1 = LayerGroup(name=u"__test_layer_group_1") layer_group_1.children = [layer_internal_wms] layer_group_2 = LayerGroup(name=u"__test_layer_group_2") layer_group_2.children = [layer_external_wms] layer_group_3 = LayerGroup(name=u"__test_layer_group_3") layer_group_3.children = [layer_wmts] layer_group_4 = LayerGroup(name=u"__test_layer_group_4") layer_group_4.children = [layer_group_1, layer_group_2] layer_group_5 = LayerGroup(name=u"__test_layer_group_5") layer_group_5.children = [layer_group_1, layer_group_3] layer_group_6 = LayerGroup(name=u"__test_layer_group_6") layer_group_6.children = [layer_internal_wms] layer_group_7 = LayerGroup(name=u"__test_layer_group_7") layer_group_7.children = [layer_group_1, layer_group_6] layer_group_8 = LayerGroup(name=u"__test_layer_group_8") layer_group_8.children = [layer_group_2, layer_group_6] theme = Theme(name=u"__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 setUp(self): # noqa from c2cgeoportal.models import User, Role, LayerV1, RestrictionArea, Interface, DBSession user1 = User(username=u"__test_user1", password=u"__test_user1") role1 = Role(name=u"__test_role1", description=u"__test_role1") user1.role_name = role1.name user1.email = u"Tarenpion" user2 = User(username=u"__test_user2", password=u"__test_user2") role2 = Role(name=u"__test_role2", description=u"__test_role2") user2.role_name = role2.name user2.email = u"Tarenpion" main = Interface(name=u"main") layer1 = LayerV1(u"layer_1", public=False) layer1.interfaces = [main] layer2 = LayerV1(u"layer_2", public=False) layer2.interfaces = [main] layer3 = LayerV1(u"layer_3", public=False) layer3.interfaces = [main] area = "POLYGON((-100 30, -100 50, 100 50, 100 30, -100 30))" area = WKTElement(area, srid=21781) restricted_area1 = RestrictionArea(u"__test_ra1", u"", [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(u"__test_ra2", u"", [layer1, layer2, layer3], [role2], area) DBSession.add_all([user1, user2, role1, role2, restricted_area1, restricted_area2]) DBSession.flush() transaction.commit()
def setUp(self): # noqa import sqlahelper import transaction from c2cgeoportal.models import DBSession, Role, User, Functionality from c2cgeoportal.lib.dbreflection import init role1 = Role(name=u"__test_role1") user1 = User( username=u"__test_user1", password=u"__test_user1", role=role1 ) role2 = Role(name=u"__test_role2") user2 = User( username=u"__test_user2", password=u"__test_user2", role=role2 ) functionality1 = Functionality(u"__test_s", u"db") functionality2 = Functionality(u"__test_a", u"db1") functionality3 = Functionality(u"__test_a", u"db2") role2.functionalities = [functionality1, functionality2, functionality3] DBSession.add_all([user1, user2, role1, role2]) transaction.commit() engine = sqlahelper.get_engine() init(engine)
def loginchange(self): set_common_headers(self.request, "loginchange", NO_CACHE) new_password = self.request.params.get("newPassword", None) new_password_confirm = self.request.params.get("confirmNewPassword", None) if new_password is None or new_password_confirm is None: raise HTTPBadRequest( "'newPassword' and 'confirmNewPassword' should be " "available in request params" ) # check if loggedin if not self.request.user: raise HTTPUnauthorized("bad credentials") if new_password != new_password_confirm: raise HTTPBadRequest( "The new password and the new password " "confirmation don't match" ) u = self.request.user u._set_password(new_password) u.is_password_changed = True DBSession.flush() log.info("Password changed for user: %s" % self.request.user.username) return { "success": "true" }
def tearDown(): # noqa testing.tearDown() from c2cgeoportal.models import DBSession, Shorturl import transaction DBSession.query(Shorturl).delete() transaction.commit()
def setUp(): # noqa import transaction from sqlalchemy import func from geoalchemy2 import WKTElement from c2cgeoportal.models import FullTextSearch, User, Role, Interface from c2cgeoportal.models import DBSession user1 = User(username=u"__test_user1", password=u"__test_user1") role1 = Role(name=u"__test_role1", description=u"__test_role1") user1.role_name = role1.name user2 = User(username=u"__test_user2", password=u"__test_user2") role2 = Role(name=u"__test_role2", description=u"__test_role2") user2.role_name = role2.name 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 = "label2" entry2.layer_name = "layer2" entry2.ts = func.to_tsvector("french", "pluie semaine") entry2.the_geom = WKTElement("POINT(-90 -45)", 21781) entry2.public = False entry3 = FullTextSearch() entry3.label = "label3" entry3.layer_name = "layer3" entry3.ts = func.to_tsvector("french", "vent neige") entry3.the_geom = WKTElement("POINT(-90 -45)", 21781) entry3.public = False entry3.role = role2 entry4 = FullTextSearch() entry4.label = "label4" entry4.layer_name = "layer1" entry4.ts = func.to_tsvector("french", "soleil travail") entry4.the_geom = WKTElement("POINT(-90 -45)", 21781) entry4.public = True entry5 = FullTextSearch() entry5.label = "label5" entry5.ts = func.to_tsvector("french", "params") entry5.public = True entry5.params = {"floor": 5} entry5.actions = [{"action": "add_layer", "data": "layer1"}] entry6 = FullTextSearch() entry6.label = "label6" entry6.ts = func.to_tsvector("french", "params") entry6.interface = Interface("main") entry6.public = True DBSession.add_all([user1, user2, role1, role2, entry1, entry2, entry3, entry4, entry5, entry6]) transaction.commit()
def test_json_extent(self): from c2cgeoportal.models import DBSession, Role role = DBSession.query(Role).filter(Role.name == '__test_role1').one() self.assertEqual(role.json_extent, None) role = DBSession.query(Role).filter(Role.name == '__test_role2').one() self.assertEqual(role.json_extent, '[1, 2, 3, 4]')
def create_default_ogcserver(): from c2cgeoportal.models import DBSession, OGCServer DBSession.query(OGCServer).delete() ogcserver = OGCServer(name="__test_ogc_server") ogcserver.url = mapserv ogcserver_external = OGCServer(name="__test_external_ogc_server") ogcserver_external.url = mapserv + "external=true&" DBSession.add_all([ogcserver, ogcserver_external]) return ogcserver, ogcserver_external
def setUp(self): from c2cgeoportal.models import User, Role, Layer, RestrictionArea, \ Functionality, DBSession TestPoint.__table__.create(bind=DBSession.bind, checkfirst=True) geom = WKTSpatialElement("MULTIPOINT((-90 -45))", srid=21781) p1 = TestPoint(the_geom=geom, name=u'foo', city=u'Lausanne', country=u'Swiss') geom = WKTSpatialElement("MULTIPOINT((-90 45))", srid=21781) p2 = TestPoint(the_geom=geom, name=u'bar', city=u'Chambéry', country=u'France') geom = WKTSpatialElement("MULTIPOINT((90 45))", srid=21781) p3 = TestPoint(the_geom=geom, name=u'éàè', city="Paris", country=u'France') geom = WKTSpatialElement("MULTIPOINT((90 -45))", srid=21781) p4 = TestPoint(the_geom=geom, name=u'123', city='Londre', country=u'UK') pt1 = Functionality(name=u'print_template', value=u'1 Wohlen A4 portrait') pt2 = Functionality(name=u'print_template', value=u'2 Wohlen A3 landscape') user1 = User(username=u'__test_user1', password=u'__test_user1') role1 = Role(name=u'__test_role1', description=u'__test_role1', functionalities=[pt1, pt2]) user1.role = role1 user1.email = u'Tarenpion' user2 = User(username=u'__test_user2', password=u'__test_user2') role2 = Role(name=u'__test_role2', description=u'__test_role2', functionalities=[pt1, pt2]) user2.role = role2 user2.email = u'Tarenpion' user3 = User(username=u'__test_user3', password=u'__test_user3') role3 = Role(name=u'__test_role3', description=u'__test_role3', functionalities=[pt1, pt2]) user3.role = role3 user3.email = u'Tarenpion' layer2 = Layer(u'testpoint_protected', 400, public=False) layer3 = Layer(u'testpoint_protected_query_with_collect', public=False) area = "POLYGON((-100 30, -100 50, 100 50, 100 30, -100 30))" area = WKTSpatialElement(area, srid=21781) restricted_area1 = RestrictionArea(u'__test_ra1', u'', [layer2, layer3], [role1], area) area = "POLYGON((-100 0, -100 20, 100 20, 100 0, -100 0))" area = WKTSpatialElement(area, srid=21781) restricted_area2 = RestrictionArea(u'__test_ra2', u'', [layer2, layer3], [role2, role3], area) area = "POLYGON((-95 43, -95 47, 95 47, 95 43, -95 43))" area = WKTSpatialElement(area, srid=21781) restricted_area3 = RestrictionArea(u'__test_ra3', u'', [layer3], [role3], area, readwrite=True) DBSession.add_all([ p1, p2, p3, p4, user1, user2, user3, restricted_area1, restricted_area2, restricted_area3 ]) DBSession.flush() self.id_lausanne = p1.id self.id_paris = p3.id transaction.commit()
def _validate_geometry(self, geom): validate = self.settings.get("geometry_validation", False) if validate and geom is not None: simple = DBSession.query(func.ST_IsSimple(geom)).scalar() if not simple: raise TopologicalError("Not simple") valid = DBSession.query(func.ST_IsValid(geom)).scalar() if not valid: reason = DBSession.query(func.ST_IsValidReason(geom)).scalar() raise TopologicalError(reason)
def setUp(self): # noqa import sqlahelper import transaction from c2cgeoportal.models import DBSession, Role, User, Interface, TreeItem from c2cgeoportal.lib.dbreflection import init for treeitem in DBSession.query(TreeItem).all(): DBSession.delete(treeitem) self.metadata = None self.layer_ids = [] self.role = Role(name=u"__test_role") self.user = User( username=u"__test_user", password=u"__test_user", role=self.role ) self.main = Interface(name=u"main") DBSession.add(self.user) DBSession.add(self.role) DBSession.add(self.main) transaction.commit() engine = sqlahelper.get_engine() init(engine)
def setUp(self): import transaction from sqlalchemy import func from geoalchemy import WKTSpatialElement from c2cgeoportal.models import FullTextSearch, User, Role from c2cgeoportal.models import DBSession user1 = User(username=u'__test_user1', password=u'__test_user1') role1 = Role(name=u'__test_role1', description=u'__test_role1') user1.role = role1 user2 = User(username=u'__test_user2', password=u'__test_user2') role2 = Role(name=u'__test_role2', description=u'__test_role2') user2.role = role2 entry1 = FullTextSearch() entry1.label = 'label1' entry1.layer_name = 'layer1' entry1.ts = func.to_tsvector('french', 'soleil travail') entry1.the_geom = WKTSpatialElement("POINT(-90 -45)") entry1.public = True entry2 = FullTextSearch() entry2.label = 'label2' entry2.layer_name = 'layer2' entry2.ts = func.to_tsvector('french', 'pluie semaine') entry2.the_geom = WKTSpatialElement("POINT(-90 -45)") entry2.public = False entry3 = FullTextSearch() entry3.label = 'label3' entry3.layer_name = 'layer3' entry3.ts = func.to_tsvector('french', 'vent neige') entry3.the_geom = WKTSpatialElement("POINT(-90 -45)") entry3.public = False entry3.role = role2 entry4 = FullTextSearch() entry4.label = 'label4' entry4.layer_name = 'layer1' entry4.ts = func.to_tsvector('french', 'soleil travail') entry4.the_geom = WKTSpatialElement("POINT(-90 -45)") entry4.public = True entry5 = FullTextSearch() entry5.label = 'label5' entry5.layer_name = 'layer1' entry5.ts = func.to_tsvector('french', 'params') entry5.the_geom = WKTSpatialElement("POINT(-90 -45)") entry5.public = True entry5.params = {'floor': 5} DBSession.add_all([user1, user2, entry1, entry2, entry3, entry4, entry5]) transaction.commit()
def tearDown(self): # noqa testing.tearDown() import transaction from c2cgeoportal.models import DBSession, User, Role transaction.commit() DBSession.query(User).filter_by(username=u"__test_user").delete() DBSession.query(Role).filter_by(name=u"__test_role").delete() transaction.commit()
def setUp(self): # noqa self.config = testing.setUp() import transaction from c2cgeoportal.models import DBSession, User, Role r = Role(name=u"__test_role") u = User(username=u"__test_user", password=u"__test_user", role=r) DBSession.add_all([r, u]) transaction.commit()
def loginchange(self): new_password = self.request.params.get('newPassword', None) new_password_confirm = self.request.params.get('confirmNewPassword', None) if new_password is None or new_password_confirm is None: raise HTTPBadRequest('"newPassword" and "confirmNewPassword" should be \ available in request params') # check if loggedin if not self.request.user: raise HTTPUnauthorized('bad credentials') if new_password != new_password_confirm: raise HTTPBadRequest("the new password and the new password \ confirmation don't match") u = self.request.user u._set_password(new_password) u.is_password_changed = True DBSession.flush() log.info("password changed for user: %s" % self.request.user.username) # handle replication if 'auth_replication_enabled' in self.request.registry.settings and \ self.request.registry.settings['auth_replication_enabled'] == \ 'true': # pragma: no cover try: log.debug("trying to find if engine set for replication exists") engine = sqlahelper.get_engine('replication') except RuntimeError: log.debug("engine for replication doesn't exist yet, trying \ to create") engine = engine_from_config( self.request.registry.settings, 'sqlalchemy_replication.') sqlahelper.add_engine(engine, 'replication') DBSession2 = scoped_session(sessionmaker(bind=engine)) dbuser_r = DBSession2.query(User).filter(User.id == self.request.user.id) result = dbuser_r.all() if len(result) == 0: msg = 'user not found in replication target database: %s' \ % self.request.user.username log.exception(msg) return HTTPBadRequest(msg) # pragma nocover else: u_r = dbuser_r.all()[0] u_r._set_password(new_password) u_r.is_password_changed = True DBSession2.commit() log.info("password changed in replication target database \ for user: %s" % self.request.user.username) return Response('true', cache_control="no-cache")
def setUp(self): from c2cgeoportal.models import DBSession, Layer, Theme, LayerGroup layer = Layer(name=u"__test_layer", public=True) layer_group = LayerGroup(name=u"__test_layer_group") layer_group.children = [layer, layer_group] theme = Theme(name=u"__test_theme") theme.children = [layer, layer_group] DBSession.add_all([layer, layer_group, theme]) transaction.commit()
def get_lux_feature_definition(self, layers): luxgetfeaturedefinitions = [] try: if layers is not None: for layer in layers.split(','): cur_layer = DBSession.query(Layer).filter( Layer.id == layer).first() if cur_layer is None: continue if not cur_layer.public: if self.request.user is None: continue # Check if the layer has a resctriction area restriction = DBSession.query(RestrictionArea).filter( RestrictionArea.roles.any( Role.id == self.request.user.role.id)).filter( RestrictionArea.layers.any( Layer.id == layer ) ).first() # If not restriction is set then check next layer if restriction is None: continue query = DBSession.query( LuxGetfeatureDefinition).filter( LuxGetfeatureDefinition.layer == layer ) if self.request.user is not None: if query.filter( LuxGetfeatureDefinition.role == self.request.user.role.id ).count() > 0: for res in query.filter( LuxGetfeatureDefinition.role == self.request.user.role.id).all(): luxgetfeaturedefinitions.append(res) else: for res in query.filter( LuxGetfeatureDefinition.role == None ).all(): # noqa luxgetfeaturedefinitions.append(res) else: for res in query.filter( LuxGetfeatureDefinition.role == None ).all(): # noqa luxgetfeaturedefinitions.append(res) except Exception as e: log.exception(e) return HTTPBadRequest() return luxgetfeaturedefinitions
def setUp(self): # noqa # Always see the diff # https://docs.python.org/2/library/unittest.html#unittest.TestCase.maxDiff self.maxDiff = None from c2cgeoportal.models import DBSession, \ Theme, LayerGroup, Interface, LayerWMS, ServerOGC TestPoint.__table__.create(bind=DBSession.bind, checkfirst=True) main = Interface(name=u"main") layer_wms_1 = LayerWMS(name=u"__test_layer_time_1", public=True) layer_wms_1.layer = "test_wmstime" layer_wms_1.time_mode = "single" layer_wms_1.interfaces = [main] layer_wms_1.server_ogc = ServerOGC(name="__test_server_ogc", type="mapserver", image_type="image/jpeg") layer_wms_2 = LayerWMS(name=u"__test_layer_time_2", public=True) layer_wms_2.layer = "test_wmstime2" layer_wms_2.time_mode = "single" layer_wms_2.interfaces = [main] layer_wms_2.server_ogc = ServerOGC(name="__test_server_ogc", type="mapserver", image_type="image/jpeg") layer_wms_group = LayerWMS(name=u"__test_layer_time_group", public=True) layer_wms_group.layer = "test_wmstimegroup" layer_wms_group.time_mode = "range" layer_wms_group.time_widget = "datepicker" layer_wms_group.interfaces = [main] layer_wms_group.server_ogc = ServerOGC(name="__test_server_ogc", type="mapserver", image_type="image/jpeg") layer_group_1 = LayerGroup(name=u"__test_layer_group_1") layer_group_1.children = [layer_wms_1, layer_wms_2] layer_group_2 = LayerGroup(name=u"__test_layer_group_2") layer_group_2.children = [layer_wms_1] layer_group_3 = LayerGroup(name=u"__test_layer_group_3") layer_group_3.children = [layer_wms_1, layer_wms_2, layer_wms_group] layer_group_4 = LayerGroup(name=u"__test_layer_group_4") layer_group_4.children = [layer_wms_group] theme = Theme(name=u"__test_theme") theme.interfaces = [main] theme.children = [ layer_group_1, layer_group_2, layer_group_3, layer_group_4 ] DBSession.add_all([theme]) transaction.commit()
def setUp(self): self.config = testing.setUp() import transaction from c2cgeoportal.models import DBSession, User, Role r = Role(name=u'__test_role') u = User(username=u'__test_user', password=u'__test_user', role=r ) DBSession.add(u) transaction.commit()
def tearDown(self): # noqa testing.tearDown() from c2cgeoportal.models import DBSession, TreeItem, Interface for item in DBSession.query(TreeItem).all(): DBSession.delete(item) DBSession.query(Interface).filter( Interface.name == "main" ).delete() transaction.commit() TestPoint.__table__.drop(bind=DBSession.bind, checkfirst=True)
def setUp(self): # noqa # Always see the diff # https://docs.python.org/2/library/unittest.html#unittest.TestCase.maxDiff self.maxDiff = None from c2cgeoportal.models import DBSession, LayerV1, Theme, Interface, LayerGroup create_default_ogcserver() main = Interface(name=u"main") mobile = Interface(name=u"mobile") layer = LayerV1(name=u"__test_layer") layer.interfaces = [main, mobile] mobile_only_layer = LayerV1(name=u"__test_mobile_only_layer") mobile_only_layer.interfaces = [mobile] desktop_only_layer = LayerV1(name=u"__test_desktop_only_layer") desktop_only_layer.interfaces = [main] group = LayerGroup(name=u"__test_layer_group") group.children = [layer, mobile_only_layer, desktop_only_layer] theme = Theme(name=u"__test_theme") theme.children = [group] theme.interfaces = [main, mobile] mobile_only_group = LayerGroup(name=u"__test_mobile_only_layer_group") mobile_only_group.children = [layer] mobile_only_theme = Theme(name=u"__test_mobile_only_theme") mobile_only_theme.children = [mobile_only_group] mobile_only_theme.interfaces = [mobile] desktop_only_group = LayerGroup(name=u"__test_desktop_only_layer_group") desktop_only_group.children = [layer] desktop_only_theme = Theme(name=u"__test_desktop_only_theme") desktop_only_theme.children = [desktop_only_group] desktop_only_theme.interfaces = [main] # the following theme should not appear in the list of themes on desktop # nor on mobile # It should be accessible by explicitely loading it in mobile though mobile_private_group = LayerGroup(name=u"__test_mobile_private_layer_group") mobile_private_group.children = [layer] mobile_private_theme = Theme(name=u"__test_mobile_private_theme") mobile_private_theme.children = [mobile_private_group] DBSession.add_all([ layer, mobile_only_layer, desktop_only_layer, theme, mobile_only_theme, desktop_only_theme, mobile_private_theme ]) transaction.commit()
def setUp(self): self.config = testing.setUp() from c2cgeoportal.models import DBSession, Layer, \ Theme, LayerGroup layer = Layer(name=u'__test_layer', public=True) layer_group = LayerGroup(name=u'__test_layer_group') layer_group.children = [layer, layer_group] theme = Theme(name=u'__test_theme') theme.children = [layer, layer_group] DBSession.add_all([layer, layer_group, theme]) transaction.commit()
def main(): # pragma: no cover parser = ArgumentParser( prog=sys.argv[0], add_help=True, description="Tool used to migrate your old layers from the old structure to the new one.", ) parser.add_argument( "-i", "--app-config", default="production.ini", dest="app_config", help="the application .ini config file (optional, default is 'production.ini')" ) parser.add_argument( "-n", "--app-name", default="app", dest="app_name", help="the application name (optional, default is 'app')" ) options = parser.parse_args() app_config = options.app_config app_name = options.app_name if app_name is None and "#" in app_config: app_config, app_name = app_config.split("#", 1) get_app(app_config, name=app_name) # must be done only once we have loaded the project config from c2cgeoportal.models import DBSession, \ ServerOGC, LayerWMS, LayerWMTS, LayerV1 session = DBSession() table_list = [LayerWMTS, LayerWMS, ServerOGC] for table in table_list: print "Emptying table %s." % str(table.__table__) # must be done exactly this way othewise the cascade config in the # models are not used for t in session.query(table).all(): session.delete(t) # list and create all distinct server_ogc server_ogc(session) print "Converting layerv1." for layer in session.query(LayerV1).all(): layer_v1tov2(session, layer) transaction.commit()
def test_theme(self): from c2cgeoportal.models import DBSession, User from c2cgeoportal.views.entry import Entry request = testing.DummyRequest() request.headers['Host'] = host request.static_url = lambda url: 'http://example.com/dummy/static/url' request.route_url = lambda url: mapserv_url curdir = os.path.dirname(os.path.abspath(__file__)) mapfile = os.path.join(curdir, 'c2cgeoportal_test.map') ms_url = "%s?map=%s&" % (mapserv_url, mapfile) request.registry.settings = { 'mapserv_url': ms_url, } request.user = None entry = Entry(request) # unautenticated themes = entry.themes() self.assertEquals(len(themes), 1) self.assertTrue(self._find_layer(themes[0], '__test_public_layer')) self.assertFalse(self._find_layer(themes[0], '__test_private_layer')) # autenticated on parent role_id = DBSession.query(User.role_id).filter_by(username=u'__test_user1').one() request.params = { 'role_id': role_id } themes = entry.themes() self.assertEquals(len(themes), 1) self.assertTrue(self._find_layer(themes[0], '__test_public_layer')) self.assertTrue(self._find_layer(themes[0], '__test_private_layer')) # autenticated request.params = {} request.user = DBSession.query(User).filter_by(username=u'__test_user1').one() themes = entry.themes() self.assertEquals(len(themes), 1) self.assertTrue(self._find_layer(themes[0], '__test_public_layer')) self.assertTrue(self._find_layer(themes[0], '__test_private_layer')) # mapfile error request.params = {} request.registry.settings = { 'mapserv_url': mapserv_url + '?map=not_a_mapfile', } from c2cgeoportal import caching caching.invalidate_region() themes, errors = entry._themes(None) self.assertEquals(len(themes), 0) self.assertEquals(len(errors), 1)
def check_geometry(r, feature, o): # we need both the "original" and "new" geometry to be # within the restriction area geom_attr, srid = self._get_geom_col_info(layer) geom_attr = getattr(o, geom_attr) geom = feature.geometry allowed = DBSession.query(func.count(RestrictionArea.id)) allowed = allowed.join(RestrictionArea.roles) allowed = allowed.join(RestrictionArea.layers) allowed = allowed.filter(RestrictionArea.readwrite.is_(True)) allowed = allowed.filter(Role.id == self.request.user.role.id) allowed = allowed.filter(Layer.id == layer.id) allowed = allowed.filter(or_( RestrictionArea.area.is_(None), RestrictionArea.area.ST_Contains(geom_attr) )) spatial_elt = None if geom and not isinstance(geom, geojson.geometry.Default): shape = asShape(geom) spatial_elt = from_shape(shape, srid=srid) allowed = allowed.filter(or_( RestrictionArea.area.is_(None), RestrictionArea.area.ST_Contains(spatial_elt) )) if allowed.scalar() == 0: raise HTTPForbidden() # check is geometry is valid self._validate_geometry(spatial_elt)
def security_cb(r, feature, o): geom = feature.geometry if geom and not isinstance(geom, geojson.geometry.Default): shape = asShape(geom) srid = _get_geom_col_info(layer)[1] spatial_elt = WKBSpatialElement(buffer(shape.wkb), srid=srid) allowed = DBSession.query( RestrictionArea.area.collect.gcontains(spatial_elt)) allowed = allowed.join(RestrictionArea.roles) allowed = allowed.join(RestrictionArea.layers) allowed = allowed.filter(RestrictionArea.area.area > 0) allowed = allowed.filter(RestrictionArea.readwrite == True) allowed = allowed.filter(Role.id == request.user.role.id) allowed = allowed.filter(Layer.id == layer.id).scalar() if not allowed: raise HTTPForbidden()
def tearDown(self): # noqa testing.tearDown() from c2cgeoportal.models import DBSession, TreeItem, Interface, OGCServer for item in DBSession.query(TreeItem).all(): DBSession.delete(item) DBSession.query(Interface).filter( Interface.name == "main" ).delete() DBSession.query(OGCServer).delete() transaction.commit() TestPoint.__table__.drop(bind=DBSession.bind, checkfirst=True)
def _get_layer(self, layer_id): """ Return a ``Layer`` object for ``layer_id``. """ layer_id = int(layer_id) try: query = DBSession.query(Layer, Layer.geo_table) query = query.filter(Layer.id == layer_id) layer, geo_table = query.one() except NoResultFound: raise HTTPNotFound("Layer %d not found" % layer_id) except MultipleResultsFound: # pragma: no cover raise HTTPInternalServerError( "Too many layers found with id %i" % layer_id ) if not geo_table: # pragma: no cover raise HTTPNotFound("Layer %d has no geo table" % layer_id) return layer
def difference(self): body = loads(self.request.body) if "geometries" not in body or \ type(body["geometries"]) != list or \ len(body["geometries"]) != 2: # pragma: no cover raise HTTPBadRequest("""Wrong body, it should be like that: { "geometries": [geomA, geomB] } """) return to_shape( DBSession.query( func.ST_Difference(from_shape(asShape(body["geometries"][0])), from_shape(asShape( body["geometries"][1])))).scalar())
def get_user_from_request(request): """ Return the User object for the request. Return ``None`` if user is anonymous or if it does not exist in the database. """ from c2cgeoportal.models import DBSession, User from sqlalchemy.orm import joinedload username = unauthenticated_userid(request) if username is not None: # we know we'll need to role object for the # user so we use earger loading return DBSession.query(User) \ .options(joinedload(User.role)) \ .filter_by(username=username) \ .first() return None
def _create_request_obj(username=None, params=None, **kwargs): if params is None: params = {} from c2cgeoportal.models import DBSession, User request = create_dummy_request(**kwargs) request.static_url = lambda url: "/dummy/static/url" request.route_url = lambda url, **kwargs: mapserv_url request.interface_name = "main" request.params = params if username is not None: request.user = DBSession.query(User) \ .filter_by(username=username).one() return request
def _themes(self, role_id, mobile=False): """ This function returns theme information for the role identified to by ``role_id``. ``mobile`` tells whether to retrieve mobile or desktop layers """ errors = [] query = self._create_layer_query(role_id) filter = Layer.inDesktopViewer == True if not mobile else \ Layer.inMobileViewer == True # NOQA query = query.filter(filter) query = query.order_by(Layer.order.asc()) layers = query.all() # retrieve layers metadata via GetCapabilities wms, wms_errors = self._wms_getcap( self.request.registry.settings['mapserv_url'], role_id) if len(wms_errors) > 0: return [], wms_errors wms_layers = list(wms.contents) themes = DBSession.query(Theme).order_by(Theme.order.asc()) exportThemes = [] for theme in themes: children, children_errors, stop = self._getChildren( theme, layers, wms_layers, wms) errors += children_errors if stop: break # test if the theme is visible for the current user if len(children) > 0: icon = self._getIconPath(theme.icon) \ if theme.icon \ else self.request.static_url( 'c2cgeoportal:static/images/blank.gif') exportThemes.append({ 'inDesktopViewer': theme.inDesktopViewer, 'inMobileViewer': theme.inMobileViewer, 'name': theme.name, 'icon': icon, 'children': children }) return exportThemes, errors
def security_cb(r, feature, o): geom = feature.geometry if geom and not isinstance(geom, geojson.geometry.Default): shape = asShape(geom) srid = self._get_geom_col_info(layer)[1] spatial_elt = WKBSpatialElement(buffer(shape.wkb), srid=srid) none = None # the only way I found to remove the pep8 warning allowed = DBSession.query(func.count(RestrictionArea.id)) allowed = allowed.join(RestrictionArea.roles) allowed = allowed.join(RestrictionArea.layers) allowed = allowed.filter(RestrictionArea.readwrite == True) allowed = allowed.filter(Role.id == self.request.user.role.id) allowed = allowed.filter(Layer.id == layer.id) allowed = allowed.filter( or_(RestrictionArea.area == none, RestrictionArea.area.gcontains(spatial_elt))) if allowed.scalar() == 0: raise HTTPForbidden()
def _create_dummy_request(self, username=None, params=None): from c2cgeoportal.models import DBSession, User request = create_dummy_request({ "fulltextsearch": { "languages": { "fr": "french", "en": "english", "de": "german", } } }, params=params) request.response = Response() request.user = None if username: request.user = DBSession.query(User) \ .filter_by(username=username).one() return request
def _create_dummy_request(self, username=None): from c2cgeoportal.models import DBSession, User request = testing.DummyRequest() request.headers['Host'] = host request.registry.settings = { 'mapserv_url': mapserv_url, 'functionalities': { 'registered': {}, 'anonymous': {} } } if username: request.user = DBSession.query(User) \ .filter_by(username=username).one() else: request.user = None return request
def get_ogc_server_wms_url_ids(request): from c2cgeoportal.models import DBSession, OGCServer from c2cgeoportal.lib.cacheversion import VersionCache global ogc_server_wms_url_ids if ogc_server_wms_url_ids is None: ogc_server_wms_url_ids = VersionCache() errors = set() servers = ogc_server_wms_url_ids.get() if servers is None: servers = dict() ogc_server_wms_url_ids.set(servers) for ogc_server in DBSession.query(OGCServer).all(): url = get_url2(ogc_server.name, ogc_server.url, request, errors) if servers.get(url) is None: servers[url] = [] servers.get(url).append(ogc_server.id) return servers
def _xsd_sequence_callback(tb, cls): from c2cgeoportal.models import DBSession for k, p in cls.__dict__.iteritems(): if not isinstance(p, _association_proxy): continue relationship_property = class_mapper(cls) \ .get_property(p.target) target_cls = relationship_property.argument query = DBSession.query(getattr(target_cls, p.value_attr)) attrs = {} attrs['minOccurs'] = str(0) attrs['nillable'] = 'true' attrs['name'] = k with tag(tb, 'xsd:element', attrs) as tb: with tag(tb, 'xsd:simpleType') as tb: with tag(tb, 'xsd:restriction', {'base': 'xsd:string'}) as tb: for value, in query: with tag(tb, 'xsd:enumeration', {'value': value}): pass
def _xsd_sequence_callback(tb, cls): from c2cgeoportal.models import DBSession for k, p in cls.__dict__.iteritems(): if not isinstance(p, _AssociationProxy): continue relationship_property = class_mapper(cls) \ .get_property(p.target) target_cls = relationship_property.argument query = DBSession.query(getattr(target_cls, p.value_attr)) attrs = {} attrs["minOccurs"] = str(0) attrs["nillable"] = "true" attrs["name"] = k with tag(tb, "xsd:element", attrs) as tb: with tag(tb, "xsd:simpleType") as tb: with tag(tb, "xsd:restriction", {"base": "xsd:string"}) as tb: for value, in query: with tag(tb, "xsd:enumeration", {"value": value}): pass
def _create_dummy_request(self, username=None): from c2cgeoportal.models import DBSession, User request = create_dummy_request({ "admin_interface": { "available_functionalities": [ "mapserver_substitution", "print_template", ] } }) request.params = { "map": os.path.join(os.path.dirname(os.path.abspath(__file__)), "c2cgeoportal_test.map") } request.user = None if username is None else \ DBSession.query(User).filter_by(username=username).one() return request
def check(request): url = request.route_url("themes") session = requests.session() for interface, in DBSession.query(Interface.name).all(): params = {} params.update(default_params) params.update( interfaces_settings.get(interface, {}).get("params", {})) params["interface"] = interface interface_url_headers = build_url("checker_themes " + interface, url, request) response = session.get(params=params, **interface_url_headers) response.raise_for_status() result = response.json() if len(result["errors"]) != 0: raise Exception("Interface '{}': Theme with error\n{}".format( interface, "\n".join(result["errors"])))
def _proto_read(layer, request): """ Read features for the layer based on the request. """ if layer.public: return _get_protocol_for_layer(layer).read(request) if request.user is None: return FeatureCollection([]) user = request.user proto = _get_protocol_for_layer(layer) cls = proto.mapped_class geom_attr = proto.geom_attr ra = DBSession.query(RestrictionArea.area.collect) ra = ra.join(RestrictionArea.roles) ra = ra.join(RestrictionArea.layers) ra = ra.filter(RestrictionArea.area.area > 0) ra = ra.filter(Role.id == user.role.id) ra = ra.filter(Layer.id == layer.id).scalar() ra = DBSpatialElement(ra) filter_ = and_(create_filter(request, cls, geom_attr), ra.gcontains(getattr(cls, geom_attr))) return proto.read(request, filter=filter_)
def get_user_from_request(request): from c2cgeoportal.models import DBSession, Role class O(object): pass username = unauthenticated_userid(request) if username is not None: user = O() user.id = 0 user.username = username user.email = None user.is_admin = False user.mymaps_role = 999 user.ogc_role = -1 connector = get_ldap_connector(request) cm = connector.manager # 0 means 'Tous publics' roletheme = 0 with cm.connection() as conn: result = conn.search_s('ou=portail,dc=act,dc=lu', ldap.SCOPE_SUBTREE, '(login=%s)' % username) if len(result) == 1: if 'roleTheme' in result[0][1]: roletheme = result[0][1]['roleTheme'][0] if 'mail' in result[0][1]: user.mail = result[0][1]['mail'][0] if 'sn' in result[0][1]: user.sn = result[0][1]['sn'][0] if 'isMymapsAdmin' in result[0][1]: user.is_admin = result[0][1]['isMymapsAdmin'][0] if 'roleMymaps' in result[0][1]: user.mymaps_role = result[0][1]['roleMymaps'][0] if 'roleOGC' in result[0][1]: user.ogc_role = result[0][1]['roleOGC'][0] user.role = DBSession.query(Role).filter_by(id=roletheme).one() user.functionalities = [] return user
def check_geometry(r, feature, o): geom = feature.geometry if geom and not isinstance(geom, geojson.geometry.Default): shape = asShape(geom) srid = self._get_geom_col_info(layer)[1] spatial_elt = from_shape(shape, srid=srid) allowed = DBSession.query(func.count(RestrictionArea.id)) allowed = allowed.join(RestrictionArea.roles) allowed = allowed.join(RestrictionArea.layers) allowed = allowed.filter(RestrictionArea.readwrite.is_(True)) allowed = allowed.filter(Role.id == self.request.user.role.id) allowed = allowed.filter(Layer.id == layer.id) allowed = allowed.filter(or_( RestrictionArea.area.is_(None), RestrictionArea.area.ST_Contains(spatial_elt) )) if allowed.scalar() == 0: raise HTTPForbidden() # check if geometry is valid self._validate_geometry(spatial_elt)
def security_cb(r, feature, o): # we need both the "original" and "new" geometry to be # within the restriction area geom_attr, srid = _get_geom_col_info(layer) geom_attr = getattr(o, geom_attr) and_clauses = [RestrictionArea.area.collect.gcontains(geom_attr)] geom = feature.geometry if geom and not isinstance(geom, geojson.geometry.Default): shape = asShape(geom) spatial_elt = WKBSpatialElement(buffer(shape.wkb), srid=srid) and_clauses.append( RestrictionArea.area.collect.gcontains(spatial_elt)) allowed = DBSession.query(and_(*and_clauses)) allowed = allowed.join(RestrictionArea.roles) allowed = allowed.join(RestrictionArea.layers) allowed = allowed.filter(RestrictionArea.area.area > 0) allowed = allowed.filter(RestrictionArea.readwrite == True) allowed = allowed.filter(Role.id == request.user.role.id) allowed = allowed.filter(Layer.id == layer.id).scalar() if not allowed: raise HTTPForbidden()
def _import_layer_wmts(self, layer, messages): from c2cgeoportal.models import DBSession, OGCServer layers = [d.value for d in layer.metadatas if d.name == "queryLayers"] if len(layers) == 0: layers = [d.value for d in layer.metadatas if d.name == "wmsLayer"] server = [d.value for d in layer.metadatas if d.name == "ogcServer"] if len(server) >= 1 and len(layers) >= 1: for wms_layer in layers: try: db_server = DBSession.query(OGCServer).filter( OGCServer.name == server[0]).one() self._import_layer_attributes( db_server.url_wfs or db_server.url, wms_layer, layer.item_type, layer.name, messages) except NoResultFound: print( colorize( "ERROR! the OGC server '{}' from the WMTS layer '{}' does not exist." .format(server[0], layer.name), RED)) if os.environ.get("IGNORE_I18N_ERRORS", "FALSE") != "TRUE": raise
def main(): parser = argparse.ArgumentParser( description= "This script will rename all the theme elements to removes duplicated elements." ) parser.add_argument( '-i', '--iniconfig', default='production.ini', help='project .ini config file', ) parser.add_argument( '-n', '--app-name', default="app", help='The application name (optional, default is "app")', ) options = parser.parse_args() # read the configuration fileConfig(options.iniconfig, defaults=os.environ) get_app(options.iniconfig, options.app_name, options=os.environ) from c2cgeoportal.models import DBSession, LayerV1, LayerWMS, LayerWMTS, LayerGroup, Theme for class_ in [LayerV1, LayerWMS, LayerWMTS, LayerGroup, Theme]: names = [] for item in DBSession.query(class_).all(): if item.name in names: i = 2 while "{}-{}".format(item.name, i) in names: i += 1 item.name = "{}-{}".format(item.name, i) names.append(item.name) transaction.commit()
def main(): parser = argparse.ArgumentParser( description="Create and populate the database tables.") parser.add_argument('-i', '--iniconfig', default='production.ini', help='project .ini config file') parser.add_argument( '-n', '--app-name', default="app", help='The application name (optional, default is "app")') options = parser.parse_args() # read the configuration fileConfig(options.iniconfig, defaults=os.environ) get_app(options.iniconfig, options.app_name, options=os.environ) from c2cgeoportal.models import DBSession, Interface, OGCServer, Theme, LayerGroup, LayerWMS session = DBSession() interfaces = session.query(Interface).all() ogc_server = session.query(OGCServer).filter( OGCServer.name == "source for image/png").one() layer_borders = LayerWMS("Borders", "borders") layer_borders.interfaces = interfaces layer_borders.ogc_server = ogc_server layer_density = LayerWMS("Density", "density") layer_density.interfaces = interfaces layer_density.ogc_server = ogc_server group = LayerGroup("Demo") group.children = [layer_borders, layer_density] theme = Theme("Demo") theme.children = [group] theme.interfaces = interfaces session.add(theme) transaction.commit()
def _create_entry_obj(self, username=None, params={}): from c2cgeoportal.models import DBSession, User from c2cgeoportal.views.entry import Entry mapfile = os.path.join(os.path.dirname(os.path.abspath(__file__)), 'c2cgeoportal_test.map') mapserv = "%s?map=%s&" % (mapserv_url, mapfile) request = testing.DummyRequest() request.headers['Host'] = host request.registry.settings = { 'mapserv_url': mapserv, } mapserv = "%s?map=%s&" % (mapserv_url, mapfile) request.static_url = lambda url: '/dummy/static/url' request.route_url = lambda url: mapserv request.params = params if username: request.user = DBSession.query(User) \ .filter_by(username=username).one() else: request.user = None return Entry(request)
def teardown_method(self, _): testing.tearDown() from c2cgeoportal.models import DBSession, OGCServer, TreeItem, \ Interface, Metadata, Dimension DBSession.query(Metadata).delete() DBSession.query(Dimension).delete() for item in DBSession.query(TreeItem).all(): DBSession.delete(item) DBSession.query(Interface).filter(Interface.name == "main").delete() DBSession.query(OGCServer).delete() transaction.commit()
def default_user_validator(request, username, password): """ Validate the username/password. This is c2cgeoportal's default user validator. """ from c2cgeoportal.models import DBSession, User user = DBSession.query(User).filter_by(username=username).first() return username if user and user.validate_password(password) else None
def setup_method(self, _): # Always see the diff # https://docs.python.org/2/library/unittest.html#unittest.TestCase.maxDiff self.maxDiff = None from c2cgeoportal.models import DBSession, \ Theme, LayerGroup, Interface, LayerWMS, LayerWMTS, Dimension ogc_server, _ = create_default_ogcserver() main = Interface(name="main") layer_wms_1 = LayerWMS(name="__test_layer_wms_1", public=True) layer_wms_1.layer = "__test_layer_wms_1" layer_wms_1.interfaces = [main] layer_wms_1.ogc_server = ogc_server Dimension("A", "a", layer_wms_1) layer_wms_2 = LayerWMS(name="__test_layer_wms_2", public=True) layer_wms_2.layer = "__test_layer_wms_2" layer_wms_2.interfaces = [main] layer_wms_2.ogc_server = ogc_server Dimension("A", "b", layer_wms_2) layer_wms_3 = LayerWMS(name="__test_layer_wms_3", public=True) layer_wms_3.layer = "__test_layer_wms_3" layer_wms_3.interfaces = [main] layer_wms_3.ogc_server = ogc_server Dimension("A", None, layer_wms_3) layer_wms_4 = LayerWMS(name="__test_layer_wms_4", public=True) layer_wms_4.layer = "__test_layer_wms_4" layer_wms_4.interfaces = [main] layer_wms_4.ogc_server = ogc_server Dimension("A", "a", layer_wms_4) layer_wms_5 = LayerWMS(name="__test_layer_wms_5", public=True) layer_wms_5.layer = "__test_layer_wms_5" layer_wms_5.interfaces = [main] layer_wms_5.ogc_server = ogc_server Dimension("B", "b", layer_wms_5) layer_wms_6 = LayerWMS(name="__test_layer_wms_6", public=True) layer_wms_6.layer = "__test_layer_wms_6" layer_wms_6.interfaces = [main] layer_wms_6.ogc_server = ogc_server Dimension("FILTER", "countries:\"name\" IN ( 'Germany' , 'Italy' )", layer_wms_6) 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] Dimension("B", "b", layer_wmts) layer_wmts_2 = LayerWMTS(name="__test_layer_wmts_2", public=True) layer_wmts_2.url = "http://example.com/1.0.0/WMTSCapabilities.xml" layer_wmts_2.layer = "map" layer_wmts_2.interfaces = [main] Dimension("FILTER", "countries:\"name\" IN ( 'Germany' , 'Italy' )", layer_wmts_2) layer_group_1 = LayerGroup(name="__test_layer_group_1") layer_group_1.children = [layer_wms_1, layer_wmts, layer_wmts_2] layer_group_2 = LayerGroup(name="__test_layer_group_2") layer_group_2.children = [layer_wms_1, layer_wms_2] layer_group_3 = LayerGroup(name="__test_layer_group_3") layer_group_3.children = [layer_wms_1, layer_wms_3] layer_group_4 = LayerGroup(name="__test_layer_group_4") layer_group_4.children = [layer_wms_1, layer_wms_4] layer_group_5 = LayerGroup(name="__test_layer_group_5") layer_group_5.children = [layer_wms_1, layer_wms_5, layer_wms_6] layer_group_6 = LayerGroup(name="__test_layer_group_6") layer_group_6.children = [layer_wms_3] 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_6, ] DBSession.add(theme) transaction.commit()
def get_private_layers(): q = DBSession.query(Layer.name).filter(Layer.public.is_(False)) return [r for r, in q.all()]
def teardown_method(self, _): testing.tearDown() import transaction from c2cgeoportal.models import FullTextSearch, User, Role, Interface from c2cgeoportal.models import DBSession DBSession.query(User).filter(User.username == "__test_user1").delete() DBSession.query(User).filter(User.username == "__test_user2").delete() DBSession.query(FullTextSearch).filter( FullTextSearch.label == "label1").delete() DBSession.query(FullTextSearch).filter( FullTextSearch.label == "label2").delete() DBSession.query(FullTextSearch).filter( FullTextSearch.label == "label3").delete() DBSession.query(FullTextSearch).filter( FullTextSearch.label == "label4").delete() DBSession.query(FullTextSearch).filter( FullTextSearch.label == "label5").delete() DBSession.query(FullTextSearch).filter( FullTextSearch.label == "label6").delete() DBSession.query(Interface).filter(Interface.name == "main").delete() DBSession.query(Role).filter(Role.name == "__test_role1").delete() DBSession.query(Role).filter(Role.name == "__test_role2").delete() 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.models import DBSession, \ 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, _): import transaction from sqlalchemy import func from geoalchemy2 import WKTElement from c2cgeoportal.models import FullTextSearch, User, Role, Interface from c2cgeoportal.models import DBSession user1 = User(username="******", password="******") role1 = Role(name="__test_role1", description="__test_role1") user1.role_name = role1.name user2 = User(username="******", password="******") role2 = Role(name="__test_role2", description="__test_role2") user2.role_name = role2.name 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 = "label2" entry2.layer_name = "layer2" entry2.ts = func.to_tsvector("french", "pluie semaine") entry2.the_geom = WKTElement("POINT(-90 -45)", 21781) entry2.public = False entry3 = FullTextSearch() entry3.label = "label3" entry3.layer_name = "layer3" entry3.ts = func.to_tsvector("french", "vent neige") entry3.the_geom = WKTElement("POINT(-90 -45)", 21781) entry3.public = False entry3.role = role2 entry4 = FullTextSearch() entry4.label = "label4" entry4.layer_name = "layer1" entry4.ts = func.to_tsvector("french", "soleil travail") entry4.the_geom = WKTElement("POINT(-90 -45)", 21781) entry4.public = True entry5 = FullTextSearch() entry5.label = "label5" entry5.ts = func.to_tsvector("french", "params") entry5.public = True entry5.params = {"floor": 5} entry5.actions = [{"action": "add_layer", "data": "layer1"}] entry6 = FullTextSearch() entry6.label = "label6" entry6.ts = func.to_tsvector("french", "params") entry6.interface = Interface("main") entry6.public = True DBSession.add_all([ user1, user2, role1, role2, entry1, entry2, entry3, entry4, entry5, entry6 ]) transaction.commit()