s2forums/djangobb_forum/models.py

# coding: utf-8

from hashlib import sha1
import os

from django.conf import settings
from django.contrib.auth.models import User, Group
from django.core.urlresolvers import reverse
from django.core.validators import MaxLengthValidator
from django.db import models
from django.db.models import aggregates
from django.db.models.signals import post_save
from django.shortcuts import get_object_or_404
from django.utils.translation import ugettext_lazy as _
from django.utils import timezone

from django_fsm.db.fields import FSMField, transition, can_proceed

from djangobb_forum.fields import AutoOneToOneField, ExtendedImageField, JSONField
from djangobb_forum.util import smiles, convert_text_to_html
from djangobb_forum import settings as forum_settings

if 'south' in settings.INSTALLED_APPS:
    from south.modelsinspector import add_introspection_rules
    add_introspection_rules([], ['^djangobb_forum\.fields\.AutoOneToOneField',
                                 '^djangobb_forum\.fields\.JSONField',
                                 '^djangobb_forum\.fields\.ExtendedImageField'])

TZ_CHOICES = [(float(x[0]), x[1]) for x in (
    (-12, '-12'), (-11, '-11'), (-10, '-10'), (-9.5, '-09.5'), (-9, '-09'),
    (-8.5, '-08.5'), (-8, '-08 PST'), (-7, '-07 MST'), (-6, '-06 CST'),
    (-5, '-05 EST'), (-4, '-04 AST'), (-3.5, '-03.5'), (-3, '-03 ADT'),
    (-2, '-02'), (-1, '-01'), (0, '00 GMT'), (1, '+01 CET'), (2, '+02'),
    (3, '+03'), (3.5, '+03.5'), (4, '+04'), (4.5, '+04.5'), (5, '+05'),
    (5.5, '+05.5'), (6, '+06'), (6.5, '+06.5'), (7, '+07'), (8, '+08'),
    (9, '+09'), (9.5, '+09.5'), (10, '+10'), (10.5, '+10.5'), (11, '+11'),
    (11.5, '+11.5'), (12, '+12'), (13, '+13'), (14, '+14'),
)]

SIGN_CHOICES = (
    (1, 'PLUS'),
    (-1, 'MINUS'),
)

PRIVACY_CHOICES = (
    (0, _(u'Display your e-mail address.')),
    (1, _(u'Hide your e-mail address but allow form e-mail.')),
    (2, _(u'Hide your e-mail address and disallow form e-mail.')),
)

MARKUP_CHOICES = [('bbcode', 'bbcode')]
try:
    import markdown
    MARKUP_CHOICES.append(("markdown", "markdown"))
except ImportError:
    pass

path = os.path.join(settings.STATIC_ROOT, 'djangobb_forum', 'themes')
if os.path.exists(path):
    # fix for collectstatic
    THEME_CHOICES = [(theme, theme) for theme in os.listdir(path)
                     if os.path.isdir(os.path.join(path, theme))]
else:
    THEME_CHOICES = []


import logging
logger = logging.getLogger(__name__)

akismet_api = None
from akismet import Akismet, AkismetError

try:
    if getattr(settings, 'AKISMET_ENABLED', True):
        akismet_api = Akismet(key=forum_settings.AKISMET_API_KEY, blog_url=forum_settings.AKISMET_BLOG_URL, agent=forum_settings.AKISMET_AGENT)
except Exception as e:
    logger.error("Error while initializing Akismet", extra={'exception': e})


class Category(models.Model):
    name = models.CharField(_('Name'), max_length=80)
    groups = models.ManyToManyField(Group, blank=True, null=True, verbose_name=_('Groups'), help_text=_('Only users from these groups can see this category'))
    position = models.IntegerField(_('Position'), blank=True, default=0)

    class Meta:
        ordering = ['position']
        verbose_name = _('Category')
        verbose_name_plural = _('Categories')

    def __unicode__(self):
        return self.name

    def forum_count(self):
        return self.forums.all().count()

    @property
    def topics(self):
        return Topic.objects.filter(forum__category__id=self.id).select_related()

    @property
    def posts(self):
        return Post.objects.filter(topic__forum__category__id=self.id).select_related()

    def has_access(self, user):
        if user.is_superuser:
            return True
        if self.groups.exists():
            if user.is_authenticated():
                if not self.groups.filter(user__pk=user.id).exists():
                    return False
            else:
                return False
        return True


