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_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, LayerV1, Theme, Interface, LayerGroup
create_default_ogcserver()
main = Interface(name="main")
mobile = Interface(name="mobile")
layer = LayerV1(name="__test_layer")
layer.interfaces = [main, mobile]
mobile_only_layer = LayerV1(name="__test_mobile_only_layer")
mobile_only_layer.interfaces = [mobile]
desktop_only_layer = LayerV1(name="__test_desktop_only_layer")
desktop_only_layer.interfaces = [main]
group = LayerGroup(name="__test_layer_group")
group.children = [layer, mobile_only_layer, desktop_only_layer]
theme = Theme(name="__test_theme")
theme.children = [group]
theme.interfaces = [main, mobile]
mobile_only_group = LayerGroup(name="__test_mobile_only_layer_group")
mobile_only_group.children = [layer]
mobile_only_theme = Theme(name="__test_mobile_only_theme")
mobile_only_theme.children = [mobile_only_group]
mobile_only_theme.interfaces = [mobile]
desktop_only_group = LayerGroup(name="__test_desktop_only_layer_group")
desktop_only_group.children = [layer]
desktop_only_theme = Theme(name="__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="__test_mobile_private_layer_group")
mobile_private_group.children = [layer]
mobile_private_theme = Theme(name="__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): # 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
# 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, LayerGroup, Interface
create_default_ogcserver()
main = Interface(name=u"desktop")
layer = LayerV1(name=u"__test_layer", public=True)
layer.interfaces = [main]
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]
theme.interfaces = [main]
DBSession.add_all([layer, layer_group, theme])
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(self): # noqa
self.maxDiff = None
from c2cgeoportal.models import User, Role, LayerV1, RestrictionArea, \
Functionality, Interface, DBSession, management, OGCServer, \
OGCSERVER_TYPE_GEOSERVER, OGCSERVER_AUTH_GEOSERVER
if management:
TestPoint.__table__.c.the_geom.type.management = True
create_default_ogcserver()
ogcserver_geoserver = OGCServer(name="__test_ogc_server_geoserver")
ogcserver_geoserver.url = mapserv
ogcserver_geoserver.type = OGCSERVER_TYPE_GEOSERVER
ogcserver_geoserver.auth = OGCSERVER_AUTH_GEOSERVER
TestPoint.__table__.create(bind=DBSession.bind, checkfirst=True)
geom = WKTElement("MULTIPOINT((-90 -45))", srid=21781)
p1 = TestPoint(the_geom=geom,
name=u"foo",
city=u"Lausanne",
country=u"Swiss")
geom = WKTElement("MULTIPOINT((-90 45))", srid=21781)
p2 = TestPoint(the_geom=geom,
name=u"bar",
city=u"Chambéry",
country=u"France")
geom = WKTElement("MULTIPOINT((90 45))", srid=21781)
p3 = TestPoint(the_geom=geom,
name=u"éàè",
city="Paris",
country=u"France")
geom = WKTElement("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_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",
functionalities=[pt1, pt2])
user2.role_name = role2.name
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_name = role3.name
user3.email = u"Tarenpion"
main = Interface(name=u"main")
layer2 = LayerV1(u"testpoint_protected", public=False)
layer2.interfaces = [main]
layer3 = LayerV1(u"testpoint_protected_query_with_collect",
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"",
[layer2, layer3], [role1], area)
area = "POLYGON((-100 0, -100 20, 100 20, 100 0, -100 0))"
area = WKTElement(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 = WKTElement(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, role1, role2, role3,
restricted_area1, restricted_area2, restricted_area3,
ogcserver_geoserver
])
DBSession.flush()
self.id_lausanne = p1.id
self.id_paris = p3.id
transaction.commit()
def _create_layer(self,
public=False,
none_area=False,
attr_list=False,
exclude_properties=False,
metadatas=None):
""" This function is central for this test class. It creates
a layer with two features, and associates a restriction area
to it. """
import transaction
import sqlahelper
from sqlalchemy import Column, Table, types, ForeignKey
from sqlalchemy.ext.declarative import declarative_base
from geoalchemy2 import Geometry, WKTElement
from c2cgeoportal.models import DBSession, management, LayerV1, RestrictionArea
if self._tables is None:
self._tables = []
self.__class__._table_index += 1
id = self.__class__._table_index
engine = sqlahelper.get_engine()
connection = engine.connect()
if not self.metadata:
self.metadata = declarative_base(bind=engine).metadata
tablename = "table_%d" % id
table1 = Table("%s_child" % tablename,
self.metadata,
Column("id", types.Integer, primary_key=True),
Column("name", types.Unicode),
schema="public")
self._tables.append(table1)
table2 = Table(tablename,
self.metadata,
Column("id", types.Integer, primary_key=True),
Column("child_id", types.Integer,
ForeignKey("public.%s_child.id" % tablename)),
Column("name", types.Unicode),
Column(
"geom",
Geometry("POINT", srid=21781,
management=management)),
schema="public")
self._tables.append(table2)
table2.drop(checkfirst=True)
table1.drop(checkfirst=True)
table1.create()
table2.create()
ins = table1.insert().values(name=u"c1é")
c1_id = connection.execute(ins).inserted_primary_key[0]
ins = table1.insert().values(name=u"c2é")
c2_id = connection.execute(ins).inserted_primary_key[0]
ins = table2.insert().values(child_id=c1_id,
name="foo",
geom=WKTElement("POINT(5 45)", 21781))
connection.execute(ins)
ins = table2.insert().values(child_id=c2_id,
name="bar",
geom=WKTElement("POINT(6 46)", 21781))
connection.execute(ins)
if attr_list:
ins = table2.insert().values(child_id=c2_id,
name="aaa,bbb,foo",
geom=WKTElement("POINT(6 46)", 21781))
connection.execute(ins)
layer = LayerV1()
layer.id = id
layer.name = str(id)
layer.geo_table = tablename
layer.public = public
layer.interface = [self.main]
if exclude_properties:
layer.exclude_properties = "name"
if metadatas:
layer.metadatas = metadatas
DBSession.add(layer)
if not public:
ra = RestrictionArea()
ra.name = u"__test_ra"
ra.layers = [layer]
ra.roles = [self.role]
ra.readwrite = True
if not none_area:
poly = "POLYGON((4 44, 4 46, 6 46, 6 44, 4 44))"
ra.area = WKTElement(poly, srid=21781)
DBSession.add(ra)
transaction.commit()
self.layer_ids.append(id)
return id