def on_router_dispatch():
try:
api_key = google_maps.helpers.get_google_api_key()
metatag.t_set('pytsite-google-maps-api-key', api_key)
except google_maps.error.GoogleApiKeyNotDefined:
if auth.get_current_user().has_role('dev'):
router.session().add_warning_message(lang.t('google_maps_ui@plugin_setup_required_warning'))
def exec(self) -> str:
# Get browser
browser = _api.get_browser(self.arg('model'))
# Set page title
metatag.t_set('title', browser.title)
# Render admin template
if self.arg('_pytsite_router_rule_name') == 'odm_ui@admin_browse':
return admin.render(
tpl.render('odm_ui@browse', {'browser': browser}))
# Render user template
elif self.arg('_pytsite_router_rule_name') == 'odm_ui@browse':
try:
# Call a controller provided by application
self.args['browser'] = browser
return router.call('odm_ui_browse', self.args)
except routing.error.RuleNotFound:
# Render a template provided by application
return tpl.render('odm_ui/browse', {'browser': browser})
# Unknown rule
else:
raise self.not_found()
def router_dispatch():
"""'pytsite.router.dispatch' event handler.
"""
try:
_metatag.t_set('fb:app_id', _api.get_app_id())
except (_error.AppIdNotSet, _error.AppSecretNotSet):
if _auth.get_current_user().is_dev:
_router.session().add_warning_message(
_lang.t('facebook@plugin_setup_required_warning'))
def router_dispatch():
"""pytsite.router.dispatch
"""
try:
client_id = auth_google.get_client_id()
metatag.t_set('google-signin-client_id', client_id)
metatag.t_set('pytsite-auth-google-client-id', client_id)
except auth_google.error.ClientIdNotDefined:
if auth.get_current_user().has_role('dev'):
router.session().add_warning_message(lang.t('auth_ui_google@plugin_setup_required_warning'))
def exec(self) -> str:
try:
self.args['form'] = _api.user_form(
self.request,
auth.get_user(nickname=self.arg('nickname')).uid)
except auth.error.UserNotFound:
raise self.not_found()
metatag.t_set('title', lang.t('auth_ui@profile_edit_title'))
try:
return router.call('auth_ui_user_profile_modify', self.args)
except routing.error.RuleNotFound:
return tpl.render('auth_ui/user-profile-modify', self.args)
def exec(self):
if not auth.get_current_user().is_admin:
raise self.forbidden()
eids = self.arg('eids')
if isinstance(eids, str):
eids = util.cleanup_list(eids.split(','))
form = _frm.DeleteEntities(self.request,
e_type=self.arg('e_type'),
eids=eids)
form.hide_title = True
metatag.t_set('title', form.title)
return admin.render(tpl.render('auth_admin@form', {'form': form}))
def exec(self):
if not auth.get_current_user().is_admin:
raise self.forbidden()
e_type = self.arg('e_type')
if e_type == 'role':
metatag.t_set('title', lang.t('auth_admin@roles'))
form = _frm.BrowseRoles(self.request)
elif e_type == 'user':
metatag.t_set('title', lang.t('auth_admin@users'))
form = _frm.BrowseUsers(self.request)
else:
raise self.server_error('Unknown auth entity type')
return admin.render(tpl.render('auth_admin@form', {'form': form}))
def exec(self) -> Union[str, http.RedirectResponse]:
# Redirect to the base URL if user is already authenticated
if not auth.get_current_user().is_anonymous:
return self.redirect(self.arg('__redirect', router.base_url()))
# Determine driver's name from argument or get default
try:
driver_name = self.arg('driver', _api.get_driver().name)
except auth.error.DriverNotRegistered:
raise self.not_found()
rule_name = self.arg('_pytsite_router_rule_name')
if 'sign_in' in rule_name:
form_type = 'sign-in'
form = _api.sign_in_form(self.request, driver_name)
elif 'sign_up' in rule_name:
# Check if sign up is enabled
if not auth.is_sign_up_enabled():
raise self.not_found()
form_type = 'sign-up'
form = _api.sign_up_form(self.request, driver_name)
elif 'restore_account' in rule_name:
form_type = 'restore-account'
form = _api.restore_account_form(self.request, driver_name)
form.redirect = router.base_url()
else:
raise ValueError('Unsupported form type')
if not form.redirect:
form.redirect = router.base_url()
metatag.t_set('title', form.title)
tpl_args = {
'driver': driver_name,
'form_type': form_type,
'form': form,
}
try:
return router.call('auth_ui_form', tpl_args)
except routing.error.RuleNotFound:
return tpl.render('auth_ui/form', tpl_args)
def exec(self) -> str:
uid = self.arg('uid')
# Load setting definition
setting_def = _api.get_definition(uid)
# Update page's title
metatag.t_set('title', lang.t(setting_def['title']))
content = setting_def['content']
if issubclass(content, _frm.Form):
return admin.render(
tpl.render('settings@form',
{'form': content(self.request, setting_uid=uid)}))
elif callable(content):
return admin.render(content())
else:
return content
def exec(self):
form = _frm.SetNewPassword(self.request, token=self.arg('token'))
metatag.t_set('title', form.title)
tpl_args = {
'driver': 'password',
'form_type': 'reset-password',
'form': form,
}
# Try to render tpl provided by application
try:
return tpl.render('auth_ui/form', tpl_args)
# Render auth_ui plugin's built-in tpl
except tpl.error.TemplateNotFound:
return tpl.render('auth_ui@form', tpl_args)
def exec(self):
if not auth.get_current_user().is_admin:
raise self.forbidden()
e_type = self.arg('e_type')
uid = self.arg('uid')
if e_type == 'role':
metatag.t_set(
'title',
lang.t('auth_admin@' +
('create_role' if uid == '0' else 'modify_role')))
form = auth_ui.role_form(self.request, role_uid=uid)
elif e_type == 'user':
metatag.t_set(
'title',
lang.t('auth_admin@' +
('create_user' if uid == '0' else 'modify_user')))
form = auth_ui.user_form(self.request, user_uid=uid)
else:
raise self.server_error('Unknown entity type')
return admin.render(tpl.render('auth_admin@form', {'form': form}))
def exec(self) -> str:
try:
user = auth.get_user(nickname=self.arg('nickname'))
except auth.error.UserNotFound:
raise self.not_found()
if not user.is_active:
raise self.not_found()
c_user = auth.get_current_user()
if not user.is_public and not (c_user == user or c_user.is_admin):
raise self.not_found()
self.args['user'] = user
metatag.t_set(
'title',
lang.t('auth_ui@profile_view_title',
{'name': user.first_last_name}))
try:
return router.call('auth_ui_user_profile_view', self.args)
except routing.error.RuleNotFound:
return tpl.render('auth_ui/user-profile-view', self.args)
def exec(self) -> str:
rule_name = self.arg('_pytsite_router_rule_name') # type: str
model = self.arg('model')
# Get form
if rule_name.endswith('m_form'):
try:
eid = self.arg('eid')
form = _api.get_m_form(model,
eid if eid != '0' else None,
hide_title=True)
metatag.t_set('title', form.title)
except errors.NotFound as e:
raise self.not_found(e)
elif rule_name.endswith('d_form'):
eids = self.arg('ids', []) or self.arg('eids', [])
form = _api.get_d_form(model, eids, hide_title=True)
else:
raise self.not_found()
metatag.t_set('title', form.title)
# Render admin template
if 'admin' in rule_name:
return admin.render(tpl.render('odm_ui@form', {'form': form}))
# Render user template
else:
try:
# Call a controller provided by application
self.args['form'] = form
return router.call('odm_ui_form', self.args)
except routing.error.RuleNotFound:
# Render a template provided by application
return tpl.render('odm_ui/form', {'form': form})
def on_dispatch():
settings = reg.get('app')
# Add meta tags for home page
if settings and router.is_base_url():
lng = lang.get_current()
for s_key in ['title', 'description', 'keywords']:
s_full_key = 'home_{}_{}'.format(s_key, lng)
if s_full_key in settings:
s_val = settings[s_full_key]
if isinstance(s_val, list):
s_val = ','.join(s_val)
metatag.t_set(s_key, s_val)
if s_key in ['title', 'description']:
metatag.t_set('og:' + s_key, s_val)
metatag.t_set('twitter:' + s_key, s_val)
def on_router_dispatch():
"""pytsite.router.dispatch
"""
if not assetman.is_package_registered(_api.get().package_name):
return
# Set current theme package
metatag.t_set('pytsite-theme', _api.get().package_name)
# Set favicon URL
favicon_fid = reg.get('theme.favicon')
if favicon_fid:
try:
f = file.get(favicon_fid)
metatag.t_set('link', rel='icon', type=f.mime, href=f.get_url(width=50, height=50))
except file.error.FileNotFound:
pass
else:
metatag.t_set('link', rel='icon', type='image/png', href=assetman.url('$theme@img/favicon.png'))
def exec(self):
from . import _api
model = self.arg('model')
entity = _api.find(model, status='*', check_publish_time=False) \
.eq('_id', self.arg('eid')) \
.first() # type: _model.ContentWithURL
# Check entity existence
if not entity:
raise self.not_found()
# Check permissions
if not entity.odm_auth_check_entity_permissions(CONTENT_PERM_VIEW):
raise self.not_found()
# Show non-published entities only to authors and users who can edit or delete them
c_user = auth.get_current_user()
if (entity.has_field('publish_time') and entity.publish_time > datetime.now()) or \
(entity.has_field('status') and entity.status in (CONTENT_STATUS_UNPUBLISHED, CONTENT_STATUS_WAITING)):
if not (entity.author == c_user
or entity.odm_auth_check_entity_permissions(
[PERM_MODIFY, PERM_DELETE])):
raise self.not_found()
# Show warnings about unpublished entities
if entity.has_field(
'publish_time') and entity.publish_time > datetime.now():
router.session().add_warning_message(
lang.t('content@content_warning_future_publish_time'))
if entity.has_field('status') and entity.status in (
CONTENT_STATUS_UNPUBLISHED, CONTENT_STATUS_WAITING):
router.session().add_warning_message(
lang.t('content@content_status_warning_{}'.format(
entity.status)))
# Breadcrumb
breadcrumb = widget.select.Breadcrumb('content-index-breadcrumb')
breadcrumb.append_item(lang.t('content@home_page'), router.base_url())
entity.content_breadcrumb(breadcrumb)
# Meta title
if entity.has_field('title'):
title = entity.title
metatag.t_set('title', title)
metatag.t_set('og:title', title)
metatag.t_set('twitter:title', title)
# Meta description
if entity.has_field('description'):
description = entity.f_get('description')
metatag.t_set('description', description)
metatag.t_set('og:description', description)
metatag.t_set('twitter:description', description)
# Meta keywords
if entity.has_field('tags'):
metatag.t_set('keywords', entity.f_get('tags', as_string=True))
# Meta image
if entity.has_field('images') and entity.images:
metatag.t_set('twitter:card', 'summary_large_image')
image_w = 900
image_h = 500
image_url = entity.images[0].get_url(width=image_w, height=image_h)
metatag.t_set('og:image', image_url)
metatag.t_set('og:image:width', str(image_w))
metatag.t_set('og:image:height', str(image_h))
metatag.t_set('twitter:image', image_url)
else:
metatag.t_set('twitter:card', 'summary')
# Various metatags
metatag.t_set('og:type', 'article')
metatag.t_set('og:url', entity.url)
metatag.t_set('article:publisher', entity.url)
# 'Author' metatag
if entity.has_field('author') and entity.author:
metatag.t_set('author', entity.author.first_last_name)
metatag.t_set('article:author', entity.author.first_last_name)
# Alternate languages URLs
for lng in lang.langs(False):
f_name = 'localization_' + lng
if entity.has_field(f_name) and entity.f_get(f_name):
hreflang.put(lng, entity.f_get(f_name).url)
else:
hreflang.remove(lng)
# Update args
self.args.update({
'entity': entity,
'breadcrumb': breadcrumb,
})
# Notify listeners
events.fire('content@view', entity=entity)
try:
# Call a controller provided by application
return router.call('content_view', self.args)
except routing.error.RuleNotFound:
# Render a template provided by application
return tpl.render('content/view', self.args)
def get_sign_in_form(self, request: http.Request, **kwargs) -> form.Form:
"""Get sign in form
"""
metatag.t_set('google-signin-client_id', self._client_id)
return _SignInForm(request, client_id=self._client_id, **kwargs)
def exec(self):
# Delayed import to prevent circular dependency
from . import _api
# Checking if the model is registered
model = self.arg('model')
if not _api.is_model_registered(model):
raise self.not_found()
# Getting finder
f = _api.find(model)
# Breadcrumb
breadcrumb = widget.select.Breadcrumb('content-index-breadcrumb')
breadcrumb.append_item(lang.t('content@home_page'), router.base_url())
# Filter by term
term_field_name = self.arg('term_field')
term_alias = self.arg('term_alias')
term = None
if term_field_name and f.mock.has_field(term_field_name):
term_field = f.mock.get_field(
term_field_name) # type: odm.field.Ref
if term_alias and term_field.model:
for term_model in term_field.model:
term = taxonomy.find(term_model).eq('alias',
term_alias).first()
if term:
self.args['term'] = term
if isinstance(f.mock.fields[term_field_name],
odm.field.Ref):
f.eq(term_field_name, term)
elif isinstance(f.mock.fields[term_field_name],
odm.field.RefsList):
f.inc(term_field_name, term)
metatag.t_set('title', term.title)
breadcrumb.append_item(term.title)
else:
raise self.not_found()
else:
raise self.not_found()
# Filter by author
author_nickname = self.arg('author')
if author_nickname:
try:
author = auth.get_user(nickname=author_nickname)
f.eq('author', author.uid)
self.args['author'] = author
metatag.t_set(
'title',
lang.t('content@articles_of_author',
{'name': author.first_last_name}))
if term:
breadcrumb.pop_item()
breadcrumb.append_item(
term.title,
router.rule_url(
'content@index', {
'model': model,
'term_field': term_field_name,
'term_alias': term_alias,
}))
breadcrumb.append_item(author.first_last_name)
except auth.error.UserNotFound:
raise self.not_found()
self.args.update({
'finder': f,
'breadcrumb': breadcrumb,
})
try:
# Call a controller provided by application
return router.call('content_index', self.args)
except routing.error.RuleNotFound:
# Render a template provided by application
return tpl.render('content/index', self.args)
