forum/templatetags/extra_tags.py

   1 import time
   2 import os
   3 import posixpath
   4 import datetime
   5 import math
   6 import re
   7 import logging
   8 from django import template
   9 from django.utils.encoding import smart_unicode
  10 from django.utils.safestring import mark_safe
  11 from forum.models import Question, Answer, QuestionRevision, AnswerRevision, NodeRevision
  12 from django.utils.translation import ugettext as _
  13 from django.utils.translation import ungettext
  14 from django.utils import simplejson
  15 from forum import settings
  16 from django.template.defaulttags import url as default_url
  17 from forum import skins
  18 from forum.utils import html
  19 from django.core.urlresolvers import reverse
  20
  21 register = template.Library()
  22
  23 GRAVATAR_TEMPLATE = ('<img class="gravatar" width="%(size)s" height="%(size)s" '
  24 'src="http://www.gravatar.com/avatar/%(gravatar_hash)s'
  25 '?s=%(size)s&amp;d=identicon&amp;r=PG" '
  26 'alt="%(username)s\'s gravatar image" />')
  27
  28 @register.simple_tag
  29 def gravatar(user, size):
  30     try:
  31         gravatar = user['gravatar']
  32         username = user['username']
  33     except (TypeError, AttributeError, KeyError):
  34         gravatar = user.gravatar
  35         username = user.username
  36     return mark_safe(GRAVATAR_TEMPLATE % {
  37     'size': size,
  38     'gravatar_hash': gravatar,
  39     'username': template.defaultfilters.urlencode(username),
  40     })
  41
  42
  43 LEADING_PAGE_RANGE_DISPLAYED = TRAILING_PAGE_RANGE_DISPLAYED = 5
  44 LEADING_PAGE_RANGE = TRAILING_PAGE_RANGE = 4
  45 NUM_PAGES_OUTSIDE_RANGE = 1
  46 ADJACENT_PAGES = 2
  47 @register.inclusion_tag("paginator.html")
  48 def cnprog_paginator(context):
  49     """
  50     custom paginator tag
  51     Inspired from http://blog.localkinegrinds.com/2007/09/06/digg-style-pagination-in-django/
  52     """
  53     if (context["is_paginated"]):
  54         " Initialize variables "
  55         in_leading_range = in_trailing_range = False
  56         pages_outside_leading_range = pages_outside_trailing_range = range(0)
  57
  58         if (context["pages"] <= LEADING_PAGE_RANGE_DISPLAYED):
  59             in_leading_range = in_trailing_range = True
  60             page_numbers = [n for n in range(1, context["pages"] + 1) if n > 0 and n <= context["pages"]]
  61         elif (context["page"] <= LEADING_PAGE_RANGE):
  62             in_leading_range = True
  63             page_numbers = [n for n in range(1, LEADING_PAGE_RANGE_DISPLAYED + 1) if n > 0 and n <= context["pages"]]
  64             pages_outside_leading_range = [n + context["pages"] for n in range(0, -NUM_PAGES_OUTSIDE_RANGE, -1)]
  65         elif (context["page"] > context["pages"] - TRAILING_PAGE_RANGE):
  66             in_trailing_range = True
  67             page_numbers = [n for n in range(context["pages"] - TRAILING_PAGE_RANGE_DISPLAYED + 1, context["pages"] + 1)
  68                             if n > 0 and n <= context["pages"]]
  69             pages_outside_trailing_range = [n + 1 for n in range(0, NUM_PAGES_OUTSIDE_RANGE)]
  70         else:
  71             page_numbers = [n for n in range(context["page"] - ADJACENT_PAGES, context["page"] + ADJACENT_PAGES + 1) if
  72                             n > 0 and n <= context["pages"]]
  73             pages_outside_leading_range = [n + context["pages"] for n in range(0, -NUM_PAGES_OUTSIDE_RANGE, -1)]
  74             pages_outside_trailing_range = [n + 1 for n in range(0, NUM_PAGES_OUTSIDE_RANGE)]
  75
  76         extend_url = context.get('extend_url', '')
  77         return {
  78         "base_url": context["base_url"],
  79         "is_paginated": context["is_paginated"],
  80         "previous": context["previous"],
  81         "has_previous": context["has_previous"],
  82         "next": context["next"],
  83         "has_next": context["has_next"],
  84         "page": context["page"],
  85         "pages": context["pages"],
  86         "page_numbers": page_numbers,
  87         "in_leading_range" : in_leading_range,
  88         "in_trailing_range" : in_trailing_range,
  89         "pages_outside_leading_range": pages_outside_leading_range,
  90         "pages_outside_trailing_range": pages_outside_trailing_range,
  91         "extend_url" : extend_url
  92         }
  93
  94 @register.inclusion_tag("pagesize.html")
  95 def cnprog_pagesize(context):
  96     """
  97     display the pagesize selection boxes for paginator
  98     """
  99     if (context["is_paginated"]):
 100         return {
 101         "base_url": context["base_url"],
 102         "pagesize" : context["pagesize"],
 103         "is_paginated": context["is_paginated"]
 104         }
 105
 106
 107 @register.simple_tag
 108 def get_score_badge(user):
 109     BADGE_TEMPLATE = '<span class="score" title="%(reputation)s %(reputationword)s">%(reputation)s</span>'
 110     if user.gold > 0 :
 111         BADGE_TEMPLATE = '%s%s' % (BADGE_TEMPLATE, '<span title="%(gold)s %(badgesword)s">'
 112         '<span class="badge1">&#9679;</span>'
 113         '<span class="badgecount">%(gold)s</span>'
 114         '</span>')
 115     if user.silver > 0:
 116         BADGE_TEMPLATE = '%s%s' % (BADGE_TEMPLATE, '<span title="%(silver)s %(badgesword)s">'
 117         '<span class="silver">&#9679;</span>'
 118         '<span class="badgecount">%(silver)s</span>'
 119         '</span>')
 120     if user.bronze > 0:
 121         BADGE_TEMPLATE = '%s%s' % (BADGE_TEMPLATE, '<span title="%(bronze)s %(badgesword)s">'
 122         '<span class="bronze">&#9679;</span>'
 123         '<span class="badgecount">%(bronze)s</span>'
 124         '</span>')
 125     BADGE_TEMPLATE = smart_unicode(BADGE_TEMPLATE, encoding='utf-8', strings_only=False, errors='strict')
 126     return mark_safe(BADGE_TEMPLATE % {
 127     'reputation' : user.reputation,
 128     'gold' : user.gold,
 129     'silver' : user.silver,
 130     'bronze' : user.bronze,
 131     'badgesword' : _('badges'),
 132     'reputationword' : _('reputation points'),
 133     })
 134
 135
 136 @register.simple_tag
 137 def get_age(birthday):
 138     current_time = datetime.datetime(*time.localtime()[0:6])
 139     year = birthday.year
 140     month = birthday.month
 141     day = birthday.day
 142     diff = current_time - datetime.datetime(year, month, day, 0, 0, 0)
 143     return diff.days / 365
 144
 145 @register.simple_tag
 146 def diff_date(date, limen=2):
 147     if not date:
 148         return _('unknown')
 149
 150     now = datetime.datetime.now()
 151     diff = now - date
 152     days = diff.days
 153     hours = int(diff.seconds/3600)
 154     minutes = int(diff.seconds/60)
 155
 156     if days > 2:
 157         if date.year == now.year:
 158             return date.strftime("%b %d at %H:%M")
 159         else:
 160             return date.strftime("%b %d '%y at %H:%M")
 161     elif days == 2:
 162         return _('2 days ago')
 163     elif days == 1:
 164         return _('yesterday')
 165     elif minutes >= 60:
 166         return ungettext('%(hr)d hour ago', '%(hr)d hours ago', hours) % {'hr':hours}
 167     else:
 168         return ungettext('%(min)d min ago', '%(min)d mins ago', minutes) % {'min':minutes}
 169
 170 @register.simple_tag
 171 def media(url):
 172     url = skins.find_media_source(url)
 173     if url:
 174         url = '///' + settings.FORUM_SCRIPT_ALIAS + '/m/' + url
 175         return posixpath.normpath(url)
 176
 177 class ItemSeparatorNode(template.Node):
 178     def __init__(self, separator):
 179         sep = separator.strip()
 180         if sep[0] == sep[-1] and sep[0] in ('\'', '"'):
 181             sep = sep[1:-1]
 182         else:
 183             raise template.TemplateSyntaxError('separator in joinitems tag must be quoted')
 184         self.content = sep
 185
 186     def render(self, context):
 187         return self.content
 188
 189 class BlockMediaUrlNode(template.Node):
 190     def __init__(self, nodelist):
 191         self.items = nodelist
 192
 193     def render(self, context):
 194         prefix = '///' + settings.FORUM_SCRIPT_ALIAS + 'm/'
 195         url = ''
 196         if self.items:
 197             url += '/'
 198         for item in self.items:
 199             url += item.render(context)
 200
 201         url = skins.find_media_source(url)
 202         url = prefix + url
 203         out = posixpath.normpath(url)
 204         return out.replace(' ', '')
 205
 206 @register.tag(name='blockmedia')
 207 def blockmedia(parser, token):
 208     try:
 209         tagname = token.split_contents()
 210     except ValueError:
 211         raise template.TemplateSyntaxError("blockmedia tag does not use arguments")
 212     nodelist = []
 213     while True:
 214         nodelist.append(parser.parse(('endblockmedia')))
 215         next = parser.next_token()
 216         if next.contents == 'endblockmedia':
 217             break
 218     return BlockMediaUrlNode(nodelist)
 219
 220
 221 @register.simple_tag
 222 def fullmedia(url):
 223     domain = settings.APP_URL
 224     #protocol = getattr(settings, "PROTOCOL", "http")
 225     path = media(url)
 226     return "%s%s" % (domain, path)
 227
 228
 229 class SimpleVarNode(template.Node):
 230     def __init__(self, name, value):
 231         self.name = name
 232         self.value = template.Variable(value)
 233
 234     def render(self, context):
 235         context[self.name] = self.value.resolve(context)
 236         return ''
 237
 238 class BlockVarNode(template.Node):
 239     def __init__(self, name, block):
 240         self.name = name
 241         self.block = block
 242
 243     def render(self, context):
 244         source = self.block.render(context)
 245         context[self.name] = source.strip()
 246         return ''
 247
 248
 249 @register.tag(name='var')
 250 def do_var(parser, token):
 251     tokens = token.split_contents()[1:]
 252
 253     if not len(tokens) or not re.match('^\w+$', tokens[0]):
 254         raise template.TemplateSyntaxError("Expected variable name")
 255
 256     if len(tokens) == 1:
 257         nodelist = parser.parse(('endvar',))
 258         parser.delete_first_token()
 259         return BlockVarNode(tokens[0], nodelist)
 260     elif len(tokens) == 3:
 261         return SimpleVarNode(tokens[0], tokens[2])
 262
 263     raise template.TemplateSyntaxError("Invalid number of arguments")
 264
 265 class DeclareNode(template.Node):
 266     dec_re = re.compile('^\s*(\w+)\s*(:?=)\s*(.*)$')
 267
 268     def __init__(self, block):
 269         self.block = block
 270
 271     def render(self, context):
 272         source = self.block.render(context)
 273
 274         for line in source.splitlines():
 275             m = self.dec_re.search(line)
 276             if m:
 277                 clist = list(context)
 278                 clist.reverse()
 279                 d = {}
 280                 d['_'] = _
 281                 d['os'] = os
 282                 d['html'] = html
 283                 d['reverse'] = reverse
 284                 for c in clist:
 285                     d.update(c)
 286                 try:
 287                     context[m.group(1).strip()] = eval(m.group(3).strip(), d)
 288                 except Exception, e:
 289                     logging.error("Error in declare tag, when evaluating: %s" % m.group(3).strip())
 290                     raise
 291         return ''
 292
 293 @register.tag(name='declare')
 294 def do_declare(parser, token):
 295     nodelist = parser.parse(('enddeclare',))
 296     parser.delete_first_token()
 297     return DeclareNode(nodelist)