root/branches/pluggable-contents/blog/views.py

# vim: encoding=utf-8 :

import datetime
import time
from urllib import quote, unquote

from django.core.paginator import Paginator, QuerySetPaginator, InvalidPage
from django.core.urlresolvers import reverse
from django.db.models.query import QuerySet
from django.http import HttpResponse, HttpResponseRedirect, Http404
from django.template import loader, RequestContext
from django.utils.translation import ugettext_lazy as _

from blog.models import Tag, Entry, Comment, TrackBack
from blog.forms import CommentForm, TrackBackForm

DEFAULT_PAGINATION_PER_PAGE = 10


def _create_pagination(obj_list, page, per_page=DEFAULT_PAGINATION_PER_PAGE,
                       orphans=0, allow_empty_first_page=True):
    if isinstance(obj_list, QuerySet):
        PageClass = QuerySetPaginator
    else:
        PageClass = Paginator
    try:
        paginator = PageClass(obj_list, per_page, orphans, allow_empty_first_page)
        page_obj = paginator.page(page)
        results = page_obj.object_list
    except InvalidPage:
        page_obj = None
        results = []
    return page_obj, results


def entry_list(request):
    """
    Show entry list.
    """
    queryset = Entry.objects.filter(is_published__exact=True)\
                            .filter(is_active__exact=True)
    page = request.GET.get('page', 1)
    page_obj, obj_list = _create_pagination(queryset, page)
    c = RequestContext(request, {
        'obj_list': obj_list,
        'page_obj': page_obj,
        'title': _(u'Latest entries'),
    })
    t = loader.get_template('blog/entry_list.html')
    return HttpResponse(t.render(c))


def entry_tag(request, label):
    """
    """
    try:
        obj = Tag.objects.get(label__iexact=label)
    except Tag.DoesNotExist:
        raise Http404
    queryset = obj.entry_set.filter(is_published__exact=True)\
                            .filter(is_active__exact=True)
    page = request.GET.get('page', 1)
    page_obj, obj_list = _create_pagination(queryset, page)
    c = RequestContext(request, {
        'current_tag': obj,
        'obj_list': obj_list,
        'page_obj': page_obj,
        'title': _(u'Tag/%s') % obj.label,
    })
    t = loader.get_template('blog/entry_list.html')
    return HttpResponse(t.render(c))


def entry_search(request, query=None):
    """
    Show search results.
    """
    if query is None:
        query = request.GET.get('query', u'')
        if len(query):
            query = quote(query.encode('utf-8'))
            return HttpResponseRedirect(reverse('blog_entry_search_keyword', args=[query]))
    encoded = unquote(query.encode('utf-8'))
    query = unicode(encoded, 'utf-8')
    if len(query):
        queryset = Entry.objects.filter(description__search=u'*D+ %s' % query)\
                                .filter(is_published__exact=True)\
                                .filter(is_active__exact=True)
    else:
        queryset = []
    page = request.GET.get('page', 1)
    page_obj, obj_list = _create_pagination(queryset, page)
    c = RequestContext(request, {
        'obj_list': obj_list,
        'page_obj': page_obj,
        'query': query,
        'title': _(u'Search/%s') % query,
    })
    t = loader.get_template('blog/entry_list.html')
    return HttpResponse(t.render(c))


def entry_from_id(request, obj_id):
    """
    Show entry detail (login required).
    """
    if not request.user.is_authenticated():
        raise Http404
    try:
        obj = Entry.objects.get(pk=obj_id)
    except Entry.DoesNotExist:
        raise Http404
    c = RequestContext(request, {'obj': obj})
    t = loader.get_template('blog/entry_detail.html')
    return HttpResponse(t.render(c))


def entry_detail(request, year, month, day, slug):
    """
    Show entry detail.
    """
    try:
        date = datetime.date(*time.strptime(year+month+day, '%Y%m%d')[:3])
    except ValueError:
        raise Http404
    date_range = (
        datetime.datetime.combine(date, datetime.time.min),
        datetime.datetime.combine(date, datetime.time.max),
    )
    try:
        obj = Entry.objects.filter(slug__exact=slug)\
                           .filter(published_at__range=date_range)\
                           .filter(is_published__exact=True)\
                           .get(is_active__exact=True)
    except Entry.DoesNotExist:
        raise Http404
    status_code = 200
    form = CommentForm(request.POST.copy() or None, auto_id='comment-%s')
    if request.method == 'POST':
        if form.is_valid():
            comment = form.save(commit=False)
            comment.entry = obj
            comment.save()
            return HttpResponseRedirect(comment.get_absolute_url())
        else:
            status_code = 403
    c = RequestContext(request, {
        'form': form,
        'obj': obj,
    })
    t = loader.get_template('blog/entry_detail.html')
    return HttpResponse(t.render(c), status=status_code)


