Removed multitread posts 'feature'

boards/migrations/0053_auto_20161127_1541.py

@@ -0,0 +1,25 b''
+# -*- coding: utf-8 -*-
+# Generated by Django 1.9.5 on 2016-11-27 13:41
+from __future__ import unicode_literals
+
+from django.db import migrations, models
+import django.db.models.deletion
+
+
+class Migration(migrations.Migration):
+
+    dependencies = [
+        ('boards', '0052_auto_20161120_1344'),
+    ]
+
+    operations = [
+        migrations.RemoveField(
+            model_name='post',
+            name='threads',
+        ),
+        migrations.AlterField(
+            model_name='post',
+            name='thread',
+            field=models.ForeignKey(on_delete=django.db.models.deletion.CASCADE, related_name='replies', to='boards.Thread'),
+        ),
+    ]

boards/admin.py

@@ -1,160 +1,160 b''
 from boards.models.attachment import FILE_TYPES_IMAGE
 from django.contrib import admin
 from django.utils.translation import ugettext_lazy as _
 from django.core.urlresolvers import reverse
 from boards.models import Post, Tag, Ban, Thread, Banner, Attachment, KeyPair, GlobalId
 
 
 @admin.register(Post)
 class PostAdmin(admin.ModelAdmin):
 
     list_display = ('id', 'title', 'text', 'poster_ip', 'linked_images',
             'foreign', 'tags')
     list_filter = ('pub_time',)
     search_fields = ('id', 'title', 'text', 'poster_ip')
     exclude = ('referenced_posts', 'refmap', 'images', 'global_id')
-    readonly_fields = ('poster_ip', 'threads', 'thread', 'linked_images',
+    readonly_fields = ('poster_ip', 'thread', 'linked_images',
             'attachments', 'uid', 'url', 'pub_time', 'opening', 'linked_global_id',
             'version', 'foreign', 'tags')
 
     def ban_poster(self, request, queryset):
         bans = 0
         for post in queryset:
             poster_ip = post.poster_ip
             ban, created = Ban.objects.get_or_create(ip=poster_ip)
             if created:
                 bans += 1
         self.message_user(request, _('{} posters were banned').format(bans))
 
     def ban_latter_with_delete(self, request, queryset):
         bans = 0
         hidden = 0
         for post in queryset:
             poster_ip = post.poster_ip
             ban, created = Ban.objects.get_or_create(ip=poster_ip)
             if created:
                 bans += 1
             posts = Post.objects.filter(poster_ip=poster_ip, id__gte=post.id)
             hidden += posts.count()
             posts.delete()
         self.message_user(request, _('{} posters were banned, {} messages were removed.').format(bans, hidden))
     ban_latter_with_delete.short_description = _('Ban user and delete posts starting from this one and later')
 
     def linked_images(self, obj: Post):
         images = obj.attachments.filter(mimetype__in=FILE_TYPES_IMAGE)
         image_urls = ['<a href="{}"><img src="{}" /></a>'.format(
             reverse('admin:%s_%s_change' % (image._meta.app_label,
                                             image._meta.model_name),
                     args=[image.id]), image.get_thumb_url()) for image in images]
         return ', '.join(image_urls)
     linked_images.allow_tags = True
 
     def linked_global_id(self, obj: Post):
         global_id = obj.global_id
         if global_id is not None:
             return '<a href="{}">{}</a>'.format(
                 reverse('admin:%s_%s_change' % (global_id._meta.app_label,
                                                 global_id._meta.model_name),
                         args=[global_id.id]), str(global_id))
     linked_global_id.allow_tags = True
 
     def tags(self, obj: Post):
         return ', '.join([tag.name for tag in obj.get_tags()])
 
     def save_model(self, request, obj, form, change):
         obj.increment_version()
         obj.save()
         obj.clear_cache()
 
     def foreign(self, obj: Post):
         return obj is not None and obj.global_id is not None and\
                 not obj.global_id.is_local()
 
     actions = ['ban_poster', 'ban_latter_with_delete']
 
 
 @admin.register(Tag)
 class TagAdmin(admin.ModelAdmin):
 
     def thread_count(self, obj: Tag) -> int:
         return obj.get_thread_count()
 
     def display_children(self, obj: Tag):
         return ', '.join([str(child) for child in obj.get_children().all()])
 
     def save_model(self, request, obj, form, change):
         super().save_model(request, obj, form, change)
         for thread in obj.get_threads().all():
             thread.refresh_tags()
     list_display = ('name', 'thread_count', 'display_children')
     search_fields = ('name',)
 
 
 @admin.register(Thread)
 class ThreadAdmin(admin.ModelAdmin):
 
     def title(self, obj: Thread) -> str:
         return obj.get_opening_post().get_title()
 
     def reply_count(self, obj: Thread) -> int:
         return obj.get_reply_count()
 
     def ip(self, obj: Thread):
         return obj.get_opening_post().poster_ip
 
     def display_tags(self, obj: Thread):
         return ', '.join([str(tag) for tag in obj.get_tags().all()])
 
     def op(self, obj: Thread):
         return obj.get_opening_post_id()
 
     # Save parent tags when editing tags
     def save_related(self, request, form, formsets, change):
         super().save_related(request, form, formsets, change)
         form.instance.refresh_tags()
 
     def save_model(self, request, obj, form, change):
         op = obj.get_opening_post()
         op.increment_version()
         op.save(update_fields=['version'])
         obj.save()
         op.clear_cache()
 
     list_display = ('id', 'op', 'title', 'reply_count', 'status', 'ip',
             'display_tags')
     list_filter = ('bump_time', 'status')
     search_fields = ('id', 'title')
     filter_horizontal = ('tags',)
 
 
 @admin.register(KeyPair)
 class KeyPairAdmin(admin.ModelAdmin):
     list_display = ('public_key', 'primary')
     list_filter = ('primary',)
     search_fields = ('public_key',)
 
 
 @admin.register(Ban)
 class BanAdmin(admin.ModelAdmin):
     list_display = ('ip', 'can_read')
     list_filter = ('can_read',)
     search_fields = ('ip',)
 
 
 @admin.register(Banner)
 class BannerAdmin(admin.ModelAdmin):
     list_display = ('title', 'text')
 
 
 @admin.register(Attachment)
 class AttachmentAdmin(admin.ModelAdmin):
     search_fields = ('alias',)
 
 
 @admin.register(GlobalId)
 class GlobalIdAdmin(admin.ModelAdmin):
     def is_linked(self, obj):
         return Post.objects.filter(global_id=obj).exists()
 
     list_display = ('__str__', 'is_linked',)
     readonly_fields = ('content',)

boards/forms.py

@@ -1,500 +1,478 b''
 import hashlib
 import re
 import time
 import logging
 
 import pytz
 
 from django import forms
 from django.core.files.uploadedfile import SimpleUploadedFile
 from django.core.exceptions import ObjectDoesNotExist
 from django.forms.utils import ErrorList
 from django.utils.translation import ugettext_lazy as _, ungettext_lazy
 from django.utils import timezone
 
 from boards.abstracts.settingsmanager import get_settings_manager
 from boards.abstracts.attachment_alias import get_image_by_alias
 from boards.mdx_neboard import formatters
 from boards.models.attachment.downloaders import download
 from boards.models.post import TITLE_MAX_LENGTH
 from boards.models import Tag, Post
 from boards.utils import validate_file_size, get_file_mimetype, \
     FILE_EXTENSION_DELIMITER
 from neboard import settings
 import boards.settings as board_settings
 import neboard
 
 POW_HASH_LENGTH = 16
 POW_LIFE_MINUTES = 5
 
 REGEX_TAGS = re.compile(r'^[\w\s\d]+$', re.UNICODE)
 REGEX_USERNAMES = re.compile(r'^[\w\s\d,]+$', re.UNICODE)
 REGEX_URL = re.compile(r'^(http|https|ftp|magnet):\/\/', re.UNICODE)
 
 VETERAN_POSTING_DELAY = 5
 
 ATTRIBUTE_PLACEHOLDER = 'placeholder'
 ATTRIBUTE_ROWS = 'rows'
 
 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 = _('music images i_dont_like_tags')
 
 LABEL_TITLE = _('Title')
 LABEL_TEXT = _('Text')
 LABEL_TAG = _('Tag')
 LABEL_SEARCH = _('Search')
 
 ERROR_SPEED = 'Please wait %(delay)d second before sending message'
 ERROR_SPEED_PLURAL = 'Please wait %(delay)d seconds before sending message'
 
 TAG_MAX_LENGTH = 20
 
 TEXTAREA_ROWS = 4
 
 TRIPCODE_DELIM = '#'
 
 # TODO Maybe this may be converted into the database table?
 MIMETYPE_EXTENSIONS = {
     'image/jpeg': 'jpeg',
     'image/png': 'png',
     'image/gif': 'gif',
     'video/webm': 'webm',
     'application/pdf': 'pdf',
     'x-diff': 'diff',
     'image/svg+xml': 'svg',
     'application/x-shockwave-flash': 'swf',
     'image/x-ms-bmp': 'bmp',
     'image/bmp': 'bmp',
 }
 
 
 logger = logging.getLogger('boards.forms')
 
 
 def get_timezones():
     timezones = []
     for tz in pytz.common_timezones:
         timezones.append((tz, tz),)
     return timezones
 
 
 class FormatPanel(forms.Textarea):
     """
     Panel for text formatting. Consists of buttons to add different tags to the
     form text area.
     """
 
     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=attrs)
 
         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):
     """
     Form with neboard-specific formatting.
     """
     required_css_class = 'required-field'
 
     def as_div(self):
         """
         Returns this form rendered as HTML <as_div>s.
         """
 
         return self._html_output(
             # TODO Do not show hidden rows in the list here
             normal_row='<div class="form-row">'
                        '<div class="form-label">'
                        '%(label)s'
                        '</div>'
                        '<div class="form-input">'
                        '%(field)s'
                        '</div>'
                        '</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,
                             widget=forms.TextInput(
                                 attrs={ATTRIBUTE_PLACEHOLDER:
                                            'test#tripcode'}))
     text = forms.CharField(
         widget=FormatPanel(attrs={
             ATTRIBUTE_PLACEHOLDER: TEXT_PLACEHOLDER,
             ATTRIBUTE_ROWS: TEXTAREA_ROWS,
         }),
         required=False, label=LABEL_TEXT)
     file = forms.FileField(required=False, label=_('File'),
                              widget=forms.ClearableFileInput(
                                  attrs={'accept': 'file/*'}))
     file_url = forms.CharField(required=False, label=_('File URL'),
                                 widget=forms.TextInput(
                                     attrs={ATTRIBUTE_PLACEHOLDER:
                                                'http://example.com/image.png'}))
 
     # 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'}))
