Added post admin page with tags edit capability

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

@@ -1,313 +1,339 b''
 import re
 import time
 import hashlib
 
 from captcha.fields import CaptchaField
 from django import forms
 from django.forms.util import ErrorList
 from django.utils.translation import ugettext_lazy as _
 
 from boards.mdx_neboard import formatters
 from boards.models.post import TITLE_MAX_LENGTH
 from boards.models import User, Post
 from neboard import settings
 from boards import utils
 import boards.settings as board_settings
 
 ATTRIBUTE_PLACEHOLDER = 'placeholder'
 
 LAST_POST_TIME = 'last_post_time'
 LAST_LOGIN_TIME = 'last_login_time'
 TEXT_PLACEHOLDER = _('''Type message here. You can reply to message >>123 like
  this. 2 new lines are required to start new paragraph.''')
 TAGS_PLACEHOLDER = _('tag1 several_words_tag')
 
 ERROR_IMAGE_DUPLICATE = _('Such image was already posted')
 
 LABEL_TITLE = _('Title')
 LABEL_TEXT = _('Text')
+LABEL_TAG = _('Tag')
+
+TAG_MAX_LENGTH = 20
+
+REGEX_TAG = ur'^[\w\d]+$'
 
 
 class FormatPanel(forms.Textarea):
     def render(self, name, value, attrs=None):
         output = '<div id="mark-panel">'
         for formatter in formatters:
             output += u'<span class="mark_btn"' + \
                       u' onClick="addMarkToMsg(\'' + formatter.format_left + \
                       '\', \'' + formatter.format_right + '\')">' + \
                       formatter.preview_left + formatter.name + \
                       formatter.preview_right + u'</span>'
 
         output += '</div>'
         output += super(FormatPanel, self).render(name, value, attrs=None)
 
         return output
 
 
 class PlainErrorList(ErrorList):
     def __unicode__(self):
         return self.as_text()
 
     def as_text(self):
         return ''.join([u'(!) %s ' % e for e in self])
 
 
 class NeboardForm(forms.Form):
 
     def as_div(self):
         """
         Returns this form rendered as HTML <as_div>s.
         """
 
         return self._html_output(
             # TODO Do not show hidden rows in the list here
             normal_row='<div class="form-row">'
                        '<div class="form-label">'
                        '%(label)s'
                        '</div>'
                        '<div class="form-input">'
                        '%(field)s'
                        '</div>'
                        '%(help_text)s'
                        '</div>',
             error_row='<div class="form-row">'
                       '<div class="form-label"></div>'
                       '<div class="form-errors">%s</div>'
                       '</div>',
             row_ender='</div>',
             help_text_html='%s',
             errors_on_separate_row=True)
 
     def as_json_errors(self):
         errors = []
 
         for name, field in self.fields.items():
             if self[name].errors:
                 errors.append({
                     'field': name,
                     'errors': self[name].errors.as_text(),
                 })
 
         return errors
 
 
 class PostForm(NeboardForm):
 
     title = forms.CharField(max_length=TITLE_MAX_LENGTH, required=False,
                             label=LABEL_TITLE)
     text = forms.CharField(
         widget=FormatPanel(attrs={ATTRIBUTE_PLACEHOLDER: TEXT_PLACEHOLDER}),
         required=False, label=LABEL_TEXT)
     image = forms.ImageField(required=False, label=_('Image'))
 
     # This field is for spam prevention only
     email = forms.CharField(max_length=100, required=False, label=_('e-mail'),
                             widget=forms.TextInput(attrs={
                                 'class': 'form-email'}))
 
     session = None
     need_to_ban = False
 
     def clean_title(self):
         title = self.cleaned_data['title']
         if title:
             if len(title) > TITLE_MAX_LENGTH:
                 raise forms.ValidationError(_('Title must have less than %s '
                                               'characters') %
                                             str(TITLE_MAX_LENGTH))
         return title
 
     def clean_text(self):
         text = self.cleaned_data['text']
         if text:
             if len(text) > board_settings.MAX_TEXT_LENGTH:
                 raise forms.ValidationError(_('Text must have less than %s '
                                               'characters') %
                                             str(board_settings
                                             .MAX_TEXT_LENGTH))
         return text
 
     def clean_image(self):
         image = self.cleaned_data['image']
         if image:
             if image._size > board_settings.MAX_IMAGE_SIZE:
                 raise forms.ValidationError(
                     _('Image must be less than %s bytes')
                     % str(board_settings.MAX_IMAGE_SIZE))
 
             md5 = hashlib.md5()
             for chunk in image.chunks():
                 md5.update(chunk)
             image_hash = md5.hexdigest()
             if Post.objects.filter(image_hash=image_hash).exists():
                 raise forms.ValidationError(ERROR_IMAGE_DUPLICATE)
 
         return image
 
     def clean(self):
         cleaned_data = super(PostForm, self).clean()
 
         if not self.session:
             raise forms.ValidationError('Humans have sessions')
 
         if cleaned_data['email']:
             self.need_to_ban = True
             raise forms.ValidationError('A human cannot enter a hidden field')
 
         if not self.errors:
             self._clean_text_image()
 
         if not self.errors and self.session:
             self._validate_posting_speed()
 
         return cleaned_data
 
     def _clean_text_image(self):
         text = self.cleaned_data.get('text')
         image = self.cleaned_data.get('image')
 
         if (not text) and (not image):
             error_message = _('Either text or image must be entered.')
             self._errors['text'] = self.error_class([error_message])
 
     def _validate_posting_speed(self):
         can_post = True
 
         if LAST_POST_TIME in self.session:
             now = time.time()
             last_post_time = self.session[LAST_POST_TIME]
 
             current_delay = int(now - last_post_time)
 
             if current_delay < settings.POSTING_DELAY:
                 error_message = _('Wait %s seconds after last posting') % str(
                     settings.POSTING_DELAY - current_delay)
                 self._errors['text'] = self.error_class([error_message])
 
                 can_post = False
 
         if can_post:
             self.session[LAST_POST_TIME] = time.time()
 
 
 class ThreadForm(PostForm):
 
     regex_tags = re.compile(ur'^[\w\s\d]+$', re.UNICODE)
 
     tags = forms.CharField(
         widget=forms.TextInput(attrs={ATTRIBUTE_PLACEHOLDER: TAGS_PLACEHOLDER}),
         max_length=100, label=_('Tags'))
 
     def clean_tags(self):
         tags = self.cleaned_data['tags']
 
         if tags:
             if not self.regex_tags.match(tags):
                 raise forms.ValidationError(
                     _('Inappropriate characters in tags.'))
 
         return tags
 
     def clean(self):
         cleaned_data = super(ThreadForm, self).clean()
 
         return cleaned_data
 
 
 class PostCaptchaForm(PostForm):
     captcha = CaptchaField()
 
     def __init__(self, *args, **kwargs):
         self.request = kwargs['request']
         del kwargs['request']
 
         super(PostCaptchaForm, self).__init__(*args, **kwargs)
 
     def clean(self):
         cleaned_data = super(PostCaptchaForm, self).clean()
 
         success = self.is_valid()
         utils.update_captcha_access(self.request, success)
 
         if success:
             return cleaned_data
         else:
             raise forms.ValidationError(_("Captcha validation failed"))
 
 
 class ThreadCaptchaForm(ThreadForm):
     captcha = CaptchaField()
 
     def __init__(self, *args, **kwargs):
         self.request = kwargs['request']
         del kwargs['request']
 
         super(ThreadCaptchaForm, self).__init__(*args, **kwargs)
 
     def clean(self):
         cleaned_data = super(ThreadCaptchaForm, self).clean()
 
         success = self.is_valid()
         utils.update_captcha_access(self.request, success)
 
         if success:
             return cleaned_data
         else:
             raise forms.ValidationError(_("Captcha validation failed"))
 
 
 class SettingsForm(NeboardForm):
 
     theme = forms.ChoiceField(choices=settings.THEMES,
                               label=_('Theme'))
 
 
 class ModeratorSettingsForm(SettingsForm):
 
     moderate = forms.BooleanField(required=False, label=_('Enable moderation '
                                                           'panel'))
 
 
 class LoginForm(NeboardForm):
 
     user_id = forms.CharField()
 
     session = None
 
     def clean_user_id(self):
         user_id = self.cleaned_data['user_id']
         if user_id:
             users = User.objects.filter(user_id=user_id)
             if len(users) == 0:
                 raise forms.ValidationError(_('No such user found'))
 
         return user_id
 
     def _validate_login_speed(self):
         can_post = True
 
         if LAST_LOGIN_TIME in self.session:
             now = time.time()
             last_login_time = self.session[LAST_LOGIN_TIME]
 
             current_delay = int(now - last_login_time)
 
             if current_delay < board_settings.LOGIN_TIMEOUT:
                 error_message = _('Wait %s minutes after last login') % str(
                     (board_settings.LOGIN_TIMEOUT - current_delay) / 60)
                 self._errors['user_id'] = self.error_class([error_message])
 
                 can_post = False
 
         if can_post:
             self.session[LAST_LOGIN_TIME] = time.time()
 
     def clean(self):
         if not self.session:
             raise forms.ValidationError('Humans have sessions')
 
         self._validate_login_speed()
 
         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

