Save bump limit separately for every thread

boards/migrations/0012_thread_max_posts.py

@@ -0,0 +1,20 b''
+# -*- coding: utf-8 -*-
+from __future__ import unicode_literals
+
+from django.db import models, migrations
+
+
+class Migration(migrations.Migration):
+
+    dependencies = [
+        ('boards', '0011_notification'),
+    ]
+
+    operations = [
+        migrations.AddField(
+            model_name='thread',
+            name='max_posts',
+            field=models.IntegerField(default=10),
+            preserve_default=True,
+        ),
+    ]

boards/models/thread.py

@@ -1,196 +1,197 b''
 import logging
 
 from django.db.models import Count, Sum
 from django.utils import timezone
 from django.db import models
 
 from boards import settings
 import boards
 from boards.utils import cached_result
 from boards.models.post import Post
 
 
 __author__ = 'neko259'
 
 
 logger = logging.getLogger(__name__)
 
 
 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()
 
         if thread_count > settings.MAX_THREAD_COUNT:
             num_threads_to_delete = thread_count - settings.MAX_THREAD_COUNT
             old_threads = threads[thread_count - num_threads_to_delete:]
 
             for thread in old_threads:
                 if settings.ARCHIVE_THREADS:
                     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'])
 
 
 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=settings.MAX_POSTS_PER_THREAD)
 
     def get_tags(self):
         """
         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 update_bump_status(self):
-        if self.get_reply_count() >= settings.MAX_POSTS_PER_THREAD:
+        if self.get_reply_count() >= self.max_posts:
             self.bumpable = False
             self.update_posts_time()
 
     def get_reply_count(self):
         return self.get_replies().count()
 
     def get_images_count(self):
         return self.get_replies().annotate(images_count=Count(
                 'images')).aggregate(Sum('images_count'))['images_count__sum']
 
     def can_bump(self):
         """
         Checks if the thread can be bumped by replying to it.
         """
 
         return self.bumpable and not self.archived
 
     def get_last_replies(self):
         """
         Gets several last replies, not including opening post
         """
 
         if settings.LAST_REPLIES_COUNT > 0:
             reply_count = self.get_reply_count()
 
             if reply_count > 0:
                 reply_count_to_show = min(settings.LAST_REPLIES_COUNT,
                                           reply_count - 1)
                 replies = self.get_replies()
                 last_replies = replies[reply_count - reply_count_to_show:]
 
                 return last_replies
 
     def get_skipped_replies_count(self):
         """
         Gets number of posts between opening post and last replies.
         """
         reply_count = self.get_reply_count()
         last_replies_count = min(settings.LAST_REPLIES_COUNT,
                                  reply_count - 1)
         return reply_count - last_replies_count - 1
 
     def get_replies(self, view_fields_only=False):
         """
         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_user_agent')
         return query.all()
 
     def get_replies_with_images(self, view_fields_only=False):
         """
         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 add_tag(self, tag):
         """
         Connects thread to a tag and tag to a thread
         """
 
         self.tags.add(tag)
 
     def get_opening_post(self, only_id=False):
         """
         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):
         """
         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):
         return boards.models.Tag.objects.get_tag_url_list(self.get_tags())
 
     def update_posts_time(self):
         self.post_set.update(last_edit_time=self.last_edit_time)
         for post in self.post_set.all():
             post.threads.update(last_edit_time=self.last_edit_time)

boards/settings.py

@@ -1,3 +1,4 b''
 from boards.default_settings import *
 
-# Site-specific settings go here
  No newline at end of file
+# Site-specific settings go here
+MAX_POSTS_PER_THREAD = 12

boards/templates/boards/thread.html

@@ -1,35 +1,35 b''
 {% extends "boards/base.html" %}
 
 {% load i18n %}
 {% load cache %}
 {% load static from staticfiles %}
 {% load board %}
 
 {% block head %}
     <title>{{ opening_post.get_title|striptags|truncatewords:10 }}
         - {{ site_name }}</title>
 {% endblock %}
 
 {% block metapanel %}
 
     {% get_current_language as LANGUAGE_CODE %}
 
     <span class="metapanel"
           data-last-update="{{ last_update }}"
           data-ws-token="{{ ws_token }}"
           data-ws-project="{{ ws_project }}"
           data-ws-host="{{ ws_host }}"
           data-ws-port="{{ ws_port }}">
 
         {% block thread_meta_panel %}
         {% endblock %}
 
         {% cache 600 thread_meta thread.last_edit_time moderator LANGUAGE_CODE %}
-            <span id="reply-count">{{ thread.get_reply_count }}</span>/{{ max_replies }} {% trans 'messages' %},
+            <span id="reply-count">{{ thread.get_reply_count }}</span>/{{ thread.max_posts }} {% trans 'messages' %},
             <span id="image-count">{{ thread.get_images_count }}</span> {% trans 'images' %}.
             {% trans 'Last update: ' %}<span id="last-update"><time datetime="{{ thread.last_edit_time|date:'c' }}">{{ thread.last_edit_time|date:'r' }}</time></span>
             [<a href="rss/">RSS</a>]
         {% endcache %}
     </span>
 
 {% endblock %}

boards/views/thread/normal.py

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

boards/views/thread/thread.py

@@ -1,123 +1,121 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 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_MAX_REPLIES = 'max_replies'
 CONTEXT_THREAD = 'thread'
 CONTEXT_WS_TOKEN = 'ws_token'
 CONTEXT_WS_PROJECT = 'ws_project'
 CONTEXT_WS_HOST = 'ws_host'
 CONTEXT_WS_PORT = 'ws_port'
 
 FORM_TITLE = 'title'
 FORM_TEXT = 'text'
 FORM_IMAGE = 'image'
 
 
 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_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(utils.datetime_to_epoch(
             thread_to_show.last_edit_time))
         params[CONTEXT_THREAD] = thread_to_show
-        params[CONTEXT_MAX_REPLIES] = settings.MAX_POSTS_PER_THREAD
 
         if settings.WEBSOCKETS_ENABLED:
             params[CONTEXT_WS_TOKEN] = utils.get_websocket_token(
                 timestamp=params[CONTEXT_LASTUPDATE])
             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()
 
         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)
         post.send_to_websocket(request)
 
         if html_response:
             if opening_post:
                 return redirect(post.get_url())
         else:
             return post
 
     def get_data(self, thread):
         """
         Returns context params for the view.
         """
 
         pass
 
     def get_template(self):
         """
         Gets template to show the thread mode on.
         """
 
         pass