-    threads = forms.CharField(required=False, label=_('Additional threads'),
-            widget=forms.TextInput(attrs={ATTRIBUTE_PLACEHOLDER:
-                '123 456 789'}))
     subscribe = forms.BooleanField(required=False, label=_('Subscribe to thread'))
 
     guess = forms.CharField(widget=forms.HiddenInput(), required=False)
     timestamp = forms.CharField(widget=forms.HiddenInput(), required=False)
     iteration = forms.CharField(widget=forms.HiddenInput(), required=False)
 
     session = None
     need_to_ban = False
     image = None
 
     def _update_file_extension(self, file):
         if file:
             mimetype = get_file_mimetype(file)
             extension = MIMETYPE_EXTENSIONS.get(mimetype)
             if extension:
                 filename = file.name.split(FILE_EXTENSION_DELIMITER, 1)[0]
                 new_filename = filename + FILE_EXTENSION_DELIMITER + extension
 
                 file.name = new_filename
             else:
                 logger = logging.getLogger('boards.forms.extension')
 
                 logger.info('Unrecognized file mimetype: {}'.format(mimetype))
 
     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:
             max_length = board_settings.get_int('Forms', 'MaxTextLength')
             if len(text) > max_length:
                 raise forms.ValidationError(_('Text must have less than %s '
                                               'characters') % str(max_length))
         return text
 
     def clean_file(self):
         file = self.cleaned_data['file']
 
         if file:
             validate_file_size(file.size)
         self._update_file_extension(file)
 
         return file
 
     def clean_file_url(self):
         url = self.cleaned_data['file_url']
 
         file = None
 
         if url:
             try:
                 file = get_image_by_alias(url, self.session)
                 self.image = file
 
                 if file is not None:
                     return
 
                 if file is None:
                     file = self._get_file_from_url(url)
                     if not file:
                         raise forms.ValidationError(_('Invalid URL'))
                     else:
                         validate_file_size(file.size)
                 self._update_file_extension(file)
             except forms.ValidationError as e:
                 # Assume we will get the plain URL instead of a file and save it
                 if REGEX_URL.match(url):
                     logger.info('Error in forms: {}'.format(e))
                     return url
                 else:
                     raise e
 
         return file
 
-    def clean_threads(self):
-        threads_str = self.cleaned_data['threads']
-
-        if len(threads_str) > 0:
-            threads_id_list = threads_str.split(' ')
-
-            threads = list()
-
-            for thread_id in threads_id_list:
-                try:
-                    thread = Post.objects.get(id=int(thread_id))
-                    if not thread.is_opening() or thread.get_thread().is_archived():
-                        raise ObjectDoesNotExist()
-                    threads.append(thread)
-                except (ObjectDoesNotExist, ValueError):
-                    raise forms.ValidationError(_('Invalid additional thread list'))
-
-            return threads
-
     def clean(self):
         cleaned_data = super(PostForm, self).clean()
 
         if cleaned_data['email']:
             if board_settings.get_bool('Forms', 'Autoban'):
                 self.need_to_ban = True
             raise forms.ValidationError('A human cannot enter a hidden field')
 
         if not self.errors:
             self._clean_text_file()
 
         limit_speed = board_settings.get_bool('Forms', 'LimitPostingSpeed')
         limit_first = board_settings.get_bool('Forms', 'LimitFirstPosting')
 
         settings_manager = get_settings_manager(self)
         if not self.errors and limit_speed or (limit_first and not settings_manager.get_setting('confirmed_user')):
             pow_difficulty = board_settings.get_int('Forms', 'PowDifficulty')
             if pow_difficulty > 0:
                 # PoW-based
                 if cleaned_data['timestamp'] \
                         and cleaned_data['iteration'] and cleaned_data['guess'] \
                         and not settings_manager.get_setting('confirmed_user'):
                     self._validate_hash(cleaned_data['timestamp'], cleaned_data['iteration'], cleaned_data['guess'], cleaned_data['text'])
             else:
                 # Time-based
                 self._validate_posting_speed()
             settings_manager.set_setting('confirmed_user', True)
 
         return cleaned_data
 
     def get_file(self):
         """
         Gets file from form or URL.
         """
 
         file = self.cleaned_data['file']
         if type(self.cleaned_data['file_url']) is not str:
             file_url = self.cleaned_data['file_url']
         else:
             file_url = None
         return file or file_url
 
     def get_file_url(self):
         if not self.get_file():
             return self.cleaned_data['file_url']
 
     def get_tripcode(self):
         title = self.cleaned_data['title']
         if title is not None and TRIPCODE_DELIM in title:
             code = title.split(TRIPCODE_DELIM, maxsplit=1)[1] + neboard.settings.SECRET_KEY
             tripcode = hashlib.md5(code.encode()).hexdigest()
         else:
             tripcode = ''
         return tripcode
 
     def get_title(self):
         title = self.cleaned_data['title']
         if title is not None and TRIPCODE_DELIM in title:
             return title.split(TRIPCODE_DELIM, maxsplit=1)[0]
         else:
             return title
 
     def get_images(self):
         if self.image:
             return [self.image]
         else:
             return []
 
     def is_subscribe(self):
         return self.cleaned_data['subscribe']
 
     def _clean_text_file(self):
         text = self.cleaned_data.get('text')
         file = self.get_file()
         file_url = self.get_file_url()
         images = self.get_images()
 
         if (not text) and (not file) and (not file_url) and len(images) == 0:
             error_message = _('Either text or file must be entered.')
             self._errors['text'] = self.error_class([error_message])
 
     def _validate_posting_speed(self):
         can_post = True
 
         posting_delay = board_settings.get_int('Forms', 'PostingDelay')
 
         if board_settings.get_bool('Forms', 'LimitPostingSpeed'):
             now = time.time()
 
             current_delay = 0
 
             if LAST_POST_TIME not in self.session:
                 self.session[LAST_POST_TIME] = now
 
                 need_delay = True
             else:
                 last_post_time = self.session.get(LAST_POST_TIME)
                 current_delay = int(now - last_post_time)
 
                 need_delay = current_delay < posting_delay
 
             if need_delay:
                 delay = posting_delay - current_delay
                 error_message = ungettext_lazy(ERROR_SPEED, ERROR_SPEED_PLURAL,
                                                delay) % {'delay': delay}
                 self._errors['text'] = self.error_class([error_message])
 
                 can_post = False
 
             if can_post:
                 self.session[LAST_POST_TIME] = now
 
     def _get_file_from_url(self, url: str) -> SimpleUploadedFile:
         """
         Gets an file file from URL.
         """
 
         try:
             return download(url)
         except forms.ValidationError as e:
             raise e
         except Exception as e:
             raise forms.ValidationError(e)
 
     def _validate_hash(self, timestamp: str, iteration: str, guess: str, message: str):
         post_time = timezone.datetime.fromtimestamp(
             int(timestamp[:-3]), tz=timezone.get_current_timezone())
 
         payload = timestamp + message.replace('\r\n', '\n')
         difficulty = board_settings.get_int('Forms', 'PowDifficulty')
         target = str(int(2 ** (POW_HASH_LENGTH * 3) / difficulty))
         if len(target) < POW_HASH_LENGTH:
             target = '0' * (POW_HASH_LENGTH - len(target)) + target
 
         computed_guess = hashlib.sha256((payload + iteration).encode())\
                              .hexdigest()[0:POW_HASH_LENGTH]
         if guess != computed_guess or guess > target:
             self._errors['text'] = self.error_class(
                 [_('Invalid PoW.')])
 
 
 
 class ThreadForm(PostForm):
 
     tags = forms.CharField(
         widget=forms.TextInput(attrs={ATTRIBUTE_PLACEHOLDER: TAGS_PLACEHOLDER}),
         max_length=100, label=_('Tags'), required=True)
     monochrome = forms.BooleanField(label=_('Monochrome'), required=False)
 
     def clean_tags(self):
         tags = self.cleaned_data['tags'].strip()
 
         if not tags or not REGEX_TAGS.match(tags):
             raise forms.ValidationError(
                 _('Inappropriate characters in tags.'))
 
         default_tag_name = board_settings.get('Forms', 'DefaultTag')\
                 .strip().lower()
 
         required_tag_exists = False
         tag_set = set()
         for tag_string in tags.split():
             if tag_string.strip().lower() == default_tag_name:
                 required_tag_exists = True
                 tag, created = Tag.objects.get_or_create(
                         name=tag_string.strip().lower(), required=True)
             else:
                 tag, created = Tag.objects.get_or_create(
                         name=tag_string.strip().lower())
             tag_set.add(tag)
 
             # If this is a new tag, don't check for its parents because nobody
             # added them yet
             if not created:
                 tag_set |= set(tag.get_all_parents())
 
         for tag in tag_set:
             if tag.required:
                 required_tag_exists = True
                 break
 
         # Use default tag if no section exists
         if not required_tag_exists:
             default_tag, created = Tag.objects.get_or_create(
                     name=default_tag_name, required=True)
             tag_set.add(default_tag)
 
         return tag_set
 
     def clean(self):
         cleaned_data = super(ThreadForm, self).clean()
 
         return cleaned_data
 
     def is_monochrome(self):
         return self.cleaned_data['monochrome']
 
 
 class SettingsForm(NeboardForm):
 
     theme = forms.ChoiceField(choices=settings.THEMES, label=_('Theme'))
     image_viewer = forms.ChoiceField(choices=settings.IMAGE_VIEWERS, label=_('Image view mode'))
     username = forms.CharField(label=_('User name'), required=False)
     timezone = forms.ChoiceField(choices=get_timezones(), label=_('Time zone'))
 
     def clean_username(self):
         username = self.cleaned_data['username']
 
         if username and not REGEX_USERNAMES.match(username):
             raise forms.ValidationError(_('Inappropriate characters.'))
 
         return username
 
 
 class SearchForm(NeboardForm):
     query = forms.CharField(max_length=500, label=LABEL_SEARCH, required=False)

