root/trunk/blog/models.py

# vim: encoding=utf-8 :

from datetime import datetime

from django.dispatch import dispatcher
from django.db import models
from django.db.models import signals
from django.utils.translation import ugettext_lazy as _
from blog.receivers import post_save_entry, post_save_comment, pre_delete_comment,\
                           post_save_trackback, pre_delete_trackback


class Tag(models.Model):
    """
    blog's tag.
    """
    label = models.CharField(_(u'label'), max_length=100, default=None)

    class Meta:
        ordering = ('label',)
        verbose_name = _(u'tag')
        verbose_name_plural = _(u'tags')

    def __unicode__(self):
        return self.label

    @models.permalink
    def get_absolute_url(self):
        return ('blog_entry_tag', [self.label.lower()])


class Entry(models.Model):
    """
    blog's entry.
    """
    title = models.CharField(_(u'title'), max_length=255, default=None)
    slug = models.SlugField(_(u'slug'))
    description = models.TextField(_(u'description'))
    comments_count = models.IntegerField(_(u'comments count'), editable=False, default=0)
    trackbacks_count = models.IntegerField(_(u'trackbacks count'), editable=False, default=0)
    created_at = models.DateTimeField(_(u'created at'), editable=False, default=datetime.now)
    updated_at = models.DateTimeField(_(u'updated at'), editable=False)
    published_at = models.DateTimeField(_(u'published at'), editable=False, blank=True, null=True)
    is_published = models.BooleanField(_(u'is published'), default=True)
    is_active = models.BooleanField(_(u'is active'), default=True)
    tags = models.ManyToManyField(Tag)

    class Meta:
        ordering = ('-published_at',)
        verbose_name = _(u'entry')
        verbose_name_plural = _(u'entries')

    def __unicode__(self):
        return self.title

    @models.permalink
    def get_absolute_url(self):
        if not self.is_published:
            name = 'blog_entry_from_id'
            args = [self.id]
        else:
            name = 'blog_entry_detail'
            args = self.published_at.strftime('%Y,%m,%d').split(',')
            args.append(self.slug)
        return (name, args)

    @models.permalink
    def get_trackback_url(self):
        if not self.is_published:
            raise NotImplementedError(_(u'%r is not published.') % self)
        args = self.published_at.strftime('%Y,%m,%d').split(',')
        args.append(self.slug)
        return ('blog_trackback_create', args)

    def save(self):
        now = datetime.now()
        self.updated_at = now
        if self.is_published and self.published_at is None:
            self.published_at = now
            self.published_now = True
        self.save_base()

    def delete(self):
        self.is_active = False
        self.is_published = False
        self.save()


class Comment(models.Model):
    """
    blog's comment.
    """
    entry = models.ForeignKey(Entry)
    name = models.CharField(_(u'name'), max_length=100, default=None)
    email = models.EmailField(_(u'mail address'), blank=True)
    url = models.URLField(_(u'URL'), blank=True)
    description = models.TextField(_(u'description'))
    created_at = models.DateTimeField(_(u'created at'), editable=False, default=datetime.now)

    class Meta:
        ordering = ('created_at',)
        verbose_name = _(u'comment')
        verbose_name_plural = _(u'comments')

    def __unicode__(self):
        return self.name
    
    def get_absolute_url(self):
        return self.entry.get_absolute_url()


class TrackBack(models.Model):
    """
    blog's track back.
    """
    entry = models.ForeignKey(Entry)
    blog_name = models.CharField(_(u'blog name'), max_length=100, blank=True, default=_(u'untitled'))
    title = models.CharField(_(u'title'), max_length=100, blank=True, default=_(u'untitled'))
    url = models.URLField(_(u'URL'))
    excerpt = models.TextField(_(u'excerpt'), blank=True)
    created_at = models.DateTimeField(_(u'created at'), editable=False, default=datetime.now)

    class Meta:
        db_table = 'blog_track_back'
        unique_together = ('entry', 'url')
        ordering = ('created_at',)
        verbose_name = _(u'track back')
        verbose_name_plural = _(u'track back')

    def __unicode__(self):
        return self.url

    def get_absolute_url(self):
        return self.entry.get_absolute_url()


class PingServer(models.Model):
    """
    blog's update ping server.
    """
    label = models.CharField(_(u'label'), max_length=100, default=None)
    url = models.URLField(_(u'URL'), unique=True)
    is_active = models.BooleanField(_(u'is active'), default=True)

    class Meta:
        db_table = 'blog_ping_server'
        ordering = ('label',)
        verbose_name = _(u'ping server')
        verbose_name_plural = _(u'ping servers')

    def __unicode__(self):
        return self.label

    def get_absolute_url(self):
        return self.url

    def delete(self):
        self.is_active = False
        self.save()


dispatcher.connect(receiver=post_save_entry, signal=signals.post_save, sender=Entry)
dispatcher.connect(receiver=post_save_comment, signal=signals.post_save, sender=Comment)
dispatcher.connect(receiver=pre_delete_comment, signal=signals.pre_delete, sender=Comment)
dispatcher.connect(receiver=post_save_trackback, signal=signals.post_save, sender=TrackBack)
dispatcher.connect(receiver=pre_delete_trackback, signal=signals.pre_delete, sender=TrackBack)

import blog.admin