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 tearDown(): # noqa
testing.tearDown()
from c2cgeoportal.models import DBSession, Shorturl
import transaction
DBSession.query(Shorturl).delete()
transaction.commit()
def teardown_method(self, _):
testing.tearDown()
from c2cgeoportal.models import DBSession, Shorturl
import transaction
DBSession.query(Shorturl).delete()
transaction.commit()
def tearDown(self): # noqa
testing.tearDown()
from c2cgeoportal.models import DBSession, Shorturl
import transaction
DBSession.query(Shorturl).delete()
transaction.commit()
def teardown_method(self, _):
from c2cgeoportal.models import User, DBSession
DBSession.query(User).filter(User.username == "__test_user1").delete()
transaction.commit()
pyramid.security.remember = None
pyramid.security.remember = self.old_remember
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 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 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 teardown_method(self, _):
import transaction
from c2cgeoportal.models import DBSession, User, Role
transaction.commit()
DBSession.query(User).filter_by(username="******").delete()
DBSession.query(Role).filter_by(name="__test_role").delete()
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 _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 tearDown(self): # noqa
from c2cgeoportal.models import User, Role, LayerV1, RestrictionArea, \
Interface, DBSession, OGCServer
DBSession.query(User).filter(User.username == "__test_user1").delete()
ra = DBSession.query(RestrictionArea).filter(
RestrictionArea.name == "__test_ra1"
).one()
ra.roles = []
ra.layers = []
DBSession.delete(ra)
r = DBSession.query(Role).filter(Role.name == "__test_role1").one()
DBSession.delete(r)
for layer in DBSession.query(LayerV1).filter(
LayerV1.name.in_(["testpoint_group", "testpoint_protected_2"])
).all():
DBSession.delete(layer)
DBSession.query(Interface).filter(
Interface.name == "main"
).delete()
DBSession.query(OGCServer).delete()
transaction.commit()
def tearDown(self):
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 test_web_client_functionalities(self):
from pyramid.testing import DummyRequest
from c2cgeoportal.models import DBSession, User
from c2cgeoportal.tests.functional import mapserv_url
from c2cgeoportal.views.entry import Entry
request = DummyRequest()
request.static_url = lambda url: 'http://example.com/dummy/static/url'
request.route_url = lambda url: mapserv_url
request.user = None
request1 = DummyRequest()
request1.static_url = lambda url: 'http://example.com/dummy/static/url'
request1.route_url = lambda url: mapserv_url
request1.user = DBSession.query(User).filter(
User.username == '__test_user1').one()
request2 = DummyRequest()
request2.static_url = lambda url: 'http://example.com/dummy/static/url'
request2.route_url = lambda url: mapserv_url
request2.user = DBSession.query(User).filter(
User.username == '__test_user2').one()
settings = {
'functionalities': {
'anonymous': {
"__test_s": "anonymous",
"__test_a": ["a1", "a2"]
},
'registered': {
"__test_s": "registered",
"__test_a": ["r1", "r2"]
},
'available_in_templates': ['__test_s', '__test_a'],
},
'mapserv_url': mapserv_url,
}
request.registry.settings = settings
request1.registry.settings = settings
request2.registry.settings = settings
annon = Entry(request)._getVars()
u1 = Entry(request1)._getVars()
u2 = Entry(request2)._getVars()
self.assertEquals(annon['functionality'], {
"__test_s": ["anonymous"],
"__test_a": ["a1", "a2"]
})
self.assertEquals(u1['functionality'], {
"__test_s": ["registered"],
"__test_a": ["r1", "r2"]
})
self.assertEquals(u2['functionality'], {
"__test_s": ["db"],
"__test_a": ["db1", "db2"]
})
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 teardown_method(self, _):
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()
PointTest.__table__.drop(bind=DBSession.bind, checkfirst=True)
def get_ogcserver_byname(self, name):
try:
result = DBSession.query(OGCServer).filter(
OGCServer.name == name).one()
DBSession.expunge(result)
return result
except NoResultFound: # pragma nocover
log.error("OGSServer '{}' does not exists (existing: {}).".format(
name,
",".join([t[0]
for t in DBSession.query(OGCServer.name).all()])))
raise
def teardown_method(self, _):
testing.tearDown()
from c2cgeoportal.models import DBSession, TreeItem, Interface, Metadata
for t in DBSession.query(Metadata).all():
DBSession.delete(t)
for item in DBSession.query(TreeItem).all():
DBSession.delete(item)
DBSession.query(Interface).filter(Interface.name == "desktop").delete()
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 test_web_client_functionalities(self):
from c2cgeoportal.models import DBSession, User
from tests.functional import create_dummy_request
from c2cgeoportal.views.entry import Entry
request = create_dummy_request()
request.static_url = lambda url: "http://example.com/dummy/static/url"
request1 = create_dummy_request()
request1.static_url = lambda url: "http://example.com/dummy/static/url"
request1.user = DBSession.query(User).filter(
User.username == "__test_user1").one()
request2 = create_dummy_request()
request2.static_url = lambda url: "http://example.com/dummy/static/url"
request2.user = DBSession.query(User).filter(
User.username == "__test_user2").one()
settings = {
"functionalities": {
"anonymous": {
"__test_s": "anonymous",
"__test_a": ["a1", "a2"]
},
"registered": {
"__test_s": "registered",
"__test_a": ["r1", "r2"]
},
"available_in_templates": ["__test_s", "__test_a"],
},
"admin_interface": {
"available_functionalities": ["__test_a", "__test_s"]
},
}
functionality.FUNCTIONALITIES_TYPES = None
request.registry.settings.update(settings)
request1.registry.settings.update(settings)
request2.registry.settings.update(settings)
annon = Entry(request).get_cgxp_viewer_vars()
u1 = Entry(request1).get_cgxp_viewer_vars()
u2 = Entry(request2).get_cgxp_viewer_vars()
self.assertEqual(annon["functionality"], {
"__test_s": ["anonymous"],
"__test_a": ["a1", "a2"]
})
self.assertEqual(u1["functionality"], {
"__test_s": ["registered"],
"__test_a": ["r1", "r2"]
})
self.assertEqual(u2["functionality"], {
"__test_s": ["db"],
"__test_a": ["db1", "db2"]
})
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 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 tearDown(self): # noqa
testing.tearDown()
from c2cgeoportal.models import DBSession, LayerV1, \
Theme, LayerGroup
for t in DBSession.query(Theme).filter(Theme.name == "__test_theme").all():
DBSession.delete(t)
DBSession.query(LayerGroup).delete()
for layer in DBSession.query(LayerV1).all():
DBSession.delete(layer) # pragma: no cover
transaction.commit()
def tearDown(self):
testing.tearDown()
from c2cgeoportal.models import DBSession, Layer, \
Theme, LayerGroup, Role
for t in DBSession.query(Theme).filter(Theme.name == '__test_theme').all():
DBSession.delete(t)
for layergroup in DBSession.query(LayerGroup).all():
DBSession.delete(layergroup) # pragma: nocover
for layer in DBSession.query(Layer).all():
DBSession.delete(layer) # pragma: nocover
transaction.commit()
def tearDown(self): # noqa
import transaction
from c2cgeoportal.models import DBSession, Role, User, \
TreeItem, RestrictionArea, Interface
transaction.commit()
for treeitem in DBSession.query(TreeItem).all():
DBSession.delete(treeitem)
DBSession.query(User).filter(
User.username == u"__test_user"
).delete()
r = DBSession.query(Role).filter(
Role.name == u"__test_role"
).one()
r.restrictionareas = []
DBSession.delete(r)
DBSession.query(RestrictionArea).filter(
RestrictionArea.name == u"__test_ra"
).delete()
DBSession.query(Interface).filter(
Interface.name == u"main"
).delete()
if self._tables is not None:
for table in self._tables[::-1]:
table.drop()
transaction.commit()
def tearDown(self):
testing.tearDown()
from c2cgeoportal.models import DBSession, Layer, \
Theme, LayerGroup
for t in DBSession.query(Theme).all():
DBSession.delete(t)
for layergroup in DBSession.query(LayerGroup).all():
DBSession.delete(layergroup) # pragma: nocover
for layer in DBSession.query(Layer).all():
DBSession.delete(layer) # pragma: nocover
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 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
user.sn = None
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]
else:
user.sn = user.mail
if 'isMymapsAdmin' in result[0][1]:
user.is_admin =\
"TRUE" == (result[0][1]['isMymapsAdmin'][0]).upper()
if 'roleMymaps' in result[0][1]:
user.mymaps_role = int(result[0][1]['roleMymaps'][0])
if 'roleOGC' in result[0][1]:
user.ogc_role = result[0][1]['roleOGC'][0]
try:
user.role = DBSession.query(Role).filter_by(id=roletheme).one()
except Exception as e:
user.role = DBSession.query(Role).filter_by(id=0).one()
log.exception(e)
user.functionalities = []
return user
def tearDown(): # noqa
testing.tearDown()
from c2cgeoportal.models import DBSession, Layer, Theme, LayerGroup, Interface, Dimension, OGCServer
DBSession.query(Dimension).delete()
for l in DBSession.query(Layer).all():
DBSession.delete(l)
DBSession.query(LayerGroup).delete()
for t in DBSession.query(Theme).all():
DBSession.delete(t)
DBSession.query(Interface).filter(Interface.name == "main").delete()
DBSession.query(OGCServer).delete()
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 themes_errors(self):
from c2cgeoportal.models import DBSession, Interface
settings = self.settings.get("themes", {})
url = self.request.route_url("themes")
h = Http()
default_params = settings.get("default", {}).get("params", {})
results = []
for interface, in DBSession.query(Interface.name).all():
params = {}
params.update(default_params)
params.update(settings.get(interface, {}).get("params", {}))
params["interface"] = interface
interface_url = add_url_params(url, params)
interface_url, headers = build_url("Check the theme",
interface_url, self.request)
resp, content = h.request(interface_url, headers=headers)
if resp.status != httplib.OK:
self.set_status(resp.status, resp.reason)
results.append("{}: {}".format(interface, content))
result = loads(content)
if len(result["errors"]) != 0:
self.set_status(500, "Theme with error")
results.append("{}: Theme with error\n{}".format(
Interface.name, "\n".join(result["errors"])))
return self.make_response("OK" if len(results) ==
0 else urllib.unquote("\n\n".join(results)))
def get_user_from_request(request):
""" Return the User object for the request.
Return ``None`` if:
* user is anonymous
* it does not exist in the database
* the referer is invalid
"""
from c2cgeoportal.models import DBSession, User
# disable the referer check for the admin interface
if not (
request.path_info_peek() == "admin" and request.referer is None or
_is_valid_referer(request.referer, settings)
):
if request.referer is not None:
log.warning("Invalid referer for %s: %s", request.path_qs,
repr(request.referer))
return None
if not hasattr(request, "_user"):
request._user = None
username = request.authenticated_userid
if username is not None:
# We know we will need the role object of the
# user so we use joined loading
request._user = DBSession.query(User) \
.filter_by(username=username) \
.first()
return request._user
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 read_one(self):
set_common_headers(self.request, "layers", NO_CACHE, add_cors=True)
layer = self._get_layer_for_request()
protocol = self._get_protocol_for_layer(layer)
feature_id = self.request.matchdict.get("feature_id", None)
feature = protocol.read(self.request, id=feature_id)
if not isinstance(feature, Feature):
return feature
if layer.public:
return feature
if self.request.user is None:
raise HTTPForbidden()
geom = feature.geometry
if not geom or isinstance(geom, geojson.geometry.Default): # pragma: no cover
return feature
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(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()
return feature
def main(): # pragma: nocover
env = bootstrap("development.ini")
from c2cgeoportal.models import DBSession, TreeItem
package = env["registry"].settings["package"]
directory = "%s/locale/" % package
destination = path.join(directory, "%s-db.pot" % package)
w = codecs.open(destination, "wt", encoding="utf-8")
w.write(
u"""#, fuzzy
msgid ""
msgstr ""
"MIME-Version: 1.0\\n"
"Content-Type: text/plain; charset=utf-8\\n"
"Content-Transfer-Encoding: 8bit\\n"
"""
)
treeitems = DBSession.query(TreeItem.item_type, TreeItem.id, TreeItem.name)
for type, id, name in treeitems:
w.write(
u"""#: %(type)s.%(id)s
msgid "%(name)s"
msgstr ""
"""
% {"type": type, "id": id, "name": name}
)
print("DB Pot file updated: %s" % destination)
def _create_getcap_request(self, username=None, additional_settings={}):
from c2cgeoportal.models import DBSession, User
request = create_dummy_request(additional_settings)
request.user = None if username is None else \
DBSession.query(User).filter_by(username=username).one()
return request
def download_measurement(self):
if self.request.user is None and self.request.referer is None:
return HTTPUnauthorized()
townname = self.request.params.get("dirName", None)
filename = self.request.params.get("filename", None)
if filename is None or townname is None:
return HTTPBadRequest("parameters are missing")
pf = geoportailv3.PF.PF()
if not pf._is_download_authorized(
townname, self.request.user, self.request.referer):
return HTTPUnauthorized()
cur_record = DBSession.query(LuxMeasurementDirectory).\
filter(LuxMeasurementDirectory.name == townname).first()
if cur_record is None:
return HTTPBadRequest("Invalid Town name")
measurement_filepath = "%s/%s" % (cur_record.path, filename)
f = open(measurement_filepath, 'r')
parcel = self.request.params.get("parcel", "UNKNOWN")
self._log_download_measurement_stats(filename, townname, parcel)
headers = {"Content-Type": "application/pdf",
"Content-Disposition": "attachment; filename=\"%s\""
% (str(filename))}
return Response(f.read(), headers=headers)
def download_generic(self):
id = self.request.params.get('id', None)
filename = self.request.params.get('filename', None)
if id is None or filename is None:
return HTTPBadRequest()
entry = DBSession.query(LuxDownloadUrl).filter(
LuxDownloadUrl.id == id).first()
if entry is not None:
if entry.protected and self.request.user is None:
return HTTPUnauthorized()
url = entry.url + filename
try:
data = urllib2.urlopen(url, None, 1800)
except Exception as e:
log.exception(e)
data = None
log.debug(url)
mimetypes.init()
type = "application/octet-stream"
mimetype = mimetypes.guess_type(url)
if mimetype[0] is not None:
type = mimetype[0]
headers = {"Content-Type": type,
"Content-Disposition": "attachment; filename=\""
+ str(filename) + "\""}
if data is not None:
return Response(data.read(), headers=headers)
return HTTPBadRequest()
def preview_measurement(self):
towncode = self.request.params.get("code", None)
filename = self.request.params.get("filename", None)
cur_record = DBSession.query(LuxMeasurementDirectory).\
filter(LuxMeasurementDirectory.town_code == int(towncode)).first()
if cur_record is None:
return HTTPBadRequest("Invalid Town name")
measurement_filepath = "%s/%s" % (cur_record.path, filename)
input1 = PdfFileReader(open(measurement_filepath, 'rb'))
factor = 1.5
page0 = input1.getPage(0)
width = int(int(page0.mediaBox[2]) / factor)
height = int(int(page0.mediaBox[3]) / factor)
(fd, tempfilename) = tempfile.mkstemp(".png")
try:
subprocess.call(["/usr/bin/convert", "-sample",
str(width) + "x" + str(height),
measurement_filepath, tempfilename])
tfile = open(tempfilename, "r")
data = tfile.read()
finally:
os.close(fd)
os.remove(tempfilename)
headers = {"Content-Type": "image/png"}
return Response(data, headers=headers)
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 _create_getcap_request(username=None):
from c2cgeoportal.models import DBSession, User
request = create_dummy_request()
request.user = None if username is None else \
DBSession.query(User).filter_by(username=username).one()
return request
def _create_getcap_request(self, username=None, additional_settings={}):
from c2cgeoportal.models import DBSession, User
request = create_dummy_request(additional_settings)
request.user = None if username is None else \
DBSession.query(User).filter_by(username=username).one()
return request
def themes_errors(self):
from c2cgeoportal.models import DBSession, Interface
settings = self.settings.get("themes", {})
url = self.request.route_url("themes")
h = Http()
default_params = settings.get("default", {}).get("params", {})
for (interface,) in DBSession.query(Interface.name).all():
params = {}
params.update(default_params)
params.update(settings.get(interface, {}).get("params", {}))
params["interface"] = interface
interface_url = add_url_params(url, params)
interface_url, headers = build_url("Check the theme", interface_url, self.request)
resp, content = h.request(interface_url, headers=headers)
if resp.status != httplib.OK:
self.set_status(resp.status, resp.reason)
return self.make_response(content)
result = loads(content)
if len(result["errors"]) != 0:
self.set_status(500, "Theme with error")
return self.make_response(
"Theme with error for interface '%s'\n%s" % (Interface.name, "\n".join(result["errors"]))
)
return self.make_response("OK")
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 _proto_read(self, layer):
""" Read features for the layer based on the self.request. """
proto = self._get_protocol_for_layer(layer)
if layer.public:
return proto.read(self.request)
user = self.request.user
if user is None:
raise HTTPForbidden()
cls = proto.mapped_class
geom_attr = proto.geom_attr
ras = DBSession.query(RestrictionArea.area, RestrictionArea.area.ST_SRID())
ras = ras.join(RestrictionArea.roles)
ras = ras.join(RestrictionArea.layers)
ras = ras.filter(Role.id == user.role.id)
ras = ras.filter(Layer.id == layer.id)
collect_ra = []
use_srid = -1
for ra, srid in ras.all():
if ra is None:
return proto.read(self.request)
else:
use_srid = srid
collect_ra.append(to_shape(ra))
if len(collect_ra) == 0: # pragma: no cover
raise HTTPForbidden()
filter1_ = create_filter(self.request, cls, geom_attr)
ra = cascaded_union(collect_ra)
filter2_ = ga_func.ST_Contains(
from_shape(ra, use_srid),
getattr(cls, geom_attr)
)
filter_ = filter2_ if filter1_ is None else and_(filter1_, filter2_)
return proto.read(self.request, filter=filter_)
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 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 test_group_update(self):
from c2cgeoportal.models import DBSession, LayerGroup
layer_group_3 = DBSession.query(LayerGroup).filter(LayerGroup.name == u"__test_layer_group_3").one()
layer_group_3.children = layer_group_3.children[:-1]
transaction.commit()
entry = self._create_entry_obj(params={
"version": "2",
"group": "__test_layer_group_3",
"catalogue": "true",
})
themes = entry.themes()
self.assertEquals(self._get_filtered_errors(themes), set())
self.assertEquals(
self._only_name(themes["group"]),
{
"name": u"__test_layer_group_3",
# order is important
"children": [{
"name": u"__test_layer_wmts"
}, {
"name": u"__test_layer_internal_wms"
}]
}
)
def test_group_update(self):
from c2cgeoportal.models import DBSession, LayerGroup
layer_group_3 = DBSession.query(LayerGroup).filter(
LayerGroup.name == "__test_layer_group_3").one()
layer_group_3.children = layer_group_3.children[:-1]
transaction.commit()
entry = self._create_entry_obj(params={
"version": "2",
"group": "__test_layer_group_3",
"catalogue": "true",
})
themes = entry.themes()
self.assertEqual(self._get_filtered_errors(themes), set())
self.assertEqual(
self._only_name(themes["group"]),
{
"name":
"__test_layer_group_3",
# order is important
"children": [{
"name": "__test_layer_wmts"
}, {
"name": "__test_layer_internal_wms"
}]
})
def read_one(self):
set_common_headers(self.request, "layers", NO_CACHE)
layer = self._get_layer_for_request()
protocol = self._get_protocol_for_layer(layer)
feature_id = self.request.matchdict.get("feature_id", None)
feature = protocol.read(self.request, id=feature_id)
if not isinstance(feature, Feature):
return feature
if layer.public:
return feature
if self.request.user is None:
raise HTTPForbidden()
geom = feature.geometry
if not geom or isinstance(geom, geojson.geometry.Default): # pragma: no cover
return feature
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(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()
return feature
def read_one(request):
layer = _get_layer_for_request(request)
protocol = _get_protocol_for_layer(layer)
feature_id = request.matchdict.get('feature_id', None)
feature = protocol.read(request, id=feature_id)
if not isinstance(feature, Feature):
return feature
if layer.public:
return feature
if request.user is None:
raise HTTPNotFound()
geom = feature.geometry
if not geom or isinstance(geom, geojson.geometry.Default): # pragma: no cover
return feature # pragma: no cover
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(Role.id == request.user.role.id)
allowed = allowed.filter(Layer.id == layer.id).scalar()
if not allowed:
raise HTTPNotFound()
return feature
def get_user_from_request(request):
""" Return the User object for the request.
Return ``None`` if:
* user is anonymous
* it does not exist in the database
* the referer is invalid
"""
from c2cgeoportal.models import DBSession, User
# disable the referer check for the admin interface
if not (request.path_info_peek() == "admin" and request.referer is None
or _is_valid_referer(request.referer, settings)):
if request.referer is not None:
log.warning("Invalid referer for %s: %s", request.path_qs,
repr(request.referer))
return None
if not hasattr(request, "_user"):
request._user = None
username = request.authenticated_userid
if username is not None:
# We know we will need the role object of the
# user so we use joined loading
request._user = DBSession.query(User) \
.filter_by(username=username) \
.first()
return request._user
def _proto_read(self, layer):
""" Read features for the layer based on the self.request. """
proto = self._get_protocol_for_layer(layer)
if layer.public:
return proto.read(self.request)
user = self.request.user
if user is None:
raise HTTPForbidden()
cls = proto.mapped_class
geom_attr = proto.geom_attr
ras = DBSession.query(RestrictionArea.area, RestrictionArea.area.ST_SRID())
ras = ras.join(RestrictionArea.roles)
ras = ras.join(RestrictionArea.layers)
ras = ras.filter(Role.id == user.role.id)
ras = ras.filter(Layer.id == layer.id)
collect_ra = []
use_srid = -1
for ra, srid in ras.all():
if ra is None:
return proto.read(self.request)
else:
use_srid = srid
collect_ra.append(to_shape(ra))
if len(collect_ra) == 0: # pragma: no cover
raise HTTPForbidden()
filter1_ = create_filter(self.request, cls, geom_attr)
ra = cascaded_union(collect_ra)
filter2_ = ga_func.ST_Contains(
from_shape(ra, use_srid),
getattr(cls, geom_attr)
)
filter_ = filter2_ if filter1_ is None else and_(filter1_, filter2_)
return proto.read(self.request, filter=filter_)
def _import_layer_wmts(self, layer, messages):
from c2cgeoportal.models import DBSession, OGCServer
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:
DBSession.query(OGCServer).filter(name=server[0]).one()
self._import_layer_attributes(
server[0].url_wfs or server[0].url, wms_layer,
layer.item_type, layer.name, layer.id, messages)
except NoResultFound:
print(
"Error: the OGC server '{}' from the WMTS layer '{}' does not exist."
.format(server[0], layer.name))