@@ -1,359 +1,370 b''
 # SOME DESCRIPTIVE TITLE.
 # Copyright (C) YEAR THE PACKAGE'S COPYRIGHT HOLDER
 # This file is distributed under the same license as the PACKAGE package.
 # FIRST AUTHOR <EMAIL@ADDRESS>, YEAR.
 #
 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"
 "Language: ru\n"
 "MIME-Version: 1.0\n"
 "Content-Type: text/plain; charset=UTF-8\n"
 "Content-Transfer-Encoding: 8bit\n"
 "Plural-Forms: nplurals=3; plural=(n%10==1 && n%100!=11 ? 0 : n%10>=2 && n"
 "%10<=4 && (n%100<10 || n%100>=20) ? 1 : 2);\n"
 
 #: authors.py:5
 msgid "author"
 msgstr "автор"
 
 #: authors.py:6
 msgid "developer"
 msgstr "разработчик"
 
 #: authors.py:7
 msgid "javascript developer"
 msgstr "разработчик javascript"
 
 #: authors.py:8
 msgid "designer"
 msgstr "дизайнер"
 
 #: forms.py:21
 msgid ""
 "Type message here. You can reply to message >>123 like\n"
 " this. 2 new lines are required to start new paragraph."
 msgstr ""
 "Введите сообщение здесь. Вы можете ответить на сообщение >>123 вот так. 2 "
 "переноса строки обязательны для создания нового абзаца."
 
 #: forms.py:23
 msgid "tag1 several_words_tag"
 msgstr "тег1 тег_из_нескольких_слов"
 
 #: forms.py:25
 msgid "Such image was already posted"
 msgstr "Такое изображение уже было загружено"
 
 #: forms.py:27
 msgid "Title"
 msgstr "Заголовок"
 
 #: forms.py:28
 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 минут после последнего входа"
 
 #: templates/boards/404.html:6
 msgid "Not found"
 msgstr "Не найдено"
 
 #: templates/boards/404.html:12
 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 "Репозиторий"
 
 #: templates/boards/base.html:14
 msgid "Feed"
 msgstr "Лента"
 
 #: templates/boards/base.html:31
 msgid "All threads"
 msgstr "Все темы"
 
 #: templates/boards/base.html:36
 msgid "Tag management"
 msgstr "Управление тегами"
 
