Fixed thread bumping

boards/models/post/__init__.py

@@ -1,421 +1,419 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.db.models import TextField, QuerySet
 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):
+            ip=NO_IP, tags: list=None, opening_posts: 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 = []
+        if not opening_posts:
+            opening_posts = []
 
         posting_time = timezone.now()
         if not thread:
             thread = boards.models.thread.Thread.objects.create(
                 bump_time=posting_time, last_edit_time=posting_time)
             list(map(thread.tags.add, tags))
             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))
 
         if new_thread:
             boards.models.thread.Thread.objects.process_oldest_threads()
         else:
             thread.last_edit_time = posting_time
             thread.bump()
             thread.save()
 
         post.build_url()
         post.connect_replies()
-        post.connect_threads(threads)
+        post.connect_threads(opening_posts)
         post.connect_notifications()
 
         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='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):
         threads = self.get_threads().all()
         return self.referenced_posts.filter(threads__in=threads)\
                 .order_by('pub_time').distinct().all()
 
     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):
         if self.url:
             return self.url
         else:
             opening_id = self.get_thread().get_opening_post_id()
             post_url = reverse('thread', kwargs={'post_id': opening_id})
             if self.id != opening_id:
                 post_url += '#' + str(self.id)
             return post_url
 
 
     def get_thread(self):
         return self.thread
 
-    def get_threads(self) -> list:
+    def get_threads(self) -> QuerySet:
         """
         Gets post's thread.
         """
 
         return self.threads
 
     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'
 
         params = dict()
         for param in POST_VIEW_PARAMS:
             if param in kwargs:
                 params[param] = kwargs[param]
 
         params.update({
             PARAMETER_POST: self,
             PARAMETER_IS_OPENING: is_opening,
             PARAMETER_THREAD: thread,
             PARAMETER_CSS_CLASS: css_class,
             PARAMETER_OP_ID: opening_post_id,
         })
 
         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):
         self.url = self.get_absolute_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):
         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(opening_post.get_thread())

boards/models/thread.py

