class TweetButton(Tag):
name = 'tweet_button'
options = Options(
Argument('text'),
'link_to',
Argument('obj', required=False),
)
def render_tag(self, context, text, obj):
return render_to_string('twitter/tweet_button.html', {
'BASE_URL': settings.BASE_URL,
'text': text,
'obj': obj,
})
class GardenMemberList(InclusionTag):
options = Options(Argument('garden'), )
template = 'farmingconcrete/garden_member_list.html'
def get_garden_members(self, garden):
if garden:
return garden.gardenmembership_set.all()
return []
def get_context(self, context, garden):
context.update({
'members': self.get_garden_members(garden),
})
return context
class RenderBundledMedia(Tag):
name = 'render_bundled_media'
options = Options(
Argument('name'),
parser_class=MediaParser,
)
def cache_get(self, key):
packed_val = cache.get(key)
if packed_val is None:
return None
val, refresh_time, refreshed = packed_val
if (time.time() > refresh_time) and not refreshed:
# Store the stale value while the cache
# revalidates for another MINT_DELAY seconds.
self.cache_set(key, val, timeout=MINT_DELAY, refreshed=True)
return None
return val
def cache_set(self, key, val, timeout=REBUILD_TIMEOUT, refreshed=False):
refresh_time = timeout + time.time()
real_timeout = timeout + MINT_DELAY
packed_val = (val, refresh_time, refreshed)
return cache.set(key, packed_val, real_timeout)
@property
def nodelist(self):
return self.blocks['nodelist']
def render_tag(self, context, name, nodelist):
request = context['request']
rendered_contents = nodelist.render(context)
content = request.media_holder[name].render()
if settings.COMPRESS:
if name == 'css':
compressor = CssCompressor(content)
elif name == 'js':
compressor = JsCompressor(content)
output = self.cache_get(compressor.cachekey)
if output is None:
try:
output = compressor.output()
self.cache_set(compressor.cachekey, output)
except:
from traceback import format_exc
raise Exception(format_exc())
else:
output = content # no compression
return '%s\n%s' % (output, rendered_contents)
class CMSEditableObjectBlock(CMSEditableObject):
"""
Templatetag that links a content extracted from a generic django model
to the model admin changeform.
The rendered content is to be specified in the enclosed block.
"""
name = 'render_model_block'
options = Options(
Argument('instance'),
Argument('edit_fields', default=None, required=False),
Argument('language', default=None, required=False),
Argument('view_url', default=None, required=False),
Argument('view_method', default=None, required=False),
'as',
Argument('varname', required=False, resolve=False),
blocks=[('endrender_model_block', 'nodelist')],
)
def render_tag(self, context, **kwargs):
"""
Renders the block and then inject the resulting HTML in the template
context
"""
context.push()
template = self.get_template(context, **kwargs)
data = self.get_context(context, **kwargs)
data['content'] = mark_safe(kwargs['nodelist'].render(data))
data['rendered_content'] = data['content']
output = render_to_string(template, data)
context.pop()
if kwargs.get('varname'):
context[kwargs['varname']] = output
return ''
else:
return output
def get_context(self, context, instance, edit_fields, language, view_url,
view_method, varname, nodelist):
"""
Uses _get_empty_context and adds the `instance` object to the local
context. Context here is to be intended as the context of the nodelist
in the block.
"""
extra_context = self._get_empty_context(context, instance, edit_fields,
language, view_url,
view_method)
extra_context['instance'] = instance
extra_context['render_model_block'] = True
return extra_context
class GetGrid(AsTag):
name = 'get_grid'
options = Options(
MultiValueArgument('keys', required=False, resolve=False),
'as',
Argument('varname', required=False, resolve=False, default="grid")
)
def get_value(self, context, keys):
key = get_key(context, keys)
grid, created = models.Grid.objects.get_or_create(key=key)
return grid
class RenderPlaceholder(Tag):
name = 'render_placeholder'
options = Options(
Argument('placeholder'),
Argument('width', default=None, required=False),
)
def render_tag(self, context, placeholder, width):
request = context.get('request', None)
if not request:
return ''
if not placeholder:
return ''
return safe(placeholder.render(context, width))
class CMSToolbar(RenderBlock):
name = 'cms_toolbar'
options = Options(
Argument('name', required=False
), # just here so sekizai thinks this is a RenderBlock
parser_class=SekizaiParser,
)
def render_tag(self, context, name, nodelist):
# render JS
request = context.get('request', None)
toolbar = getattr(request, 'toolbar', None)
if toolbar:
toolbar.init_toolbar(request)
toolbar.populate()
if request and 'cms-toolbar-login-error' in request.GET:
context['cms_toolbar_login_error'] = request.GET[
'cms-toolbar-login-error'] == '1'
context['cms_version'] = __version__
context['django_version'] = DJANGO_VERSION
context['python_version'] = PYTHON_VERSION
context['cms_edit_on'] = get_cms_setting('CMS_TOOLBAR_URL__EDIT_ON')
context['cms_edit_off'] = get_cms_setting('CMS_TOOLBAR_URL__EDIT_OFF')
if toolbar and toolbar.show_toolbar:
language = toolbar.toolbar_language
with force_language(language):
# needed to populate the context with sekizai content
render_to_string('cms/toolbar/toolbar_javascript.html',
flatten_context(context))
context['addons'] = mark_safe(toolbar.render_addons(context))
else:
language = None
# render everything below the tag
rendered_contents = nodelist.render(context)
# sanity checks
if not request:
return rendered_contents
if not toolbar:
return rendered_contents
if not toolbar.show_toolbar:
return rendered_contents
# render the toolbar content
request.toolbar.post_template_populate()
with force_language(language):
addons = mark_safe(toolbar.post_template_render_addons(context))
toolbar = render_to_string('cms/toolbar/toolbar.html',
flatten_context(context))
# return the toolbar content and the content below
return '%s\n%s\n%s' % (toolbar, addons, rendered_contents)
class BaseChart(BasePanel):
name = 'chart'
template = 'tags/chart.html'
options = Options(
Argument('container_id'),
MultiKeywordArgument('kw', required=False),
blocks=[('endchart', 'nodelist')],
)
DEFAULT_STYLES = 'min-width: 310px; height: 400px; margin: 0 auto'
def get_panel_context(self, arguments):
kw = arguments.pop('kw')
arguments['style'] = kw.get('style', self.DEFAULT_STYLES)
return arguments
class Panel(BasePanel):
name = 'panel'
template = 'tags/panel.html'
options = Options(
Argument('title'),
MultiKeywordArgument('kw', required=False),
blocks=[('endpanel', 'nodelist')],
)
def get_panel_context(self, arguments):
kw = arguments.pop('kw')
arguments['state'] = kw.get('state', 'default')
arguments['icon'] = kw.get('icon', 'fa-cube')
return arguments
class Addtoblock(SekizaiTag):
name = 'addtoblock'
options = Options(
Argument('name'),
parser_class=AddtoblockParser,
)
def render_tag(self, context, name, nodelist):
rendered_contents = nodelist.render(context)
varname = getattr(settings, 'SEKIZAI_VARNAME',
'SEKIZAI_CONTENT_HOLDER')
context[varname][name].append(rendered_contents)
return ""
class MainMenuEmbodyId(MainMenu):
name = 'main_menu_embody_id'
options = Options(
Argument('root_id', default=None, required=False),
StringArgument(
'template',
default='bootstrap{}/menu/navbar.html'.format(BOOTSTRAP),
required=False),
IntegerArgument('offset', default=0, required=False),
IntegerArgument('limit', default=100, required=False),
StringArgument('namespace', default=None, required=False),
Flag('embody_root', default=True, false_values=['skip_root']),
Argument('next_page', default=None, required=False),
)
class CMSEditableObjectAddBlock(CMSEditableObject):
"""
Templatetag that links arbitrary content to the addform for the specified
model (based on the provided model instance).
"""
name = 'render_model_add_block'
options = Options(
Argument('instance'),
Argument('language', default=None, required=False),
Argument('view_url', default=None, required=False),
Argument('view_method', default=None, required=False),
'as',
Argument('varname', required=False, resolve=False),
blocks=[('endrender_model_add_block', 'nodelist')],
)
def render_tag(self, context, **kwargs):
"""
Renders the block and then inject the resulting HTML in the template
context
"""
context.push()
template = self.get_template(context, **kwargs)
data = self.get_context(context, **kwargs)
data['content'] = kwargs['nodelist'].render(data)
data['rendered_content'] = data['content']
output = render_to_string(template, flatten_context(data))
context.pop()
if kwargs.get('varname'):
context[kwargs['varname']] = output
return ''
else:
return output
def get_context(self, context, **kwargs):
"""
Uses _get_empty_context and adds the `render_model_icon` variable.
"""
instance = kwargs.pop('instance')
if isinstance(instance, Model) and not instance.pk:
instance.pk = 0
kwargs.pop('varname')
kwargs.pop('nodelist')
extra_context = self._get_empty_context(context,
instance,
None,
editmode=False,
**kwargs)
extra_context['render_model_add'] = True
return extra_context
class MainMenu(ShowMenu):
name = 'main_menu'
options = Options(
IntegerArgument('from_level', default=0, required=False),
IntegerArgument('to_level', default=100, required=False),
StringArgument('template', default='cms/bootstrap3/main-menu.html', required=False),
StringArgument('namespace', default=None, required=False),
StringArgument('root_id', default=None, required=False),
Argument('next_page', default=None, required=False),
)
def get_context(self, context, from_level, to_level, template, namespace, root_id, next_page):
return super(MainMenu, self).get_context(context, from_level, to_level, 100, 100, template, namespace, root_id, next_page)
class TaskPairs(AsTag):
options = Options(
'as',
Argument('varname', resolve=False, required=False),
)
def get_value(self, context):
"""Get tasks in pairs, useful for PDF pairing of tasks"""
tasks = Task.objects.all().values_list('name', flat=True)
for i in range(0, len(tasks), 2):
try:
yield (tasks[i], tasks[i + 1])
except IndexError:
yield (tasks[i], )
class Products(InclusionTag):
"""
Inclusion tag for displaying all products.
"""
template = 'shop/templatetags/_products.html'
options = Options(Argument('objects', resolve=True, required=False), )
def get_context(self, context, objects):
if objects is None:
objects = Product.objects.filter(active=True)
context.update({
'products': objects,
})
return context
class EasyMapTag(InclusionTag):
"""
The syntax:
{% easy_map <address> [<width> <height>] [<zoom>] [using <template_name>] %}
The "address" parameter can be an ``easy_maps.Address`` instance
or a string describing it. If an address is not found a new entry
is created in the database.
"""
name = 'easy_map'
template = 'easy_maps/map.html'
options = Options(
Argument('address', resolve=True, required=True),
Argument('width', required=False, default=None),
Argument('height', required=False, default=None),
IntegerArgument('zoom', required=False, default=None),
'using',
Argument('template_name', default=None, required=False),
)
def render_tag(self, context, **kwargs):
params = dict((k, v) for k, v in kwargs.items()
if v and k not in ['template_name'])
if 'address' in params and (len(params) == 2 or len(params) > 4):
raise template.TemplateSyntaxError(
"easy_map tag has the following syntax: "
"{% easy_map <address> [<width> <height>] [zoom] [using <template_name>] %}"
)
if settings.EASY_MAPS_GOOGLE_KEY is None and settings.EASY_MAPS_GOOGLE_MAPS_API_KEY is None:
raise ImproperlyConfigured(
"easy_map tag requires EASY_MAPS_GOOGLE_KEY to be set in global settings "
"because of the restrictions introduced in Google Maps API v3 by Google, Inc."
)
return super(EasyMapTag, self).render_tag(context, **kwargs)
def get_template(self, context, **kwargs):
return kwargs.get('template_name', None) or self.template
def get_context(self, context, **kwargs):
kwargs.update({'map': parse_address(kwargs.pop('address'))})
if not kwargs.get('zoom', None):
kwargs['zoom'] = settings.EASY_MAPS_ZOOM # default value
kwargs['language'] = settings.EASY_MAPS_LANGUAGE
kwargs[
'api_key'] = settings.EASY_MAPS_GOOGLE_KEY or settings.EASY_MAPS_GOOGLE_MAPS_API_KEY
return kwargs
class RenderPlaceholder(AsTag):
"""
Render the content of the plugins contained in a placeholder.
The result can be assigned to a variable within the template's context by using the `as` keyword.
It behaves in the same way as the `PageAttribute` class, check its docstring for more details.
"""
name = 'render_placeholder'
options = Options(Argument('placeholder'),
Argument('width', default=None, required=False),
'language',
Argument('language', default=None, required=False), 'as',
Argument('varname', required=False, resolve=False))
def _get_value(self, context, editable=True, **kwargs):
request = context.get('request', None)
placeholder = kwargs.get('placeholder')
width = kwargs.get('width')
nocache = kwargs.get('nocache', False)
language = kwargs.get('language')
if not request:
return ''
if not placeholder:
return ''
if isinstance(placeholder, string_types):
placeholder = PlaceholderModel.objects.get(slot=placeholder)
if not hasattr(request, 'placeholders'):
request.placeholders = {}
perms = (placeholder.has_change_permission(request)
or not placeholder.cache_placeholder)
if not perms or placeholder.slot not in request.placeholders:
request.placeholders[placeholder.slot] = (placeholder, perms)
else:
request.placeholders[placeholder.slot] = (
placeholder, perms
and request.placeholders[placeholder.slot][1])
context = copy(context)
return safe(
placeholder.render(context,
width,
lang=language,
editable=editable,
use_cache=not nocache))
def get_value_for_context(self, context, **kwargs):
return self._get_value(context, editable=False, **kwargs)
def get_value(self, context, **kwargs):
return self._get_value(context, **kwargs)
class LanguageChooser(InclusionTag):
"""
Displays a language chooser
- template: template used to render the language chooser
"""
name = 'language_chooser'
template = 'menu/dummy.html'
options = Options(
Argument('template', default=NOT_PROVIDED, required=False),
Argument('i18n_mode', default='raw', required=False),
)
def get_context(self, context, template, i18n_mode):
if template in MARKERS:
_tmp = template
if i18n_mode not in MARKERS:
template = i18n_mode
else:
template = NOT_PROVIDED
i18n_mode = _tmp
if template is NOT_PROVIDED:
template = "menu/language_chooser.html"
if not i18n_mode in MARKERS:
i18n_mode = 'raw'
if 'request' not in context:
# If there's an exception (500), default context_processors may not be called.
return {'template': 'cms/content.html'}
marker = MARKERS[i18n_mode]
current_lang = get_language()
site = Site.objects.get_current()
request = context['request']
if request.user.is_staff:
languages = get_language_list(site_id=site.pk)
else:
languages = get_public_languages(site_id=site.pk)
languages_info = []
for language in languages:
obj = get_language_object(language, site_id=site.pk)
languages_info.append((obj['code'], marker(obj['name'],
obj['code'])))
context['languages'] = languages_info
context['current_language'] = current_lang
context['template'] = template
return context
class ProductTypeIcon(Tag):
name = "product_type_icon"
options = Options(
Argument('product_type', resolve=True, required=True),
Argument('tag', resolve=True, required=True),
)
def render_tag(self, context, product_type, tag):
try:
icon = product_type.icons.get(name=tag)
return icon.image.url
except Exception, error:
return ApplicationSettings.DEFAULT_CATEGORY_IMAGE_URL.format(
tag.lower())
class SkillsShareds(AsTag):
options = Options(
'as',
Argument('varname', resolve=False, required=False),
)
def get_value(self, context):
shared = (
'skills_shared',
'concepts_shared',
'projects_proposed',
'ideas_to_learn',
'intentions_to_collaborate',
)
return dict([(s, s.replace('_', ' ')) for s in shared])
class RenderPlugin(Tag):
name = 'render_plugin'
options = Options(Argument('plugin'))
def render_tag(self, context, plugin):
if not plugin:
return ''
content_renderer = context['cms_content_renderer']
content = content_renderer.render_plugin(
instance=plugin,
context=context,
editable=content_renderer.user_is_on_edit_mode(),
)
return content
class Paginate(Tag):
"""Paginate the given queryset, placing a Pager in the template context."""
name = "paginate"
options = Options(
Argument("queryset"),
"as",
Argument("varname", resolve=False),
)
def render_tag(self, context, queryset, varname):
"""Place Pager for given ``queryset`` in context as ``varname``."""
request = context["request"]
pagesize, pagenum = pagination.from_request(request)
context[varname] = pagination.Pager(queryset, pagesize, pagenum)
return u""
class PageTagsList(AsTag):
name = 'page_tags'
title = False
options = Options(Argument('page_lookup'),
Argument('lang', required=False, default=None),
Argument('site', required=False, default=None), 'as',
Argument('varname', required=True, resolve=False))
def get_value(self, context, page_lookup, lang, site):
request = context.get('request', False)
if not request: # pragma: no cover
return ''
return get_page_tags_from_request(request, page_lookup, lang, site,
self.title)
class RenderPlugin(Tag):
name = 'render_plugin'
options = Options(Argument('plugin'))
def render_tag(self, context, plugin):
if not plugin:
raise TemplateSyntaxError("Plugin is missing")
content_renderer = context['cms_content_renderer']
content = content_renderer.render_plugin(
instance=plugin,
context=context,
editable=content_renderer.user_is_on_edit_mode(),
)
return content
class JavascriptString(Tag):
name = 'javascript_string'
options = Options(
blocks=[
('end_javascript_string', 'nodelist'),
]
)
def render_tag(self, context, **kwargs):
try:
from django.utils.html import escapejs
except ImportError:
from django.utils.text import javascript_quote as escapejs
rendered = self.nodelist.render(context)
return "'%s'" % escapejs(rendered.strip())
class IfCanDelete(Tag):
name = 'ifcandelete'
options = Options(
Argument('metric'),
blocks=[('endifcandelete', 'nodelist')],
)
def render_tag(self, context, metric, nodelist):
user = context['user']
meta = metric['model']._meta
if user.has_perm(
'%s.%s' %
(meta.app_label, get_permission_codename('delete', meta))):
return nodelist.render(context)
return ''
class MetricContentType(AsTag):
options = Options(
Argument('metric', resolve=True, required=True),
'for',
Argument('model', resolve=True, required=False),
'as',
Argument('varname', resolve=False, required=False),
)
def get_value(self, context, metric, model):
if model:
app_name, model_name = model.split('.')
return ContentType.objects.get_by_natural_key(app_name, model_name)
return ContentType.objects.get_for_model(metric['model'])
class GetRelatedCategories(AsTag):
"""
A template tag to retrieve as a context variable, all the categories related via a
CategoryPlugin to one or more of the pages targeted by a queryset or iterable.
eg:
{% get_related_category_pages pages as categories %}
Keyword arguments:
pages: a queryset of iterable targeting a group of cms pages.
"""
options = Options(
Argument("pages", required=True),
"as",
Argument("varname", required=True, resolve=False),
)
def get_value(self, context, **kwargs):
"""
Get all categories related to either of the pages targeted by the queryset or
iterator passed in argument.
"""
current_page = context["current_page"]
language = translation.get_language()
selector = "category_plugins__cmsplugin_ptr__"
filter_dict = {
f"{selector:s}language": language,
f"{selector:s}placeholder__page__publisher_is_draft":
current_page.publisher_is_draft,
f"{selector:s}placeholder__page__in": kwargs["pages"],
}
if context["current_page"].publisher_is_draft:
query = Category.objects.filter(
extended_object__publisher_is_draft=True,
extended_object__in=Page.objects.filter(**filter_dict),
)
else:
query = Category.objects.filter(
extended_object__publisher_is_draft=False,
extended_object__publisher_public__in=Page.objects.filter(
**filter_dict),
)
return (query.select_related("extended_object").order_by(
"extended_object__node__path").distinct())
class EasyMapTag(InclusionTag):
"""
The syntax:
{% easy_map <address> [<width> <height>] [<zoom>] [using <template_name>] %}
The "address" parameter can be an ``easy_maps.Address`` instance or a string
describing it. If an address is not found a new entry is created
in the database.
"""
name = 'easy_map'
template = 'easy_maps/map.html'
options = Options(
Argument('address', resolve=True, required=True),
IntegerArgument('width', required=False, default=None),
IntegerArgument('height', required=False, default=None),
IntegerArgument('zoom', required=False, default=16),
'using',
Argument('template_name', default=None, required=False),
)
def render_tag(self, context, **kwargs):
params = dict((k, v) for k, v in kwargs.items() if v is not None)
if len(params.keys()) == 3 or len(params.keys()) > 5:
raise template.TemplateSyntaxError(
"easy_map tag has the following syntax: "
"{% easy_map <address> [<width> <height>] [zoom] [using <template_name>] %}"
)
return super(EasyMapTag, self).render_tag(context, **kwargs)
def get_template(self, context, **kwargs):
return kwargs.get('template_name', None) or self.template
def parse_address(self, address=None):
if isinstance(address, Address):
return address
if not address:
return Address(latitude=CENTER[0], longitude=CENTER[1])
else:
return Address.objects.get_or_create(address=address)[0]
raise NotImplementedError
def get_context(self, context, **kwargs):
kwargs.update({'map': self.parse_address(kwargs.pop('address'))})
return kwargs
class ShowPagesAroundPage(InclusionTag):
"""
give the one level deep neighbour of a page
"""
name = 'dju_show_pages_around_page'
template = 'dju_page_thumbnail/dju_show_pages_around_page.html'
options = Options(
StringArgument(
'template',
default='dju_page_thumbnail/dju_show_pages_around_page.html',
required=False), )
def get_context(self, context, template):
try:
# If there's an exception (500), default context_processors may not be called.
request = context['request']
except KeyError:
return {'template': 'menu/empty.html'}
currentPage = request.current_page
def get_info(page):
try:
imageurl = page.djupagethumbnail.image.url
except:
imageurl = ''
return page.get_absolute_url(), page.get_title(), imageurl
scanval = [('parent', [currentPage.get_parent()]),
('siblings', currentPage.get_siblings()),
('descendants', currentPage.get_descendants())]
data = {}
for datatype, objectslist in scanval:
datalist = []
for p in objectslist:
abs_url, title, imageurl = get_info(p)
datalist.append({
'abs_url': abs_url,
'title': title,
'imageurl': imageurl
})
data[datatype] = datalist
try:
context.update({'data': data, 'template': template})
except:
context = {'template': template}
return context