-#: templates/boards/base.html:38
+#: templates/boards/base.html:38 templates/boards/settings.html:7
 msgid "Settings"
 msgstr "Настройки"
 
 #: templates/boards/base.html:50 templates/boards/login.html:6
 #: templates/boards/login.html.py:21
 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"
 msgstr "Скорость: %(ppd)s сообщений в день"
 
 #: templates/boards/base.html:55
 msgid "Up"
 msgstr "Вверх"
 
 #: templates/boards/login.html:15
 msgid "User ID"
 msgstr "ID пользователя"
 
 #: templates/boards/login.html:24
 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 "Пользователь:"
 
 #: templates/boards/settings.html:16
 msgid "You are moderator."
 msgstr "Вы модератор."
 
 #: templates/boards/settings.html:19
 msgid "Posts:"
 msgstr "Сообщений:"
 
 #: templates/boards/settings.html:20
 msgid "First access:"
 msgstr "Первый доступ:"
 
 #: templates/boards/settings.html:22
 msgid "Last access:"
 msgstr "Последний доступ: "
 
 #: templates/boards/settings.html:31
 msgid "Save"
 msgstr "Сохранить"
 
 #: templates/boards/tags.html:27
 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 "Последнее обновление: "
 
 #: templates/boards/rss/post.html:5
 msgid "Post image"
 msgstr "Изображение сообщения"
 
 #: templates/boards/staticpages/banned.html:6
 msgid "Banned"
 msgstr "Заблокирован"
 
 #: templates/boards/staticpages/banned.html:11
 msgid "Your IP address has been banned. Contact the administrator"
 msgstr "Ваш IP адрес был заблокирован. Свяжитесь с администратором"
 
 #: templates/boards/staticpages/help.html:6
 #: templates/boards/staticpages/help.html:10
 msgid "Syntax"
 msgstr "Синтаксис"
 
 #: templates/boards/staticpages/help.html:11
 msgid "2 line breaks for a new line."
 msgstr "2 перевода строки создают новый абзац."
 
 #: templates/boards/staticpages/help.html:12
 msgid "Italic text"
 msgstr "Курсивный текст"
 
 #: templates/boards/staticpages/help.html:13
 msgid "Bold text"
 msgstr "Полужирный текст"
 
 #: templates/boards/staticpages/help.html:14
 msgid "Spoiler"
 msgstr "Спойлер"
 
 #: templates/boards/staticpages/help.html:15
 msgid "Link to a post"
 msgstr "Ссылка на сообщение"
 
 #: templates/boards/staticpages/help.html:16
 msgid "Strikethrough text"
 msgstr "Зачеркнутый текст"
 
 #: templates/boards/staticpages/help.html:17
 msgid "You need to new line before:"
 msgstr "Перед этими тегами нужна новая строка:"
 
 #: templates/boards/staticpages/help.html:18
 msgid "Comment"
 msgstr "Комментарий"
 
 #: templates/boards/staticpages/help.html:19
 msgid "Quote"
 msgstr "Цитата"