class Forum(models.Model):
    category = models.ForeignKey(Category, related_name='forums', verbose_name=_('Category'))
    moderator_only = models.BooleanField(_('New topics by moderators only'), default=False)
    name = models.CharField(_('Name'), max_length=80)
    position = models.IntegerField(_('Position'), blank=True, default=0)
    description = models.TextField(_('Description'), blank=True, default='')
    moderators = models.ManyToManyField(User, blank=True, null=True, verbose_name=_('Moderators'))
    updated = models.DateTimeField(_('Updated'), auto_now=True)
    post_count = models.IntegerField(_('Post count'), blank=True, default=0)
    topic_count = models.IntegerField(_('Topic count'), blank=True, default=0)
    last_post = models.ForeignKey('Post', related_name='last_forum_post', blank=True, null=True)

    class Meta:
        ordering = ['position']
        verbose_name = _('Forum')
        verbose_name_plural = _('Forums')

    def __unicode__(self):
        return self.name

    @models.permalink
    def get_absolute_url(self):
        return ('djangobb:forum', [self.id])

    def get_mobile_url(self):
        return reverse('djangobb:mobile_forum', args=[self.id])

    @property
    def posts(self):
        return Post.objects.filter(topic__forum__id=self.id).select_related()

    def set_last_post(self):
        try:
            self.last_post = Topic.objects.filter(forum=self).latest().last_post
        except Topic.DoesNotExist:
            self.last_post = None

    def set_counts(self):
        self.topic_count = Topic.objects.filter(forum=self).count()
        self.post_count = Post.objects.filter(topic__forum=self).count()


class Topic(models.Model):
    forum = models.ForeignKey(Forum, related_name='topics', verbose_name=_('Forum'))
    name = models.CharField(_('Subject'), max_length=255)
    created = models.DateTimeField(_('Created'), auto_now_add=True)
    updated = models.DateTimeField(_('Updated'), null=True)
    user = models.ForeignKey(User, verbose_name=_('User'))
    views = models.IntegerField(_('Views count'), blank=True, default=0)
    sticky = models.BooleanField(_('Sticky'), blank=True, default=False)
    closed = models.BooleanField(_('Closed'), blank=True, default=False)
    subscribers = models.ManyToManyField(User, related_name='subscriptions', verbose_name=_('Subscribers'), blank=True)
    post_count = models.IntegerField(_('Post count'), blank=True, default=0)
    last_post = models.ForeignKey('Post', related_name='last_topic_post', blank=True, null=True)

    class Meta:
        ordering = ['-updated']
        get_latest_by = 'updated'
        verbose_name = _('Topic')
        verbose_name_plural = _('Topics')
        permissions = (
            ('delayed_close', 'Can close topics after a delay'),
            )

    def __unicode__(self):
        return self.name

    def move_to(self, new_forum):
        """
        Move a topic to a new forum.
        """
        self.clear_last_forum_post()
        old_forum = self.forum
        self.forum = new_forum
        self.save()
        old_forum.set_last_post()
        old_forum.set_counts()
        old_forum.save()

    def delete(self, *args, **kwargs):
        self.clear_last_forum_post()
        forum = self.forum
        if forum_settings.SOFT_DELETE_TOPICS and (self.forum != get_object_or_404(Forum, pk=forum_settings.SOFT_DELETE_TOPICS) or not kwargs.get('staff', False)):
            self.forum = get_object_or_404(Forum, pk=forum_settings.SOFT_DELETE_TOPICS)
            self.save()
        else:
            super(Topic, self).delete()

        forum.set_last_post()
        forum.set_counts()
        forum.save()

    @property
    def head(self):
        try:
            return self.posts.select_related().order_by('created')[0]
        except IndexError:
            return None

    @property
    def reply_count(self):
        return self.post_count - 1

    @models.permalink
    def get_absolute_url(self):
        return ('djangobb:topic', [self.id])

    def get_mobile_url(self):
        return reverse('djangobb:mobile_topic', args=[self.id])

    def update_read(self, user):
        tracking = user.posttracking
        #if last_read > last_read - don't check topics
        if tracking.last_read and (tracking.last_read > self.last_post.created):
            return
        if isinstance(tracking.topics, dict):
            #clear topics if len > 5Kb and set last_read to current time
            if len(tracking.topics) > 5120:
                tracking.topics = None
                tracking.last_read = timezone.now()
                tracking.save()
            #update topics if exist new post or does't exist in dict
            elif self.last_post_id > tracking.topics.get(str(self.id), 0):
                tracking.topics[str(self.id)] = self.last_post_id
                tracking.save()
        else:
            #initialize topic tracking dict
            tracking.topics = {self.id: self.last_post_id}
            tracking.save()

    def clear_last_forum_post(self):
        """
        Prep for moving/deleting. Update the forum the topic belongs to.
        """
        try:
            last_post = self.posts.latest()
            last_post.last_forum_post.clear()
        except Post.DoesNotExist:
            pass
        else:
            last_post.last_forum_post.clear()


