boards/views/all_threads.py

import string

from django.core.urlresolvers import reverse
from django.db import transaction
from django.shortcuts import render, redirect

from boards import utils
from boards.abstracts.paginator import get_paginator
from boards.forms import ThreadForm, PlainErrorList
from boards.models import Post, Thread, Ban, Tag
from boards.views.banned import BannedView
from boards.views.base import BaseBoardView, PARAMETER_FORM
from boards.views.posting_mixin import PostMixin
import neboard

TAG_DELIMITER = ' '

PARAMETER_CURRENT_PAGE = 'current_page'
PARAMETER_PAGINATOR = 'paginator'
PARAMETER_THREADS = 'threads'

TEMPLATE = 'boards/posting_general.html'
DEFAULT_PAGE = 1


class AllThreadsView(PostMixin, BaseBoardView):

    user = None

    def get(self, request, page=DEFAULT_PAGE, form=None):
        context = self.get_context_data(request=request)

        self.user = context['user']

        if not form:
            form = ThreadForm(error_class=PlainErrorList)

        paginator = get_paginator(self.get_threads(),
                                  neboard.settings.THREADS_PER_PAGE)
        paginator.current_page = int(page)

        threads = paginator.page(page).object_list

        context[PARAMETER_THREADS] = threads
        context[PARAMETER_FORM] = form

        self._get_page_context(paginator, context, page)

        return render(request, TEMPLATE, context)

    def post(self, request, page=DEFAULT_PAGE):
        form = ThreadForm(request.POST, request.FILES,
                          error_class=PlainErrorList)
        form.session = request.session

        if form.is_valid():
            return self.create_thread(request, form)
        if form.need_to_ban:
            # Ban user because he is suspected to be a bot
            self._ban_current_user(request)

        return self.get(request, page, form)

    @staticmethod
    def _get_page_context(paginator, context, page):
        """
        Get pagination context variables
        """

        context[PARAMETER_PAGINATOR] = paginator
        context[PARAMETER_CURRENT_PAGE] = paginator.page(int(page))

    def parse_tags_string(self, tag_strings):
        """
        Parses tag list string and returns tag object list.
        """

        tags = []

        if tag_strings:
            tag_strings = tag_strings.split(TAG_DELIMITER)
            for tag_name in tag_strings:
                tag_name = string.lower(tag_name.strip())
                if len(tag_name) > 0:
                    tag, created = Tag.objects.get_or_create(name=tag_name)
                    tags.append(tag)

        return tags

    @transaction.atomic
    def create_thread(self, request, form, html_response=True):
        """
        Creates a new thread with an opening post.
        """

        ip = utils.get_client_ip(request)
        is_banned = Ban.objects.filter(ip=ip).exists()

        if is_banned:
            if html_response:
                return redirect(BannedView().as_view())
            else:
                return

        data = form.cleaned_data

        title = data['title']
        text = data['text']

        text = self._remove_invalid_links(text)

        if 'image' in data.keys():
            image = data['image']
        else:
            image = None

        tag_strings = data['tags']

        tags = self.parse_tags_string(tag_strings)

        post = Post.objects.create_post(title=title, text=text, ip=ip,
                                        image=image, tags=tags,
                                        user=self._get_user(request))

        if html_response:
            return redirect(post.get_url())

    def get_threads(self):
        """
        Gets list of threads that will be shown on a page.
        """

        return Thread.objects.all().order_by('-bump_time')\
            .exclude(tags__in=self.user.hidden_tags.all())