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