Added tree mode for the thread

boards/migrations/0019_auto_20150519_1323.py

@@ -0,0 +1,19 b''
+# -*- coding: utf-8 -*-
+from __future__ import unicode_literals
+
+from django.db import models, migrations
+
+
+class Migration(migrations.Migration):
+
+    dependencies = [
+        ('boards', '0018_banner'),
+    ]
+
+    operations = [
+        migrations.AlterField(
+            model_name='post',
+            name='referenced_posts',
+            field=models.ManyToManyField(db_index=True, to='boards.Post', null=True, related_name='refposts', blank=True),
+        ),
+    ]

boards/templates/boards/thread_tree.html

@@ -0,0 +1,19 b''
+{% extends "boards/thread.html" %}
+
+{% load i18n %}
+{% load static from staticfiles %}
+{% load board %}
+{% load tz %}
+
+{% block thread_content %}
+    {% get_current_language as LANGUAGE_CODE %}
+    {% get_current_timezone as TIME_ZONE %}
+
+    <div class="thread">
+        {% for post in thread.get_top_level_replies %}
+            {% post_view post moderator=moderator reply_link=True mode_tree=True %}
+        {% endfor %}
+    </div>
+
+    <script src="{% static 'js/thread.js' %}"></script>
+{% endblock %}

boards/views/thread/tree.py

@@ -0,0 +1,27 b''
+from boards import settings
+from boards.views.thread import ThreadView
+
+TEMPLATE_TREE = 'boards/thread_tree.html'
+
+CONTEXT_OP = 'opening_post'
+CONTEXT_BUMPABLE = 'bumpable'
+
+
+class TreeThreadView(ThreadView):
+
+    def get_template(self):
+        return TEMPLATE_TREE
+
+    def get_data(self, thread):
+        params = dict()
+
+        bumpable = thread.can_bump()
+        params[CONTEXT_BUMPABLE] = bumpable
+        max_posts = thread.max_posts
+
+        params[CONTEXT_OP] = thread.get_opening_post()
+
+        return params
+
+    def get_mode(self):
+        return 'tree'

boards/locale/ru/LC_MESSAGES/django.po

@@ -1,427 +1,429 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: 2015-05-14 23:38+0300\n"
+"POT-Creation-Date: 2015-05-19 15:44+0300\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"
 
 #: admin.py:22
 msgid "{} posters were banned"
 msgstr ""
 
 #: 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:35
 msgid "Type message here. Use formatting panel for more advanced usage."
 msgstr ""
 "Вводите сообщение сюда. Используйте панель для более сложного форматирования."
 
 #: forms.py:36
 msgid "music images i_dont_like_tags"
 msgstr "музыка картинки теги_не_нужны"
 
 #: forms.py:38
 msgid "Title"
 msgstr "Заголовок"
 
 #: forms.py:39
 msgid "Text"
 msgstr "Текст"
 
 #: forms.py:40
 msgid "Tag"
 msgstr "Метка"
 
 #: forms.py:41 templates/boards/base.html:40 templates/search/search.html:7
 msgid "Search"
 msgstr "Поиск"
 
 #: forms.py:43
 #, python-format
 msgid "Please wait %s seconds before sending message"
 msgstr "Пожалуйста подождите %s секунд перед отправкой сообщения"
 
 #: forms.py:144
 msgid "Image"
 msgstr "Изображение"
 
 #: forms.py:147
 msgid "Image URL"
 msgstr "URL изображения"
 
 #: forms.py:153
 msgid "e-mail"
 msgstr ""
 
 #: forms.py:156
 msgid "Additional threads"
 msgstr "Дополнительные темы"
 
 #: forms.py:167
 #, python-format
 msgid "Title must have less than %s characters"
 msgstr "Заголовок должен иметь меньше %s символов"
 
 #: forms.py:177
 #, python-format
 msgid "Text must have less than %s characters"
 msgstr "Текст должен быть короче %s символов"
 
 #: forms.py:197
 msgid "Invalid URL"
 msgstr "Неверный URL"
 
 #: forms.py:218
 msgid "Invalid additional thread list"
 msgstr "Неверный список дополнительных тем"
 
 #: forms.py:250
 msgid "Either text or image must be entered."
 msgstr "Текст или картинка должны быть введены."
 
 #: forms.py:288
 #, python-format
 msgid "Image must be less than %s bytes"
 msgstr "Изображение должно быть менее %s байт"
 
 #: forms.py:335 templates/boards/all_threads.html:129
 #: templates/boards/rss/post.html:10 templates/boards/tags.html:6
 msgid "Tags"
 msgstr "Метки"
 
 #: forms.py:342
 msgid "Inappropriate characters in tags."
 msgstr "Недопустимые символы в метках."
 
 #: forms.py:356
 msgid "Need at least one of the tags: "
 msgstr "Нужна хотя бы одна из меток: "
 
 #: forms.py:369
 msgid "Theme"
 msgstr "Тема"
 
 #: forms.py:370
 msgid "Image view mode"
 msgstr "Режим просмотра изображений"
 
 #: forms.py:371
 msgid "User name"
 msgstr "Имя пользователя"
 
 #: forms.py:372
 msgid "Time zone"
 msgstr "Часовой пояс"
 
 #: forms.py:378
 msgid "Inappropriate characters."
 msgstr "Недопустимые символы."
 
 #: templates/boards/404.html:6
 msgid "Not found"
 msgstr "Не найдено"
 
 #: templates/boards/404.html:12
 msgid "This page does not exist"
 msgstr "Этой страницы не существует"
 
 #: templates/boards/all_threads.html:35
 msgid "Related message"
 msgstr "Связанное сообщение"
 
 #: templates/boards/all_threads.html:60
 msgid "Edit tag"
 msgstr "Изменить метку"
 
 #: templates/boards/all_threads.html:63
 #, python-format
 msgid "This tag has %(thread_count)s threads and %(post_count)s posts."
 msgstr "С этой меткой есть %(thread_count)s тем и %(post_count)s сообщений."
 
 #: templates/boards/all_threads.html:70 templates/boards/feed.html:30
 #: templates/boards/notifications.html:17 templates/search/search.html:26
 msgid "Previous page"
 msgstr "Предыдущая страница"
 
 #: templates/boards/all_threads.html:84
 #, python-format
 msgid "Skipped %(count)s replies. Open thread to see all replies."
 msgstr "Пропущено %(count)s ответов. Откройте тред, чтобы увидеть все ответы."
 
 #: templates/boards/all_threads.html:102 templates/boards/feed.html:40
 #: templates/boards/notifications.html:27 templates/search/search.html:37
 msgid "Next page"
 msgstr "Следующая страница"
 
 #: templates/boards/all_threads.html:107
 msgid "No threads exist. Create the first one!"
 msgstr "Нет тем. Создайте первую!"
 
 #: templates/boards/all_threads.html:113
 msgid "Create new thread"
 msgstr "Создать новую тему"
 
 #: templates/boards/all_threads.html:118 templates/boards/preview.html:16
-#: templates/boards/thread_normal.html:43
+#: templates/boards/thread_normal.html:38
 msgid "Post"
 msgstr "Отправить"
 
 #: templates/boards/all_threads.html:123
 msgid "Tags must be delimited by spaces. Text or image is required."
 msgstr ""
 "Метки должны быть разделены пробелами. Текст или изображение обязательны."
 
 #: templates/boards/all_threads.html:126
