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