def main(global_config, **settings):
""" This function returns a Pyramid WSGI application.
"""
if 'DATABASE_URL' in os.environ:
settings['sqlalchemy.url'] = os.environ['DATABASE_URL']
engine = engine_from_config(settings, 'sqlalchemy.')
DBSession.configure(bind=engine)
Base.metadata.bind = engine
config = Configurator(
settings=settings,
authentication_policy=AuthTktAuthenticationPolicy('somesecret'),
authorization_policy=ACLAuthorizationPolicy(),
default_permission='view')
config.include('pyramid_jinja2')
config.add_static_view('static', 'static', cache_max_age=3600)
config.add_route('home', '/', factory=EntryFactory)
config.add_route('detail', '/journal/{id:\d+}', factory=EntryFactory)
config.add_route('action', '/journal/{action}', factory=EntryFactory)
config.add_route('auth', '/sign/{action}', factory=EntryFactory)
config.scan()
return config.make_wsgi_app()
def setUp(self):
self.config = testing.setUp(
settings={'pyramid.debug_authorization': True})
# Set up debug_authorization logging to console
logging.basicConfig(level=logging.DEBUG)
debug_logger = logging.getLogger()
self.config.registry.registerUtility(debug_logger, IDebugLogger)
self.config.include("cornice")
self.authz_policy = ACLAuthorizationPolicy()
self.config.set_authorization_policy(self.authz_policy)
self.authn_policy = AuthTktAuthenticationPolicy('$3kr1t')
self.config.set_authentication_policy(self.authn_policy)
self.config.scan("tests.test_service")
self.config.scan("tests.test_pyramidhook")
self.app = TestApp(CatchErrors(self.config.make_wsgi_app()))
register_service_views(self.config, service)
def main(global_config, **settings):
""" This function returns a Pyramid WSGI application.
"""
engine = engine_from_config(settings, 'sqlalchemy.')
DBSession.configure(bind=engine)
Base.metadata.bind = engine
session_factory = session_factory_from_settings(settings)
authentication = AuthTktAuthenticationPolicy(
settings.get('session.secret'), )
authorization = ACLAuthorizationPolicy()
config = Configurator(
settings=settings,
root_factory=root_factory,
authentication_policy=authentication,
authorization_policy=authorization,
session_factory=session_factory,
)
config.add_translation_dirs(
'colander:locale/',
'travelcrm:locale/',
)
config.add_subscriber('.lib.subscribers.company_schema',
'pyramid.events.NewRequest')
config.add_subscriber('.lib.subscribers.company_settings',
'pyramid.events.NewRequest')
config.add_subscriber('.lib.subscribers.helpers',
'pyramid.events.BeforeRender')
config.add_subscriber('.lib.subscribers.scheduler',
'pyramid.events.ApplicationCreated')
config.add_renderer('pdf', PDFRendererFactory)
config.add_renderer('sse', SSERendererFactory)
config.add_static_view('css', 'static/css', cache_max_age=3600)
config.add_static_view('js', 'static/js', cache_max_age=3600)
config.add_thumb_view('thumbs')
config.scan()
return config.make_wsgi_app()
def main(global_config, **settings):
""" This function returns a Pyramid WSGI application.
"""
engine = engine_from_config(settings, 'sqlalchemy.')
initialize_sql(engine)
authn_policy = AuthTktAuthenticationPolicy('sosecret',
callback=groupfinder)
authz_policy = ACLAuthorizationPolicy()
config = Configurator(settings=settings,
root_factory='motionman.models.RootFactory',
authentication_policy=authn_policy,
authorization_policy=authz_policy)
#config = Configurator(settings=settings)
config.add_static_view('static', 'motionman:static')
config.add_route('home', '/')
config.add_route('setting_edit', '/setting/edit')
config.add_route('user_list', '/user/list')
config.add_route('user_add', '/user/add')
config.add_route('user_edit', '/user/edit/{id}')
config.add_route('user_delete', '/user/delete/{id}')
config.add_route('motion_list', '/motion/list')
config.add_route('motion_add', '/motion/add')
config.add_route('motion_vote', '/motion/vote/{id}/{chips}')
config.add_route('motion_message', '/motion/message/{id}')
config.add_route('login', '/login')
config.add_route('logout', '/logout')
config.add_view('motionman.views.login.login',
context='pyramid.httpexceptions.HTTPForbidden',
renderer='motionman:templates/login.pt')
config.scan('motionman.views')
return config.make_wsgi_app()
def main(global_config, **settings):
""" This function returns a Pyramid WSGI application.
"""
engine = engine_from_config(settings, 'sqlalchemy.')
DBSession.configure(bind=engine)
Base.metadata.bind = engine
authn_policy = AuthTktAuthenticationPolicy('secret',
callback=groupfinder,
hashalg='sha512')
authz_policy = ACLAuthorizationPolicy()
config = Configurator(settings=settings, root_factory='myshop.RootFactory')
config.set_authentication_policy(authn_policy)
config.set_authorization_policy(authz_policy)
config.set_request_property(get_user, 'user', reify=True)
config.set_request_property(lambda request: DBSession, 'db', reify=True)
config.include('pyramid_chameleon')
config.add_static_view('static', 'static', cache_max_age=3600)
config.add_route('home', '/')
config.add_route('category', '/category/{id}')
config.add_route('item', '/item/{id}')
config.add_route('search', '/search')
config.add_route('annoncement', '/annoncement/{id}')
config.add_route('login', '/login')
config.add_route('logout', '/logout')
config.add_route('register', '/register')
config.add_route('order', '/order')
config.add_route('cart', '/cart')
config.add_route('comment', '/comment')
config.add_route('add_item', '/category/{id}/add')
config.scan()
return config.make_wsgi_app()
def main():
"""Create a configured wsgi app"""
settings = {}
settings['reload_all'] = os.environ.get('DEBUG', True)
settings['debug_all'] = os.environ.get('DEBUG', True)
settings['sqlalchemy.url'] = os.environ.get(
'DATABASE_URL',
'postgresql://{}:@localhost:5432/learning_journal'.format(USER))
engine = sa.engine_from_config(settings, 'sqlalchemy.')
DBSession.configure(bind=engine)
settings['auth.username'] = os.environ.get('AUTH_USERNAME', 'admin')
manager = BCRYPTPasswordManager()
settings['auth.password'] = os.environ.get('AUTH_PASSWORD',
manager.encode('secret'))
# secret value for session signing:
secret = os.environ.get('JOURNAL_SESSION_SECRET', 'itsaseekrit')
session_factory = SignedCookieSessionFactory(secret)
# add a secret value for auth tkt signing
auth_secret = os.environ.get('JOURNAL_AUTH_SECRET', 'anotherseekrit')
# configuration setup
config = Configurator(
settings=settings,
session_factory=session_factory,
authentication_policy=AuthTktAuthenticationPolicy(secret=auth_secret,
hashalg='sha512'),
authorization_policy=ACLAuthorizationPolicy(),
)
config.include('pyramid_jinja2')
config.include('pyramid_tm')
config.add_static_view('static', os.path.join(here, 'static'))
config.add_route('home', '/')
config.add_route('add', '/add')
config.add_route('login', '/login')
config.add_route('logout', '/logout')
config.add_route('detail', '/detail/{id}')
config.add_route('editview', '/editview')
config.scan()
app = config.make_wsgi_app()
return app
def main():
"""Create a configured wsgi app"""
settings = {}
settings['reload_all'] = os.environ.get('DEBUG', True)
settings['debug_all'] = os.environ.get('DEBUG', True)
settings['sqlalchemy.url'] = os.environ.get('DATABASE_URL',
'postgresql:///whiteknight')
engine = sa.engine_from_config(settings, 'sqlalchemy.')
DBSession.configure(bind=engine)
settings['auth.username'] = os.environ.get('AUTH_USERNAME', 'admin')
manager = BCRYPTPasswordManager()
settings['auth.password'] = os.environ.get('AUTH_PASSWORD',
manager.encode('secret'))
secret = os.environ.get('JOURNAL_SESSION_SECRET', 'itsaseekrit')
session_factory = SignedCookieSessionFactory(secret)
auth_secret = os.environ.get('JOURNAL_AUTH_SECRET', 'anotherseekrit')
config = Configurator(
settings=settings,
session_factory=session_factory,
authentication_policy=AuthTktAuthenticationPolicy(secret=auth_secret,
hashalg='sha512',
debug=True),
authorization_policy=ACLAuthorizationPolicy(),
)
config.add_static_view('static', os.path.join(here, 'static'))
config.include('pyramid_jinja2')
config.include('pyramid_tm')
config.add_route('home', '/')
config.add_route('login', '/login')
config.add_route('logout', '/logout')
config.add_route('feed', '/feed')
config.add_route('scrape', '/scrape')
config.add_route('scrape_twitter', '/scrape_twitter')
config.add_route('tweet', '/tweet/{id}')
config.add_route('edit_comment', '/edit_comment/{id}')
config.add_route('remove_one', '/remove_one/{id}')
config.add_route('delete_all', '/delete_all')
config.scan()
app = config.make_wsgi_app()
return app
def setup(config):
"""Setup SAML2 auth - to be called when the app starts."""
# Ensure python-lasso is available.
if not lasso_loaded:
raise Exception(
'SAML2 enabled in settings but python-lasso could not be loaded.\n'
'Download Lasso from <http://lasso.entrouvert.org/>.')
# Register the authentication policy.
config.set_authentication_policy(
AuthTktAuthenticationPolicy(
config.get_settings()['saml2.auth_secret'],
hashalg='sha512',
callback=get_user_principals,
))
# Add routes for SAML2 views.
config.add_route('saml2_login', '/login')
config.add_route('saml2_login_metadata', '/login_metadata')
config.add_route('saml2_login_success', '/login_success')
config.add_route('saml2_logout', '/logout')
# Register SAML2 views. Avoid using the "view_config" decorator as we don't
# want the views to be added when SAML2 is disabled.
def add_view(view, **kwargs):
config.add_view(view,
permission=NO_PERMISSION_REQUIRED,
http_cache=0,
**kwargs)
add_view(login_view, route_name='saml2_login', renderer='json')
add_view(login_metadata_view,
route_name='saml2_login_metadata',
renderer='string')
add_view(login_success_view, route_name='saml2_login_success')
add_view(logout_view, route_name='saml2_logout', renderer='json')
# The default 403 (forbidden) view produces HTML; change it to a JSON one.
forbidden_view_config(renderer='json')(forbidden_view)
def main(global_config, **settings):
""" This function returns a Pyramid WSGI application.
"""
session_factory = session_factory_from_settings(settings)
authn_policy = AuthTktAuthenticationPolicy('A@uth3ntic@t3')
authz_policy = ACLAuthorizationPolicy()
config = Configurator(settings=settings,
root_factory=Root,
authentication_policy=authn_policy,
authorization_policy=authz_policy,
session_factory=session_factory)
# MongoDB
def add_mongo_db(event):
settings = event.request.registry.settings
url = settings['mongodb.url']
db_name = settings['mongodb.db_name']
db = settings['mongodb_conn'][db_name]
event.request.db = db
db_uri = settings['mongodb.url']
MongoDB = pymongo.Connection
if 'pyramid_debugtoolbar' in set(settings.values()):
class MongoDB(pymongo.Connection):
def __html__(self):
return 'MongoDB: <b>{}></b>'.format(self)
conn = MongoDB(db_uri)
config.registry.settings['mongodb_conn'] = conn
config.add_subscriber(add_mongo_db, NewRequest)
config.include('pyramid_chameleon')
config.add_static_view('static', 'forum:static', cache_max_age=3600)
config.add_route('home', '/')
config.scan('forum')
return config.make_wsgi_app()
def main():
"""Create a configured wsgi app"""
# configuraton settings
settings = {}
settings['reload_all'] = os.environ.get('DEBUG', True)
settings['debug_all'] = os.environ.get('DEBUG', True)
settings['db'] = os.environ.get('DATABASE_URL',
'dbname=learning_journal user=edward')
settings['auth.username'] = os.environ.get('AUTH_USERNAME', 'admin')
manager = BCRYPTPasswordManager()
settings['auth.password'] = os.environ.get('AUTH_PASSWORD',
manager.encode('secret'))
# secret value for session signing:
secret = os.environ.get('JOURNAL_SESSION_SECRET', 'itsaseekrit')
session_factory = SignedCookieSessionFactory(secret)
# secret value for auth signing
auth_secret = os.environ.get('JOURNAL_AUTH_SECRET', 'anotherseekrit')
# configuration setup
config = Configurator(
settings=settings,
session_factory=session_factory,
authentication_policy=AuthTktAuthenticationPolicy(secret=auth_secret,
hashalg='sha512'),
authorization_policy=ACLAuthorizationPolicy(),
)
config.include('pyramid_jinja2')
config.add_static_view('static', os.path.join(here, 'static'))
config.add_route('home', '/')
config.add_route('add', '/add')
config.add_route('login', '/login')
config.add_route('logout', '/logout')
config.add_route('detail', '/detail/{id:\d+}')
config.add_route('edit', '/edit/{id:\d+}')
config.scan()
jinja2.filters.FILTERS['markdown'] = mdown
# serve app
app = config.make_wsgi_app()
return app
def main(global_config, **settings):
""" This function returns a Pyramid WSGI application.
"""
Base.metadata.create_all()
session = Session(bind=engine)
session.query(TempOrder).delete(synchronize_session=False)
#admin = Admin(Login= "******", Password = "******")
#session.add(admin)
session.commit()
config = Configurator(root_factory=MyFactory,
settings=settings,
session_factory=my_session_factory)
config.include('pyramid_jinja2')
config.add_static_view('static', 'static', cache_max_age=3600)
config.add_route('home', '/')
config.add_route('buy', '/buy')
config.add_route('login', '/login')
config.add_route('register', '/register')
config.add_route('order', '/order')
config.add_route('products', '/products')
config.add_route('admin', '/admin')
config.add_route('buyProduct', "/buyProduct/{id}")
config.add_route('delete', "/delete/{id}")
config.add_route('reload', "/reload/{id}")
config.add_route('removeOrder', "/removeOrder/{id}")
config.add_route('deleteProduct', "/deleteProduct/{id}")
config.add_route('addProduct', "/addProduct")
config.add_route('loginAdmin', "/loginAdmin")
config.add_route('logoutAdmin', "/logoutAdmin")
#авторизация и аутентификация
authn_policy = AuthTktAuthenticationPolicy('sosecret', hashalg='sha512')
authz_policy = ACLAuthorizationPolicy()
config.set_authentication_policy(authn_policy)
config.set_authorization_policy(authz_policy)
config.scan()
return config.make_wsgi_app()
def main(global_config, **settings):
""" This function returns a Pyramid WSGI application.
"""
engine = engine_from_config(settings, 'sqlalchemy.')
DBSession.configure(bind=engine)
Base.metadata.bind = engine
init_model()
session_factory = session_factory_from_settings(settings)
if 'localization' not in settings:
settings['localization'] = 'id_ID.UTF-8'
locale.setlocale(locale.LC_ALL, settings['localization'])
if 'timezone' not in settings:
settings['timezone'] = DefaultTimeZone
config = Configurator(settings=settings,
root_factory='opensipkdsig.models.RootFactory',
session_factory=session_factory)
config.include('pyramid_beaker')
config.include('pyramid_chameleon')
authn_policy = AuthTktAuthenticationPolicy('sosecret',
callback=group_finder,
hashalg='sha512')
authz_policy = ACLAuthorizationPolicy()
config.set_authentication_policy(authn_policy)
config.set_authorization_policy(authz_policy)
config.add_request_method(get_user, 'user', reify=True)
config.add_request_method(get_title, 'title', reify=True)
config.add_notfound_view(RemoveSlashNotFoundViewFactory())
config.add_static_view('static', 'static', cache_max_age=3600)
config.add_static_view('deform_static', 'deform:static')
config.add_static_view('files', settings['static_files'])
for name, path, title in routes:
config.add_route(name, path)
config.scan()
app = config.make_wsgi_app()
from paste.translogger import TransLogger
app = TransLogger(app, setup_console_handler=False)
return app
def main(global_config, **settings):
"""
Main entrypoint for wsgi
"""
my_session_factory = SignedCookieSessionFactory('itsaseekreet')
config = Configurator(settings=settings,
session_factory=my_session_factory)
config.include('pyramid_jinja2')
authn_policy = AuthTktAuthenticationPolicy(
settings['BarLibrary.secret'], callback=None,
hashalg='sha512')
authz_policy = ACLAuthorizationPolicy()
config.set_authentication_policy(authn_policy)
config.set_authorization_policy(authz_policy)
config.add_static_view(name='static', path='barlibrary:static')
config.include('.models')
config.include('.routes')
config.scan()
return config.make_wsgi_app()
def main(global_config, **settings):
""" This function returns a Pyramid WSGI application.
"""
engine = engine_from_config(settings, 'sqlalchemy.')
DBSession.configure(bind=engine)
Base.metadata.bind = engine
authn_policy = AuthTktAuthenticationPolicy(
'sosecret', callback=groupfinder)
authz_policy = ACLAuthorizationPolicy()
config = Configurator(settings=settings,
root_factory='tutorial.models.RootFactory')
config.set_authentication_policy(authn_policy)
config.set_authorization_policy(authz_policy)
config.add_static_view('static', 'static', cache_max_age=3600)
config.add_route('view_wiki', '/')
config.add_route('login', '/login')
config.add_route('logout', '/logout')
config.add_route('view_page', '/{pagename}')
config.add_route('add_page', '/add_page/{pagename}')
config.add_route('edit_page', '/{pagename}/edit_page')
config.scan()
return config.make_wsgi_app()
def main(global_config, **settings):
""" This function returns a Pyramid WSGI application.
"""
if 'DATABASE_URL' in os.environ:
settings['sqlalchemy.url'] = os.environ['DATABASE_URL']
engine = engine_from_config(settings, 'sqlalchemy.')
engine = engine_from_config(settings, 'sqlalchemy.')
DBSession.configure(bind=engine)
Base.metadata.bind = engine
secret = os.environ.get('AUTH_SECRET', 'somesecret')
config = Configurator(settings=settings)
# config = Configurator(
# settings=settings,
# authentication_policy=authentication_policy,
# authorization_policy=authorization_policy,
# root)
config = Configurator(
settings=settings,
authentication_policy=AuthTktAuthenticationPolicy(
secret,
hashalg='sha512'
),
authorization_policy=ACLAuthorizationPolicy(),
root_factory=DefaultRoot,
)
config.include('pyramid_jinja2')
config.add_static_view('static', 'static', cache_max_age=3600)
config.add_route('list', '/')
config.add_route('login', '/login')
config.add_route('logout', '/logout')
config.add_route('add_entry', '/create')
config.add_route('delete_entry', '/delete_entry/{entry_id}')
# config.add_route('delete_entry', '/')
config.add_route('detail', '/view/{entry_id}')
config.add_route('edit', '/edit/{entry_id}')
config.scan()
return config.make_wsgi_app()
def make_wsgi_app(global_config: Dict[Any, Any], **settings) -> Router:
# Logging
main_only_quicksetup_rootlogger()
logging.getLogger('sqlalchemy').setLevel(logging.WARNING)
# log.debug(f"global_config: {global_config!r}")
# log.debug(f"settings: {settings!r}")
# Database
engine = engine_from_config(settings,
NlpServerConfigKeys._SQLALCHEMY_PREFIX,
**SQLALCHEMY_COMMON_OPTIONS)
# ... add to config - pool_recycle is set to create new sessions every 7h
sqla_url = get_safe_url_from_engine(engine)
log.info(f"Using database {sqla_url!r}")
dbsession.configure(bind=engine)
Base.metadata.bind = engine
# Pyramid
config = Configurator(settings=settings)
# Security policies
authn_policy = AuthTktAuthenticationPolicy(
settings[NlpServerConfigKeys.NLP_WEBSERVER_SECRET],
secure=True, # only allow requests over HTTPS
hashalg='sha512')
authz_policy = ACLAuthorizationPolicy()
config.set_authentication_policy(authn_policy)
config.set_authorization_policy(authz_policy)
# Compression
config.add_tween("cardinal_pythonlib.pyramid.compression.CompressionTweenFactory") # noqa
# Routes
config.add_route('index', '/')
config.scan('.views')
# Create WSGI app
return config.make_wsgi_app()
def configure_auth(config, settings):
extra_authn_policy = {}
if 'groups_callback' in settings:
extra_authn_policy['callback'] = settings['groups_callback']
if not settings.get('testing'):
authn_policy = SessionAuthenticationPolicy(prefix='session',
**extra_authn_policy)
else:
authn_policy = AuthTktAuthenticationPolicy(settings.get(
'auth_tk_secret', '1234'),
hashalg='sha512',
wild_domain=False,
**extra_authn_policy)
authz_policy = ACLAuthorizationPolicy()
config.set_authentication_policy(authn_policy)
config.set_authorization_policy(authz_policy)
return config
def main(global_config, **settings):
""" This function returns a Pyramid WSGI application.
"""
authn_policy = AuthTktAuthenticationPolicy('sosecret',
callback=groupfinder)
authz_policy = ACLAuthorizationPolicy()
zodb_uri = settings.get('zodb_uri', False)
if zodb_uri is False:
raise ValueError("No 'zodb_uri' in application configuration.")
finder = PersistentApplicationFinder(zodb_uri, appmaker)
def get_root(request):
return finder(request.environ)
config = Configurator(root_factory=get_root,
settings=settings,
authentication_policy=authn_policy,
authorization_policy=authz_policy)
config.add_static_view('static', 'tutorial:static')
config.scan('tutorial')
return config.make_wsgi_app()
def includeme(config):
auth_secret = environ.get(
'AUTH_SECRET',
'\x85v\xaf\xf9:3I\x0c\x98\x80\xec\x9e\xe3\xd4\xee\xba\xdfst\xb5')
authz_policy = ACLAuthorizationPolicy()
authn_policy = AuthTktAuthenticationPolicy(
secret=auth_secret,
hashalg='sha512',
)
config.set_authentication_policy(authn_policy)
config.set_authorization_policy(authz_policy)
config.set_default_permission('view')
config.set_root_factory(PyramidStocksRoot)
session_secret = environ.get(
'SESSION_SECRET',
'\xc0\xa37\xc6\x15\xb4B7\x16\xe9\xaa[^<`\x7f;p\x18\x1f')
session_factory = SignedCookieSessionFactory(session_secret)
config.set_session_factory(session_factory)
config.set_default_csrf_options(require_csrf=True)
def main(global_config, **settings):
""" This function returns a Pyramid WSGI application.
"""
authn_policy = AuthTktAuthenticationPolicy('mysecret',
timeout=30000,
callback=group_finder)
authz_policy = ACLAuthorizationPolicy()
config = Configurator(settings=settings,
root_factory=RootFactory,
authentication_policy=authn_policy,
authorization_policy=authz_policy)
config.include('pyramid_jinja2')
config.add_static_view('static', 'static', cache_max_age=3600)
config.add_route('home', '/')
config.add_route('login', '/login')
config.add_route('logout', '/logout')
config.scan()
return config.make_wsgi_app()
def main(global_config, **settings):
""" This function returns a Pyramid WSGI application.
"""
with Configurator(settings=settings, request_factory=MyRequest) as config:
config.include('pyramid_chameleon')
# Security policies
authn_policy = AuthTktAuthenticationPolicy(settings['tutorial.secret'],
hashalg='sha512')
authz_policy = ACLAuthorizationPolicy()
config.set_authentication_policy(authn_policy)
config.set_authorization_policy(authz_policy)
config.include('.models')
config.include('pyramid_jinja2')
config.include('.routes')
config.include('pyramid_mailer')
config.scan('.views')
config.scan('.process_request')
config.add_tween('webapp.access_tween.access_tween_factory')
config.add_static_view('deform_static', 'deform:static/')
return config.make_wsgi_app()
def main(global_config, **settings):
with Configurator(settings=settings, root_factory=Root) as config:
config.set_request_factory(Request)
# mako
registry_settings = config.registry.settings
if 'mako.directories' not in registry_settings:
registry_settings['mako.directories'] = 'wim_web:web/templates'
# Configuration to show 'None' as empty string
registry_settings['mako.imports'] = (
'from markupsafe import escape_silent')
registry_settings['mako.default_filters'] = 'escape_silent'
# session
session_factory = SignedCookieSessionFactory(
settings['wim_web.session_secret'])
config.set_session_factory(session_factory)
# auth
authn_policy = AuthTktAuthenticationPolicy(settings['wim_web.secret'],
callback=groupfinder,
hashalg='sha512')
authz_policy = ACLAuthorizationPolicy()
config.set_authentication_policy(authn_policy)
config.set_authorization_policy(authz_policy)
# includes
config.include('pyramid_tm')
config.include('wim_web.database')
config.include('pyramid_mako')
# frontend
config.add_static_view('static',
'wim_web:web/static',
cache_max_age=3600)
# backend
config.scan('wim_web.web.views')
initialize_forms()
return config.make_wsgi_app()
def main(global_config, **settings):
""" This function returns a Pyramid WSGI application.
"""
set_cache_regions_from_settings(settings)
authentication_policy = AuthTktAuthenticationPolicy('seekrit',
callback=groupfinder)
authorization_policy = ACLAuthorizationPolicy()
config = Configurator(settings=settings,
root_factory=RootFactory,
authentication_policy=authentication_policy,
authorization_policy=authorization_policy)
engine = engine_from_config(settings, 'sqlalchemy.')
DBSession.configure(bind=engine)
Base.metadata.bind = engine
config.set_session_factory(session_factory_from_settings(settings))
config.add_mako_renderer('.html')
json_renderer = JSON()
def datetime_adapter(obj, request):
return obj.isoformat()
json_renderer.add_adapter(datetime.datetime, datetime_adapter)
config.add_renderer('json', json_renderer)
# Add static routes (required for static_path in Mako)
config.add_static_view(name=settings.get('webassets.base_url'),
path='static')
config.include(include_views)
config.include(include_css)
config.include(include_js)
config.scan()
return config.make_wsgi_app()
def main(global_config, **settings):
""" This function returns a Pyramid WSGI application.
"""
authn_policy = AuthTktAuthenticationPolicy('seekrit')
authz_policy = ACLAuthorizationPolicy()
my_session_factory = UnencryptedCookieSessionFactoryConfig('itsaseekreet')
config = Configurator(
settings=settings,
root_factory='scribeui_pyramid.modules.app.resources.RootFactory',
authentication_policy=authn_policy,
authorization_policy=authz_policy,
session_factory=my_session_factory)
config.include('pyramid_jinja2')
config.include('.modules')
config.add_jinja2_search_path("scribeui_pyramid:templates")
environment = config.get_jinja2_environment()
environment.globals['time'] = get_rid()
environment.globals['getattr'] = jinja_getattr
config.add_static_view('static',
'scribeui_pyramid:static',
cache_max_age=3600)
return config.make_wsgi_app()
def main(global_config, **settings):
""" This function returns a Pyramid WSGI application.
"""
authn_policy = AuthTktAuthenticationPolicy(
str(uuid4()), callback=group_finder, hashalg='sha512')
authz_policy = ACLAuthorizationPolicy()
config = Configurator(settings=settings,
root_factory='brainbro.models.RootFactory')
config.set_authentication_policy(authn_policy)
config.set_authorization_policy(authz_policy)
config.include('pyramid_jinja2')
config.add_static_view('static', path='static', cache_max_age=3600)
config.add_route('home', '/')
config.add_route('login', '/login')
config.add_route('logout', '/logout')
config.add_route('create_session', '/session/create')
config.add_route('destroy_session', '/session/destroy/{session}')
config.scan()
return config.make_wsgi_app()
def main(global_config, **settings):
config = Configurator(settings=settings,
root_factory='tutorial.models.Root')
# Security policies
authn_policy = AuthTktAuthenticationPolicy(
'sosecret', callback=groupfinder, hashalg='sha512')
authz_policy = ACLAuthorizationPolicy()
config.set_authentication_policy(authn_policy)
config.set_authorization_policy(authz_policy)
config.add_route('wiki_view', '/')
config.add_route('login', '/login')
config.add_route('logout', '/logout')
config.add_route('wikipage_add', '/add')
config.add_route('wikipage_view', '/{uid}')
config.add_route('wikipage_edit', '/{uid}/edit')
config.add_route('wikipage_delete', '/{uid}/delete')
config.add_static_view(name='static', path='tutorial:static')
config.add_static_view('deform_static', 'deform:static/')
config.scan()
return config.make_wsgi_app()
def main(global_config, **settings):
"""This function returns a Pyramid WSGI application."""
authn_policy = AuthTktAuthenticationPolicy(
settings["auth.secret"],
cookie_name="ushauri_" + settings["country"] + "_auth_tkt",
)
authz_policy = ACLAuthorizationPolicy()
config = Configurator(
settings=settings,
authentication_policy=authn_policy,
authorization_policy=authz_policy,
)
apppath = os.path.dirname(os.path.abspath(__file__))
config.include(".models")
# Load and configure the host application
load_environment(settings, config, apppath)
return config.make_wsgi_app()
def main(global_config, **settings):
""" This function returns a Pyramid WSGI application.
"""
engine = engine_from_config(settings, 'sqlalchemy.')
DBSession.configure(bind=engine)
Base.metadata.bind = engine
session_factory = session_factory_from_settings(settings)
authn_policy = AuthTktAuthenticationPolicy('supersecret',
callback=groupfinder)
authz_policy = ACLAuthorizationPolicy()
config = Configurator(settings=settings,
authentication_policy=authn_policy,
authorization_policy=authz_policy,
root_factory=Root)
config.set_session_factory(session_factory)
config.include('pyramid_fanstatic')
config.include('pyramid_beaker')
config.include('pyramid_alfresco.oauth')
config.add_alfresco_login_from_settings(prefix='alfresco.')
config.add_static_view('static', 'static', cache_max_age=3600)
config.add_route('home', '/')
config.add_route('folders', '/sites/{site}/folders')
config.add_route('path', '/path/{path:.*}')
config.add_route('details', '/details/{path:.*}')
config.add_route('delete', '/delete/{path:.*}')
config.add_route('file', '/file/{path:.*}')
config.add_route('createFolder', '/createFolder/{path:.*}')
config.add_route('uploadFile', '/uploadFile/{path:.*}')
config.add_route('docs_home', '/docs')
config.add_route('docs_details', '/docs/details/{id:.*}')
config.add_route('createDoc', '/docs/createDoc')
config.add_route('login', '/login')
config.add_route('logout', '/logout')
config.add_route('oauth', '/alfresco_oauth')
config.scan()
return config.make_wsgi_app()
def main(global_config, **settings):
""" This function returns a Pyramid WSGI application.
"""
engine = engine_from_config(settings, 'sqlalchemy.')
DBSession.configure(bind=engine)
Base.metadata.bind = engine
authentication_policy = AuthTktAuthenticationPolicy('somesecret',
hashalg='sha512')
authorization_policy = ACLAuthorizationPolicy()
config = Configurator(settings=settings,
authentication_policy=authentication_policy,
authorization_policy=authorization_policy)
config.include('pyramid_jinja2')
config.add_static_view('static', 'static', cache_max_age=3600)
config.add_route('home', '/')
config.add_route('blog', '/blog/{id:\d+}/{slug}')
config.add_route('blog_action',
'/blog/{action}',
factory='pyramid_blogr.security.BlogRecordFactory')
config.add_route('auth', '/sign/{action}')
config.scan()
return config.make_wsgi_app()
def main(global_config, **settings):
""" This function returns a Pyramid WSGI application.
"""
engine = get_db_engine()
DBSession.configure(bind=engine)
Base.metadata.bind = engine
authentication_policy = AuthTktAuthenticationPolicy(
AUTH_SECRET,
callback=get_principal_indentifiers,
)
authorization_policy = ACLAuthorizationPolicy()
config = Configurator(
settings=settings,
authentication_policy=authentication_policy,
authorization_policy=authorization_policy,
root_factory=RootFactory,
)
config.add_static_view('static', 'static', cache_max_age=3600)
config.add_static_view(name='media', path=MEDIA_ROOT, cache_max_age=3600)
# Update redis.sessions.url
config.registry.settings['redis.sessions.url'] = get_redis_url()
config.include('pyramid_redis_sessions')
config.include('pyramid_jinja2')
# Add .html extension as a renderer
config.add_jinja2_renderer('.html')
# Scan views for route configuration
config.include('polls.views.polls')
config.include('polls.views.auth')
config.scan()
return config.make_wsgi_app()
