Merged in 1.7 branch

boards/templates/boards/post_admin.html

@@ -0,0 +1,38 b''
+{% extends "boards/base.html" %}
+
+{% load i18n %}
+{% load cache %}
+{% load static from staticfiles %}
+{% load board %}
+
+{% block head %}
+<title>#{{ post.id }} - {{ site_name }}</title>
+{% endblock %}
+
+{% block content %}
+    {% spaceless %}
+
+        {% post_view post moderator=moderator %}
+
+        {% if post.is_opening %}
+            <div class="post">
+                {% trans 'Tags:' %}
+                {% for tag in post.thread_new.get_tags %}
+                <a class="tag" href={% url 'tag' tag.name %}>#{{ tag.name }}</a>
+                <a href="?method=delete_tag&tag={{ tag.name }}">[X]</a>
+                    {% if not forloop.last %},{% endif %}
+                {% endfor %}
+                <div class="post-form-w">
+                <form id="form" enctype="multipart/form-data"
+                    method="post">{% csrf_token %}
+                    {{ tag_form.as_div }}
+                    <div class="form-submit">
+                        <input type="submit" value="{% trans "Add tag" %}"/>
+                    </div>
+                </form>
+                </div>
+            </div>
+        {% endif %}
+
+    {% endspaceless %}
+{% endblock %}

boards/views/all_tags.py

@@ -0,0 +1,12 b''
+from django.shortcuts import render
+
+from boards.views.base import BaseBoardView
+from boards.models.tag import Tag
+
+class AllTagsView(BaseBoardView):
+
+    def get(self, request):
+        context = self.get_context_data(request=request)
+        context['all_tags'] = Tag.objects.get_not_empty_tags()
+
+        return render(request, 'boards/tags.html', context)

boards/views/all_threads.py

@@ -0,0 +1,125 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, form=None):
+        context = self.get_context_data(request=request)
+
+        if not form:
+            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)
+
+        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))
+
+    # 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).order_by('-bump_time')

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).order_by('-bump_time')

boards/views/authors.py

@@ -0,0 +1,13 b''
+from django.shortcuts import render
+
+from boards.authors import authors
+from boards.views.base import BaseBoardView
+
+
+class AuthorsView(BaseBoardView):
+
+    def get(self, request):
+        context = self.get_context_data(request=request)
+        context['authors'] = authors
+
+        return render(request, 'boards/authors.html', context)

boards/views/ban.py

@@ -0,0 +1,23 b''
+from django.db import transaction
+from django.shortcuts import get_object_or_404
+
+from boards.views.base import BaseBoardView
+from boards.models import Post, Ban
+from boards.views.mixins import RedirectNextMixin
+
+
+class BanUserView(BaseBoardView, RedirectNextMixin):
+
+    @transaction.atomic
+    def get(self, request, post_id):
+        user = self._get_user(request)
+        post = get_object_or_404(Post, id=post_id)
+
+        if user.is_moderator():
+            # TODO Show confirmation page before ban
+            ban, created = Ban.objects.get_or_create(ip=post.poster_ip)
+            if created:
+                ban.reason = 'Banned for post ' + str(post_id)
+                ban.save()
+
+        return self.redirect_to_next(request)

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=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/delete_post.py

@@ -0,0 +1,26 b''
+from django.shortcuts import redirect, get_object_or_404
+from django.db import transaction
+
+from boards.views.base import BaseBoardView
+from boards.views.mixins import RedirectNextMixin
+from boards.models import Post
+
+
+class DeletePostView(BaseBoardView, RedirectNextMixin):
+
+    @transaction.atomic
+    def get(self, request, post_id):
+        user = self._get_user(request)
+        post = get_object_or_404(Post, id=post_id)
+
+        opening_post = post.is_opening()
+
+        if user.is_moderator():
+            # TODO Show confirmation page before deletion
+            Post.objects.delete_post(post)
+
+        if not opening_post:
+            thread = post.thread_new
+            return redirect('thread', post_id=thread.get_opening_post().id)
+        else:
+            return self.redirect_to_next(request)

boards/views/login.py

@@ -0,0 +1,30 b''
+from django.shortcuts import render, redirect
+from boards.forms import LoginForm, PlainErrorList
+from boards.models import User
+from boards.views.base import BaseBoardView, PARAMETER_FORM
+
+__author__ = 'neko259'
+
+
+class LoginView(BaseBoardView):
+
+    def get(self, request, form=None):
+        context = self.get_context_data(request=request)
+
+        if not form:
+            form = LoginForm()
+        context[PARAMETER_FORM] = form
+
+        return render(request, 'boards/login.html', context)
+
+    def post(self, request):
+        form = LoginForm(request.POST, request.FILES,
+                         error_class=PlainErrorList)
+        form.session = request.session
+
+        if form.is_valid():
+            user = User.objects.get(user_id=form.cleaned_data['user_id'])
+            request.session['user_id'] = user.id
+            return redirect('index')
+        else:
+            return self.get(request, form)

boards/views/mixins.py

@@ -0,0 +1,39 b''
+PARAMETER_METHOD = 'method'
+
+from django.shortcuts import redirect
+from django.http import HttpResponseRedirect
+
+
+class RedirectNextMixin:
+
+    def redirect_to_next(self, request):
+        """
+        If a 'next' parameter was specified, redirect to the next page. This
+        is used when the user is required to return to some page after the
+        current view has finished its work.
+        """
+
+        if 'next' in request.GET:
+            next_page = request.GET['next']
+            return HttpResponseRedirect(next_page)
+        else:
+            return redirect('index')
+
+
+class DispatcherMixin:
+    """
+    This class contains a dispather method that can run a method specified by
+    'method' request parameter.
+    """
+
+    def dispatch_method(self, *args, **kwargs):
+        request = args[0]
+
+        method_name = None
+        if PARAMETER_METHOD in request.GET:
+            method_name = request.GET[PARAMETER_METHOD]
+        elif PARAMETER_METHOD in request.POST:
+            method_name = request.POST[PARAMETER_METHOD]
+
+        if method_name:
+            return getattr(self, method_name)(*args, **kwargs)

boards/views/not_found.py