class Post(models.Model):
    topic = models.ForeignKey(Topic, related_name='posts', verbose_name=_('Topic'))
    user = models.ForeignKey(User, related_name='posts', verbose_name=_('User'))
    created = models.DateTimeField(_('Created'), auto_now_add=True)
    updated = models.DateTimeField(_('Updated'), blank=True, null=True)
    updated_by = models.ForeignKey(User, verbose_name=_('Updated by'), blank=True, null=True)
    markup = models.CharField(_('Markup'), max_length=15, default=forum_settings.DEFAULT_MARKUP, choices=MARKUP_CHOICES)
    body = models.TextField(_('Message'), validators=[MaxLengthValidator(forum_settings.POST_MAX_LENGTH)])
    body_html = models.TextField(_('HTML version'))
    user_ip = models.IPAddressField(_('User IP'), blank=True, null=True)


    class Meta:
        ordering = ['created']
        get_latest_by = 'created'
        verbose_name = _('Post')
        verbose_name_plural = _('Posts')
        permissions = (
            ('fast_post', 'Can add posts without a time limit'),
            ('med_post', 'Can add posts at medium speed'),
            ('post_external_links', 'Can post external links'),
            ('delayed_delete', 'Can delete posts after a delay'),
        )

    def save(self, *args, **kwargs):
        self.body_html = convert_text_to_html(self.body, self.user.forum_profile)
        if forum_settings.SMILES_SUPPORT and self.user.forum_profile.show_smilies:
            self.body_html = smiles(self.body_html)
        super(Post, self).save(*args, **kwargs)

    def move_to(self, to_topic, delete_topic=True):
        delete_topic = (self.topic.posts.count() == 1) and delete_topic
        prev_topic = self.topic
        self.topic = to_topic
        self.save()
        self.set_counts()

        if delete_topic:
            prev_topic.delete()
        prev_topic.forum.set_last_post()
        prev_topic.forum.set_counts()
        prev_topic.forum.save()

    def delete(self, *args, **kwargs):
        self_id = self.id
        head_post_id = self.topic.posts.order_by('created')[0].id
        forum = self.topic.forum
        topic = self.topic
        profile = self.user.forum_profile
        self.last_topic_post.clear()
        self.last_forum_post.clear()

        # If we actually delete the post, we lose any reports that my have come from it. Also, there is no recovery (but I don't care about that as much right now)
        if self_id == head_post_id:
            topic.delete(*args, **kwargs)
        else:
            if forum_settings.SOFT_DELETE_POSTS and (self.topic != get_object_or_404(Topic, pk=forum_settings.SOFT_DELETE_POSTS) or not kwargs.get('staff', False)):
                    self.topic = get_object_or_404(Topic, pk=forum_settings.SOFT_DELETE_POSTS)
                    self.save()
            else:
                super(Post, self).delete()
                #if post was last in topic - remove topic
            try:
                topic.last_post = Post.objects.filter(topic__id=topic.id).latest()
            except Post.DoesNotExist:
                topic.last_post = None
            topic.post_count = Post.objects.filter(topic__id=topic.id).count()
            topic.save()
        forum.set_last_post()
        forum.save()
        self.set_counts()

    def set_counts(self):
        """
        Recounts this post's forum and and topic post counts.
        """
        forum = self.topic.forum
        profile = self.user.forum_profile
        #TODO: for speedup - save/update only changed fields
        forum.set_counts()
        forum.save()
        profile.set_counts()
        profile.save()

    @models.permalink
    def get_absolute_url(self):
        return ('djangobb:post', [self.id])

    def get_mobile_url(self):
        return reverse('djangobb:mobile_post', args=[self.id])

    def summary(self):
        LIMIT = 50
        tail = len(self.body) > LIMIT and '...' or ''
        return self.body[:LIMIT] + tail

    __unicode__ = summary


