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.const import *
  12 from forum.models import Question, Answer, QuestionRevision, AnswerRevision, NodeRevision
  13 from django.utils.translation import ugettext as _
  14 from django.utils.translation import ungettext
  15 from django.utils import simplejson
  16 from django.conf import settings
  17 from django.template.defaulttags import url as default_url
  18 from forum import skins
  19
  20 register = template.Library()
  21
  22 GRAVATAR_TEMPLATE = ('<img class="gravatar" width="%(size)s" height="%(size)s" '
  23                      'src="http://www.gravatar.com/avatar/%(gravatar_hash)s'
  24                      '?s=%(size)s&amp;d=identicon&amp;r=PG" '
  25                      'alt="%(username)s\'s gravatar image" />')
  26
  27 @register.simple_tag
  28 def gravatar(user, size):
  29     """
  30     Creates an ``<img>`` for a user's Gravatar with a given size.
  31
  32     This tag can accept a User object, or a dict containing the
  33     appropriate values.
  34     """
  35     try:
  36         gravatar = user['gravatar']
  37         username = user['username']
  38     except (TypeError, AttributeError, KeyError):
  39         gravatar = user.gravatar
  40         username = user.username
  41     return mark_safe(GRAVATAR_TEMPLATE % {
  42         'size': size,
  43         'gravatar_hash': gravatar,
  44         'username': template.defaultfilters.urlencode(username),
  45     })
  46
  47 MAX_FONTSIZE = 18
  48 MIN_FONTSIZE = 12
  49 @register.simple_tag
  50 def tag_font_size(max_size, min_size, current_size):
  51     """
  52     do a logarithmic mapping calcuation for a proper size for tagging cloud
  53     Algorithm from http://blogs.dekoh.com/dev/2007/10/29/choosing-a-good-font-size-variation-algorithm-for-your-tag-cloud/
  54     """
  55     #avoid invalid calculation
  56     if current_size == 0:
  57         current_size = 1
  58     try:
  59         weight = (math.log10(current_size) - math.log10(min_size)) / (math.log10(max_size) - math.log10(min_size))
  60     except:
  61         weight = 0
  62     return MIN_FONTSIZE + round((MAX_FONTSIZE - MIN_FONTSIZE) * weight)
  63
  64
  65 LEADING_PAGE_RANGE_DISPLAYED = TRAILING_PAGE_RANGE_DISPLAYED = 5
  66 LEADING_PAGE_RANGE = TRAILING_PAGE_RANGE = 4
  67 NUM_PAGES_OUTSIDE_RANGE = 1
  68 ADJACENT_PAGES = 2
  69 @register.inclusion_tag("paginator.html")
  70 def cnprog_paginator(context):
  71     """
  72     custom paginator tag
  73     Inspired from http://blog.localkinegrinds.com/2007/09/06/digg-style-pagination-in-django/
  74     """
  75     if (context["is_paginated"]):
  76         " Initialize variables "
  77         in_leading_range = in_trailing_range = False
  78         pages_outside_leading_range = pages_outside_trailing_range = range(0)
  79
  80         if (context["pages"] <= LEADING_PAGE_RANGE_DISPLAYED):
  81             in_leading_range = in_trailing_range = True
  82             page_numbers = [n for n in range(1, context["pages"] + 1) if n > 0 and n <= context["pages"]]
  83         elif (context["page"] <= LEADING_PAGE_RANGE):
  84             in_leading_range = True
  85             page_numbers = [n for n in range(1, LEADING_PAGE_RANGE_DISPLAYED + 1) if n > 0 and n <= context["pages"]]
  86             pages_outside_leading_range = [n + context["pages"] for n in range(0, -NUM_PAGES_OUTSIDE_RANGE, -1)]
  87         elif (context["page"] > context["pages"] - TRAILING_PAGE_RANGE):
  88             in_trailing_range = True
  89             page_numbers = [n for n in range(context["pages"] - TRAILING_PAGE_RANGE_DISPLAYED + 1, context["pages"] + 1) if n > 0 and n <= context["pages"]]
  90             pages_outside_trailing_range = [n + 1 for n in range(0, NUM_PAGES_OUTSIDE_RANGE)]
  91         else:
  92             page_numbers = [n for n in range(context["page"] - ADJACENT_PAGES, context["page"] + ADJACENT_PAGES + 1) if n > 0 and n <= context["pages"]]
  93             pages_outside_leading_range = [n + context["pages"] for n in range(0, -NUM_PAGES_OUTSIDE_RANGE, -1)]
  94             pages_outside_trailing_range = [n + 1 for n in range(0, NUM_PAGES_OUTSIDE_RANGE)]
  95
  96         extend_url = context.get('extend_url', '')
  97         return {
  98             "base_url": context["base_url"],
  99             "is_paginated": context["is_paginated"],
 100             "previous": context["previous"],
 101             "has_previous": context["has_previous"],
 102             "next": context["next"],
 103             "has_next": context["has_next"],
 104             "page": context["page"],
 105             "pages": context["pages"],
 106             "page_numbers": page_numbers,
 107             "in_leading_range" : in_leading_range,
 108             "in_trailing_range" : in_trailing_range,
 109             "pages_outside_leading_range": pages_outside_leading_range,
 110             "pages_outside_trailing_range": pages_outside_trailing_range,
 111             "extend_url" : extend_url
 112         }
 113
 114 @register.inclusion_tag("pagesize.html")
 115 def cnprog_pagesize(context):
 116     """
 117     display the pagesize selection boxes for paginator
 118     """
 119     if (context["is_paginated"]):
 120         return {
 121             "base_url": context["base_url"],
 122             "pagesize" : context["pagesize"],
 123             "is_paginated": context["is_paginated"]
 124         }
 125
 126
 127 @register.simple_tag
 128 def get_score_badge(user):
 129     BADGE_TEMPLATE = '<span class="score" title="%(reputation)s %(reputationword)s">%(reputation)s</span>'
 130     if user.gold > 0 :
 131         BADGE_TEMPLATE = '%s%s' % (BADGE_TEMPLATE, '<span title="%(gold)s %(badgesword)s">'
 132         '<span class="badge1">&#9679;</span>'
 133         '<span class="badgecount">%(gold)s</span>'
 134         '</span>')
 135     if user.silver > 0:
 136         BADGE_TEMPLATE = '%s%s' % (BADGE_TEMPLATE, '<span title="%(silver)s %(badgesword)s">'
 137         '<span class="silver">&#9679;</span>'
 138         '<span class="badgecount">%(silver)s</span>'
 139         '</span>')
 140     if user.bronze > 0:
 141         BADGE_TEMPLATE = '%s%s' % (BADGE_TEMPLATE, '<span title="%(bronze)s %(badgesword)s">'
 142         '<span class="bronze">&#9679;</span>'
 143         '<span class="badgecount">%(bronze)s</span>'
 144         '</span>')
 145     BADGE_TEMPLATE = smart_unicode(BADGE_TEMPLATE, encoding='utf-8', strings_only=False, errors='strict')
 146     return mark_safe(BADGE_TEMPLATE % {
 147         'reputation' : user.reputation,
 148         'gold' : user.gold,
 149         'silver' : user.silver,
 150         'bronze' : user.bronze,
 151                 'badgesword' : _('badges'),
 152                 'reputationword' : _('reputation points'),
 153     })
 154
 155 @register.simple_tag
 156 def get_score_badge_by_details(rep, gold, silver, bronze):
 157     BADGE_TEMPLATE = '<span class="reputation-score" title="%(reputation)s %(repword)s">%(reputation)s</span>'
 158     if gold > 0 :
 159         BADGE_TEMPLATE = '%s%s' % (BADGE_TEMPLATE, '<span title="%(gold)s %(badgeword)s">'
 160         '<span class="badge1">&#9679;</span>'
 161         '<span class="badgecount">%(gold)s</span>'
 162         '</span>')
 163     if silver > 0:
 164         BADGE_TEMPLATE = '%s%s' % (BADGE_TEMPLATE, '<span title="%(silver)s %(badgeword)s">'
 165         '<span class="badge2">&#9679;</span>'
 166         '<span class="badgecount">%(silver)s</span>'
 167         '</span>')
 168     if bronze > 0:
 169         BADGE_TEMPLATE = '%s%s' % (BADGE_TEMPLATE, '<span title="%(bronze)s %(badgeword)s">'
 170         '<span class="badge3">&#9679;</span>'
 171         '<span class="badgecount">%(bronze)s</span>'
 172         '</span>')
 173     BADGE_TEMPLATE = smart_unicode(BADGE_TEMPLATE, encoding='utf-8', strings_only=False, errors='strict')
 174     return mark_safe(BADGE_TEMPLATE % {
 175         'reputation' : rep,
 176         'gold' : gold,
 177         'silver' : silver,
 178         'bronze' : bronze,
 179                 'repword' : _('reputation points'),
 180                 'badgeword' : _('badges'),
 181     })
 182
 183 @register.simple_tag
 184 def get_age(birthday):
 185     current_time = datetime.datetime(*time.localtime()[0:6])
 186     year = birthday.year
 187     month = birthday.month
 188     day = birthday.day
 189     diff = current_time - datetime.datetime(year,month,day,0,0,0)
 190     return diff.days / 365
 191
 192 @register.simple_tag
 193 def get_total_count(up_count, down_count):
 194     return up_count + down_count
 195
 196 @register.simple_tag
 197 def format_number(value):
 198     strValue = str(value)
 199     if len(strValue) <= 3:
 200         return strValue
 201     result = ''
 202     first = ''
 203     pattern = re.compile('(-?\d+)(\d{3})')
 204     m = re.match(pattern, strValue)
 205     while m != None:
 206         first = m.group(1)
 207         second = m.group(2)
 208         result = ',' + second + result
 209         strValue = first + ',' + second
 210         m = re.match(pattern, strValue)
 211     return first + result
 212
 213 @register.simple_tag
 214 def convert2tagname_list(question):
 215     question['tagnames'] = [name for name in question['tagnames'].split(u' ')]
 216     return ''
 217
 218 @register.simple_tag
 219 def diff_date(date, limen=2):
 220     if not date:
 221         return _('unknown')
 222
 223     now = datetime.datetime.now()#datetime(*time.localtime()[0:6])#???
 224     diff = now - date
 225     days = diff.days
 226     hours = int(diff.seconds/3600)
 227     minutes = int(diff.seconds/60)
 228
 229     if days > 2:
 230         if date.year == now.year:
 231             return date.strftime("%b %d at %H:%M")
 232         else:
 233             return date.strftime("%b %d '%y at %H:%M")
 234     elif days == 2:
 235         return _('2 days ago')
 236     elif days == 1:
 237         return _('yesterday')
 238     elif minutes >= 60:
 239         return ungettext('%(hr)d hour ago','%(hr)d hours ago',hours) % {'hr':hours}
 240     else:
 241         return ungettext('%(min)d min ago','%(min)d mins ago',minutes) % {'min':minutes}
 242
 243 @register.simple_tag
 244 def get_latest_changed_timestamp():
 245     try:
 246         from time import localtime, strftime
 247         from os import path
 248         root = settings.SITE_SRC_ROOT
 249         dir = (
 250             root,
 251             '%s/forum' % root,
 252             '%s/templates' % root,
 253         )
 254         stamp = (path.getmtime(d) for d in dir)
 255         latest = max(stamp)
 256         timestr = strftime("%H:%M %b-%d-%Y %Z", localtime(latest))
 257     except:
 258         timestr = ''
 259     return timestr
 260
 261 @register.simple_tag
 262 def media(url):
 263     url = skins.find_media_source(url)
 264     if url:
 265         url = '///' + settings.FORUM_SCRIPT_ALIAS + '/m/' + url
 266         return posixpath.normpath(url) + '?v=%d' % settings.RESOURCE_REVISION
 267
 268 class ItemSeparatorNode(template.Node):
 269     def __init__(self,separator):
 270         sep = separator.strip()
 271         if sep[0] == sep[-1] and sep[0] in ('\'','"'):
 272             sep = sep[1:-1]
 273         else:
 274             raise template.TemplateSyntaxError('separator in joinitems tag must be quoted')
 275         self.content = sep
 276     def render(self,context):
 277         return self.content
 278
 279 class JoinItemListNode(template.Node):
 280     def __init__(self,separator=ItemSeparatorNode("''"), items=()):
 281         self.separator = separator
 282         self.items = items
 283     def render(self,context):
 284         out = []
 285         empty_re = re.compile(r'^\s*$')
 286         for item in self.items:
 287             bit = item.render(context)
 288             if not empty_re.search(bit):
 289                 out.append(bit)
 290         return self.separator.render(context).join(out)
 291
 292 @register.tag(name="joinitems")
 293 def joinitems(parser,token):
 294     try:
 295         tagname,junk,sep_token = token.split_contents()
 296     except ValueError:
 297         raise template.TemplateSyntaxError("joinitems tag requires 'using \"separator html\"' parameters")
 298     if junk == 'using':
 299         sep_node = ItemSeparatorNode(sep_token)
 300     else:
 301         raise template.TemplateSyntaxError("joinitems tag requires 'using \"separator html\"' parameters")
 302     nodelist = []
 303     while True:
 304         nodelist.append(parser.parse(('separator','endjoinitems')))
 305         next = parser.next_token()
 306         if next.contents == 'endjoinitems':
 307             break
 308
 309     return JoinItemListNode(separator=sep_node,items=nodelist)
 310
 311 class BlockMediaUrlNode(template.Node):
 312     def __init__(self,nodelist):
 313         self.items = nodelist
 314     def render(self,context):
 315         prefix = '///' + settings.FORUM_SCRIPT_ALIAS + 'm/'
 316         url = ''
 317         if self.items:
 318             url += '/'
 319         for item in self.items:
 320             url += item.render(context)
 321
 322         url = skins.find_media_source(url)
 323         url = prefix + url
 324         out = posixpath.normpath(url) + '?v=%d' % settings.RESOURCE_REVISION
 325         return out.replace(' ','')
 326
 327 @register.tag(name='blockmedia')
 328 def blockmedia(parser,token):
 329     try:
 330         tagname = token.split_contents()
 331     except ValueError:
 332         raise template.TemplateSyntaxError("blockmedia tag does not use arguments")
 333     nodelist = []
 334     while True:
 335         nodelist.append(parser.parse(('endblockmedia')))
 336         next = parser.next_token()
 337         if next.contents == 'endblockmedia':
 338             break
 339     return BlockMediaUrlNode(nodelist)
 340
 341 class FullUrlNode(template.Node):
 342     def __init__(self, default_node):
 343         self.default_node = default_node
 344
 345     def render(self, context):
 346         domain = settings.APP_URL
 347         #protocol = getattr(settings, "PROTOCOL", "http")
 348         path = self.default_node.render(context)
 349         return "%s%s" % (domain, path)
 350
 351 @register.tag(name='fullurl')
 352 def fullurl(parser, token):
 353     default_node = default_url(parser, token)
 354     return FullUrlNode(default_node)
 355
 356 @register.simple_tag
 357 def fullmedia(url):
 358     domain = settings.APP_URL
 359     #protocol = getattr(settings, "PROTOCOL", "http")
 360     path = media(url)
 361     return "%s%s" % (domain, path)
 362
 363 class UserVarNode(template.Node):
 364     def __init__(self, tokens):
 365         self.tokens = tokens
 366
 367     def render(self, context):
 368         return "{{ %s }}" % self.tokens
 369
 370 @register.tag(name='user_var')
 371 def user_var(parser, token):
 372     tokens = " ".join(token.split_contents()[1:])
 373     return UserVarNode(tokens)
 374
 375
 376 class VariablesNode(template.Node):
 377     def __init__(self, nodelist, var_name):
 378         self.nodelist = nodelist
 379         self.var_name = var_name
 380
 381     def render(self, context):
 382         source = self.nodelist.render(context)
 383         context[self.var_name] = simplejson.loads(source)
 384         return ''
 385
 386 @register.tag(name='var')
 387 def do_variables(parser, token):
 388     try:
 389         tag_name, arg = token.contents.split(None, 1)
 390     except ValueError:
 391         msg = '"%s" tag requires arguments' % token.contents.split()[0]
 392         raise template.TemplateSyntaxError(msg)
 393     m = re.search(r'as (\w+)', arg)
 394     if m:
 395         var_name, = m.groups()
 396     else:
 397         msg = '"%s" tag had invalid arguments' % tag_name
 398         raise template.TemplateSyntaxError(msg)
 399
 400     nodelist = parser.parse(('endvar',))
 401     parser.delete_first_token()
 402     return VariablesNode(nodelist, var_name)