Source code for feincms3.templatetags.feincms3

from django import template
from django.conf import settings
from django.template.base import Node, TemplateSyntaxError, kwarg_re
from django.urls import NoReverseMatch
from django.utils.html import conditional_escape, mark_safe

from feincms3.applications import reverse_app as _reverse_app
from feincms3.utils import is_first_party_link

register = template.Library()

[docs] @register.simple_tag(takes_context=True) def render_region(context, regions, region, **kwargs): """ Render a single region. See :class:`~feincms3.renderer.RegionRenderer` for additional details. Usage:: {% render_region regions "main" %} """ return regions.render(region, context, **kwargs)
class ReverseAppNode(Node): def __init__(self, namespaces, view_name, args, kwargs, asvar): self.namespaces = namespaces self.view_name = view_name self.args = args self.kwargs = kwargs self.asvar = asvar def _current_app(self, context): try: return context.request.current_app except AttributeError: try: return context.request.resolver_match.namespace except AttributeError: return None def render(self, context): args = [arg.resolve(context) for arg in self.args] kwargs = {k: v.resolve(context) for k, v in self.kwargs.items()} namespaces = self.namespaces.resolve(context) view_name = self.view_name.resolve(context) fallback = kwargs.pop("fallback", None) if not isinstance(namespaces, (list, tuple)): namespaces = namespaces.split(",") # Try to look up the URL. If it fails, raise NoReverseMatch unless the # {% reverse ... as var %} construct is used, in which case return # nothing. url = "" try: url = _reverse_app( namespaces, view_name, args=args, kwargs=kwargs, current_app=self._current_app(context), ) except NoReverseMatch: if fallback is not None: url = fallback elif self.asvar is None: raise if self.asvar: context[self.asvar] = url return "" else: if context.autoescape: url = conditional_escape(url) return url
[docs] @register.tag def reverse_app(parser, token): """ Reverse app URLs, preferring the active language. Usage:: {% load feincms3 %} {% reverse_app 'blog' 'detail' [args] [kw=args] [fallback='/'] %} ``namespaces`` can either be a list or a comma-separated list of namespaces. ``NoReverseMatch`` exceptions can be avoided by providing a ``fallback`` as a keyword argument or by saving the result in a variable, similar to ``{% url 'view' as url %}`` does:: {% reverse_app 'newsletter' 'subscribe-form' fallback='/newsletter/' %} Or:: {% reverse_app 'extranet' 'login' as login_url %} """ bits = token.split_contents() if len(bits) < 3: raise TemplateSyntaxError( "'reverse_app' takes at least two arguments, a namespace and" " a URL pattern name." ) namespaces = parser.compile_filter(bits[1]) viewname = parser.compile_filter(bits[2]) args = [] kwargs = {} asvar = None bits = bits[3:] if len(bits) >= 2 and bits[-2] == "as": asvar = bits[-1] bits = bits[:-2] if len(bits): for bit in bits: match = kwarg_re.match(bit) if not match: raise TemplateSyntaxError("Malformed arguments to reverse_app tag") name, value = match.groups() if name: kwargs[name] = parser.compile_filter(value) else: args.append(parser.compile_filter(value)) return ReverseAppNode(namespaces, viewname, args, kwargs, asvar)
[docs] @register.filter def translations(iterable, languages=None): """ Return a list of dictionaries, one for each language in ``settings.LANGUAGES``. An example follows: .. code-block:: python [ {"code": "en", "name": "English", "object": <instance>}, {"code": "de", "name": "German", "object": None}, # ... ] The filter accepts anything you throw at it. "It" should be an iterable of objects having a ``language_code`` property however, or anything non-iterable (such as ``None``). The filter always returns a list of all languages in ``settings.LANGUAGES`` but the ``object`` key's value will always be ``None`` if the data is unusable. """ try: translations = {obj.language_code: obj for obj in iterable} if iterable else {} except TypeError: translations = {} return [ {"code": code, "name": name, "object": translations.get(code)} for code, name in (languages or settings.LANGUAGES) ]
@register.simple_tag def translations_from(*iterables, languages=None): t = { code: {"code": code, "name": name, "object": None} for code, name in (languages or settings.LANGUAGES) } for iterable in iterables: if iterable and not isinstance(iterable, str): for obj in iterable: t[obj.language_code]["object"] = obj return list(t.values())
[docs] @register.simple_tag def maybe_target_blank(href, *, attributes='target="_blank" rel="noopener"'): """ Return the value of ``attributes`` if the first argument isn't a first party link (as determined by :func:`~feincms3.utils.is_first_party_link`) Usage:: <a href="{{ url }}" {% maybe_target_blank url %}>...</a> """ if is_first_party_link(href): return "" return mark_safe(attributes)