class Reputation(models.Model):
    from_user = models.ForeignKey(User, related_name='reputations_from', verbose_name=_('From'))
    to_user = models.ForeignKey(User, related_name='reputations_to', verbose_name=_('To'))
    post = models.ForeignKey(Post, related_name='post', verbose_name=_('Post'))
    time = models.DateTimeField(_('Time'), auto_now_add=True)
    sign = models.IntegerField(_('Sign'), choices=SIGN_CHOICES, default=0)
    reason = models.TextField(_('Reason'), max_length=1000)

    class Meta:
        verbose_name = _('Reputation')
        verbose_name_plural = _('Reputations')
        unique_together = (('from_user', 'post'),)

    def __unicode__(self):
        return u'T[%d], FU[%d], TU[%d]: %s' % (self.post.id, self.from_user.id, self.to_user.id, unicode(self.time))


class ProfileManager(models.Manager):
    use_for_related_fields = True
    def get_query_set(self):
        qs = super(ProfileManager, self).get_query_set()
        if forum_settings.REPUTATION_SUPPORT:
            qs = qs.extra(select={
                'reply_total': 'SELECT SUM(sign) FROM djangobb_forum_reputation WHERE to_user_id = djangobb_forum_profile.user_id GROUP BY to_user_id',
                'reply_count_minus': "SELECT SUM(sign) FROM djangobb_forum_reputation WHERE to_user_id = djangobb_forum_profile.user_id AND sign = '-1' GROUP BY to_user_id",
                'reply_count_plus': "SELECT SUM(sign) FROM djangobb_forum_reputation WHERE to_user_id = djangobb_forum_profile.user_id AND sign = '1' GROUP BY to_user_id",
                })
        return qs