-#: templates/boards/thread_normal.html:48
+#: templates/boards/thread_normal.html:43
 msgid "Text syntax"
 msgstr "Синтаксис текста"
 
 #: templates/boards/all_threads.html:143 templates/boards/feed.html:53
 msgid "Pages:"
 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:14 templates/boards/base.html.py:41
 msgid "Feed"
 msgstr "Лента"
 
 #: templates/boards/base.html:31
 msgid "All threads"
 msgstr "Все темы"
 
 #: templates/boards/base.html:37
 msgid "Add tags"
 msgstr "Добавить метки"
 
 #: templates/boards/base.html:39
 msgid "Tag management"
 msgstr "Управление метками"
 
 #: templates/boards/base.html:39
 msgid "tags"
 msgstr "метки"
 
 #: templates/boards/base.html:40
-#| msgid "Search"
 msgid "search"
 msgstr "поиск"
 
 #: templates/boards/base.html:41 templates/boards/feed.html:11
 msgid "feed"
 msgstr "лента"
 
 #: templates/boards/base.html:44 templates/boards/base.html.py:45
 #: templates/boards/notifications.html:8
 msgid "Notifications"
 msgstr "Уведомления"
 
 #: templates/boards/base.html:52 templates/boards/settings.html:8
 msgid "Settings"
 msgstr "Настройки"
 
 #: templates/boards/base.html:65
 msgid "Admin"
 msgstr "Администрирование"
 
 #: templates/boards/base.html:67
 #, python-format
 msgid "Speed: %(ppd)s posts per day"
 msgstr "Скорость: %(ppd)s сообщений в день"
 
 #: templates/boards/base.html:69
 msgid "Up"
 msgstr "Вверх"
 
 #: templates/boards/feed.html:45
 msgid "No posts exist. Create the first one!"
 msgstr "Нет сообщений. Создайте первое!"
 
 #: templates/boards/post.html:25
 msgid "Open"
 msgstr "Открыть"
 
 #: templates/boards/post.html:27 templates/boards/post.html.py:38
 msgid "Reply"
 msgstr "Ответить"
 
 #: templates/boards/post.html:33
 msgid " in "
 msgstr " в "
 
 #: templates/boards/post.html:43
 msgid "Edit"
 msgstr "Изменить"
 
 #: templates/boards/post.html:45
 msgid "Edit thread"
 msgstr "Изменить тему"
 
-#: templates/boards/post.html:77
+#: templates/boards/post.html:84
 msgid "Replies"
 msgstr "Ответы"
 
-#: templates/boards/post.html:89 templates/boards/thread.html:26
+#: templates/boards/post.html:97 templates/boards/thread.html:37
 msgid "messages"
 msgstr "сообщений"
 
-#: templates/boards/post.html:90 templates/boards/thread.html:27
+#: templates/boards/post.html:98 templates/boards/thread.html:38
 msgid "images"
 msgstr "изображений"
 
 #: templates/boards/preview.html:6 templates/boards/staticpages/help.html:20
 msgid "Preview"
 msgstr "Предпросмотр"
 
 #: templates/boards/rss/post.html:5
 msgid "Post image"
 msgstr "Изображение сообщения"
 
 #: templates/boards/settings.html:16
 msgid "You are moderator."
 msgstr "Вы модератор."
 
 #: templates/boards/settings.html:20
 msgid "Hidden tags:"
 msgstr "Скрытые метки:"
 
 #: templates/boards/settings.html:28
 msgid "No hidden tags."
 msgstr "Нет скрытых меток."
 
 #: templates/boards/settings.html:37
 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:17
 #: templates/boards/staticpages/help.html:18
 msgid "Quote"
 msgstr "Цитата"
 
 #: templates/boards/staticpages/help.html:20
 msgid "You can try pasting the text and previewing the result here:"
 msgstr "Вы можете попробовать вставить текст и проверить результат здесь:"
 
 #: templates/boards/tags.html:21
 msgid "No tags found."
 msgstr "Метки не найдены."
 
 #: templates/boards/tags.html:24
 msgid "All tags"
 msgstr "Все метки"
 
-#: templates/boards/thread.html:28
-msgid "Last update: "
-msgstr "Последнее обновление: "
-
-#: templates/boards/thread_gallery.html:19
-#: templates/boards/thread_normal.html:13
+#: templates/boards/thread.html:15
 msgid "Normal mode"
 msgstr "Нормальный режим"
 
-#: templates/boards/thread_gallery.html:20
-#: templates/boards/thread_normal.html:14
+#: templates/boards/thread.html:16
 msgid "Gallery mode"
 msgstr "Режим галереи"
 
-#: templates/boards/thread_gallery.html:41
+#: templates/boards/thread.html:17
+#| msgid "Normal mode"
+msgid "Tree mode"
+msgstr "Древовидный режим"
+
+#: templates/boards/thread.html:39
+msgid "Last update: "
+msgstr "Последнее обновление: "
+
+#: templates/boards/thread_gallery.html:36
 msgid "No images."
 msgstr "Нет изображений."
 
-#: templates/boards/thread_normal.html:22
+#: templates/boards/thread_normal.html:17
 msgid "posts to bumplimit"
 msgstr "сообщений до бамплимита"
 
-#: templates/boards/thread_normal.html:36
+#: templates/boards/thread_normal.html:31
 msgid "Reply to thread"
 msgstr "Ответить в тему"
 
-#: templates/boards/thread_normal.html:49
+#: templates/boards/thread_normal.html:44
 msgid "Close form"
 msgstr "Закрыть форму"
 
-#: templates/boards/thread_normal.html:63
+#: templates/boards/thread_normal.html:58 templates/boards/thread_tree.html:22
 msgid "Update"
 msgstr "Обновить"
 
 #: templates/search/search.html:17
 msgid "Ok"
 msgstr "Ок"

boards/models/post/__init__.py

@@ -1,411 +1,424 b''
 from datetime import datetime, timedelta, date
 from datetime import time as dtime
 import logging
 import re
 import uuid
 
 from django.core.exceptions import ObjectDoesNotExist
 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 Parser
 from boards.models import PostImage
 from boards.models.base import Viewable
 from boards import utils
 from boards.models.post.export import get_exporter, DIFF_TYPE_JSON
 from boards.models.user import Notification, Ban
 import boards.models.thread
 
 
 APP_LABEL_BOARDS = 'boards'
 
 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'
 
 REGEX_REPLY = re.compile(r'\[post\](\d+)\[/post\]')
 REGEX_NOTIFICATION = re.compile(r'\[user\](\w+)\[/user\]')
 
 PARAMETER_TRUNCATED = 'truncated'
 PARAMETER_TAG = 'tag'
 PARAMETER_OFFSET = 'offset'
 PARAMETER_DIFF_TYPE = 'type'
 PARAMETER_CSS_CLASS = 'css_class'
 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'
 PARAMETER_REPLY_LINK = 'reply_link'
 PARAMETER_NEED_OP_DATA = 'need_op_data'
 
