Rewriting views to class-based

boards/views/all_threads.py

@@ -0,0 +1,134 b''
+import string
+
+from django.core.paginator import Paginator
+from django.core.urlresolvers import reverse
+from django.db import transaction
+from django.shortcuts import render, redirect
+
+from boards import utils
+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
+
+PARAMETER_CURRENT_PAGE = 'current_page'
+
+PARAMETER_PAGINATOR = 'paginator'
+
+PARAMETER_THREADS = 'threads'
+
+TEMPLATE = 'boards/posting_general.html'
+DEFAULT_PAGE = 1
+
+
+class AllThreadsView(PostMixin, BaseBoardView):
+
+    def get(self, request, page=DEFAULT_PAGE):
+        context = self.get_context_data(request=request)
+
+        form = ThreadForm(error_class=PlainErrorList)
+
+        paginator = Paginator(self.get_threads(),
+                              neboard.settings.THREADS_PER_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):
+        context = self.get_context_data(request=request)
+
+        form = ThreadForm(request.POST, request.FILES,
+                          error_class=PlainErrorList)
+        form.session = request.session
+
+        if form.is_valid():
+            return self._new_post(request, form)
+        if form.need_to_ban:
+            # Ban user because he is suspected to be a bot
+            self._ban_current_user(request)
+
+        paginator = Paginator(self.get_threads(),
+                              neboard.settings.THREADS_PER_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)
+
+    @staticmethod
+    def _get_page_context(paginator, context, page):
+        """
+        Get pagination context variables
+        """
+
+        context[PARAMETER_PAGINATOR] = paginator
+        context[PARAMETER_CURRENT_PAGE] = paginator.page(int(page))
+
+    # TODO This method should be refactored
+    @transaction.atomic
+    def _new_post(self, request, form, opening_post=None, html_response=True):
+        """
+        Add a new thread 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
+
+        tags = []
+
+        tag_strings = data['tags']
+
+        if tag_strings:
+            tag_strings = tag_strings.split(' ')
+            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)
+
+        post = Post.objects.create_post(title=title, text=text, ip=ip,
+                                        image=image, tags=tags,
+                                        user=self._get_user(request))
+
+        thread_to_show = (opening_post.id if opening_post else post.id)
+
+        if html_response:
+            if opening_post:
+                return redirect(
+                    reverse('thread', kwargs={'post_id': thread_to_show}) +
+                    '#' + str(post.id))
+            else:
+                return redirect('thread', post_id=thread_to_show)
+
+    def get_threads(self):
+        return Thread.objects.filter(archived=False)
  No newline at end of file

boards/views/archived_threads.py

@@ -0,0 +1,10 b''
+from boards.models import Thread
+from boards.views.all_threads import AllThreadsView
+
+__author__ = 'neko259'
+
+
+class ArchiveView(AllThreadsView):
+
+    def get_threads(self):
+        return Thread.objects.filter(archived=True)
  No newline at end of file

boards/views/banned.py

@@ -0,0 +1,16 b''
+from django.shortcuts import get_object_or_404, render
+from boards import utils
+from boards.models import Ban
+from boards.views.base import BaseBoardView
+
+
+class BannedView(BaseBoardView):
+
+    def get(self, request):
+        """Show the page that notifies that user is banned"""
+
+        context = self.get_context_data(request)
+
+        ban = get_object_or_404(Ban, ip=utils.get_client_ip(request))
+        context['ban_reason'] = ban.reason
+        return render(request, 'boards/staticpages/banned.html', context)

boards/views/base.py

@@ -0,0 +1,125 b''
+from datetime import datetime, timedelta
+import hashlib
+from django.db import transaction
+from django.db.models import Count
+from django.template import RequestContext
+from django.utils import timezone
+from django.views.generic import View
+from boards import utils
+from boards.models import User, Post
+from boards.models.post import SETTING_MODERATE
+from boards.models.user import RANK_USER, Ban
+import neboard
+
+BAN_REASON_SPAM = 'Autoban: spam bot'
+
+OLD_USER_AGE_DAYS = 90
+
+PARAMETER_FORM = 'form'
+
+
+class BaseBoardView(View):
+
+    def get_context_data(self, **kwargs):
+        request = kwargs['request']
+        context = self._default_context(request)
+
+        context['version'] = neboard.settings.VERSION
+        context['site_name'] = neboard.settings.SITE_NAME
+
+        return context
+
+    def _default_context(self, request):
+        """Create context with default values that are used in most views"""
+
+        context = RequestContext(request)
+
+        user = self._get_user(request)
+        context['user'] = user
+        context['tags'] = user.get_sorted_fav_tags()
+        context['posts_per_day'] = float(Post.objects.get_posts_per_day())
+
+        theme = self._get_theme(request, user)
+        context['theme'] = theme
+        context['theme_css'] = 'css/' + theme + '/base_page.css'
+
+        # This shows the moderator panel
+        moderate = user.get_setting(SETTING_MODERATE)
+        if moderate == 'True':
+            context['moderator'] = user.is_moderator()
+        else:
+            context['moderator'] = False
+
+        return context
+
+    def _get_user(self, request):
+        """
+        Get current user from the session. If the user does not exist, create
+        a new one.
+        """
+
+        session = request.session
+        if not 'user_id' in session:
+            request.session.save()
+
+            md5 = hashlib.md5()
+            md5.update(session.session_key)
+            new_id = md5.hexdigest()
+
+            while User.objects.filter(user_id=new_id).exists():
+                md5.update(str(timezone.now()))
+                new_id = md5.hexdigest()
+
+            time_now = timezone.now()
+            user = User.objects.create(user_id=new_id, rank=RANK_USER,
+                                       registration_time=time_now)
+
+            self._delete_old_users()
+
+            session['user_id'] = user.id
+        else:
+            user = User.objects.get(id=session['user_id'])
+
+        return user
+
+    def _get_theme(self, request, user=None):
+        """
+        Get user's CSS theme
+        """
+
+        if not user:
+            user = self._get_user(request)
+        theme = user.get_setting('theme')
+        if not theme:
+            theme = neboard.settings.DEFAULT_THEME
+
+        return theme
+
+    def _delete_old_users(self):
+        """
+        Delete users with no favorite tags and posted messages. These can be spam
+        bots or just old user accounts
+        """
+
+        old_registration_date = datetime.now().date() - timedelta(
+            OLD_USER_AGE_DAYS)
+
+        for user in User.objects.annotate(tags_count=Count('fav_tags')).filter(
+                tags_count=0).filter(
+                registration_time__lt=old_registration_date):
+            if not Post.objects.filter(user=user).exists():
+                user.delete()
+
+    @transaction.atomic
+    def _ban_current_user(self, request):
+        """
+        Add current user to the IP ban list
+        """
+
+        ip = utils.get_client_ip(request)
+        ban, created = Ban.objects.get_or_create(ip=ip)
+        if created:
+            ban.can_read = False
+            ban.reason = BAN_REASON_SPAM
+        ban.save()
+

boards/views/posting_mixin.py

@@ -0,0 +1,25 b''
+import re
+import string
+
+from boards.models import Post
+from boards.models.post import REGEX_REPLY
+
+REFLINK_PREFIX = '>>'
+
+
+class PostMixin:
+
+    @staticmethod
+    def _remove_invalid_links(text):
+        """
+        Replace invalid links in posts so that they won't be parsed.
+        Invalid links are links to non-existent posts
+        """
+
+        for reply_number in re.finditer(REGEX_REPLY, text):
+            post_id = reply_number.group(1)
+            post = Post.objects.filter(id=post_id)
+            if not post.exists():
+                text = string.replace(text, REFLINK_PREFIX + post_id, post_id)
+
+        return text

boards/views/tag_threads.py

@@ -0,0 +1,28 b''
+from django.shortcuts import get_object_or_404
+from boards.models import Tag, Post
+from boards.views.all_threads import AllThreadsView, DEFAULT_PAGE
+
+__author__ = 'neko259'
+
+
+class TagView(AllThreadsView):
+
+    tag_name = None
+
+    def get_threads(self):
+        tag = get_object_or_404(Tag, name=self.tag_name)
+
+        return tag.threads.filter(archived=False)
+
+    def get_context_data(self, **kwargs):
+        context = super(TagView, self).get_context_data(**kwargs)
+
+        tag = get_object_or_404(Tag, name=self.tag_name)
+        context['tag'] = tag
+
+        return context
+
+    def get(self, request, tag_name, page=DEFAULT_PAGE):
+        self.tag_name = tag_name
+
+        return super(TagView, self).get(request, page)
  No newline at end of file

boards/views/thread.py

@@ -0,0 +1,149 b''
+import string
+from django.core.urlresolvers import reverse
+from django.db import transaction
+from django.http import Http404
+from django.shortcuts import get_object_or_404, render, redirect
+from boards import utils
+from boards.forms import PostForm, PlainErrorList
+from boards.models import Post, 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
+
+MODE_GALLERY = 'gallery'
+MODE_NORMAL = 'normal'
+
+
+class ThreadView(BaseBoardView, PostMixin):
+
+    def get(self, request, post_id, mode=MODE_NORMAL):
+        opening_post = get_object_or_404(Post, id=post_id)
+
+        # If this is not OP, don't show it as it is
+        if not opening_post.is_opening():
+            raise Http404
+
+        form = PostForm(error_class=PlainErrorList)
+
+        thread_to_show = opening_post.thread_new
+
+        context = self.get_context_data(request=request)
+
+        posts = thread_to_show.get_replies()
+        context[PARAMETER_FORM] = form
+        context["last_update"] = utils.datetime_to_epoch(
+            thread_to_show.last_edit_time)
+        context["thread"] = thread_to_show
+
+        if MODE_NORMAL == mode:
+            context['bumpable'] = thread_to_show.can_bump()
+            if context['bumpable']:
+                context['posts_left'] = neboard.settings.MAX_POSTS_PER_THREAD - posts \
+                    .count()
+                context['bumplimit_progress'] = str(
+                    float(context['posts_left']) /
+                    neboard.settings.MAX_POSTS_PER_THREAD * 100)
+
+            context['posts'] = posts
+
+            document = 'boards/thread.html'
+        elif MODE_GALLERY == mode:
+            context['posts'] = posts.filter(image_width__gt=0)
+
+            document = 'boards/thread_gallery.html'
+        else:
+            raise Http404
+
+        return render(request, document, context)
+
+    def post(self, request, post_id, mode=MODE_NORMAL):
+        opening_post = get_object_or_404(Post, id=post_id)
+
+        # If this is not OP, don't show it as it is
+        if not opening_post.is_opening():
+            raise Http404
+
+        if not opening_post.thread_new.archived:
+            form = PostForm(request.POST, request.FILES,
+                            error_class=PlainErrorList)
+            form.session = request.session
+
+            if form.is_valid():
+                return self.new_post(request, form, opening_post)
+            if form.need_to_ban:
+                # Ban user because he is suspected to be a bot
+                self._ban_current_user(request)
+
+            thread_to_show = opening_post.thread_new
+
+            context = self.get_context_data(request=request)
+
+            posts = thread_to_show.get_replies()
+            context[PARAMETER_FORM] = form
+            context["last_update"] = utils.datetime_to_epoch(
+                thread_to_show.last_edit_time)
+            context["thread"] = thread_to_show
+
+            if MODE_NORMAL == mode:
+                context['bumpable'] = thread_to_show.can_bump()
+                if context['bumpable']:
+                    context['posts_left'] = neboard.settings.MAX_POSTS_PER_THREAD - posts \
+                        .count()
+                    context['bumplimit_progress'] = str(
+                        float(context['posts_left']) /
+                        neboard.settings.MAX_POSTS_PER_THREAD * 100)
+
+                context['posts'] = posts
+
+                document = 'boards/thread.html'
+            elif MODE_GALLERY == mode:
+                context['posts'] = posts.filter(image_width__gt=0)
+
+                document = 'boards/thread_gallery.html'
+            else:
+                raise Http404
+
+            return render(request, document, context)
+
+    @transaction.atomic
+    def new_post(self, request, form, opening_post=None, html_response=True):
+        """Add a new post (in thread or as a reply)."""
+
+        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
+
+        tags = []
+
+        post_thread = opening_post.thread_new
+
+        post = Post.objects.create_post(title=title, text=text, ip=ip,
+                                        thread=post_thread, image=image,
+                                        tags=tags,
+                                        user=self._get_user(request))
+
+        thread_to_show = (opening_post.id if opening_post else post.id)
+
+        if html_response:
+            if opening_post:
+                return redirect(reverse('thread',
+                            kwargs={'post_id': thread_to_show}) + '#'
+                                + str(post.id))
  No newline at end of file

boards/middlewares.py

@@ -17,14 +17,14 b' class BanMiddleware:'
 
     def process_view(self, request, view_func, view_args, view_kwargs):
 
-        if view_func != views.you_are_banned:
+        if view_func != views.banned.BannedView.as_view:
             ip = utils.get_client_ip(request)
             bans = Ban.objects.filter(ip=ip)
 
             if bans.exists():
                 ban = bans[0]
                 if not ban.can_read:
-                    return redirect(views.you_are_banned)
+                    return redirect('banned')
 
 
 class MinifyHTMLMiddleware(object):

boards/models/post.py

@@ -356,6 +356,10 b' class Thread(models.Model):'
 
                 return last_replies
 
+    def get_skipped_replies_count(self):
+        last_replies = self.get_last_replies()
+        return self.get_reply_count() - len(last_replies) - 1
+
     def get_replies(self):
         """
         Get sorted thread posts