@@ -0,0 +1,13 b''
+from django.shortcuts import render
+
+from boards.views.base import BaseBoardView
+
+
+class NotFoundView(BaseBoardView):
+    """
+    Page 404 (not found)
+    """
+
+    def get(self, request):
+        context = self.get_context_data(request=request)
+        return render(request, 'boards/404.html', context)

boards/views/post_admin.py

@@ -0,0 +1,57 b''
+from django.shortcuts import render, get_object_or_404, redirect
+
+from boards.views.base import BaseBoardView
+from boards.views.mixins import DispatcherMixin
+from boards.models.post import Post
+from boards.models.tag import Tag
+from boards.forms import AddTagForm, PlainErrorList
+
+class PostAdminView(BaseBoardView, DispatcherMixin):
+
+    def get(self, request, post_id, form=None):
+        user = self._get_user(request)
+        if not user.is_moderator:
+            redirect('index')
+
+        post = get_object_or_404(Post, id=post_id)
+
+        if not form:
+            dispatch_result = self.dispatch_method(request, post)
+            if dispatch_result:
+                return dispatch_result
+            form = AddTagForm()
+
+        context = self.get_context_data(request=request)
+
+        context['post'] = post
+
+        context['tag_form'] = form
+
+        return render(request, 'boards/post_admin.html', context)
+
+    def post(self, request, post_id):
+        user = self._get_user(request)
+        if not user.is_moderator:
+            redirect('index')
+
+        post = get_object_or_404(Post, id=post_id)
+        return self.dispatch_method(request, post)
+
+    def delete_tag(self, request, post):
+        tag_name = request.GET['tag']
+        tag = get_object_or_404(Tag, name=tag_name)
+
+        post.remove_tag(tag)
+
+        return redirect('post_admin', post.id)
+
+    def add_tag(self, request, post):
+        form = AddTagForm(request.POST, error_class=PlainErrorList)
+        if form.is_valid():
+            tag_name = form.cleaned_data['tag']
+            tag, created = Tag.objects.get_or_create(name=tag_name)
+
+            post.add_tag(tag)
+            return redirect('post_admin', post.id)
+        else:
+            return self.get(request, post.id, form)

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/settings.py

@@ -0,0 +1,52 b''
+from django.db import transaction
+from django.shortcuts import render, redirect
+
+from boards.views.base import BaseBoardView, PARAMETER_FORM
+from boards.forms import SettingsForm, ModeratorSettingsForm, PlainErrorList
+from boards.models.post import SETTING_MODERATE
+
+
+class SettingsView(BaseBoardView):
+
+    def get(self, request):
+        context = self.get_context_data(request=request)
+        user = context['user']
+        is_moderator = user.is_moderator()
+
+        selected_theme = context['theme']
+
+        if is_moderator:
+            form = ModeratorSettingsForm(initial={
+                'theme': selected_theme,
+                'moderate': context['moderator']
+            }, error_class=PlainErrorList)
+        else:
+            form = SettingsForm(initial={'theme': selected_theme},
+                                error_class=PlainErrorList)
+
+        context[PARAMETER_FORM] = form
+
+        return render(request, 'boards/settings.html', context)
+
+    def post(self, request):
+        context = self.get_context_data(request=request)
+        user = context['user']
+        is_moderator = user.is_moderator()
+
+        with transaction.atomic():
+            if is_moderator:
+                form = ModeratorSettingsForm(request.POST,
+                                             error_class=PlainErrorList)
+            else:
+                form = SettingsForm(request.POST, error_class=PlainErrorList)
+
+            if form.is_valid():
+                selected_theme = form.cleaned_data['theme']
+
+                user.save_setting('theme', selected_theme)
+
+                if is_moderator:
+                    moderate = form.cleaned_data['moderate']
+                    user.save_setting(SETTING_MODERATE, moderate)
+
+            return redirect('settings')

boards/views/static.py

@@ -0,0 +1,13 b''
+from django.shortcuts import render
+
+from boards.views.base import BaseBoardView
+
+class StaticPageView(BaseBoardView):
+
+    def get(request, name):
+        """
+        Show a static page that needs only tags list and a CSS
+        """
+
+        context = self.get_context_data(request=request)
+        return render(request, 'boards/staticpages/' + name + '.html', context)

boards/views/tag_threads.py

@@ -0,0 +1,51 b''
+from django.shortcuts import get_object_or_404
+from boards.models import Tag, Post
+from boards.views.all_threads import AllThreadsView, DEFAULT_PAGE
+from boards.views.mixins import DispatcherMixin, RedirectNextMixin
+
+__author__ = 'neko259'
+
+
+class TagView(AllThreadsView, DispatcherMixin, RedirectNextMixin):
+
+    tag_name = None
+
+    def get_threads(self):
+        tag = get_object_or_404(Tag, name=self.tag_name)
+
+        return tag.threads.filter(archived=False).order_by('-bump_time')
+
+    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
+
+        dispatch_result = self.dispatch_method(request)
+        if dispatch_result:
+            return dispatch_result
+        else:
+            return super(TagView, self).get(request, page)
+
+    def subscribe(self, request):
+        user = self._get_user(request)
+        tag = get_object_or_404(Tag, name=self.tag_name)
+
+        if not tag in user.fav_tags.all():
+            user.add_tag(tag)
+
+        return self.redirect_to_next(request)
+
+    def unsubscribe(self, request):
+        user = self._get_user(request)
+        tag = get_object_or_404(Tag, name=self.tag_name)
+
+        if tag in user.fav_tags.all():
+            user.remove_tag(tag)
+
+        return self.redirect_to_next(request)

boards/views/thread.py

@@ -0,0 +1,121 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, form=None):
+        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 form:
+            form = PostForm(error_class=PlainErrorList)
+
+        thread_to_show = opening_post.thread_new
+
+        context = self.get_context_data(request=request)
+
+        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 \
+                        - thread_to_show.get_reply_count()
+                context['bumplimit_progress'] = str(
+                    float(context['posts_left']) /
+                    neboard.settings.MAX_POSTS_PER_THREAD * 100)
+
+            context['opening_post'] = thread_to_show.get_opening_post()
+
+            document = 'boards/thread.html'
+        elif MODE_GALLERY == mode:
+            posts = thread_to_show.get_replies()
+            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)
+
+            return self.get(request, post_id, mode, form)
+
+    @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))