class Profile(models.Model):
    user = AutoOneToOneField(User, related_name='forum_profile', verbose_name=_('User'))
    status = models.CharField(_('Status'), max_length=30, blank=True)
    site = models.URLField(_('Site'), verify_exists=False, blank=True)
    jabber = models.CharField(_('Jabber'), max_length=80, blank=True)
    icq = models.CharField(_('ICQ'), max_length=12, blank=True)
    msn = models.CharField(_('MSN'), max_length=80, blank=True)
    aim = models.CharField(_('AIM'), max_length=80, blank=True)
    yahoo = models.CharField(_('Yahoo'), max_length=80, blank=True)
    location = models.CharField(_('Location'), max_length=30, blank=True)
    signature = models.TextField(_('Signature'), blank=True, default='', max_length=forum_settings.SIGNATURE_MAX_LENGTH)
    signature_html = models.TextField(_('Signature'), blank=True, default='', max_length=forum_settings.SIGNATURE_MAX_LENGTH)
    time_zone = models.FloatField(_('Time zone'), choices=TZ_CHOICES, default=float(forum_settings.DEFAULT_TIME_ZONE))
    language = models.CharField(_('Language'), max_length=5, default='', choices=settings.LANGUAGES)
    avatar = ExtendedImageField(_('Avatar'), blank=True, default='', upload_to=forum_settings.AVATARS_UPLOAD_TO, width=forum_settings.AVATAR_WIDTH, height=forum_settings.AVATAR_HEIGHT)
    theme = models.CharField(_('Theme'), choices=THEME_CHOICES, max_length=80, default='default')
    show_avatar = models.BooleanField(_('Show avatar'), blank=True, default=True)
    show_signatures = models.BooleanField(_('Show signatures'), blank=True, default=True)
    show_smilies = models.BooleanField(_('Show smilies'), blank=True, default=True)
    privacy_permission = models.IntegerField(_('Privacy permission'), choices=PRIVACY_CHOICES, default=1)
    auto_subscribe = models.BooleanField(_('Auto subscribe'), help_text=_("Auto subscribe all topics you have created or reply."), blank=True, default=False)
    markup = models.CharField(_('Default markup'), max_length=15, default=forum_settings.DEFAULT_MARKUP, choices=MARKUP_CHOICES)
    post_count = models.IntegerField(_('Post count'), blank=True, default=0)

    objects = ProfileManager()

    class Meta:
        verbose_name = _('Profile')
        verbose_name_plural = _('Profiles')

    def last_post(self):
        posts = Post.objects.filter(user__id=self.user_id).order_by('-created')
        if posts:
            return posts[0].created
        else:
            return  None

    def set_counts(self):
        self.post_count = Post.objects.filter(user=self.user).count()


class PostTracking(models.Model):
    """
    Model for tracking read/unread posts.
    In topics stored ids of topics and last_posts as dict.
    """

    user = AutoOneToOneField(User)
    topics = JSONField(null=True, blank=True)
    last_read = models.DateTimeField(null=True, blank=True)

    class Meta:
        verbose_name = _('Post tracking')
        verbose_name_plural = _('Post tracking')

    def __unicode__(self):
        return self.user.username

class Report(models.Model):
    reported_by = models.ForeignKey(User, related_name='reported_by', verbose_name=_('Reported by'))
    post = models.ForeignKey(Post, verbose_name=_('Post'))
    zapped = models.BooleanField(_('Zapped'), blank=True, default=False)
    zapped_by = models.ForeignKey(User, related_name='zapped_by', blank=True, null=True, verbose_name=_('Zapped by'))
    created = models.DateTimeField(_('Created'), blank=True)
    reason = models.TextField(_('Reason'), blank=True, default='', max_length='1000')

    class Meta:
        verbose_name = _('Report')
        verbose_name_plural = _('Reports')

    def __unicode__(self):
        return u'%s %s' % (self.reported_by , self.zapped)

class Ban(models.Model):
    user = models.OneToOneField(User, verbose_name=_('Banned user'), related_name='ban_users')
    ban_start = models.DateTimeField(_('Ban start'), default=timezone.now)
    ban_end = models.DateTimeField(_('Ban end'), blank=True, null=True)
    reason = models.TextField(_('Reason'))

    class Meta:
        verbose_name = _('Ban')
        verbose_name_plural = _('Bans')

    def __unicode__(self):
        return self.user.username

    def save(self, *args, **kwargs):
        self.user.is_active = False
        self.user.save()
        super(Ban, self).save(*args, **kwargs)

    def delete(self, *args, **kwargs):
        self.user.is_active = True
        self.user.save()
        super(Ban, self).delete(*args, **kwargs)


