def get_template_sources(self, template_name, template_dirs=None):
"""
Return possible absolute paths to "template_name" in the current theme
and any themes it inherits from.
Any paths that don't lie inside one of the template dirs are excluded
from the result set for security reasons.
"""
request = get_current_request()
mobile = (request and request.mobile)
active_theme = get_active_theme()
theme = get_theme(active_theme)
cached_theme, theme_search_info = self.cached_theme_search_info
# If the theme changed or the user is previewing a different theme,
# recalculate theme_search_info.
# Note that this Loader instance may be shared between multiple threads,
# so you must be careful when reading/writing
# self.cached_theme_search_info to ensure that writes in one thread
# cannot cause unexpected behavior in another thread that is
# reading/writing self.cached_theme_search_info at the same time.
if cached_theme != theme:
theme_search_info = []
for cur_theme in get_theme_search_order(theme):
if is_builtin_theme(cur_theme) or not settings.USE_S3_THEME:
theme_search_info.append(
(cur_theme, get_theme_root(cur_theme), False))
else:
theme_search_info.append((cur_theme, cur_theme, True))
if theme == active_theme:
self.cached_theme_search_info = (theme, theme_search_info)
for cur_theme, cur_theme_root, use_s3_theme in theme_search_info:
for template_path in (['mobile', 'templates']
if mobile else ['templates']):
if not use_s3_theme:
try:
template_file = safe_join(cur_theme_root,
template_path, template_name)
except SuspiciousFileOperation:
# The joined path was located outside of template_path,
# although it might be inside another one, so this isn't
# fatal.
continue
else:
template_file = os.path.join(cur_theme_root, template_path,
template_name)
origin = Origin(name=template_file,
template_name=template_name,
loader=self)
origin.theme = cur_theme
origin.use_s3_theme = use_s3_theme
yield origin
def get_template_path(template_dir, template_name, loader=None):
"""Return Origin object with template file path"""
return Origin(
name=join(template_dir, template_name),
template_name=template_name,
loader=loader,
)
def load_template(self, template_name, template_dirs=None):
warnings.warn(
'The load_template() method is deprecated. Use get_template() '
'instead.',
RemovedInDjango21Warning,
)
source, display_name = self.load_template_source(
template_name,
template_dirs,
)
origin = Origin(
name=display_name,
template_name=template_name,
loader=self,
)
try:
template = Template(source, origin, template_name, self.engine)
except TemplateDoesNotExist:
# If compiling the template we found raises TemplateDoesNotExist,
# back off to returning the source and display name for the
# template we were asked to load. This allows for correct
# identification of the actual template that does not exist.
return source, display_name
else:
return template, None
def get_template_sources(self,
template_name,
template_dirs=None,
app_label=None,
model_name=None):
"""
Return an Origin object pointing to an absolute path in each directory
in template_dirs. For security reasons, if a path doesn't lie inside
one of the template_dirs it is excluded from the result set.
Source: django.template.loaders.filesystem.Loader
Hard override accepts app_label and model_name
"""
if not template_dirs:
template_dirs = self.get_dirs(app_label=app_label,
model_name=model_name)
for template_dir in template_dirs:
try:
name = safe_join(template_dir, template_name)
except SuspiciousFileOperation:
# The joined path was located outside of this template_dir
# (it might be inside another one, so this isn't fatal).
continue
yield Origin(
name=name,
template_name=template_name,
loader=self,
)
def render(self, context={}):
"""Render's a template, context can be a Django Context or a
dictionary.
"""
# flatten the Django Context into a single dictionary.
context_dict = {}
if hasattr(context, 'dicts'):
for d in context.dicts:
context_dict.update(d)
else:
context_dict = context
# Django Debug Toolbar needs a RequestContext-like object in order
# to inspect context.
class FakeRequestContext:
dicts = [context]
context = FakeRequestContext()
# Used by debug_toolbar.
if settings.TEMPLATE_DEBUG:
from django.test import signals
self.origin = Origin(self.filename)
signals.template_rendered.send(sender=self, template=self,
context=context)
# Jinja2 internally converts the context instance to a dictionary, thus
# we need to store the current_app attribute as a key/value pair.
context_dict['_current_app'] = getattr(context, 'current_app', None)
return super(Template, self).render(context_dict)
def find_template(self, name, dirs=None):
"""
RemovedInDjango21Warning: An internal method to lookup the template
name in all the configured loaders.
"""
key = self.cache_key(name, dirs)
try:
result = self.find_template_cache[key]
except KeyError:
result = None
for loader in self.loaders:
try:
template, display_name = loader(name, dirs)
except TemplateDoesNotExist:
pass
else:
origin = Origin(
name=display_name,
template_name=name,
loader=loader,
)
result = template, origin
break
self.find_template_cache[key] = result
if result:
return result
else:
self.template_cache[key] = TemplateDoesNotExist
raise TemplateDoesNotExist(name)
def render(self, context={}):
"""Render's a template, context can be a Django Context or a
dictionary.
"""
# flatten the Django Context into a single dictionary.
context_dict = {}
if hasattr(context, 'dicts'):
for d in context.dicts:
context_dict.update(d)
else:
context_dict = context
# Django Debug Toolbar needs a RequestContext-like object in order
# to inspect context.
class FakeRequestContext:
dicts = [context]
context = FakeRequestContext()
# Used by debug_toolbar.
if settings.TEMPLATE_DEBUG:
from django.test import signals
self.origin = Origin(self.filename)
signals.template_rendered.send(sender=self, template=self,
context=context)
return super(Template, self).render(context_dict)
def _generate_template_source(self, template_name, design):
"""Generate template source."""
template_source = join(self._app_dir, 'templates', design,
template_name)
if isfile(template_source):
if VERSION[:2] >= (1, 9):
template_source = Origin(name=template_source)
return [template_source]
return []
def stream(self, context=None):
if context == None:
context = {}
new_ctxt = ctxt_to_dict(context)
if engines['djinga'].engine.debug:
# send django signal on template rendering if in debug mode
from django.test import signals
from django.template.base import Origin
self.origin = Origin(self.filename)
signals.template_rendered.send(sender=self,
template=self,
context=context)
return super(DjingaTemplate, self).stream(new_ctxt)
def clean(self):
template = DjangoTemplate('')
template.source = self.changed_content
try:
engine = Engine.get_default()
lexer = DebugLexer(self.changed_content)
tokens = lexer.tokenize()
parser = Parser(tokens, engine.template_libraries,
engine.template_builtins, Origin(UNKNOWN_SOURCE))
parser.parse()
except TemplateSyntaxError as e:
exception_info = template.get_exception_info(e, e.token)
raise ValidationError({
'changed_content':
mark_safe(
'{message}<br/>Line {line}:\n<pre>{before}<b>{during}</b>{after}</pre>'
.format(**exception_info))
}) from e
def render(self, context=None, request=None):
context = ctxt_to_dict(context) if context else {}
engine = engines['djinga'].engine
if engine.debug:
# send django signal on template rendering if in debug mode
from django.test import signals
from django.template.base import Origin
self.origin = Origin(self.filename)
signals.template_rendered.send(sender=self,
template=self,
context=context)
# adds the context processors (without the builtin ones)
for cp in engine.template_context_processors:
context.update(cp(request))
return super(DjingaTemplate, self).render(context)
def get_template_sources(self, template_name, template_dirs=None):
"Template loader that loads templates from a ZIP file."
template_zipfiles = getattr(settings, "TEMPLATE_ZIP_FILES", ['library.zip'])
try :
yield self.templates_dict[template_name]._origin
except KeyError:
# Try each ZIP file in TEMPLATE_ZIP_FILES.
for fname in template_zipfiles:
try:
z = zipfile.ZipFile(fname)
source = z.read('templates/%s' % (template_name))
except (IOError, KeyError):
continue
z.close()
origin = Origin(name=template_name, template_name=template_name, loader=self)
self.templates_dict[template_name]= EntryLoaderCache(origin=origin, content=source)
yield origin
def get_contents(self, origin):
"""
Used by Django 1.9+
"""
name, _extension = os.path.splitext(origin.name)
template_name, _extension = os.path.splitext(origin.template_name)
for extension in HAML_EXTENSIONS:
try_name = self._generate_template_name(name, extension)
try_template_name = self._generate_template_name(template_name, extension)
try_origin = Origin(try_name, try_template_name, origin.loader)
try:
haml_source = super(Loader, self).get_contents(try_origin)
except TemplateDoesNotExist:
pass
else:
haml_parser = Compiler()
return haml_parser.process(haml_source)
raise TemplateDoesNotExist(origin.template_name)
def get_template(self, template_name, *args, **kwargs):
"""
Return the template with the given name. The template_name should have the type
(``{html}`` or ``{plaintext}``) appended to the template model instance name.
"""
# use get_model because models.py imports this module - avoid cyclic imports
template_model = apps.get_model("impression", "Template")
match = self.name_pattern.match(template_name)
if not match:
raise ValueError(
'template_name must end with either "{html}" or "{plaintext}"')
template_shortname = match[1]
body_type = match[2]
template = template_model.objects.get(name=template_shortname)
origin = Origin(
name="Impression Model Template",
template_name=template_name,
loader=type(self).__name__,
)
return DjangoTemplate(
self.get_template_body(template, body_type),
origin=origin,
)
def render(self, context=None, request=None):
if context is None:
context = {}
if request is not None:
def _get_val():
token = get_token(request)
if token is None:
return 'NOTPROVIDED'
else:
return smart_text(token)
context["request"] = request
context["csrf_token"] = SimpleLazyObject(_get_val)
# Support for django context processors
for processor in self.backend.context_processors:
context.update(processor(request))
if settings.TEMPLATE_DEBUG:
from django.test import signals
self.template.origin = Origin(self.template.filename)
context_obj = Context(context)
context_processors = {}
if request is not None:
for processor in self.backend.context_processors:
context_processors[processor.__name__] = processor(request)
context_obj.context_processors = context_processors
signals.template_rendered.send(sender=self,
template=self.template,
context=context_obj)
return self.template.render(context)
def get_template_path(template_dir, template_name):
"""Return Origin object with template file path"""
return Origin(name=join(template_dir, template_name))
def get_template_path(template_dir, template_name, loader=None):
return Origin(
name=join(template_dir, template_name),
template_name=template_name,
loader=loader,
)
def get_template_sources(self, template_name):
yield Origin(
name=template_name,
template_name=template_name,
loader=self,
)
