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 import random
   9 from django import template
  10 from django.utils.encoding import smart_unicode
  11 from django.utils.safestring import mark_safe
  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 forum import settings
  17 from django.template.defaulttags import url as default_url
  18 from forum import skins
  19 from forum.utils import html
  20 from extra_filters import decorated_int
  21 from django.core.urlresolvers import reverse
  22
  23 register = template.Library()
  24
  25 GRAVATAR_TEMPLATE = ('<img class="gravatar" width="%(size)s" height="%(size)s" '
  26 'src="http://www.gravatar.com/avatar/%(gravatar_hash)s'
  27 '?s=%(size)s&amp;d=%(default)s&amp;r=%(rating)s" '
  28 'alt="%(username)s\'s gravatar image" />')
  29
  30 @register.simple_tag
  31 def gravatar(user, size):
  32     try:
  33         gravatar = user['gravatar']
  34         username = user['username']
  35     except (TypeError, AttributeError, KeyError):
  36         gravatar = user.gravatar
  37         username = user.username
  38     return mark_safe(GRAVATAR_TEMPLATE % {
  39     'size': size,
  40     'gravatar_hash': gravatar,
  41     'default': settings.GRAVATAR_DEFAULT_IMAGE,
  42     'rating': settings.GRAVATAR_ALLOWED_RATING,
  43     'username': template.defaultfilters.urlencode(username),
  44     })
  45
  46
  47 @register.simple_tag
  48 def get_score_badge(user):
  49     if user.is_suspended():
  50         return _("(suspended)")
  51
  52     repstr = decorated_int(user.reputation, "")
  53
  54     BADGE_TEMPLATE = '<span class="score" title="%(reputation)s %(reputationword)s">%(repstr)s</span>'
  55     if user.gold > 0 :
  56         BADGE_TEMPLATE = '%s%s' % (BADGE_TEMPLATE, '<span title="%(gold)s %(badgesword)s">'
  57         '<span class="badge1">&#9679;</span>'
  58         '<span class="badgecount">%(gold)s</span>'
  59         '</span>')
  60     if user.silver > 0:
  61         BADGE_TEMPLATE = '%s%s' % (BADGE_TEMPLATE, '<span title="%(silver)s %(badgesword)s">'
  62         '<span class="silver">&#9679;</span>'
  63         '<span class="badgecount">%(silver)s</span>'
  64         '</span>')
  65     if user.bronze > 0:
  66         BADGE_TEMPLATE = '%s%s' % (BADGE_TEMPLATE, '<span title="%(bronze)s %(badgesword)s">'
  67         '<span class="bronze">&#9679;</span>'
  68         '<span class="badgecount">%(bronze)s</span>'
  69         '</span>')
  70     BADGE_TEMPLATE = smart_unicode(BADGE_TEMPLATE, encoding='utf-8', strings_only=False, errors='strict')
  71     return mark_safe(BADGE_TEMPLATE % {
  72     'reputation' : user.reputation,
  73     'repstr': repstr,
  74     'gold' : user.gold,
  75     'silver' : user.silver,
  76     'bronze' : user.bronze,
  77     'badgesword' : _('badges'),
  78     'reputationword' : _('reputation points'),
  79     })
  80
  81 # Usage: {% get_accept_rate node.author %}
  82 @register.simple_tag
  83 def get_accept_rate(user):
  84     # We get the number of all user's answers.
  85     total_answers_count = Answer.objects.filter(author=user).count()
  86
  87     # We get the number of the user's accepted answers.
  88     accepted_answers_count = Answer.objects.filter(author=user, state_string__contains="(accepted)").count()
  89
  90     # In order to represent the accept rate in percentages we divide the number of the accepted answers to the
  91     # total answers count and make a hundred multiplication.
  92     accept_rate = (float(accepted_answers_count) / float(total_answers_count) * 100)
  93
  94     # If the user has more than one accepted answers the rate title will be in plural.
  95     if accepted_answers_count > 1:
  96         accept_rate_number_title = _('%(user)s has %(count)d accepted answers') % {
  97             'user' : user.username,
  98             'count' : int(accepted_answers_count)
  99         }
 100     # If the user has one accepted answer we'll be using singular.
 101     elif accepted_answers_count == 1:
 102         accept_rate_number_title = _('%s has one accepted answer') % user.username
 103     # This are the only options. Otherwise there are no accepted answers at all.
 104     else:
 105         accept_rate_number_title = _('%s has no accepted answers') % user.username
 106
 107     html_output = """
 108     <span title="%(accept_rate_title)s" class="accept_rate">%(accept_rate_label)s:</span>
 109     <span title="%(accept_rate_number_title)s">%(accept_rate)d&#37;</span>
 110     """ % {
 111         'accept_rate_label' : _('accept rate'),
 112         'accept_rate_title' : _('Rate of the user\'s accepted answers'),
 113         'accept_rate' : int(accept_rate),
 114         'accept_rate_number_title' : u'%s' % accept_rate_number_title,
 115     }
 116
 117     return mark_safe(html_output)
 118
 119 @register.simple_tag
 120 def get_age(birthday):
 121     current_time = datetime.datetime(*time.localtime()[0:6])
 122     year = birthday.year
 123     month = birthday.month
 124     day = birthday.day
 125     diff = current_time - datetime.datetime(year, month, day, 0, 0, 0)
 126     return diff.days / 365
 127
 128 @register.simple_tag
 129 def diff_date(date, limen=2):
 130     if not date:
 131         return _('unknown')
 132
 133     now = datetime.datetime.now()
 134     diff = now - date
 135     days = diff.days
 136     hours = int(diff.seconds/3600)
 137     minutes = int(diff.seconds/60)
 138
 139     if days > 2:
 140         if date.year == now.year:
 141             return date.strftime(_("%b %d at %H:%M").encode())
 142         else:
 143             return date.strftime(_("%b %d '%y at %H:%M").encode())
 144     elif days == 2:
 145         return _('2 days ago')
 146     elif days == 1:
 147         return _('yesterday')
 148     elif minutes >= 60:
 149         return ungettext('%(hr)d ' + _("hour ago"), '%(hr)d ' + _("hours ago"), hours) % {'hr':hours}
 150     elif diff.seconds >= 60:
 151         return ungettext('%(min)d ' + _("min ago"), '%(min)d ' + _("mins ago"), minutes) % {'min':minutes}
 152     else:
 153         return ungettext('%(sec)d ' + _("sec ago"), '%(sec)d ' + _("secs ago"), diff.seconds) % {'sec':diff.seconds}
 154
 155 @register.simple_tag
 156 def media(url):
 157     url = skins.find_media_source(url)
 158     if url:
 159         # Create the URL prefix.
 160         url_prefix = settings.FORCE_SCRIPT_NAME + '/m/'
 161
 162         # Make sure any duplicate forward slashes are replaced with a single
 163         # forward slash.
 164         url_prefix = re.sub("/+", "/", url_prefix)
 165
 166         url = url_prefix + url
 167         return url
 168
 169 class ItemSeparatorNode(template.Node):
 170     def __init__(self, separator):
 171         sep = separator.strip()
 172         if sep[0] == sep[-1] and sep[0] in ('\'', '"'):
 173             sep = sep[1:-1]
 174         else:
 175             raise template.TemplateSyntaxError('separator in joinitems tag must be quoted')
 176         self.content = sep
 177
 178     def render(self, context):
 179         return self.content
 180
 181 class BlockMediaUrlNode(template.Node):
 182     def __init__(self, nodelist):
 183         self.items = nodelist
 184
 185     def render(self, context):
 186         prefix = settings.APP_URL + 'm/'
 187         url = ''
 188         if self.items:
 189             url += '/'
 190         for item in self.items:
 191             url += item.render(context)
 192
 193         url = skins.find_media_source(url)
 194         url = prefix + url
 195         out = url
 196         return out.replace(' ', '')
 197
 198 @register.tag(name='blockmedia')
 199 def blockmedia(parser, token):
 200     try:
 201         tagname = token.split_contents()
 202     except ValueError:
 203         raise template.TemplateSyntaxError("blockmedia tag does not use arguments")
 204     nodelist = []
 205     while True:
 206         nodelist.append(parser.parse(('endblockmedia')))
 207         next = parser.next_token()
 208         if next.contents == 'endblockmedia':
 209             break
 210     return BlockMediaUrlNode(nodelist)
 211
 212
 213 @register.simple_tag
 214 def fullmedia(url):
 215     domain = settings.APP_BASE_URL
 216     #protocol = getattr(settings, "PROTOCOL", "http")
 217     path = media(url)
 218     return "%s%s" % (domain, path)
 219
 220
 221 class SimpleVarNode(template.Node):
 222     def __init__(self, name, value):
 223         self.name = name
 224         self.value = template.Variable(value)
 225
 226     def render(self, context):
 227         context[self.name] = self.value.resolve(context)
 228         return ''
 229
 230 class BlockVarNode(template.Node):
 231     def __init__(self, name, block):
 232         self.name = name
 233         self.block = block
 234
 235     def render(self, context):
 236         source = self.block.render(context)
 237         context[self.name] = source.strip()
 238         return ''
 239
 240
 241 @register.tag(name='var')
 242 def do_var(parser, token):
 243     tokens = token.split_contents()[1:]
 244
 245     if not len(tokens) or not re.match('^\w+$', tokens[0]):
 246         raise template.TemplateSyntaxError("Expected variable name")
 247
 248     if len(tokens) == 1:
 249         nodelist = parser.parse(('endvar',))
 250         parser.delete_first_token()
 251         return BlockVarNode(tokens[0], nodelist)
 252     elif len(tokens) == 3:
 253         return SimpleVarNode(tokens[0], tokens[2])
 254
 255     raise template.TemplateSyntaxError("Invalid number of arguments")
 256
 257 class DeclareNode(template.Node):
 258     dec_re = re.compile('^\s*(\w+)\s*(:?=)\s*(.*)$')
 259
 260     def __init__(self, block):
 261         self.block = block
 262
 263     def render(self, context):
 264         source = self.block.render(context)
 265
 266         for line in source.splitlines():
 267             m = self.dec_re.search(line)
 268             if m:
 269                 clist = list(context)
 270                 clist.reverse()
 271                 d = {}
 272                 d['_'] = _
 273                 d['os'] = os
 274                 d['html'] = html
 275                 d['reverse'] = reverse
 276                 for c in clist:
 277                     d.update(c)
 278                 try:
 279                     context[m.group(1).strip()] = eval(m.group(3).strip(), d)
 280                 except Exception, e:
 281                     logging.error("Error in declare tag, when evaluating: %s" % m.group(3).strip())
 282                     raise
 283         return ''
 284
 285 @register.tag(name='declare')
 286 def do_declare(parser, token):
 287     nodelist = parser.parse(('enddeclare',))
 288     parser.delete_first_token()
 289     return DeclareNode(nodelist)
 290
 291 # Usage: {% random 1 999 %}
 292 # Generates random number in the template
 293 class RandomNumberNode(template.Node):
 294     # We get the limiting numbers
 295     def __init__(self, int_from, int_to):
 296         self.int_from = int(int_from)
 297         self.int_to = int(int_to)
 298
 299     # We generate the random number using the standard python interface
 300     def render(self, context):
 301         return str(random.randint(self.int_from, self.int_to))
 302
 303 @register.tag(name="random")
 304 def random_number(parser, token):
 305     # Try to get the limiting numbers from the token
 306     try:
 307         tag_name, int_from, int_to = token.split_contents()
 308     except ValueError:
 309         # If we had no success -- raise an exception
 310         raise template.TemplateSyntaxError, "%r tag requires exactly two arguments" % token.contents.split()[0]
 311
 312     # Call the random Node
 313     return RandomNumberNode(int_from, int_to)