boards/models/post/__init__.py

@@ -1,409 +1,393 b''
 import uuid
 import hashlib
 import re
 
 from boards import settings
 from boards.abstracts.tripcode import Tripcode
 from boards.models import Attachment, KeyPair, GlobalId
 from boards.models.attachment import FILE_TYPES_IMAGE
 from boards.models.base import Viewable
 from boards.models.post.export import get_exporter, DIFF_TYPE_JSON
 from boards.models.post.manager import PostManager, NO_IP
 from boards.utils import datetime_to_epoch
 from django.core.exceptions import ObjectDoesNotExist
 from django.core.urlresolvers import reverse
 from django.db import models
 from django.db.models import TextField, QuerySet, F
 from django.template.defaultfilters import truncatewords, striptags
 from django.template.loader import render_to_string
 
 CSS_CLS_HIDDEN_POST = 'hidden_post'
 CSS_CLS_DEAD_POST = 'dead_post'
 CSS_CLS_ARCHIVE_POST = 'archive_post'
 CSS_CLS_POST = 'post'
 CSS_CLS_MONOCHROME = 'monochrome'
 
 TITLE_MAX_WORDS = 10
 
 APP_LABEL_BOARDS = 'boards'
 
 BAN_REASON_AUTO = 'Auto'
 
 TITLE_MAX_LENGTH = 200
 
 REGEX_REPLY = re.compile(r'\[post\](\d+)\[/post\]')
 REGEX_GLOBAL_REPLY = re.compile(r'\[post\](\w+)::([^:]+)::(\d+)\[/post\]')
 REGEX_URL = re.compile(r'https?\://[a-zA-Z0-9\-\.]+\.[a-zA-Z]{2,3}(/\S*)?')
 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_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',
     'need_open_link',
     'truncated',
     'mode_tree',
     'perms',
     'tree_depth',
 )
 
 
 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(db_index=True)
     text = TextField(blank=True, null=True)
     _text_rendered = TextField(blank=True, null=True, editable=False)
 
     attachments = models.ManyToManyField(Attachment, null=True, blank=True,
                                          related_name='attachment_posts')
 
     poster_ip = models.GenericIPAddressField()
 
     # Used for cache and threads updating
     last_edit_time = models.DateTimeField()
 
     referenced_posts = models.ManyToManyField('Post', symmetrical=False,
                                               null=True,
                                               blank=True, related_name='refposts',
                                               db_index=True)
     refmap = models.TextField(null=True, blank=True)
-    threads = models.ManyToManyField('Thread', db_index=True,
-                                     related_name='multi_replies')
-    thread = models.ForeignKey('Thread', db_index=True, related_name='pt+')
+    thread = models.ForeignKey('Thread', db_index=True, related_name='replies')
 
     url = models.TextField()
     uid = models.TextField(db_index=True)
 
     # Global ID with author key. If the message was downloaded from another
     # server, this indicates the server.
     global_id = models.OneToOneField(GlobalId, null=True, blank=True,
                                      on_delete=models.CASCADE)
 
     tripcode = models.CharField(max_length=50, blank=True, default='')
     opening = models.BooleanField(db_index=True)
     hidden = models.BooleanField(default=False)
     version = models.IntegerField(default=1)
 
     def __str__(self):
         return 'P#{}/{}'.format(self.id, self.get_title())
 
     def get_title(self) -> str:
         return self.title
 
     def get_title_or_text(self):
         title = self.get_title()
         if not title:
             title = truncatewords(striptags(self.get_text()), TITLE_MAX_WORDS)
 
         return title
 
     def build_refmap(self, excluded_ids=None) -> 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.
         """
 
         replies = self.referenced_posts
         if excluded_ids is not None:
             replies = replies.exclude(id__in=excluded_ids)
         else:
             replies = replies.all()
 
         post_urls = [refpost.get_link_view() for refpost in replies]
 
         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.opening
 
     def get_absolute_url(self, thread=None):
         # Url is cached only for the "main" thread. When getting url
         # for other threads, do it manually.
         return self.url
 
     def get_thread(self):
         return self.thread
 
     def get_thread_id(self):
         return self.thread_id
 
     def get_threads(self) -> QuerySet:
         """
         Gets post's thread.
         """
 
         return self.threads
 
     def _get_cache_key(self):
         return [datetime_to_epoch(self.last_edit_time)]
 
     def get_view_params(self, *args, **kwargs):
         """
         Gets the parameters required for viewing the post based on the arguments
         given and the post itself.
         """
         thread = kwargs.get('thread') or self.get_thread()
 
         css_classes = [CSS_CLS_POST]
         if thread.is_archived():
             css_classes.append(CSS_CLS_ARCHIVE_POST)
         elif not thread.can_bump():
             css_classes.append(CSS_CLS_DEAD_POST)
         if self.is_hidden():
             css_classes.append(CSS_CLS_HIDDEN_POST)
         if thread.is_monochrome():
             css_classes.append(CSS_CLS_MONOCHROME)
 
         params = dict()
         for param in POST_VIEW_PARAMS:
             if param in kwargs:
                 params[param] = kwargs[param]
 
         params.update({
             PARAMETER_POST: self,
             PARAMETER_IS_OPENING: self.is_opening(),
             PARAMETER_THREAD: thread,
             PARAMETER_CSS_CLASS: ' '.join(css_classes),
         })
 
         return params
 
     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.
         """
         params = self.get_view_params(*args, **kwargs)
 
         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) -> Attachment:
         return self.attachments.filter(mimetype__in=FILE_TYPES_IMAGE).earliest('id')
 
     def set_global_id(self, key_pair=None):
         """
         Sets global id based on the given key pair. If no key pair is given,
         default one is used.
         """
 
         if key_pair:
             key = key_pair
         else:
             try:
                 key = KeyPair.objects.get(primary=True)
             except KeyPair.DoesNotExist:
                 # Do not update the global id because there is no key defined
                 return
         global_id = GlobalId(key_type=key.key_type,
                              key=key.public_key,
                              local_id=self.id)
         global_id.save()
 
         self.global_id = global_id
 
         self.save(update_fields=['global_id'])
 
     def get_pub_time_str(self):
         return str(self.pub_time)
 
     def get_replied_ids(self):
         """
         Gets ID list of the posts that this post replies.
         """
 
         raw_text = self.get_raw_text()
 
         local_replied = REGEX_REPLY.findall(raw_text)
         global_replied = []
         for match in REGEX_GLOBAL_REPLY.findall(raw_text):
             key_type = match[0]
             key = match[1]
             local_id = match[2]
 
             try:
                 global_id = GlobalId.objects.get(key_type=key_type,
                                                  key=key, local_id=local_id)
                 for post in Post.objects.filter(global_id=global_id).only('id'):
                     global_replied.append(post.id)
             except GlobalId.DoesNotExist:
                 pass
         return local_replied + global_replied
 
     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()