boards/models/post.py

@@ -1,393 +1,417 b''
 from datetime import datetime, timedelta
 from datetime import time as dtime
 import os
 from random import random
 import time
 import math
 import re
 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
 
 from neboard import settings
 from boards import thumbs
 
 MAX_TITLE_LENGTH = 50
 
 APP_LABEL_BOARDS = 'boards'
 
 CACHE_KEY_PPD = 'ppd'
 
 POSTS_PER_DAY_RANGE = range(7)
 
 BAN_REASON_AUTO = 'Auto'
 
 IMAGE_THUMB_SIZE = (200, 150)
 
 TITLE_MAX_LENGTH = 50
 
 DEFAULT_MARKUP_TYPE = 'markdown'
 
 NO_PARENT = -1
 NO_IP = '0.0.0.0'
 UNKNOWN_UA = ''
 ALL_PAGES = -1
 IMAGES_DIRECTORY = 'images/'
 FILE_EXTENSION_DELIMITER = '.'
 
 SETTING_MODERATE = "moderate"
 
 REGEX_REPLY = re.compile('>>(\d+)')
 
 
 class PostManager(models.Manager):
 
     def create_post(self, title, text, image=None, thread=None,
                     ip=NO_IP, tags=None, user=None):
         """
         Create new post
         """
 
         posting_time = timezone.now()
         if not thread:
             thread = Thread.objects.create(bump_time=posting_time,
                                            last_edit_time=posting_time)
         else:
             thread.bump()
             thread.last_edit_time = posting_time
             thread.save()
 
         post = self.create(title=title,
                            text=text,
                            pub_time=posting_time,
                            thread_new=thread,
                            image=image,
                            poster_ip=ip,
                            poster_user_agent=UNKNOWN_UA,  # TODO Get UA at
                            # last!
                            last_edit_time=posting_time,
                            user=user)
 
         thread.replies.add(post)
         if tags:
             linked_tags = []
             for tag in tags:
                 tag_linked_tags = tag.get_linked_tags()
                 if len(tag_linked_tags) > 0:
                     linked_tags.extend(tag_linked_tags)
 
             tags.extend(linked_tags)
             map(thread.add_tag, tags)
 
         self._delete_old_threads()
         self.connect_replies(post)
 
         return post
 
     def delete_post(self, post):
         """
         Delete post and update or delete its thread
         """
 
         thread = post.thread_new
 
         if post.is_opening():
             thread.delete_with_posts()
         else:
             thread.last_edit_time = timezone.now()
             thread.save()
 
             post.delete()
 
     def delete_posts_by_ip(self, ip):
         """
         Delete all posts of the author with same IP
         """
 
         posts = self.filter(poster_ip=ip)
         map(self.delete_post, posts)
 
     # 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:
             threads = tag.threads
 
             if not threads.exists():
                 raise Http404
         else:
             threads = Thread.objects.all()
 
         threads = threads.filter(archived=archived).order_by(order_by)
 
         if page != ALL_PAGES:
             threads = Paginator(threads, settings.THREADS_PER_PAGE).page(
                     page).object_list
 
         return threads
 
     # TODO Move this method to thread manager
     def _delete_old_threads(self):
         """
         Preserves maximum thread count. If there are too many threads,
         archive the old ones.
         """
 
         threads = self.get_threads()
         thread_count = threads.count()
 
         if thread_count > settings.MAX_THREAD_COUNT:
             num_threads_to_delete = thread_count - settings.MAX_THREAD_COUNT
             old_threads = threads[thread_count - num_threads_to_delete:]
 
             for thread in old_threads:
                 thread.archived = True
                 thread.last_edit_time = timezone.now()
                 thread.save()
 
     def connect_replies(self, post):
         """
         Connect replies to a post to show them as a reflink map
         """
 
         for reply_number in re.finditer(REGEX_REPLY, post.text.raw):
             post_id = reply_number.group(1)
             ref_post = self.filter(id=post_id)
             if ref_post.count() > 0:
                 referenced_post = ref_post[0]
                 referenced_post.referenced_posts.add(post)
                 referenced_post.last_edit_time = post.pub_time
                 referenced_post.save()
 
                 referenced_thread = referenced_post.thread_new
                 referenced_thread.last_edit_time = post.pub_time
                 referenced_thread.save()
 
     def get_posts_per_day(self):
         """
         Get average count of posts per day for the last 7 days
         """
 
         today = datetime.now().date()
         ppd = cache.get(CACHE_KEY_PPD + str(today))
         if ppd:
             return ppd
 
         posts_per_days = []
         for i in POSTS_PER_DAY_RANGE:
             day_end = today - timedelta(i + 1)
             day_start = today - timedelta(i + 2)
 
             day_time_start = timezone.make_aware(datetime.combine(day_start,
                 dtime()), timezone.get_current_timezone())
             day_time_end = timezone.make_aware(datetime.combine(day_end,
                 dtime()), timezone.get_current_timezone())
 
             posts_per_days.append(float(self.filter(
                 pub_time__lte=day_time_end,
                 pub_time__gte=day_time_start).count()))
 
         ppd = (sum(posts_per_day for posts_per_day in posts_per_days) /
                len(posts_per_days))
         cache.set(CACHE_KEY_PPD, ppd)
         return ppd
 
 
 class Post(models.Model):
     """A post is a message."""
 
     objects = PostManager()
 
     class Meta:
         app_label = APP_LABEL_BOARDS
 
     # TODO Save original file name to some field
     def _update_image_filename(self, filename):
         """Get unique image filename"""
 
         path = IMAGES_DIRECTORY
         new_name = str(int(time.mktime(time.gmtime())))
         new_name += str(int(random() * 1000))
         new_name += FILE_EXTENSION_DELIMITER
         new_name += filename.split(FILE_EXTENSION_DELIMITER)[-1:][0]
 
         return os.path.join(path, new_name)
 
     title = models.CharField(max_length=TITLE_MAX_LENGTH)
     pub_time = models.DateTimeField()
     text = MarkupField(default_markup_type=DEFAULT_MARKUP_TYPE,
                        escape_html=False)
 
     image_width = models.IntegerField(default=0)
     image_height = models.IntegerField(default=0)
 
     image_pre_width = models.IntegerField(default=0)
     image_pre_height = models.IntegerField(default=0)
 
     image = thumbs.ImageWithThumbsField(upload_to=_update_image_filename,
                                         blank=True, sizes=(IMAGE_THUMB_SIZE,),
                                         width_field='image_width',
                                         height_field='image_height',
                                         preview_width_field='image_pre_width',
                                         preview_height_field='image_pre_height')
     image_hash = models.CharField(max_length=36)
 
     poster_ip = models.GenericIPAddressField()
     poster_user_agent = models.TextField()
 
     thread = models.ForeignKey('Post', null=True, default=None)
     thread_new = models.ForeignKey('Thread', null=True, default=None)
     last_edit_time = models.DateTimeField()
     user = models.ForeignKey('User', null=True, default=None)
 
     referenced_posts = models.ManyToManyField('Post', symmetrical=False,
                                               null=True,
                                               blank=True, related_name='rfp+')
 
     def __unicode__(self):
         return '#' + str(self.id) + ' ' + self.title + ' (' + \
                self.text.raw[:50] + ')'
 
     def get_title(self):
         title = self.title
         if len(title) == 0:
             title = self.text.rendered
 
         return title
 
     def get_sorted_referenced_posts(self):
         return self.referenced_posts.order_by('id')
 
     def is_referenced(self):
         return self.referenced_posts.all().exists()
 
     def is_opening(self):
         return self.thread_new.get_replies()[0] == self
 
     def save(self, *args, **kwargs):
         """
         Save the model and compute the image hash
         """
 
         if not self.pk and self.image:
             md5 = hashlib.md5()
             for chunk in self.image.chunks():
                 md5.update(chunk)
             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):
 
     class Meta:
         app_label = APP_LABEL_BOARDS
 
     tags = models.ManyToManyField('Tag')
     bump_time = models.DateTimeField()
     last_edit_time = models.DateTimeField()
     replies = models.ManyToManyField('Post', symmetrical=False, null=True,
                                      blank=True, related_name='tre+')
     archived = models.BooleanField(default=False)
 
     def get_tags(self):
         """
         Get a sorted tag list
         """
 
         return self.tags.order_by('name')
 
     def bump(self):
         """
         Bump (move to up) thread
         """
 
         if self.can_bump():
             self.bump_time = timezone.now()
 
     def get_reply_count(self):
         return self.replies.count()
 
     def get_images_count(self):
         return self.replies.filter(image_width__gt=0).count()
 
     def can_bump(self):
         """
         Check if the thread can be bumped by replying
         """
 
         if self.archived:
             return False
 
         post_count = self.get_reply_count()
 
         return post_count < settings.MAX_POSTS_PER_THREAD
 
     def delete_with_posts(self):
         """
         Completely delete thread and all its posts
         """
 
         if self.replies.count() > 0:
             self.replies.all().delete()
 
         self.delete()
 
     def get_last_replies(self):
         """
         Get last replies, not including opening post
         """
 
         if settings.LAST_REPLIES_COUNT > 0:
             reply_count = self.get_reply_count()
 
             if reply_count > 0:
                 reply_count_to_show = min(settings.LAST_REPLIES_COUNT,
                                           reply_count - 1)
                 last_replies = self.replies.all().order_by('pub_time')[
                                reply_count - reply_count_to_show:]
 
                 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
         """
 
         return self.replies.all().order_by('pub_time')
 
     def add_tag(self, tag):
         """
         Connect thread to a tag and tag to a thread
         """
 
         self.tags.add(tag)
         tag.threads.add(self)
 
     def get_opening_post(self):
         """
         Get first post of the thread
         """
 
         return self.get_replies()[0]
 
     def __unicode__(self):
         return str(self.id)
 
     def get_pub_time(self):
         """
         Thread does not have its own pub time, so we need to get it from
         the opening post
         """
 
         return self.get_opening_post().pub_time

boards/templates/boards/post.html

@@ -1,96 +1,98 b''
 {% load i18n %}
 {% load board %}
 {% load cache %}
 
 {% get_current_language as LANGUAGE_CODE %}
 
 {% cache 600 post post.id post.thread_new.last_edit_time truncated moderator LANGUAGE_CODE need_open_link %}
     {% 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 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 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 '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 %}
             {% 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 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>
         {% endwith %}
     {% endspaceless %}
 {% endcache %}

boards/urls.py

@@ -1,76 +1,83 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, 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',),
 }
 
 urlpatterns = patterns('',
 
     # /boards/
     url(r'^$', all_threads.AllThreadsView.as_view(), name='index'),
     # /boards/page/
     url(r'^page/(?P<page>\w+)/$', all_threads.AllThreadsView.as_view(),
         name='index'),
 
     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/$', login.LoginView.as_view(), name='login'),
 
     # /boards/tag/tag_name/
     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+)/$',
         tag_threads.TagView.as_view(), name='tag'),
 
     # /boards/thread/
     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'^authors/$', AuthorsView.as_view(), name='authors'),
     url(r'^delete/(?P<post_id>\w+)/$', DeletePostView.as_view(),
-        name='delete'),
+            name='delete'),
     url(r'^ban/(?P<post_id>\w+)/$', BanUserView.as_view(), name='ban'),
 
     url(r'^banned/$', views.banned.BannedView.as_view(), name='banned'),
     url(r'^staticpage/(?P<name>\w+)/$', StaticPageView.as_view(),
-        name='staticpage'),
+            name='staticpage'),
 
     # RSS feeds
     url(r'^rss/$', AllThreadsFeed()),
     url(r'^page/(?P<page>\w+)/rss/$', AllThreadsFeed()),
     url(r'^tag/(?P<tag_name>\w+)/rss/$', TagThreadsFeed()),
     url(r'^tag/(?P<tag_name>\w+)/page/(?P<page>\w+)/rss/$', TagThreadsFeed()),
     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"),
     url(r'^api/diff_thread/(?P<thread_id>\w+)/(?P<last_update_time>\w+)/$',
         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,
             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/views/mixins.py

@@ -1,33 +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, request):
+    def dispatch_method(self, *args, **kwargs):
+        request = args[0]
+
+        method_name = None
         if PARAMETER_METHOD in request.GET:
             method_name = request.GET[PARAMETER_METHOD]
-            return getattr(self, method_name)(request)
+        elif PARAMETER_METHOD in request.POST:
+            method_name = request.POST[PARAMETER_METHOD]
 
+        if method_name:
+            return getattr(self, method_name)(*args, **kwargs)