def plugin_load_wsgi():
from pytsite import lang, router
from plugins import settings, auth_ui, auth_google
from . import _driver, _eh, _settings_form, _controllers
# Language globals
lang.register_global(
'auth_ui_google_admin_settings_url',
lambda language, args: settings.form_url('auth_google'))
# Event handlers
router.on_dispatch(_eh.router_dispatch)
# Settings
settings.define('auth_google', _settings_form.Form,
'auth_ui_google@auth_google', 'fa fa-google', 'dev')
try:
auth_ui.register_driver(_driver.UI(auth_google.get_client_id()))
router.handle(_controllers.Authorization,
'/auth_google/authorization',
'auth_ui_google@authorization',
filters=auth_ui.AuthFilter)
except auth_google.error.ClientIdNotDefined:
pass
def plugin_load_wsgi():
from pytsite import router
from . import _controllers
router.handle(_controllers.Download, '/file/download/<uid>',
'file@download')
def plugin_load_wsgi():
from pytsite import cron, events, router
from plugins import http_api, settings, robots_txt, flag
from . import _eh, _controllers, _http_api_controllers, _settings_form
# Events listeners
cron.hourly(_eh.on_cron_hourly)
cron.daily(_eh.on_cron_daily)
on_content_view(_eh.on_content_view)
events.listen('comments@create_comment', _eh.on_comments_create_comment)
flag.on_flag_create(_eh.on_flag_toggle)
flag.on_flag_delete(_eh.on_flag_toggle)
# Routes
router.handle(_controllers.Index, 'content/index/<model>', 'content@index')
# HTTP API endpoints
http_api.handle('PATCH', 'content/view/<model>/<uid>',
_http_api_controllers.PatchViewsCount,
'content@patch_view_count')
http_api.handle('POST', 'content/abuse/<model>/<uid>',
_http_api_controllers.PostAbuse, 'content@post_abuse')
# Settings
settings.define('content', _settings_form.Form, 'content@content',
'fa fa-glass', 'dev')
# Sitemap location in robots.txt
robots_txt.sitemap('/sitemap/index.xml')
def plugin_load_wsgi():
from pytsite import router
from plugins import auth_ui
from . import _driver, _controllers
auth_ui.register_driver(_driver.Password())
router.handle(_controllers.ResetPassword, 'auth_ui_password/reset/<token>', 'auth_ui_password@reset')
def plugin_load_wsgi():
from pytsite import router
from . import _controllers
router.handle(_controllers.PostHook,
'/telegram/hook/<bot_uid>',
'telegram@bot_hook',
methods='POST')
def plugin_load_wsgi():
from pytsite import router
from plugins import admin
from . import _controllers
# Search term route
router.handle(_controllers.SearchTerms, '/taxonomy/search/<model>/<query>',
'taxonomy@search_terms')
# Admin sidebar section
admin.sidebar.add_section('taxonomy', 'taxonomy@taxonomy', 0, 'title')
def plugin_load():
from pytsite import router, tpl
from . import _controllers
# HTTP API entry point route
router.handle(_controllers.Entry,
'/api/<path:http_api_endpoint>',
'http_api@entry',
methods='*')
# Tpl globals
tpl.register_global('http_api_endpoint', endpoint)
def plugin_load():
from pytsite import router
from plugins import permissions, admin
from . import _controllers
# Permissions group
permissions.define_group('content', 'content@content')
# Admin section should exist before any content's models registration
admin.sidebar.add_section('content', 'content@content', 100)
# Routes which must be registered in any environment
router.handle(_controllers.View, 'content/view/<model>/<eid>',
'content@view')
def plugin_load_uwsgi():
from pytsite import lang, router
from plugins import settings
from . import _eh, _settings_form, _controllers
# Lang globals
lang.register_global('facebook_admin_settings_url', lambda language, args: settings.form_url('facebook'))
# Routes
router.handle(_controllers.Authorize, '/facebook/authorize', 'facebook@authorize')
# Settings
settings.define('facebook', _settings_form.Form, 'facebook@facebook', 'fa fa-facebook', 'dev')
# Event handlers
router.on_dispatch(_eh.router_dispatch)
def plugin_load():
from pytsite import router, cleanup
from plugins import odm
from . import _model, _controllers, _eh
# Register ODM models
odm.register_model('file', _model.AnyFileODMEntity)
odm.register_model('file_image', _model.ImageFileODMEntity)
router.handle(
_controllers.Image,
'/image/resize/<int:width>/<int:height>/<p1>/<p2>/<filename>',
'file_storage_odm@image',
defaults={
'width': 0,
'height': 0
})
cleanup.on_cleanup(_eh.pytsite_cleanup)
def plugin_load_wsgi():
from pytsite import router, cron
from plugins import settings, http_api
from . import _eh, _model, _settings_form, _controllers, _http_api_controllers
# Event handlers
cron.every_min(_eh.on_cron_every_min)
# Routes
router.handle(_controllers.Unsubscribe,
'/content_digest/unsubscribe/<sid>',
'content_digest@unsubscribe')
# HTTP API handlers
http_api.handle('POST', 'content_digest/subscribe',
_http_api_controllers.PostSubscribe,
'content_digest@post_subscribe')
# Settings
settings.define('content_digest', _settings_form.Form,
'content_digest@content_digest', 'fa fa-rocket')
def plugin_load_wsgi():
from pytsite import router
from plugins import admin, auth_ui
from . import _controllers, _eh
# Routing
abp = admin.base_path()
router.handle(_controllers.GetForm,
abp + '/settings/<uid>',
'settings@get_form',
filters=auth_ui.AuthFilter)
# Admin sidebar's section
admin.sidebar.add_section('settings', __name__ + '@settings', 2000,
'title')
# Define default application settings form
define('app', _frm.Application, __name__ + '@application', 'fa fa-cube')
# Event handlers
router.on_dispatch(_eh.on_dispatch)
def plugin_load_wsgi():
"""Hook
"""
from pytsite import tpl, router
from plugins import auth_ui, robots_txt
from . import _controllers, _api
bp = base_path()
# 'Miscellaneous' sidebar's section
sidebar.add_section('misc', 'admin@miscellaneous', 500)
# Dashboard route
router.handle(_controllers.Dashboard,
bp,
'admin@dashboard',
filters=auth_ui.AuthFilter)
# Tpl globals
tpl.register_global('admin_base_path', bp)
# robots.txt rules
robots_txt.disallow(bp + '/')
# Preload permanent assets
assetman.preload('twitter-bootstrap', True)
assetman.preload('font-awesome', True)
assetman.preload('css/common.css', True)
assetman.preload('js/index.js', True)
# Register template globals
tpl.register_global(
'language_nav', lambda: widget.select.LanguageNav(
'language-nav', css='navbar-right', dropdown=True))
if plugman.is_installed(['content', 'section', 'article', 'page']):
from plugins import content, section
from . import controllers
router.handle(controllers.Home(), '/', 'home')
# These two routes needed by 'article' plugin as final point while processing request
router.handle(controllers.ContentEntityIndex(),
name='content_entity_index')
router.handle(controllers.ContentEntityView(), name='content_entity_view')
# "Article index by section" route
router.handle('content@index', '/section/<term_alias>',
'article_index_by_section', {
'model': 'article',
'term_field': 'section',
})
# "Article index by tag" route
router.handle('content@index', '/tag/<term_alias>', 'article_index_by_tag',
def plugin_load_wsgi():
from pytsite import router
from plugins import auth_ui, settings, admin, http_api
from . import _frm, _controllers, _http_api_controllers
# Settings form
settings.define('auth', _frm.Settings, 'auth_admin@security', 'fa fa-user', 'dev')
# BAse path for route rules
abp = admin.base_path() + '/auth'
# HTTP API rules
http_api.handle('GET', abp + '/browse/<e_type>', _http_api_controllers.GetBrowserRows, 'auth_admin@browser_rows')
# Admin routes
flt = auth_ui.AuthFilter
router.handle(_controllers.Browser, abp + '/browse/role', 'auth_admin@browse_roles',
{'e_type': 'role'}, filters=flt)
router.handle(_controllers.Browser, abp + '/browse/user', 'auth_admin@browse_users',
{'e_type': 'user'}, filters=flt)
router.handle(_controllers.ModifyForm, abp + '/modify/role/<uid>', 'auth_admin@form_role_modify',
{'e_type': 'role'}, filters=flt)
router.handle(_controllers.ModifyForm, abp + '/modify/user/<uid>', 'auth_admin@form_user_modify',
{'e_type': 'user'}, filters=flt)
router.handle(_controllers.DeleteForm, abp + '/delete/role', 'auth_admin@form_role_delete',
{'e_type': 'role'}, ('GET', 'POST'), flt)
router.handle(_controllers.DeleteForm, abp + '/delete/user', 'auth_admin@form_user_delete',
{'e_type': 'user'}, ('GET', 'POST'), flt)
# 'Security' admin sidebar section
admin.sidebar.add_section('security', 'auth_admin@security', 1000)
# 'Users' admin sidebar menu
admin.sidebar.add_menu('security', 'users', 'auth_admin@users', router.rule_path('auth_admin@browse_users'),
'fa fa-users', weight=10)
# 'Roles' admin sidebar menu
admin.sidebar.add_menu('security', 'roles', 'auth_admin@roles', router.rule_path('auth_admin@browse_roles'),
'fa fa-key', weight=20, roles='dev')
def plugin_load_wsgi():
from pytsite import router
from plugins import admin, http_api, auth_ui
from . import _controllers, _http_api_controllers
abp = admin.base_path()
# Browse route
router.handle(_controllers.Browse,
abp + '/odm_ui/<model>',
'odm_ui@admin_browse',
filters=auth_ui.AuthFilter)
router.handle(_controllers.Browse,
'odm_ui/<model>',
'odm_ui@browse',
filters=auth_ui.AuthFilter)
# Create/modify form routes
router.handle(_controllers.Form,
abp + '/odm_ui/<model>/modify/<eid>',
'odm_ui@admin_m_form',
filters=auth_ui.AuthFilter)
router.handle(_controllers.Form,
'odm_ui/<model>/modify/<eid>',
'odm_ui@m_form',
filters=auth_ui.AuthFilter)
# Delete form route
router.handle(_controllers.Form,
abp + '/odm_ui/<model>/delete',
'odm_ui@admin_d_form',
methods=('GET', 'POST'),
filters=auth_ui.AuthFilter)
router.handle(_controllers.Form,
'odm_ui/<model>/delete',
'odm_ui@d_form',
methods=('GET', 'POST'),
filters=auth_ui.AuthFilter)
# HTTP API handlers
http_api.handle('GET', 'odm_ui/browser/rows/<model>',
_http_api_controllers.GetBrowserRows,
'odm_ui@get_browser_rows')
http_api.handle('PUT', 'odm_ui/browser/rows/<model>',
_http_api_controllers.PutBrowserRows,
'odm_ui@put_browser_rows')
http_api.handle('GET', 'odm_ui/widget/entity_select',
_http_api_controllers.GetWidgetEntitySelect,
'odm_ui@widget_entity_select')
def theme_load_wsgi():
from pytsite import reg, tpl, router, events
from . import controllers, eh
# Home page route
router.handle(controllers.Home, '/', 'home')
# Following routes required by 'content' plugin as final point while processing request
router.handle(controllers.ContentIndex, name='content_index')
router.handle(controllers.ContentView, name='content_view')
router.handle(controllers.ContentModify, name='content_modify')
# "Article index by section" route
router.handle('content@index', '/section/<term_alias>',
'article_index_by_section', {
'model': 'article',
'term_field': 'section',
})
# "Article index by tag" route
router.handle('content@index', '/tag/<term_alias>', 'article_index_by_tag',
{
'model': 'article',
'term_field': 'tags',
})
# "Article index by author" route
router.handle('content@index', '/author/<author>',
'article_index_by_author', {
'model': 'article',
})
# Event handlers
router.on_dispatch(eh.on_router_dispatch)
tpl.on_render(eh.on_tpl_render)
events.listen('[email protected]_widgets.theme',
eh.settings_form_setup_widgets_setup_widgets_theme)
# Force Twitter Bootstrap v3 on the password authentication page
reg.put('auth_ui_password.twitter_bootstrap_version', 3)
def plugin_load_wsgi():
from pytsite import router
from plugins import robots_txt, auth, http_api
from . import _controllers, _http_api_controllers, _eh
# Routes
bp = base_path()
router.handle(_controllers.Form, bp + '/sign-in',
'auth_ui@sign_in_default')
router.handle(_controllers.Form, bp + '/sign-in/<driver>',
'auth_ui@sign_in')
router.handle(_controllers.Form, bp + '/sign-up',
'auth_ui@sign_up_default')
router.handle(_controllers.Form, bp + '/sign-up/<driver>',
'auth_ui@sign_up')
router.handle(_controllers.Form, bp + '/restore/<driver>',
'auth_ui@restore_account')
router.handle(_controllers.SignUpConfirm, bp + '/sign-up/confirm/<code>',
'auth_ui@sign_up_confirm')
router.handle(_controllers.SignOut, bp + '/sign-out', 'auth_ui@sign_out')
router.handle(_controllers.UserProfileView, bp + '/user/<nickname>',
'auth_ui@user_profile_view')
router.handle(_controllers.UserProfileModify, bp + '/user/<nickname>/edit',
'auth_ui@user_profile_modify')
# HTTP API routes
http_api.handle('GET', 'auth_ui/widget/user_select',
_http_api_controllers.GetWidgetUserSelect,
'auth_ui@get_widget_user_select')
# Events handlers
auth.on_sign_up(_eh.on_auth_sign_up)
auth.on_user_status_change(_eh.on_auth_user_status_change)
auth.on_user_as_jsonable(_eh.on_auth_user_as_jsonable)
# robots.txt rules
robots_txt.disallow(bp + '/')