class Attachment(models.Model):
    post = models.ForeignKey(Post, verbose_name=_('Post'), related_name='attachments')
    size = models.IntegerField(_('Size'))
    content_type = models.CharField(_('Content type'), max_length=255)
    path = models.CharField(_('Path'), max_length=255)
    name = models.TextField(_('Name'))
    hash = models.CharField(_('Hash'), max_length=40, blank=True, default='', db_index=True)

    def __unicode__(self):
        return self.name

    def save(self, *args, **kwargs):
        super(Attachment, self).save(*args, **kwargs)
        if not self.hash:
            self.hash = sha1(str(self.id) + settings.SECRET_KEY).hexdigest()
        super(Attachment, self).save(*args, **kwargs)

    @models.permalink
    def get_absolute_url(self):
        return ('djangobb:forum_attachment', [self.hash])

    def get_absolute_path(self):
        return os.path.join(settings.MEDIA_ROOT, forum_settings.ATTACHMENT_UPLOAD_TO,
                            self.path)


#------------------------------------------------------------------------------


class Poll(models.Model):
    topic = models.ForeignKey(Topic)
    question = models.CharField(max_length=200)
    choice_count = models.PositiveSmallIntegerField(default=1,
        help_text=_("How many choices are allowed simultaneously."),
    )
    active = models.BooleanField(default=True,
        help_text=_("Can users vote to this poll or just see the result?"),
    )
    deactivate_date = models.DateTimeField(null=True, blank=True,
        help_text=_("Point of time after this poll would be automatic deactivated"),
    )
    users = models.ManyToManyField(User, blank=True, null=True,
        help_text=_("Users who has voted this poll."),
    )
    def auto_deactivate(self):
        if self.active and self.deactivate_date:
            now = timezone.now()
            if now > self.deactivate_date:
                self.active = False
                self.save()

    def __unicode__(self):
        return self.question


class PollChoice(models.Model):
    poll = models.ForeignKey(Poll, related_name="choices")
    choice = models.CharField(max_length=200)
    votes = models.IntegerField(default=0, editable=False)

    def percent(self):
        if not self.votes:
            return 0.0
        result = PollChoice.objects.filter(poll=self.poll).aggregate(aggregates.Sum("votes"))
        votes_sum = result["votes__sum"]
        return float(self.votes) / votes_sum * 100

    def __unicode__(self):
        return self.choice


#------------------------------------------------------------------------------


class PostStatusManager(models.Manager):
    def create_for_post(self, post, **kwargs):
        user_agent = kwargs.get("HTTP_USER_AGENT", None)
        referrer = kwargs.get("HTTP_REFERER", None)
        permalink = kwargs.get("permalink", None)
        return self.create(
            post=post, topic=post.topic, forum=post.topic.forum,
            user_agent=user_agent, referrer=referrer, permalink=permalink)

    def review_posts(self, posts, certainly_spam=False):
        for post in posts:
            try:
                post_status = post.poststatus
            except PostStatus.DoesNotExist:
                post_status = self.create_for_post(post)
            post_status.review(certainly_spam=certainly_spam)

    def delete_user_posts(self, posts):
        for post in posts:
            try:
                post_status = post.poststatus
            except PostStatus.DoesNotExist:
                post_status = self.create_for_post(post)
            post_status.filter_user_deleted()

    def undelete_user_posts(self, posts):
        for post in posts:
            try:
                post_status = post.poststatus
            except PostStatus.DoesNotExist:
                post_status = self.create_for_post(post)
            post_status.filter_user_undeleted()        

    def review_new_posts(self):
        unreviewed = self.filter(state=PostStatus.UNREVIEWED)
        for post_status in unreviewed:
            post_status.review()
        return unreviewed


