def add_redirect(config: pyramid.config.Configurator, name: str, from_: str, to: str) -> None: def redirect_view(request: pyramid.request.Request) -> HTTPFound: return HTTPFound(location=request.route_url(to)) config.add_route(name, from_, request_method="GET") config.add_view(redirect_view, route_name=name)
def add_interface_ngeo( config: pyramid.config.Configurator, route_name: str, route: str, renderer: Optional[str] = None, permission: Optional[str] = None, ) -> None: """Add the ngeo interfaces views and routes.""" config.add_route(route_name, route, request_method="GET") # Permalink theme: recover the theme for generating custom viewer.js url config.add_route( f"{route_name}theme", f"{route}{'' if route[-1] == '/' else '/'}theme/{{themes}}", request_method="GET", ) config.add_view(Entry, attr="get_ngeo_index_vars", route_name=route_name, renderer=renderer, permission=permission) config.add_view( Entry, attr="get_ngeo_index_vars", route_name=f"{route_name}theme", renderer=renderer, permission=permission, )
def add_interface_canvas( config: pyramid.config.Configurator, route_name: str, route: str, interface_config: Dict[str, Any], permission: Optional[str] = None, ) -> None: """Add the ngeo interfaces views and routes.""" renderer = f"/etc/geomapfish/interfaces/{route_name}.html.mako" config.add_route(route_name, route, request_method="GET") # Permalink theme: recover the theme for generating custom viewer.js URL config.add_route( f"{route_name}theme", f"{route}{'' if route[-1] == '/' else '/'}theme/{{themes}}", request_method="GET", ) view = partial(canvas_view, interface_config=interface_config) view.__module__ = canvas_view.__module__ config.add_view( view, route_name=route_name, renderer=renderer, permission=permission, ) config.add_view( view, route_name=f"{route_name}theme", renderer=renderer, permission=permission, )
def init(config: pyramid.config.Configurator) -> None: base_path = _utils.get_base_path(config) if base_path != '': config.add_route("c2c_index", base_path, request_method=("GET", "POST")) config.add_view(_index, route_name="c2c_index", http_cache=0) config.add_route("c2c_index_slash", base_path + "/", request_method=("GET", "POST")) config.add_view(_index, route_name="c2c_index_slash", http_cache=0)
def init(config: pyramid.config.Configurator) -> None: if os.path.isfile(VERSIONS_PATH): versions = _read_versions() config.add_route("c2c_versions", _utils.get_base_path(config) + r"/versions.json", request_method="GET") config.add_view(lambda request: versions, route_name="c2c_versions", renderer="fast_json", http_cache=0) LOG.info("Installed the /versions.json service") git_hash = versions['main']['git_hash'] if 'git_tag' in versions['main']: LOG.warning("Starting version %s (%s)", versions['main']['git_tag'], git_hash) else: LOG.warning("Starting version %s", git_hash) if stats.USE_TAGS: stats.increment_counter(['version'], 1, tags=dict(version=git_hash)) else: stats.increment_counter(['version', git_hash], 1)
def add_interface_ngeo( config: pyramid.config.Configurator, route_name: str, route: str, renderer: str = None, permission: str = None, ) -> None: config.add_route(route_name, route, request_method="GET") config.add_view(Entry, attr="get_ngeo_index_vars", route_name=route_name, renderer=renderer, permission=permission) # Permalink theme: recover the theme for generating custom viewer.js url config.add_route( "{}theme".format(route_name), "{}{}theme/{{themes}}".format(route, "" if route[-1] == "/" else "/"), request_method="GET", ) config.add_view( Entry, attr="get_ngeo_index_vars", route_name="{}theme".format(route_name), renderer=renderer, permission=permission, )
def _add_view(config: pyramid.config.Configurator, name: str, path: str, view: Callable[[pyramid.request.Request], Any]) -> None: config.add_route("c2c_debug_" + name, config_utils.get_base_path(config) + r"/debug/" + path, request_method="GET") config.add_view(view, route_name="c2c_debug_" + name, renderer="fast_json", http_cache=0)
def init(config: pyramid.config.Configurator) -> None: config.add_route("c2c_read_stats_json", _utils.get_base_path(config) + r"/stats.json", request_method="GET") memory_backend = cast(stats.MemoryBackend, stats.BACKENDS['memory']) config.add_view(memory_backend.get_stats, route_name="c2c_read_stats_json", renderer="fast_json", http_cache=0)
def add_cors_route(config: pyramid.config.Configurator, pattern: str, service: str) -> None: """Add the OPTIONS route and view need for services supporting CORS.""" def view(request: pyramid.request.Request) -> pyramid.response.Response: return set_common_headers(request, service, Cache.PRIVATE_NO) name = pattern + "_options" config.add_route(name, pattern, request_method="OPTIONS") config.add_view(view, route_name=name)
def _static(config: pyramid.config.Configurator): config.add_route(name='index', path='/*subpath') config.add_view( request_method='GET', route_name='index', view=pyramid.static.static_view( root_dir='megadloader:static/', package_name='megadloader:static', ), )
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 includeme(config: pyramid.config.Configurator) -> None: for pattern, view, request_method in [ ('/api/sign_in', api.sign_in, 'POST'), ('/api/sign_up', api.sign_up, 'POST'), ]: config.add_route(pattern, pattern, request_method=request_method) config.add_view(view, route_name=pattern, request_method=request_method) config.add_view(api.error, context=Exception)
def add_admin_interface(config: pyramid.config.Configurator) -> None: if config.get_settings().get("enable_admin_interface", False): config.add_request_method( lambda request: c2cgeoportal_commons.models.DBSession(), "dbsession", reify=True, ) config.add_view(c2cgeoportal_geoportal.views.add_ending_slash, route_name="admin_add_ending_slash") config.add_route("admin_add_ending_slash", "/admin", request_method="GET") config.include("c2cgeoportal_admin")
def add_getitfixed(config: pyramid.config.Configurator) -> None: if config.get_settings()["getitfixed"].get("enabled", False): for route_name, pattern in ( ("getitfixed_add_ending_slash", "/getitfixed"), ("getitfixed_admin_add_ending_slash", "/getitfixed_admin"), ): config.add_view(c2cgeoportal_geoportal.views.add_ending_slash, route_name=route_name) config.add_route(route_name, pattern, request_method="GET") config.include("getitfixed") # Register admin and getitfixed search paths together Form.set_zpt_renderer(c2cgeoform.default_search_paths, translator=translator)
def _configure_location(config, geoip): """Configure the location server. This adds the ``service-location`` route and corresponding view to the given configurator. A reified request method ``geoip`` is added which returns a database reader for the given GeoIP database. :param pathlib.Path geoip: the path to the GeoIP database to use for the location service. """ config.add_request_method( lambda r: geoip2.database.Reader(str(geoip)), "geoip", reify=True) config.add_route("service-location", "/services/location") config.add_view(_location, route_name="service-location", renderer="json")
def test_deprecated_ranges_in_route_predicate(self): config = self._makeConfig() config.add_route('foo', '/foo', accept='text/*') config.add_view(lambda r: 'OK', route_name='foo', renderer='string') app = self._makeTestApp(config) res = app.get( '/foo', headers={'Accept': 'application/json; q=1.0, text/plain; q=0.9'}, status=200, ) self.assertEqual(res.content_type, 'text/plain') self.assertEqual(res.body, b'OK') res = app.get('/foo', headers={'Accept': 'application/json'}, status=404) self.assertEqual(res.content_type, 'application/json')
def __init__(self, config: pyramid.config.Configurator) -> None: config.add_route("c2c_health_check", _utils.get_base_path(config) + r"/health_check", request_method="GET") config.add_view(self._view, route_name="c2c_health_check", renderer="fast_json", http_cache=0) self._checks: List[Tuple[str, Callable[[pyramid.request.Request], Any], int]] = [] redis_url = _utils.env_or_config(config, broadcast.REDIS_ENV_KEY, broadcast.REDIS_CONFIG_KEY) if redis_url is not None: self.add_redis_check(redis_url, level=2) if version.get_version() is not None: self.add_version_check(level=2)
def on_class_load(cls, config: pyramid.config.Configurator): super(cls, cls).on_class_load(config) # config.add_route('test_payment_form', cls.route_payment_form) config.add_route('yandex_money_result_redirect', cls.route_result_redirect) settings = config.registry.settings # ViewsPaymentTestServer.notify_url = settings.get(ViewsPaymentTestServer.__name__+'.notify_url') # config.add_view( # ViewsPaymentTestServer, # attr='view_payment_form', # route_name='test_payment_form', # renderer='payment_systems/test_payment_form.jinja2' # ) config.add_view(ViewsPaymentClientYandexMoney, attr='view_result_redirect', route_name='test_payment_notify', renderer='string')
def __init__(self, config: pyramid.config.Configurator) -> None: config.add_route( "c2c_health_check", config_utils.get_base_path(config) + r"/health_check", request_method="GET" ) config.add_view(self._view, route_name="c2c_health_check", renderer="fast_json", http_cache=0) self._checks: List[Tuple[str, Callable[[pyramid.request.Request], Any], int]] = [] self.name = config_utils.env_or_config( config, redis_utils.REDIS_SENTINELS_KEY, redis_utils.REDIS_SENTINELS_KEY_PROP, config_utils.env_or_config(config, redis_utils.REDIS_URL_KEY, redis_utils.REDIS_URL_KEY_PROP), ) if self.name: self.add_redis_check(level=2) if version.get_version() is not None: self.add_version_check(level=2)
def on_class_load(cls, config: pyramid.config.Configurator): super(cls, cls).on_class_load(config) config.add_route('test_payment_form', cls.route_payment_form) config.add_route('test_payment_notify', cls.route_payment_notify) settings = config.registry.settings ViewsPaymentTestServer.notify_url = settings.get(ViewsPaymentTestServer.__name__+'.notify_url') config.add_view( ViewsPaymentTestServer, attr='view_payment_form', route_name='test_payment_form', renderer='payment_systems/test_payment_form.jinja2' ) config.add_view( ViewsPaymentTestClient, attr='view_payment_client_notify', route_name='test_payment_notify', renderer='string' )
def includeme(config: pyramid.config.Configurator) -> None: """Initialize the index page.""" base_path = config_utils.get_base_path(config) if base_path != "": config.add_route("c2c_index", base_path, request_method=("GET", "POST")) config.add_view(_index, route_name="c2c_index", http_cache=0) config.add_route("c2c_index_slash", base_path + "/", request_method=("GET", "POST")) config.add_view(_index, route_name="c2c_index_slash", http_cache=0) settings = config.get_settings() auth_type_ = auth_type(settings) if auth_type_ == AuthenticationType.SECRET: LOG.warning( "It is recommended to use OAuth2 with GitHub login instead of the `C2C_SECRET` because it " "protects from brute force attacks and the access grant is personal and can be revoked." ) if auth_type_ == AuthenticationType.GITHUB: config.add_route("c2c_github_login", base_path + "/github-login", request_method=("GET", )) config.add_view(_github_login, route_name="c2c_github_login", http_cache=0) config.add_route("c2c_github_callback", base_path + "/github-callback", request_method=("GET", )) config.add_view(_github_login_callback, route_name="c2c_github_callback", http_cache=0, renderer="fast_json") config.add_route("c2c_github_logout", base_path + "/github-logout", request_method=("GET", )) config.add_view(_github_logout, route_name="c2c_github_logout", http_cache=0)
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 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 _configure_authentication(config): """Configure authentication policies, routes and view. This adds a authentication and authorisation policy to the given configurator. In addition to this it adds a reified request method called ``openid_consumer`` -- see :func:`_get_openid_consumer`. For authentication two routes are added: ``authenticate-begin`` and ``authentication-complete``. These routes are bound to the views :func:`_begin_authentication` and :func:`_complete_authentication` respectively. The authentication completion view will have it's renderer set to the ``authentication-complete.jinja2`` Jinja template. Authentication it self is done through Steam's OpenID provision. The two views added by this function implement the OpenID flow. An additional route ``service-profile`` and corresponding view is added that returns a JSON object that identifies the current user. """ # TODO: DO NOT use this factory in production! config.set_session_factory( pyramid.session.SignedCookieSessionFactory("coffeedenshul")) authn_policy = pyramid.authentication.AuthTktAuthenticationPolicy( "coffeedenshul", hashalg="sha512", ) authz_policy = pyramid.authorization.ACLAuthorizationPolicy() config.set_authentication_policy(authn_policy) config.set_authorization_policy(authz_policy) config.add_request_method( _get_openid_consumer, "openid_consumer", reify=True, ) config.add_route("authenticate-begin", "/authenticate/begin") config.add_route("authenticate-complete", "/authenticate/complete") config.add_view(_begin_authentication, route_name="authenticate-begin") config.add_view( _complete_authentication, route_name="authenticate-complete", renderer="authentication-complete.jinja2", ) config.add_route("service-profile", "/services/profile") config.add_view(_profile, route_name="service-profile", renderer="json")
def add_routes(self): config = self.config config.add_route('sentry_frontend', '/sentry_frontend') config.add_route('login', '/login') config.add_route('logout', '/logout') config.add_route('navigation', '/navigation') config.add_route('home', '/') config.add_route('map', '/map') config.add_route('infobrief_print', '/infobrief_print') config.add_route('calendar', '/calendar') config.add_route('calendar_event_add', '/calendar/add') config.add_route( 'calendar_event_delete', '/calendar/{id}/delete', factory='..model.Event.context_factory' ) config.add_route('map_download', '/map/download') config.add_route('parcel_list', '/parcels') config.add_route('parcel_map_upload', '/parcels/{id}/upload_map', factory='..model.Parcel.context_factory') config.add_route('parcel_map_download_check', '/parcels/{id}/check_download_map', factory='..model.Parcel.context_factory') config.add_route('parcel_map_download', '/parcels/{id}/download_map', factory='..model.Parcel.context_factory') config.add_route('depot', '/depot') config.add_route('mail_add', '/mail/add') config.add_route('mail_list_inbox', '/mail/inbox') config.add_route('mail_list_sent', '/mail/sent') config.add_route('mail_list_drafts', '/mail/drafts') config.add_route('mail_edit', '/mail/{id}/edit', factory='..mail.Message.context_factory') config.add_route('mail_reply', '/mail/{id}/reply', factory='..mail.Message.context_factory') config.add_route('mail_status', '/mail/{id}/status', factory='..mail.Message.context_factory') config.add_route('mail_preview', '/mail/{id}/preview', factory='..mail.Message.context_factory') config.add_route('mail_print', '/mail/{id}/download', factory='..mail.Message.context_factory') config.add_route('mail_send', '/mail/{id}/send', factory='..mail.Message.context_factory') config.add_route('mail_duplicate', '/mail/{id}/duplicate', factory='..mail.Message.context_factory') config.add_route('mail_delete', '/mail/{id}/delete', factory='..mail.Message.context_factory') config.add_route('mail_list_attachments', '/mail/{id}/attachments', factory='..mail.Message.context_factory') config.add_route('mail_attachment_del', '/mail/attachment/{id}/del', factory='..mail.Attachment.context_factory') config.add_route('mail_attachment_white_page', '/mail/attachment/{id}/change_white_page', factory='..mail.Attachment.context_factory') config.add_route('mail_attachment_download', '/mail/attachment/{id}/download', factory='..mail.Attachment.context_factory') config.add_route('mail_postmark_open_tracking_webhook', '/mail/postmark_open_tracking_webhook') config.add_route('mail_postmark_inbound_webhook', '/mail/postmark_inbound_webhook') config.add_route('member_assignments', '/members/assignment_attendees') config.add_route('member_assignments_bill', '/members/assignment_attendees/bill') config.add_route('member_assignments_detail', '/members/assignment_attendees/{id}/list', factory='..model.Member.context_factory') config.add_route('member_add', '/members/add') config.add_route('member_edit', '/members/{id}/edit', factory='..model.Member.context_factory') config.add_route('member_attachment_add', '/members/{id}/attachments/add', factory='..model.Member.context_factory') config.add_route('member_attachment', '/members/{id}/attachments', factory='..model.Member.context_factory') config.add_route( 'member_attachment_download', '/members/{member_id}/attachments/{id}/download', factory='..model.MemberAttachment.context_factory') config.add_route( 'member_attachment_delete', '/members/{member_id}/attachments/{id}/delete', factory='..model.MemberAttachment.context_factory') config.add_route('member_account_list', '/members/account_list') config.add_route('member_account_detail_list', '/members/{id}/account_details', factory='..model.Member.context_factory') config.add_route( 'member_account_detail_switch_ir', '/members/{member_id}/account_details/{id}/switch', factory='.account.AccountDetailFactory') config.add_route('banking_account_list', '/accounts/list') config.add_route('banking_account_list_detail', '/accounts/{id}/detail', factory='..account.BookingKind.context_factory') config.add_route('banking_account_list_report', '/accounts/report.pdf') config.add_route('sepa_sammler_list', '/accounts/sepa_sammler') config.add_route('sepa_sammler_add', '/accounts/sepa_sammler/add') config.add_route( 'sepa_ueberweisung_add', '/accounts/sepa_sammler/add_ueberweisung' ) config.add_route('sepa_sammler_edit', '/accounts/sepa_sammler/{id}/edit', factory='..account.SEPASammler.context_factory') config.add_route('sepa_sammler_export', '/accounts/sepa_sammler/{id}/export', factory='..account.SEPASammler.context_factory') config.add_route('sepa_sammler_update', '/accounts/sepa_sammler/{id}/update', factory='..account.SEPASammler.context_factory') config.add_route('sepa_sammler_entry_list', '/accounts/sepa_sammler/{id}/entries', factory='..account.SEPASammler.context_factory') config.add_route('sepa_direct_debit', '/accounts/sepa_direct_debit') config.add_route('booking_list', '/accounts/{id}/list', factory='..account.BankingAccount.context_factory') config.add_route('split_booking', '/booking/{id}/split', factory='..account.Booking.context_factory') config.add_route('map_booking', '/booking/{id}/map', factory='..account.Booking.context_factory') config.add_route('waste_water', '/waste_water') config.add_route('property_tax_b', '/property_tax_b') config.add_route('member_list', '/members') config.add_route('member_list_leased', '/members_leased') config.add_route('member_list_passive', '/members_passive') config.add_route('member_list_tap_water', '/members_tap_water') config.add_route('member_sale_history', '/members/sale_history') config.add_route('membership_fee', '/members/insert_membership_fee') config.add_route('member_sale', '/members/{id}/sale', factory='..model.Member.context_factory') config.add_route('direct_debit_letter', '/members/{id}/direct_debit_letter', factory='..model.Member.context_factory') config.add_route('become_member_letter', '/members/{id}/become_member_letter', factory='..model.Member.context_factory') config.add_route('mv_entrance_list', '/members/mv_entrance_list') config.add_route('energy_meter_export', '/electricity/export') config.add_route('energy_meter_import', '/electricity/import') config.add_route('calculate_energy_values', '/electricity/calculate_energy_values') config.add_route('access_authority', '/access_authority') config.add_route('access_authority_detail', '/access_authority/{id}/list', factory='.authority.AuthorityContext.context_factory') config.add_route('access_authority_detail_add', '/access_authority/{id}/list/add', factory='.authority.AuthorityContext.context_factory') config.add_route( 'access_authority_detail_edit', '/access_authority/{viewname}/list/{id}/edit', factory='..model.AccessAuthority.context_factory') config.add_route( 'access_authority_detail_delete', '/access_authority/{viewname}/list/{id}/delete', factory='..model.AccessAuthority.context_factory') config.add_route('energy_price', '/energy_price') config.add_route('electricity_list', '/electricity') config.add_route('global_energy_value_list', '/electricity_billing') config.add_route('energy_value_list', '/electricity/{id}/history', factory='..electricity.ElectricMeter.context_factory') config.add_route('advance_pay_value_list', '/electricity/{id}/advance_pay_history', factory='..electricity.ElectricMeter.context_factory') config.add_route('externals', '/externals') config.add_route('external_add', '/externals/add') config.add_route('external_edit', '/externals/{id}/edit', factory='..mail.ExternalRecipient.context_factory') config.add_route('external_delete', '/externals/{id}/delete', factory='..mail.ExternalRecipient.context_factory') config.add_route('bulletins', '/bulletins') config.add_route('bulletin_add', '/bulletins/add') config.add_route('bulletin_edit', '/bulletins/{id}/edit', factory='..bulletins.Bulletin.context_factory') config.add_route('bulletin_delete', '/bulletins/{id}/delete', factory='..bulletins.Bulletin.context_factory') config.add_route('bulletin_print', '/bulletins/{id}/print', factory='..bulletins.Bulletin.context_factory') config.add_route('keylists', '/keylists') config.add_route('keylist_add', '/keylists/add') config.add_route('keylist_edit', '/keylists/{id}/edit', factory='..keylist.Keylist.context_factory') config.add_route('keylist_delete', '/keylists/{id}/delete', factory='..keylist.Keylist.context_factory') config.add_route('keys', '/keylists/{id}/keys', factory='..keylist.Keylist.context_factory') config.add_route('key_add', '/keylists/{id}/keys/add', factory='..keylist.Keylist.context_factory') config.add_route( 'key_edit', '/keylists/{keylist_id}/keys/{id}/edit', factory='..keylist.Key.context_factory') config.add_route( 'key_delete', '/keylists/{keylist_id}/keys/{id}/delete', factory='..keylist.Key.context_factory') config.add_route('keylist_attachment_add', '/keylists/{id}/attachments/add', factory='..keylist.Keylist.context_factory') config.add_route('keylist_attachment', '/keylists/{id}/attachments', factory='..keylist.Keylist.context_factory') config.add_route( 'keylist_attachment_download', '/keylists/{keylist_id}/attachments/{id}/download', factory='..keylist.KeylistAttachment.context_factory') config.add_route('protocols', '/protocols') config.add_route('protocol_add', '/protocols/add') config.add_route('protocol_edit', '/protocols/{id}/edit', factory='..protocol.Protocol.context_factory') config.add_route('protocol_delete', '/protocols/{id}/delete', factory='..protocol.Protocol.context_factory') config.add_route('protocol_detail', '/protocols/{id}/details', factory='..protocol.Protocol.context_factory') config.add_route('protocol_detail_add', '/protocols/{id}/details/add', factory='..protocol.Protocol.context_factory') config.add_route( 'protocol_detail_edit', '/protocols/{protocol_id}/details/{id}/edit', factory='..protocol.ProtocolDetail.context_factory') config.add_route( 'protocol_detail_delete', '/protocols/{protocol_id}/details/{id}/delete', factory='..protocol.ProtocolDetail.context_factory') config.add_route('protocol_print', '/protocols/{id}/print', factory='..protocol.Protocol.context_factory') config.add_route('protocol_attachment_add', '/protocols/{id}/attachments/add', factory='..protocol.Protocol.context_factory') config.add_route('protocol_attachment', '/protocols/{id}/attachments', factory='..protocol.Protocol.context_factory') config.add_route( 'protocol_attachment_download', '/protocols/{protocol_id}/attachments/{id}/download', factory='..protocol.ProtocolAttachment.context_factory') config.add_route( 'protocol_attachment_delete', '/protocols/{protocol_id}/attachments/{id}/delete', factory='..protocol.ProtocolAttachment.context_factory') config.add_route('protocol_commitment', '/protocols/{id}/commitments', factory='..protocol.Protocol.context_factory') config.add_route('protocol_commitment_add', '/protocols/{id}/commitments/add', factory='..protocol.Protocol.context_factory') config.add_route( 'protocol_commitment_edit', '/protocols/{protocol_id}/commitments/{id}/edit', factory='..protocol.ProtocolCommitment.context_factory') config.add_route( 'protocol_commitment_delete', '/protocols/{protocol_id}/commitments/{id}/delete', factory='..protocol.ProtocolCommitment.context_factory') config.add_route('assignments', '/assignments') config.add_route('assignment_add', '/assignments/add') config.add_route('assignment_edit', '/assignments/{id}/edit', factory='..assignment.Assignment.context_factory') config.add_route('assignment_delete', '/assignments/{id}/delete', factory='..assignment.Assignment.context_factory') config.add_route('assignment_list_attendees', '/assignments/{id}/list', factory='..assignment.Assignment.context_factory') config.add_route('assignment_attendees_add', '/assignments/{id}/attendees/add', factory='..assignment.Assignment.context_factory') config.add_route( 'assignment_attendees_edit', '/assignments/{assignment_id}/attendees/{id}/edit', factory='..assignment.AssignmentAttendee.context_factory') config.add_route( 'assignment_attendees_delete', '/assignments/{assignment_id}/attendees/{id}/delete', factory='..assignment.AssignmentAttendee.context_factory') config.add_route('depots', '/depots') config.add_route('depot_add', '/depots/add') config.add_route('depot_edit', '/depots/{id}/edit', factory='..depot.Depot.context_factory') config.add_route('depot_delete', '/depots/{id}/delete', factory='..depot.Depot.context_factory') config.add_route('depot_download', '/depots/{id}/download', factory='..depot.Depot.context_factory')
def add_routes(config): config.add_route('stripe', '/stripe')
import pyramid.config import pyramid.response from config import PING_MESSAGE # noinspection PyUnusedLocal def ping(request): return pyramid.response.Response(PING_MESSAGE.format(app='pyramid')) with pyramid.config.Configurator() as config: config.add_route('ping', '/') config.add_view(ping, route_name='ping') app = config.make_wsgi_app()
def _api(config: pyramid.config.Configurator): config.add_route('api: status', '/api/status') config.add_view( request_method='GET', route_name='api: status', view=handle_status, renderer='json', ) config.add_route('api: categories', '/api/categories/') config.add_view( request_method='GET', route_name='api: categories', view=handle_list_categories, renderer='json', ) config.add_view( request_method='POST', route_name='api: categories', view=handle_create_category, renderer='json', ) config.add_route('api: urls', '/api/urls/') config.add_view( request_method='GET', route_name='api: urls', view=handle_get_urls, renderer='json', ) config.add_view( request_method='POST', route_name='api: urls', view=handle_add_url, renderer='json', ) config.add_route('api: queue items', '/api/queue/{queue_id}') config.add_view( request_method='DELETE', route_name='api: queue items', view=handle_delete_url, renderer='json', ) config.add_route('api: files', '/api/files/') config.add_view( request_method='GET', route_name='api: files', view=handle_list_files, renderer='json', ) config.add_route('api: file', '/api/files/{file_id}') config.add_view( request_method='GET', route_name='api: file', view=handle_get_file, renderer='json', )
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)
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" group["creation_date"] = datetime.utcnow()
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 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 _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')