+POST_VIEW_PARAMS = (
+    'need_op_data',
+    'reply_link',
+    'moderator',
+    'need_open_link',
+    'truncated',
+    'mode_tree',
+)
+
 REFMAP_STR = '<a href="{}">&gt;&gt;{}</a>'
 
 
 class PostManager(models.Manager):
     @transaction.atomic
     def create_post(self, title: str, text: str, image=None, thread=None,
             ip=NO_IP, tags: list=None, threads: list=None):
         """
         Creates new post
         """
 
         is_banned = Ban.objects.filter(ip=ip).exists()
 
         # TODO Raise specific exception and catch it in the views
         if is_banned:
             raise Exception("This user is banned")
 
         if not tags:
             tags = []
         if not threads:
             threads = []
 
         posting_time = timezone.now()
         if not thread:
             thread = boards.models.thread.Thread.objects.create(
                 bump_time=posting_time, last_edit_time=posting_time)
             new_thread = True
         else:
             new_thread = False
 
         pre_text = Parser().preparse(text)
 
         post = self.create(title=title,
                            text=pre_text,
                            pub_time=posting_time,
                            poster_ip=ip,
                            thread=thread,
                            last_edit_time=posting_time)
         post.threads.add(thread)
 
         logger = logging.getLogger('boards.post.create')
 
         logger.info('Created post {} by {}'.format(post, post.poster_ip))
 
         if image:
             post.images.add(PostImage.objects.create_with_hash(image))
 
         list(map(thread.add_tag, tags))
 
         if new_thread:
             boards.models.thread.Thread.objects.process_oldest_threads()
         else:
             thread.last_edit_time = posting_time
             thread.bump()
             thread.save()
 
         post.connect_replies()
         post.connect_threads(threads)
         post.connect_notifications()
 
         post.build_url()
 
         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()
 
     @utils.cached_result()
     def get_posts_per_day(self) -> float:
         """
         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)
 
         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
 
         return ppd
     
 
 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, null=True, blank=True)
     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()
 
     # TODO This field can be removed cause UID is used for update now
     last_edit_time = models.DateTimeField()
 
     referenced_posts = models.ManyToManyField('Post', symmetrical=False,
                                               null=True,
-                                              blank=True, related_name='rfp+',
+                                              blank=True, related_name='refposts',
                                               db_index=True)
     refmap = models.TextField(null=True, blank=True)
     threads = models.ManyToManyField('Thread', db_index=True)
     thread = models.ForeignKey('Thread', db_index=True, related_name='pt+')
 
     url = models.TextField()
     uid = models.TextField(db_index=True)
 
     def __str__(self):
         return 'P#{}/{}'.format(self.id, self.title)
 
+    def get_referenced_posts(self):
+        return self.referenced_posts.order_by('pub_time')
+
     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.
         """
 
         post_urls = [REFMAP_STR.format(refpost.get_absolute_url(), refpost.id)
                      for refpost in self.referenced_posts.all()]
 
         self.refmap = ', '.join(post_urls)
 
     def is_referenced(self) -> bool:
         return self.refmap and 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
 
     def get_absolute_url(self):
         return self.url
 
     def get_thread(self):
         return self.thread
 
     def get_threads(self) -> list:
         """
         Gets post's thread.
         """
 
         return self.threads
 
-    def get_view(self, moderator=False, need_open_link=False,
-                 truncated=False, reply_link=False, *args, **kwargs) -> str:
+    def get_view(self, *args, **kwargs) -> str:
         """
         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.
         """
 
         thread = self.get_thread()
         is_opening = kwargs.get(PARAMETER_IS_OPENING, self.is_opening())
 
         if is_opening:
             opening_post_id = self.id
         else:
             opening_post_id = thread.get_opening_post_id()
 
         css_class = 'post'
         if thread.archived:
             css_class += ' archive_post'
         elif not thread.can_bump():
             css_class += ' dead_post'
 