requirements.txt

@@ -0,0 +1,8 b''
+pillow
+django>=1.6
+django_cleanup
+django-markupfield
+markdown
+python-markdown
+django-simple-captcha
+line-profiler

boards/forms.py

@@ -26,6 +26,11 b" ERROR_IMAGE_DUPLICATE = _('Such image wa"
 
 LABEL_TITLE = _('Title')
 LABEL_TEXT = _('Text')
+LABEL_TAG = _('Tag')
+
+TAG_MAX_LENGTH = 20
+
+REGEX_TAG = ur'^[\w\d]+$'
 
 
 class FormatPanel(forms.Textarea):
@@ -311,3 +316,24 b' class LoginForm(NeboardForm):'
         cleaned_data = super(LoginForm, self).clean()
 
         return cleaned_data
+
+
+class AddTagForm(NeboardForm):
+
+    tag = forms.CharField(max_length=TAG_MAX_LENGTH, label=LABEL_TAG)
+    method = forms.CharField(widget=forms.HiddenInput(), initial='add_tag')
+
+    def clean_tag(self):
+        tag = self.cleaned_data['tag']
+
+        regex_tag = re.compile(REGEX_TAG, re.UNICODE)
+        if not regex_tag.match(tag):
+            raise forms.ValidationError(_('Inappropriate characters in tags.'))
+
+        return tag
+
+    def clean(self):
+        cleaned_data = super(AddTagForm, self).clean()
+
+        return cleaned_data
+

boards/locale/ru/LC_MESSAGES/django.po

@@ -7,7 +7,7 b' msgid ""'
 msgstr ""
 "Project-Id-Version: PACKAGE VERSION\n"
 "Report-Msgid-Bugs-To: \n"
-"POT-Creation-Date: 2014-01-15 10:46+0200\n"
+"POT-Creation-Date: 2014-01-22 13:07+0200\n"
 "PO-Revision-Date: YEAR-MO-DA HO:MI+ZONE\n"
 "Last-Translator: FULL NAME <EMAIL@ADDRESS>\n"
 "Language-Team: LANGUAGE <[e-mail]>\n"
@@ -58,63 +58,67 b' msgstr "\xd0\x97\xd0\xb0\xd0\xb3\xd0\xbe\xd0\xbb\xd0\xbe\xd0\xb2\xd0\xbe\xd0\xba"'
 msgid "Text"
 msgstr "Текст"
 
-#: forms.py:89
+#: forms.py:29
+msgid "Tag"
+msgstr "Тег"
+
+#: forms.py:106
 msgid "Image"
 msgstr "Изображение"
 
-#: forms.py:92
+#: forms.py:109
 msgid "e-mail"
 msgstr ""
 
-#: forms.py:103
+#: forms.py:120
 #, python-format
 msgid "Title must have less than %s characters"
 msgstr "Заголовок должен иметь меньше %s символов"
 
-#: forms.py:112
+#: forms.py:129
 #, python-format
 msgid "Text must have less than %s characters"
 msgstr "Текст должен быть короче %s символов"
 
-#: forms.py:123
+#: forms.py:140
 #, python-format
 msgid "Image must be less than %s bytes"
 msgstr "Изображение должно быть менее %s байт"
 
-#: forms.py:158
+#: forms.py:175
 msgid "Either text or image must be entered."
 msgstr "Текст или картинка должны быть введены."
 
-#: forms.py:171
+#: forms.py:188
 #, python-format
 msgid "Wait %s seconds after last posting"
 msgstr "Подождите %s секунд после последнего постинга"
 
-#: forms.py:187 templates/boards/tags.html:6 templates/boards/rss/post.html:10
+#: forms.py:204 templates/boards/tags.html:6 templates/boards/rss/post.html:10
 msgid "Tags"
 msgstr "Теги"
 
-#: forms.py:195
+#: forms.py:212 forms.py:331
 msgid "Inappropriate characters in tags."
 msgstr "Недопустимые символы в тегах."
 
-#: forms.py:223 forms.py:244
+#: forms.py:240 forms.py:261
 msgid "Captcha validation failed"
 msgstr "Проверка капчи провалена"
 
-#: forms.py:250
+#: forms.py:267
 msgid "Theme"
 msgstr "Тема"
 
-#: forms.py:255
+#: forms.py:272
 msgid "Enable moderation panel"
 msgstr "Включить панель модерации"
 
-#: forms.py:270
+#: forms.py:287
 msgid "No such user found"
 msgstr "Данный пользователь не найден"
 
-#: forms.py:284
+#: forms.py:301
 #, python-format
 msgid "Wait %s minutes after last login"
 msgstr "Подождите %s минут после последнего входа"
@@ -127,69 +131,19 b' msgstr "\xd0\x9d\xd0\xb5 \xd0\xbd\xd0\xb0\xd0\xb9\xd0\xb4\xd0\xb5\xd0\xbd\xd0\xbe"'
 msgid "This page does not exist"
 msgstr "Этой страницы не существует"
 
-#: templates/boards/archive.html:9 templates/boards/base.html:51
-msgid "Archive"
-msgstr "Архив"
-
-#: templates/boards/archive.html:39 templates/boards/posting_general.html:64
-msgid "Previous page"
-msgstr "Предыдущая страница"
-
-#: templates/boards/archive.html:68
-msgid "Open"
-msgstr "Открыть"
-
-#: templates/boards/archive.html:74 templates/boards/post.html:37
-#: templates/boards/posting_general.html:103 templates/boards/thread.html:69
-msgid "Delete"
-msgstr "Удалить"
-
-#: templates/boards/archive.html:78 templates/boards/post.html:40
-#: templates/boards/posting_general.html:107 templates/boards/thread.html:72
-msgid "Ban IP"
-msgstr "Заблокировать IP"
-
-#: templates/boards/archive.html:87 templates/boards/post.html:53
-#: templates/boards/posting_general.html:116
-#: templates/boards/posting_general.html:180 templates/boards/thread.html:81
-msgid "Replies"
-msgstr "Ответы"
-
-#: templates/boards/archive.html:96 templates/boards/posting_general.html:125
-#: templates/boards/thread.html:138 templates/boards/thread_gallery.html:58
-msgid "images"
-msgstr "изображений"
-
-#: templates/boards/archive.html:97 templates/boards/thread.html:137
-#: templates/boards/thread_gallery.html:57
-msgid "replies"
-msgstr "ответов"
-
-#: templates/boards/archive.html:116 templates/boards/posting_general.html:203
-msgid "Next page"
-msgstr "Следующая страница"
-
-#: templates/boards/archive.html:121 templates/boards/posting_general.html:208
-msgid "No threads exist. Create the first one!"
-msgstr "Нет тем. Создайте первую!"
-
-#: templates/boards/archive.html:130 templates/boards/posting_general.html:235
-msgid "Pages:"
-msgstr "Страницы: "
-
 #: templates/boards/authors.html:6 templates/boards/authors.html.py:12
 msgid "Authors"
 msgstr "Авторы"
 