+        self.get_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 ref_post.get_thread().id not in thread_ids:
                         # 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):
         opening = self.is_opening()
         opening_id = self.id if opening else self.get_thread().get_opening_post_id()
         url = reverse('thread', kwargs={'post_id': opening_id})
         if not opening:
             url += '#' + str(self.id)
 
         return url
 
     def save(self, force_insert=False, force_update=False, using=None,
              update_fields=None):
         new_post = self.id is None
 
         self.uid = str(uuid.uuid4())
         if update_fields is not None and 'uid' not in update_fields:
             update_fields += ['uid']
 
         if not new_post:
-            for thread in self.get_threads().all():
+            thread = self.get_thread()
+            if thread:
                 thread.last_edit_time = self.last_edit_time
-
                 thread.save(update_fields=['last_edit_time', 'status'])
 
         super().save(force_insert, force_update, using, update_fields)
 
         if new_post:
             self.url = self._build_url()
             super().save(update_fields=['url'])
 
     def get_text(self) -> str:
         return self._text_rendered
 
     def get_raw_text(self) -> str:
         return self.text
 
     def get_sync_text(self) -> str:
         """
         Returns text applicable for sync. It has absolute post reflinks.
         """
 
         replacements = dict()
         for post_id in REGEX_REPLY.findall(self.get_raw_text()):
             try:
                 absolute_post_id = str(Post.objects.get(id=post_id).global_id)
                 replacements[post_id] = absolute_post_id
             except Post.DoesNotExist:
                 pass
 
         text = self.get_raw_text() or ''
         for key in replacements:
             text = text.replace('[post]{}[/post]'.format(key),
                                 '[post]{}[/post]'.format(replacements[key]))
         text = text.replace('\r\n', '\n').replace('\r', '\n')
 
         return text
 
-    def connect_threads(self, opening_posts):
-        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', 'status'])
-            self.threads.add(opening_post.get_thread())
-
     def get_tripcode(self):
         if self.tripcode:
             return Tripcode(self.tripcode)
 
     def get_link_view(self):
         """
         Gets view of a reflink to the post.
         """
         result = '<a href="{}">&gt;&gt;{}</a>'.format(self.get_absolute_url(),
                                                       self.id)
         if self.is_opening():
             result = '<b>{}</b>'.format(result)
 
         return result
 
     def is_hidden(self) -> bool:
         return self.hidden
 
     def set_hidden(self, hidden):
         self.hidden = hidden
 
     def increment_version(self):
         self.version = F('version') + 1
 
     def clear_cache(self):
         """
         Clears sync data (content cache, signatures etc).
         """
         global_id = self.global_id
         if global_id is not None and global_id.is_local()\
                 and global_id.content is not None:
             global_id.clear_cache()
 
     def get_tags(self):
         return self.get_thread().get_tags()
 
     def get_ip_color(self):
         return hashlib.md5(self.poster_ip.encode()).hexdigest()[:6]
 
     def has_ip(self):
         return self.poster_ip != NO_IP
 

boards/models/post/manager.py

@@ -1,196 +1,190 b''
 import logging
 
 from datetime import datetime, timedelta, date
 from datetime import time as dtime
 
 from boards.abstracts.exceptions import BannedException, ArchiveException
 from django.db import models, transaction
 from django.utils import timezone
 from django.dispatch import Signal
 
 import boards
 
 from boards.models.user import Ban
 from boards.mdx_neboard import Parser
 from boards.models import Attachment
 from boards import utils
 
 __author__ = 'neko259'
 
 POSTS_PER_DAY_RANGE = 7
 NO_IP = '0.0.0.0'
 
 
 post_import_deps = Signal()
 
 
 class PostManager(models.Manager):
     @transaction.atomic
     def create_post(self, title: str, text: str, file=None, thread=None,
-                    ip=NO_IP, tags: list=None, opening_posts: list=None,
+                    ip=NO_IP, tags: list=None,
                     tripcode='', monochrome=False, images=[],
                     file_url=None):
         """
         Creates new post
         """
 
         if thread is not None and thread.is_archived():
             raise ArchiveException('Cannot post into an archived thread')
 
         if not utils.is_anonymous_mode():
             is_banned = Ban.objects.filter(ip=ip).exists()
         else:
             is_banned = False
 
         if is_banned:
             raise BannedException("This user is banned")
 
         if not tags:
             tags = []
-        if not opening_posts:
-            opening_posts = []
 
         posting_time = timezone.now()
         new_thread = False
         if not thread:
             thread = boards.models.thread.Thread.objects.create(
                 bump_time=posting_time, last_edit_time=posting_time,
-                    monochrome=monochrome)
+                monochrome=monochrome)
             list(map(thread.tags.add, tags))
             new_thread = True
 
         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,
                            tripcode=tripcode,
                            opening=new_thread)
-        post.threads.add(thread)
 
         logger = logging.getLogger('boards.post.create')
 
         logger.info('Created post [{}] with text [{}] by {}'.format(post,
             post.get_text(),post.poster_ip))
 
         if file:
             self._add_file_to_post(file, post)
         for image in images:
             post.attachments.add(image)
         if file_url:
             post.attachments.add(Attachment.objects.create_from_url(file_url))
 
-        post.connect_threads(opening_posts)
         post.set_global_id()
 
         # Thread needs to be bumped only when the post is already created
         if not new_thread:
             thread.last_edit_time = posting_time
             thread.bump()
             thread.save()
 
         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
 
     def get_post_per_days(self, days) -> int:
         day_end = date.today() + timedelta(1)
         day_start = day_end - timedelta(days)
 
         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())
 
         return self.filter(
             pub_time__lte=day_time_end,
             pub_time__gte=day_time_start).count()
 
 
     @transaction.atomic
     def import_post(self, title: str, text: str, pub_time: str, global_id,
                     opening_post=None, tags=list(), files=list(),
                     tripcode=None, version=1):
         is_opening = opening_post is None
         if is_opening:
             thread = boards.models.thread.Thread.objects.create(
                 bump_time=pub_time, last_edit_time=pub_time)
             list(map(thread.tags.add, tags))
         else:
             thread = opening_post.get_thread()
 
         post = self.create(title=title,
                            text=text,
                            pub_time=pub_time,
                            poster_ip=NO_IP,
                            last_edit_time=pub_time,
                            global_id=global_id,
                            opening=is_opening,
                            thread=thread,
                            tripcode=tripcode,
                            version=version)
 
         for file in files:
             self._add_file_to_post(file, post)
 
-        post.threads.add(thread)
-
         url_to_post = '[post]{}[/post]'.format(str(global_id))
         replies = self.filter(text__contains=url_to_post)
         for reply in replies:
             post_import_deps.send(reply)
 
     @transaction.atomic
     def update_post(self, post, title: str, text: str, pub_time: str,
                     tags=list(), files=list(), tripcode=None, version=1):
         post.title = title
         post.text = text
         post.pub_time = pub_time
         post.tripcode = tripcode
         post.version = version
         post.save()
 
         post.clear_cache()
 
         post.attachments.clear()
         for file in files:
             self._add_file_to_post(file, post)
 
         thread = post.get_thread()
         thread.tags.clear()
         list(map(thread.tags.add, tags))
 
     def _add_file_to_post(self, file, post):
         post.attachments.add(Attachment.objects.create_with_hash(file))

boards/models/tag.py