@@ -1,235 +1,237 b''
 import logging
 from adjacent import Client
 
 from django.db.models import Count, Sum, QuerySet
 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) -> 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.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) -> 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
 
     def get_replies(self, view_fields_only=False) -> QuerySet:
         """
         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) -> 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).annotate(images_count=Count(
             'images')).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().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):
+        last_edit_time = self.last_edit_time
+
         for post in self.post_set.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 = self.last_edit_time
+                post.last_edit_time = last_edit_time
                 post.save(update_fields=['last_edit_time'])
 
-                post.threads.update(last_edit_time=self.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()

boards/static/js/thread_update.js

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

boards/tests/test_post.py

@@ -1,135 +1,178 b''
 from django.core.paginator import Paginator
 from django.test import TestCase
+
 from boards import settings
 from boards.models import Tag, Post, Thread
 
 
 class PostTests(TestCase):
 
     def _create_post(self):
         tag, created = Tag.objects.get_or_create(name='test_tag')
         return Post.objects.create_post(title='title', text='text',
                                         tags=[tag])
 
     def test_post_add(self):
         """Test adding post"""
 
         post = self._create_post()
 
         self.assertIsNotNone(post, 'No post was created.')
         self.assertEqual('test_tag', post.get_thread().tags.all()[0].name,
                          'No tags were added to the post.')
 
     def test_delete_post(self):
         """Test post deletion"""
 
         post = self._create_post()
         post_id = post.id
 
         post.delete()
 
         self.assertFalse(Post.objects.filter(id=post_id).exists())
 
     def test_delete_thread(self):
         """Test thread deletion"""
 
         opening_post = self._create_post()
         thread = opening_post.get_thread()
         reply = Post.objects.create_post("", "", thread=thread)
 
         thread.delete()
 
         self.assertFalse(Post.objects.filter(id=reply.id).exists(),
                          'Reply was not deleted with the thread.')
         self.assertFalse(Post.objects.filter(id=opening_post.id).exists(),
                          'Opening post was not deleted with the thread.')
 
     def test_post_to_thread(self):
         """Test adding post to a thread"""
 
         op = self._create_post()
         post = Post.objects.create_post("", "", thread=op.get_thread())
 
         self.assertIsNotNone(post, 'Reply to thread wasn\'t created')
         self.assertEqual(op.get_thread().last_edit_time, post.pub_time,
                          'Post\'s create time doesn\'t match thread last edit'
                          ' time')
 
     def test_delete_posts_by_ip(self):
         """Test deleting posts with the given ip"""
 
         post = self._create_post()
         post_id = post.id
 
         Post.objects.delete_posts_by_ip('0.0.0.0')
 
         self.assertFalse(Post.objects.filter(id=post_id).exists())
 
     def test_get_thread(self):
         """Test getting all posts of a thread"""
 
         opening_post = self._create_post()
 
         for i in range(2):
             Post.objects.create_post('title', 'text',
                                      thread=opening_post.get_thread())
 
         thread = opening_post.get_thread()
 
         self.assertEqual(3, thread.get_replies().count())
 
     def test_create_post_with_tag(self):
         """Test adding tag to post"""
 
         tag = Tag.objects.create(name='test_tag')
         post = Post.objects.create_post(title='title', text='text', tags=[tag])
 
         thread = post.get_thread()
         self.assertIsNotNone(post, 'Post not created')
         self.assertTrue(tag in thread.tags.all(), 'Tag not added to thread')
 
     def test_thread_max_count(self):
         """Test deletion of old posts when the max thread count is reached"""
 
         for i in range(settings.get_int('Messages', 'MaxThreadCount') + 1):
             self._create_post()
 
         self.assertEqual(settings.get_int('Messages', 'MaxThreadCount'),
                          len(Thread.objects.filter(archived=False)))
 
     def test_pages(self):
         """Test that the thread list is properly split into pages"""
 
         for i in range(settings.get_int('Messages', 'MaxThreadCount')):
             self._create_post()
 
         all_threads = Thread.objects.filter(archived=False)
 
         paginator = Paginator(Thread.objects.filter(archived=False),
                               settings.get_int('View', 'ThreadsPerPage'))
         posts_in_second_page = paginator.page(2).object_list
         first_post = posts_in_second_page[0]
 
         self.assertEqual(all_threads[settings.get_int('View', 'ThreadsPerPage')].id,
                          first_post.id)
 
     def test_thread_replies(self):
         """
         Tests that the replies can be queried from a thread in all possible
         ways.
         """
 
         tag = Tag.objects.create(name='test_tag')
         opening_post = Post.objects.create_post(title='title', text='text',
                                         tags=[tag])
         thread = opening_post.get_thread()
 
-        reply1 = Post.objects.create_post(title='title', text='text', thread=thread)
-        reply2 = Post.objects.create_post(title='title', text='text', thread=thread)
+        Post.objects.create_post(title='title', text='text', thread=thread)
+        Post.objects.create_post(title='title', text='text', thread=thread)
 
         replies = thread.get_replies()
         self.assertTrue(len(replies) > 0, 'No replies found for thread.')
 
         replies = thread.get_replies(view_fields_only=True)
         self.assertTrue(len(replies) > 0,
                 'No replies found for thread with view fields only.')
+
+    def test_bumplimit(self):
+        """
+        Tests that the thread bumpable status is changed and post uids and
+        last update times are updated across all post threads.
+        """
+
+        op1 = Post.objects.create_post(title='title', text='text')
+        op2 = Post.objects.create_post(title='title', text='text')
+
+        thread1 = op1.get_thread()
+        thread1.max_posts = 5
+        thread1.save()
+
+        uid_1 = op1.uid
+        uid_2 = op2.uid
+
+        # Create multi reply
+        Post.objects.create_post(
+            title='title', text='text', thread=thread1,
+            opening_posts=[op1, op2])
+        thread_update_time_2 = op2.get_thread().last_edit_time
+        for i in range(6):
+            Post.objects.create_post(title='title', text='text',
+                                     thread=thread1)
+
+        self.assertFalse(op1.get_thread().can_bump(),
+                         'Thread is bumpable when it should not be.')
+        self.assertTrue(op2.get_thread().can_bump(),
+                        'Thread is not bumpable when it should be.')
+        self.assertNotEqual(
+            uid_1, Post.objects.get(id=op1.id).uid,
+            'UID of the first OP should be changed but it is not.')
+        self.assertEqual(
+            uid_2, Post.objects.get(id=op2.id).uid,
+            'UID of the first OP should not be changed but it is.')
+
+        self.assertNotEqual(
+            thread_update_time_2,
+            Thread.objects.get(id=op2.get_thread().id).last_edit_time,
+            'Thread last update time should change when the other thread '
+            'changes status.')

boards/views/all_threads.py

@@ -1,169 +1,169 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
 import requests
 
 from boards import utils, settings
 from boards.abstracts.paginator import get_paginator
 from boards.abstracts.settingsmanager import get_settings_manager
 from boards.forms import ThreadForm, PlainErrorList
 from boards.models import Post, Thread, Ban, Tag, PostImage, Banner
 from boards.views.banned import BannedView
 from boards.views.base import BaseBoardView, CONTEXT_FORM
 from boards.views.posting_mixin import PostMixin
 
 
 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_BANNERS = 'banners'
 
 PARAMETER_PREV_LINK = 'prev_page_link'
 PARAMETER_NEXT_LINK = 'next_page_link'
 
 TEMPLATE = 'boards/all_threads.html'
 DEFAULT_PAGE = 1
 
 
 class AllThreadsView(PostMixin, BaseBoardView):
 
     def __init__(self):
         self.settings_manager = None
         super(AllThreadsView, self).__init__()
 
     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)
         paginator = get_paginator(self.get_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_BANNERS] = Banner.objects.order_by('-id').all()
 
         self.get_page_context(paginator, params, page)
 
         return render(request, TEMPLATE, params)
 
     def post(self, request):
         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
         if current_page.has_previous():
             params[PARAMETER_PREV_LINK] = self.get_previous_page_link(
                     current_page)
         if current_page.has_next():
             params[PARAMETER_NEXT_LINK] = self.get_next_page_link(current_page)
 
     def get_previous_page_link(self, current_page):
         return reverse('index') + '?page=' \
                 + str(current_page.previous_page_number())
 
     def get_next_page_link(self, current_page):
         return reverse('index') + '?page=' \
                 + str(current_page.next_page_number())
 
     @staticmethod
     def parse_tags_string(tag_strings):
         """
         Parses tag list string and returns tag object list.
         """
 
         tags = []
 
         if tag_strings:
             tag_strings = tag_strings.split(TAG_DELIMITER)
             for tag_name in tag_strings:
                 tag_name = tag_name.strip().lower()
                 if len(tag_name) > 0:
                     tag, created = Tag.objects.get_or_create(name=tag_name)
                     tags.append(tag)
 
         return tags
 
     @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 = data[FORM_TITLE]
         text = data[FORM_TEXT]
         image = form.get_image()
         threads = data[FORM_THREADS]
 
         text = self._remove_invalid_links(text)
 
         tag_strings = data[FORM_TAGS]
 
         tags = self.parse_tags_string(tag_strings)
 
         post = Post.objects.create_post(title=title, text=text, image=image,
-                                        ip=ip, tags=tags, threads=threads)
+                                        ip=ip, tags=tags, opening_posts=threads)
 
         # This is required to update the threads to which posts we have replied
         # when creating this one
         post.notify_clients()
 
         if html_response:
             return redirect(post.get_absolute_url())
 
     def get_threads(self):
         """
         Gets list of threads that will be shown on a page.
         """
 
         return Thread.objects.order_by('-bump_time')\
             .exclude(tags__in=self.settings_manager.get_hidden_tags())

boards/views/thread/thread.py

@@ -1,138 +1,138 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'
 CONTEXT_OP = 'opening_post'
 
 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()
         params[CONTEXT_OP] = opening_post
 
         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)
+                                        opening_posts=threads)
         post.notify_clients()
 
         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