-#: templates/boards/authors.html:25
+#: templates/boards/authors.html:26
 msgid "Distributed under the"
 msgstr "Распространяется под"
 
-#: templates/boards/authors.html:27
+#: templates/boards/authors.html:28
 msgid "license"
 msgstr "лицензией"
 
-#: templates/boards/authors.html:29
+#: templates/boards/authors.html:30
 msgid "Repository"
 msgstr "Репозиторий"
 
@@ -205,7 +159,7 b' msgstr "\xd0\x92\xd1\x81\xd0\xb5 \xd1\x82\xd0\xb5\xd0\xbc\xd1\x8b"'
 msgid "Tag management"
 msgstr "Управление тегами"
 
-#: templates/boards/base.html:38
+#: templates/boards/base.html:38 templates/boards/settings.html:7
 msgid "Settings"
 msgstr "Настройки"
 
@@ -214,6 +168,10 b' msgstr "\xd0\x9d\xd0\xb0\xd1\x81\xd1\x82\xd1\x80\xd0\xbe\xd0\xb9\xd0\xba\xd0\xb8"'
 msgid "Login"
 msgstr "Вход"
 
+#: templates/boards/base.html:51
+msgid "Archive"
+msgstr "Архив"
+
 #: templates/boards/base.html:53
 #, python-format
 msgid "Speed: %(ppd)s posts per day"
@@ -231,32 +189,81 b' msgstr "ID \xd0\xbf\xd0\xbe\xd0\xbb\xd1\x8c\xd0\xb7\xd0\xbe\xd0\xb2\xd0\xb0\xd1\x82\xd0\xb5\xd0\xbb\xd1\x8f"'
 msgid "Insert your user id above"
 msgstr "Вставьте свой ID пользователя выше"
 
-#: templates/boards/posting_general.html:97
+#: templates/boards/post.html:47
+msgid "Open"
+msgstr "Открыть"
+
+#: templates/boards/post.html:49
 msgid "Reply"
 msgstr "Ответ"
 
-#: templates/boards/posting_general.html:142
+#: templates/boards/post.html:56
+msgid "Edit"
+msgstr "Изменить"
+
+#: templates/boards/post.html:58
+msgid "Delete"
+msgstr "Удалить"
+
+#: templates/boards/post.html:61
+msgid "Ban IP"
+msgstr "Заблокировать IP"
+
+#: templates/boards/post.html:74
+msgid "Replies"
+msgstr "Ответы"
+
+#: templates/boards/post.html:85 templates/boards/thread.html:74
+#: templates/boards/thread_gallery.html:59
+msgid "images"
+msgstr "изображений"
+
+#: templates/boards/post_admin.html:19
+msgid "Tags:"
+msgstr "Теги:"
+
+#: templates/boards/post_admin.html:30
+msgid "Add tag"
+msgstr "Добавить тег"
+
+#: templates/boards/posting_general.html:64
+msgid "Previous page"
+msgstr "Предыдущая страница"
+
+#: templates/boards/posting_general.html:77
 #, python-format
 msgid "Skipped %(count)s replies. Open thread to see all replies."
 msgstr "Пропущено %(count)s ответов. Откройте тред, чтобы увидеть все ответы."
 
-#: templates/boards/posting_general.html:214
+#: templates/boards/posting_general.html:100
+msgid "Next page"
+msgstr "Следующая страница"
+
+#: templates/boards/posting_general.html:105
+msgid "No threads exist. Create the first one!"
+msgstr "Нет тем. Создайте первую!"
+
+#: templates/boards/posting_general.html:111
 msgid "Create new thread"
 msgstr "Создать новую тему"
 
-#: templates/boards/posting_general.html:218 templates/boards/thread.html:115
+#: templates/boards/posting_general.html:115 templates/boards/thread.html:50
 msgid "Post"
 msgstr "Отправить"
 
-#: templates/boards/posting_general.html:222
+#: templates/boards/posting_general.html:119
 msgid "Tags must be delimited by spaces. Text or image is required."
 msgstr ""
 "Теги должны быть разделены пробелами. Текст или изображение обязательны."
 
-#: templates/boards/posting_general.html:225 templates/boards/thread.html:119
+#: templates/boards/posting_general.html:122 templates/boards/thread.html:54
 msgid "Text syntax"
 msgstr "Синтаксис текста"
 
+#: templates/boards/posting_general.html:132
+msgid "Pages:"
+msgstr "Страницы: "
+
 #: templates/boards/settings.html:14
 msgid "User:"
 msgstr "Пользователь:"
@@ -285,23 +292,27 b' msgstr "\xd0\xa1\xd0\xbe\xd1\x85\xd1\x80\xd0\xb0\xd0\xbd\xd0\xb8\xd1\x82\xd1\x8c"'
 msgid "No tags found."
 msgstr "Теги не найдены."
 
-#: templates/boards/thread.html:19 templates/boards/thread_gallery.html:20
+#: templates/boards/thread.html:20 templates/boards/thread_gallery.html:21
 msgid "Normal mode"
 msgstr "Нормальный режим"
 
-#: templates/boards/thread.html:20 templates/boards/thread_gallery.html:21
+#: templates/boards/thread.html:21 templates/boards/thread_gallery.html:22
 msgid "Gallery mode"
 msgstr "Режим галереи"
 
-#: templates/boards/thread.html:28
+#: templates/boards/thread.html:29
 msgid "posts to bumplimit"
 msgstr "сообщений до бамплимита"
 
