def render(template_name, form_fill=None, form_errors={}, extra_vars=None,
cache_key=None, cache_type=None, cache_expire=None,
method='xhtml'):
# Create a render callable for the cache function
def render_template():
# Pull in extra vars if needed
globs = extra_vars or {}
# Second, get the globals
globs.update(pylons_globals())
globs['g'] = app_globals
globs['_form_errors'] = form_errors
# Grab a template reference
template = globs['app_globals'].genshi_loader.load(template_name)
stream = template.generate(**globs)
if form_fill is not None:
filler = HTMLFormFiller(data=form_fill)
stream = stream | filler
return literal(stream.render(method=method, encoding=None))
return cached_template(template_name, render_template, cache_key=cache_key,
cache_type=cache_type, cache_expire=cache_expire,
ns_options=('method'), method=method)
def render_kajiki(template_name, extra_vars=None, cache_key=None,
cache_type=None, cache_expire=None, method='xhtml'):
"""Render a template with Kajiki
Accepts the cache options ``cache_key``, ``cache_type``, and
``cache_expire`` in addition to method which are passed to Kajiki's
render function.
"""
# Create a render callable for the cache function
def render_template():
# Pull in extra vars if needed
globs = extra_vars or {}
# Second, get the globals
globs.update(templating.pylons_globals())
# Grab a template reference
template = globs['app_globals'].kajiki_loader.load(template_name)
return literal(template(globs).render())
return templating.cached_template(template_name, render_template, cache_key=cache_key,
cache_type=cache_type, cache_expire=cache_expire,
ns_options=('method'), method=method)
def render(template_name, extra_vars=None, *pargs, **kwargs):
'''Render a template and return the output.
This is CKAN's main template rendering function.
:params template_name: relative path to template inside registered tpl_dir
:type template_name: str
:params extra_vars: additional variables available in template
:type extra_vars: dict
:params pargs: DEPRECATED
:type pargs: tuple
:params kwargs: DEPRECATED
:type kwargs: dict
'''
if pargs or kwargs:
tb = inspect.getframeinfo(sys._getframe(1))
log.warning(
'Extra arguments to `base.render` are deprecated: ' +
'<{0.filename}:{0.lineno}>'.format(tb)
)
if extra_vars is None:
extra_vars = {}
if not is_flask_request():
renderer = _pylons_prepare_renderer(template_name, extra_vars,
*pargs, **kwargs)
return cached_template(template_name, renderer)
return flask_render_template(template_name, **extra_vars)
def render_macro(template_name, name, cache_key=None,
cache_type=None, cache_expire=None, **kwargs):
"""Render a template with Jinja2
Accepts the cache options ``cache_key``, ``cache_type``, and
``cache_expire``.
"""
# Create a render callable for the cache function
def render_template():
# Pull in extra vars if needed
globs = {}
# Second, get the globals
globs.update(pylons_globals())
# Grab a template reference
template = \
getattr(globs['app_globals'].jinja2_env.get_template(template_name).make_module(vars=globs), name)(**kwargs)
return template
return cached_template(template_name, render_template, cache_key=cache_key,
cache_type=cache_type, cache_expire=cache_expire)
def render(template_name, extra_vars=None, cache_key=None, cache_type=None,
cache_expire=None, method='xhtml', loader_class=MarkupTemplate):
def render_template():
globs = extra_vars or {}
globs.update(pylons_globals())
globs['actions'] = model.Action
# Using pylons.url() or pylons.url_for() directly destroys the
# localisation stuff so we remove it so any bad templates crash
# and burn
del globs['url']
template = globs['app_globals'].genshi_loader.load(template_name,
cls=loader_class)
stream = template.generate(**globs)
for item in PluginImplementations(IGenshiStreamFilter):
stream = item.filter(stream)
return literal(stream.render(method=method, encoding=None, strip_whitespace=False))
if 'Pragma' in response.headers:
del response.headers["Pragma"]
if cache_key is not None or cache_type is not None:
response.headers["Cache-Control"] = "public"
if cache_expire is not None:
response.headers["Cache-Control"] = "max-age=%s, must-revalidate" % cache_expire
return cached_template(template_name, render_template, cache_key=cache_key,
cache_type=cache_type, cache_expire=cache_expire)
def render(template_name, extra_vars=None, cache_key=None, cache_type=None,
cache_expire=None, method='xhtml', loader_class=MarkupTemplate):
def render_template():
globs = extra_vars or {}
globs.update(pylons_globals())
globs['actions'] = model.Action
template = globs['app_globals'].genshi_loader.load(template_name,
cls=loader_class)
stream = template.generate(**globs)
for item in PluginImplementations(IGenshiStreamFilter):
stream = item.filter(stream)
return literal(stream.render(method=method, encoding=None))
if 'Pragma' in response.headers:
del response.headers["Pragma"]
if cache_key is not None or cache_type is not None:
response.headers["Cache-Control"] = "public"
if cache_expire is not None:
response.headers["Cache-Control"] = "max-age=%s, must-revalidate" % cache_expire
return cached_template(template_name, render_template, cache_key=cache_key,
cache_type=cache_type, cache_expire=cache_expire)
def render_genshi(template_name, genshi_loader, cache_key=None, cache_type=None,
cache_expire=None, fragment=False, format='xhtml'):
"""
Copied out of Pylons so that we can specify the path to genshi templates.
Render a template with Genshi
Accepts the cache options ``cache_key``, ``cache_type``, and
``cache_expire`` in addition to fragment and format which are
passed to Genshi's render function.
"""
# Create a render callable for the cache function
def render_template():
# First, get the globals
globs = pylons_globals()
# Grab a template reference
template = genshi_loader.load(template_name)
return template.generate(**globs).render()
return cached_template(template_name, render_template, cache_key=cache_key,
cache_type=cache_type, cache_expire=cache_expire,
ns_options=('fragment', 'format'),
fragment=fragment, format=format)
def render(template_name, extra_vars=None, *pargs, **kwargs):
'''Render a template and return the output.
This is CKAN's main template rendering function.
:params template_name: relative path to template inside registered tpl_dir
:type template_name: str
:params extra_vars: additional variables available in template
:type extra_vars: dict
:params pargs: DEPRECATED
:type pargs: tuple
:params kwargs: DEPRECATED
:type kwargs: dict
'''
if pargs or kwargs:
tb = inspect.getframeinfo(sys._getframe(1))
log.warning(
'Extra arguments to `base.render` are deprecated: ' +
'<{0.filename}:{0.lineno}>'.format(tb)
)
if extra_vars is None:
extra_vars = {}
if not is_flask_request():
renderer = _pylons_prepare_renderer(template_name, extra_vars,
*pargs, **kwargs)
return cached_template(template_name, renderer)
return flask_render_template(template_name, **extra_vars)
def render_kajiki(template_name,
extra_vars=None,
cache_key=None,
cache_type=None,
cache_expire=None,
method='xhtml'):
"""Render a template with Kajiki
Accepts the cache options ``cache_key``, ``cache_type``, and
``cache_expire`` in addition to method which are passed to Kajiki's
render function.
"""
# Create a render callable for the cache function
def render_template():
# Pull in extra vars if needed
globs = extra_vars or {}
# Second, get the globals
globs.update(templating.pylons_globals())
# Grab a template reference
template = globs['app_globals'].kajiki_loader.load(template_name)
return literal(template(globs).render())
return templating.cached_template(template_name,
render_template,
cache_key=cache_key,
cache_type=cache_type,
cache_expire=cache_expire,
ns_options=('method'),
method=method)
def __call__(self, template_name, template_vars, **kwargs):
"""Render the template_vars with the Genshi template."""
template_vars.update(self.genshi_functions)
# Gets document type from content type or from config options
doctype = 'text/x-vcard'
method = 'vcf'
kwargs['doctype'] = doctype
kwargs['method'] = method
def render_template():
template = self.load_template(template_name)
return template.generate(**template_vars).render(encoding=None)
return templating.cached_template(template_name, render_template,
**kwargs)
def __call__(self, template_name, template_vars, **kwargs):
"""Render the template_vars with the Genshi template."""
template_vars.update(self.genshi_functions)
# Gets document type from content type or from config options
doctype = 'text/x-vcard'
method='vcf'
kwargs['doctype'] = doctype
kwargs['method'] = method
def render_template():
template = self.load_template(template_name)
return template.generate(**template_vars).render(encoding=None)
return templating.cached_template(
template_name, render_template,
**kwargs)
def render_genshi(template_name, extra_vars=None, cache_key=None,
cache_type=None, cache_expire=None, method='xhtml',
form_data=None, form_errors=None):
"""Render a template with Genshi
Taken from Pylons, augmented with the HTMLFormFiller functionality,
use ``form_data'' option.
Added our own HTMLFormErrors, ``form_errors'' takes a dict of form field ids
and error messages.
We also use genshi's DocTypeInserter
Accepts the cache options ``cache_key``, ``cache_type``, and
``cache_expire`` in addition to method which are passed to Genshi's
render function.
"""
# Create a render callable for the cache function
def render_template():
# Pull in extra vars if needed
globs = extra_vars or {}
# Second, get the globals
globs.update(pylons_globals())
# Grab a template reference
template = globs['app_globals'].genshi_loader.load(template_name)
stream = template.generate(**globs) | DocTypeInserter(DocType.HTML5)
if form_data:
stream = stream | HTMLFormFiller(data=form_data)
if form_errors:
stream = stream | HTMLFormErrors(errors=form_errors)
return literal(stream.render(method=method, encoding=None))
# if there's form data we don't cache
if form_data or form_errors:
return render_template()
return cached_template(template_name, render_template, cache_key=cache_key,
cache_type=cache_type, cache_expire=cache_expire,
ns_options=('method'), method=method)
def render_pytiles(template_name, extra_vars=None, cache_key=None,
cache_type=None, cache_expire=None):
"""Render a template with Pytiles"""
# Create a render callable for the cache function
def render_template():
# Pull in extra vars if needed
globs = extra_vars or {}
# Second, get the globals
globs.update(pylons_globals())
# Grab a template reference
template = \
globs['app_globals'].pytiles_container.get_template(template_name)
return literal(template.render(**globs))
return cached_template(template_name, render_template, cache_key=cache_key,
cache_type=cache_type, cache_expire=cache_expire)
def __call__(self, template_name, template_vars, **kwargs):
"""Render the template_vars with the Chameleon-Genshi template."""
# Gets template format from content type or from config options
format = kwargs.get('format')
if not format:
format = self.format_for_content_type.get(response.content_type)
if not format:
format = config.get('templating.chameleon.genshi.format')
if not format:
format = config.get('templating.genshi.method')
if not format or format not in ('xml', 'text'):
format = 'xml'
def render_template():
template_vars.update(my_pylons_globals())
template = self.load_template(template_name, format=format)
return literal(template.render(**template_vars))
return templating.cached_template(
template_name, render_template,
ns_options=('doctype', 'method'), **kwargs)
def render_evoque(template_name, extra_vars=None, cache_key=None,
cache_type=None, cache_expire=None,
collection=None, raw=False, quoting=None):
""" Render a template with Evoque : http://evoque.gizmojo.org/ext/pylons/
Accepts the cache options ``cache_key``, ``cache_type``, and
``cache_expire``.
The remaining options affect how template is located, loaded and rendered:
- template_name: normally this is the collection-root-relative locator for
the template; if template had been previously with location specified
via the src option, then may be any arbitrary string identifier.
- collection: either(None, str, Collection), an existing collection,
None implies the default collection
- raw: bool, render the raw template source
- quoting: either(str, type), sets the Quoted-No-More string class to use,
None uses the collection's default,
"xml" uses qpy.xml,
"str" uses unicode
"""
# Create a render callable for the cache function
def render_template():
# Get the globals
# Note: when running in restricted mode which of these globals are
# to be exposed should be a lot more selective.
pg = pylons_globals()
# Update any extra vars if needed
if extra_vars:
pg.update(extra_vars)
# Grab a template reference
template = pg['app_globals'].evoque_domain.get_template(
template_name, collection=collection, raw=raw, quoting=quoting)
return template.evoque(pg, raw=raw, quoting=quoting)
return cached_template(template_name, render_template, cache_key=cache_key,
cache_type=cache_type, cache_expire=cache_expire)
def __call__(self, template_name, template_vars, **kwargs):
"""Render the template_vars with the Genshi template."""
template_vars.update(self.genshi_functions)
# Gets document type from content type or from config options
doctype = kwargs.get('doctype')
if not doctype:
doctype = config.get('templating.genshi.doctype')
if not doctype:
method = kwargs.get('method') or config.get(
'templating.genshi.method') or 'xhtml'
doctype = self.doctypes_for_methods.get(method)
doctypes = self.doctypes_for_content_type.get(response.content_type)
if doctypes and (not doctype or doctype not in doctypes):
doctype = doctypes[0]
kwargs['doctype'] = doctype
# Gets rendering method from content type or from config options
method = kwargs.get('method')
if not method:
method = config.get('templating.genshi.method')
if not method:
method = self.method_for_doctype(doctype)
methods = self.methods_for_content_type.get(response.content_type)
if methods and (not method or method not in methods):
method = methods[0]
kwargs['method'] = method
def render_template():
template_vars.update(my_pylons_globals())
template = self.load_template(template_name)
return literal(template.generate(**template_vars).render(
doctype=doctype, method=method, encoding=None))
return templating.cached_template(
template_name, render_template,
ns_options=('doctype', 'method'), **kwargs)
def render(template_name, extra_vars=None, cache_key=None, cache_type=None,
cache_expire=None, method='xhtml', loader_class=MarkupTemplate,
cache_force=None, renderer=None):
''' Main template rendering function. '''
def render_template():
globs = extra_vars or {}
globs.update(pylons_globals())
globs['actions'] = model.Action
# Using pylons.url() directly destroys the localisation stuff so
# we remove it so any bad templates crash and burn
del globs['url']
try:
template_path, template_type = lib.render.template_info(template_name)
except lib.render.TemplateNotFound:
template_type = 'genshi'
template_path = ''
# snippets should not pass the context
# but allow for legacy genshi templates
if renderer == 'snippet' and template_type != 'genshi':
del globs['c']
del globs['tmpl_context']
log.debug('rendering %s [%s]' % (template_path, template_type))
if config.get('debug'):
context_vars = globs.get('c')
if context_vars:
context_vars = dir(context_vars)
debug_info = {'template_name': template_name,
'template_path': template_path,
'template_type': template_type,
'vars': globs,
'c_vars': context_vars,
'renderer': renderer}
if 'CKAN_DEBUG_INFO' not in request.environ:
request.environ['CKAN_DEBUG_INFO'] = []
request.environ['CKAN_DEBUG_INFO'].append(debug_info)
# Jinja2 templates
if template_type == 'jinja2':
# We don't want to have the config in templates it should be
# accessed via g (app_globals) as this gives us flexability such
# as changing via database settings.
del globs['config']
# TODO should we raise error if genshi filters??
return render_jinja2(template_name, globs)
# Genshi templates
template = globs['app_globals'].genshi_loader.load(template_name,
cls=loader_class)
stream = template.generate(**globs)
for item in PluginImplementations(IGenshiStreamFilter):
stream = item.filter(stream)
if loader_class == NewTextTemplate:
return literal(stream.render(method="text", encoding=None))
return literal(stream.render(method=method, encoding=None,
strip_whitespace=True))
if 'Pragma' in response.headers:
del response.headers["Pragma"]
## Caching Logic
allow_cache = True
# Force cache or not if explicit.
if cache_force is not None:
allow_cache = cache_force
# Do not allow caching of pages for logged in users/flash messages etc.
elif session.last_accessed:
allow_cache = False
# Tests etc.
elif 'REMOTE_USER' in request.environ:
allow_cache = False
# Don't cache if based on a non-cachable template used in this.
elif request.environ.get('__no_cache__'):
allow_cache = False
# Don't cache if we have set the __no_cache__ param in the query string.
elif request.params.get('__no_cache__'):
allow_cache = False
# Don't cache if we have extra vars containing data.
elif extra_vars:
for k, v in extra_vars.iteritems():
allow_cache = False
break
# Record cachability for the page cache if enabled
request.environ['CKAN_PAGE_CACHABLE'] = allow_cache
if allow_cache:
response.headers["Cache-Control"] = "public"
try:
cache_expire = int(config.get('ckan.cache_expires', 0))
response.headers["Cache-Control"] += \
", max-age=%s, must-revalidate" % cache_expire
except ValueError:
pass
else:
# We do not want caching.
response.headers["Cache-Control"] = "private"
# Prevent any further rendering from being cached.
request.environ['__no_cache__'] = True
log.debug('Template cache-control: %s' % response.headers["Cache-Control"])
# Render Time :)
try:
return cached_template(template_name, render_template,
loader_class=loader_class)
except ckan.exceptions.CkanUrlException, e:
raise ckan.exceptions.CkanUrlException(
'\nAn Exception has been raised for template %s\n%s' %
(template_name, e.message))
def render(template_name,
extra_vars=None,
cache_key=None,
cache_type=None,
cache_expire=None,
method='xhtml',
loader_class=MarkupTemplate,
cache_force=None,
renderer=None):
''' Main template rendering function. '''
def render_template():
globs = extra_vars or {}
globs.update(pylons_globals())
globs['actions'] = model.Action
# Using pylons.url() directly destroys the localisation stuff so
# we remove it so any bad templates crash and burn
del globs['url']
try:
template_path, template_type = lib.render.template_info(
template_name)
except lib.render.TemplateNotFound:
template_type = 'genshi'
template_path = ''
# snippets should not pass the context
# but allow for legacy genshi templates
if renderer == 'snippet' and template_type != 'genshi':
del globs['c']
del globs['tmpl_context']
log.debug('rendering %s [%s]' % (template_path, template_type))
if config.get('debug'):
context_vars = globs.get('c')
if context_vars:
context_vars = dir(context_vars)
debug_info = {
'template_name': template_name,
'template_path': template_path,
'template_type': template_type,
'vars': globs,
'c_vars': context_vars,
'renderer': renderer
}
if 'CKAN_DEBUG_INFO' not in request.environ:
request.environ['CKAN_DEBUG_INFO'] = []
request.environ['CKAN_DEBUG_INFO'].append(debug_info)
# Jinja2 templates
if template_type == 'jinja2':
# We don't want to have the config in templates it should be
# accessed via g (app_globals) as this gives us flexability such
# as changing via database settings.
del globs['config']
# TODO should we raise error if genshi filters??
return render_jinja2(template_name, globs)
# Genshi templates
template = globs['app_globals'].genshi_loader.load(template_name,
cls=loader_class)
stream = template.generate(**globs)
for item in PluginImplementations(IGenshiStreamFilter):
stream = item.filter(stream)
if loader_class == NewTextTemplate:
return literal(stream.render(method="text", encoding=None))
return literal(
stream.render(method=method, encoding=None, strip_whitespace=True))
if 'Pragma' in response.headers:
del response.headers["Pragma"]
## Caching Logic
allow_cache = True
# Force cache or not if explicit.
if cache_force is not None:
allow_cache = cache_force
# Do not allow caching of pages for logged in users/flash messages etc.
elif session.last_accessed:
allow_cache = False
# Tests etc.
elif 'REMOTE_USER' in request.environ:
allow_cache = False
# Don't cache if based on a non-cachable template used in this.
elif request.environ.get('__no_cache__'):
allow_cache = False
# Don't cache if we have set the __no_cache__ param in the query string.
elif request.params.get('__no_cache__'):
allow_cache = False
# Don't cache if we have extra vars containing data.
elif extra_vars:
for k, v in extra_vars.iteritems():
allow_cache = False
break
# Record cachability for the page cache if enabled
request.environ['CKAN_PAGE_CACHABLE'] = allow_cache
if allow_cache:
response.headers["Cache-Control"] = "public"
try:
cache_expire = int(config.get('ckan.cache_expires', 0))
response.headers["Cache-Control"] += \
", max-age=%s, must-revalidate" % cache_expire
except ValueError:
pass
else:
# We do not want caching.
response.headers["Cache-Control"] = "private"
# Prevent any further rendering from being cached.
request.environ['__no_cache__'] = True
log.debug('Template cache-control: %s' % response.headers["Cache-Control"])
# Render Time :)
try:
return cached_template(template_name,
render_template,
loader_class=loader_class)
except ckan.exceptions.CkanUrlException, e:
raise ckan.exceptions.CkanUrlException(
'\nAn Exception has been raised for template %s\n%s' %
(template_name, e.message))
def render(template_name,
extra_vars=None,
cache_key=None,
cache_type=None,
cache_expire=None,
cache_force=None,
renderer=None):
'''Render a template and return the output.
This is CKAN's main template rendering function.
.. todo::
Document the parameters of :py:func:`ckan.plugins.toolkit.render`.
'''
def render_template():
globs = extra_vars or {}
globs.update(pylons_globals())
# Using pylons.url() directly destroys the localisation stuff so
# we remove it so any bad templates crash and burn
del globs['url']
try:
template_path, template_type = render_.template_info(template_name)
except render_.TemplateNotFound:
raise
log.debug('rendering %s [%s]' % (template_path, template_type))
if config.get('debug'):
context_vars = globs.get('c')
if context_vars:
context_vars = dir(context_vars)
debug_info = {
'template_name': template_name,
'template_path': template_path,
'template_type': template_type,
'vars': globs,
'c_vars': context_vars,
'renderer': renderer
}
if 'CKAN_DEBUG_INFO' not in request.environ:
request.environ['CKAN_DEBUG_INFO'] = []
request.environ['CKAN_DEBUG_INFO'].append(debug_info)
del globs['config']
return render_jinja2(template_name, globs)
if 'Pragma' in response.headers:
del response.headers["Pragma"]
## Caching Logic
allow_cache = True
# Force cache or not if explicit.
if cache_force is not None:
allow_cache = cache_force
# Do not allow caching of pages for logged in users/flash messages etc.
elif session.last_accessed:
allow_cache = False
# Tests etc.
elif 'REMOTE_USER' in request.environ:
allow_cache = False
# Don't cache if based on a non-cachable template used in this.
elif request.environ.get('__no_cache__'):
allow_cache = False
# Don't cache if we have set the __no_cache__ param in the query string.
elif request.params.get('__no_cache__'):
allow_cache = False
# Don't cache if we have extra vars containing data.
elif extra_vars:
for k, v in extra_vars.iteritems():
allow_cache = False
break
# Record cachability for the page cache if enabled
request.environ['CKAN_PAGE_CACHABLE'] = allow_cache
if allow_cache:
response.headers["Cache-Control"] = "public"
try:
cache_expire = int(config.get('ckan.cache_expires', 0))
response.headers["Cache-Control"] += \
", max-age=%s, must-revalidate" % cache_expire
except ValueError:
pass
else:
# We do not want caching.
response.headers["Cache-Control"] = "private"
# Prevent any further rendering from being cached.
request.environ['__no_cache__'] = True
# Render Time :)
try:
return cached_template(template_name, render_template)
except ckan.exceptions.CkanUrlException, e:
raise ckan.exceptions.CkanUrlException(
'\nAn Exception has been raised for template %s\n%s' %
(template_name, e.message))
def render(
template_name, extra_vars=None, cache_key=None, cache_type=None, cache_expire=None, cache_force=None, renderer=None
):
"""Render a template and return the output.
This is CKAN's main template rendering function.
.. todo::
Document the parameters of :py:func:`ckan.plugins.toolkit.render`.
"""
def render_template():
globs = extra_vars or {}
globs.update(pylons_globals())
# Using pylons.url() directly destroys the localisation stuff so
# we remove it so any bad templates crash and burn
del globs["url"]
try:
template_path, template_type = render_.template_info(template_name)
except render_.TemplateNotFound:
raise
log.debug("rendering %s [%s]" % (template_path, template_type))
if config.get("debug"):
context_vars = globs.get("c")
if context_vars:
context_vars = dir(context_vars)
debug_info = {
"template_name": template_name,
"template_path": template_path,
"template_type": template_type,
"vars": globs,
"c_vars": context_vars,
"renderer": renderer,
}
if "CKAN_DEBUG_INFO" not in request.environ:
request.environ["CKAN_DEBUG_INFO"] = []
request.environ["CKAN_DEBUG_INFO"].append(debug_info)
del globs["config"]
return render_jinja2(template_name, globs)
if "Pragma" in response.headers:
del response.headers["Pragma"]
## Caching Logic
allow_cache = True
# Force cache or not if explicit.
if cache_force is not None:
allow_cache = cache_force
# Do not allow caching of pages for logged in users/flash messages etc.
elif session.last_accessed:
allow_cache = False
# Tests etc.
elif "REMOTE_USER" in request.environ:
allow_cache = False
# Don't cache if based on a non-cachable template used in this.
elif request.environ.get("__no_cache__"):
allow_cache = False
# Don't cache if we have set the __no_cache__ param in the query string.
elif request.params.get("__no_cache__"):
allow_cache = False
# Don't cache if we have extra vars containing data.
elif extra_vars:
for k, v in extra_vars.iteritems():
allow_cache = False
break
# Record cachability for the page cache if enabled
request.environ["CKAN_PAGE_CACHABLE"] = allow_cache
if allow_cache:
response.headers["Cache-Control"] = "public"
try:
cache_expire = int(config.get("ckan.cache_expires", 0))
response.headers["Cache-Control"] += ", max-age=%s, must-revalidate" % cache_expire
except ValueError:
pass
else:
# We do not want caching.
response.headers["Cache-Control"] = "private"
# Prevent any further rendering from being cached.
request.environ["__no_cache__"] = True
# Render Time :)
try:
return cached_template(template_name, render_template)
except ckan.exceptions.CkanUrlException, e:
raise ckan.exceptions.CkanUrlException(
"\nAn Exception has been raised for template %s\n%s" % (template_name, e.message)
)
def render(template_name,
extra_vars=None,
cache_key=None,
cache_type=None,
cache_expire=None,
method='xhtml',
loader_class=MarkupTemplate,
cache_force=None):
''' Main genshi template rendering function. '''
def render_template():
globs = extra_vars or {}
globs.update(pylons_globals())
globs['actions'] = model.Action
# add the template name to the context to help us know where we are
# used in depreciating functions etc
c.__template_name = template_name
# Using pylons.url() directly destroys the localisation stuff so
# we remove it so any bad templates crash and burn
del globs['url']
template = globs['app_globals'].genshi_loader.load(template_name,
cls=loader_class)
stream = template.generate(**globs)
for item in PluginImplementations(IGenshiStreamFilter):
stream = item.filter(stream)
if loader_class == NewTextTemplate:
return literal(stream.render(method="text", encoding=None))
return literal(
stream.render(method=method, encoding=None, strip_whitespace=True))
if 'Pragma' in response.headers:
del response.headers["Pragma"]
## Caching Logic
allow_cache = True
# Force cache or not if explicit.
if cache_force is not None:
allow_cache = cache_force
# Do not allow caching of pages for logged in users/flash messages etc.
elif session.last_accessed:
allow_cache = False
# Tests etc.
elif 'REMOTE_USER' in request.environ:
allow_cache = False
# Don't cache if based on a non-cachable template used in this.
elif request.environ.get('__no_cache__'):
allow_cache = False
# Don't cache if we have set the __no_cache__ param in the query string.
elif request.params.get('__no_cache__'):
allow_cache = False
# Don't cache if we have extra vars containing data.
elif extra_vars:
for k, v in extra_vars.iteritems():
allow_cache = False
break
# Record cachability for the page cache if enabled
request.environ['CKAN_PAGE_CACHABLE'] = allow_cache
if allow_cache:
response.headers["Cache-Control"] = "public"
try:
cache_expire = int(config.get('ckan.cache_expires', 0))
response.headers[
"Cache-Control"] += ", max-age=%s, must-revalidate" % cache_expire
except ValueError:
pass
else:
# We do not want caching.
response.headers["Cache-Control"] = "private"
# Prevent any further rendering from being cached.
request.environ['__no_cache__'] = True
log.debug('Template cache-control: %s' % response.headers["Cache-Control"])
# Render Time :)
try:
return cached_template(template_name,
render_template,
loader_class=loader_class)
except ckan.exceptions.CkanUrlException, e:
raise ckan.exceptions.CkanUrlException(
'\nAn Exception has been raised for template %s\n%s' %
(template_name, e.message))
def render(template_name, extra_vars=None, cache_key=None, cache_type=None,
cache_expire=None, method='xhtml', loader_class=MarkupTemplate,
cache_force=None):
''' Main genshi template rendering function. '''
def render_template():
globs = extra_vars or {}
globs.update(pylons_globals())
globs['actions'] = model.Action
# add the template name to the context to help us know where we are
# used in depreciating functions etc
c.__template_name = template_name
# Using pylons.url() directly destroys the localisation stuff so
# we remove it so any bad templates crash and burn
del globs['url']
template = globs['app_globals'].genshi_loader.load(template_name,
cls=loader_class)
stream = template.generate(**globs)
for item in PluginImplementations(IGenshiStreamFilter):
stream = item.filter(stream)
if loader_class == NewTextTemplate:
return literal(stream.render(method="text", encoding=None))
return literal(stream.render(method=method, encoding=None,
strip_whitespace=True))
if 'Pragma' in response.headers:
del response.headers["Pragma"]
## Caching Logic
allow_cache = True
# Force cache or not if explicit.
if cache_force is not None:
allow_cache = cache_force
# Do not allow caching of pages for logged in users/flash messages etc.
elif session.last_accessed:
allow_cache = False
# Tests etc.
elif 'REMOTE_USER' in request.environ:
allow_cache = False
# Don't cache if based on a non-cachable template used in this.
elif request.environ.get('__no_cache__'):
allow_cache = False
# Don't cache if we have set the __no_cache__ param in the query string.
elif request.params.get('__no_cache__'):
allow_cache = False
# Don't cache if we have extra vars containing data.
elif extra_vars:
for k, v in extra_vars.iteritems():
allow_cache = False
break
# Record cachability for the page cache if enabled
request.environ['CKAN_PAGE_CACHABLE'] = allow_cache
if allow_cache:
response.headers["Cache-Control"] = "public"
try:
cache_expire = int(config.get('ckan.cache_expires', 0))
response.headers["Cache-Control"] += \
", max-age=%s, must-revalidate" % cache_expire
except ValueError:
pass
else:
# We do not want caching.
response.headers["Cache-Control"] = "private"
# Prevent any further rendering from being cached.
request.environ['__no_cache__'] = True
log.debug('Template cache-control: %s' % response.headers["Cache-Control"])
# Render Time :)
try:
return cached_template(template_name, render_template,
loader_class=loader_class)
except ckan.exceptions.CkanUrlException, e:
raise ckan.exceptions.CkanUrlException(
'\nAn Exception has been raised for template %s\n%s' %
(template_name, e.message))