def trackback_create(request, year, month, day, slug):
    """
    Add new track back.
    """
    try:
        date = datetime.date(*time.strptime(year+month+day, '%Y%m%d')[:3])
    except ValueError:
        raise Http404
    date_range = (
        datetime.datetime.combine(date, datetime.time.min),
        datetime.datetime.combine(date, datetime.time.max),
    )
    try:
        obj = Entry.objects.filter(slug__exact=slug)\
                           .filter(published_at__range=date_range)\
                           .filter(is_published__exact=True)\
                           .get(is_active__exact=True)
    except Entry.DoesNotExist:
        raise Http404
    if request.method == 'GET':
        return HttpResponseRedirect(obj.get_absolute_url())
    data = request.POST.copy()
    data.update({'entry': obj.id})
    form = TrackBackForm(data)
    if form.is_valid():
        trackback = form.save()
        status_code = 200
        c = RequestContext(request, {'error': 0})
    else:
        status_code = 403
        c = RequestContext(request, {
            'error': 1,
            'message': _(u'Your request has been rejected, because it was invalid.')
        })
    t = loader.get_template('blog/trackback_response.xml')
    return HttpResponse(t.render(c), status=status_code)


def archive_day(request, year, month, day):
    """
    Show day archive.
    """
    try:
        date = datetime.date(*time.strptime(year+month+day, '%Y%m%d')[:3])
    except ValueError:
        raise Http404
    date_range = (
        datetime.datetime.combine(date, datetime.time.min),
        datetime.datetime.combine(date, datetime.time.max),
    )
    queryset = Entry.objects.filter(published_at__range=date_range)\
                            .filter(is_published__exact=True)\
                            .filter(is_active__exact=True)
    page = request.GET.get('page', 1)
    page_obj, obj_list = _create_pagination(queryset, page)
    c = RequestContext(request, {
        'obj_list': obj_list,
        'page_obj': page_obj,
        'title': _(u'Archive@%s') % date.strftime('%Y/%m/%d'),
    })
    t = loader.get_template('blog/entry_list.html')
    return HttpResponse(t.render(c))


def archive_month(request, year, month):
    """
    Show month archive.
    """
    try:
        firstday = datetime.date(*time.strptime(year+month, '%Y%m')[:3])
    except ValueError:
        raise Http404
    for i in range(31, 0, -1):
        try:
            lastday = firstday.replace(day=i)
            break
        except:
            pass
    date_range = (
        datetime.datetime.combine(firstday, datetime.time.min),
        datetime.datetime.combine(lastday, datetime.time.max),
    )
    queryset = Entry.objects.filter(published_at__range=date_range)\
                            .filter(is_published__exact=True)\
                            .filter(is_active__exact=True)
    page = request.GET.get('page', 1)
    page_obj, obj_list = _create_pagination(queryset, page)
    c = RequestContext(request, {
        'obj_list': obj_list,
        'page_obj': page_obj,
        'title': _(u'Archive@%s') % firstday.strftime('%Y/%m'),
    })
    t = loader.get_template('blog/entry_list.html')
    return HttpResponse(t.render(c))


def archive_year(request, year):
    """
    Show year archive.
    """
    try:
        firstday = datetime.date(*time.strptime(year, '%Y')[:3])
    except ValueError:
        raise Http404
    lastday = firstday.replace(month=12, day=31)
    date_range = (
        datetime.datetime.combine(firstday, datetime.time.min),
        datetime.datetime.combine(lastday, datetime.time.max),
    )
    queryset = Entry.objects.filter(published_at__range=date_range)\
                            .filter(is_published__exact=True)\
                            .filter(is_active__exact=True)
    page = request.GET.get('page', 1)
    page_obj, obj_list = _create_pagination(queryset, page)
    c = RequestContext(request, {
        'obj_list': obj_list,
        'page_obj': page_obj,
        'title': _(u'Archive@%s') % firstday.year,
    })
    t = loader.get_template('blog/entry_list.html')
    return HttpResponse(t.render(c))