root/trunk/blog/templatetags/blogutils.py

# vim: encoding=utf-8 :

import datetime
import math
import os
import re
import time

from django.conf import settings
from django.db import connection
from django.db.models.query import QuerySet
from django.core.urlresolvers import reverse
from django.template import Library

from blog.models import Tag

EMOTICON_PATTERNS = (
    (re.compile(r'(\s+)(:\)|:-\))(\s*)'), u'emoticon_smile'),
    (re.compile(r'(\s+)(:D|:-D)(\s*)'), u'emoticon_grin'),
    (re.compile(r'(\s+)(:p|:P|:-p|:-P)(\s*)'), u'emoticon_tongue'),
    (re.compile(r'(\s+)(;\)|;-\))(\s*)'), u'emoticon_wink'),
    (re.compile(r'(\s+)(:\(|:-\()(\s*)'), u'emoticon_unhappy'),
    (re.compile(r'(\s+)(:o|:O|:-o|:-O)(\s*)'), u'emoticon_surprised'),
    (re.compile(r'(\s+)(:3|:-3)(\s*)'), u'emoticon_waii'),
    (re.compile(r'(\s+)(:lol:)(\s*)'), u'emoticon_happy'),
    (re.compile(r'(\s+)(:evil:)(\s*)'), u'emoticon_evilgrin'),
)


register = Library()

class ArchiveLink(object):
    """
    Create Archive Link.
    """
    def __init__(self, date, count):
        self.date = date
        self.count = count
    
    def __str__(self):
        return self.date.strftime('%b %Y').lower()
    
    def get_absolute_url(self):
        date = self.date.strftime('%Y,%m').split(',')
        return reverse('blog_archive_month', args=date)


class TagLink(object):
    """
    Create tag link.
    """
    def __init__(self, label, count, current=None):
        self.label = label
        self.count = count
        self.current = current or False
    
    def __unicode__(self):
        return self.label
    
    def get_absolute_url(self):
        kwargs = {
            'label': self.label.lower(),
        }
        return reverse('blog_entry_tag', args=[self.label.lower()])


class TagCloud(object):
    """
    TagLink's container.
    """
    def __init__(self):
        self._clouds = []

    def __len__(self):
        return len(self._clouds)

    def __iter__(self):
        return self

    def next(self):
        if hasattr(self, '_index'):
            self._index += 1
        else:
            self._index = 0
        try:
            e = self._clouds[self._index]
            e.rank = int((math.sqrt(e.count) - self._min) * self._base)
            return e
        except IndexError:
            del self._index
            raise StopIteration

    def append(self, e):
        if not isinstance(e, TagLink):
            raise ValueError("%s is not TagLink's instance." % e.__class__.__name__)
        self._clouds.append(e)

    def set_range(self, _min, _max):
        self._min = math.sqrt(_min)
        self._max = math.sqrt(_max)
        if self._min != self._max:
            self._base = float(24) / (self._max - self._min)
        else:
            self._base = 1


@register.inclusion_tag('blog/_links.html')
def archive_links():
    sql = """
    SELECT
        COUNT(id) as cnt,
        EXTRACT(YEAR FROM created_at) as year,
        EXTRACT(MONTH FROM created_at) as month
    FROM
        blog_entry
    WHERE
        is_active = True
    GROUP BY
        year DESC,
        month DESC
    """.splitlines()
    sql = ' '.join(map(lambda l: l.strip(), sql))
    cursor = connection.cursor()
    cursor.execute(sql)
    obj_list = []
    for count, year, month in cursor.fetchall():
        obj_list.append(ArchiveLink(date=datetime.date(year, month, 1),
                                    count=count))
    return {
        'MEDIA_URL': settings.MEDIA_URL,
        'DESIGN_THEME': settings.DESIGN_THEME,
        'id': u'archive-list',
        'obj_list': obj_list,
        'title': u'Archives',
    }


@register.inclusion_tag('blog/_tag_cloud.html')
def tag_links(currents=None):
    sql = """
    SELECT
        T.label,
        COUNT(T.label) as cnt
    FROM
        blog_tag AS T
    JOIN
        blog_entry_tags AS B
    ON
        T.id = B.tag_id
    JOIN
        blog_entry AS E
    ON
        B.entry_id = E.id AND E.is_active = True
    GROUP BY
        T.label ASC
    """.splitlines()
    sql = ' '.join(map(lambda l: l.strip(), sql))
    cursor = connection.cursor()
    cursor.execute(sql)
    
    if isinstance(currents, QuerySet):
        currents = [t.label for t in currents]
    elif isinstance(currents, Tag):
        currents = [currents.label]
    else:
        currents = []
    counts = []
    obj_list = TagCloud()
    for label, cnt in cursor.fetchall():
        counts.append(cnt)
        current = label in currents
        obj_list.append(TagLink(label=label, count=cnt, current=current))
    counts.sort()
    try:
        obj_list.set_range(counts[0], counts[-1])
    except IndexError:
        obj_list = []
    return {
        'MEDIA_URL': settings.MEDIA_URL,
        'DESIGN_THEME': settings.DESIGN_THEME,
        'id': u'tag-list',
        'obj_list': obj_list,
        'title': u'Categories',
    }


@register.filter
def to_oneline(value):
    return value.replace('\r\n', '\n').replace('\r', '\n').replace('\n', '')


@register.filter
def emoticon(value):
    """
    replace keyword to emoticon
    """
    file_path = os.path.join(settings.MEDIA_URL, 'themes', settings.DESIGN_THEME)
    for pattern, file_name in EMOTICON_PATTERNS:
        needle = r'\1<img src="%(file_path)s/images/icons/%(file_name)s.png" alt="\2" />\3' % {
            'file_path': file_path,
            'file_name': file_name,
        }
        value = pattern.sub(needle, value)
    return value
emoticon.is_safe = True