-#: templates/boards/thread.html:109
+#: templates/boards/thread.html:44
 msgid "Reply to thread"
 msgstr "Ответить в тему"
 
-#: templates/boards/thread.html:139 templates/boards/thread_gallery.html:59
+#: templates/boards/thread.html:73 templates/boards/thread_gallery.html:58
+msgid "replies"
+msgstr "ответов"
+
+#: templates/boards/thread.html:75 templates/boards/thread_gallery.html:60
 msgid "Last update: "
 msgstr "Последнее обновление: "
 

boards/mdx_neboard.py

@@ -66,11 +66,11 b' class ReflinkPattern(Pattern):'
 
             post = posts[0]
             if not post.is_opening():
-                link = reverse(boards.views.thread, kwargs={
+                link = reverse('thread', kwargs={
                     'post_id': post.thread_new.get_opening_post().id})\
                        + '#' + post_id
             else:
-                link = reverse(boards.views.thread, kwargs={'post_id': post_id})
+                link = reverse('thread', kwargs={'post_id': post_id})
 
             ref_element.set('href', link)
             ref_element.text = m.group(2)

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

@@ -10,7 +10,7 b' import hashlib'
 from django.core.cache import cache
 from django.core.paginator import Paginator
 
-from django.db import models
+from django.db import models, transaction
 from django.http import Http404
 from django.utils import timezone
 from markupfield.fields import MarkupField
@@ -94,13 +94,11 b' class PostManager(models.Manager):'
         """
         Delete post and update or delete its thread
         """
-        
+
         thread = post.thread_new
 
-        if thread.get_opening_post() == self:
-            thread.replies.delete()
-
-            thread.delete()
+        if post.is_opening():
+            thread.delete_with_posts()
         else:
             thread.last_edit_time = timezone.now()
             thread.save()
@@ -115,7 +113,8 b' class PostManager(models.Manager):'
         posts = self.filter(poster_ip=ip)
         map(self.delete_post, posts)
 
-    # TODO Move this method to thread manager
+    # TODO This method may not be needed any more, because django's paginator
+    # is used
     def get_threads(self, tag=None, page=ALL_PAGES,
                     order_by='-bump_time', archived=False):
         if tag:
@@ -197,7 +196,7 b' class PostManager(models.Manager):'
 
         ppd = (sum(posts_per_day for posts_per_day in posts_per_days) /
                len(posts_per_days))
-        cache.set(CACHE_KEY_PPD, ppd)
+        cache.set(CACHE_KEY_PPD + str(today), ppd)
         return ppd
 
 
@@ -284,6 +283,30 b' class Post(models.Model):'
             self.image_hash = md5.hexdigest()
         super(Post, self).save(*args, **kwargs)
 
+    @transaction.atomic
+    def add_tag(self, tag):
+        edit_time = timezone.now()
+
+        thread = self.thread_new
+        thread.add_tag(tag)
+        self.last_edit_time = edit_time
+        self.save()
+
+        thread.last_edit_time = edit_time
+        thread.save()
+
+    @transaction.atomic
+    def remove_tag(self, tag):
+        edit_time = timezone.now()
+
+        thread = self.thread_new
+        thread.tags.remove(tag)
+        self.last_edit_time = edit_time
+        self.save()
+
+        thread.last_edit_time = edit_time
+        thread.save()
+
 
 class Thread(models.Model):
 
@@ -356,6 +379,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
@@ -379,7 +406,7 b' class Thread(models.Model):'
         return self.get_replies()[0]
 
     def __unicode__(self):
-        return str(self.get_replies()[0].id)
+        return str(self.id)
 
     def get_pub_time(self):
         """

boards/static/css/base.css

@@ -13,7 +13,6 b''
 
 .img-full {
     position: fixed;
-    z-index: 9999;
     background-color: #CCC;
     border: 1px solid #000;
     cursor: pointer;

boards/static/js/image.js

@@ -85,7 +85,10 b' function addImgPreview() {'
 
                     return false;
                 }
-            ).draggable()
+            ).draggable({
+                    addClasses: false,
+                    stack: '.img-full'
+                })
         }
         else {
             $('#'+thumb_id).remove();

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

@@ -4,85 +4,102 b''
 
 {% get_current_language as LANGUAGE_CODE %}
 
-{% cache 300 post post.id post.thread_new.last_edit_time truncated moderator LANGUAGE_CODE need_open_link %}
-{% 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 %}
+{% cache 600 post post.id thread.last_edit_time truncated moderator LANGUAGE_CODE need_open_link %}
+
+    {% with is_opening=post.is_opening %}
+    {% spaceless %}
+        {% 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 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>]
+        {% 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 %}
-        {% if post.is_opening and need_open_link %}
-            [<a class="link" href="
-                    {% url 'thread' post.id %}#form">{% trans "Reply" %}</a>]
-        {% endif %}
+        <div class="message">
+            <div class="post-info">
+                <span class="title">{{ post.title }}</span>
+                {% cache 600 post_id post.id %}
+                    <a class="post_id" href="{% post_url post.id %}">
+                        ({{ post.id }}) </a>
+                {% endcache %}
+                [<span class="pub_time">{{ post.pub_time }}</span>]
+                {% if thread.archived %}
+                    — [{{ thread.bump_time }}]
+                {% endif %}
+                {% if not truncated and not thread.archived %}
+                    [<a href="#" onclick="javascript:addQuickReply('{{ post.id }}')
+                        ; return false;">&gt;&gt;</a>]
+                {% endif %}
+                {% if 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 }}
+                {% if moderator %}
+                    <span class="moderator_info">
+                        [<a href="{% url 'post_admin' post_id=post.id %}"
+                            >{% trans 'Edit' %}</a>]
+                        [<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 %}
+            {% cache 600 post_replies post.id post.last_edit_time moderator LANGUAGE_CODE %}
+                {% 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 %}
+            {% endcache %}
+        </div>
+        {% if is_opening and thread.tags.exists %}
+            <div class="metadata">
+                {% if 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 %}
-    {% 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>
-{% 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>
-{% endspaceless %}
+        {% endwith %}
+    {% endspaceless %}
+    {% endwith %}
 {% endcache %}

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 %}
@@ -41,10 +41,10 b''
     <div class="tag_info">
         <h2>
             {% if tag in user.fav_tags.all %}
-                <a href="{% url 'tag_unsubscribe' tag.name %}?next={{ request.path }}"
+                <a href="{% url 'tag' tag.name %}?method=unsubscribe&next={{ request.path }}"
                    class="fav">★</a>
             {% else %}
-                <a href="{% url 'tag_subscribe' tag.name %}?next={{ request.path }}"
+                <a href="{% url 'tag' tag.name %}?method=subscribe&next={{ request.path }}"
                    class="not_fav">★</a>
             {% endif %}
             #{{ tag.name }}
@@ -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/tags.html

@@ -13,10 +13,10 b''
             {% for tag in all_tags %}
                 <div class="tag_item" style="font-size: {{ tag.get_font_value }}em">
                 {% if tag in user.fav_tags.all %}
-                    <a href="{% url 'tag_unsubscribe' tag.name %}?next={{ request.path }}"
+                    <a href="{% url 'tag' tag.name %}?method=unsubscribe&next={{ request.path }}"
                         class="fav">★</a>
                 {% else %}
-                    <a href="{% url 'tag_subscribe' tag.name %}?next={{ request.path }}"
+                    <a href="{% url 'tag' tag.name %}?method=subscribe&next={{ request.path }}"
                         class="not_fav">★</a>
                 {% endif %}
                 <a class="tag" href="{% url 'tag' tag.name %}">

boards/templates/boards/thread.html

@@ -6,38 +6,42 b''
 {% load board %}
 
 {% block head %}
-    <title>{{ thread.get_opening_post.get_title|striptags|truncatewords:10 }} - Neboard</title>
+    <title>{{ opening_post.get_title|striptags|truncatewords:10 }}
+        - {{ site_name }}</title>
 {% endblock %}
 
 {% block content %}
     {% spaceless %}
     {% get_current_language as LANGUAGE_CODE %}
 
-        <div class="image-mode-tab">
-            <a class="current_mode" href="{% url 'thread' thread.get_opening_post.id %}">{% trans 'Normal mode' %}</a>,
-            <a href="{% url 'thread_mode' thread.get_opening_post.id 'gallery' %}">{% trans 'Gallery mode' %}</a>
-        </div>
+    {% cache 600 thread_view thread.id thread.last_edit_time moderator LANGUAGE_CODE %}
+
+    <div class="image-mode-tab">
+        <a class="current_mode" href="{% url 'thread' opening_post.id %}">{% trans 'Normal mode' %}</a>,
+        <a href="{% url 'thread_mode' opening_post.id 'gallery' %}">{% trans 'Gallery mode' %}</a>
+    </div>
 
-        {% if bumpable %}
-            <div class="bar-bg">
-                <div class="bar-value" style="width:{{ bumplimit_progress }}%" id="bumplimit_progress">
-                </div>
-                <div class="bar-text">
-                    <span id="left_to_limit">{{ posts_left }}</span> {% trans 'posts to bumplimit' %}
-                </div>
+    {% if bumpable %}
+        <div class="bar-bg">
+            <div class="bar-value" style="width:{{ bumplimit_progress }}%" id="bumplimit_progress">
+            </div>
+            <div class="bar-text">
+                <span id="left_to_limit">{{ posts_left }}</span> {% trans 'posts to bumplimit' %}
             </div>
-        {% endif %}
+        </div>
+    {% endif %}
+
     <div class="thread">
-    {% for post in posts %}
-        {% post_view post moderator=moderator %}
-    {% endfor %}
+        {% for post in thread.get_replies %}
+            {% post_view post moderator=moderator %}
+        {% endfor %}
     </div>
 
     {% if not thread.archived %}
 
     <div class="post-form-w">
         <script src="{% static 'js/panel.js' %}"></script>
-        <div class="form-title">{% trans "Reply to thread" %} #{{ thread.get_opening_post.id }}</div>
+        <div class="form-title">{% trans "Reply to thread" %} #{{ opening_post.id }}</div>
         <div class="post-form">
             <form id="form" enctype="multipart/form-data" method="post"
                     >{% csrf_token %}
@@ -57,6 +61,8 b''
 
     <script src="{% static 'js/thread.js' %}"></script>
 
+    {% endcache %}
+
     {% endspaceless %}
 {% endblock %}
 

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
 
@@ -73,4 +73,4 b' def post_view_truncated(post, need_open_'
         'truncated': True,
         'need_open_link': need_open_link,
         'moderator': moderator,
-    }
  No newline at end of file
+    }

boards/tests.py

@@ -1,9 +1,13 b''
 # coding=utf-8
+import time
+import logging
+
 from django.test import TestCase
 from django.test.client import Client
-import time
+from django.core.urlresolvers import reverse, NoReverseMatch
 
 from boards.models import Post, Tag
+from boards import urls
 from neboard import settings
 
 PAGE_404 = 'boards/404.html'
@@ -18,6 +22,8 b' HTTP_CODE_REDIRECT = 302'
 HTTP_CODE_OK = 200
 HTTP_CODE_NOT_FOUND = 404
 
+logger = logging.getLogger(__name__)
+
 
 class PostTests(TestCase):
 
@@ -223,11 +229,29 b' class FormTest(TestCase):'
 
 
 class ViewTest(TestCase):
-    def test_index(self):
+
+    def test_all_views(self):
+        '''
+        Try opening all views defined in ulrs.py that don't need additional
+        parameters
+        '''
+
         client = Client()
+        for url in urls.urlpatterns:
+            try:
+                view_name = url.name
+                logger.debug('Testing view %s' % view_name)
 
-        response = client.get('/')
-        self.assertEqual(HTTP_CODE_OK, response.status_code, 'Index page not '
-                                                             'opened')
-        self.assertEqual('boards/posting_general.html', response.templates[0]
-        .name, 'Index page should open posting_general template')
+                try:
+                    response = client.get(reverse(view_name))
+
+                    self.assertEqual(HTTP_CODE_OK, response.status_code,
+                            '%s view not opened' % view_name)
+                except NoReverseMatch:
+                    # This view just needs additional arguments
+                    pass
+                except Exception, e:
+                    self.fail('Got exception %s at %s view' % (e, view_name))
+            except AttributeError:
+                # This is normal, some views do not have names
+                pass

boards/urls.py

@@ -1,7 +1,13 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, \
+        login, settings, all_tags
+from boards.views.authors import AuthorsView
+from boards.views.delete_post import DeletePostView
+from boards.views.ban import BanUserView
+from boards.views.static import StaticPageView
+from boards.views.post_admin import PostAdminView
 
 js_info_dict = {
     'packages': ('boards',),
@@ -10,41 +16,46 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'),
+    url(r'^login/$', login.LoginView.as_view(), 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'),
-
-    # /boards/tag/tag_name/unsubscribe/
-    url(r'^tag/(?P<tag_name>\w+)/subscribe/$', views.tag_subscribe,
-        name='tag_subscribe'),
-    # /boards/tag/tag_name/unsubscribe/
-    url(r'^tag/(?P<tag_name>\w+)/unsubscribe/$', views.tag_unsubscribe,
-        name='tag_unsubscribe'),
+    url(r'^tag/(?P<tag_name>\w+)/page/(?P<page>\w+)/$',
+        tag_threads.TagView.as_view(), name='tag'),
 
     # /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'^settings/$', views.settings, name='settings'),
-    url(r'^tags/$', views.all_tags, name='tags'),
+    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'),
+
+    # /boards/post_admin/
+    url(r'^post_admin/(?P<post_id>\w+)/$', PostAdminView.as_view(),
+            name='post_admin'),
+
+    url(r'^settings/$', settings.SettingsView.as_view(), name='settings'),
+    url(r'^tags/$', all_tags.AllTagsView.as_view(), name='tags'),
     url(r'^captcha/', include('captcha.urls')),
-    url(r'^jump/(?P<post_id>\w+)/$', views.jump_to_post, name='jumper'),
-    url(r'^authors/$', views.authors, name='authors'),
-    url(r'^delete/(?P<post_id>\w+)/$', views.delete, name='delete'),
-    url(r'^ban/(?P<post_id>\w+)/$', views.ban, name='ban'),
+    url(r'^authors/$', AuthorsView.as_view(), name='authors'),
+    url(r'^delete/(?P<post_id>\w+)/$', DeletePostView.as_view(),
+            name='delete'),
+    url(r'^ban/(?P<post_id>\w+)/$', BanUserView.as_view(), name='ban'),
 
-    url(r'^banned/$', views.you_are_banned, name='banned'),
-    url(r'^staticpage/(?P<name>\w+)/$', views.static_page, name='staticpage'),
+    url(r'^banned/$', views.banned.BannedView.as_view(), name='banned'),
+    url(r'^staticpage/(?P<name>\w+)/$', StaticPageView.as_view(),
+            name='staticpage'),
 
     # RSS feeds
     url(r'^rss/$', AllThreadsFeed()),
@@ -54,7 +65,8 b" urlpatterns = patterns('',"
     url(r'^thread/(?P<post_id>\w+)/rss/$', ThreadPostsFeed()),
 
     # i18n
-    url(r'^jsi18n/$', 'boards.views.cached_js_catalog', js_info_dict, name='js_info_dict'),
+    url(r'^jsi18n/$', 'boards.views.cached_js_catalog', js_info_dict,
+        name='js_info_dict'),
 
     # API
     url(r'^api/post/(?P<post_id>\w+)/$', api.get_post, name="get_post"),
@@ -62,9 +74,10 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

@@ -1,609 +1,9 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.response import HttpResponse
-from django.template import RequestContext
-from django.shortcuts import render, redirect, get_object_or_404
-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.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
-
-
-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"""
-
-    context = _init_default_context(request)
-
-    if request.method == 'POST':
-        form = LoginForm(request.POST, request.FILES,
-                         error_class=PlainErrorList)
-        form.session = request.session
-
-        if form.is_valid():
-            user = User.objects.get(user_id=form.cleaned_data['user_id'])
-            request.session['user_id'] = user.id
-            return redirect(index)
-
-    else:
-        form = LoginForm()
-
-    context['form'] = form
-
-    return render(request, 'boards/login.html', context)
-
-
-def settings(request):
-    """User's settings"""
-
-    context = _init_default_context(request)
-    user = _get_user(request)
-    is_moderator = user.is_moderator()
-
-    if request.method == 'POST':
-        with transaction.atomic():
-            if is_moderator:
-                form = ModeratorSettingsForm(request.POST,
-                                             error_class=PlainErrorList)
-            else:
-                form = SettingsForm(request.POST, error_class=PlainErrorList)
-
-            if form.is_valid():
-                selected_theme = form.cleaned_data['theme']
-
-                user.save_setting('theme', selected_theme)
-
-                if is_moderator:
-                    moderate = form.cleaned_data['moderate']
-                    user.save_setting(SETTING_MODERATE, moderate)
-
-            return redirect(settings)
-    else:
-        selected_theme = _get_theme(request)
-
-        if is_moderator:
-            form = ModeratorSettingsForm(initial={'theme': selected_theme,
-                                                  'moderate': context['moderator']},
-                                         error_class=PlainErrorList)
-        else:
-            form = SettingsForm(initial={'theme': selected_theme},
-                                error_class=PlainErrorList)
-
-    context['form'] = form
-
-    return render(request, 'boards/settings.html', context)
-
-
-def all_tags(request):
-    """All tags list"""
-
-    context = _init_default_context(request)
-    context['all_tags'] = Tag.objects.get_not_empty_tags()
-
-    return render(request, 'boards/tags.html', context)
-
-
-def jump_to_post(request, post_id):
-    """Determine thread in which the requested post is and open it's page"""
-
-    post = get_object_or_404(Post, id=post_id)
-
-    if not post.thread:
-        return redirect(thread, post_id=post.id)
-    else:
-        return redirect(reverse(thread, kwargs={'post_id': post.thread.id})
-                        + '#' + str(post.id))
-
-
-def authors(request):
-    """Show authors list"""
-
-    context = _init_default_context(request)
-    context['authors'] = boards.authors.authors
-
-    return render(request, 'boards/authors.html', context)
-
-
[e-mail]
-def delete(request, post_id):
-    """Delete post"""
-
-    user = _get_user(request)
-    post = get_object_or_404(Post, id=post_id)
-
-    if user.is_moderator():
-        # TODO Show confirmation page before deletion
-        Post.objects.delete_post(post)
-
-    if not post.thread:
-        return _redirect_to_next(request)
-    else:
-        return redirect(thread, post_id=post.thread.id)
-
-
[e-mail]
-def ban(request, post_id):
-    """Ban user"""
-
-    user = _get_user(request)
-    post = get_object_or_404(Post, id=post_id)
-
-    if user.is_moderator():
-        # TODO Show confirmation page before ban
-        ban, created = Ban.objects.get_or_create(ip=post.poster_ip)
-        if created:
-            ban.reason = 'Banned for post ' + str(post_id)
-            ban.save()
-
-    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)"""
-
-    context = _init_default_context(request)
-    return render(request, 'boards/404.html', context)
-
-
[e-mail]
-def tag_subscribe(request, tag_name):
-    """Add tag to favorites"""
-
-    user = _get_user(request)
-    tag = get_object_or_404(Tag, name=tag_name)
-
-    if not tag in user.fav_tags.all():
-        user.add_tag(tag)
-
-    return _redirect_to_next(request)
-
-
[e-mail]
-def tag_unsubscribe(request, tag_name):
-    """Remove tag from favorites"""
-
-    user = _get_user(request)
-    tag = get_object_or_404(Tag, name=tag_name)
-
-    if tag in user.fav_tags.all():
-        user.remove_tag(tag)
-
-    return _redirect_to_next(request)
-
-
-def static_page(request, name):
-    """Show a static page that needs only tags list and a CSS"""
-
-    context = _init_default_context(request)
-    return render(request, 'boards/staticpages/' + name + '.html', context)
-
-
-def api_get_post(request, post_id):
-    """
-    Get the JSON of a post. This can be
-    used as and API for external clients.
-    """
-
-    post = get_object_or_404(Post, id=post_id)
-
-    json = serializers.serialize("json", [post], fields=(
-        "pub_time", "_text_rendered", "title", "text", "image",
-        "image_width", "image_height", "replies", "tags"
-    ))
-
-    return HttpResponse(content=json)
 
 
 @cache_page(86400)
 def cached_js_catalog(request, domain='djangojs', packages=None):
     return javascript_catalog(request, domain, packages)
-
-
-def _get_theme(request, user=None):
-    """Get user's CSS theme"""
-
-    if not user:
-        user = _get_user(request)
-    theme = user.get_setting('theme')
-    if not theme:
-        theme = neboard.settings.DEFAULT_THEME
-
-    return theme
-
-
-def _init_default_context(request):
-    """Create context with default values that are used in most views"""
-
-    context = RequestContext(request)
-
-    user = _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 = _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(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)
-
-        _delete_old_users()
-
-        session['user_id'] = user.id
-    else:
-        user = User.objects.get(id=session['user_id'])
-
-    return user
-
-
-def _redirect_to_next(request):
-    """
-    If a 'next' parameter was specified, redirect to the next page. This is
-    used when the user is required to return to some page after the current
-    view has finished its work.
-    """
-
-    if 'next' in request.GET:
-        next_page = request.GET['next']
-        return HttpResponseRedirect(next_page)
-    else:
-        return redirect(index)
-
-
[e-mail]
-def _ban_current_user(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()
-
-
-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, '>>' + post_id, post_id)
-
-    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"""
-
-    last_replies = thread_to_show.get_last_replies()
-    skipped_replies_count = thread_to_show.get_replies().count() \
-                            - len(last_replies) - 1
-    return {
-        'thread': thread_to_show,
-        'op': thread_to_show.get_replies()[0],
-        'bumpable': thread_to_show.can_bump(),
-        '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

@@ -5,10 +5,12 b' from django.http import HttpResponse'
 from django.shortcuts import get_object_or_404, render
 from django.template import RequestContext
 from django.utils import timezone
+from django.core import serializers
+
 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 +55,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 +80,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,12 +181,28 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))
 
 
+def api_get_post(request, post_id):
+    """
+    Get the JSON of a post. This can be
+    used as and API for external clients.
+    """
+
+    post = get_object_or_404(Post, id=post_id)
+
+    json = serializers.serialize("json", [post], fields=(
+        "pub_time", "_text_rendered", "title", "text", "image",
+        "image_width", "image_height", "replies", "tags"
+    ))
+
+    return HttpResponse(content=json)
+
+
 # TODO Add pub time and replies
 def _get_post_data(post_id, format_type=DIFF_TYPE_JSON, request=None,
         include_last_update=False):
@@ -200,6 +219,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

changelog.markdown

@@ -14,3 +14,15 b' thread.'
 * Added API for viewing threads and posts
 * New tag popularity algorithm
 * Tags list page changes. Now tags list is more like a tag cloud
+
+# 1.7 Anubis
+* [ADMIN] Added admin page for post editing, capable of adding and removing tags
+* [CODE] Post view unification
+* Post caching instead of thread caching
+* Simplified tag list page
+* [API] Added api for thread update in json
+* Image duplicate check
+* Posting over ajax (no page reload now)
+* Update last update time with thread update
+* Added z-index to the images to move the dragged image to front
+* [CODE] Major view refactoring. Now almost all views are class-based

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 += (

neboard/urls.py

@@ -5,6 +5,8 b' from django.conf.urls.static import stat'
 from django.contrib import admin
 from neboard import settings
 
+from boards.views.not_found import NotFoundView
+
 admin.autodiscover()
 
 urlpatterns = patterns('',
@@ -20,4 +22,4 b" urlpatterns = patterns('',"
     url(r'^', include('boards.urls')),
 ) + static(settings.MEDIA_URL, document_root=settings.MEDIA_ROOT)
 
-handler404 = 'boards.views.page_404'
+handler404 = NotFoundView.as_view()

todo.txt

@@ -15,7 +15,6 b''
 post or its part (delimited by N characters) into quote of the new post.
 [NOT STARTED] Ban confirmation page with reason
 [NOT STARTED] Post deletion confirmation page
-[NOT STARTED] Moderating page. Tags editing and adding
 [NOT STARTED] Get thread graph image using pygraphviz
 [NOT STARTED] Subscribing to tag via AJAX