@@ -1,150 +1,150 b''
 import hashlib
 from boards.models.attachment import FILE_TYPES_IMAGE
 from django.template.loader import render_to_string
 from django.db import models
 from django.db.models import Count
 from django.core.urlresolvers import reverse
 
 from boards.models import Attachment
 from boards.models.base import Viewable
 from boards.models.thread import STATUS_ACTIVE, STATUS_BUMPLIMIT, STATUS_ARCHIVE
 from boards.utils import cached_result
 import boards
 
 __author__ = 'neko259'
 
 
 RELATED_TAGS_COUNT = 5
 
 
 class TagManager(models.Manager):
 
     def get_not_empty_tags(self):
         """
         Gets tags that have non-archived threads.
         """
 
         return self.annotate(num_threads=Count('thread_tags')).filter(num_threads__gt=0)\
             .order_by('-required', 'name')
 
     def get_tag_url_list(self, tags: list) -> str:
         """
         Gets a comma-separated list of tag links.
         """
 
         return ', '.join([tag.get_view() for tag in 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, unique=True)
     required = models.BooleanField(default=False, db_index=True)
     description = models.TextField(blank=True)
 
     parent = models.ForeignKey('Tag', null=True, blank=True,
             related_name='children')
 
     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, status=None) -> int:
         threads = self.get_threads()
         if status is not None:
             threads = threads.filter(status=status)
         return threads.count()
 
     def get_active_thread_count(self) -> int:
         return self.get_thread_count(status=STATUS_ACTIVE)
 
     def get_bumplimit_thread_count(self) -> int:
         return self.get_thread_count(status=STATUS_BUMPLIMIT)
 
     def get_archived_thread_count(self) -> int:
         return self.get_thread_count(status=STATUS_ARCHIVE)
 
     def get_absolute_url(self):
         return reverse('tag', kwargs={'tag_name': self.name})
 
     def get_threads(self):
         return self.thread_tags.order_by('-bump_time')
 
     def is_required(self):
         return self.required
 
     def get_view(self):
         link = '<a class="tag" href="{}">{}</a>'.format(
             self.get_absolute_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,
         })
 
     @cached_result()
     def get_post_count(self):
-        return self.get_threads().aggregate(num_posts=Count('multi_replies'))['num_posts']
+        return self.get_threads().aggregate(num_posts=Count('replies'))['num_posts']
 
     def get_description(self):
         return self.description
 
     def get_random_image_post(self, status=[STATUS_ACTIVE, STATUS_BUMPLIMIT]):
         posts = boards.models.Post.objects.filter(attachments__mimetype__in=FILE_TYPES_IMAGE)\
             .annotate(images_count=Count(
-            'attachments')).filter(images_count__gt=0, threads__tags__in=[self])
+            'attachments')).filter(images_count__gt=0, thread__tags__in=[self])
         if status is not None:
             posts = posts.filter(thread__status__in=status)
         return posts.order_by('?').first()
 
     def get_first_letter(self):
         return self.name and self.name[0] or ''
 
     def get_related_tags(self):
         return set(Tag.objects.filter(thread_tags__in=self.get_threads()).exclude(
             id=self.id).order_by('?')[:RELATED_TAGS_COUNT])
 
     @cached_result()
     def get_color(self):
         """
         Gets color hashed from the tag name.
         """
         return hashlib.md5(self.name.encode()).hexdigest()[:6]
 
     def get_parent(self):
         return self.parent
 
     def get_all_parents(self):
         parents = list()
         parent = self.get_parent()
         if parent and parent not in parents:
             parents.insert(0, parent)
             parents = parent.get_all_parents() + parents
 
         return parents
 
     def get_children(self):
         return self.children
 
     def get_images(self):
         return Attachment.objects.filter(
             attachment_posts__thread__tags__in=[self]).filter(
             mimetype__in=FILE_TYPES_IMAGE).order_by('-attachment_posts__pub_time')
  No newline at end of file

boards/models/thread.py

@@ -1,327 +1,327 b''
 import logging
 from adjacent import Client
 from datetime import timedelta
 
 
 from django.db.models import Count, Sum, QuerySet, Q
 from django.utils import timezone
 from django.db import models, transaction
 
 from boards.models.attachment import FILE_TYPES_IMAGE
 from boards.models import STATUS_BUMPLIMIT, STATUS_ACTIVE, STATUS_ARCHIVE
 
 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
 
 FAV_THREAD_NO_UPDATES = -1
 
 
 __author__ = 'neko259'
 
 
 logger = logging.getLogger(__name__)
 
 
 WS_NOTIFICATION_TYPE_NEW_POST = 'new_post'
 WS_NOTIFICATION_TYPE = 'notification_type'
 
 WS_CHANNEL_THREAD = "thread:"
 
 STATUS_CHOICES = (
         (STATUS_ACTIVE, STATUS_ACTIVE),
         (STATUS_BUMPLIMIT, STATUS_BUMPLIMIT),
         (STATUS_ARCHIVE, STATUS_ARCHIVE),
 )
 
 
 class ThreadManager(models.Manager):
     def process_old_threads(self):
         """
          Preserves maximum thread count. If there are too many threads,
          archive or delete the old ones.
          """
         old_time_delta = settings.get_int('Messages', 'ThreadArchiveDays')
         old_time = timezone.now() - timedelta(days=old_time_delta)
         old_ops = Post.objects.filter(opening=True, pub_time__lte=old_time).exclude(thread__status=STATUS_ARCHIVE)
 
         for op in old_ops:
             thread = op.get_thread()
             if settings.get_bool('Storage', 'ArchiveThreads'):
                 self._archive_thread(thread)
             else:
                 thread.delete()
             logger.info('Processed old thread {}'.format(thread))
 
 
     def _archive_thread(self, thread):
         thread.status = STATUS_ARCHIVE
         thread.last_edit_time = timezone.now()
         thread.update_posts_time()
         thread.save(update_fields=['last_edit_time', 'status'])
 
     def get_new_posts(self, datas):
         query = None
         # TODO Use classes instead of dicts
         for data in datas:
             if data['last_id'] != FAV_THREAD_NO_UPDATES:
                 q = (Q(id=data['op'].get_thread_id())
                      & Q(multi_replies__id__gt=data['last_id']))
                 if query is None:
                     query = q
                 else:
                     query = query | q
         if query is not None:
             return self.filter(query).annotate(
                 new_post_count=Count('multi_replies'))
 
     def get_new_post_count(self, datas):
         new_posts = self.get_new_posts(datas)
         return new_posts.aggregate(total_count=Count('multi_replies'))\
                 ['total_count'] if new_posts else 0
 
 
 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', related_name='thread_tags')
     bump_time = models.DateTimeField(db_index=True)
     last_edit_time = models.DateTimeField()
     max_posts = models.IntegerField(default=get_thread_max_posts)
     status = models.CharField(max_length=50, default=STATUS_ACTIVE,
             choices=STATUS_CHOICES, db_index=True)
     monochrome = models.BooleanField(default=False)
 
     def get_tags(self) -> QuerySet:
         """
         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.status = STATUS_BUMPLIMIT
             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().filter(
             attachments__mimetype__in=FILE_TYPES_IMAGE)\
             .annotate(images_count=Count(
             'attachments')).aggregate(Sum('images_count'))['images_count__sum'] or 0
 
     def can_bump(self) -> bool:
         """
         Checks if the thread can be bumped by replying to it.
         """
 
         return self.get_status() == STATUS_ACTIVE
 
     def get_last_replies(self) -> QuerySet:
         """
         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
 
     # TODO Remove argument, it is not used
     def get_replies(self, view_fields_only=True) -> QuerySet:
         """
         Gets sorted thread posts
         """
