root/trunk/plugins/views.py

# vim: encoding=utf-8

import datetime
import math

from django.conf import settings
from django.core import exceptions
from django.core.urlresolvers import reverse
from django.db import connection
from django.template import loader, Context
from django.utils.translation import ugettext_lazy as _

from blog.models import Entry, Comment, TrackBack


class ContentsNotUsed(Exception):
    pass


class ContentsManager(object):
    """
    """
    def __init__(self, keyword):
        self._contents = []
        try:
            assigned_contents = getattr(settings, keyword)
        except AttributeError:
            raise exceptions.ImproperlyConfigured('settings does not define a "%s" attribute' % keyword)
        for contents_path in assigned_contents:
            try:
                dot_index = contents_path.rindex('.')
            except ValueError:
                raise exceptions.ImproperlyConfigured('%s isn\'t a contents module' % contents_path)
            c_module, c_classname = contents_path[:dot_index], contents_path[dot_index+1:]
            try:
                mod = __import__(c_module, {}, {}, [''])
            except ImportError, e:
                raise exceptions.ImproperlyConfigured('Error importing contents %s: "%s"' % (c_module, e))
            try:
                c_class = getattr(mod, c_classname)
            except AttributeError:
                raise exceptions.ImproperlyConfigured('Contents module "%s" does not define a "%s" class' % (c_module, c_classname))
            try:
                c_instance = c_class()
            except ContentsNotUsed:
                continue
            self._contents.append(c_instance)

    def __str__(self):
        return self.render()

    def __unicode__(self):
        return unicode(self.render(), 'utf-8')

    def render(self):
        results = []
        for contents in self._contents:
            rendered = contents.render()
            if rendered is None:
                continue
            results.append(rendered)
        return '\n'.join(results)


class Content(object):
    """
    """
    def __init__(self):
        pass

    def __str__(self):
        return self.render()

    def __unicode__(self):
        return unicode(self.render(), 'utf-8')

    def render(self):
        raise NotImplementedError


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 ArchiveContent(Content):
    def render(self):
        cursor = connection.cursor()
        qn = connection.ops.quote_name
        sql = """
        SELECT
            COUNT(e.%(id)s) as cnt,
            EXTRACT(YEAR FROM e.%(published_at)s) as year,
            EXTRACT(MONTH FROM e.%(published_at)s) as month
        FROM %(blog_entry)s e
        WHERE
            e.%(is_published)s = True
        AND
            e.%(is_active)s = True
        GROUP BY
            year DESC,
            month DESC
        """ % {
            'id': qn('id'),
            'published_at': qn('published_at'),
            'blog_entry': qn('blog_entry'),
            'is_published': qn('is_published'),
            'is_active': qn('is_active'),
        }
        cursor.execute(sql)
        obj_list = []
        for count, year, month in cursor.fetchall():
            if not bool(year) or not bool(month):
                continue
            obj_list.append(ArchiveLink(date=datetime.date(year, month, 1),
                                        count=count))
        c = Context({
            'MEDIA_URL': settings.MEDIA_URL,
            'DESIGN_THEME': settings.DESIGN_THEME,
            'id': u'archive-list',
            'obj_list': obj_list,
            'title': u'Archives',
        })
        t = loader.get_template('blog/_links.html')
        return t.render(c)


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


class TagCloudContent(Content):
    """
    """
    def render(self):
        cursor = connection.cursor()
        qn = connection.ops.quote_name
        sql = """
        SELECT
            t.%(label)s,
            COUNT(t.%(label)s) as cnt
        FROM %(blog_tag)s t, %(blog_entry_tags)s b, %(blog_entry)s e
        WHERE
            t.%(id)s = b.%(tag_id)s
        AND
            b.%(entry_id)s = e.%(id)s
        AND
            e.%(is_active)s = True
        GROUP BY
            t.%(label)s ASC
        """ % {
            'id': qn('id'),
            'tag_id': qn('tag_id'),
            'entry_id': qn('entry_id'),
            'label': qn('label'),
            'is_active': qn('is_active'),
            'blog_tag': qn('blog_tag'),
            'blog_entry_tags': qn('blog_entry_tags'),
            'blog_entry': qn('blog_entry'),
        }
        cursor.execute(sql)

        # TODO: check current tags.
#        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))
            obj_list.append(TagLink(label=label, count=cnt))
        counts.sort()
        try:
            obj_list.set_range(counts[0], counts[-1])
        except IndexError:
            obj_list = []
        c = Context({
            'MEDIA_URL': settings.MEDIA_URL,
            'DESIGN_THEME': settings.DESIGN_THEME,
            'id': u'tag-list',
            'obj_list': obj_list,
            'title': _(u'Categories'),
        })
        t = loader.get_template('blog/_tag_cloud.html')
        return t.render(c)


class RecentEntriesContent(Content):
    """
    """
    def render(self):
        # TODO: accessible this point.
        obj_list = Entry.objects.filter(is_published__exact=True)\
                                .filter(is_active__exact=True)[0:10]
        c = Context({
            'MEDIA_URL': settings.MEDIA_URL,
            'DESIGN_THEME': settings.DESIGN_THEME,
            'id': u'comment-list',
            'obj_list': obj_list,
            'title': _(u'Recent Entries'),
        })
        t = loader.get_template('blog/_links.html')
        return t.render(c)


class RecentCommentsContent(Content):
    """
    """
    def render(self):
        # TODO: accessible this point.
        obj_list = Comment.objects.all().order_by('-created_at')[0:10]
        c = Context({
            'MEDIA_URL': settings.MEDIA_URL,
            'DESIGN_THEME': settings.DESIGN_THEME,
            'id': u'comment-list',
            'obj_list': obj_list,
            'title': _(u'Recent Comments'),
        })
        t = loader.get_template('blog/_links.html')
        return t.render(c)