contrib/shipherd/templatetags/shipherd.py

   1 from django import template
   2 from django.conf import settings
   3 from django.utils.safestring import mark_safe
   4 from philo.contrib.shipherd.models import Navigation
   5 from philo.models import Node
   6 from mptt.templatetags.mptt_tags import RecurseTreeNode, cache_tree_children
   7 from django.utils.translation import ugettext as _
   8
   9
  10 register = template.Library()
  11
  12
  13 class RecurseNavigationNode(RecurseTreeNode):
  14         def __init__(self, template_nodes, instance_var, key):
  15                 self.template_nodes = template_nodes
  16                 self.instance_var = instance_var
  17                 self.key = key
  18
  19         def _render_node(self, context, item, request):
  20                 bits = []
  21                 context.push()
  22                 for child in item.get_children():
  23                         context['item'] = child
  24                         bits.append(self._render_node(context, child, request))
  25                 context['item'] = item
  26                 context['children'] = mark_safe(u''.join(bits))
  27                 context['active'] = item.is_active(request)
  28                 context['active_descendants'] = item.has_active_descendants(request)
  29                 rendered = self.template_nodes.render(context)
  30                 context.pop()
  31                 return rendered
  32
  33         def render(self, context):
  34                 try:
  35                         request = context['request']
  36                 except KeyError:
  37                         return ''
  38
  39                 instance = self.instance_var.resolve(context)
  40
  41                 try:
  42                         navigation = instance.navigation[self.key]
  43                 except:
  44                         return settings.TEMPLATE_STRING_IF_INVALID
  45
  46                 bits = [self._render_node(context, item, request) for item in navigation]
  47                 return ''.join(bits)
  48
  49
  50 @register.tag
  51 def recursenavigation(parser, token):
  52         """
  53         Based on django-mptt's recursetree templatetag. In addition to {{ item }} and {{ children }},
  54         sets {{ active }} and {{ active_descendants }} in the context.
  55
  56         Note that the tag takes two variables: a Node instance and the key of the navigation to
  57         be recursed.
  58
  59         Usage:
  60                 <ul>
  61                         {% recursenavigation node main %}
  62                                 <li{% if active %} class='active'{% endif %}>
  63                                         {{ item.text }}
  64                                         {% if children %}
  65                                                 <ul>
  66                                                         {{ children }}
  67                                                 </ul>
  68                                         {% endif %}
  69                                 </li>
  70                         {% endrecursenavigation %}
  71                 </ul>
  72         """
  73         bits = token.contents.split()
  74         if len(bits) != 3:
  75                 raise template.TemplateSyntaxError(_('%s tag requires two arguments: a node and a navigation section name') % bits[0])
  76
  77         instance_var = parser.compile_filter(bits[1])
  78         key = bits[2]
  79
  80         template_nodes = parser.parse(('endrecursenavigation',))
  81         parser.delete_first_token()
  82
  83         return RecurseNavigationNode(template_nodes, instance_var, key)
  84
  85
  86 @register.filter
  87 def has_navigation(node, key=None):
  88         try:
  89                 nav = node.navigation
  90                 if key is not None:
  91                         if key in nav and bool(node.navigation[key]):
  92                                 return True
  93                         elif key not in node.navigation:
  94                                 return False
  95                 return bool(node.navigation)
  96         except:
  97                 return False
  98
  99
 100 @register.filter
 101 def navigation_host(node, key):
 102         try:
 103                 return Navigation.objects.filter(node__in=node.get_ancestors(include_self=True), key=key).order_by('-node__level')[0].node
 104         except:
 105                 if settings.TEMPLATE_DEBUG:
 106                         raise
 107                 return node