-        query = self.multi_replies.order_by('pub_time').prefetch_related(
-            'thread', 'attachments')
+        query = self.replies.order_by('pub_time').prefetch_related(
+            'attachments')
         return query
 
     def get_viewable_replies(self) -> QuerySet:
         """
         Gets replies with only fields that are used for viewing.
         """
         return self.get_replies().defer('text', 'last_edit_time', 'version')
 
     def get_top_level_replies(self) -> QuerySet:
         return self.get_replies().exclude(refposts__threads__in=[self])
 
     def get_replies_with_images(self, view_fields_only=False) -> QuerySet:
         """
         Gets replies that have at least one image attached
         """
         return self.get_replies(view_fields_only).filter(
             attachments__mimetype__in=FILE_TYPES_IMAGE).annotate(images_count=Count(
             'attachments')).filter(images_count__gt=0)
 
     def get_opening_post(self, only_id=False) -> Post:
         """
         Gets the first post of the thread
         """
 
         query = self.get_replies().filter(opening=True)
         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 __str__(self):
         return 'T#{}'.format(self.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):
         last_edit_time = self.last_edit_time
 
         for post in self.multi_replies.all():
             if exclude_posts is None or post not in exclude_posts:
                 # Manual update is required because uids are generated on save
                 post.last_edit_time = last_edit_time
                 post.save(update_fields=['last_edit_time'])
 
                 post.get_threads().update(last_edit_time=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()
 
     def get_required_tags(self):
         return self.get_tags().filter(required=True)
 
     def get_replies_newer(self, post_id):
         return self.get_replies().filter(id__gt=post_id)
 
     def is_archived(self):
         return self.get_status() == STATUS_ARCHIVE
 
     def get_status(self):
         return self.status
 
     def is_monochrome(self):
         return self.monochrome
 
     # If tags have parent, add them to the tag list
     @transaction.atomic
     def refresh_tags(self):
         for tag in self.get_tags().all():
             parents = tag.get_all_parents()
             if len(parents) > 0:
                 self.tags.add(*parents)
 
     def get_reply_tree(self):
         replies = self.get_replies().prefetch_related('refposts')
         tree = []
         for reply in replies:
             parents = reply.refposts.all()
 
             found_parent = False
             searching_for_index = False
 
             if len(parents) > 0:
                 index = 0
                 parent_depth = 0
 
                 indexes_to_insert = []
 
                 for depth, element in tree:
                     index += 1
 
                     # If this element is next after parent on the same level,
                     # insert child before it
                     if searching_for_index and depth <= parent_depth:
                         indexes_to_insert.append((index - 1, parent_depth))
                         searching_for_index = False
 
                     if element in parents:
                         found_parent = True
                         searching_for_index = True
                         parent_depth = depth
 
             if not found_parent:
                 tree.append((0, reply))
             else:
                 if searching_for_index:
                     tree.append((parent_depth + 1, reply))
 
                 offset = 0
                 for last_index, parent_depth in indexes_to_insert:
                     tree.insert(last_index + offset, (parent_depth + 1, reply))
                     offset += 1
 
         return tree

boards/templates/boards/thread_normal.html

@@ -1,81 +1,81 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 id="quote-button">{% trans 'Quote' %}</div>
 
     <div class="tag_info">
         <h2>
             <form action="{% url 'thread' opening_post.id %}" method="post" class="post-button-form">
                 {% csrf_token %}
                 {% if is_favorite %}
                     <button name="method" value="unsubscribe" class="fav">★</button>
                 {% else %}
                     <button name="method" value="subscribe" class="not_fav">★</button>
                 {% endif %}
             </form>
             {{ opening_post.get_title_or_text }}
         </h2>
     </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_viewable_replies %}
-            {% post_view post reply_link=True %}
+            {% post_view post reply_link=True thread=thread %}
         {% endfor %}
     </div>
 
     {% if not thread.is_archived %}
         <div class="post-form-w">
             <script src="{% static 'js/panel.js' %}"></script>
             <div class="form-title">{% trans "Reply to thread" %} #{{ opening_post.id }}<span class="reply-to-message"> {% trans "to message " %} #<span id="reply-to-message-id"></span></span></div>
             <div class="post-form" id="compact-form" data-hasher="{% static 'js/3party/sha256.js' %}"
                        data-pow-script="{% static 'js/proof_of_work.js' %}">
                 <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" %}"/>
                             <button id="preview-button" type="button" onclick="return false;">{% trans 'Preview' %}</button>
                             <button id="file-source-button" type="button" onclick="return false;">{% trans 'Change file source' %}</button>
                         </div>
                     </form>
                 </div>
                 <div id="preview-text"></div>
                 <div>
                     {% with size=max_file_size|filesizeformat %}
                         {% blocktrans %}Max file size is {{ size }}.{% endblocktrans %}
                     {% endwith %}
                 </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/form.js' %}"></script>
         <script src="{% static 'js/jquery.form.min.js' %}"></script>
         <script src="{% static 'js/3party/jquery.blockUI.js' %}"></script>
         <script src="{% static 'js/thread.js' %}"></script>
         <script src="{% static 'js/thread_update.js' %}"></script>
     {% endif %}
 
     <script src="{% static 'js/3party/centrifuge.js' %}"></script>
 {% endblock %}

boards/views/all_threads.py

@@ -1,186 +1,186 b''
 from django.core.urlresolvers import reverse
 from django.core.files import File
 from django.core.files.temp import NamedTemporaryFile
 from django.core.paginator import EmptyPage
 from django.db import transaction
 from django.http import Http404
 from django.shortcuts import render, redirect
 from django.utils.decorators import method_decorator
 from django.views.decorators.csrf import csrf_protect
 
 from boards import utils, settings
 from boards.abstracts.paginator import get_paginator
 from boards.abstracts.settingsmanager import get_settings_manager,\
         SETTING_ONLY_FAVORITES
 from boards.forms import ThreadForm, PlainErrorList
 from boards.models import Post, Thread, Ban
 from boards.views.banned import BannedView
 from boards.views.base import BaseBoardView, CONTEXT_FORM
 from boards.views.posting_mixin import PostMixin
 from boards.views.mixins import FileUploadMixin, PaginatedMixin,\
         DispatcherMixin, PARAMETER_METHOD
 
 FORM_TAGS = 'tags'
 FORM_TEXT = 'text'
 FORM_TITLE = 'title'
 FORM_IMAGE = 'image'
 FORM_THREADS = 'threads'
 
 TAG_DELIMITER = ' '
 
 PARAMETER_CURRENT_PAGE = 'current_page'
 PARAMETER_PAGINATOR = 'paginator'
 PARAMETER_THREADS = 'threads'
 PARAMETER_ADDITIONAL = 'additional_params'
 PARAMETER_MAX_FILE_SIZE = 'max_file_size'
 PARAMETER_RSS_URL = 'rss_url'
 
 TEMPLATE = 'boards/all_threads.html'
 DEFAULT_PAGE = 1
 
 
 class AllThreadsView(PostMixin, FileUploadMixin, BaseBoardView, PaginatedMixin, DispatcherMixin):
 
     def __init__(self):
         self.settings_manager = None
         super(AllThreadsView, self).__init__()
 
     @method_decorator(csrf_protect)
     def get(self, request, form: ThreadForm=None):
         page = request.GET.get('page', DEFAULT_PAGE)
 
         params = self.get_context_data(request=request)
 
         if not form:
             form = ThreadForm(error_class=PlainErrorList)
 
         self.settings_manager = get_settings_manager(request)
 
         threads = self.get_threads()
 
         order = request.GET.get('order', 'bump')
         if order == 'bump':
             threads = threads.order_by('-bump_time')
         else:
-            threads = threads.filter(multi_replies__opening=True).order_by('-multi_replies__pub_time')
+            threads = threads.filter(replies__opening=True)\
+                .order_by('-replies__pub_time')
         filter = request.GET.get('filter')
         threads = threads.distinct()
 
         paginator = get_paginator(threads,
                                   settings.get_int('View', 'ThreadsPerPage'))
         paginator.current_page = int(page)
 
         try:
             threads = paginator.page(page).object_list
         except EmptyPage:
             raise Http404()
 
         params[PARAMETER_THREADS] = threads
         params[CONTEXT_FORM] = form
         params[PARAMETER_MAX_FILE_SIZE] = self.get_max_upload_size()
         params[PARAMETER_RSS_URL] = self.get_rss_url()
 
         paginator.set_url(self.get_reverse_url(), request.GET.dict())
         self.get_page_context(paginator, params, page)
 
         return render(request, TEMPLATE, params)
 
     @method_decorator(csrf_protect)
     def post(self, request):
         if PARAMETER_METHOD in request.POST:
             self.dispatch_method(request)
 
             return redirect('index')  # FIXME Different for different modes
 
         form = ThreadForm(request.POST, request.FILES,
                           error_class=PlainErrorList)
         form.session = request.session
 
         if form.is_valid():
             return self.create_thread(request, form)
         if form.need_to_ban:
             # Ban user because he is suspected to be a bot
             self._ban_current_user(request)
 
         return self.get(request, form)
 
     def get_page_context(self, paginator, params, page):
         """
         Get pagination context variables
         """
 
         params[PARAMETER_PAGINATOR] = paginator
         current_page = paginator.page(int(page))
         params[PARAMETER_CURRENT_PAGE] = current_page
         self.set_page_urls(paginator, params)
 
     def get_reverse_url(self):
         return reverse('index')
 
     @transaction.atomic
     def create_thread(self, request, form: ThreadForm, html_response=True):
         """
         Creates a new thread with an opening post.
         """
 
         ip = utils.get_client_ip(request)
         is_banned = Ban.objects.filter(ip=ip).exists()
 
         if is_banned:
             if html_response:
                 return redirect(BannedView().as_view())
             else:
                 return
 
         data = form.cleaned_data
 
         title = form.get_title()
         text = data[FORM_TEXT]
         file = form.get_file()
         file_url = form.get_file_url()