class PostStatus(models.Model):
    """
    Keeps track of the status of posts for moderation purposes.
    """
    UNREVIEWED = 'unreviewed'
    USER_DELETED = 'user_deleted'
    FILTERED_SPAM = 'filtered_spam'
    FILTERED_HAM = 'filtered_ham'
    MARKED_SPAM = 'marked_spam'
    MARKED_HAM = 'marked_ham'

    AKISMET_MAX_SIZE = 1024*250

    post = models.OneToOneField(Post, db_index=True)
    state = FSMField(default=UNREVIEWED, db_index=True)
    topic = models.ForeignKey(Topic) # Original topic
    forum = models.ForeignKey(Forum) # Original forum
    user_agent = models.CharField(max_length=200, blank=True, null=True)
    referrer = models.CharField(max_length=200, blank=True, null=True)
    permalink = models.CharField(max_length=200, blank=True, null=True)

    objects = PostStatusManager()

    spam_category = None
    spam_forum = None
    spam_topic = None

    def _get_spam_dustbin(self):
        if self.spam_category is None:
            self.spam_category, _ = Category.objects.get_or_create(
                name=forum_settings.SPAM_CATEGORY_NAME)

        if self.spam_forum is None:
            self.spam_forum, _ = Forum.objects.get_or_create(
                category=self.spam_category,
                name=forum_settings.SPAM_FORUM_NAME)

        if self.spam_topic is None:
            filterbot = User.objects.get_by_natural_key("filterbot")
            self.spam_topic, _ = Topic.objects.get_or_create(
                forum=self.spam_forum, name=forum_settings.SPAM_TOPIC_NAME,
                user=filterbot)

        return (self.spam_topic, self.spam_forum)

    def _undelete_post(self):
        """
        If the post is in the spam dustbin, move it back to its original location.
        """
        spam_topic, spam_forum = self._get_spam_dustbin()
        post = self.post
        topic = self.topic
        head = post.topic.head

        if post == head:
            # Move the original topic back to the original forum (either from
            # the dustbin, or from the spam dustbin)
            topic.move_to(self.forum)
        
        if topic != post.topic:
            # If the post was moved from its original topic, put it back now that
            # the topic is in place.
            post.move_to(topic, delete_topic=False)

    def _delete_post(self):
        """
        Move the post to the spam dustbin.
        """
        spam_topic, spam_forum = self._get_spam_dustbin()
        post = self.post
        topic = self.topic
        head = topic.head

        if post == head:
            topic.move_to(spam_forum)
        else:
            post.move_to(spam_topic)

    def to_akismet_data(self):
        post = self.post
        topic = self.topic
        user = post.user
        user_ip = post.user_ip
        comment_author = user.username
        user_agent = self.user_agent
        referrer = self.referrer
        permalink = self.permalink
        comment_date_gmt = post.created.isoformat(' ')
        comment_post_modified_gmt = topic.created.isoformat(' ')

        return {
            'user_ip': user_ip,
            'user_agent': user_agent,
            'comment_author': comment_author,
            'referrer': referrer,
            'permalink': permalink,
            'comment_type': 'comment',
            'comment_date_gmt': comment_date_gmt,
            'comment_post_modified_gmt': comment_post_modified_gmt
        }

    def to_akismet_content(self):
        """
        Truncate the post body to the largest allowed string size. Use size, not
        length, since the Akismet server checks size, not length.
        """
        return self.post.body.encode('utf-8')[:self.AKISMET_MAX_SIZE].decode('utf-8', 'ignore')

    def _comment_check(self):
        """
        Pass the associated post through Akismet if it's available. If it's not
        available return None. Otherwise return True or False.
        """
        if akismet_api is None:
            logger.warning("Skipping akismet check. No api.")
            return None

        data = self.to_akismet_data()
        content = self.to_akismet_content()
        is_spam = None

        try:
            is_spam = akismet_api.comment_check(content, data)
        except AkismetError as e:
            try:
                # try again, in case of timeout
                is_spam = akismet_api.comment_check(content, data)
            except Exception as e:
                logger.error(
                    "Error while checking Akismet", exc_info=True, extra={
                        "post": self.post, "post_id": self.post.id,
                        "content_length": len(content)})
                is_spam = None
        except Exception as e:
            logger.error(
                "Error while checking Akismet", exc_info=True, extra={
                    "post": self.post, "post_id": self.post.id,
                    "content_length": len(content)})
            is_spam = None

        return is_spam

    def _submit_comment(self, report_type):
        """
        Report this post to Akismet as spam or ham. Raises an exception if it
        fails. report_type is 'spam' or 'ham'. Used by report_spam/report_ham.
        """
        if akismet_api is None:
            logger.error("Can't submit to Akismet. No API.")
            return None

        data = self.to_akismet_data()
        content = self.to_akismet_content()

        if report_type == "spam":
            akismet_api.submit_spam(content, data)

        elif report_type == "ham":
            akismet_api.submit_ham(content, data)
        else:
            raise NotImplementedError(
                "You're trying to report an unsupported comment type.")

    def _submit_spam(self):
        """
        Report this post to Akismet as spam.
        """
        self._submit_comment("spam")

    def _submit_ham(self):
        """
        Report this post to Akismet as ham.
        """
        self._submit_comment("ham")

    def is_spam(self):
        """
        Condition used by the FSM. Return True if the Akismet API is available
        and returns a positive. Otherwise return False or None.
        """
        is_spam = self._comment_check()
        if is_spam is None:
            return False
        else:
            return is_spam

    def is_ham(self):
        """
        Inverse of is_spam.
        """
        is_spam = self._comment_check()
        if is_spam is None:
            return False
        else:
            return not is_spam

    @transition(
        field=state, source=UNREVIEWED, target=FILTERED_SPAM,
        save=True, conditions=[is_spam])
    def filter_spam(self):
        """
        Akismet detected this post is spam, move it to the dustbin and report it.
        """
        self._delete_post()

    @transition(
        field=state, source=UNREVIEWED, target=FILTERED_HAM,
        save=True, conditions=[is_ham])
    def filter_ham(self):
        """
        Akismet detected this post as ham. Don't do anything (except change state).
        """
        pass

    @transition(
        field=state, source=[UNREVIEWED, FILTERED_HAM, MARKED_HAM], target=USER_DELETED,
        save=True)
    def filter_user_deleted(self):
        """
        Post is not marked spam by akismet, but user has been globally deleted,
        putting this into the spam dusbin.
        """
        self._delete_post()

    @transition(
        field=state, source=[FILTERED_SPAM, MARKED_SPAM], target=MARKED_HAM,
        save=True)
    def mark_ham(self):
        """
        Either Akismet returned a false positive, or a moderator accidentally
        marked this as spam. Tell Akismet that this is ham, undelete it.
        """
        self._submit_ham()
        self._undelete_post()

    @transition(
        field=state, source=[FILTERED_HAM, MARKED_HAM], target=MARKED_SPAM,
        save=True)
    def mark_spam(self):
        """
        Akismet missed this, or a moderator accidentally marked it as ham. Tell
        Akismet that this is spam.
        """
        self._submit_spam()
        self._delete_post()

    @transition(
        field=state, source=USER_DELETED, target=UNREVIEWED,
        save=True)
    def filter_user_undeleted(self):
        """
        Post is not marked spam by akismet, but user has been globally deleted,
        putting this into the spam dusbin.
        """
        self._undelete_post()

    def review(self, certainly_spam=False):
        """
        Process this post, used by the manager and the spam-hammer. The
        ``certainly_spam`` argument is used to force mark as spam/delete the
        post, no matter what status Akismet returns.
        """
        if can_proceed(self.filter_spam):
            self.filter_spam()
        elif can_proceed(self.filter_ham):
            self.filter_ham()
            if certainly_spam:
                self.mark_spam()
        else:
            if certainly_spam:
                self._delete_post()
            logger.warn(
                "Couldn't filter post.", exc_info=True, extra={
                    'post_id': self.post.id, 'content_length': len(self.post.body)})


from .signals import post_saved, topic_saved

post_save.connect(post_saved, sender=Post, dispatch_uid='djangobb_post_save')
post_save.connect(topic_saved, sender=Topic, dispatch_uid='djangobb_topic_save')