-        return render_to_string('boards/post.html', {
+        params = dict()
+        for param in POST_VIEW_PARAMS:
+            if param in kwargs:
+                params[param] = kwargs[param]
+
+        params.update({
             PARAMETER_POST: self,
-            PARAMETER_MODERATOR: moderator,
             PARAMETER_IS_OPENING: is_opening,
             PARAMETER_THREAD: thread,
             PARAMETER_CSS_CLASS: css_class,
-            PARAMETER_NEED_OPEN_LINK: need_open_link,
-            PARAMETER_TRUNCATED: truncated,
             PARAMETER_OP_ID: opening_post_id,
-            PARAMETER_REPLY_LINK: reply_link,
-            PARAMETER_NEED_OP_DATA: kwargs.get(PARAMETER_NEED_OP_DATA)
         })
 
+        return render_to_string('boards/post.html', params)
+
     def get_search_view(self, *args, **kwargs):
         return self.get_view(need_op_data=True, *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.
         """
 
         for image in self.images.all():
             image_refs_count = Post.objects.filter(images__in=[image]).count()
             if image_refs_count == 1:
                 image.delete()
 
         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) -> str:
         """
         Gets post HTML or JSON data that can be rendered on a page or used by
         API.
         """
 
         return get_exporter(format_type).export(self, request,
                                                 include_last_update)
 
     def notify_clients(self, recursive=True):
         """
         Sends post HTML data to the thread web socket.
         """
 
         if not settings.get_bool('External', 'WebsocketsEnabled'):
             return
 
         thread_ids = list()
         for thread in self.get_threads().all():
             thread_ids.append(thread.id)
 
             thread.notify_clients()
 
         if recursive:
             for reply_number in re.finditer(REGEX_REPLY, self.get_raw_text()):
                 post_id = reply_number.group(1)
 
                 try:
                     ref_post = Post.objects.get(id=post_id)
 
                     if ref_post.get_threads().exclude(id__in=thread_ids).exists():
                         # If post is in this thread, its thread was already notified.
                         # Otherwise, notify its thread separately.
                         ref_post.notify_clients(recursive=False)
                 except ObjectDoesNotExist:
                     pass
 
     def build_url(self):
         thread = self.get_thread()
         opening_id = thread.get_opening_post_id()
         post_url = reverse('thread', kwargs={'post_id': opening_id})
         if self.id != opening_id:
             post_url += '#' + str(self.id)
         self.url = post_url
         self.save(update_fields=['url'])
 
     def save(self, force_insert=False, force_update=False, using=None,
              update_fields=None):
         self._text_rendered = Parser().parse(self.get_raw_text())
 
         self.uid = str(uuid.uuid4())
         if update_fields is not None and 'uid' not in update_fields:
             update_fields += ['uid']
 
         if self.id:
             for thread in self.get_threads().all():
                 if thread.can_bump():
                     thread.update_bump_status(exclude_posts=[self])
                 thread.last_edit_time = self.last_edit_time
 
                 thread.save(update_fields=['last_edit_time', 'bumpable'])
 
         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
 
     def get_absolute_id(self) -> str:
         """
         If the post has many threads, shows its main thread OP id in the post
         ID.
         """
 
         if self.get_threads().count() > 1:
             return '{}/{}'.format(self.get_thread().get_opening_post_id(), self.id)
         else:
             return str(self.id)
 
     def connect_notifications(self):
         for reply_number in re.finditer(REGEX_NOTIFICATION, self.get_raw_text()):
             user_name = reply_number.group(1).lower()
             Notification.objects.get_or_create(name=user_name, post=self)
 
     def connect_replies(self):
         """
         Connects replies to a post to show them as a reflink map
         """
 
         for reply_number in re.finditer(REGEX_REPLY, self.get_raw_text()):
             post_id = reply_number.group(1)
 
             try:
                 referenced_post = Post.objects.get(id=post_id)
 
                 referenced_post.referenced_posts.add(self)
                 referenced_post.last_edit_time = self.pub_time
                 referenced_post.build_refmap()
                 referenced_post.save(update_fields=['refmap', 'last_edit_time'])
             except ObjectDoesNotExist:
                 pass
 
     def connect_threads(self, opening_posts):
         """
         If the referenced post is an OP in another thread,
         make this post multi-thread.
         """
 
         for opening_post in opening_posts:
             threads = opening_post.get_threads().all()
             for thread in threads:
                 if thread.can_bump():
                     thread.update_bump_status()
 
                 thread.last_edit_time = self.last_edit_time
                 thread.save(update_fields=['last_edit_time', 'bumpable'])
 
                 self.threads.add(thread)

boards/models/thread.py

@@ -1,240 +1,243 b''
 import logging
 from adjacent import Client
 
 from django.db.models import Count, Sum
 from django.utils import timezone
 from django.db import models
 
 from boards import settings
 import boards
 from boards.utils import cached_result, datetime_to_epoch
 from boards.models.post import Post
 from boards.models.tag import Tag
 
 
 __author__ = 'neko259'
 
 
 logger = logging.getLogger(__name__)
 
 
 WS_NOTIFICATION_TYPE_NEW_POST = 'new_post'
 WS_NOTIFICATION_TYPE = 'notification_type'
 
 WS_CHANNEL_THREAD = "thread:"
 
 
 class ThreadManager(models.Manager):
     def process_oldest_threads(self):
         """
          Preserves maximum thread count. If there are too many threads,
          archive or delete the old ones.
          """
 
         threads = Thread.objects.filter(archived=False).order_by('-bump_time')
         thread_count = threads.count()
 
         max_thread_count = settings.get_int('Messages', 'MaxThreadCount')
         if thread_count > max_thread_count:
             num_threads_to_delete = thread_count - max_thread_count
             old_threads = threads[thread_count - num_threads_to_delete:]
 
             for thread in old_threads:
                 if settings.get_bool('Storage', 'ArchiveThreads'):
                     self._archive_thread(thread)
                 else:
                     thread.delete()
 
             logger.info('Processed %d old threads' % num_threads_to_delete)
 
     def _archive_thread(self, thread):
         thread.archived = True
         thread.bumpable = False
         thread.last_edit_time = timezone.now()
         thread.update_posts_time()
         thread.save(update_fields=['archived', 'last_edit_time', 'bumpable'])
 
 
 def get_thread_max_posts():
     return settings.get_int('Messages', 'MaxPostsPerThread')
 
 
 class Thread(models.Model):
     objects = ThreadManager()
 
     class Meta:
         app_label = 'boards'
 
     tags = models.ManyToManyField('Tag')
     bump_time = models.DateTimeField(db_index=True)
     last_edit_time = models.DateTimeField()
     archived = models.BooleanField(default=False)
     bumpable = models.BooleanField(default=True)
     max_posts = models.IntegerField(default=get_thread_max_posts)
 
     def get_tags(self) -> list:
         """
         Gets a sorted tag list.
         """
 
         return self.tags.order_by('name')
 
     def bump(self):
         """
         Bumps (moves to up) thread if possible.
         """
 
         if self.can_bump():
             self.bump_time = self.last_edit_time
 
             self.update_bump_status()
 
             logger.info('Bumped thread %d' % self.id)
 
     def has_post_limit(self) -> bool:
         return self.max_posts > 0
 
     def update_bump_status(self, exclude_posts=None):
         if self.has_post_limit() and self.get_reply_count() >= self.max_posts:
             self.bumpable = False
             self.update_posts_time(exclude_posts=exclude_posts)
 
     def _get_cache_key(self):
         return [datetime_to_epoch(self.last_edit_time)]
 
     @cached_result(key_method=_get_cache_key)
     def get_reply_count(self) -> int:
         return self.get_replies().count()
 
     @cached_result(key_method=_get_cache_key)
     def get_images_count(self) -> int:
         return self.get_replies().annotate(images_count=Count(
             'images')).aggregate(Sum('images_count'))['images_count__sum']
 
     def can_bump(self) -> bool:
         """
         Checks if the thread can be bumped by replying to it.
         """
 
         return self.bumpable and not self.archived
 
     def get_last_replies(self) -> list:
         """
         Gets several last replies, not including opening post
         """
 
         last_replies_count = settings.get_int('View', 'LastRepliesCount')
 
         if last_replies_count > 0:
             reply_count = self.get_reply_count()
 
             if reply_count > 0:
                 reply_count_to_show = min(last_replies_count,
                                           reply_count - 1)
                 replies = self.get_replies()
                 last_replies = replies[reply_count - reply_count_to_show:]
 
                 return last_replies
 
     def get_skipped_replies_count(self) -> int:
         """
         Gets number of posts between opening post and last replies.
         """
         reply_count = self.get_reply_count()
         last_replies_count = min(settings.get_int('View', 'LastRepliesCount'),
                                  reply_count - 1)
         return reply_count - last_replies_count - 1
 
     def get_replies(self, view_fields_only=False) -> list:
         """
         Gets sorted thread posts
         """
 
         query = Post.objects.filter(threads__in=[self])
         query = query.order_by('pub_time').prefetch_related('images', 'thread', 'threads')
         if view_fields_only:
             query = query.defer('poster_ip')
         return query.all()
 
+    def get_top_level_replies(self):
+        return self.get_replies().exclude(refposts__threads__in=[self])
+
     def get_replies_with_images(self, view_fields_only=False) -> list:
         """
         Gets replies that have at least one image attached
         """
 
         return self.get_replies(view_fields_only).annotate(images_count=Count(
             'images')).filter(images_count__gt=0)
 
     # TODO Do we still need this?
     def add_tag(self, tag: Tag):
         """
         Connects thread to a tag and tag to a thread
         """
 
         self.tags.add(tag)
 
     def get_opening_post(self, only_id=False) -> Post:
         """
         Gets the first post of the thread
         """
 
         query = self.get_replies().order_by('pub_time')
         if only_id:
             query = query.only('id')
         opening_post = query.first()
 
         return opening_post
 
     @cached_result()
     def get_opening_post_id(self) -> int:
         """
         Gets ID of the first thread post.
         """
 
         return self.get_opening_post(only_id=True).id
 
     def get_pub_time(self):
         """
         Gets opening post's pub time because thread does not have its own one.
         """
 
         return self.get_opening_post().pub_time
 
     def delete(self, using=None):
         """
         Deletes thread with all replies.
         """
 
         for reply in self.get_replies().all():
             reply.delete()
 
         super(Thread, self).delete(using)
 
     def __str__(self):
         return 'T#{}/{}'.format(self.id, self.get_opening_post_id())
 
     def get_tag_url_list(self) -> list:
         return boards.models.Tag.objects.get_tag_url_list(self.get_tags())
 
     def update_posts_time(self, exclude_posts=None):
         for post in self.post_set.all():
             if exclude_posts is not None and post not in exclude_posts:
                 # Manual update is required because uids are generated on save
                 post.last_edit_time = self.last_edit_time
                 post.save(update_fields=['last_edit_time'])
 
                 post.threads.update(last_edit_time=self.last_edit_time)
 
     def notify_clients(self):
         if not settings.get_bool('External', 'WebsocketsEnabled'):
             return
 
         client = Client()
 
         channel_name = WS_CHANNEL_THREAD + str(self.get_opening_post_id())
         client.publish(channel_name, {
             WS_NOTIFICATION_TYPE: WS_NOTIFICATION_TYPE_NEW_POST,
             })
         client.send()
 
     def get_absolute_url(self):
         return self.get_opening_post().get_absolute_url()

boards/static/css/md/base_page.css

@@ -1,526 +1,533 b''
 * {
    text-decoration: none;
    font-weight: inherit;
 }
 
 b, strong {
    font-weight: bold;
 }
 
 html {
     background: #555;
     color: #ffffff;
 }
 
 body {
     margin: 0;
 }
 
 #admin_panel {
     background: #FF0000;
     color: #00FF00
 }
 
 .input_field_error {
     color: #FF0000;
 }
 
 .title {
     font-weight: bold;
     color: #ffcc00;
 }
 
 .link, a {
     color: #afdcec;
 }
 
 .block {
     display: inline-block;
     vertical-align: top;
 }
 
 .tag {
     color: #FFD37D;
 }
 
 .post_id {
     color: #fff380;
 }
 
 .post, .dead_post, .archive_post, #posts-table {
     background: #333;
     padding: 10px;
     clear: left;
     word-wrap: break-word;
     border-top: 1px solid #777;
     border-bottom: 1px solid #777;
 }
 
 .post + .post {
     border-top: none;
 }
 
 .dead_post + .dead_post {
     border-top: none;
 }
 
 .archive_post + .archive_post {
     border-top: none;
 }
 
 .metadata {
     padding-top: 5px;
     margin-top: 10px;
     border-top: solid 1px #666;
     color: #ddd;
 }
 
 .navigation_panel, .tag_info {
     background: #222;
     margin-bottom: 5px;
     margin-top: 5px;
     padding: 10px;
     border-bottom: solid 1px #888;
     border-top: solid 1px #888;
     color: #eee;
 }
 
 .navigation_panel .link:first-child {
     border-right: 1px solid #fff;
     font-weight: bold;
     margin-right: 1ex;
     padding-right: 1ex;
 }
 
 .navigation_panel .right-link {
     border-left: 1px solid #fff;
     border-right: none;
     float: right;
     margin-left: 1ex;
     margin-right: 0;
     padding-left: 1ex;
     padding-right: 0;
 }
 
 .navigation_panel .link {
     font-weight: bold;
 }
 
 .navigation_panel::after, .post::after {
     clear: both;
     content: ".";
     display: block;
     height: 0;
     line-height: 0;
     visibility: hidden;
 }
 
 .header {
     border-bottom: solid 2px #ccc;
     margin-bottom: 5px;
     border-top: none;
     margin-top: 0;
 }
 
 .footer {
     border-top: solid 2px #ccc;
     margin-top: 5px;
     border-bottom: none;
     margin-bottom: 0;
 }
 
 p, .br {
     margin-top: .5em;
     margin-bottom: .5em;
 }
 
 .post-form-w {
     background: #333344;
     border-top: solid 1px #888;
     border-bottom: solid 1px #888;
     color: #fff;
     padding: 10px;
     margin-bottom: 5px;
     margin-top: 5px;
 }
 
 .form-row {
     width: 100%;
     display: table-row;
 }
 
 .form-label {
     padding: .25em 1ex .25em 0;
     vertical-align: top;
     display: table-cell;
 }
 
 .form-input {
     padding: .25em 0;
     width: 100%;
     display: table-cell;
 }
 
 .form-errors {
     font-weight: bolder;
     vertical-align: middle;
     display: table-cell;
 }
 
 .post-form input:not([name="image"]), .post-form textarea, .post-form select {
     background: #333;
     color: #fff;
     border: solid 1px;
     padding: 0;
     font: medium sans-serif;
     width: 100%;
 }
 
 .post-form textarea {
     resize: vertical;
 }
 
 .form-submit {
     display: table;
     margin-bottom: 1ex;
     margin-top: 1ex;
 }
 
 .form-title {
     font-weight: bold;
     font-size: 2ex;
     margin-bottom: 0.5ex;
 }
 
 .post-form input[type="submit"], input[type="submit"] {
     background: #222;
     border: solid 2px #fff;
     color: #fff;
     padding: 0.5ex;
 }
 
 input[type="submit"]:hover {
     background: #060;
 }
 
 blockquote {
     border-left: solid 2px;
     padding-left: 5px;
     color: #B1FB17;
     margin: 0;
 }
 
 .post > .image {
     float: left;
     margin: 0 1ex .5ex 0;
     min-width: 1px;
     text-align: center;
     display: table-row;
 }
 
 .post > .metadata {
     clear: left;
 }
 
 .get {
     font-weight: bold;
     color: #d55;
 }
 
 * {
     text-decoration: none;
 }
 
 .dead_post {
     background-color: #442222;
 }
 
 .archive_post {
     background-color: #000;
 }
 
 .mark_btn {
     border: 1px solid;
     padding: 2px 2ex;
     display: inline-block;
     margin: 0 5px 4px 0;
 }
 
 .mark_btn:hover {
     background: #555;
 }
 
 .quote {
     color: #92cf38;
     font-style: italic;
 }
 
 .multiquote {
     padding: 3px;
     display: inline-block;
     background: #222;
     border-style: solid;
     border-width: 1px 1px 1px 4px;
     font-size: 0.9em;
 }
 
 .spoiler {
     background: black;
     color: black;
     padding: 0 1ex 0 1ex;
 }
 
 .spoiler:hover {
     color: #ddd;
 }
 
 .comment {
     color: #eb2;
 }
 
 a:hover {
     text-decoration: underline;
 }
 
 .last-replies {
     margin-left: 3ex;
     margin-right: 3ex;
     border-left: solid 1px #777;
     border-right: solid 1px #777;
 }
 
 .last-replies > .post:first-child {
     border-top: none;
 }
 
 .thread {
     margin-bottom: 3ex;
     margin-top: 1ex;
 }
 
 .post:target {
     border: solid 2px white;
 }
 
 pre{
     white-space:pre-wrap
 }
 
 li {
     list-style-position: inside;
 }
 
 .fancybox-skin {
     position: relative;
     background-color: #fff;
     color: #ddd;
     text-shadow: none;
 }
 
 .fancybox-image {
     border: 1px solid black;
 }
 
 .image-mode-tab {
     background: #444;
     color: #eee;
     margin-top: 5px;
     padding: 5px;
     border-top: 1px solid #888;
     border-bottom: 1px solid #888;
 }
 
 .image-mode-tab > label {
     margin: 0 1ex;
 }
 
 .image-mode-tab > label > input {
     margin-right: .5ex;
 }
 
 #posts-table {
     margin-top: 5px;
     margin-bottom: 5px;
 }
 
 .tag_info > h2 {
     margin: 0;
 }
 
 .post-info {
     color: #ddd;
     margin-bottom: 1ex;
 }
 
 .moderator_info {
     color: #e99d41;
     float: right;
     font-weight: bold;
     opacity: 0.4;
 }
 
 .moderator_info:hover {
     opacity: 1;
 }
 
 .refmap {
     font-size: 0.9em;
     color: #ccc;
     margin-top: 1em;
 }
 
 .fav {
     color: yellow;
 }
 
 .not_fav {
     color: #ccc;
 }
 
 .role {
     text-decoration: underline;
 }
 
 .form-email {
     display: none;
 }
 
 .bar-value {
     background: rgba(50, 55, 164, 0.45);
     font-size: 0.9em;
     height: 1.5em;
 }
 
 .bar-bg {
     position: relative;
     border-top: solid 1px #888;
     border-bottom: solid 1px #888;
     margin-top: 5px;
     overflow: hidden;
 }
 
 .bar-text {
     padding: 2px;
     position: absolute;
     left: 0;
     top: 0;
 }
 
 .page_link {
     background: #444;
     border-top: solid 1px #888;
     border-bottom: solid 1px #888;
     padding: 5px;
     color: #eee;
     font-size: 2ex;
 }
 
 .skipped_replies {
     padding: 5px;
     margin-left: 3ex;
     margin-right: 3ex;
     border-left: solid 1px #888;
     border-right: solid 1px #888;
     border-bottom: solid 1px #888;
     background: #000;
 }
 
 .current_page {
     padding: 2px;
     background-color: #afdcec;
     color: #000;
 }
 
 .current_mode {
     font-weight: bold;
 }
 
 .gallery_image {
     border: solid 1px;
     padding: 0.5ex;
     margin: 0.5ex;
     text-align: center;
 }
 
 code {
     border: dashed 1px #ccc;
     background: #111;
     padding: 2px;
     font-size: 1.2em;
     display: inline-block;
 }
 
 pre {
     overflow: auto;
 }
 
 .img-full {
     background: #222;
     border: solid 1px white;
 }
 
 .tag_item {
     display: inline-block;
 }
 
 #id_models li {
     list-style: none;
 }
 
 #id_q {
     margin-left: 1ex;
 }
 
 ul {
     padding-left: 0px;
 }
 
 .quote-header {
     border-bottom: 2px solid #ddd;
     margin-bottom: 1ex;
     padding-bottom: .5ex;
     color: #ddd;
     font-size: 1.2em;
 }
 
 /* Reflink preview */
 .post_preview {
     border-left: 1px solid #777;
     border-right: 1px solid #777;
     max-width: 600px;
 }
 
 /* Code highlighter */
 .hljs {
     color: #fff;
     background: #000;
     display: inline-block;
 }
 
 .hljs, .hljs-subst, .hljs-tag .hljs-title, .lisp .hljs-title, .clojure .hljs-built_in, .nginx .hljs-title {
     color: #fff;
 }
 
 #up {
     position: fixed;
     bottom: 5px;
     right: 5px;
     border: 1px solid #777;
     background: #000;
     padding: 4px;
 }
 
 .user-cast {
     border: solid #ffffff 1px;
     padding: .2ex;
     background: #152154;
     color: #fff;
 }
 
 .highlight {
     background-color: #222;
 }
 
 .post-button-form > button:hover {
     text-decoration: underline;
 }
+
+.tree_reply > .post {
+    margin-left: 1ex;
+    margin-top: 1ex;
+    border-left: solid 1px #777;
+    border-right: solid 1px #777;
+}

boards/templates/boards/post.html

@@ -1,95 +1,103 b''
 {% load i18n %}
 {% load board %}
 
 {% get_current_language as LANGUAGE_CODE %}
 
 <div class="{{ css_class }}" id="{{ post.id }}" data-uid="{{ post.uid }}">
     <div class="post-info">
         <a class="post_id" href="{{ post.get_absolute_url }}">({{ post.get_absolute_id }})</a>
         <span class="title">{{ post.title }}</span>
         <span class="pub_time"><time datetime="{{ post.pub_time|date:'c' }}">{{ post.pub_time }}</time></span>
         {% comment %}
             Thread death time needs to be shown only if the thread is alredy archived
             and this is an opening post (thread death time) or a post for popup
             (we don't see OP here so we show the death time in the post itself).
         {% endcomment %}
         {% if thread.archived %}
             {% if is_opening %}
             — <time datetime="{{ thread.bump_time|date:'c' }}">{{ thread.bump_time }}</time>
             {% endif %}
         {% endif %}
         {% if is_opening %}
             {% if 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 %}
         {% else %}
             {% if need_op_data %}
                 {% with thread.get_opening_post as op %}
                     {% trans " in " %}<a href="{{ op.get_absolute_url }}">&gt;&gt;{{ op.id }}</a> <span class="title">{{ op.get_title|striptags|truncatewords:5 }}</span>
                 {% endwith %}
             {% endif %}
         {% endif %}
         {% if reply_link and not thread.archived %}
             <a href="#form" onclick="addQuickReply('{{ post.id }}'); return false;">{% trans 'Reply' %}</a>
         {% 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>
     {% comment %}
         Post images. Currently only 1 image can be posted and shown, but post model
         supports multiple.
     {%  endcomment %}
     {% if post.images.exists %}
         {% with post.images.all.0 as image %}
             {% autoescape off %}
                 {{ image.get_view }}
             {% endautoescape %}
         {% endwith %}
     {% endif %}
     {% comment %}
         Post message (text)
     {% endcomment %}
     <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>
+            {% if mode_tree %}
+                <div class="tree_reply">
+                    {% for refpost in post.get_referenced_posts %}
+                        {% post_view refpost mode_tree=True %}
+                    {% endfor %}
+                </div>
+            {% else %}
+                <div class="refmap">
+                    {% autoescape off %}
+                        {% trans "Replies" %}: {{ post.refmap }}
+                    {% endautoescape %}
+                </div>
+            {% endif %}
         {% endif %}
     </div>
     {% comment %}
         Thread metadata: counters, tags etc
     {% endcomment %}
     {% 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">
                 {% autoescape off %}
                     {{ thread.get_tag_url_list }}
                 {% endautoescape %}
             </span>
         </div>
     {% endif %}
 </div>

boards/templates/boards/thread.html

@@ -1,32 +1,43 b''
 {% extends "boards/base.html" %}
 
 {% load i18n %}
 {% load static from staticfiles %}
 {% load board %}
 {% load tz %}
 
 {% block head %}
     <title>{{ opening_post.get_title|striptags|truncatewords:10 }}
         - {{ site_name }}</title>
 {% endblock %}
 
+{% block content %}
+    <div class="image-mode-tab">
+        <a {% ifequal mode 'normal' %}class="current_mode"{% endifequal %} href="{% url 'thread' opening_post.id %}">{% trans 'Normal mode' %}</a>,
+        <a {% ifequal mode 'gallery' %}class="current_mode"{% endifequal %} href="{% url 'thread_gallery' opening_post.id %}">{% trans 'Gallery mode' %}</a>,
+        <a {% ifequal mode 'tree' %}class="current_mode"{% endifequal %} href="{% url 'thread_tree' opening_post.id %}">{% trans 'Tree mode' %}</a>
+    </div>
+
+    {% block thread_content %}
+    {% endblock %}
+{% endblock %}
+
 {% block metapanel %}
 
     <span class="metapanel"
           data-last-update="{{ last_update }}"
           data-ws-token-time="{{ ws_token_time }}"
           data-ws-token="{{ ws_token }}"
           data-ws-project="{{ ws_project }}"
           data-ws-host="{{ ws_host }}"
           data-ws-port="{{ ws_port }}">
 
         {% block thread_meta_panel %}
         {% endblock %}
 
         <span id="reply-count">{{ thread.get_reply_count }}</span>{% if thread.has_post_limit %}/{{ thread.max_posts }}{% endif %} {% trans 'messages' %},
             <span id="image-count">{{ thread.get_images_count }}</span> {% trans 'images' %}.
             {% trans 'Last update: ' %}<span id="last-update"><time datetime="{{ thread.last_edit_time|date:'c' }}">{{ thread.last_edit_time }}</time></span>
             [<a href="rss/">RSS</a>]
     </span>
 
 {% endblock %}

boards/templates/boards/thread_gallery.html

@@ -1,44 +1,39 b''
 {% extends "boards/thread.html" %}
 
 {% load i18n %}
 {% load static from staticfiles %}
 {% load board %}
 {% load tz %}
 
 {% block head %}
     <meta name="robots" content="noindex">
     <title>{{ thread.get_opening_post.get_title|striptags|truncatewords:10 }}
         - {{ site_name }}</title>
 {% endblock %}
 
-{% block content %}
+{% block thread_content %}
     {% get_current_language as LANGUAGE_CODE %}
     {% get_current_timezone as TIME_ZONE %}
 
-    <div class="image-mode-tab">
-        <a href="{% url 'thread' thread.get_opening_post.id %}">{% trans 'Normal mode' %}</a>,
-        <a class="current_mode" href="{% url 'thread_gallery' thread.get_opening_post.id %}">{% trans 'Gallery mode' %}</a>
-    </div>
-
     <div id="posts-table">
         {% if posts %}
             {% for post in posts %}
                 <div class="gallery_image">
                 {% with post.get_first_image as image %}
                     {% autoescape off %}
                         {{ image.get_view }}
                     {% endautoescape %}
                     <div class="gallery_image_metadata">
                         {{ image.width }}x{{ image.height }}
                         {% image_actions image.image.url request.get_host %}
                         <br />
                         <a href="{{ post.get_absolute_url }}">>>{{ post.id }}</a>
                     </div>
                 {% endwith %}
                 </div>
             {% endfor %}
         {% else %}
             {% trans 'No images.' %}
         {% endif %}
     </div>
 {% endblock %}

boards/templates/boards/thread_normal.html

@@ -1,64 +1,59 b''
 {% extends "boards/thread.html" %}
 
 {% load i18n %}
 {% load static from staticfiles %}
 {% load board %}
 {% load tz %}
 
-{% block content %}
+{% block thread_content %}
     {% get_current_language as LANGUAGE_CODE %}
     {% get_current_timezone as TIME_ZONE %}
 
-    <div class="image-mode-tab">
-        <a class="current_mode" href="{% url 'thread' opening_post.id %}">{% trans 'Normal mode' %}</a>,
-        <a href="{% url 'thread_gallery' opening_post.id %}">{% trans 'Gallery mode' %}</a>
-    </div>
-
     {% if bumpable and thread.has_post_limit %}
         <div class="bar-bg">
             <div class="bar-value" style="width:{{ bumplimit_progress }}%" id="bumplimit_progress">
             </div>
             <div class="bar-text">
                 <span id="left_to_limit">{{ posts_left }}</span> {% trans 'posts to bumplimit' %}
             </div>
         </div>
     {% endif %}
 
     <div class="thread">
         {% for post in thread.get_replies %}
             {% post_view post moderator=moderator reply_link=True %}
         {% endfor %}
     </div>
 
     {% if not thread.archived %}
         <div class="post-form-w">
             <script src="{% static 'js/panel.js' %}"></script>
             <div class="form-title">{% trans "Reply to thread" %} #{{ opening_post.id }}</div>
             <div class="post-form" id="compact-form">
                 <div class="swappable-form-full">
                     <form enctype="multipart/form-data" method="post" id="form">{% csrf_token %}
                         <div class="compact-form-text"></div>
                         {{ form.as_div }}
                         <div class="form-submit">
                             <input type="submit" value="{% trans "Post" %}"/>
                         </div>
                     </form>
                 </div>
                 <div><a href="{% url "staticpage" name="help" %}">
                     {% trans 'Text syntax' %}</a></div>
                 <div><a id="form-close-button" href="#" onClick="resetFormPosition(); return false;">{% trans 'Close form' %}</a></div>
             </div>
         </div>
 
         <script src="{% static 'js/jquery.form.min.js' %}"></script>
     {% endif %}
 
     <script src="{% static 'js/form.js' %}"></script>
     <script src="{% static 'js/thread.js' %}"></script>
     <script src="{% static 'js/thread_update.js' %}"></script>
     <script src="{% static 'js/3party/centrifuge.js' %}"></script>
 {% endblock %}
 
 {% block thread_meta_panel %}
     <button id="autoupdate">{% trans 'Update' %}</button>
 {% endblock %}

boards/urls.py

@@ -1,85 +1,87 b''
 from django.conf.urls import patterns, url
 from django.views.i18n import javascript_catalog
 
 from boards import views
 from boards.rss import AllThreadsFeed, TagThreadsFeed, ThreadPostsFeed
 from boards.views import api, tag_threads, all_threads, \
     settings, all_tags, feed
 from boards.views.authors import AuthorsView
 from boards.views.notifications import NotificationView
 from boards.views.search import BoardSearchView
 from boards.views.static import StaticPageView
 from boards.views.preview import PostPreviewView
 
 
 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'),
 
     # /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>\d+)/$', views.thread.normal.NormalThreadView.as_view(),
+    url(r'^thread/(?P<post_id>\d+)/$', views.thread.NormalThreadView.as_view(),
         name='thread'),
-    url(r'^thread/(?P<post_id>\d+)/mode/gallery/$', views.thread.gallery.GalleryThreadView.as_view(),
+    url(r'^thread/(?P<post_id>\d+)/mode/gallery/$', views.thread.GalleryThreadView.as_view(),
         name='thread_gallery'),
+    url(r'^thread/(?P<post_id>\d+)/mode/tree/$', views.thread.TreeThreadView.as_view(),
+        name='thread_tree'),
     # /feed/
     url(r'^feed/$', views.feed.FeedView.as_view(), name='feed'),
     url(r'^feed/page/(?P<page>\w+)/$', views.feed.FeedView.as_view(),
         name='feed'),
 
     url(r'^settings/$', settings.SettingsView.as_view(), name='settings'),
     url(r'^tags/(?P<query>\w+)?/?$', all_tags.AllTagsView.as_view(), name='tags'),
     url(r'^authors/$', AuthorsView.as_view(), name='authors'),
 
     url(r'^banned/$', views.banned.BannedView.as_view(), name='banned'),
     url(r'^staticpage/(?P<name>\w+)/$', StaticPageView.as_view(),
         name='staticpage'),
 
     # RSS feeds
     url(r'^rss/$', AllThreadsFeed()),
     url(r'^page/(?P<page>\d+)/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>\d+)/rss/$', ThreadPostsFeed()),
 
     # i18n
     url(r'^jsi18n/$', javascript_catalog, js_info_dict,
         name='js_info_dict'),
 
     # API
     url(r'^api/post/(?P<post_id>\d+)/$', api.get_post, name="get_post"),
     url(r'^api/diff_thread$',
         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/notifications/(?P<username>\w+)/$', api.api_get_notifications,
             name='api_notifications'),
 
     # Search
     url(r'^search/$', BoardSearchView.as_view(), name='search'),
 
     # Notifications
     url(r'^notifications/(?P<username>\w+)$', NotificationView.as_view(), name='notifications'),
 
     # Post preview
     url(r'^preview/$', PostPreviewView.as_view(), name='preview')
 
 )

boards/views/thread/__init__.py

@@ -1,3 +1,4 b''
 from boards.views.thread.thread import ThreadView
 from boards.views.thread.normal import NormalThreadView
 from boards.views.thread.gallery import GalleryThreadView
+from boards.views.thread.tree import TreeThreadView

boards/views/thread/gallery.py

@@ -1,19 +1,24 b''
 from boards.views.thread import ThreadView
 
 TEMPLATE_GALLERY = 'boards/thread_gallery.html'
 
 CONTEXT_POSTS = 'posts'
+CONTEXT_OP = 'opening_post'
 
 
 class GalleryThreadView(ThreadView):
 
     def get_template(self):
         return TEMPLATE_GALLERY
 
     def get_data(self, thread):
         params = dict()
 
         params[CONTEXT_POSTS] = thread.get_replies_with_images(
             view_fields_only=True)
+        params[CONTEXT_OP] = thread.get_opening_post()
 
         return params
+
+    def get_mode(self):
+        return 'gallery'

boards/views/thread/normal.py

@@ -1,31 +1,34 b''
 from boards import settings
 from boards.views.thread import ThreadView
 
 TEMPLATE_NORMAL = 'boards/thread_normal.html'
 
 CONTEXT_OP = 'opening_post'
 CONTEXT_BUMPLIMIT_PRG = 'bumplimit_progress'
 CONTEXT_POSTS_LEFT = 'posts_left'
 CONTEXT_BUMPABLE = 'bumpable'
 
 
 class NormalThreadView(ThreadView):
 
     def get_template(self):
         return TEMPLATE_NORMAL
 
+    def get_mode(self):
+        return 'normal'
+
     def get_data(self, thread):
         params = dict()
 
         bumpable = thread.can_bump()
         params[CONTEXT_BUMPABLE] = bumpable
         max_posts = thread.max_posts
         if bumpable and thread.has_post_limit():
             left_posts = max_posts - thread.get_reply_count()
             params[CONTEXT_POSTS_LEFT] = left_posts
             params[CONTEXT_BUMPLIMIT_PRG] = str(
                 float(left_posts) / max_posts * 100)
 
         params[CONTEXT_OP] = thread.get_opening_post()
 
         return params

boards/views/thread/thread.py

@@ -1,131 +1,136 b''
 from django.core.exceptions import ObjectDoesNotExist
 from django.http import Http404
 from django.shortcuts import get_object_or_404, render, redirect
 from django.views.generic.edit import FormMixin
 from django.utils import timezone
 from django.utils.dateformat import format
 
 from boards import utils, settings
 from boards.forms import PostForm, PlainErrorList
 from boards.models import Post
 from boards.views.base import BaseBoardView, CONTEXT_FORM
 from boards.views.posting_mixin import PostMixin
 
 import neboard
 
 
 CONTEXT_LASTUPDATE = "last_update"
 CONTEXT_THREAD = 'thread'
 CONTEXT_WS_TOKEN = 'ws_token'
 CONTEXT_WS_PROJECT = 'ws_project'
 CONTEXT_WS_HOST = 'ws_host'
 CONTEXT_WS_PORT = 'ws_port'
 CONTEXT_WS_TIME = 'ws_token_time'
+CONTEXT_MODE = 'mode'
 
 FORM_TITLE = 'title'
 FORM_TEXT = 'text'
 FORM_IMAGE = 'image'
 FORM_THREADS = 'threads'
 
 
 class ThreadView(BaseBoardView, PostMixin, FormMixin):
 
     def get(self, request, post_id, form: PostForm=None):
         try:
             opening_post = Post.objects.get(id=post_id)
         except ObjectDoesNotExist:
             raise Http404
 
         # If this is not OP, don't show it as it is
         if not opening_post.is_opening():
             return redirect(opening_post.get_thread().get_opening_post()
                 .get_absolute_url())
 
         if not form:
             form = PostForm(error_class=PlainErrorList)
 
         thread_to_show = opening_post.get_thread()
 
         params = dict()
 
         params[CONTEXT_FORM] = form
         params[CONTEXT_LASTUPDATE] = str(thread_to_show.last_edit_time)
         params[CONTEXT_THREAD] = thread_to_show
+        params[CONTEXT_MODE] = self.get_mode()
 
         if settings.get_bool('External', 'WebsocketsEnabled'):
             token_time = format(timezone.now(), u'U')
 
             params[CONTEXT_WS_TIME] = token_time
             params[CONTEXT_WS_TOKEN] = utils.get_websocket_token(
                 timestamp=token_time)
             params[CONTEXT_WS_PROJECT] = neboard.settings.CENTRIFUGE_PROJECT_ID
             params[CONTEXT_WS_HOST] = request.get_host().split(':')[0]
             params[CONTEXT_WS_PORT] = neboard.settings.CENTRIFUGE_PORT
 
         params.update(self.get_data(thread_to_show))
 
         return render(request, self.get_template(), params)
 
     def post(self, request, post_id):
         opening_post = get_object_or_404(Post, id=post_id)
 
         # If this is not OP, don't show it as it is
         if not opening_post.is_opening():
             raise Http404
 
         if not opening_post.get_thread().archived:
             form = PostForm(request.POST, request.FILES,
                             error_class=PlainErrorList)
             form.session = request.session
 
             if form.is_valid():
                 return self.new_post(request, form, opening_post)
             if form.need_to_ban:
                 # Ban user because he is suspected to be a bot
                 self._ban_current_user(request)
 
             return self.get(request, post_id, form)
 
     def new_post(self, request, form: PostForm, opening_post: Post=None,
                  html_response=True):
         """
         Adds a new post (in thread or as a reply).
         """
 
         ip = utils.get_client_ip(request)
 
         data = form.cleaned_data
 
         title = data[FORM_TITLE]
         text = data[FORM_TEXT]
         image = form.get_image()
         threads = data[FORM_THREADS]
 
         text = self._remove_invalid_links(text)
 
         post_thread = opening_post.get_thread()
 
         post = Post.objects.create_post(title=title, text=text, image=image,
                                         thread=post_thread, ip=ip,
                                         threads=threads)
         post.notify_clients()
 
         if html_response:
             if opening_post:
                 return redirect(post.get_absolute_url())
         else:
             return post
 
     def get_data(self, thread):
         """
         Returns context params for the view.
         """
 
         pass
 
     def get_template(self):
         """
         Gets template to show the thread mode on.
         """
 
         pass
+
+    def get_mode(self):
+        pass