-        threads = data[FORM_THREADS]
         images = form.get_images()
 
         text = self._remove_invalid_links(text)
 
         tags = data[FORM_TAGS]
         monochrome = form.is_monochrome()
 
         post = Post.objects.create_post(title=title, text=text, file=file,
-                                        ip=ip, tags=tags, opening_posts=threads,
+                                        ip=ip, tags=tags,
                                         tripcode=form.get_tripcode(),
                                         monochrome=monochrome, images=images,
                                         file_url = file_url)
 
         # This is required to update the threads to which posts we have replied
         # when creating this one
         post.notify_clients()
 
         if form.is_subscribe():
             settings_manager = get_settings_manager(request)
             settings_manager.add_or_read_fav_thread(post)
 
         if html_response:
             return redirect(post.get_absolute_url())
 
     def get_threads(self):
         """
         Gets list of threads that will be shown on a page.
         """
 
         threads = Thread.objects\
             .exclude(tags__in=self.settings_manager.get_hidden_tags())
         if self.settings_manager.get_setting(SETTING_ONLY_FAVORITES):
             fav_tags = self.settings_manager.get_fav_tags()
             if len(fav_tags) > 0:
                 threads = threads.filter(tags__in=fav_tags)
 
         return threads
 
     def get_rss_url(self):
         return self.get_reverse_url() + 'rss/'
 
     def toggle_fav(self, request):
         settings_manager = get_settings_manager(request)
         settings_manager.set_setting(SETTING_ONLY_FAVORITES,
                 not settings_manager.get_setting(SETTING_ONLY_FAVORITES, False))

boards/views/api.py

@@ -1,315 +1,315 b''
 import json
 import logging
 
 from django.core import serializers
 from django.db import transaction
 from django.http import HttpResponse
 from django.shortcuts import get_object_or_404
 from django.views.decorators.csrf import csrf_protect
 
 from boards.abstracts.settingsmanager import get_settings_manager
 from boards.forms import PostForm, PlainErrorList
 from boards.mdx_neboard import Parser
 from boards.models import Post, Thread, Tag, Attachment
 from boards.models.thread import STATUS_ARCHIVE
 from boards.models.user import Notification
 from boards.utils import datetime_to_epoch
 from boards.views.thread import ThreadView
 from boards.models.attachment.viewers import FILE_TYPES_IMAGE
 
 __author__ = 'neko259'
 
 PARAMETER_TRUNCATED = 'truncated'
 PARAMETER_TAG = 'tag'
 PARAMETER_OFFSET = 'offset'
 PARAMETER_DIFF_TYPE = 'type'
 PARAMETER_POST = 'post'
 PARAMETER_UPDATED = 'updated'
 PARAMETER_LAST_UPDATE = 'last_update'
 PARAMETER_THREAD = 'thread'
 PARAMETER_UIDS = 'uids'
 PARAMETER_SUBSCRIBED = 'subscribed'
 
 DIFF_TYPE_HTML = 'html'
 DIFF_TYPE_JSON = 'json'
 
 STATUS_OK = 'ok'
 STATUS_ERROR = 'error'
 
 logger = logging.getLogger(__name__)
 
 
 @transaction.atomic
 def api_get_threaddiff(request):
     """
     Gets posts that were changed or added since time
     """
 
     thread_id = request.POST.get(PARAMETER_THREAD)
     uids_str = request.POST.get(PARAMETER_UIDS)
 
     if not thread_id or not uids_str:
         return HttpResponse(content='Invalid request.')
 
     uids = uids_str.strip().split(' ')
 
     opening_post = get_object_or_404(Post, id=thread_id)
     thread = opening_post.get_thread()
 
     json_data = {
         PARAMETER_UPDATED: [],
         PARAMETER_LAST_UPDATE: None,  # TODO Maybe this can be removed already?
     }
-    posts = Post.objects.filter(threads__in=[thread]).exclude(uid__in=uids)
+    posts = Post.objects.filter(thread=thread).exclude(uid__in=uids)
 
     diff_type = request.GET.get(PARAMETER_DIFF_TYPE, DIFF_TYPE_HTML)
 
     for post in posts:
         json_data[PARAMETER_UPDATED].append(post.get_post_data(
             format_type=diff_type, request=request))
     json_data[PARAMETER_LAST_UPDATE] = str(thread.last_edit_time)
 
     settings_manager = get_settings_manager(request)
     json_data[PARAMETER_SUBSCRIBED] = str(settings_manager.thread_is_fav(opening_post))
 
     # If the tag is favorite, update the counter
     settings_manager = get_settings_manager(request)
     favorite = settings_manager.thread_is_fav(opening_post)
     if favorite:
         settings_manager.add_or_read_fav_thread(opening_post)
 
     return HttpResponse(content=json.dumps(json_data))
 
 
 @csrf_protect
 def api_add_post(request, opening_post_id):
     """
     Adds a post and return the JSON response for it
     """
 
     opening_post = get_object_or_404(Post, id=opening_post_id)
 
     logger.info('Adding post via api...')
 
     status = STATUS_OK
     errors = []
 
     if request.method == 'POST':
         form = PostForm(request.POST, request.FILES, error_class=PlainErrorList)
         form.session = request.session
 
         if form.need_to_ban:
             # Ban user because he is suspected to be a bot
             # _ban_current_user(request)
             status = STATUS_ERROR
         if form.is_valid():
             post = ThreadView().new_post(request, form, opening_post,
                                          html_response=False)
             if not post:
                 status = STATUS_ERROR
             else:
                 logger.info('Added post #%d via api.' % post.id)
         else:
             status = STATUS_ERROR
             errors = form.as_json_errors()
 
     response = {
         'status': status,
         'errors': errors,
     }
 
     return HttpResponse(content=json.dumps(response))
 
 
 def get_post(request, post_id):
     """
     Gets the html of a post. Used for popups. Post can be truncated if used
     in threads list with 'truncated' get parameter.
     """
 
     post = get_object_or_404(Post, id=post_id)
     truncated = PARAMETER_TRUNCATED in request.GET
 
     return HttpResponse(content=post.get_view(truncated=truncated, need_op_data=True))
 
 
 def api_get_threads(request, count):
     """
     Gets the JSON thread opening posts list.
     Parameters that can be used for filtering:
     tag, offset (from which thread to get results)
     """
 
     if PARAMETER_TAG in request.GET:
         tag_name = request.GET[PARAMETER_TAG]
         if tag_name is not None:
             tag = get_object_or_404(Tag, name=tag_name)
             threads = tag.get_threads().exclude(status=STATUS_ARCHIVE)
     else: 
         threads = Thread.objects.exclude(status=STATUS_ARCHIVE)
 
     if PARAMETER_OFFSET in request.GET:
         offset = request.GET[PARAMETER_OFFSET]
         offset = int(offset) if offset is not None else 0
     else:
         offset = 0
 
     threads = threads.order_by('-bump_time')
     threads = threads[offset:offset + int(count)]
 
     opening_posts = []
     for thread in threads:
         opening_post = thread.get_opening_post()
 
         # TODO Add tags, replies and images count
         post_data = opening_post.get_post_data(include_last_update=True)
         post_data['status'] = thread.get_status()
 
         opening_posts.append(post_data)
 
     return HttpResponse(content=json.dumps(opening_posts))
 
 
 # TODO Test this
 def api_get_tags(request):
     """
     Gets all tags or user tags.
     """
 
     # TODO Get favorite tags for the given user ID
 
     tags = Tag.objects.get_not_empty_tags()
 
     term = request.GET.get('term')
     if term is not None:
         tags = tags.filter(name__contains=term)
 
     tag_names = [tag.name for tag in tags]
 
     return HttpResponse(content=json.dumps(tag_names))
 
 
 def api_get_stickers(request):
     attachments = Attachment.objects.filter(mimetype__in=FILE_TYPES_IMAGE)\
         .exclude(alias='').exclude(alias=None)
 
     term = request.GET.get('term')
     if term:
         attachments = attachments.filter(alias__contains=term)
 
     image_dict = [{'thumb': attachment.get_thumb_url(),
                    'alias': attachment.alias}
                   for attachment in attachments]
 
     return HttpResponse(content=json.dumps(image_dict))
 
 
 # TODO The result can be cached by the thread last update time
 # TODO Test this
 def api_get_thread_posts(request, opening_post_id):
     """
     Gets the JSON array of thread posts
     """
 
     opening_post = get_object_or_404(Post, id=opening_post_id)
     thread = opening_post.get_thread()
     posts = thread.get_replies()
 
     json_data = {
         'posts': [],
         'last_update': None,
     }
     json_post_list = []
 
     for post in posts:
         json_post_list.append(post.get_post_data())
     json_data['last_update'] = datetime_to_epoch(thread.last_edit_time)
     json_data['posts'] = json_post_list
 
     return HttpResponse(content=json.dumps(json_data))
 
 
 def api_get_notifications(request, username):
     last_notification_id_str = request.GET.get('last', None)
     last_id = int(last_notification_id_str) if last_notification_id_str is not None else None
 
     posts = Notification.objects.get_notification_posts(usernames=[username],
                                                         last=last_id)
 
     json_post_list = []
     for post in posts:
         json_post_list.append(post.get_post_data())
     return HttpResponse(content=json.dumps(json_post_list))
 
 
 def api_get_post(request, post_id):
     """
     Gets the JSON of a post. This can be
     used as and API for external clients.
     """
 
     post = get_object_or_404(Post, id=post_id)
 
     json = serializers.serialize("json", [post], fields=(
         "pub_time", "_text_rendered", "title", "text", "image",
         "image_width", "image_height", "replies", "tags"
     ))
 
     return HttpResponse(content=json)
 
 
 def api_get_preview(request):
     raw_text = request.POST['raw_text']
 
     parser = Parser()
     return HttpResponse(content=parser.parse(parser.preparse(raw_text)))
 
 
 def api_get_new_posts(request):
     """
     Gets favorite threads and unread posts count.
     """
     posts = list()
 
     include_posts = 'include_posts' in request.GET
 
     settings_manager = get_settings_manager(request)
     fav_threads = settings_manager.get_fav_threads()
     fav_thread_ops = Post.objects.filter(id__in=fav_threads.keys())\
         .order_by('-pub_time').prefetch_related('thread')
 
     ops = [{'op': op, 'last_id': fav_threads[str(op.id)]} for op in fav_thread_ops]
     if include_posts:
         new_post_threads = Thread.objects.get_new_posts(ops)
         if new_post_threads:
             thread_ids = {thread.id: thread for thread in new_post_threads}
         else:
             thread_ids = dict()
 
         for op in fav_thread_ops:
             fav_thread_dict = dict()
 
             op_thread = op.get_thread()
             if op_thread.id in thread_ids:
                 thread = thread_ids[op_thread.id]
                 new_post_count = thread.new_post_count
                 fav_thread_dict['newest_post_link'] = thread.get_replies()\
                         .filter(id__gt=fav_threads[str(op.id)])\
                         .first().get_absolute_url(thread=thread)
             else:
                 new_post_count = 0
             fav_thread_dict['new_post_count'] = new_post_count
 
             fav_thread_dict['id'] = op.id
 
             fav_thread_dict['post_url'] = op.get_link_view()
             fav_thread_dict['title'] = op.title
 
             posts.append(fav_thread_dict)
     else:
         fav_thread_dict = dict()
         fav_thread_dict['new_post_count'] = \
             Thread.objects.get_new_post_count(ops)
         posts.append(fav_thread_dict)
 
     return HttpResponse(content=json.dumps(posts))

