Added required tags. At least one such tag is needed to create a thread. All

other tags including new can be added is desired

boards/migrations/0004_tag_required.py

@@ -0,0 +1,20 b''
+# -*- coding: utf-8 -*-
+from __future__ import unicode_literals
+
+from django.db import models, migrations
+
+
+class Migration(migrations.Migration):
+
+    dependencies = [
+        ('boards', '0003_remove_tag_threads'),
+    ]
+
+    operations = [
+        migrations.AddField(
+            model_name='tag',
+            name='required',
+            field=models.BooleanField(default=False),
+            preserve_default=True,
+        ),
+    ]

boards/forms.py

@@ -1,294 +1,305 b''
 import re
 import time
 import hashlib
 
 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 PostImage
+from boards.models import PostImage, Tag
 from neboard import settings
 from boards import utils
 import boards.settings as board_settings
 
 VETERAN_POSTING_DELAY = 5
 
 ATTRIBUTE_PLACEHOLDER = 'placeholder'
 
 LAST_POST_TIME = 'last_post_time'
 LAST_LOGIN_TIME = 'last_login_time'
 TEXT_PLACEHOLDER = _('''Type message here. Use formatting panel for more advanced usage.''')
 TAGS_PLACEHOLDER = _('tag1 several_words_tag')
 
 ERROR_IMAGE_DUPLICATE = _('Such image was already posted')
 
 LABEL_TITLE = _('Title')
 LABEL_TEXT = _('Text')
 LABEL_TAG = _('Tag')
 LABEL_SEARCH = _('Search')
 
 TAG_MAX_LENGTH = 20
 
 REGEX_TAG = r'^[\w\d]+$'
 
 
 class FormatPanel(forms.Textarea):
     def render(self, name, value, attrs=None):
         output = '<div id="mark-panel">'
         for formatter in formatters:
             output += '<span class="mark_btn"' + \
                       ' onClick="addMarkToMsg(\'' + formatter.format_left + \
                       '\', \'' + formatter.format_right + '\')">' + \
                       formatter.preview_left + formatter.name + \
                       formatter.preview_right + '</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(['(!) %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>'
                        '<div class="form-row"><div class="form-input">'
                        '%(field)s'
                        '</div></div>'
                        '<div class="form-row">'
                        '%(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 list(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'),
                              widget=forms.ClearableFileInput(
                                  attrs={'accept': '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'].strip()
         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 PostImage.objects.filter(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
 
         posting_delay = settings.POSTING_DELAY
 
         if board_settings.LIMIT_POSTING_SPEED and 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 < posting_delay:
                 error_message = _('Wait %s seconds after last posting') % str(
                     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(r'^[\w\s\d]+$', re.UNICODE)
 
     tags = forms.CharField(
         widget=forms.TextInput(attrs={ATTRIBUTE_PLACEHOLDER: TAGS_PLACEHOLDER}),
         max_length=100, label=_('Tags'), required=True)
 
     def clean_tags(self):
         tags = self.cleaned_data['tags'].strip()
 
         if not tags or not self.regex_tags.match(tags):
             raise forms.ValidationError(
                 _('Inappropriate characters in tags.'))
 
+        tag_models = []
+        required_tag_exists = False
+        for tag in tags.split():
+            tag_model = Tag.objects.filter(name=tag.strip().lower(),
+                    required=True)
+            if tag_model.exists():
+                required_tag_exists = True
+
+        if not required_tag_exists:
+            raise forms.ValidationError(_('Need at least 1 required tag.'))
+
         return tags
 
     def clean(self):
         cleaned_data = super(ThreadForm, self).clean()
 
         return cleaned_data
 
 
 class SettingsForm(NeboardForm):
 
     theme = forms.ChoiceField(choices=settings.THEMES,
                               label=_('Theme'))
 
 
 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
 
 
 class SearchForm(NeboardForm):
     query = forms.CharField(max_length=500, label=LABEL_SEARCH, required=False)
 
 
 class LoginForm(NeboardForm):
 
     password = forms.CharField()
 
     session = None
 
     def clean_password(self):
         password = self.cleaned_data['password']
         if board_settings.MASTER_PASSWORD != password:
             raise forms.ValidationError(_('Invalid master password'))
 
         return password
 
     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['password'] = self.error_class([error_message])
 
                 can_post = False
 
         if can_post:
             self.session[LAST_LOGIN_TIME] = time.time()
 
     def clean(self):
         self._validate_login_speed()
 
         cleaned_data = super(LoginForm, self).clean()
 
         return cleaned_data

boards/locale/ru/LC_MESSAGES/django.po

@@ -1,367 +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-11-18 16:31+0200\n"
+"POT-Creation-Date: 2015-01-08 16:36+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:9
 msgid "author"
 msgstr "автор"
 
 #: authors.py:10
 msgid "developer"
 msgstr "разработчик"
 
 #: authors.py:11
 msgid "javascript developer"
 msgstr "разработчик javascript"
 
 #: authors.py:12
 msgid "designer"
 msgstr "дизайнер"
 
 #: forms.py:22
 msgid "Type message here. Use formatting panel for more advanced usage."
 msgstr ""
 "Вводите сообщение сюда. Используйте панель для более сложного форматирования."
 
 #: forms.py:23
 msgid "tag1 several_words_tag"
-msgstr "тег1 тег_из_нескольких_слов"
+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:29
 msgid "Tag"
-msgstr "Тег"
+msgstr "Метка"
 
-#: forms.py:30 templates/boards/base.html:40 templates/search/search.html:9
+#: forms.py:30 templates/boards/base.html:38 templates/search/search.html:9
 #: templates/search/search.html.py:13
 msgid "Search"
 msgstr "Поиск"
 
 #: forms.py:107
 msgid "Image"
 msgstr "Изображение"
 
 #: forms.py:112
 msgid "e-mail"
 msgstr ""
 
 #: forms.py:123
 #, python-format
 msgid "Title must have less than %s characters"
 msgstr "Заголовок должен иметь меньше %s символов"
 
 #: forms.py:132
 #, python-format
 msgid "Text must have less than %s characters"
 msgstr "Текст должен быть короче %s символов"
 
 #: forms.py:143
 #, python-format
 msgid "Image must be less than %s bytes"
 msgstr "Изображение должно быть менее %s байт"
 
 #: forms.py:178
 msgid "Either text or image must be entered."
 msgstr "Текст или картинка должны быть введены."
 
 #: forms.py:194
 #, python-format
 msgid "Wait %s seconds after last posting"
 msgstr "Подождите %s секунд после последнего постинга"
 
 #: forms.py:210 templates/boards/rss/post.html:10 templates/boards/tags.html:7
 msgid "Tags"
-msgstr "Теги"
+msgstr "Метки"
 
-#: forms.py:217 forms.py:243
+#: forms.py:217 forms.py:254
 msgid "Inappropriate characters in tags."
-msgstr "Недопустимые символы в тегах."
+msgstr "Недопустимые символы в метках."
 
-#: forms.py:230
+#: forms.py:228
+msgid "Need at least 1 required tag."
+msgstr "Нужна хотя бы 1 обязательная метка."
+
+#: forms.py:241
 msgid "Theme"
 msgstr "Тема"
 
-#: forms.py:266
+#: forms.py:277
 msgid "Invalid master password"
 msgstr "Неверный мастер-пароль"
 
-#: forms.py:280
+#: forms.py:291
 #, 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/authors.html:6 templates/boards/authors.html.py:12
 msgid "Authors"
 msgstr "Авторы"
 
 #: templates/boards/authors.html:26
 msgid "Distributed under the"
 msgstr "Распространяется под"
 
 #: templates/boards/authors.html:28
 msgid "license"
 msgstr "лицензией"
 
 #: templates/boards/authors.html:30
 msgid "Repository"
 msgstr "Репозиторий"
 
-#: templates/boards/base.html:16
+#: templates/boards/base.html:13
 msgid "Feed"
 msgstr "Лента"
 
-#: templates/boards/base.html:33
+#: templates/boards/base.html:30
 msgid "All threads"
 msgstr "Все темы"
 
-#: templates/boards/base.html:38
+#: templates/boards/base.html:36
 msgid "Tag management"
-msgstr "Управление тегами"
+msgstr "Управление метками"
 
-#: templates/boards/base.html:41 templates/boards/settings.html:7
+#: templates/boards/base.html:39 templates/boards/settings.html:7
 msgid "Settings"
 msgstr "Настройки"
 
-#: templates/boards/base.html:56
+#: templates/boards/base.html:52
 msgid "Admin"
 msgstr ""
 
-#: templates/boards/base.html:58
+#: templates/boards/base.html:54
 #, python-format
 msgid "Speed: %(ppd)s posts per day"
 msgstr "Скорость: %(ppd)s сообщений в день"
 
-#: templates/boards/base.html:60
+#: templates/boards/base.html:56
 msgid "Up"
 msgstr "Вверх"
 
 #: templates/boards/login.html:6 templates/boards/login.html.py:16
 msgid "Login"
 msgstr "Вход"
 
 #: templates/boards/login.html:19
 msgid "Insert your user id above"
 msgstr "Вставьте свой ID пользователя выше"
 
-#: templates/boards/post.html:21 templates/boards/staticpages/help.html:17
+#: templates/boards/post.html:19 templates/boards/staticpages/help.html:17
 msgid "Quote"
 msgstr "Цитата"
 
-#: templates/boards/post.html:31
+#: templates/boards/post.html:27
 msgid "Open"
 msgstr "Открыть"
 
-#: templates/boards/post.html:33
+#: templates/boards/post.html:29
 msgid "Reply"
 msgstr "Ответ"
 
-#: templates/boards/post.html:40
+#: templates/boards/post.html:36
 msgid "Edit"
 msgstr "Изменить"
 
-#: templates/boards/post.html:42
+#: templates/boards/post.html:39
 msgid "Edit thread"
 msgstr "Изменить тему"
 
-#: templates/boards/post.html:73
+#: templates/boards/post.html:71
 msgid "Replies"
 msgstr "Ответы"
 
-#: templates/boards/post.html:83 templates/boards/thread.html:100
+#: templates/boards/post.html:79 templates/boards/thread.html:89
 #: templates/boards/thread_gallery.html:59
 msgid "messages"
 msgstr "сообщений"
 
-#: templates/boards/post.html:84 templates/boards/thread.html:101
+#: templates/boards/post.html:80 templates/boards/thread.html:90
 #: templates/boards/thread_gallery.html:60
 msgid "images"
 msgstr "изображений"
 
 #: templates/boards/post_admin.html:19
 msgid "Tags:"
-msgstr "Теги:"
+msgstr "Метки:"
 
 #: templates/boards/post_admin.html:30
 msgid "Add tag"
-msgstr "Добавить тег"
+msgstr "Добавить метку"
 
 #: templates/boards/posting_general.html:56
 msgid "Show tag"
-msgstr "Показывать тег"
+msgstr "Показывать метку"
 
 #: templates/boards/posting_general.html:60
 msgid "Hide tag"
-msgstr "Скрывать тег"
+msgstr "Скрывать метку"
 
-#: templates/boards/posting_general.html:79 templates/search/search.html:22
+#: templates/boards/posting_general.html:66
+msgid "Edit tag"
+msgstr "Изменить метку"
+
+#: templates/boards/posting_general.html:82 templates/search/search.html:22
 msgid "Previous page"
 msgstr "Предыдущая страница"
 
-#: templates/boards/posting_general.html:94
+#: templates/boards/posting_general.html:97
 #, python-format
 msgid "Skipped %(count)s replies. Open thread to see all replies."
 msgstr "Пропущено %(count)s ответов. Откройте тред, чтобы увидеть все ответы."
 
-#: templates/boards/posting_general.html:121 templates/search/search.html:33
+#: templates/boards/posting_general.html:124 templates/search/search.html:33
 msgid "Next page"
 msgstr "Следующая страница"
 
-#: templates/boards/posting_general.html:126
+#: templates/boards/posting_general.html:129
 msgid "No threads exist. Create the first one!"
 msgstr "Нет тем. Создайте первую!"
 
-#: templates/boards/posting_general.html:132
+#: templates/boards/posting_general.html:135
 msgid "Create new thread"
 msgstr "Создать новую тему"
 
-#: templates/boards/posting_general.html:137 templates/boards/preview.html:16
-#: templates/boards/thread.html:59
+#: templates/boards/posting_general.html:140 templates/boards/preview.html:16
+#: templates/boards/thread.html:54
 msgid "Post"
 msgstr "Отправить"
 
-#: templates/boards/posting_general.html:142
+#: templates/boards/posting_general.html:145
 msgid "Tags must be delimited by spaces. Text or image is required."
 msgstr ""
-"Теги должны быть разделены пробелами. Текст или изображение обязательны."
+"Метки должны быть разделены пробелами. Текст или изображение обязательны."
 
-#: templates/boards/posting_general.html:145 templates/boards/thread.html:67
+#: templates/boards/posting_general.html:148 templates/boards/thread.html:62
 msgid "Text syntax"
 msgstr "Синтаксис текста"
 
-#: templates/boards/posting_general.html:157
+#: templates/boards/posting_general.html:160
 msgid "Pages:"
 msgstr "Страницы: "
 
 #: templates/boards/preview.html:6 templates/boards/staticpages/help.html:19
 msgid "Preview"
 msgstr "Предпросмотр"
 
 #: templates/boards/rss/post.html:5
 msgid "Post image"
 msgstr "Изображение сообщения"
 
 #: templates/boards/settings.html:15
 msgid "You are moderator."
 msgstr "Вы модератор."
 
 #: templates/boards/settings.html:19
 msgid "Hidden tags:"
-msgstr "Скрытые теги:"
+msgstr "Скрытые метки:"
 
 #: templates/boards/settings.html:26
 msgid "No hidden tags."
-msgstr "Нет скрытых тегов."
+msgstr "Нет скрытых меток."
 
 #: templates/boards/settings.html:35
 msgid "Save"
 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 "Italic text"
 msgstr "Курсивный текст"
 
 #: templates/boards/staticpages/help.html:12
 msgid "Bold text"
 msgstr "Полужирный текст"
 
 #: templates/boards/staticpages/help.html:13
 msgid "Spoiler"
 msgstr "Спойлер"
 
 #: templates/boards/staticpages/help.html:14
 msgid "Link to a post"
 msgstr "Ссылка на сообщение"
 
 #: templates/boards/staticpages/help.html:15
 msgid "Strikethrough text"
 msgstr "Зачеркнутый текст"
 
 #: templates/boards/staticpages/help.html:16
 msgid "Comment"
 msgstr "Комментарий"
 
 #: templates/boards/staticpages/help.html:19
 msgid "You can try pasting the text and previewing the result here:"
 msgstr "Вы можете попробовать вставить текст и проверить результат здесь:"
 
-#: templates/boards/tags.html:22
+#: templates/boards/tags.html:23
 msgid "No tags found."
-msgstr "Теги не найдены."
+msgstr "Метки не найдены."
 
-#: templates/boards/thread.html:21 templates/boards/thread_gallery.html:19
+#: templates/boards/thread.html:19 templates/boards/thread_gallery.html:19
 msgid "Normal mode"
 msgstr "Нормальный режим"
 
-#: templates/boards/thread.html:22 templates/boards/thread_gallery.html:20
+#: templates/boards/thread.html:20 templates/boards/thread_gallery.html:20
 msgid "Gallery mode"
 msgstr "Режим галереи"
 
-#: templates/boards/thread.html:30
+#: templates/boards/thread.html:28
 msgid "posts to bumplimit"
 msgstr "сообщений до бамплимита"
 
-#: templates/boards/thread.html:51
+#: templates/boards/thread.html:46
 msgid "Reply to thread"
 msgstr "Ответить в тему"
 
-#: templates/boards/thread.html:64
+#: templates/boards/thread.html:59
 msgid "Switch mode"
 msgstr "Переключить режим"
 
-#: templates/boards/thread.html:102 templates/boards/thread_gallery.html:61
+#: templates/boards/thread.html:91 templates/boards/thread_gallery.html:61
 msgid "Last update: "
 msgstr "Последнее обновление: "
 
-#~ msgid "Delete"
-#~ msgstr "Удалить"
-
-#~ msgid "Ban IP"
-#~ msgstr "Заблокировать IP"

boards/models/base.py

@@ -1,10 +1,18 b''
 __author__ = 'neko259'
 
 
 class Viewable():
     def __init__(self):
         pass
 
     def get_view(self, *args, **kwargs):
-        """Get an HTML view for a model"""
-        pass
  No newline at end of file
+        """
+        Gets an HTML view for a model
+        """
+        pass
+
+    def get_search_view(self, *args, **kwargs):
+        """
+        Gets an HTML view for search.
+        """
+        pass

boards/models/post.py

@@ -1,438 +1,441 b''
 from datetime import datetime, timedelta, date
 from datetime import time as dtime
 import logging
 import re
 
 from adjacent import Client
 from django.core.cache import cache
 from django.core.urlresolvers import reverse
 from django.db import models, transaction
 from django.db.models import TextField
 from django.template.loader import render_to_string
 from django.utils import timezone
 
 from boards import settings
 from boards.mdx_neboard import bbcode_extended
 from boards.models import PostImage
 from boards.models.base import Viewable
 from boards.models.thread import Thread
 from boards.utils import datetime_to_epoch
 
 
 WS_NOTIFICATION_TYPE_NEW_POST = 'new_post'
 WS_NOTIFICATION_TYPE = 'notification_type'
 
 WS_CHANNEL_THREAD = "thread:"
 
 APP_LABEL_BOARDS = 'boards'
 
 CACHE_KEY_PPD = 'ppd'
 CACHE_KEY_POST_URL = 'post_url'
 
 POSTS_PER_DAY_RANGE = 7
 
 BAN_REASON_AUTO = 'Auto'
 
 IMAGE_THUMB_SIZE = (200, 150)
 
 TITLE_MAX_LENGTH = 200
 
 # TODO This should be removed
 NO_IP = '0.0.0.0'
 
 # TODO Real user agent should be saved instead of this
 UNKNOWN_UA = ''
 
 REGEX_REPLY = re.compile(r'\[post\](\d+)\[/post\]')
 
 PARAMETER_TRUNCATED = 'truncated'
 PARAMETER_TAG = 'tag'
 PARAMETER_OFFSET = 'offset'
 PARAMETER_DIFF_TYPE = 'type'
 PARAMETER_BUMPABLE = 'bumpable'
 PARAMETER_THREAD = 'thread'
 PARAMETER_IS_OPENING = 'is_opening'
 PARAMETER_MODERATOR = 'moderator'
 PARAMETER_POST = 'post'
 PARAMETER_OP_ID = 'opening_post_id'
 PARAMETER_NEED_OPEN_LINK = 'need_open_link'
 
 DIFF_TYPE_HTML = 'html'
 DIFF_TYPE_JSON = 'json'
 
 PREPARSE_PATTERNS = {
     r'>>(\d+)': r'[post]\1[/post]',  # Reflink ">>123"
     r'^>(.+)': r'[quote]\1[/quote]',  # Quote ">text"
     r'^//(.+)': r'[comment]\1[/comment]',  # Comment "//text"
 }
 
 
 class PostManager(models.Manager):
     @transaction.atomic
     def create_post(self, title: str, text: str, image=None, thread=None,
                     ip=NO_IP, tags: list=None):
         """
         Creates new post
         """
 
         if not tags:
             tags = []
 
         posting_time = timezone.now()
         if not thread:
             thread = Thread.objects.create(bump_time=posting_time,
                                            last_edit_time=posting_time)
             new_thread = True
         else:
             new_thread = False
 
         pre_text = self._preparse_text(text)
 
         post = self.create(title=title,
                            text=pre_text,
                            pub_time=posting_time,
                            thread_new=thread,
                            poster_ip=ip,
                            poster_user_agent=UNKNOWN_UA,  # TODO Get UA at
                            # last!
                            last_edit_time=posting_time)
 
         logger = logging.getLogger('boards.post.create')
 
         logger.info('Created post {} by {}'.format(
             post, post.poster_ip))
 
         if image:
             post_image = PostImage.objects.create(image=image)
             post.images.add(post_image)
             logger.info('Created image #{} for post #{}'.format(
                 post_image.id, post.id))
 
         thread.replies.add(post)
         list(map(thread.add_tag, tags))
 
         if new_thread:
             Thread.objects.process_oldest_threads()
         else:
             thread.bump()
             thread.last_edit_time = posting_time
             thread.save()
 
         self.connect_replies(post)
 
         return post
 
     def delete_posts_by_ip(self, ip):
         """
         Deletes all posts of the author with same IP
         """
 
         posts = self.filter(poster_ip=ip)
         for post in posts:
             post.delete()
 
     def  connect_replies(self, post):
         """
         Connects replies to a post to show them as a reflink map
         """
 
         for reply_number in re.finditer(REGEX_REPLY, post.get_raw_text()):
             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.build_refmap()
                 referenced_post.save(update_fields=['refmap', 'last_edit_time'])
 
                 referenced_thread = referenced_post.get_thread()
                 referenced_thread.last_edit_time = post.pub_time
                 referenced_thread.save(update_fields=['last_edit_time'])
 
     def get_posts_per_day(self):
         """
         Gets average count of posts per day for the last 7 days
         """
 
         day_end = date.today()
         day_start = day_end - timedelta(POSTS_PER_DAY_RANGE)
 
         cache_key = CACHE_KEY_PPD + str(day_end)
         ppd = cache.get(cache_key)
         if ppd:
             return ppd
 
         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_period = float(self.filter(
             pub_time__lte=day_time_end,
             pub_time__gte=day_time_start).count())
 
         ppd = posts_per_period / POSTS_PER_DAY_RANGE
 
         cache.set(cache_key, ppd)
         return ppd
 
     def _preparse_text(self, text):
         """
         Preparses text to change patterns like '>>' to a proper bbcode
         tags.
         """
 
         for key, value in PREPARSE_PATTERNS.items():
             text = re.sub(key, value, text, flags=re.MULTILINE)
 
         return text
 
 
 class Post(models.Model, Viewable):
     """A post is a message."""
 
     objects = PostManager()
 
     class Meta:
         app_label = APP_LABEL_BOARDS
         ordering = ('id',)
 
     title = models.CharField(max_length=TITLE_MAX_LENGTH)
     pub_time = models.DateTimeField()
     text = TextField(blank=True, null=True)
     _text_rendered = TextField(blank=True, null=True, editable=False)
 
     images = models.ManyToManyField(PostImage, null=True, blank=True,
                                     related_name='ip+', db_index=True)
 
     poster_ip = models.GenericIPAddressField()
     poster_user_agent = models.TextField()
 
     thread_new = models.ForeignKey('Thread', null=True, default=None,
                                    db_index=True)
     last_edit_time = models.DateTimeField()
 
     referenced_posts = models.ManyToManyField('Post', symmetrical=False,
                                               null=True,
                                               blank=True, related_name='rfp+',
                                               db_index=True)
     refmap = models.TextField(null=True, blank=True)
 
     def __str__(self):
         return 'P#{}/{}'.format(self.id, self.title)
 
     def get_title(self) -> str:
         """
         Gets original post title or part of its text.
         """
 
         title = self.title
         if not title:
             title = self.get_text()
 
         return title
 
     def build_refmap(self) -> None:
         """
         Builds a replies map string from replies list. This is a cache to stop
         the server from recalculating the map on every post show.
         """
         map_string = ''
 
         first = True
         for refpost in self.referenced_posts.all():
             if not first:
                 map_string += ', '
             map_string += '<a href="%s">&gt;&gt;%s</a>' % (refpost.get_url(),
                                                            refpost.id)
             first = False
 
         self.refmap = map_string
 
     def get_sorted_referenced_posts(self):
         return self.refmap
 
     def is_referenced(self) -> bool:
         if not self.refmap:
             return False
         else:
             return len(self.refmap) > 0
 
     def is_opening(self) -> bool:
         """
         Checks if this is an opening post or just a reply.
         """
 
         return self.get_thread().get_opening_post_id() == self.id
 
     @transaction.atomic
     def add_tag(self, tag):
         edit_time = timezone.now()
 
         thread = self.get_thread()
         thread.add_tag(tag)
         self.last_edit_time = edit_time
         self.save(update_fields=['last_edit_time'])
 
         thread.last_edit_time = edit_time
         thread.save(update_fields=['last_edit_time'])
 
     def get_url(self, thread=None):
         """
         Gets full url to the post.
         """
 
         cache_key = CACHE_KEY_POST_URL + str(self.id)
         link = cache.get(cache_key)
 
         if not link:
             if not thread:
                 thread = self.get_thread()
 
             opening_id = thread.get_opening_post_id()
 
             if self.id != opening_id:
                 link = reverse('thread', kwargs={
                     'post_id': opening_id}) + '#' + str(self.id)
             else:
                 link = reverse('thread', kwargs={'post_id': self.id})
 
             cache.set(cache_key, link)
 
         return link
 
     def get_thread(self) -> Thread:
         """
         Gets post's thread.
         """
 
         return self.thread_new
 
     def get_referenced_posts(self):
         return self.referenced_posts.only('id', 'thread_new')
 
     def get_view(self, moderator=False, need_open_link=False,
                  truncated=False, *args, **kwargs):
         """
         Renders post's HTML view. Some of the post params can be passed over
         kwargs for the means of caching (if we view the thread, some params
         are same for every post and don't need to be computed over and over.
         """
 
         is_opening = kwargs.get(PARAMETER_IS_OPENING, self.is_opening())
         thread = kwargs.get(PARAMETER_THREAD, self.get_thread())
         can_bump = kwargs.get(PARAMETER_BUMPABLE, thread.can_bump())
 
         if is_opening:
             opening_post_id = self.id
         else:
             opening_post_id = thread.get_opening_post_id()
 
         return render_to_string('boards/post.html', {
             PARAMETER_POST: self,
             PARAMETER_MODERATOR: moderator,
             PARAMETER_IS_OPENING: is_opening,
             PARAMETER_THREAD: thread,
             PARAMETER_BUMPABLE: can_bump,
             PARAMETER_NEED_OPEN_LINK: need_open_link,
             PARAMETER_TRUNCATED: truncated,
             PARAMETER_OP_ID: opening_post_id,
         })
 
+    def get_search_view(self, *args, **kwargs):
+        return self.get_view(args, kwargs)
+
     def get_first_image(self) -> PostImage:
         return self.images.earliest('id')
 
     def delete(self, using=None):
         """
         Deletes all post images and the post itself. If the post is opening,
         thread with all posts is deleted.
         """
 
         self.images.all().delete()
 
         if self.is_opening():
             self.get_thread().delete()
         else:
             thread = self.get_thread()
             thread.last_edit_time = timezone.now()
             thread.save()
 
         super(Post, self).delete(using)
 
         logging.getLogger('boards.post.delete').info(
             'Deleted post {}'.format(self))
 
     def get_post_data(self, format_type=DIFF_TYPE_JSON, request=None,
                       include_last_update=False):
         """
         Gets post HTML or JSON data that can be rendered on a page or used by
         API.
         """
 
         if format_type == DIFF_TYPE_HTML:
             params = dict()
             params['post'] = self
             if PARAMETER_TRUNCATED in request.GET:
                 params[PARAMETER_TRUNCATED] = True
 
             return render_to_string('boards/api_post.html', params)
         elif format_type == DIFF_TYPE_JSON:
             post_json = {
                 'id': self.id,
                 'title': self.title,
                 'text': self._text_rendered,
                 }
             if self.images.exists():
                 post_image = self.get_first_image()
                 post_json['image'] = post_image.image.url
                 post_json['image_preview'] = post_image.image.url_200x150
             if include_last_update:
                 post_json['bump_time'] = datetime_to_epoch(
                     self.thread_new.bump_time)
             return post_json
 
     def send_to_websocket(self, request, recursive=True):
         """
         Sends post HTML data to the thread web socket.
         """
 
         if not settings.WEBSOCKETS_ENABLED:
             return
 
         client = Client()
 
         thread = self.get_thread()
         thread_id = thread.id
         channel_name = WS_CHANNEL_THREAD + str(thread.get_opening_post_id())
         client.publish(channel_name, {
             WS_NOTIFICATION_TYPE: WS_NOTIFICATION_TYPE_NEW_POST,
         })
         client.send()
 
         logger = logging.getLogger('boards.post.websocket')
 
         logger.info('Sent notification from post #{} to channel {}'.format(
             self.id, channel_name))
 
         if recursive:
             for reply_number in re.finditer(REGEX_REPLY, self.get_raw_text()):
                 post_id = reply_number.group(1)
                 ref_post = Post.objects.filter(id=post_id)[0]
 
                 # If post is in this thread, its thread was already notified.
                 # Otherwise, notify its thread separately.
                 if ref_post.thread_new_id != thread_id:
                     ref_post.send_to_websocket(request, recursive=False)
 
     def save(self, force_insert=False, force_update=False, using=None,
              update_fields=None):
         self._text_rendered = bbcode_extended(self.get_raw_text())
 
         super().save(force_insert, force_update, using, update_fields)
 
     def get_text(self) -> str:
         return self._text_rendered
 
     def get_raw_text(self) -> str:
         return self.text

boards/models/tag.py

@@ -1,82 +1,94 b''
 from django.template.loader import render_to_string
 from django.db import models
 from django.db.models import Count, Sum
 from django.core.urlresolvers import reverse
 
 from boards.models import Thread
 from boards.models.base import Viewable
 
 
 __author__ = 'neko259'
 
 
 class TagManager(models.Manager):
 
     def get_not_empty_tags(self):
         """
         Gets tags that have non-archived threads.
         """
 
         not_empty_tags = list()
-        tags = self.order_by('name')
+        tags = self.order_by('-required', 'name')
         for tag in tags:
             if tag.get_thread_count() > 0:
                 not_empty_tags.append(tag)
 
         return not_empty_tags
 
 
 class Tag(models.Model, Viewable):
     """
     A tag is a text node assigned to the thread. The tag serves as a board
     section. There can be multiple tags for each thread
     """
 
     objects = TagManager()
 
     class Meta:
         app_label = 'boards'
         ordering = ('name',)
 
     name = models.CharField(max_length=100, db_index=True)
+    required = models.BooleanField(default=False)
 
     def __str__(self):
         return self.name
 
     def is_empty(self) -> bool:
         """
         Checks if the tag has some threads.
         """
 
         return self.get_thread_count() == 0
 
     def get_thread_count(self) -> int:
         return self.get_threads().count()
 
     def get_post_count(self, archived=False):
         """
         Gets posts count for the tag's threads.
         """
 
         posts_count = 0
 
         threads = self.get_threads().filter(archived=archived)
         if threads.exists():
             posts_count = threads.annotate(posts_count=Count('replies')) \
                 .aggregate(posts_sum=Sum('posts_count'))['posts_sum']
 
         if not posts_count:
             posts_count = 0
 
         return posts_count
 
     def get_url(self):
         return reverse('tag', kwargs={'tag_name': self.name})
 
-    def get_view(self, *args, **kwargs):
+    def get_threads(self):
+        return Thread.objects.filter(tags__in=[self]).order_by('-bump_time')
+
+    def is_required(self):
+        return self.required
+
+    def get_view(self):
+        #prefix = '##' if self.is_required() else '#'
+        link = '<a class="tag" href="{}">{}</a>'.format(
+                self.get_url(), self.name)
+        if self.is_required():
+            link = '<b>{}</b>'.format(link)
+        return link
+
+    def get_search_view(self, *args, **kwargs):
         return render_to_string('boards/tag.html', {
             'tag': self,
         })
-
-    def get_threads(self):
-        return Thread.objects.filter(tags__in=[self]).order_by('-bump_time')

boards/static/js/thread_update.js

@@ -1,335 +1,333 b''
 /*
  @licstart  The following is the entire license notice for the
  JavaScript code in this page.
 
 
  Copyright (C) 2013-2014  neko259
 
  The JavaScript code in this page is free software: you can
  redistribute it and/or modify it under the terms of the GNU
  General Public License (GNU GPL) as published by the Free Software
  Foundation, either version 3 of the License, or (at your option)
  any later version.  The code is distributed WITHOUT ANY WARRANTY;
  without even the implied warranty of MERCHANTABILITY or FITNESS
  FOR A PARTICULAR PURPOSE.  See the GNU GPL for more details.
 
  As additional permission under GNU GPL version 3 section 7, you
  may distribute non-source (e.g., minimized or compacted) forms of
  that code without the copy of the GNU GPL normally required by
  section 4, provided you include this license notice and a URL
  through which recipients can access the Corresponding Source.
 
  @licend  The above is the entire license notice
  for the JavaScript code in this page.
  */
 
 var wsUser = '';
 
 var loading = false;
 var unreadPosts = 0;
 var documentOriginalTitle = '';
 
 // Thread ID does not change, can be stored one time
 var threadId = $('div.thread').children('.post').first().attr('id');
 
 /**
  * Connect to websocket server and subscribe to thread updates. On any update we
  * request a thread diff.
  *
  * @returns {boolean} true if connected, false otherwise
  */
 function connectWebsocket() {
     var metapanel = $('.metapanel')[0];
 
     var wsHost = metapanel.getAttribute('data-ws-host');
     var wsPort = metapanel.getAttribute('data-ws-port');
 
     if (wsHost.length > 0 && wsPort.length > 0)
     var centrifuge = new Centrifuge({
         "url": 'ws://' + wsHost + ':' + wsPort + "/connection/websocket",
         "project": metapanel.getAttribute('data-ws-project'),
         "user": wsUser,
         "timestamp": metapanel.getAttribute('data-last-update'),
         "token": metapanel.getAttribute('data-ws-token'),
         "debug": false
     });
 
     centrifuge.on('error', function(error_message) {
         console.log("Error connecting to websocket server.");
         return false;
     });
 
     centrifuge.on('connect', function() {
         var channelName = 'thread:' + threadId;
         centrifuge.subscribe(channelName, function(message) {
             getThreadDiff();
         });
 
         // For the case we closed the browser and missed some updates
         getThreadDiff();
         $('#autoupdate').text('[+]');
     });
 
     centrifuge.connect();
 
     return true;
 }
 
 /**
  * Get diff of the posts from the current thread timestamp.
  * This is required if the browser was closed and some post updates were
  * missed.
  */
 function getThreadDiff() {
     var lastUpdateTime = $('.metapanel').attr('data-last-update');
 
     var diffUrl = '/api/diff_thread/' + threadId + '/' + lastUpdateTime + '/';
 
     $.getJSON(diffUrl)
         .success(function(data) {
             var addedPosts = data.added;
 
             for (var i = 0; i < addedPosts.length; i++) {
                 var postText = addedPosts[i];
                 var post = $(postText);
 
                 updatePost(post)
 
                 lastPost = post;
             }
 
             var updatedPosts = data.updated;
 
             for (var i = 0; i < updatedPosts.length; i++) {
                 var postText = updatedPosts[i];
                 var post = $(postText);
 
                 updatePost(post)
             }
 
             // TODO Process removed posts if any
             $('.metapanel').attr('data-last-update', data.last_update);
         })
 }
 
 /**
  * Add or update the post on html page.
  */
 function updatePost(postHtml) {
     // This needs to be set on start because the page is scrolled after posts
     // are added or updated
     var bottom = isPageBottom();
 
     var post = $(postHtml);
 
     var threadBlock = $('div.thread');
 
     var lastUpdate = '';
 
     var postId = post.attr('id');
 
     // If the post already exists, replace it. Otherwise add as a new one.
     var existingPosts = threadBlock.children('.post[id=' + postId + ']');
 
     if (existingPosts.size() > 0) {
         existingPosts.replaceWith(post);
     } else {
         var threadPosts = threadBlock.children('.post');
         var lastPost = threadPosts.last();
 
         post.appendTo(lastPost.parent());
 
         updateBumplimitProgress(1);
         showNewPostsTitle(1);
 
         lastUpdate = post.children('.post-info').first()
             .children('.pub_time').first().text();
 
         if (bottom) {
             scrollToBottom();
         }
     }
 
     processNewPost(post);
     updateMetadataPanel(lastUpdate)
 }
 
 /**
  * Initiate a blinking animation on a node to show it was updated.
  */
 function blink(node) {
     var blinkCount = 2;
 
     var nodeToAnimate = node;
     for (var i = 0; i < blinkCount; i++) {
         nodeToAnimate = nodeToAnimate.fadeTo('fast', 0.5).fadeTo('fast', 1.0);
     }
 }
 
 function isPageBottom() {
     var scroll = $(window).scrollTop() / ($(document).height()
         - $(window).height());
 
     return scroll == 1
 }
 
 function initAutoupdate() {
     return connectWebsocket();
 }
 
 function getReplyCount() {
     return $('.thread').children('.post').length
 }
 
 function getImageCount() {
     return $('.thread').find('img').length
 }
 
 /**
  * Update post count, images count and last update time in the metadata
  * panel.
  */
 function updateMetadataPanel(lastUpdate) {
     var replyCountField = $('#reply-count');
     var imageCountField = $('#image-count');
 
     replyCountField.text(getReplyCount());
     imageCountField.text(getImageCount());
 
     if (lastUpdate !== '') {
         var lastUpdateField = $('#last-update');
         lastUpdateField.text(lastUpdate);
         blink(lastUpdateField);
     }
 
     blink(replyCountField);
     blink(imageCountField);
 }
 
 /**
  * Update bumplimit progress bar
  */
 function updateBumplimitProgress(postDelta) {
     var progressBar = $('#bumplimit_progress');
     if (progressBar) {
         var postsToLimitElement = $('#left_to_limit');
 
         var oldPostsToLimit = parseInt(postsToLimitElement.text());
         var postCount = getReplyCount();
         var bumplimit = postCount - postDelta + oldPostsToLimit;
 
         var newPostsToLimit = bumplimit - postCount;
         if (newPostsToLimit <= 0) {
             $('.bar-bg').remove();
             $('.thread').children('.post').addClass('dead_post');
         } else {
             postsToLimitElement.text(newPostsToLimit);
             progressBar.width((100 - postCount / bumplimit * 100.0) + '%');
         }
     }
 }
 
 /**
  * Show 'new posts' text in the title if the document is not visible to a user
  */
 function showNewPostsTitle(newPostCount) {
     if (document.hidden) {
         if (documentOriginalTitle === '') {
             documentOriginalTitle = document.title;
         }
         unreadPosts = unreadPosts + newPostCount;
         document.title = '[' + unreadPosts + '] ' + documentOriginalTitle;
 
         document.addEventListener('visibilitychange', function() {
             if (documentOriginalTitle !== '') {
                 document.title = documentOriginalTitle;
                 documentOriginalTitle = '';
                 unreadPosts = 0;
             }
 
             document.removeEventListener('visibilitychange', null);
         });
     }
 }
 
 /**
  * Clear all entered values in the form fields
  */
 function resetForm(form) {
     form.find('input:text, input:password, input:file, select, textarea').val('');
     form.find('input:radio, input:checkbox')
              .removeAttr('checked').removeAttr('selected');
     $('.file_wrap').find('.file-thumb').remove();
 }
 
 /**
  * When the form is posted, this method will be run as a callback
  */
 function updateOnPost(response, statusText, xhr, form) {
     var json = $.parseJSON(response);
     var status = json.status;
 
     showAsErrors(form, '');
 
     if (status === 'ok') {
         resetForm(form);
     } else {
         var errors = json.errors;
         for (var i = 0; i < errors.length; i++) {
             var fieldErrors = errors[i];
 
             var error = fieldErrors.errors;
 
             showAsErrors(form, error);
         }
     }
 
     scrollToBottom();
 }
 
 /**
  * Show text in the errors row of the form.
  * @param form
  * @param text
  */
 function showAsErrors(form, text) {
     form.children('.form-errors').remove();
 
     if (text.length > 0) {
         var errorList = $('<div class="form-errors">' + text
             + '<div>');
         errorList.appendTo(form);
     }
 }
 
 /**
  * Run js methods that are usually run on the document, on the new post
  */
 function processNewPost(post) {
     addRefLinkPreview(post[0]);
     highlightCode(post);
     blink(post);
 }
 
 $(document).ready(function(){
-    if ('WebSocket' in window) {
         if (initAutoupdate()) {
             // Post form data over AJAX
             var threadId = $('div.thread').children('.post').first().attr('id');
 
             var form = $('#form');
 
             var options = {
                 beforeSubmit: function(arr, $form, options) {
                     showAsErrors($('form'), gettext('Sending message...'));
                 },
-                success: updateOnPost,
+            success: getThreadDiff,
                 url: '/api/add_post/' + threadId + '/'
             };
 
             form.ajaxForm(options);
 
             resetForm(form);
         }
-    }
 });

boards/templates/boards/base.html

@@ -1,59 +1,60 b''
 {% load staticfiles %}
 {% load i18n %}
 {% load l10n %}
 {% load static from staticfiles %}
 
 <!DOCTYPE html>
 <html>
 <head>
     <link rel="stylesheet" type="text/css" href="{% static 'css/base.css' %}" media="all"/>
     <link rel="stylesheet" type="text/css" href="{% static 'css/3party/highlight.css' %}" media="all"/>
     <link rel="stylesheet" type="text/css" href="{% static theme_css %}" media="all"/>
 
     <link rel="alternate" type="application/rss+xml" href="rss/" title="{% trans 'Feed' %}"/>
 
     <link rel="icon" type="image/png"
         href="{% static 'favicon.png' %}">
 
     <meta name="viewport" content="width=device-width, initial-scale=1"/>
     <meta charset="utf-8"/>
 
     {% block head %}{% endblock %}
 </head>
 <body>
 <script src="{% static 'js/jquery-2.0.1.min.js' %}"></script>
 <script src="{% static 'js/jquery-ui-1.10.3.custom.min.js' %}"></script>
 <script src="{% static 'js/jquery.mousewheel.js' %}"></script>
 <script src="{% url 'js_info_dict' %}"></script>
 
 <div class="navigation_panel header">
     <a class="link" href="{% url 'index' %}">{% trans "All threads" %}</a>
     {% for tag in tags %}
-        <a class="tag" href="{% url 'tag' tag_name=tag.name %}"
-                >#{{ tag.name }}</a>,
+        {% autoescape off %}
+            {{ tag.get_view }}{% if not forloop.last %},{% endif %}
+        {% endautoescape %}
     {% endfor %}
     <a href="{% url 'tags' %}" title="{% trans 'Tag management' %}"
             >[...]</a>,
         <a href="{% url 'search' %}" title="{% trans 'Search' %}">[S]</a>
     <a class="link" href="{% url 'settings' %}">{% trans 'Settings' %}</a>
 </div>
 
 {% block content %}{% endblock %}
 
 <script src="{% static 'js/3party/highlight.min.js' %}"></script>
 <script src="{% static 'js/popup.js' %}"></script>
 <script src="{% static 'js/image.js' %}"></script>
 <script src="{% static 'js/refpopup.js' %}"></script>
 <script src="{% static 'js/main.js' %}"></script>
 
 <div class="navigation_panel footer">
     {% block metapanel %}{% endblock %}
     [<a href="{% url 'admin:index' %}">{% trans 'Admin' %}</a>]
     {% with ppd=posts_per_day|floatformat:2 %}
         {% blocktrans %}Speed: {{ ppd }} posts per day{% endblocktrans %}
     {% endwith %}
     <a class="link" href="#top">{% trans 'Up' %}</a>
 </div>
 
 </body>
 </html>

boards/templates/boards/post.html

@@ -1,90 +1,91 b''
 {% load i18n %}
 {% load board %}
 {% load cache %}
 
 {% get_current_language as LANGUAGE_CODE %}
 
 {% if thread.archived %}
     <div class="post archive_post" id="{{ post.id }}">
 {% elif bumpable %}
     <div class="post" id="{{ post.id }}">
 {% else %}
     <div class="post dead_post" id="{{ post.id }}">
 {% endif %}
 
 <div class="post-info">
     <a class="post_id" href="{% post_object_url post thread=thread %}"
             {% if not truncated and not thread.archived %}
        onclick="javascript:addQuickReply('{{ post.id }}'); return false;"
        title="{% trans 'Quote' %}" {% endif %}>({{ post.id }})</a>
     <span class="title">{{ post.title }}</span>
     <span class="pub_time">{{ post.pub_time }}</span>
     {% if thread.archived %}
         — {{ thread.bump_time }}
     {% endif %}
     {% if is_opening and need_open_link %}
         {% if thread.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 'admin:boards_post_change' post.id %}"
                 >{% trans 'Edit' %}</a>]
             {% if is_opening %}
                 [<a href="{% url 'admin:boards_thread_change' thread.id %}"
                     >{% trans 'Edit thread' %}</a>]
             {% endif %}
         </span>
     {% endif %}
 </div>
 {% if post.images.exists %}
     {% with post.images.all.0 as image %}
         <div class="image">
             <a
                     class="thumb"
                     href="{{ image.image.url }}"><img
                     src="{{ image.image.url_200x150 }}"
                     alt="{{ post.id }}"
                     width="{{ image.pre_width }}"
                     height="{{ image.pre_height }}"
                     data-width="{{ image.width }}"
                     data-height="{{ image.height }}"/>
             </a>
         </div>
     {% endwith %}
 {% endif %}
 <div class="message">
     {% autoescape off %}
         {% if truncated %}
             {{ post.get_text|truncatewords_html:50 }}
         {% else %}
             {{ post.get_text }}
         {% endif %}
     {% endautoescape %}
     {% if post.is_referenced %}
         <div class="refmap">
             {% autoescape off %}
                 {% trans "Replies" %}: {{ post.refmap }}
             {% endautoescape %}
         </div>
     {% endif %}
 </div>
 {% if is_opening %}
     <div class="metadata">
         {% if is_opening and need_open_link %}
             {{ thread.get_reply_count }} {% trans 'messages' %},
             {{ 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 %}
+                {% autoescape off %}
+                    {{ tag.get_view }}{% if not forloop.last %},{% endif %}
+                {% endautoescape %}
             {% endfor %}
         </span>
     </div>
 {% endif %}
 </div>

boards/templates/boards/posting_general.html

@@ -1,197 +1,200 b''
 {% extends "boards/base.html" %}
 
 {% load i18n %}
 {% load cache %}
 {% load board %}
 {% load static %}
 
 {% block head %}
     {% if tag %}
         <title>{{ tag.name }} - {{ site_name }}</title>
     {% else %}
         <title>{{ site_name }}</title>
     {% endif %}
 
     {% if current_page.has_previous %}
         <link rel="prev" href="
             {% if tag %}
                 {% url "tag" tag_name=tag.name page=current_page.previous_page_number %}
             {% elif archived %}
                 {% url "archive" page=current_page.previous_page_number %}
             {% else %}
                 {% url "index" page=current_page.previous_page_number %}
             {% endif %}
         " />
     {% endif %}
     {% if current_page.has_next %}
         <link rel="next" href="
             {% if tag %}
                 {% url "tag" tag_name=tag.name page=current_page.next_page_number %}
             {% elif archived %}
                 {% url "archive" page=current_page.next_page_number %}
             {% else %}
                 {% url "index" page=current_page.next_page_number %}
             {% endif %}
         " />
     {% endif %}
 
 {% endblock %}
 
 {% block content %}
 
     {% get_current_language as LANGUAGE_CODE %}
 
 {% if tag %}
     <div class="tag_info">
         <h2>
             {% if tag in fav_tags %}
                 <a href="{% url 'tag' tag.name %}?method=unsubscribe&next={{ request.path }}"
                    class="fav" rel="nofollow">★</a>
             {% else %}
                 <a href="{% url 'tag' tag.name %}?method=subscribe&next={{ request.path }}"
                    class="not_fav" rel="nofollow">★</a>
             {% endif %}
             {% if tag in hidden_tags %}
                 <a href="{% url 'tag' tag.name %}?method=unhide&next={{ request.path }}"
                    title="{% trans 'Show tag' %}"
                    class="fav" rel="nofollow">H</a>
             {% else %}
                 <a href="{% url 'tag' tag.name %}?method=hide&next={{ request.path }}"
                    title="{% trans 'Hide tag' %}"
                    class="not_fav" rel="nofollow">H</a>
             {% endif %}
-            #{{ tag.name }}
+            {% autoescape off %}
+                {{ tag.get_view }}
+            {% endautoescape %}
+            [<a href="{% url 'admin:boards_tag_change' tag.id %}"$>{% trans 'Edit tag' %}</a>]
         </h2>
     </div>
 {% endif %}
 
     {% if threads %}
         {% if current_page.has_previous %}
             <div class="page_link">
                 <a href="
             {% if tag %}
                 {% url "tag" tag_name=tag.name page=current_page.previous_page_number %}
             {% elif archived %}
                 {% url "archive" page=current_page.previous_page_number %}
             {% else %}
                 {% url "index" page=current_page.previous_page_number %}
             {% endif %}
                 ">{% trans "Previous page" %}</a>
             </div>
         {% endif %}
 
         {% for thread in threads %}
             {% cache 600 thread_short thread.id thread.last_edit_time moderator LANGUAGE_CODE %}
             <div class="thread">
                 {% with can_bump=thread.can_bump %}
                 {% post_view thread.get_opening_post moderator is_opening=True thread=thread can_bump=can_bump truncated=True need_open_link=True %}
                 {% if not thread.archived %}
                     {% with last_replies=thread.get_last_replies %}
                         {% if last_replies %}
                             {% if thread.get_skipped_replies_count %}
                                 <div class="skipped_replies">
                                     <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 last_replies %}
                                     {% post_view post moderator=moderator is_opening=False thread=thread can_bump=can_bump truncated=True %}
                                 {% endfor %}
                             </div>
                         {% endif %}
                     {% endwith %}
                 {% endif %}
                 {% endwith %}
             </div>
             {% endcache %}
         {% endfor %}
 
         {% if current_page.has_next %}
             <div class="page_link">
                 <a href="
             {% if tag %}
                 {% url "tag" tag_name=tag.name page=current_page.next_page_number %}
             {% elif archived %}
                 {% url "archive" page=current_page.next_page_number %}
             {% else %}
                 {% url "index" page=current_page.next_page_number %}
             {% endif %}
                 ">{% trans "Next page" %}</a>
             </div>
         {% endif %}
     {% else %}
         <div class="post">
             {% trans 'No threads exist. Create the first one!' %}</div>
     {% endif %}
 
     <div class="post-form-w">
         <script src="{% static 'js/panel.js' %}"></script>
         <div class="post-form">
             <div class="form-title">{% trans "Create new thread" %}</div>
             <div class="swappable-form-full">
             <form enctype="multipart/form-data" method="post">{% csrf_token %}
                 {{ form.as_div }}
                 <div class="form-submit">
                     <input type="submit" value="{% trans "Post" %}"/>
                 </div>
             </form>
             </div>
             <div>
                 {% trans 'Tags must be delimited by spaces. Text or image is required.' %}
             </div>
             <div><a href="{% url "staticpage" name="help" %}">
                 {% trans 'Text syntax' %}</a></div>
         </div>
     </div>
 
     <script src="{% static 'js/form.js' %}"></script>
 
 {% endblock %}
 
 {% block metapanel %}
 
     <span class="metapanel">
         <b><a href="{% url "authors" %}">{{ site_name }}</a> {{ version }}</b>
         {% trans "Pages:" %}
         <a href="
             {% if tag %}
                 {% url "tag" tag_name=tag.name page=paginator.page_range|first %}
             {% elif archived %}
                 {% url "archive" page=paginator.page_range|first %}
             {% else %}
                 {% url "index" page=paginator.page_range|first %}
             {% endif %}
         ">&lt;&lt;</a>
         [
         {% for page in paginator.center_range %}
             <a
                 {% ifequal page current_page.number %}
                     class="current_page"
                 {% endifequal %}
                 href="
             {% if tag %}
                 {% url "tag" tag_name=tag.name page=page %}
             {% elif archived %}
                 {% url "archive" page=page %}
             {% else %}
                 {% url "index" page=page %}
             {% endif %}
             ">{{ page }}</a>
             {% if not forloop.last %},{% endif %}
         {% endfor %}
         ]
         <a href="
             {% if tag %}
                 {% url "tag" tag_name=tag.name page=paginator.page_range|last %}
             {% elif archived %}
                 {% url "archive" page=paginator.page_range|last %}
             {% else %}
                 {% url "index" page=paginator.page_range|last %}
             {% endif %}
         ">&gt;&gt;</a>
         [<a href="rss/">RSS</a>]
     </span>
 
 {% endblock %}

boards/templates/boards/tag.html

@@ -1,3 +1,5 b''
 <div class="post">
-    <a class="tag" href="{% url 'tag' tag_name=tag.name %}">#{{ tag.name }}</a>
-</div>
  No newline at end of file
+    {% autoescape off %}
+        {{ tag.get_view }}
+    {% endautoescape %}
+</div>

boards/templates/boards/tags.html

@@ -1,27 +1,28 b''
 {% extends "boards/base.html" %}
 
 {% load i18n %}
 {% load cache %}
 
 {% block head %}
     <title>Neboard - {% trans "Tags" %}</title>
 {% endblock %}
 
 {% block content %}
 
 {% cache 600 all_tags_list %}
     <div class="post">
         {% if all_tags %}
             {% for tag in all_tags %}
                 <div class="tag_item">
-                <a class="tag" href="{% url 'tag' tag.name %}">
-                #{{ tag.name }}</a>
+                    {% autoescape off %}
+                        {{ tag.get_view }}
+                    {% endautoescape %}
                 </div>
             {% endfor %}
         {% else %}
             {% trans 'No tags found.' %}
         {% endif %}
     </div>
 {% endcache %}
 
 {% endblock %}

boards/templates/search/search.html

@@ -1,38 +1,38 b''
 {% extends 'boards/base.html' %}
 
 {% load board %}
 {% load i18n %}
 
 {% block content %}
     <div class="post-form-w">
         <div class="post-form">
             <h3>{% trans 'Search' %}</h3>
             <form method="get" action="">
                 {{ form.as_div }}
                 <div class="form-submit">
                     <input type="submit" value="{% trans 'Search' %}">
                 </div>
             </form>
         </div>
     </div>
 
     {% if page %}
         {% if page.has_previous %}
             <div class="page_link">
             <a href="?query={{ query }}&amp;page={{ page.previous_page_number }}">{% trans "Previous page" %}
             </a>
             </div>
         {% endif %}
 
         {% for result in page.object_list %}
-            {{ result.object.get_view }}
+            {{ result.object.get_search_view }}
         {% endfor %}
 
         {% if page.has_next %}
             <div class="page_link">
                 <a href="?query={{ query }}&amp;page={{ page.next_page_number }}">{% trans "Next page" %}
                 </a>
             </div>
         {% endif %}
     {% endif %}
-{% endblock %}
  No newline at end of file
+{% endblock %}

boards/tests/test_forms.py

@@ -1,55 +1,56 b''
 from django.test import TestCase, Client
 import time
 from boards import settings
-from boards.models import Post
+from boards.models import Post, Tag
 import neboard
 
 
 TEST_TAG = 'test_tag'
 
 PAGE_404 = 'boards/404.html'
 
 TEST_TEXT = 'test text'
 
 NEW_THREAD_PAGE = '/'
 THREAD_PAGE_ONE = '/thread/1/'
 HTTP_CODE_REDIRECT = 302
 
 
 class FormTest(TestCase):
     def test_post_validation(self):
         client = Client()
 
         valid_tags = 'tag1 tag_2 тег_3'
         invalid_tags = '$%_356 ---'
+        Tag.objects.create(name='tag1', required=True)
 
         response = client.post(NEW_THREAD_PAGE, {'title': 'test title',
                                                  'text': TEST_TEXT,
                                                  'tags': valid_tags})
         self.assertEqual(response.status_code, HTTP_CODE_REDIRECT,
                          msg='Posting new message failed: got code ' +
                              str(response.status_code))
 
         self.assertEqual(1, Post.objects.count(),
                          msg='No posts were created')
 
         client.post(NEW_THREAD_PAGE, {'text': TEST_TEXT,
                                       'tags': invalid_tags})
         self.assertEqual(1, Post.objects.count(), msg='The validation passed '
                                                       'where it should fail')
 
         # Change posting delay so we don't have to wait for 30 seconds or more
         old_posting_delay = neboard.settings.POSTING_DELAY
         # Wait fot the posting delay or we won't be able to post
         settings.POSTING_DELAY = 1
         time.sleep(neboard.settings.POSTING_DELAY + 1)
         response = client.post(THREAD_PAGE_ONE, {'text': TEST_TEXT,
                                                  'tags': valid_tags})
         self.assertEqual(HTTP_CODE_REDIRECT, response.status_code,
                          msg='Posting new message failed: got code ' +
                              str(response.status_code))
         # Restore posting delay
         settings.POSTING_DELAY = old_posting_delay
 
         self.assertEqual(2, Post.objects.count(),
                          msg='No posts were created')

manage.py

@@ -1,10 +1,10 b''
-#!/usr/bin/env python
+#!/usr/bin/env python3
 import os
 import sys
 
 if __name__ == "__main__":
     os.environ.setdefault("DJANGO_SETTINGS_MODULE", "neboard.settings")
 
     from django.core.management import execute_from_command_line
 
     execute_from_command_line(sys.argv)