boards/templates/boards/login.html

@@ -3,7 +3,7 b''
 {% load i18n %}
 
 {% block head %}
-    <title>{% trans 'Login' %}</title>
+    <title>{% trans 'Login' %} - {{ site_name }}</title>
 {% endblock %}
 
 {% block content %}

boards/templates/boards/post.html

@@ -2,82 +2,90 b''
 {% load board %}
 
 {% spaceless %}
-{% if post.thread_new.archived %}
-    <div class="post archive_post" id="{{ post.id }}">
-{% elif post.thread_new.can_bump %}
-    <div class="post" id="{{ post.id }}">
-{% else %}
-    <div class="post dead_post" id="{{ post.id }}">
-{% endif %}
-
-{% if post.image %}
-    <div class="image">
-        <a
-                class="thumb"
-                href="{{ post.image.url }}"><img
-                src="{{ post.image.url_200x150 }}"
-                alt="{{ post.id }}"
-                width="{{ post.image_pre_width }}"
-                height="{{ post.image_pre_height }}"
-                data-width="{{ post.image_width }}"
-                data-height="{{ post.image_height }}"/>
-        </a>
-    </div>
-{% endif %}
-<div class="message">
-    <div class="post-info">
-        <span class="title">{{ post.title }}</span>
-        <a class="post_id" href="{% post_url post.id %}">
-            ({{ post.id }}) </a>
-        [<span class="pub_time">{{ post.pub_time }}</span>]
-        {% if not truncated %}
-            [<a href="#" onclick="javascript:addQuickReply('{{ post.id }}')
-                ; return false;">&gt;&gt;</a>]
-        {% endif %}
-        {% if post.is_opening and need_open_link %}
-            [<a class="link" href="
-                    {% url 'thread' post.id %}#form">{% trans "Reply" %}</a>]
+    {% with thread=post.thread_new %}
+        {% if thread.archived %}
+            <div class="post archive_post" id="{{ post.id }}">
+        {% elif thread.can_bump %}
+            <div class="post" id="{{ post.id }}">
+        {% else %}
+            <div class="post dead_post" id="{{ post.id }}">
         {% endif %}
 
-        {% if moderator %}
-            <span class="moderator_info">
-                [<a href="{% url 'delete' post_id=post.id %}"
-                    >{% trans 'Delete' %}</a>]
-                ({{ post.poster_ip }})
-                [<a href="{% url 'ban' post_id=post.id %}?next={{ request.path }}"
-                    >{% trans 'Ban IP' %}</a>]
-            </span>
+    {% if post.image %}
+        <div class="image">
+            <a
+                    class="thumb"
+                    href="{{ post.image.url }}"><img
+                    src="{{ post.image.url_200x150 }}"
+                    alt="{{ post.id }}"
+                    width="{{ post.image_pre_width }}"
+                    height="{{ post.image_pre_height }}"
+                    data-width="{{ post.image_width }}"
+                    data-height="{{ post.image_height }}"/>
+            </a>
+        </div>
+    {% endif %}
+    <div class="message">
+        <div class="post-info">
+            <span class="title">{{ post.title }}</span>
+            <a class="post_id" href="{% post_url post.id %}">
+                ({{ post.id }}) </a>
+            [<span class="pub_time">{{ post.pub_time }}</span>]
+            {% if thread.archived %}
+                — [{{ thread.bump_time }}]
+            {% endif %}
+            {% if not truncated %}
+                [<a href="#" onclick="javascript:addQuickReply('{{ post.id }}')
+                    ; return false;">&gt;&gt;</a>]
+            {% endif %}
+            {% if post.is_opening and need_open_link %}
+                {% if post.thread_new.archived %}
+                    [<a class="link" href="{% url 'thread' post.id %}">{% trans "Open" %}</a>]
+                {% else %}
+                    [<a class="link" href="{% url 'thread' post.id %}#form">{% trans "Reply" %}</a>]
+                {% endif %}
+            {% endif %}
+
+            {% if moderator %}
+                <span class="moderator_info">
+                    [<a href="{% url 'delete' post_id=post.id %}"
+                        >{% trans 'Delete' %}</a>]
+                    ({{ post.poster_ip }})
+                    [<a href="{% url 'ban' post_id=post.id %}?next={{ request.path }}"
+                        >{% trans 'Ban IP' %}</a>]
+                </span>
+            {% endif %}
+        </div>
+        {% autoescape off %}
+            {% if truncated %}
+                {{ post.text.rendered|truncatewords_html:50 }}
+            {% else %}
+                {{ post.text.rendered }}
+            {% endif %}
+        {% endautoescape %}
+        {% if post.is_referenced %}
+            <div class="refmap">
+                {% trans "Replies" %}:
+                {% for ref_post in post.get_sorted_referenced_posts %}
+                    <a href="{% post_url ref_post.id %}">&gt;&gt;{{ ref_post.id }}</a
+                            >{% if not forloop.last %},{% endif %}
+                {% endfor %}
+            </div>
         {% endif %}
     </div>
-    {% autoescape off %}
-        {% if truncated %}
-            {{ post.text.rendered|truncatewords_html:50 }}
-        {% else %}
-            {{ post.text.rendered }}
-        {% endif %}
-    {% endautoescape %}
-    {% if post.is_referenced %}
-        <div class="refmap">
-            {% trans "Replies" %}:
-            {% for ref_post in post.get_sorted_referenced_posts %}
-                <a href="{% post_url ref_post.id %}">&gt;&gt;{{ ref_post.id }}</a
-                        >{% if not forloop.last %},{% endif %}
-            {% endfor %}
+    {% if post.is_opening and thread.tags.exists %}
+        <div class="metadata">
+            {% if post.is_opening and need_open_link %}
+                {{ thread.get_images_count }} {% trans 'images' %}.
+            {% endif %}
+            <span class="tags">
+                {% for tag in thread.get_tags %}
+                    <a class="tag" href="{% url 'tag' tag.name %}">
+                        #{{ tag.name }}</a>{% if not forloop.last %},{% endif %}
+                {% endfor %}
+            </span>
         </div>
     {% endif %}
-</div>
-{% if post.is_opening and post.thread_new.tags.exists %}
-    <div class="metadata">
-        {% if post.is_opening and need_open_link %}
-            {{ post.thread_new.get_images_count }} {% trans 'images' %}.
-        {% endif %}
-        <span class="tags">
-            {% for tag in post.thread_new.get_tags %}
-                <a class="tag" href="{% url 'tag' tag.name %}">
-                    #{{ tag.name }}</a>{% if not forloop.last %},{% endif %}
-            {% endfor %}
-        </span>
     </div>
-{% endif %}
-</div>
+    {% endwith %}
 {% endspaceless %}

boards/templates/boards/posting_general.html

@@ -7,9 +7,9 b''
 
 {% block head %}
     {% if tag %}
-        <title>Neboard - {{ tag.name }}</title>
+        <title>{{ tag.name }} - {{ site_name }}</title>
     {% else %}
-        <title>Neboard</title>
+        <title>{{ site_name }}</title>
     {% endif %}
 
     {% if current_page.has_previous %}
@@ -66,23 +66,25 b''
         {% endif %}
 
         {% for thread in threads %}
-            {% cache 600 thread_short thread.thread.id thread.thread.last_edit_time moderator LANGUAGE_CODE %}
+            {% cache 600 thread_short thread.id thread.last_edit_time moderator LANGUAGE_CODE %}
             <div class="thread">
-                {% post_view_truncated thread.op True moderator %}
-            {% if thread.last_replies.exists %}
-                {% if thread.skipped_replies %}
+                {% post_view_truncated thread.get_opening_post True moderator %}
+            {% if not thread.archived %}
+            {% if thread.get_last_replies.exists %}
+                {% if thread.get_skipped_replies_count %}
                     <div class="skipped_replies">
-                        <a href="{% url 'thread' thread.op.id %}">
-                        {% blocktrans with count=thread.skipped_replies %}Skipped {{ count }} replies. Open thread to see all replies.{% endblocktrans %}
+                        <a href="{% url 'thread' thread.get_opening_post.id %}">
+                            {% blocktrans with count=thread.get_skipped_replies_count %}Skipped {{ count }} replies. Open thread to see all replies.{% endblocktrans %}
                         </a>
                     </div>
                 {% endif %}
                 <div class="last-replies">
-                    {% for post in thread.last_replies %}
+                    {% for post in thread.get_last_replies %}
                         {% post_view_truncated post moderator=moderator%}
                     {% endfor %}
                 </div>
             {% endif %}
+            {% endif %}
         </div>
         {% endcache %}
         {% endfor %}
@@ -126,7 +128,7 b''
 {% block metapanel %}
 
     <span class="metapanel">
-        <b><a href="{% url "authors" %}">Neboard</a> 1.6 Amon</b>
+        <b><a href="{% url "authors" %}">{{ site_name }}</a> {{ version }}</b>
         {% trans "Pages:" %}[
         {% for page in paginator.page_range %}
             <a

boards/templates/boards/settings.html

@@ -4,7 +4,7 b''
 {% load humanize %}
 
 {% block head %}
-    <title>Neboard settings</title>
+    <title>{% trans 'Settings' %} - {{ site_name }}</title>
 {% endblock %}
 
 {% block content %}

boards/templates/boards/thread.html

@@ -6,7 +6,8 b''
 {% load board %}
 
 {% block head %}
-    <title>{{ thread.get_opening_post.get_title|striptags|truncatewords:10 }} - Neboard</title>
+    <title>{{ thread.get_opening_post.get_title|striptags|truncatewords:10 }}
+        - {{ site_name }}</title>
 {% endblock %}
 
 {% block content %}

boards/templates/boards/thread_gallery.html

@@ -6,7 +6,8 b''
 {% load board %}
 
 {% block head %}
-    <title>{{ thread.get_opening_post.get_title|striptags|truncatewords:10 }} - Neboard</title>
+    <title>{{ thread.get_opening_post.get_title|striptags|truncatewords:10 }}
+        - {{ site_name }}</title>
 {% endblock %}
 
 {% block content %}

boards/templatetags/board.py

@@ -25,11 +25,11 b' def post_url(*args, **kwargs):'
     post = get_object_or_404(Post, id=post_id)
 
     if not post.is_opening():
-        link = reverse(thread, kwargs={
+        link = reverse('thread', kwargs={
             'post_id': post.thread_new.get_opening_post().id}) + '#' + str(
             post_id)
     else:
-        link = reverse(thread, kwargs={'post_id': post_id})
+        link = reverse('thread', kwargs={'post_id': post_id})
 
     return link
 

boards/urls.py

@@ -1,7 +1,7 b''
 from django.conf.urls import patterns, url, include
 from boards import views
 from boards.rss import AllThreadsFeed, TagThreadsFeed, ThreadPostsFeed
-from boards.views import api
+from boards.views import api, tag_threads, all_threads, archived_threads
 
 js_info_dict = {
     'packages': ('boards',),
@@ -10,20 +10,24 b' js_info_dict = {'
 urlpatterns = patterns('',
 
     # /boards/
-    url(r'^$', views.index, name='index'),
+    url(r'^$', all_threads.AllThreadsView.as_view(), name='index'),
     # /boards/page/
-    url(r'^page/(?P<page>\w+)/$', views.index, name='index'),
+    url(r'^page/(?P<page>\w+)/$', all_threads.AllThreadsView.as_view(),
+        name='index'),
 
-    url(r'^archive/$', views.archive, name='archive'),
-    url(r'^archive/page/(?P<page>\w+)/$', views.archive, name='archive'),
+    url(r'^archive/$', archived_threads.ArchiveView.as_view(), name='archive'),
+    url(r'^archive/page/(?P<page>\w+)/$',
+        archived_threads.ArchiveView.as_view(), name='archive'),
 
     # login page
     url(r'^login/$', views.login, name='login'),
 
     # /boards/tag/tag_name/
-    url(r'^tag/(?P<tag_name>\w+)/$', views.tag, name='tag'),
+    url(r'^tag/(?P<tag_name>\w+)/$', tag_threads.TagView.as_view(),
+        name='tag'),
     # /boards/tag/tag_id/page/
-    url(r'^tag/(?P<tag_name>\w+)/page/(?P<page>\w+)/$', views.tag, name='tag'),
+    url(r'^tag/(?P<tag_name>\w+)/page/(?P<page>\w+)/$',
+        tag_threads.TagView.as_view(), name='tag'),
 
     # /boards/tag/tag_name/unsubscribe/
     url(r'^tag/(?P<tag_name>\w+)/subscribe/$', views.tag_subscribe,
@@ -33,8 +37,10 b" urlpatterns = patterns('',"
         name='tag_unsubscribe'),
 
     # /boards/thread/
-    url(r'^thread/(?P<post_id>\w+)/$', views.thread, name='thread'),
-    url(r'^thread/(?P<post_id>\w+)/(?P<mode>\w+)/$', views.thread, name='thread_mode'),
+    url(r'^thread/(?P<post_id>\w+)/$', views.thread.ThreadView.as_view(),
+        name='thread'),
+    url(r'^thread/(?P<post_id>\w+)/(?P<mode>\w+)/$', views.thread.ThreadView
+        .as_view(), name='thread_mode'),
     url(r'^settings/$', views.settings, name='settings'),
     url(r'^tags/$', views.all_tags, name='tags'),
     url(r'^captcha/', include('captcha.urls')),
@@ -43,7 +49,7 b" urlpatterns = patterns('',"
     url(r'^delete/(?P<post_id>\w+)/$', views.delete, name='delete'),
     url(r'^ban/(?P<post_id>\w+)/$', views.ban, name='ban'),
 
-    url(r'^banned/$', views.you_are_banned, name='banned'),
+    url(r'^banned/$', views.banned.BannedView.as_view, name='banned'),
     url(r'^staticpage/(?P<name>\w+)/$', views.static_page, name='staticpage'),
 
     # RSS feeds
@@ -62,9 +68,9 b" urlpatterns = patterns('',"
         api.api_get_threaddiff, name="get_thread_diff"),
     url(r'^api/threads/(?P<count>\w+)/$', api.api_get_threads,
             name='get_threads'),
-    url(r'api/tags/$', api.api_get_tags, name='get_tags'),
-    url(r'api/thread/(?P<opening_post_id>\w+)/$', api.api_get_thread_posts,
+    url(r'^api/tags/$', api.api_get_tags, name='get_tags'),
+    url(r'^api/thread/(?P<opening_post_id>\w+)/$', api.api_get_thread_posts,
             name='get_thread'),
-    url(r'api/add_post/(?P<opening_post_id>\w+)/$', api.api_add_post, name='add_post'),
+    url(r'^api/add_post/(?P<opening_post_id>\w+)/$', api.api_add_post, name='add_post'),
 
 )

boards/utils.py

@@ -1,6 +1,7 b''
 """
 This module contains helper functions and helper classes.
 """
+from django.utils import timezone
 
 from neboard import settings
 import time
@@ -70,4 +71,10 b' def get_client_ip(request):'
         ip = x_forwarded_for.split(',')[-1].strip()
     else:
         ip = request.META.get('REMOTE_ADDR')
-    return ip
  No newline at end of file
+    return ip
+
+
+def datetime_to_epoch(datetime):
+    return int(time.mktime(timezone.localtime(
+        datetime,timezone.get_current_timezone()).timetuple())
+               * 1000000 + datetime.microsecond)
  No newline at end of file

boards/views/__init__.py

@@ -2,19 +2,15 b' from datetime import datetime, timedelta'
 
 from django.db.models import Count
 
-
-OLD_USER_AGE_DAYS = 90
-
 __author__ = 'neko259'
 
 import hashlib
 import string
-import time
 import re
 
 from django.core import serializers
 from django.core.urlresolvers import reverse
-from django.http import HttpResponseRedirect, Http404
+from django.http import HttpResponseRedirect
 from django.http.response import HttpResponse
 from django.template import RequestContext
 from django.shortcuts import render, redirect, get_object_or_404
@@ -22,242 +18,25 b' from django.utils import timezone'
 from django.db import transaction
 from django.views.decorators.cache import cache_page
 from django.views.i18n import javascript_catalog
-from django.core.paginator import Paginator
 
-from boards import forms
 import boards
 from boards import utils
-from boards.forms import ThreadForm, PostForm, SettingsForm, PlainErrorList, \
-    ThreadCaptchaForm, PostCaptchaForm, LoginForm, ModeratorSettingsForm
-from boards.models import Post, Tag, Ban, User, Thread
+from boards.forms import SettingsForm, PlainErrorList, \
+    LoginForm, ModeratorSettingsForm
+from boards.models import Post, Tag, Ban, User
 from boards.models.post import SETTING_MODERATE, REGEX_REPLY
 from boards.models.user import RANK_USER
 from boards import authors
-from boards.utils import get_client_ip
 import neboard
 
+import all_threads
+
 
 BAN_REASON_SPAM = 'Autoban: spam bot'
-MODE_GALLERY = 'gallery'
-MODE_NORMAL = 'normal'
 
 DEFAULT_PAGE = 1
 
 
-def index(request, page=DEFAULT_PAGE):
-    context = _init_default_context(request)
-
-    if utils.need_include_captcha(request):
-        threadFormClass = ThreadCaptchaForm
-        kwargs = {'request': request}
-    else:
-        threadFormClass = ThreadForm
-        kwargs = {}
-
-    if request.method == 'POST':
-        form = threadFormClass(request.POST, request.FILES,
-                               error_class=PlainErrorList, **kwargs)
-        form.session = request.session
-
-        if form.is_valid():
-            return _new_post(request, form)
-        if form.need_to_ban:
-            # Ban user because he is suspected to be a bot
-            _ban_current_user(request)
-    else:
-        form = threadFormClass(error_class=PlainErrorList, **kwargs)
-
-    threads = []
-    for thread_to_show in Post.objects.get_threads(page=int(page)):
-        threads.append(_get_template_thread(thread_to_show))
-
-    # TODO Make this generic for tag and threads list pages
-    context['threads'] = None if len(threads) == 0 else threads
-    context['form'] = form
-
-    paginator = Paginator(Thread.objects.filter(archived=False),
-            neboard.settings.THREADS_PER_PAGE)
-    _get_page_context(paginator, context, page)
-
-    return render(request, 'boards/posting_general.html',
-                  context)
-
-
-def archive(request, page=DEFAULT_PAGE):
-    """
-    Get archived posts
-    """
-
-    context = _init_default_context(request)
-
-    threads = []
-    for thread_to_show in Post.objects.get_threads(page=int(page),
-                                                   archived=True):
-        threads.append(_get_template_thread(thread_to_show))
-
-    context['threads'] = threads
-
-    paginator = Paginator(Thread.objects.filter(archived=True),
-            neboard.settings.THREADS_PER_PAGE)
-    _get_page_context(paginator, context, page)
-
-    return render(request, 'boards/archive.html', context)
-
-
[e-mail]
-def _new_post(request, form, opening_post=None, html_response=True):
-    """Add a new post (in thread or as a reply)."""
-
-    ip = get_client_ip(request)
-    is_banned = Ban.objects.filter(ip=ip).exists()
-
-    if is_banned:
-        if html_response:
-            return redirect(you_are_banned)
-        else:
-            return
-
-    data = form.cleaned_data
-
-    title = data['title']
-    text = data['text']
-
-    text = _remove_invalid_links(text)
-
-    if 'image' in data.keys():
-        image = data['image']
-    else:
-        image = None
-
-    tags = []
-
-    if not opening_post:
-        tag_strings = data['tags']
-
-        if tag_strings:
-            tag_strings = tag_strings.split(' ')
-            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)
-        post_thread = None
-    else:
-        post_thread = opening_post.thread_new
-
-    post = Post.objects.create_post(title=title, text=text, ip=ip,
-                                    thread=post_thread, image=image,
-                                    tags=tags, user=_get_user(request))
-
-    thread_to_show = (opening_post.id if opening_post else post.id)
-
-    if html_response:
-        if opening_post:
-            return redirect(reverse(thread, kwargs={'post_id': thread_to_show}) +
-                            '#' + str(post.id))
-        else:
-            return redirect(thread, post_id=thread_to_show)
-
-
-def tag(request, tag_name, page=DEFAULT_PAGE):
-    """
-    Get all tag threads. Threads are split in pages, so some page is
-    requested.
-    """
-
-    tag = get_object_or_404(Tag, name=tag_name)
-    threads = []
-    for thread_to_show in Post.objects.get_threads(page=int(page), tag=tag):
-        threads.append(_get_template_thread(thread_to_show))
-
-    if request.method == 'POST':
-        form = ThreadForm(request.POST, request.FILES,
-                          error_class=PlainErrorList)
-        form.session = request.session
-
-        if form.is_valid():
-            return _new_post(request, form)
-        if form.need_to_ban:
-            # Ban user because he is suspected to be a bot
-            _ban_current_user(request)
-    else:
-        form = forms.ThreadForm(initial={'tags': tag_name},
-                                error_class=PlainErrorList)
-
-    context = _init_default_context(request)
-    context['threads'] = None if len(threads) == 0 else threads
-    context['tag'] = tag
-
-    paginator = Paginator(Post.objects.get_threads(tag=tag),
-            neboard.settings.THREADS_PER_PAGE)
-    _get_page_context(paginator, context, page)
-
-    context['form'] = form
-
-    return render(request, 'boards/posting_general.html',
-                  context)
-
-
-def thread(request, post_id, mode=MODE_NORMAL):
-    """Get all thread posts"""
-
-    if utils.need_include_captcha(request):
-        postFormClass = PostCaptchaForm
-        kwargs = {'request': request}
-    else:
-        postFormClass = PostForm
-        kwargs = {}
-
-    opening_post = get_object_or_404(Post, id=post_id)
-
-    # If this is not OP, don't show it as it is
-    if not opening_post.is_opening():
-        raise Http404
-
-    if request.method == 'POST' and not opening_post.thread_new.archived:
-        form = postFormClass(request.POST, request.FILES,
-                             error_class=PlainErrorList, **kwargs)
-        form.session = request.session
-
-        if form.is_valid():
-            return _new_post(request, form, opening_post)
-        if form.need_to_ban:
-            # Ban user because he is suspected to be a bot
-            _ban_current_user(request)
-    else:
-        form = postFormClass(error_class=PlainErrorList, **kwargs)
-
-    thread_to_show = opening_post.thread_new
-
-    context = _init_default_context(request)
-
-    posts = thread_to_show.get_replies()
-    context['form'] = form
-    context["last_update"] = _datetime_to_epoch(thread_to_show.last_edit_time)
-    context["thread"] = thread_to_show
-
-    if MODE_NORMAL == mode:
-        context['bumpable'] = thread_to_show.can_bump()
-        if context['bumpable']:
-            context['posts_left'] = neboard.settings.MAX_POSTS_PER_THREAD - posts \
-                .count()
-            context['bumplimit_progress'] = str(
-                float(context['posts_left']) /
-                neboard.settings.MAX_POSTS_PER_THREAD * 100)
-
-        context['posts'] = posts
-
-        document = 'boards/thread.html'
-    elif MODE_GALLERY == mode:
-        context['posts'] = posts.filter(image_width__gt=0)
-
-        document = 'boards/thread_gallery.html'
-    else:
-        raise Http404
-
-    return render(request, document, context)
-
-
 def login(request):
     """Log in with user id"""
 
@@ -271,7 +50,7 b' def login(request):'
         if form.is_valid():
             user = User.objects.get(user_id=form.cleaned_data['user_id'])
             request.session['user_id'] = user.id
-            return redirect(index)
+            return redirect('index')
 
     else:
         form = LoginForm()
@@ -337,9 +116,9 b' def jump_to_post(request, post_id):'
     post = get_object_or_404(Post, id=post_id)
 
     if not post.thread:
-        return redirect(thread, post_id=post.id)
+        return redirect('thread', post_id=post.id)
     else:
-        return redirect(reverse(thread, kwargs={'post_id': post.thread.id})
+        return redirect(reverse('thread', kwargs={'post_id': post.thread.id})
                         + '#' + str(post.id))
 
 
@@ -366,7 +145,7 b' def delete(request, post_id):'
     if not post.thread:
         return _redirect_to_next(request)
     else:
-        return redirect(thread, post_id=post.thread.id)
+        return redirect('thread', post_id=post.thread.id)
 
 
 @transaction.atomic
@@ -386,16 +165,6 b' def ban(request, post_id):'
     return _redirect_to_next(request)
 
 
-def you_are_banned(request):
-    """Show the page that notifies that user is banned"""
-
-    context = _init_default_context(request)
-
-    ban = get_object_or_404(Ban, ip=utils.get_client_ip(request))
-    context['ban_reason'] = ban.reason
-    return render(request, 'boards/staticpages/banned.html', context)
-
-
 def page_404(request):
     """Show page 404 (not found error)"""
 
@@ -457,6 +226,8 b" def cached_js_catalog(request, domain='d"
     return javascript_catalog(request, domain, packages)
 
 
+# TODO This method is deprecated and should be removed after switching to
+# class-based view
 def _get_theme(request, user=None):
     """Get user's CSS theme"""
 
@@ -469,6 +240,8 b' def _get_theme(request, user=None):'
     return theme
 
 
+# TODO This method is deprecated and should be removed after switching to
+# class-based view
 def _init_default_context(request):
     """Create context with default values that are used in most views"""
 
@@ -493,6 +266,8 b' def _init_default_context(request):'
     return context
 
 
+# TODO This method is deprecated and should be removed after switching to
+# class-based view
 def _get_user(request):
     """
     Get current user from the session. If the user does not exist, create
@@ -515,7 +290,8 b' def _get_user(request):'
         user = User.objects.create(user_id=new_id, rank=RANK_USER,
                                    registration_time=time_now)
 
-        _delete_old_users()
+        # TODO This is just a test. This method should be removed
+        # _delete_old_users()
 
         session['user_id'] = user.id
     else:
@@ -535,7 +311,7 b' def _redirect_to_next(request):'
         next_page = request.GET['next']
         return HttpResponseRedirect(next_page)
     else:
-        return redirect(index)
+        return redirect('index')
 
 
 @transaction.atomic
@@ -565,12 +341,6 b' def _remove_invalid_links(text):'
     return text
 
 
-def _datetime_to_epoch(datetime):
-    return int(time.mktime(timezone.localtime(
-        datetime,timezone.get_current_timezone()).timetuple())
-               * 1000000 + datetime.microsecond)
-
-
 def _get_template_thread(thread_to_show):
     """Get template values for thread"""
 
@@ -584,26 +354,3 b' def _get_template_thread(thread_to_show)'
         'last_replies': last_replies,
         'skipped_replies': skipped_replies_count,
         }
-
-
-def _delete_old_users():
-    """
-    Delete users with no favorite tags and posted messages. These can be spam
-    bots or just old user accounts
-    """
-
-    old_registration_date = datetime.now().date() - timedelta(OLD_USER_AGE_DAYS)
-
-    for user in User.objects.annotate(tags_count=Count('fav_tags')).filter(
-            tags_count=0).filter(registration_time__lt=old_registration_date):
-        if not Post.objects.filter(user=user).exists():
-            user.delete()
-
-
-def _get_page_context(paginator, context, page):
-    """
-    Get pagination context variables
-    """
-
-    context['paginator'] = paginator
-    context['current_page'] = paginator.page(int(page))

boards/views/api.py

@@ -7,8 +7,8 b' from django.template import RequestConte'
 from django.utils import timezone
 from boards.forms import PostForm, PlainErrorList
 from boards.models import Post, Thread, Tag
-from boards.views import _datetime_to_epoch, _new_post, \
-    _ban_current_user
+from boards.utils import datetime_to_epoch
+from boards.views.thread import ThreadView
 
 __author__ = 'neko259'
 
@@ -53,7 +53,7 b' def api_get_threaddiff(request, thread_i'
         json_data['added'].append(_get_post_data(post.id, diff_type, request))
     for post in updated_posts:
         json_data['updated'].append(_get_post_data(post.id, diff_type, request))
-    json_data['last_update'] = _datetime_to_epoch(thread.last_edit_time)
+    json_data['last_update'] = datetime_to_epoch(thread.last_edit_time)
 
     return HttpResponse(content=json.dumps(json_data))
 
@@ -78,7 +78,8 b' def api_add_post(request, opening_post_i'
         #    _ban_current_user(request)
         #    status = STATUS_ERROR
         if form.is_valid():
-            _new_post(request, form, opening_post, html_response=False)
+            ThreadView().new_post(request, form, opening_post,
+                                  html_response=False)
         else:
             status = STATUS_ERROR
             errors = form.as_json_errors()
@@ -178,7 +179,7 b' def api_get_thread_posts(request, openin'
 
     for post in posts:
         json_post_list.append(_get_post_data(post.id))
-    json_data['last_update'] = _datetime_to_epoch(thread.last_edit_time)
+    json_data['last_update'] = datetime_to_epoch(thread.last_edit_time)
     json_data['posts'] = json_post_list
 
     return HttpResponse(content=json.dumps(json_data))
@@ -200,6 +201,6 b' def _get_post_data(post_id, format_type='
             post_json['image'] = post.image.url
             post_json['image_preview'] = post.image.url_200x150
         if include_last_update:
-            post_json['bump_time'] = _datetime_to_epoch(
+            post_json['bump_time'] = datetime_to_epoch(
                     post.thread_new.bump_time)
         return post_json

neboard/settings.py

@@ -223,6 +223,8 b' POSTING_DELAY = 20 # seconds'
 
 COMPRESS_HTML = True
 
+VERSION = '1.7 Anubis'
+
 # Debug mode middlewares
 if DEBUG:
     MIDDLEWARE_CLASSES += (