357 lines
13 KiB
Python
357 lines
13 KiB
Python
# w.c.s. - web application for online forms
|
|
# Copyright (C) 2005-2010 Entr'ouvert
|
|
#
|
|
# This program is free software; you can redistribute it and/or modify
|
|
# it under the terms of the GNU General Public License as published by
|
|
# the Free Software Foundation; either version 2 of the License, or
|
|
# (at your option) any later version.
|
|
#
|
|
# This program is distributed in the hope that it will be useful,
|
|
# but WITHOUT ANY WARRANTY; without even the implied warranty of
|
|
# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
|
|
# GNU General Public License for more details.
|
|
#
|
|
# You should have received a copy of the GNU General Public License
|
|
# along with this program; if not, see <http://www.gnu.org/licenses/>.
|
|
|
|
import io
|
|
import os
|
|
import re
|
|
|
|
import django.template
|
|
from django.template import TemplateSyntaxError as DjangoTemplateSyntaxError
|
|
from django.template import VariableDoesNotExist as DjangoVariableDoesNotExist
|
|
from django.template import engines
|
|
from django.template.loader import render_to_string
|
|
from django.utils.encoding import force_text, smart_text
|
|
from quixote import get_publisher, get_request, get_response, get_session
|
|
from quixote.html import TemplateIO, htmlescape, htmltext
|
|
|
|
from . import ezt, force_str
|
|
|
|
|
|
def get_theme_directory(theme_id):
|
|
system_location = os.path.join(get_publisher().data_dir, 'themes', theme_id)
|
|
local_location = os.path.join(get_publisher().app_dir, 'themes', theme_id)
|
|
if os.path.exists(local_location):
|
|
location = local_location
|
|
elif os.path.exists(system_location):
|
|
location = system_location
|
|
else:
|
|
return None
|
|
|
|
while os.path.islink(location):
|
|
location = os.path.join(os.path.dirname(location), os.readlink(location))
|
|
|
|
if not os.path.exists(location):
|
|
return None
|
|
|
|
return location
|
|
|
|
|
|
def html_top(title=None, default_org=None):
|
|
if not hasattr(get_response(), 'filter'):
|
|
get_response().filter = {}
|
|
get_response().filter['title'] = title
|
|
get_response().filter['default_org'] = default_org
|
|
|
|
|
|
def error_page(error_message, error_title=None, location_hint=None):
|
|
from . import _
|
|
|
|
if not error_title:
|
|
error_title = _('Error')
|
|
|
|
kwargs = {'title': error_title}
|
|
|
|
if get_request().is_in_backoffice() and get_request().user and get_request().user.can_go_in_backoffice():
|
|
from wcs.qommon.backoffice.menu import html_top as backoffice_html_top
|
|
|
|
get_response().add_javascript(['jquery.js', 'qommon.js', 'gadjo.js'])
|
|
backoffice_html_top(section='', **kwargs)
|
|
|
|
context = get_decorate_vars('', get_response())
|
|
context['error_message'] = error_message
|
|
return QommonTemplateResponse(
|
|
templates=['wcs/backoffice/error.html'], context=context, is_django_native=True
|
|
)
|
|
|
|
r = TemplateIO(html=True)
|
|
html_top(**kwargs)
|
|
r += htmltext('<div class="error-page">')
|
|
r += htmltext('<p>%s</p>') % error_message
|
|
continue_link = htmltext('<a href="%s">%s</a>') % (get_publisher().get_root_url(), _('the homepage'))
|
|
r += htmltext('<p>%s</p>') % htmltext(_('Continue to %s')) % continue_link
|
|
r += htmltext('</div>')
|
|
return htmltext(r.getvalue())
|
|
|
|
|
|
def get_decorate_vars(body, response, generate_breadcrumb=True, **kwargs):
|
|
from .publisher import get_cfg
|
|
|
|
if response.content_type != 'text/html':
|
|
return {'body': body}
|
|
|
|
body = str(body)
|
|
if get_request().get_header('x-popup') == 'true':
|
|
return {'body': body}
|
|
|
|
kwargs = {}
|
|
for k, v in response.filter.items():
|
|
if v:
|
|
kwargs[k] = str(v)
|
|
if 'lang' not in kwargs and hasattr(get_request(), 'language'):
|
|
response.filter['lang'] = get_request().language
|
|
|
|
if ('rel="popup"' in body or 'rel="popup"' in kwargs.get('sidebar', '')) or (
|
|
'data-popup' in body or 'data-popup' in kwargs.get('sidebar', '')
|
|
):
|
|
response.add_javascript(['popup.js', 'widget_list.js'])
|
|
|
|
onload = kwargs.get('onload')
|
|
org_name = get_cfg('sp', {}).get('organization_name', kwargs.get('default_org', get_publisher().APP_NAME))
|
|
site_name = get_cfg('misc', {}).get('sitename', org_name)
|
|
|
|
current_theme = get_cfg('branding', {}).get('theme', get_publisher().default_theme)
|
|
|
|
if kwargs.get('title'):
|
|
title = kwargs.get('title')
|
|
page_title = '%s - %s' % (site_name, title)
|
|
title_or_orgname = title
|
|
else:
|
|
page_title = site_name
|
|
title = None
|
|
title_or_orgname = site_name
|
|
script = kwargs.get('script') or ''
|
|
script += response.get_css_includes_for_header()
|
|
script += response.get_javascript_for_header()
|
|
|
|
try:
|
|
user = get_request().user
|
|
except Exception:
|
|
user = None
|
|
|
|
if type(user) in (int, str) and get_session():
|
|
try:
|
|
user = get_session().get_user_object()
|
|
except KeyError:
|
|
pass
|
|
|
|
root_url = get_publisher().get_application_static_files_root_url()
|
|
|
|
theme_url = '%sthemes/%s' % (root_url, current_theme)
|
|
|
|
is_in_backoffice = response.filter.get('admin_ezt')
|
|
|
|
if is_in_backoffice:
|
|
header_menu = kwargs.get('header_menu')
|
|
user_info = kwargs.get('user_info')
|
|
page_title = kwargs.get('sitetitle', '') + kwargs.get('title', '')
|
|
subtitle = kwargs.get('subtitle')
|
|
sidebar = kwargs.get('sidebar')
|
|
css = root_url + get_publisher().qommon_static_dir + get_publisher().qommon_admin_css
|
|
extra_head = get_publisher().get_site_option('backoffice_extra_head')
|
|
app_label = get_publisher().get_site_option('app_label') or 'w.c.s.'
|
|
else:
|
|
css = root_url + 'themes/%s/%s.css' % (current_theme, get_publisher().APP_NAME)
|
|
|
|
# this variable is kept in locals() as it was once part of the default
|
|
# template and existing installations may have template changes that
|
|
# still have it.
|
|
prelude = ''
|
|
|
|
if generate_breadcrumb:
|
|
breadcrumb = ''
|
|
if hasattr(response, 'breadcrumb') and response.breadcrumb:
|
|
s = []
|
|
path = root_url
|
|
if is_in_backoffice:
|
|
path += response.breadcrumb[0][0]
|
|
response.breadcrumb = response.breadcrumb[1:]
|
|
total_len = sum(len(str(x[1])) for x in response.breadcrumb if x[1] is not None)
|
|
for component, label in response.breadcrumb:
|
|
if component.startswith('http:') or component.startswith('https:'):
|
|
s.append('<a href="%s">%s</a>' % (component, label))
|
|
continue
|
|
if label is not None:
|
|
if isinstance(label, str):
|
|
label = htmlescape(label)
|
|
if not is_in_backoffice and (
|
|
total_len > 80 and len(label) > 10 and response.breadcrumb[-1] != (component, label)
|
|
):
|
|
s.append('<a href="%s%s" title="%s">%s</a>' % (path, component, label, '...'))
|
|
else:
|
|
s.append('<a href="%s%s">%s</a>' % (path, component, label))
|
|
path += component.split('#')[0] # remove anchor for next parts
|
|
breadcrumb = ' <span class="separator">></span> '.join(s)
|
|
|
|
vars = response.filter.copy()
|
|
vars.update(get_publisher().substitutions.get_context_variables())
|
|
vars.update(locals())
|
|
return vars
|
|
|
|
|
|
def render(template_name, context):
|
|
request = getattr(get_request(), 'django_request', None)
|
|
result = render_to_string(template_name, context, request=request)
|
|
return htmltext(force_str(result))
|
|
|
|
|
|
class QommonTemplateResponse:
|
|
is_django_native = False
|
|
|
|
def __init__(self, templates, context, is_django_native=False):
|
|
self.templates = templates
|
|
self.context = context
|
|
self.is_django_native = is_django_native
|
|
|
|
def add_media(self):
|
|
# run add_media so we get them in the page <head>
|
|
if 'html_form' in self.context:
|
|
self.context['html_form'].add_media()
|
|
if 'form' in self.context and hasattr(self.context['form'], 'add_media'):
|
|
# legacy name, conflicting with formdata "form*" variables
|
|
self.context['form'].add_media()
|
|
|
|
|
|
class TemplateError(Exception):
|
|
def __init__(self, msg, params=()):
|
|
self.msg = msg
|
|
self.params = params
|
|
|
|
def __str__(self):
|
|
from . import misc
|
|
|
|
return misc.site_encode(smart_text(self.msg) % self.params)
|
|
|
|
|
|
def ezt_raises(exception, on_parse=False):
|
|
from . import _
|
|
|
|
parts = []
|
|
parts.append(
|
|
{
|
|
ezt.ArgCountSyntaxError: _('wrong number of arguments'),
|
|
ezt.UnknownReference: _('unknown reference'),
|
|
ezt.NeedSequenceError: _('sequence required'),
|
|
ezt.UnclosedBlocksError: _('unclosed block'),
|
|
ezt.UnmatchedEndError: _('unmatched [end]'),
|
|
ezt.UnmatchedElseError: _('unmatched [else]'),
|
|
ezt.BaseUnavailableError: _('unavailable base location'),
|
|
ezt.BadFormatConstantError: _('bad format constant'),
|
|
ezt.UnknownFormatConstantError: _('unknown format constant'),
|
|
}.get(exception.__class__, _('unknown error'))
|
|
)
|
|
if exception.line is not None:
|
|
parts.append(
|
|
_('at line %(line)d and column %(column)d')
|
|
% {'line': exception.line + 1, 'column': exception.column + 1}
|
|
)
|
|
if on_parse:
|
|
message = _('syntax error in ezt template: %s')
|
|
else:
|
|
message = _('failure to render ezt template: %s')
|
|
raise TemplateError(message % ' '.join([str(x) for x in parts]))
|
|
|
|
|
|
class Template:
|
|
def __init__(self, value, raises=False, ezt_format=ezt.FORMAT_RAW, ezt_only=False, autoescape=True):
|
|
'''Guess kind of template (Django or ezt), and parse it'''
|
|
self.value = value
|
|
self.raises = raises
|
|
|
|
if ('{{' in value or '{%' in value) and not ezt_only: # Django template
|
|
self.format = 'django'
|
|
self.render = self.django_render
|
|
if autoescape is False:
|
|
value = '{%% autoescape off %%}%s{%% endautoescape %%}' % value
|
|
try:
|
|
self.template = engines['django'].from_string(value)
|
|
except DjangoTemplateSyntaxError as e:
|
|
if raises:
|
|
from . import _
|
|
|
|
raise TemplateError(_('syntax error in Django template: %s'), e)
|
|
self.render = self.null_render
|
|
|
|
elif '[' in value and '<!--[if gte' not in value:
|
|
# ezt template with protection against office copy/paste.
|
|
self.format = 'ezt'
|
|
self.render = self.ezt_render
|
|
self.template = ezt.Template(compress_whitespace=False)
|
|
try:
|
|
self.template.parse(value, base_format=ezt_format)
|
|
except ezt.EZTException as e:
|
|
if raises:
|
|
ezt_raises(e, on_parse=True)
|
|
self.render = self.null_render
|
|
|
|
else:
|
|
self.format = 'plain'
|
|
self.render = self.null_render
|
|
|
|
def null_render(self, context=None):
|
|
return str(self.value)
|
|
|
|
def django_render(self, context=None):
|
|
from wcs.carddef import CardDefDoesNotExist
|
|
from wcs.formdef import FormDefDoesNotExist
|
|
|
|
context = context or {}
|
|
try:
|
|
rendered = self.template.render(context)
|
|
except (DjangoTemplateSyntaxError, DjangoVariableDoesNotExist) as e:
|
|
if self.raises:
|
|
from . import _
|
|
|
|
raise TemplateError(_('failure to render Django template: %s'), e)
|
|
return self.value
|
|
except (FormDefDoesNotExist, CardDefDoesNotExist) as e:
|
|
if get_request() and getattr(get_request(), 'inspect_mode', False):
|
|
raise
|
|
get_publisher().record_error(exception=e, notify=True)
|
|
return self.value
|
|
rendered = str(rendered)
|
|
if context.get('allow_complex'):
|
|
return rendered
|
|
return re.sub(r'[\uE000-\uF8FF]', '', rendered)
|
|
|
|
def ezt_render(self, context=None):
|
|
context = context or {}
|
|
fd = io.StringIO()
|
|
try:
|
|
self.template.generate(fd, context)
|
|
except ezt.EZTException as e:
|
|
if self.raises:
|
|
ezt_raises(e)
|
|
else:
|
|
return self.value
|
|
return force_str(fd.getvalue())
|
|
|
|
@classmethod
|
|
def is_template_string(cls, string, ezt_support=True):
|
|
return isinstance(string, str) and (
|
|
'{{' in string or '{%' in string or ('[' in string and ezt_support)
|
|
)
|
|
|
|
|
|
# monkey patch django template Variable resolution to convert legacy
|
|
# strings to unicode
|
|
variable_resolve_orig = django.template.base.Variable.resolve
|
|
|
|
|
|
def variable_resolve(self, context):
|
|
try:
|
|
value = variable_resolve_orig(self, context)
|
|
except UnicodeEncodeError:
|
|
# don't crash on non-ascii variable names
|
|
return context.template.engine.string_if_invalid
|
|
if isinstance(value, str):
|
|
return force_text(value, 'utf-8')
|
|
return value
|
|
|
|
|
|
if not getattr(django.template.base.Variable, 'monkey_patched', False):
|
|
django.template.base.Variable.resolve = variable_resolve
|
|
django.template.base.Variable.monkey_patched = True
|