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 create(self):
if 'url' not in self.request.params:
raise HTTPBadRequest('The parameter url is required')
url = self.request.params['url']
# Check that it is an internal URL...
hostname = urlparse(url).hostname
if hostname != self.request.host:
raise HTTPBadRequest("The requested host '%s' shound be '%s'" %
(hostname, self.request.host))
tries = 0
while True:
ref = ''.join(
random.choice(string.ascii_letters + string.digits)
for i in range(self.settings.get('length', 4)))
test_url = DBSession.query(Shorturl).filter(
Shorturl.ref == ref).all()
if len(test_url) == 0:
break
if tries > 20: # pragma: no cover
message = "No free ref found, considere to incrase the length"
logging.error(message)
raise HTTPInternalServerError(message)
user_email = self.request.user.email \
if self.request.user is not None else None
email = self.request.params.get('email') or user_email
short_url = Shorturl()
short_url.url = url
short_url.ref = ref
short_url.creator_email = email
short_url.creation = datetime.now()
short_url.nb_hits = 0
DBSession.add(short_url)
s_url = self.request.route_url('shortener_get', ref=ref)
if \
email is not None and \
'email_from' in self.settings and \
'email_subject' in self.settings and \
'email_body' in self.settings and \
'smtp_server' in self.settings: # pragma: no cover
text = self.settings['email_body'] % {
'full_url': url,
'short_url': s_url,
}
send_email(
self.settings['email_from'],
[email],
text.encode('utf-8'),
self.settings['email_subject'],
self.settings['smtp_server'],
)
return {'short_url': s_url}
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): # 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):
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 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 setUp(self): # noqa
# Always see the diff
# https://docs.python.org/2/library/unittest.html#unittest.TestCase.maxDiff
self.maxDiff = None
functionality.FUNCTIONALITIES_TYPES = None
from c2cgeoportal.models import DBSession, User, Role, \
RestrictionArea, Theme, LayerGroup, Interface, LayerWMS
ogcserver, ogcserver_external = create_default_ogcserver()
role1 = Role(name=u"__test_role1")
role1.id = 999
user1 = User(username=u"__test_user1", password=u"__test_user1", role=role1)
user1.email = "*****@*****.**"
role2 = Role(name=u"__test_role2", extent=WKTElement(
"POLYGON((1 2, 1 4, 3 4, 3 2, 1 2))", srid=21781
))
user2 = User(username=u"__test_user2", password=u"__test_user2", role=role2)
main = Interface(name=u"main")
private_layer = LayerWMS(name=u"__test_private_layer", public=False)
private_layer.layer = "__test_private_layer"
private_layer.geo_table = "a_schema.a_geo_table"
private_layer.interfaces = [main]
private_layer.ogc_server = ogcserver
group = LayerGroup(name=u"__test_layer_group")
group.children = [private_layer]
theme = Theme(name=u"__test_theme")
theme.children = [group]
theme.interfaces = [main]
DBSession.add(RestrictionArea(
name=u"__test_ra1", description=u"", layers=[private_layer],
roles=[role1],
))
DBSession.add(RestrictionArea(
name=u"__test_ra2", description=u"", layers=[private_layer],
roles=[role2], readwrite=True,
))
DBSession.add_all([
user1, user2, role1, role2, theme, group, private_layer,
])
transaction.commit()
def setup_method(self, _):
self.maxDiff = None
from c2cgeoportal.models import User, DBSession
user = User(username="******", password="******")
DBSession.add(user)
DBSession.flush()
self.old_remember = pyramid.security.remember
self.user = None
def remember(request, user=None):
self.user = user
pyramid.security.remember = remember
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 setUp(self):
import sqlahelper
import transaction
from c2cgeoportal.models import DBSession, Role, User
from c2cgeoportal.lib.dbreflection import init
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)
DBSession.add(self.user)
transaction.commit()
engine = sqlahelper.get_engine()
init(engine)
def setUp(self):
import sqlahelper
import transaction
from c2cgeoportal.models import DBSession, Role, User
from c2cgeoportal.lib.dbreflection import init
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
)
DBSession.add(self.user)
transaction.commit()
engine = sqlahelper.get_engine()
init(engine)
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
main = Interface(name=u"main")
ogc_server = OGCServer(name="__test_ogc_server", type="mapserver", image_type="image/jpeg")
layer_wms_1 = LayerWMS(name=u"__test_layer_wms", public=True)
layer_wms_1.layer = "testpoint_unprotected"
layer_wms_1.interfaces = [main]
layer_wms_1.ogc_server = ogc_server
layer_wms_2 = LayerWMS(name=u"__test_layer_wms", public=True)
layer_wms_2.layer = "testpoint_substitution"
layer_wms_2.interfaces = [main]
layer_wms_2.ogc_server = ogc_server
layer_wms_3 = LayerWMS(name=u"__test_layer_wms_3", public=True)
layer_wms_3.layer = "testpoint_unprotected,testpoint_substitution"
layer_wms_3.interfaces = [main]
layer_wms_3.ogc_server = ogc_server
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_wms_3]
theme = Theme(name=u"__test_theme")
theme.interfaces = [main]
theme.children = [
layer_group_1, layer_group_2
]
DBSession.add(theme)
transaction.commit()
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): # 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_method(self, _):
import transaction
from c2cgeoportal.models import DBSession, Role, User, Interface
cleanup_db()
self.metadata = None
self.layer_ids = []
DBSession.query(User).delete()
DBSession.query(User).filter(User.username == "__test_user").delete()
self.role = Role(name="__test_role")
self.user = User(username="******",
password="******",
role=self.role)
self.main = Interface(name="main")
DBSession.add(self.user)
DBSession.add(self.role)
DBSession.add(self.main)
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
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
def create(self):
if 'url' not in self.request.params:
raise HTTPBadRequest('The parameter url is required')
url = self.request.params['url']
# Check that it is an internal URL...
uri_parts = urlparse(url)
hostname = uri_parts.hostname
paths = uri_parts.path.split('/')
if hostname != self.request.server_name:
raise HTTPBadRequest("The requested host '%s' should be '%s'" % (
hostname, self.request.host
))
shortened = False
if (len(paths) > 1 and paths[-2] == 'short'):
ref = paths[-1]
shortened = True
tries = 0
while not shortened:
ref = ''.join(
random.choice(string.ascii_letters + string.digits)
for i in range(self.settings.get('length', 4))
)
test_url = DBSession.query(Shorturl).filter(Shorturl.ref == ref).all()
if len(test_url) == 0:
break
tries += 1 # pragma: no cover
if tries > 20: # pragma: no cover
message = "No free ref found, considere to increase the length"
logging.error(message)
raise HTTPInternalServerError(message)
user_email = self.request.user.email \
if self.request.user is not None else None
email = self.request.params.get('email')
if not shortened:
short_url = Shorturl()
short_url.url = url
short_url.ref = ref
short_url.creator_email = user_email
short_url.creation = datetime.now()
short_url.nb_hits = 0
DBSession.add(short_url)
s_url = self.request.route_url('shortener_get', ref=ref)
email = email or user_email
if \
email is not None and \
'email_from' in self.settings and \
'email_subject' in self.settings and \
'email_body' in self.settings and \
'smtp_server' in self.settings: # pragma: no cover
text = self.settings['email_body'] % {
'full_url': url,
'short_url': s_url,
}
send_email(
self.settings['email_from'],
[email],
text.encode('utf-8'),
self.settings['email_subject'],
self.settings['smtp_server'],
)
return {'short_url': s_url}
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, Metadata
desktop = Interface(name="desktop")
ogc_server_internal, _ = create_default_ogcserver()
layer_wms = LayerWMS(name="__test_layer_internal_wms", public=True)
layer_wms.layer = "__test_layer_internal_wms"
layer_wms.ogc_server = ogc_server_internal
layer_wms.interfaces = [desktop]
layer_wms.metadatas = [
Metadata("string", "string"),
Metadata("list", "1, 2, a"),
Metadata("boolean", "y"),
Metadata("boolean2", "no"),
Metadata("boolean3", "Hello"),
Metadata("integer", "1"),
Metadata("float", "5.5"),
Metadata("json", '{"test": 123}'),
Metadata("json_wrong", '{"test": 123'),
Metadata("date", "Sep 25 2003"),
Metadata("time", "10:36:28"),
Metadata("datetime", "Sep 25 10:36:28 BRST 2003"),
Metadata("date2", "Sep 25 10:36:28 BRST 2003"),
Metadata("time2", "Sep 25 10:36:28 BRST 2003"),
Metadata("datetime2", "Hello"),
Metadata("url1", "http://example.com/hi?a=b#c"),
Metadata("url2", "static:///path/icon.png"),
Metadata("url3", "static://static/path/icon.png"),
Metadata("url4", "static://cgxp/path/icon.png"),
Metadata("url5", "static://project:static/path/icon.png"),
Metadata("url6", "static://project:cgxp/path/icon.png"),
Metadata("url7", "config://server"),
Metadata("url8", "config://server/index.html"),
Metadata("url9", "/dummy/static/icon.png"),
Metadata("url10", "dummy/static/icon.png"),
Metadata("url11", "https:///static/icon.png"),
Metadata("url12", "static://test"),
Metadata("url13", "static://test/"),
Metadata("url14", "config:///static/icon.png"),
Metadata("url15", "config://unknown_server"),
Metadata("url16", "https://"),
Metadata("url17", "https:///"),
Metadata("url18", "https:///static"),
Metadata("url19", ""),
Metadata("url20", "/"),
Metadata("unknown", "Hello"),
]
layer_group = LayerGroup(name="__test_layer_group")
layer_group.children = [layer_wms]
theme = Theme(name="__test_theme")
theme.interfaces = [desktop]
theme.children = [layer_group]
DBSession.add(theme)
transaction.commit()
def create(self):
if "url" not in self.request.params:
raise HTTPBadRequest("The parameter url is required")
url = self.request.params["url"]
# Check that it is an internal URL...
uri_parts = urlparse(url)
hostname = uri_parts.hostname
if "allowed_hosts" in self.settings:
if hostname not in self.settings[
"allowed_hosts"]: # pragma: no cover
raise HTTPBadRequest("The requested host is not allowed.")
else:
if hostname != self.request.server_name:
raise HTTPBadRequest("The requested host '%s' should be '%s'" %
(hostname, self.request.server_name))
shortened = False
for base in self.short_bases:
base_parts = urlparse(base)
if uri_parts.path.startswith(base_parts.path):
shortened = True
ref = uri_parts.path.split("/")[-1]
tries = 0
while not shortened:
ref = "".join(
random.choice(string.ascii_letters + string.digits)
for i in range(self.settings.get("length", 4)))
test_url = DBSession.query(Shorturl).filter(
Shorturl.ref == ref).all()
if len(test_url) == 0:
break
tries += 1 # pragma: no cover
if tries > 20: # pragma: no cover
message = "No free ref found, considere to increase the length"
logging.error(message)
raise HTTPInternalServerError(message)
user_email = self.request.user.email \
if self.request.user is not None else None
email = self.request.params.get("email")
if not shortened:
short_url = Shorturl()
short_url.url = url
short_url.ref = ref
short_url.creator_email = user_email
short_url.creation = datetime.now()
short_url.nb_hits = 0
DBSession.add(short_url)
if "base_url" in self.settings:
s_url = self.settings["base_url"] + ref
else:
s_url = self.request.route_url("shortener_get", ref=ref)
if \
email is not None and \
"email_from" in self.settings and \
"email_subject" in self.settings and \
"email_body" in self.settings and \
"smtp_server" in self.settings: # pragma: no cover
text = self.settings["email_body"] % {
"full_url": url,
"short_url": s_url,
"message": self.request.params.get("message", ""),
}
send_email(
self.settings["email_from"],
[email],
text.encode("utf-8"),
self.settings["email_subject"],
self.settings["smtp_server"],
)
set_common_headers(self.request, "shortner", NO_CACHE)
return {"short_url": s_url}
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, OGCServer, LayerWMS, LayerWMTS
main = Interface(name="main")
ogc_server_internal, _ = create_default_ogcserver()
ogc_server_external = OGCServer(name="__test_ogc_server_external",
url="http://wms.geo.admin.ch/",
image_type="image/jpeg")
layer_internal_wms = LayerWMS(name="__test_layer_internal_wms",
public=True)
layer_internal_wms.layer = "__test_layer_internal_wms"
layer_internal_wms.interfaces = [main]
layer_internal_wms.ogc_server = ogc_server_internal
layer_external_wms = LayerWMS(name="__test_layer_external_wms",
layer="ch.swisstopo.dreiecksvermaschung",
public=True)
layer_external_wms.interfaces = [main]
layer_external_wms.ogc_server = ogc_server_external
layer_wmts = LayerWMTS(name="__test_layer_wmts", public=True)
layer_wmts.url = "http://example.com/1.0.0/WMTSCapabilities.xml"
layer_wmts.layer = "map"
layer_wmts.interfaces = [main]
layer_group_1 = LayerGroup(name="__test_layer_group_1")
layer_group_1.children = [layer_internal_wms]
layer_group_2 = LayerGroup(name="__test_layer_group_2")
layer_group_2.children = [layer_external_wms]
layer_group_3 = LayerGroup(name="__test_layer_group_3")
layer_group_3.children = [layer_wmts]
layer_group_4 = LayerGroup(name="__test_layer_group_4")
layer_group_4.children = [layer_group_1, layer_group_2]
layer_group_5 = LayerGroup(name="__test_layer_group_5")
layer_group_5.children = [layer_group_1, layer_group_3]
layer_group_6 = LayerGroup(name="__test_layer_group_6")
layer_group_6.children = [layer_internal_wms]
layer_group_7 = LayerGroup(name="__test_layer_group_7")
layer_group_7.children = [layer_group_1, layer_group_6]
layer_group_8 = LayerGroup(name="__test_layer_group_8")
layer_group_8.children = [layer_group_2, layer_group_6]
theme = Theme(name="__test_theme")
theme.interfaces = [main]
theme.children = [
layer_group_1,
layer_group_2,
layer_group_3,
layer_group_4,
layer_group_5,
layer_group_7,
layer_group_8,
]
DBSession.add(theme)
transaction.commit()
class Import:
def __init__(self, options):
self.options = options
self.imported = set()
settings = get_config(".build/config.yaml")
package = settings["package"]
self.fts_languages = settings["fulltextsearch"]["languages"]
self.languages = settings["available_locale_names"]
# must be done only once we have loaded the project config
from c2cgeoportal.models import DBSession, FullTextSearch, Interface, Theme, Role
self.session = DBSession()
self.session.execute(FullTextSearch.__table__.delete().where(
FullTextSearch.from_theme == True)) # noqa
self._ = {}
for lang in self.languages:
self._[lang] = translation("{}-client".format(package),
os.path.join(package, "locale/"),
[lang])
query = self.session.query(Interface)
if options.interfaces is not None:
query = query.filter(Interface.name.in_(options.interfaces))
self.interfaces = query.all()
self.public_theme = {}
self.public_group = {}
for interface in self.interfaces:
self.public_theme[interface.id] = []
self.public_group[interface.id] = []
for theme in self.session.query(Theme).filter_by(public=True).all():
self._add_theme(theme)
for role in self.session.query(Role).all():
for theme in self.session.query(Theme).all():
self._add_theme(theme, role)
transaction.commit()
def _add_fts(self, item, interface, action, role):
from c2cgeoportal.models import FullTextSearch
key = (item.name if self.options.name else item.id, interface.id,
role.id if role is not None else None)
if key not in self.imported:
self.imported.add(key)
for lang in self.languages:
fts = FullTextSearch()
fts.label = self._[lang].gettext(item.name)
fts.role = role
fts.interface = interface
fts.lang = lang
fts.public = role is None
fts.ts = func.to_tsvector(self.fts_languages[lang], fts.label)
fts.actions = [{
"action": action,
"data": item.name,
}]
fts.from_theme = True
self.session.add(fts)
def _add_theme(self, theme, role=None):
fill = False
for interface in self.interfaces:
if interface in theme.interfaces:
for child in theme.children:
fill = self._add_block(child, interface, role) or fill
if fill and self.options.themes:
if role is None:
self.public_theme[interface.id].append(theme.id)
if role is None or theme.id not in self.public_theme[
interface.id]:
self._add_fts(theme, interface, "add_theme", role)
def _add_block(self, group, interface, role):
return self._add_group(group, interface, self.options.blocks, role)
def _add_folder(self, group, interface, role):
return self._add_group(group, interface, self.options.folders, role)
def _add_group(self, group, interface, export, role):
from c2cgeoportal.models import LayerGroup
fill = False
for child in group.children:
if isinstance(child, LayerGroup):
fill = self._add_folder(child, interface, role) or fill
else:
fill = self._add_layer(child, interface, role) or fill
if fill and export:
if role is None:
self.public_group[interface.id].append(group.id)
if role is None or group.id not in self.public_group[interface.id]:
self._add_fts(group, interface, "add_group", role)
return fill
def _layer_visible(self, layer, role):
for restrictionarea in layer.restrictionareas:
if role in restrictionarea.roles:
return True
return False
def _add_layer(self, layer, interface, role):
from c2cgeoportal.models import LayerV1
if isinstance(layer, LayerV1):
return False
if role is None:
fill = layer.public and interface in layer.interfaces
else:
fill = interface in layer.interfaces and not layer.public and \
self._layer_visible(layer, role)
if fill and self.options.layers:
self._add_fts(layer, interface, "add_layer", role)
return fill
def create(self):
if "url" not in self.request.params:
raise HTTPBadRequest("The parameter url is required")
url = self.request.params["url"]
# Check that it is an internal URL...
uri_parts = urlparse(url)
hostname = uri_parts.hostname
paths = uri_parts.path.split("/")
if hostname != self.request.server_name:
raise HTTPBadRequest("The requested host '%s' should be '%s'" % (
hostname, self.request.host
))
shortened = False
if (len(paths) > 1 and paths[-2] == "short"):
ref = paths[-1]
shortened = True
tries = 0
while not shortened:
ref = "".join(
random.choice(string.ascii_letters + string.digits)
for i in range(self.settings.get("length", 4))
)
test_url = DBSession.query(Shorturl).filter(Shorturl.ref == ref).all()
if len(test_url) == 0:
break
tries += 1 # pragma: no cover
if tries > 20: # pragma: no cover
message = "No free ref found, considere to increase the length"
logging.error(message)
raise HTTPInternalServerError(message)
user_email = self.request.user.email \
if self.request.user is not None else None
email = self.request.params.get("email")
if not shortened:
short_url = Shorturl()
short_url.url = url
short_url.ref = ref
short_url.creator_email = user_email
short_url.creation = datetime.now()
short_url.nb_hits = 0
DBSession.add(short_url)
if "base_url" in self.settings:
s_url = self.settings["base_url"] + ref
else:
s_url = self.request.route_url("shortener_get", ref=ref)
email = email or user_email
if \
email is not None and \
"email_from" in self.settings and \
"email_subject" in self.settings and \
"email_body" in self.settings and \
"smtp_server" in self.settings: # pragma: no cover
text = self.settings["email_body"] % {
"full_url": url,
"short_url": s_url,
}
send_email(
self.settings["email_from"],
[email],
text.encode("utf-8"),
self.settings["email_subject"],
self.settings["smtp_server"],
)
set_common_headers(
self.request, "shortner", NO_CACHE
)
return {"short_url": s_url}
class Import:
def __init__(self, options):
self.options = options
self.imported = set()
settings = get_config(".build/config.yaml")
package = settings["package"]
self.fts_languages = settings["fulltextsearch"]["languages"]
self.languages = settings["available_locale_names"]
# must be done only once we have loaded the project config
from c2cgeoportal.models import DBSession, FullTextSearch, Interface, Theme, Role
self.session = DBSession()
self.session.execute(FullTextSearch.__table__.delete().where(FullTextSearch.from_theme == True)) # noqa
self._ = {}
for lang in self.languages:
self._[lang] = translation(
"{}-client".format(package), os.path.join(package, "locale/"), [lang])
query = self.session.query(Interface)
if options.interfaces is not None:
query = query.filter(
Interface.name.in_(options.interfaces)
)
self.interfaces = query.all()
self.public_theme = {}
self.public_group = {}
for interface in self.interfaces:
self.public_theme[interface.id] = []
self.public_group[interface.id] = []
for theme in self.session.query(Theme).filter_by(public=True).all():
self._add_theme(theme)
for role in self.session.query(Role).all():
for theme in self.session.query(Theme).all():
self._add_theme(theme, role)
transaction.commit()
def _add_fts(self, item, interface, action, role):
from c2cgeoportal.models import FullTextSearch
key = (
item.name if self.options.name else item.id,
interface.id,
role.id if role is not None else None
)
if key not in self.imported:
self.imported.add(key)
for lang in self.languages:
fts = FullTextSearch()
fts.label = self._[lang].gettext(item.name)
fts.role = role
fts.interface = interface
fts.lang = lang
fts.public = role is None
fts.ts = func.to_tsvector(self.fts_languages[lang], fts.label)
fts.actions = [{
"action": action,
"data": item.name,
}]
fts.from_theme = True
self.session.add(fts)
def _add_theme(self, theme, role=None):
fill = False
for interface in self.interfaces:
if interface in theme.interfaces:
for child in theme.children:
fill = self._add_block(child, interface, role) or fill
if fill and self.options.themes:
if role is None:
self.public_theme[interface.id].append(theme.id)
if role is None or theme.id not in self.public_theme[interface.id]:
self._add_fts(theme, interface, "add_theme", role)
def _add_block(self, group, interface, role):
return self._add_group(group, interface, self.options.blocks, role)
def _add_folder(self, group, interface, role):
return self._add_group(group, interface, self.options.folders, role)
def _add_group(self, group, interface, export, role):
from c2cgeoportal.models import LayerGroup
fill = False
for child in group.children:
if isinstance(child, LayerGroup):
fill = self._add_folder(child, interface, role) or fill
else:
fill = self._add_layer(child, interface, role) or fill
if fill and export:
if role is None:
self.public_group[interface.id].append(group.id)
if role is None or group.id not in self.public_group[interface.id]:
self._add_fts(group, interface, "add_group", role)
return fill
def _layer_visible(self, layer, role):
for restrictionarea in layer.restrictionareas:
if role in restrictionarea.roles:
return True
return False
def _add_layer(self, layer, interface, role):
from c2cgeoportal.models import LayerV1
if isinstance(layer, LayerV1):
return False
if role is None:
fill = layer.public and interface in layer.interfaces
else:
fill = interface in layer.interfaces and not layer.public and \
self._layer_visible(layer, role)
if fill and self.options.layers:
self._add_fts(layer, interface, "add_layer", role)
return fill
def _create_layer(self, public=False):
""" 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 func
from sqlalchemy import Column, Table, types, ForeignKey
from sqlalchemy.ext.declarative import declarative_base
from geoalchemy import (GeometryDDL, GeometryExtensionColumn,
Point, WKTSpatialElement)
from c2cgeoportal.models import DBSession, Layer, RestrictionArea
self.__class__._table_index = self.__class__._table_index + 1
id = self.__class__._table_index
engine = sqlahelper.get_engine()
if not self.metadata:
self.metadata = declarative_base(bind=engine).metadata
tablename = "table_%d" % id
table = Table('%s_child' % tablename, self.metadata,
Column('id', types.Integer, primary_key=True),
Column('name', types.Unicode),
schema='public'
)
table.create()
ins = table.insert().values(name=u'c1é')
c1_id = engine.connect().execute(ins).inserted_primary_key[0]
ins = table.insert().values(name=u'c2é')
c2_id = engine.connect().execute(ins).inserted_primary_key[0]
table = 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),
GeometryExtensionColumn('geom', Point(srid=21781)),
schema='public')
GeometryDDL(table)
table.create()
ins = table.insert().values(
child_id=c1_id,
name='foo',
geom=func.ST_GeomFromText('POINT(5 45)', 21781))
f1_id = engine.connect().execute(ins).inserted_primary_key[0] # NOQA
ins = table.insert().values(
child_id=c2_id,
name='bar',
geom=func.ST_GeomFromText('POINT(6 46)', 21781))
f2_id = engine.connect().execute(ins).inserted_primary_key[0] # NOQA
layer = Layer()
layer.id = id
layer.geoTable = tablename
layer.public = public
DBSession.add(layer)
if not public:
ra = RestrictionArea()
ra.name = u'__test_ra'
ra.layers = [layer]
ra.roles = [self.role]
ra.readwrite = True
poly = 'POLYGON((4 44, 4 46, 6 46, 6 44, 4 44))'
ra.area = WKTSpatialElement(poly, srid=21781)
DBSession.add(ra)
self.layer_ids.append(self.__class__._table_index)
transaction.commit()
return id
def setUp(self): # noqa
# Always see the diff
# https://docs.python.org/2/library/unittest.html#unittest.TestCase.maxDiff
self.maxDiff = None
functionality.FUNCTIONALITIES_TYPES = None
from c2cgeoportal.models import DBSession, User, Role, \
RestrictionArea, Theme, LayerGroup, Interface, LayerWMS
ogcserver, ogcserver_external = create_default_ogcserver()
role1 = Role(name=u"__test_role1")
role1.id = 999
user1 = User(username=u"__test_user1",
password=u"__test_user1",
role=role1)
user1.email = "*****@*****.**"
role2 = Role(name=u"__test_role2",
extent=WKTElement("POLYGON((1 2, 1 4, 3 4, 3 2, 1 2))",
srid=21781))
user2 = User(username=u"__test_user2",
password=u"__test_user2",
role=role2)
main = Interface(name=u"main")
private_layer = LayerWMS(name=u"__test_private_layer", public=False)
private_layer.layer = "__test_private_layer"
private_layer.geo_table = "a_schema.a_geo_table"
private_layer.interfaces = [main]
private_layer.ogc_server = ogcserver
group = LayerGroup(name=u"__test_layer_group")
group.children = [private_layer]
theme = Theme(name=u"__test_theme")
theme.children = [group]
theme.interfaces = [main]
DBSession.add(
RestrictionArea(
name=u"__test_ra1",
description=u"",
layers=[private_layer],
roles=[role1],
))
DBSession.add(
RestrictionArea(
name=u"__test_ra2",
description=u"",
layers=[private_layer],
roles=[role2],
readwrite=True,
))
DBSession.add_all([
user1,
user2,
role1,
role2,
theme,
group,
private_layer,
])
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, ServerOGC, LayerWMS, UIMetadata
desktop = Interface(name=u"desktop")
server_ogc_internal = ServerOGC(name="__test_server_ogc_internal", type="mapserver", image_type="image/png")
layer_wms = LayerWMS(name=u"__test_layer_internal_wms", public=True)
layer_wms.layer = "__test_layer_internal_wms"
layer_wms.server_ogc = server_ogc_internal
layer_wms.interfaces = [desktop]
layer_wms.ui_metadatas = [
UIMetadata("string", "string"),
UIMetadata("list", "1, 2, a"),
UIMetadata("boolean", "y"),
UIMetadata("boolean2", "no"),
UIMetadata("boolean3", "Hello"),
UIMetadata("integer", "1"),
UIMetadata("float", "5.5"),
UIMetadata("date", "Sep 25 2003"),
UIMetadata("time", "10:36:28"),
UIMetadata("datetime", "Sep 25 10:36:28 BRST 2003"),
UIMetadata("date2", "Sep 25 10:36:28 BRST 2003"),
UIMetadata("time2", "Sep 25 10:36:28 BRST 2003"),
UIMetadata("datetime2", "Hello"),
UIMetadata("url1", "http://example.com/hi?a=b#c"),
UIMetadata("url2", "static:///path/icon.png"),
UIMetadata("url3", "static://static/path/icon.png"),
UIMetadata("url4", "static://cgxp/path/icon.png"),
UIMetadata("url5", "static://project:static/path/icon.png"),
UIMetadata("url6", "static://project:cgxp/path/icon.png"),
UIMetadata("url7", "config://server"),
UIMetadata("url8", "config://server/index.html"),
UIMetadata("url9", "/dummy/static/icon.png"),
UIMetadata("url10", "dummy/static/icon.png"),
UIMetadata("url11", "https:///static/icon.png"),
UIMetadata("url12", "static://test"),
UIMetadata("url13", "static://test/"),
UIMetadata("url14", "config:///static/icon.png"),
UIMetadata("url15", "config://unknown_server"),
UIMetadata("url16", "https://"),
UIMetadata("url17", "https:///"),
UIMetadata("url18", "https:///static"),
UIMetadata("url19", ""),
UIMetadata("url20", "/"),
UIMetadata("unknown", "Hello"),
]
layer_group = LayerGroup(name=u"__test_layer_group")
layer_group.children = [layer_wms]
theme = Theme(name=u"__test_theme")
theme.interfaces = [desktop]
theme.children = [layer_group]
DBSession.add(theme)
transaction.commit()
def create(self):
if "url" not in self.request.params:
raise HTTPBadRequest("The parameter url is required")
url = self.request.params["url"]
# see: http://httpd.apache.org/docs/2.2/mod/core.html#limitrequestline
if len(url) > 8190: # pragma: no cover
raise HTTPBadRequest("The parameter url is too long ({} > {})".format(len(url), 8190))
# Check that it is an internal URL...
uri_parts = urlparse(url)
hostname = uri_parts.hostname
if "allowed_hosts" in self.settings:
if hostname not in self.settings["allowed_hosts"]: # pragma: no cover
raise HTTPBadRequest("The requested host is not allowed.")
else:
if hostname != self.request.server_name:
raise HTTPBadRequest("The requested host '{0!s}' should be '{1!s}'".format(
hostname, self.request.server_name
))
shortened = False
for base in self.short_bases:
base_parts = urlparse(base)
if uri_parts.path.startswith(base_parts.path):
shortened = True
ref = uri_parts.path.split("/")[-1]
tries = 0
while not shortened:
ref = "".join(
random.choice(string.ascii_letters + string.digits)
for i in range(self.settings.get("length", 4))
)
test_url = DBSession.query(Shorturl).filter(Shorturl.ref == ref).all()
if len(test_url) == 0:
break
tries += 1 # pragma: no cover
if tries > 20: # pragma: no cover
message = "No free ref found, considere to increase the length"
logging.error(message)
raise HTTPInternalServerError(message)
user_email = self.request.user.email \
if self.request.user is not None else None
email = self.request.params.get("email")
if not shortened:
short_url = Shorturl()
short_url.url = url
short_url.ref = ref
short_url.creator_email = user_email
short_url.creation = datetime.now()
short_url.nb_hits = 0
DBSession.add(short_url)
if "base_url" in self.settings:
s_url = self.settings["base_url"] + ref
else:
s_url = self.request.route_url("shortener_get", ref=ref)
if \
email is not None and \
"email_from" in self.settings and \
"email_subject" in self.settings and \
"email_body" in self.settings and \
"smtp_server" in self.settings: # pragma: no cover
text = self.settings["email_body"] % {
"full_url": url,
"short_url": s_url,
"message": self.request.params.get("message", ""),
}
send_email(
self.settings["email_from"],
[email],
text.encode("utf-8"),
self.settings["email_subject"],
self.settings["smtp_server"],
)
set_common_headers(
self.request, "shortner", NO_CACHE
)
return {"short_url": s_url}
def _create_layer(self,
public=False,
none_area=False,
attr_list=False,
exclude_properties=False):
""" 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 func
from sqlalchemy import Column, Table, types, ForeignKey
from sqlalchemy.ext.declarative import declarative_base
from geoalchemy import (GeometryDDL, GeometryExtensionColumn, Point,
WKTSpatialElement)
from c2cgeoportal.models import DBSession, Layer, RestrictionArea
self.__class__._table_index = self.__class__._table_index + 1
id = self.__class__._table_index
engine = sqlahelper.get_engine()
if not self.metadata:
self.metadata = declarative_base(bind=engine).metadata
tablename = "table_%d" % id
table = Table('%s_child' % tablename,
self.metadata,
Column('id', types.Integer, primary_key=True),
Column('name', types.Unicode),
schema='public')
table.create()
ins = table.insert().values(name=u'c1é')
c1_id = engine.connect().execute(ins).inserted_primary_key[0]
ins = table.insert().values(name=u'c2é')
c2_id = engine.connect().execute(ins).inserted_primary_key[0]
table = 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),
GeometryExtensionColumn('geom', Point(srid=21781)),
schema='public')
GeometryDDL(table)
table.create()
ins = table.insert().values(child_id=c1_id,
name='foo',
geom=func.ST_GeomFromText(
'POINT(5 45)', 21781))
engine.connect().execute(ins).inserted_primary_key[0]
ins = table.insert().values(child_id=c2_id,
name='bar',
geom=func.ST_GeomFromText(
'POINT(6 46)', 21781))
engine.connect().execute(ins).inserted_primary_key[0]
if attr_list:
ins = table.insert().values(child_id=c2_id,
name='aaa,bbb,foo',
geom=func.ST_GeomFromText(
'POINT(6 46)', 21781))
engine.connect().execute(ins).inserted_primary_key[0]
layer = Layer()
layer.id = id
layer.geoTable = tablename
layer.public = public
if exclude_properties:
layer.excludeProperties = 'name'
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 = WKTSpatialElement(poly, srid=21781)
DBSession.add(ra)
self.layer_ids.append(self.__class__._table_index)
transaction.commit()
return id
def _create_layer(
self, public=False, none_area=False, attr_list=False,
exclude_properties=False):
""" 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()
if not self.metadata:
self.metadata = declarative_base(bind=engine).metadata
tablename = "table_%d" % id
table = Table(
'%s_child' % tablename, self.metadata,
Column('id', types.Integer, primary_key=True),
Column('name', types.Unicode),
schema='public'
)
table.create()
self._tables.append(table)
ins = table.insert().values(name=u'c1é')
c1_id = engine.connect().execute(ins).inserted_primary_key[0]
ins = table.insert().values(name=u'c2é')
c2_id = engine.connect().execute(ins).inserted_primary_key[0]
table = 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'
)
table.create()
self._tables.append(table)
ins = table.insert().values(
child_id=c1_id,
name='foo',
geom=WKTElement('POINT(5 45)', 21781)
)
engine.connect().execute(ins).inserted_primary_key[0]
ins = table.insert().values(
child_id=c2_id,
name='bar',
geom=WKTElement('POINT(6 46)', 21781)
)
engine.connect().execute(ins).inserted_primary_key[0]
if attr_list:
ins = table.insert().values(
child_id=c2_id,
name='aaa,bbb,foo',
geom=WKTElement('POINT(6 46)', 21781)
)
engine.connect().execute(ins).inserted_primary_key[0]
layer = LayerV1()
layer.id = id
layer.geo_table = tablename
layer.public = public
layer.interface = [self.main]
if exclude_properties:
layer.exclude_properties = 'name'
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
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, LayerWMTS, Dimension
ogc_server, _ = create_default_ogcserver()
main = Interface(name=u"main")
layer_wms_1 = LayerWMS(name=u"__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=u"__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=u"__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=u"__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=u"__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_wmts = LayerWMTS(name=u"__test_layer_wmts", public=True)
layer_wmts.interfaces = [main]
Dimension("B", "b", layer_wmts)
layer_group_1 = LayerGroup(name=u"__test_layer_group_1")
layer_group_1.children = [layer_wms_1, layer_wmts]
layer_group_2 = LayerGroup(name=u"__test_layer_group_2")
layer_group_2.children = [layer_wms_1, layer_wms_2]
layer_group_3 = LayerGroup(name=u"__test_layer_group_3")
layer_group_3.children = [layer_wms_1, layer_wms_3]
layer_group_4 = LayerGroup(name=u"__test_layer_group_4")
layer_group_4.children = [layer_wms_1, layer_wms_4]
layer_group_5 = LayerGroup(name=u"__test_layer_group_5")
layer_group_5.children = [layer_wms_1, layer_wms_5]
layer_group_6 = LayerGroup(name=u"__test_layer_group_6")
layer_group_6.children = [layer_wms_3]
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_6,
]
DBSession.add(theme)
transaction.commit()
def _create_layer(self, exclude_properties=False, metadatas=None, geom_type=False):
""" This function is central for this test class. It creates
a layer with two features, and associates a restriction area
to it. """
import transaction
from sqlalchemy import Column, Table, types, ForeignKey
from sqlalchemy.ext.declarative import declarative_base
from geoalchemy2 import Geometry
from c2cgeoportal.models import DBSession, RestrictionArea, LayerWMS
self.__class__._table_index += 1
id = self.__class__._table_index
engine = DBSession.c2c_rw_bind
connection = engine.connect()
if not self.metadata:
self.metadata = declarative_base(bind=engine).metadata
tablename = "geo_table_{0:d}".format(id)
schemaname = "geodata"
table1 = Table(
"{0!s}_child".format(tablename), self.metadata,
Column("id", types.Integer, primary_key=True),
Column("name", types.Unicode),
schema=schemaname
)
self._tables.append(table1)
table2 = Table(
tablename, self.metadata,
Column("id", types.Integer, primary_key=True),
Column("child_id", types.Integer,
ForeignKey("{0!s}.{1!s}_child.id".format(schemaname, tablename))),
Column("name", types.Unicode, nullable=False),
Column("deleted", types.Boolean),
Column("last_update_user", types.Unicode),
Column("last_update_date", types.DateTime),
Column("date", types.Date),
Column("start_time", types.Time),
# Column("interval", Interval()),
Column("short_name1", types.String, nullable=True),
Column("short_name2", types.String(50), nullable=True),
Column("short_number", types.Integer, nullable=True),
Column("double_number", types.Float(precision=4)),
Column("large_binary", types.LargeBinary(length=60), nullable=True),
Column("value", types.Enum("one", "two", "three", name="an_enum_value")),
Column("numeric", types.Numeric(precision=5, scale=2), nullable=True),
Column("numeric2", types.Numeric(), nullable=True),
schema=schemaname
)
if geom_type:
table2.append_column(
Column("geom", Geometry("POINT", srid=21781))
)
else:
table2.append_column(
Column("geom", Geometry(srid=21781))
)
self._tables.append(table2)
table2.drop(checkfirst=True)
table1.drop(checkfirst=True)
table1.create()
table2.create()
ins = table1.insert().values(name="c1é")
connection.execute(ins).inserted_primary_key[0]
ins = table1.insert().values(name="c2é")
connection.execute(ins).inserted_primary_key[0]
layer = LayerWMS(name="test_WMS_1", public=True)
layer.layer = "test_wms"
layer.id = id
layer.geo_table = "{0!s}.{1!s}".format(schemaname, tablename)
layer.interfaces = [self.main]
layer.ogc_server = self.ogc_server
if exclude_properties:
layer.exclude_properties = "name"
if metadatas:
layer.metadatas = metadatas
DBSession.add(self.layer_group_1)
self.layer_group_1.children = self.layer_group_1.children + [layer]
DBSession.add(self.layer_group_1)
ra = RestrictionArea()
ra.name = "__test_ra"
ra.layers = [layer]
ra.roles = [self.role]
ra.readwrite = True
DBSession.add(ra)
transaction.commit()
self.layer_ids.append(id)
return id
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 setup_method(self, _):
# Always see the diff
# https://docs.python.org/2/library/unittest.html#unittest.TestCase.maxDiff
self.maxDiff = None
self._tables = []
functionality.FUNCTIONALITIES_TYPES = None
from c2cgeoportal.models import DBSession, User, Role, \
RestrictionArea, TreeItem, Theme, LayerGroup, Interface, LayerWMS
from sqlalchemy import Column, Table, types
from sqlalchemy.ext.declarative import declarative_base
from geoalchemy2 import Geometry
for o in DBSession.query(RestrictionArea).all():
DBSession.delete(o)
for o in DBSession.query(Role).all():
DBSession.delete(o)
for o in DBSession.query(User).all():
DBSession.delete(o)
for o in DBSession.query(TreeItem).all():
DBSession.delete(o)
ogcserver, ogcserver_external = create_default_ogcserver()
role1 = Role(name="__test_role1")
role1.id = 999
user1 = User(username="******", password="******", role=role1)
user1.email = "*****@*****.**"
role2 = Role(name="__test_role2", extent=WKTElement(
"POLYGON((1 2, 1 4, 3 4, 3 2, 1 2))", srid=21781
))
user2 = User(username="******", password="******", role=role2)
main = Interface(name="main")
engine = DBSession.c2c_rw_bind
engine.connect()
a_geo_table = Table(
"a_geo_table", declarative_base(bind=engine).metadata,
Column("id", types.Integer, primary_key=True),
Column("geom", Geometry("POINT", srid=21781)),
schema="geodata"
)
self._tables = [a_geo_table]
a_geo_table.drop(checkfirst=True)
a_geo_table.create()
private_layer = LayerWMS(name="__test_private_layer", public=False)
private_layer.layer = "__test_private_layer"
private_layer.geo_table = "geodata.a_geo_table"
private_layer.interfaces = [main]
private_layer.ogc_server = ogcserver
group = LayerGroup(name="__test_layer_group")
group.children = [private_layer]
theme = Theme(name="__test_theme")
theme.children = [group]
theme.interfaces = [main]
DBSession.add(RestrictionArea(
name="__test_ra1", description="", layers=[private_layer],
roles=[role1],
))
DBSession.add(RestrictionArea(
name="__test_ra2", description="", layers=[private_layer],
roles=[role2], readwrite=True,
))
DBSession.add_all([
user1, user2, role1, role2, theme, group, private_layer,
])
transaction.commit()