boards/views/feed.py

@@ -1,74 +1,74 b''
 from django.core.urlresolvers import reverse
 from django.shortcuts import render
 
 from boards import settings
 from boards.abstracts.paginator import get_paginator
 from boards.abstracts.settingsmanager import get_settings_manager
 from boards.models import Post
 from boards.views.base import BaseBoardView
 from boards.views.posting_mixin import PostMixin
 
 POSTS_PER_PAGE = settings.get_int('View', 'PostsPerPage')
 
 PARAMETER_CURRENT_PAGE = 'current_page'
 PARAMETER_PAGINATOR = 'paginator'
 PARAMETER_POSTS = 'posts'
 
 PARAMETER_PREV_LINK = 'prev_page_link'
 PARAMETER_NEXT_LINK = 'next_page_link'
 
 TEMPLATE = 'boards/feed.html'
 DEFAULT_PAGE = 1
 
 
 class FeedView(PostMixin, BaseBoardView):
 
     def get(self, request):
         page = request.GET.get('page', DEFAULT_PAGE)
         tripcode = request.GET.get('tripcode', None)
         favorites = 'favorites' in request.GET
         ip = request.GET.get('ip', None)
 
         params = self.get_context_data(request=request)
 
         settings_manager = get_settings_manager(request)
 
         posts = Post.objects.exclude(
-            threads__tags__in=settings_manager.get_hidden_tags()).order_by(
-            '-pub_time').prefetch_related('attachments', 'thread', 'threads')
+            thread__tags__in=settings_manager.get_hidden_tags()).order_by(
+            '-pub_time').prefetch_related('attachments', 'thread')
         if tripcode:
             posts = posts.filter(tripcode=tripcode)
         if favorites:
             fav_thread_ops = Post.objects.filter(id__in=settings_manager.get_fav_threads().keys())
             fav_threads = [op.get_thread() for op in fav_thread_ops]
             posts = posts.filter(threads__in=fav_threads)
         if ip and request.user.has_perm('post_delete'):
             posts = posts.filter(poster_ip=ip)
 
         paginator = get_paginator(posts, POSTS_PER_PAGE)
         paginator.current_page = int(page)
 
         params[PARAMETER_POSTS] = paginator.page(page).object_list
 
         paginator.set_url(reverse('feed'), request.GET.dict())
 
         self.get_page_context(paginator, params, page)
 
         return render(request, TEMPLATE, params)
 
     # TODO Dedup this into PagedMixin
     def get_page_context(self, paginator, params, page):
         """
         Get pagination context variables
         """
 
         params[PARAMETER_PAGINATOR] = paginator
         current_page = paginator.page(int(page))
         params[PARAMETER_CURRENT_PAGE] = current_page
         if current_page.has_previous():
             params[PARAMETER_PREV_LINK] = paginator.get_page_url(
                     current_page.previous_page_number())
         if current_page.has_next():
             params[PARAMETER_NEXT_LINK] = paginator.get_page_url(
                     current_page.next_page_number())
 

boards/views/thread/thread.py

@@ -1,183 +1,181 b''
 from django.contrib.auth.decorators import permission_required
 
 from django.core.exceptions import ObjectDoesNotExist
 from django.core.urlresolvers import reverse
 from django.http import Http404
 from django.shortcuts import get_object_or_404, render, redirect
 from django.template.context_processors import csrf
 from django.utils.decorators import method_decorator
 from django.views.decorators.csrf import csrf_protect
 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.abstracts.settingsmanager import get_settings_manager
 from boards.forms import PostForm, PlainErrorList
 from boards.models import Post
 from boards.views.base import BaseBoardView, CONTEXT_FORM
 from boards.views.mixins import DispatcherMixin, PARAMETER_METHOD
 from boards.views.posting_mixin import PostMixin
 import neboard
 
 REQ_POST_ID = 'post_id'
 
 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'
 CONTEXT_OP = 'opening_post'
 CONTEXT_FAVORITE = 'is_favorite'
 CONTEXT_RSS_URL = 'rss_url'
 
 FORM_TITLE = 'title'
 FORM_TEXT = 'text'
 FORM_IMAGE = 'image'
 FORM_THREADS = 'threads'
 
 
 class ThreadView(BaseBoardView, PostMixin, FormMixin, DispatcherMixin):
 
     @method_decorator(csrf_protect)
     def get(self, request, post_id, form: PostForm=None):
         try:
             opening_post = Post.objects.get(id=post_id)
         except ObjectDoesNotExist:
             raise Http404
 
         # If the tag is favorite, update the counter
         settings_manager = get_settings_manager(request)
         favorite = settings_manager.thread_is_fav(opening_post)
         if favorite:
             settings_manager.add_or_read_fav_thread(opening_post)
 
         # 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()
         params[CONTEXT_OP] = opening_post
         params[CONTEXT_FAVORITE] = favorite
         params[CONTEXT_RSS_URL] = self.get_rss_url(post_id)
 
         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)
 
     @method_decorator(csrf_protect)
     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 PARAMETER_METHOD in request.POST:
             self.dispatch_method(request, opening_post)
 
             return redirect('thread', post_id)  # FIXME Different for different modes
 
         if not opening_post.get_thread().is_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 = form.get_title()
         text = data[FORM_TEXT]
         file = form.get_file()
         file_url = form.get_file_url()
-        threads = data[FORM_THREADS]
         images = form.get_images()
 
         text = self._remove_invalid_links(text)
 
         post_thread = opening_post.get_thread()
 
         post = Post.objects.create_post(title=title, text=text, file=file,
                                         thread=post_thread, ip=ip,
-                                        opening_posts=threads,
                                         tripcode=form.get_tripcode(),
                                         images=images, file_url=file_url)
         post.notify_clients()
 
         if form.is_subscribe():
             settings_manager = get_settings_manager(request)
             settings_manager.add_or_read_fav_thread(
                     post_thread.get_opening_post())
 
         if html_response:
             if opening_post:
                 return redirect(post.get_absolute_url())
         else:
             return post
 
     def get_data(self, thread) -> dict:
         """
         Returns context params for the view.
         """
 
         return dict()
 
     def get_template(self) -> str:
         """
         Gets template to show the thread mode on.
         """
 
         pass
 
     def get_mode(self) -> str:
         pass
 
     def subscribe(self, request, opening_post):
         settings_manager = get_settings_manager(request)
         settings_manager.add_or_read_fav_thread(opening_post)
 
     def unsubscribe(self, request, opening_post):
         settings_manager = get_settings_manager(request)
         settings_manager.del_fav_thread(opening_post)
 
     def get_rss_url(self, opening_id):
         return reverse('thread', kwargs={'post_id': opening_id}) + 'rss/'