def main(global_config, **settings): """Return a Pyramid WSGI application.""" settings.setdefault('mako.directories', 'porygo_nz:templates') engine = sqlalchemy.engine_from_config(settings, 'sqlalchemy.') porygo_nz.db.DBSession.configure(bind=engine) config = pyramid.config.Configurator( settings=settings, root_factory=porygo_nz.resources.get_root) config.include('pyramid_mako') config.add_static_view('static', 'porygo_nz:static') config.add_request_method(porygo_nz.db.request_session, name='db', reify=True) config.add_request_method(porygo_nz.request_methods.show_abilities, reify=True) config.add_request_method(porygo_nz.request_methods.show_hidden_abilities, reify=True) config.scan() return config.make_wsgi_app()
def create_app(_=None, **settings): """Configure and return the WSGI app.""" config = pyramid.config.Configurator(settings=load_settings(settings)) config.include("pyramid_jinja2") config.include("via.views") config.include("h_pyramid_sentry") # Configure Pyramid so we can generate static URLs static_path = resource_filename("via", "static") cache_buster = PathCacheBuster(static_path) print(f"Cache buster salt: {cache_buster.salt}") config.add_static_view(name="static", path="via:static") config.add_cache_buster("via:static", cachebust=cache_buster) app = WhiteNoise( config.make_wsgi_app(), index_file=True, # Config for serving files at static/<salt>/path which are marked # as immutable root=static_path, prefix=cache_buster.immutable_path, immutable_file_test=cache_buster.get_immutable_file_test(), ) app.add_files( # Config for serving files at / which are marked as mutable. This is # for robots.txt and / -> index.html root=resource_filename("via", "static"), prefix="/", ) return app
def main(global_config, **settings): config = pyramid.config.Configurator(settings=settings) config.add_static_view('static', os.path.join(here, 'static')) config.add_route('home', '/') config.add_route('away_mode', '/away_mode') config.add_route('status', '/status') config.scan() app = config.make_wsgi_app() return app
def _make_application(*, geoip, socket): """Construct a Pyramid WSGI application. This creates a central Pyramid configurator then adds all routes, views and Jinja2 configuration to it. :mod:`pyramid_jinja2` is included into the configuration. The search path for Jinja2 is set to the ``templates/`` directory. The Jinja2 syntax is modified so that it uses square brackets instead of curly ones. E.g. ``{{foo}}`` becomes ``[[foo]]``. This applies to Jinja2 statements as well as comments. A route and view is added for ``/`` which serves the Angular application. A default 'not found' view is also added which also serves the Angular application. This is so that the Angular ``$location`` service can use *HTML5 mode* routing. Because of this there is no guarantee that a matched route will be set for the current request inside the entry point template. E.g. you can't use ``request.current_route_url``. Static views are added for the ``external``, ``scripts``, ``styles``, ``images``, ``templates`` and ``data`` directories. These are all served directly from the route. E.g. templates are served from ``/templates/``. The configuration for Steam OpenID authentication and the location service is added. :param pathlib.Path geoip: the path to the GeoIP database to use for the location service. :param str socket: the websocket URL the UI should connect to. :return: a WSGI application. """ config = pyramid.config.Configurator(settings={ "pyramid.reload_templates": True, }) config.include("pyramid_jinja2") config.add_jinja2_search_path(__name__ + ":templates/") config.add_route("main", "/") config.add_view(route_name="main", renderer="main.jinja2") config.add_notfound_view(_404, renderer="main.jinja2") for static in ["external", "scripts", "styles", "images", "templates", "data"]: config.add_static_view(static, "{}:{}/".format(__name__, static)) _configure_authentication(config) _configure_location(config, geoip) config.commit() jinja2_env = config.get_jinja2_environment() jinja2_env.block_start_string = "[%" jinja2_env.block_end_string = "%]" jinja2_env.variable_start_string = "[[" jinja2_env.variable_end_string = "]]" jinja2_env.comment_start_string = "[#" jinja2_env.comment_end_string = "#]" jinja2_env.globals["socket"] = socket return config.make_wsgi_app()
def app(): """Configure and return the WSGI app.""" config = pyramid.config.Configurator(settings=settings()) config.add_static_view(name="static", path="static") config.include("pyramid_jinja2") config.registry.settings["jinja2.filters"] = { "static_path": "pyramid_jinja2.filters:static_path_filter", "static_url": "pyramid_jinja2.filters:static_url_filter" } config.include("bouncer.views") config.include("bouncer.sentry") return config.make_wsgi_app()
def main(global_config, **settings): """ This function returns a Pyramid WSGI application. """ model.setup() session_factory = session_factory_from_settings(settings) config = Configurator( settings=settings, root_factory=security.RootFactory, authentication_policy=AuthTktAuthenticationPolicy( settings["cookie_secret"], callback=security.group_finder), authorization_policy=ACLAuthorizationPolicy()) config.set_request_factory(security.RequestWithUserAttribute) config.set_session_factory(session_factory) config.add_static_view("static", "scrobble:static") config.add_route("home", "/", view="scrobble.views.list_users", view_renderer="list_users.mako") config.add_route("new_account", "/new_account", view="scrobble.login.new_account", view_renderer="new_account.mako") config.add_route("login", "/login", view="scrobble.login.login") config.add_route("logout", "/logout", view="scrobble.login.logout", view_renderer="logout.mako") config.add_route("list_users", "/users", view="scrobble.views.list_users", view_renderer="list_users.mako") config.add_route("user_home", "/user/{user}", view="scrobble.views.user_home", view_renderer="user_home.mako") config.add_route("simulate_listen", "/simulate_listen", view="scrobble.views.simulate_listen", view_renderer="simulate.mako") config.add_route("api_login", "api/login") config.add_route("api_whoami", "api/whoami") config.add_route("api_track_listen", "api/track_listen") config.add_route("api_follow_user", "api/follow_user") config.add_route("api_unfollow_user", "api/unfollow_user") config.scan() return config.make_wsgi_app()
def _configure_routes(config): config.add_static_view(name='static', path='nerffinder:static') config.add_route('root', '/') config.add_view(nerffinder.views.map.map_view, route_name='root', renderer='nerffinder:templates/splash.mak') config.add_route('map', '/map') config.add_view(nerffinder.views.map.map_view, route_name='map', renderer='nerffinder:templates/map.mak') config.add_route('chart', '/chart') config.add_view(nerffinder.views.chart.chart_view, route_name='chart', renderer='nerffinder:templates/chart.mak') config.add_route('precache', '/precache') config.add_view(nerffinder.views.precache.precache_view, route_name='precache', renderer='nerffinder:templates/precache.mak') config.add_route('api_gear_categories', '/api/v1/gear/categories/') config.add_view(nerffinder.api.v1.gear.categories_view, route_name='api_gear_categories', renderer='json') config.add_route('api_gear_locations', '/api/v1/gear/locations/') config.add_view(nerffinder.api.v1.gear.locations_view, route_name='api_gear_locations', renderer='json') config.add_route('api_gear_details', '/api/v1/gear/details/{id}/') config.add_view(nerffinder.api.v1.gear.details_view, route_name='api_gear_details', renderer='json')
def create_app(_=None, **settings): """Configure and return the WSGI app.""" config = pyramid.config.Configurator(settings=load_settings(settings)) config.include("pyramid_exclog") config.include("pyramid_jinja2") config.include("pyramid_services") config.include("h_pyramid_sentry") config.include("via.views") config.include("via.services") # Configure Pyramid so we can generate static URLs static_path = str(importlib_resources.files("via") / "static") cache_buster = PathCacheBuster(static_path) print(f"Cache buster salt: {cache_buster.salt}") config.add_static_view(name="static", path="via:static") config.add_cache_buster("via:static", cachebust=cache_buster) # Make the CheckmateClient object available as request.checkmate. config.add_request_method(ViaCheckmateClient, reify=True, name="checkmate") config.add_tween("via.tweens.robots_tween_factory") # Add this as near to the end of your config as possible: config.include("pyramid_sanity") app = WhiteNoise( config.make_wsgi_app(), index_file=True, # Config for serving files at static/<salt>/path which are marked # as immutable root=static_path, prefix=cache_buster.immutable_path, immutable_file_test=cache_buster.get_immutable_file_test(), ) app.add_files( # Config for serving files at / which are marked as mutable. This is # for / -> index.html root=static_path, prefix="/", ) return app
def getPyramidConfigurator(is_dev_server=False): """ Get a pre-configurated Pyramid WSGI application. """ # Configure and create the WSGI application. config = pyramid.config.Configurator(authentication_policy=CustomAuthPolicy()) # Configuration settings. settings = dict() if is_dev_server: settings['pyramid.reload_templates'] = True config.add_settings(settings) # Include additional pyramid modules. config.include('pyramid_jinja2') # Scan the code for view declarations. config.scan(local) # Setup the views. config.add_route('index', '/') config.add_route('view.create_user', pattern='/users/create') config.add_route('view.search_users', pattern='/users/search') config.add_route('view.display_user', pattern='/users/{user_uid}') config.add_route('view.display_battles', pattern='/battles') # Setup the APIs. config.add_route('api.create_user', pattern='/api/users') config.add_route('api.modify_user', pattern='/api/users/{user_uid}') config.add_route('api.create_battle_log', pattern='/api/battles') config.add_route('api.list_users', pattern='/api/list_users') # Add static views config.add_static_view("styles", "local:site/styles/") return config
def init_wsgi_app() -> pyramid.router.Router: config = pyramid.config.Configurator( settings={ 'pyramid.includes': [ 'pyramid_jinja2', 'pyramid_tm', ], 'pyramid.reload_templates': True, }) init_json_renderer(config) for name, path, method in [ ('index', "/", 'GET'), ('api_create_step', "/api/steps", 'POST'), ('api_get_step', "/api/steps/{step_id:\d+}", 'GET'), ('api_update_step', "/api/steps/{step_id:\d+}", 'PUT'), ]: config.add_route(name, path, request_method=method) config.scan() config.add_static_view('static', '../static', cache_max_age=1) config.commit() return config.make_wsgi_app()
def main(global_config, **settings): """ This function returns a Pyramid WSGI application. """ # Setup -------------------------------------------------------------------- # Db init_DBSession(settings) # Pyramid Global Settings config = pyramid.config.Configurator( settings=settings, root_factory=TraversalGlobalRootFactory) # , autocommit=True def assert_settings_keys(keys): for settings_key in key: assert config.registry.settings.get(settings_key) # Register Additional Includes --------------------------------------------- config.include( 'pyramid_mako' ) # The mako.directories value is updated in the scan for addons. We trigger the import here to include the correct folders. # Reload on template change - Dedicated from pserve #template_filenames = map(operator.attrgetter('absolute'), file_scan(config.registry.settings['mako.directories'])) #from pyramid.scripts.pserve import add_file_callback #add_file_callback(lambda: template_filenames) # Parse/Convert setting keys that have specified datatypes # Environment variables; capitalized and separated by underscores can override a settings key. # e.g. # export KARAKARA_TEMPLATE_TITLE=Test # can override 'karakara.template.title' for key in config.registry.settings.keys(): value = os.getenv( key.replace('.', '_').upper(), '' ) if config.registry.settings['karakara.server.mode'] != 'test' else '' value = value or config.registry.settings[key] config.registry.settings[key] = convert_str_with_type(value) # Session identity config.add_request_method(partial( session_identity, session_keys={'id', 'admin', 'faves', 'user'}), 'session_identity', reify=True) # Setup Cache Manager config in view setup_pyramid_cache_manager(config) # Setup Autoformat view processor setup_pyramid_autoformater(config) @post_view_dict_augmentation.register_pre_render_decorator() def add_paths_to_response_dict(request, response): response['paths'] = { 'context': pyramid.traversal.resource_path(request.context), 'queue': '', } try: queue_context = request.context.queue_context if queue_context: response['paths'].update( template_helpers.paths_for_queue(queue_context.id)) except AttributeError: pass # i18n config.add_translation_dirs( config.registry.settings['i18n.translation_dirs']) # Session Manager session_settings = extract_subkeys(config.registry.settings, 'session.') session_factory = SignedCookieSessionFactory(serializer=json_serializer, **session_settings) config.set_session_factory(session_factory) from .model.actions import last_track_db_update def _last_track_db_update(request): return last_track_db_update() # Track DB Version --------------------------------------------------------- config.add_request_method(_last_track_db_update, 'last_track_db_update', property=True, reify=True) # Cachebust etags ---------------------------------------------------------- # crude implementation; count the number of tags in db, if thats changed, the etags will invalidate if not config.registry.settings['server.etag.cache_buster']: config.registry.settings[ 'server.etag.cache_buster'] = 'last_update:{0}'.format( str(last_track_db_update())) # TODO: Where is this used? How is this related to karakara.tracks.version? # Global State ------------------------------------------------------------- config.registry.settings['karakara.tracks.version'] = random.randint( 0, 20000000) # Search Config ------------------------------------------------------------ import karakara.views.queue_search karakara.views.queue_search.search_config = read_json( config.registry.settings['karakara.search.view.config']) assert karakara.views.queue_search.search_config, 'search_config data required' # LogEvent ----------------------------------------------------------------- log_event_logger = logging.getLogger('json_log_event') def log_event(request, **data): """ It is expected that python's logging framework is used to output these events to the correct destination. Logstash can then read/process this log output for overview/stats """ event = data.get('event') try: event = request.matched_route.name except Exception: pass try: event = request.context.__name__ except Exception: pass data.update({ 'event': event, 'session_id': request.session.get('id'), 'ip': request.environ.get('REMOTE_ADDR'), 'timestamp': now(), }) log_event_logger.info(json_string(data)) config.add_request_method(log_event) # WebSocket ---------------------------------------------------------------- class NullAuthEchoServerManager(object): def recv(self, *args, **kwargs): pass socket_manager = NullAuthEchoServerManager() if config.registry.settings.get('karakara.websocket.port'): def authenticator(key): """Only admin authenticated keys can connect to the websocket""" cookie_name = config.registry.settings['session.cookie_name'] if cookie_name in key: cookie = key else: cookie = '{0}={1}'.format(cookie_name, key) request = pyramid.request.Request({'HTTP_COOKIE': cookie}) session_data = session_factory(request) return session_data and session_data.get('admin') def _int_or_none(setting_key): return int(config.registry.settings.get(setting_key) ) if config.registry.settings.get(setting_key) else None try: _socket_manager = AuthEchoServerManager( authenticator=authenticator, websocket_port=_int_or_none('karakara.websocket.port'), tcp_port=_int_or_none('karakara.tcp.port'), ) _socket_manager.start() socket_manager = _socket_manager except OSError: log.warn('Unable to setup websocket') def send_websocket_message(request, message): # TODO: This will have to be augmented with json and queue_id in future socket_manager.recv( message.encode('utf-8')) # TODO: ?um? new_line needed? config.add_request_method(send_websocket_message) #config.registry['socket_manager'] = socket_manager # Login Providers ---------------------------------------------------------- from .views.comunity_login import social_login social_login.user_store = ComunityUserStore() login_providers = config.registry.settings.get('login.provider.enabled') # Facebook if 'facebook' in login_providers: assert_settings_keys( ('login.facebook.appid', 'login.facebook.secret'), message= 'To use facebook as a login provider appid and secret must be provided' ) social_login.add_login_provider( FacebookLogin( appid=config.registry.settings.get('login.facebook.appid'), secret=config.registry.settings.get('login.facebook.secret'), permissions=config.registry.settings.get( 'login.facebook.permissions'), )) # Google if 'google' in login_providers: social_login.add_login_provider( GoogleLogin(client_secret_file=config.registry.settings.get( 'login.google.client_secret_file'), )) # Firefox Persona (Deprecated technology but a useful reference) #if 'persona' in login_providers: # social_login.add_login_provider(PersonaLogin( # site_url=config.registry.settings.get('server.url') # )) # No login provider if not login_providers and config.registry.settings.get( 'karakara.server.mode') != 'test': # Auto login if no service keys are provided social_login.add_login_provider(NullLoginProvider()) social_login.user_store = NullComunityUserStore() template_helpers.javascript_inline['comunity'] = social_login.html_includes # KaraKara request additions ----------------------------------------------- from unittest.mock import patch def call_sub_view(request, view_callable, acquire_cache_bucket_func): """ A wrapper for called view_callable's to allow subrequests to use correct cache_buckets """ if not hasattr(request, 'cache_bucket'): # FFS - don't ask questions ... just ... (sigh) ... patch can ONLY patch existing attributes setattr(request, 'cache_bucket', 'some placeholder s***e') _cache_bucket = acquire_cache_bucket_func(request) with patch.object(request, 'cache_bucket', _cache_bucket): assert request.cache_bucket == _cache_bucket return view_callable(request)['data'] config.add_request_method(call_sub_view) from .model_logic.queue_logic import QueueLogic config.add_request_method(QueueLogic, 'queue', reify=True) # Routes ------------------------------------------------------------------- def settings_path(key): path = os.path.join(os.getcwd(), config.registry.settings[key]) if not os.path.isdir(path): log.error('Unable to add_static_view {key}:{path}'.format( key=key, path=path)) #TODO: reaplce with formatstring return path # Static Routes config.add_static_view( name='ext', path=settings_path('static.externals')) # cache_max_age=3600 config.add_static_view( name='static', path=settings_path('static.assets')) # cache_max_age=3600 config.add_static_view(name='player', path=settings_path('static.player')) config.add_static_view(name='player2', path=settings_path('static.player2')) # AllanC - it's official ... static route setup and generation is a mess in pyramid #config.add_static_view(name=settings["static.media" ], path="karakara:media" ) config.add_static_view( name='files', path=config.registry.settings['static.processmedia2.config'] ['path_processed']) # View Routes config.add_route('inject_testdata', '/inject_testdata') # Upload extras ----- #config.add_static_view(name=settings['upload.route.uploaded'], path=settings['upload.path']) # the 'upload' route above always matchs first config.add_route('upload', '/upload{sep:/?}{name:.*}') # Events ------------------------------------------------------------------- config.add_subscriber(add_localizer_to_request, pyramid.events.NewRequest) config.add_subscriber(add_render_globals_to_template, pyramid.events.BeforeRender) # Tweens ------------------------------------------------------------------- if config.registry.settings.get( 'karakara.server.mode' ) == 'development' and config.registry.settings.get( 'karakara.server.postmortem'): config.add_tween('karakara.postmortem_tween_factory') # Return ------------------------------------------------------------------- config.scan(ignore='.tests') config.scan('calaldees.pyramid_helpers.views') return config.make_wsgi_app()
def includeme(config: pyramid.config.Configurator) -> None: """ This function returns a Pyramid WSGI application. """ settings = config.get_settings() config.include("c2cgeoportal_commons") if "available_locale_names" not in settings: settings["available_locale_names"] = available_locale_names() call_hook(settings, "after_settings", settings) get_user_from_request = create_get_user_from_request(settings) config.add_request_method(get_user_from_request, name="user", property=True) config.add_request_method(get_user_from_request, name="get_user") # Configure 'locale' dir as the translation dir for c2cgeoportal app config.add_translation_dirs("c2cgeoportal_geoportal:locale/") config.include("c2cwsgiutils.pyramid.includeme") health_check = HealthCheck(config) config.registry["health_check"] = health_check metrics_config = config.registry.settings["metrics"] if metrics_config["memory_maps_rss"]: add_provider(MemoryMapProvider("rss")) if metrics_config["memory_maps_size"]: add_provider(MemoryMapProvider("size")) if metrics_config["memory_cache"]: add_provider( MemoryCacheSizeProvider( metrics_config.get("memory_cache_all", False))) if metrics_config["raster_data"]: add_provider(RasterDataSizeProvider()) if metrics_config["total_python_object_memory"]: add_provider(TotalPythonObjectMemoryProvider()) # Initialise DBSessions init_dbsessions(settings, config, health_check) checker.init(config, health_check) check_collector.init(config, health_check) # dogpile.cache configuration if "cache" in settings: register_backend("c2cgeoportal.hybrid", "c2cgeoportal_geoportal.lib.caching", "HybridRedisBackend") register_backend("c2cgeoportal.hybridsentinel", "c2cgeoportal_geoportal.lib.caching", "HybridRedisSentinelBackend") for name, cache_config in settings["cache"].items(): caching.init_region(cache_config, name) @zope.event.classhandler.handler(InvalidateCacheEvent) def handle(event: InvalidateCacheEvent) -> None: # pylint: disable=unused-variable del event caching.invalidate_region() if caching.MEMORY_CACHE_DICT: caching.get_region("std").delete_multi( caching.MEMORY_CACHE_DICT.keys()) caching.MEMORY_CACHE_DICT.clear() # Register a tween to get back the cache buster path. if "cache_path" not in config.get_settings(): config.get_settings()["cache_path"] = ["static"] config.add_tween( "c2cgeoportal_geoportal.lib.cacheversion.CachebusterTween") config.add_tween("c2cgeoportal_geoportal.lib.headers.HeadersTween") # Bind the mako renderer to other file extensions add_mako_renderer(config, ".html") add_mako_renderer(config, ".js") # Add the "geojson" renderer config.add_renderer("geojson", GeoJSON()) # Add the "xsd" renderer config.add_renderer("xsd", XSD(include_foreign_keys=True)) # Add the set_user_validator directive, and set a default user validator config.add_directive("set_user_validator", set_user_validator) config.set_user_validator(default_user_validator) config.add_route("dynamic", "/dynamic.json", request_method="GET") # Add routes to the mapserver proxy config.add_route_predicate("mapserverproxy", MapserverproxyRoutePredicate) config.add_route( "mapserverproxy", "/mapserv_proxy", mapserverproxy=True, pregenerator=C2CPregenerator(role=True), request_method="GET", ) config.add_route( "mapserverproxy_post", "/mapserv_proxy", mapserverproxy=True, pregenerator=C2CPregenerator(role=True), request_method="POST", ) add_cors_route(config, "/mapserv_proxy", "mapserver") # Add route to the tinyows proxy config.add_route("tinyowsproxy", "/tinyows_proxy", pregenerator=C2CPregenerator(role=True)) # Add routes to the entry view class config.add_route("base", "/", static=True) config.add_route("loginform", "/login.html", request_method="GET") add_cors_route(config, "/login", "login") config.add_route("login", "/login", request_method="POST") add_cors_route(config, "/logout", "login") config.add_route("logout", "/logout", request_method="GET") add_cors_route(config, "/loginchangepassword", "login") config.add_route("change_password", "/loginchangepassword", request_method="POST") add_cors_route(config, "/loginresetpassword", "login") config.add_route("loginresetpassword", "/loginresetpassword", request_method="POST") add_cors_route(config, "/loginuser", "login") config.add_route("loginuser", "/loginuser", request_method="GET") config.add_route("testi18n", "/testi18n.html", request_method="GET") config.add_renderer(".map", AssetRendererFactory) config.add_renderer(".css", AssetRendererFactory) config.add_renderer(".ico", AssetRendererFactory) config.add_route("localejson", "/locale.json", request_method="GET") def add_static_route(name: str, attr: str, path: str, renderer: str) -> None: config.add_route(name, path, request_method="GET") config.add_view(Entry, attr=attr, route_name=name, renderer=renderer) add_static_route("favicon", "favicon", "/favicon.ico", "/etc/geomapfish/static/images/favicon.ico") add_static_route("robot.txt", "robot_txt", "/robot.txt", "/etc/geomapfish/static/robot.txt") add_static_route("apijs", "apijs", "/api.js", "/etc/static-ngeo/api.js") add_static_route("apijsmap", "apijsmap", "/api.js.map", "/etc/static-ngeo/api.js.map") add_static_route("apicss", "apicss", "/api.css", "/etc/static-ngeo/api.css") add_static_route("apihelp", "apihelp", "/apihelp/index.html", "/etc/geomapfish/static/apihelp/index.html") c2cgeoportal_geoportal.views.add_redirect(config, "apihelp_redirect", "/apihelp.html", "apihelp") config.add_route("themes", "/themes", request_method="GET", pregenerator=C2CPregenerator(role=True)) config.add_route("invalidate", "/invalidate", request_method="GET") # Print proxy routes config.add_route("printproxy", "/printproxy", request_method="HEAD") add_cors_route(config, "/printproxy/*all", "print") config.add_route( "printproxy_capabilities", "/printproxy/capabilities.json", request_method="GET", pregenerator=C2CPregenerator(role=True), ) config.add_route( "printproxy_report_create", "/printproxy/report.{format}", request_method="POST", header=JSON_CONTENT_TYPE, ) config.add_route("printproxy_status", "/printproxy/status/{ref}.json", request_method="GET") config.add_route("printproxy_cancel", "/printproxy/cancel/{ref}", request_method="DELETE") config.add_route("printproxy_report_get", "/printproxy/report/{ref}", request_method="GET") # Full-text search routes add_cors_route(config, "/search", "fulltextsearch") config.add_route("fulltextsearch", "/search", request_method="GET") # Access to raster data add_cors_route(config, "/raster", "raster") config.add_route("raster", "/raster", request_method="GET") add_cors_route(config, "/profile.json", "profile") config.add_route("profile.json", "/profile.json", request_method="POST") # Shortener add_cors_route(config, "/short/create", "shortener") config.add_route("shortener_create", "/short/create", request_method="POST") config.add_route("shortener_get", "/s/{ref}", request_method="GET") # Geometry processing config.add_route("difference", "/difference", request_method="POST") # PDF report tool config.add_route("pdfreport", "/pdfreport/{layername}/{ids}", request_method="GET") # Add routes for the "layers" web service add_cors_route(config, "/layers/*all", "layers") config.add_route("layers_count", "/layers/{layer_id:\\d+}/count", request_method="GET") config.add_route( "layers_metadata", "/layers/{layer_id:\\d+}/md.xsd", request_method="GET", pregenerator=C2CPregenerator(role=True), ) config.add_route("layers_read_many", "/layers/{layer_id:\\d+,?(\\d+,)*\\d*$}", request_method="GET") # supports URLs like /layers/1,2,3 config.add_route("layers_read_one", "/layers/{layer_id:\\d+}/{feature_id}", request_method="GET") config.add_route("layers_create", "/layers/{layer_id:\\d+}", request_method="POST", header=GEOJSON_CONTENT_TYPE) config.add_route( "layers_update", "/layers/{layer_id:\\d+}/{feature_id}", request_method="PUT", header=GEOJSON_CONTENT_TYPE, ) config.add_route("layers_delete", "/layers/{layer_id:\\d+}/{feature_id}", request_method="DELETE") config.add_route( "layers_enumerate_attribute_values", "/layers/{layer_name}/values/{field_name}", request_method="GET", pregenerator=C2CPregenerator(), ) # There is no view corresponding to that route, it is to be used from # mako templates to get the root of the "layers" web service config.add_route("layers_root", "/layers", request_method="HEAD") # Resource proxy (load external url, useful when loading non https content) config.add_route("resourceproxy", "/resourceproxy", request_method="GET") # Dev config.add_route("dev", "/dev/*path", request_method="GET") # Used memory in caches config.add_route("memory", "/memory", request_method="GET") # Scan view decorator for adding routes config.scan(ignore=[ "c2cgeoportal_geoportal.lib", "c2cgeoportal_geoportal.scaffolds", "c2cgeoportal_geoportal.scripts", ]) add_admin_interface(config) add_getitfixed(config) # Add the project static view with cache buster config.add_static_view( name="static", path="/etc/geomapfish/static", cache_max_age=int(config.get_settings()["default_max_age"]), ) config.add_cache_buster("/etc/geomapfish/static", version_cache_buster) # Add the project static view without cache buster config.add_static_view( name="static-ngeo", path="/etc/static-ngeo", cache_max_age=int(config.get_settings()["default_max_age"]), ) # Handles the other HTTP errors raised by the views. Without that, # the client receives a status=200 without content. config.add_view(error_handler, context=HTTPException) c2cwsgiutils.index.additional_title = ( '<div class="row"><div class="col-lg-3"><h2>GeoMapFish</h2></div><div class="col-lg">' ) c2cwsgiutils.index.additional_auth.extend([ '<a href="../tiles/admin/">TileCloud chain admin</a><br>', '<a href="../tiles/c2c/">TileCloud chain c2c tools</a><br>', '<a href="../invalidate">Invalidate the cache</a><br>', '<a href="../memory">Memory status</a><br>', ]) if config.get_settings().get("enable_admin_interface", False): c2cwsgiutils.index.additional_noauth.append( '<a href="../admin/">Admin</a><br>') c2cwsgiutils.index.additional_noauth.append( '</div></div><div class="row"><div class="col-lg-3"><h3>Interfaces</h3></div><div class="col-lg">' ) c2cwsgiutils.index.additional_noauth.append( '<a href="../">Default</a><br>') for interface in config.get_settings().get("interfaces", []): if not interface.get("default", False): c2cwsgiutils.index.additional_noauth.append( '<a href="../{interface}">{interface}</a><br>'.format( interface=interface["name"])) c2cwsgiutils.index.additional_noauth.append( '<a href="../apihelp/index.html">API help</a><br>') c2cwsgiutils.index.additional_noauth.append("</div></div><hr>")
from group import Group from supergroup import SuperGroup #Use pymongo from pymongo import MongoClient from mongokit import Document, Connection from bson import json_util from pyramid.renderers import JSON if __name__ == '__main__': my_session_factory = UnencryptedCookieSessionFactoryConfig('itsaseekreet') config = Configurator(session_factory = my_session_factory) config.include('pyramid_debugtoolbar') config.add_settings({'mako.directories':'templates/'}) config.add_static_view(name='static', path='static') config.add_route('home', '/') config.add_route('about', '/about') config.add_view(home, route_name='home') mgconnection = MongoClient() db = mgconnection.test # Clear database db.drop_collection('users') db.drop_collection('groups') connection = Connection() connection.register([User,Group,SuperGroup]) group = connection.Group() group["name"] = "sampleGroup"