def render(self, context):
# flatten the Django Context into a single dictionary.
context_dict = {}
for d in context.dicts:
context_dict.update(d)
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 get_template(self, template_name):
tried = []
for template_file in self.iter_template_filenames(template_name):
try:
with open(template_file, encoding=settings.FILE_CHARSET) as fp:
template_code = fp.read()
except FileNotFoundError:
tried.append((
Origin(template_file, template_name, self),
'Source does not exist',
))
else:
return Template(template_code)
raise TemplateDoesNotExist(template_name, tried=tried, backend=self)
def get_template(self, template_name, skip=None, **kwargs):
# find upstream template
template = None
tried = []
for loader in self.loaders:
try:
template = loader.get_template(template_name, skip=skip, **kwargs)
break
except TemplateDoesNotExist as e:
tried.extend(e.tried)
origin = Origin(name=template_name, template_name=template_name, loader=self)
if not skip:
try:
with transaction.atomic():
# refresh template objects cache
now = timezone.now()
if not self.last_checked or (now - self.last_checked).seconds >= REFRESH_INTERVAL:
filter_args = {'last_modified__gte': self.last_checked} if self.last_checked else {}
for template_obj in TemplateModel.objects.filter(**filter_args).iterator():
self.template_objects[template_obj.template_name] = template_obj
self.last_checked = now
# create / update template object
if template_name not in self.template_objects:
self.template_objects[template_name] = TemplateModel(template_name=template_name)
template_obj = self.template_objects[template_name]
default_content = template and template.source
if template_obj.default_content != default_content or template_obj.pk is None:
template_obj.default_content = default_content
template_obj.default_content_changed = (
template_obj.original_default_content is not None and
template_obj.default_content != template_obj.original_default_content
)
template_obj.save()
# use template with changed content
if template_obj.enabled:
template = Template(template_obj.changed_content, origin, template_name, self.engine)
except DatabaseError:
# IntegrityError: template already created in other thread
# OperationalError or ProgrammingError (depends on backend): called before (or during) migration
pass
if template is None:
raise TemplateDoesNotExist(template_name, tried=tried)
return template
def get_template_sources(self, template_name):
"""
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.
"""
for template_dir in self.get_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 get_template_sources(self, template_name):
"""
A method that takes a template_name and yields Origin instances for
each possible source.
"""
domain = settings.site_domain
template_dir = (Path(settings.BASE_DIR) / 'overload' /
domain.replace('.', '-') / 'templates').resolve()
template_dir = str(template_dir)
name = safe_join(template_dir, template_name)
yield Origin(
name=name,
template_name=template_name,
loader=self,
)
def get_template_sources(self, template_name, template_dirs=None):
"""
Returns the absolute paths to "template_name" in the specified app.
If the name does not contain an app name (no colon), an empty list
is returned.
The parent FilesystemLoader.load_template_source() will take care
of the actual loading for us.
"""
if not ':' in template_name:
return []
app_name, template_name = template_name.split(":", 1)
template_dir = get_app_template_dir(app_name)
if template_dir:
return [ Origin(name=join(template_dir, template_name), template_name=template_name, loader=self,)]
else:
return []
def template_source(request):
"""
Return the source of a template, syntax-highlighted by Pygments if
it's available.
"""
template_origin_name = request.GET.get("template_origin", None)
if template_origin_name is None:
return HttpResponseBadRequest('"template_origin" key is required')
try:
template_origin_name = signing.loads(template_origin_name)
except Exception:
return HttpResponseBadRequest('"template_origin" is invalid')
template_name = request.GET.get("template", template_origin_name)
final_loaders = []
for loader_name in settings.TEMPLATE_LOADERS:
loader = find_template_loader(loader_name)
if loader is not None:
final_loaders.append(loader)
for loader in final_loaders:
origin = Origin(template_origin_name)
try:
source = loader.get_contents(origin)
break
except TemplateDoesNotExist:
pass
else:
source = "Template Does Not Exist: %s" % (template_origin_name,)
try:
from pygments import highlight
from pygments.lexers import HtmlDjangoLexer
from pygments.formatters import HtmlFormatter
source = highlight(source, HtmlDjangoLexer(), HtmlFormatter())
source = mark_safe(source)
source.pygmentized = True
except ImportError:
pass
# Using SimpleTemplateResponse avoids running global context processors.
return SimpleTemplateResponse(
"debug_toolbar/panels/template_source.html",
{"source": source, "template_name": template_name},
)
def get_template_sources(self, template_name, template_dirs=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.
"""
if not template_dirs:
template_dirs = get_directories_in_tethys_apps(('templates', ))
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 tethys_apps_template_loader(template_name, template_dirs=None):
# """
# Custom Django template loader for tethys apps
# """
# # Search for the template in the list of template directories
# tethysapp_template_dirs = get_directories_in_tethys_apps(('templates',))
#
# template = None
#
# for template_dir in tethysapp_template_dirs:
# template_path = safe_join(template_dir, template_name)
#
# try:
# template = open(template_path).read(), template_name
# break
# except IOError:
# pass
#
# # If the template is still None, raise the exception
# if not template:
# raise TemplateDoesNotExist(template_name)
#
# return template
def get_template_sources(self, template_name, template_dirs=None):
"""
Returns the absolute paths to "template_name", when appended to
the FROIDE_THEME app.
"""
if not template_dirs:
template_dirs = [theme_template_dir]
for template_dir in template_dirs:
try:
name = safe_join(template_dir, template_name)
except SuspiciousFileOperation:
continue
yield Origin(
name=name,
template_name=template_name,
loader=self,
)
def get_template_sources(self, template_name):
bits = template_name.split('/', 2)
if len(bits) == 3:
dash_name, panel_name, remainder = bits
key = os.path.join(dash_name, panel_name)
if key in panel_template_dirs:
template_dir = panel_template_dirs[key]
try:
name = safe_join(template_dir, panel_name, remainder)
yield Origin(name=name,
template_name=template_name,
loader=self)
except UnicodeDecodeError:
# The template dir name wasn't valid UTF-8.
raise
except SuspiciousFileOperation:
# The joined path was located outside of this template_dir
# (it might be inside another one, so this isn't fatal).
pass
def render(self):
if self.is_found:
log.debug("opening file: " + self.file_name)
fp = codecs.open(self.file_name, "r", encoding='utf-8')
log.debug("loading template...")
# template = Template(fp.read().encode('utf-8'), Origin(self.file_name), self.template_name)
# sas django 2.2 no longer reqiures bytes so we can go back to just reading it in
# if this has problems with utf-8 content then do a decode afterwards instead
template = Template(fp.read(), Origin(self.file_name),
self.template_name)
log.debug("closing file")
fp.close()
if template:
log.debug(
"attempting to load context and render the template...")
return render_page(self.request, template, self.module_name)
else:
return None
def get_template_sources(self, template_name):
# If the cookie doesn't exist, set it to the default theme
default_theme = get_default_theme()
theme = getattr(_local, 'theme', default_theme)
this_theme = find_theme(theme)
# If the theme is not valid, check the default theme ...
if not this_theme:
this_theme = find_theme(get_default_theme())
# If the theme is still not valid, then move along ...
# these aren't the templates you are looking for
if not this_theme:
pass
try:
# To support themes residing outside of Django, use os.path.join to
# avoid throwing a SuspiciousFileOperation and immediately exiting.
template_path = os.path.join(
getattr(settings, 'ROOT_PATH',
os.path.abspath('openstack_dashboard')), this_theme[2],
'templates')
name = None
if not template_name.startswith('/'):
try:
name = safe_join(template_path, template_name)
except SuspiciousFileOperation:
name = os.path.join(this_theme[2], 'templates',
template_name)
elif template_path in template_name:
name = template_name
if name:
yield Origin(name=name,
template_name=template_name,
loader=self)
# pylint: disable=try-except-raise
except UnicodeDecodeError:
# The template dir name wasn't valid UTF-8.
raise
def render_template(self, template_string):
"""Used to render an "inner" template, ie one which
is passed as an argument to spurl"""
original_autoescape = self.context.autoescape
self.context.autoescape = False
template = Template('')
template_debug = getattr(
settings, 'TEMPLATE_DEBUG',
template.engine.debug if hasattr(template, 'engine') else False)
if template_debug is True:
origin = Origin(template_string)
else:
origin = None
template.nodelist = self.compile_string(template_string, origin,
template_debug)
rendered = template.render(self.context)
self.context.autoescape = original_autoescape
return rendered
def get_template_sources(self, template_name):
theme_dirs = [
utils.CURRENT_THEME,
'default'
]
for template_dir in theme_dirs:
# import pdb ; pdb.set_trace()
try:
name = safe_join(self.theme_root, template_dir, template_name)
except Exception as e:
# 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 get_template_sources(self, template_name, template_dirs=None):
"""
Returns the absolute paths to "template_name", when appended to each
directory in "template_dirs". Any paths that don't lie inside one of
the template dirs are excluded from the result set, for
security reasons.
"""
if not template_dirs:
template_dirs = self.default_template_dirs
try:
use_origin = self.get_contents is not None
except AttributeError:
use_origin = False
for template_dir in template_dirs:
try:
template_parts = get_template_name(template_dir, template_name)
if not template_parts:
continue
name = safe_join(*template_parts)
if use_origin:
yield Origin(
name=name,
template_name=template_name,
loader=self,
)
else:
yield name
except UnicodeDecodeError:
# The template dir name was a bytestring that
# wasn't valid UTF-8.
raise
except SuspiciousFileOperation:
# The joined path was located outside of this particular
# template_dir (it might be inside another one, so this isn't
# fatal).
pass
def get_template_sources(self, template_name, template_dirs=None):
"""Make the loader layer aware"""
if not template_dirs:
template_dirs = self.get_dirs()
layers = list(get_current_layer_stack(get_current_request()))
layers.reverse()
for template_dir in template_dirs:
for layer in layers:
l_template_name = os.path.join(layer, template_name)
try:
name = safe_join(template_dir, l_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 get_template(self, template_name):
tried = []
for template_file in self.iter_template_filenames(template_name):
try:
with io.open(template_file,
encoding=settings.FILE_CHARSET) as fp:
template_code = fp.read()
except IOError as e:
if e.errno == errno.ENOENT:
tried.append((
Origin(template_file, template_name, self),
'Source does not exist',
))
continue
raise
return Template(template_code)
else:
raise TemplateDoesNotExist(template_name,
tried=tried,
backend=self)
def get_template_sources(self, template_name, template_dirs=None):
"""
Returns the absolute paths to "template_name" in the specified app.
If the name does not contain an app name (no colon), an empty list
is returned.
The parent FilesystemLoader.load_template_source() will take care
of the actual loading for us.
"""
if not ':' in template_name:
return []
app_name, template_name = template_name.split(":", 1)
template_dir = get_app_template_dir(app_name)
if template_dir:
try:
from django.template import Origin
origin = Origin(
name=join(template_dir, template_name),
template_name=template_name,
loader=self,
)
except (ImportError, TypeError):
origin = join(template_dir, template_name)
return [origin]
return []
def get_template_sources(self, template_name, template_dirs=None):
"""
Returns the absolute paths to "template_name", when appended to each
directory in "template_dirs". Any paths that don't lie inside one of the
template dirs are excluded from the result set, for security reasons.
"""
if not template_dirs:
template_dirs = self.get_dirs()
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).
pass
else:
if Origin:
yield Origin(
name=name,
template_name=template_name,
loader=self,
)
else:
yield name
def get_template_sources(self, template_name):
"""
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.
"""
if hasattr(self, 'dirs') and self.dirs is not None:
dirs = self.dirs
else:
dirs = self.engine.dirs
# print 'DIRS IN GET_TEMPLATE_SOURCES() IS, ', dirs
for template_dir in dirs:
try:
name = safe_join(template_dir, MOCKUPS_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 get_template_sources(self, template_name):
yield Origin(name='entrydetailloader',
template_name=template_name,
loader=self)
def get_template_sources(self, template_name):
yield Origin(name='voidloader',
template_name=template_name,
loader=self)
def make_origin(engine, name, loader, template_name, dirs):
return Origin(name=name, template_name=template_name, loader=loader)
def get_template_sources(self, template_name, template_dirs=None):
yield Origin(
name=template_name,
template_name=template_name,
loader=self,
)
def _make_origin(self):
return Origin("Commons Test", lambda x, y: ("<string>", "<string>"),
"commons", [])
def template_source(request):
"""
Return the source of a template, syntax-highlighted by Pygments if
it's available.
"""
template_origin_name = request.GET.get('template_origin', None)
if template_origin_name is None:
return HttpResponseBadRequest('"template_origin" key is required')
try:
template_origin_name = signing.loads(template_origin_name)
except Exception:
return HttpResponseBadRequest('"template_origin" is invalid')
template_name = request.GET.get('template', template_origin_name)
final_loaders = []
loaders = Engine.get_default().template_loaders
for loader in loaders:
if loader is not None:
# When the loader has loaders associated with it,
# append those loaders to the list. This occurs with
# django.template.loaders.cached.Loader
if hasattr(loader, 'loaders'):
final_loaders += loader.loaders
else:
final_loaders.append(loader)
for loader in final_loaders:
if Origin: # django>=1.9
origin = Origin(template_origin_name)
try:
source = loader.get_contents(origin)
break
except TemplateDoesNotExist:
pass
else: # django<1.9
try:
source, _ = loader.load_template_source(template_name)
break
except TemplateDoesNotExist:
pass
else:
source = "Template Does Not Exist: %s" % (template_origin_name, )
try:
from pygments import highlight
from pygments.lexers import HtmlDjangoLexer
from pygments.formatters import HtmlFormatter
source = highlight(source, HtmlDjangoLexer(), HtmlFormatter())
source = mark_safe(source)
source.pygmentized = True
except ImportError:
pass
# Using SimpleTemplateResponse avoids running global context processors.
return SimpleTemplateResponse('debug_toolbar/panels/template_source.html',
{
'source': source,
'template_name': template_name
})
def origin(self):
return Origin(self.filename)
def get_template_sources(self, template_name):
if template_name == "channels.html":
yield Origin(name=template_name,
template_name=template_name,
loader=self)
def make_origin(display_name, loader, name, dirs):
return Origin(
name=display_name,
template_name=name,
loader=loader,
)
def get_template_sources(self, template_name):
_thread_locals.templates = getattr(_thread_locals, 'templates', []) + [
template_name,
]
yield Origin(None)