Updated paginator for long page lists. Removed old get_threads method in the post manager

boards/abstracts/__init__.py

@@ -0,0 +1,1 b''
+__author__ = 'vurdalak'

boards/abstracts/paginator.py

@@ -0,0 +1,22 b''
+from django.core.paginator import Paginator
+
+__author__ = 'neko259'
+
+PAGINATOR_LOOKAROUND_SIZE = 3
+
+
+def get_paginator(*args, **kwargs):
+    return DividedPaginator(*args, **kwargs)
+
+
+class DividedPaginator(Paginator):
+
+    lookaround_size = PAGINATOR_LOOKAROUND_SIZE
+    current_page = 0
+
+    def center_range(self):
+        index = self.page_range.index(self.current_page)
+
+        start = max(0, index - self.lookaround_size)
+        end = min(len(self.page_range), index + self.lookaround_size + 1)
+        return self.page_range[start:end]
  No newline at end of file

boards/models/post.py

@@ -1,451 +1,431 b''
 from datetime import datetime, timedelta, date
 from datetime import time as dtime
 import os
 from random import random
 import time
 import math
 import re
 import hashlib
 
 from django.core.cache import cache
 from django.core.paginator import Paginator
 from django.core.urlresolvers import reverse
 
 from django.db import models, transaction
 from django.http import Http404
 from django.utils import timezone
 from markupfield.fields import MarkupField
 
 from neboard import settings
 from boards import thumbs
 
 MAX_TITLE_LENGTH = 50
 
 APP_LABEL_BOARDS = 'boards'
 
 CACHE_KEY_PPD = 'ppd'
 CACHE_KEY_POST_URL = 'post_url'
 CACHE_KEY_OPENING_POST = 'opening_post'
 
 POSTS_PER_DAY_RANGE = range(7)
 
 BAN_REASON_AUTO = 'Auto'
 
 IMAGE_THUMB_SIZE = (200, 150)
 
 TITLE_MAX_LENGTH = 50
 
 DEFAULT_MARKUP_TYPE = 'markdown'
 
 NO_PARENT = -1
 NO_IP = '0.0.0.0'
 UNKNOWN_UA = ''
 ALL_PAGES = -1
 IMAGES_DIRECTORY = 'images/'
 FILE_EXTENSION_DELIMITER = '.'
 
 SETTING_MODERATE = "moderate"
 
 REGEX_REPLY = re.compile('>>(\d+)')
 
 
 class PostManager(models.Manager):
 
     def create_post(self, title, text, image=None, thread=None,
                     ip=NO_IP, tags=None, user=None):
         """
         Create new post
         """
 
         posting_time = timezone.now()
         if not thread:
             thread = Thread.objects.create(bump_time=posting_time,
                                            last_edit_time=posting_time)
         else:
             thread.bump()
             thread.last_edit_time = posting_time
             thread.save()
 
         post = self.create(title=title,
                            text=text,
                            pub_time=posting_time,
                            thread_new=thread,
                            image=image,
                            poster_ip=ip,
                            poster_user_agent=UNKNOWN_UA,  # TODO Get UA at
                            # last!
                            last_edit_time=posting_time,
                            user=user)
 
         thread.replies.add(post)
         if tags:
             linked_tags = []
             for tag in tags:
                 tag_linked_tags = tag.get_linked_tags()
                 if len(tag_linked_tags) > 0:
                     linked_tags.extend(tag_linked_tags)
 
             tags.extend(linked_tags)
             map(thread.add_tag, tags)
 
         self._delete_old_threads()
         self.connect_replies(post)
 
         return post
 
     def delete_post(self, post):
         """
         Delete post and update or delete its thread
         """
 
         thread = post.thread_new
 
         if post.is_opening():
             thread.delete_with_posts()
         else:
             thread.last_edit_time = timezone.now()
             thread.save()
 
             post.delete()
 
     def delete_posts_by_ip(self, ip):
         """
         Delete all posts of the author with same IP
         """
 
         posts = self.filter(poster_ip=ip)
         map(self.delete_post, posts)
 
-    # TODO This method may not be needed any more, because django's paginator
-    # is used
-    def get_threads(self, tag=None, page=ALL_PAGES,
-                    order_by='-bump_time', archived=False):
-        if tag:
-            threads = tag.threads
-
-            if not threads.exists():
-                raise Http404
-        else:
-            threads = Thread.objects.all()
-
-        threads = threads.filter(archived=archived).order_by(order_by)
-
-        if page != ALL_PAGES:
-            threads = Paginator(threads, settings.THREADS_PER_PAGE).page(
-                    page).object_list
-
-        return threads
-
     # TODO Move this method to thread manager
     def _delete_old_threads(self):
         """
         Preserves maximum thread count. If there are too many threads,
         archive the old ones.
         """
 
-        threads = self.get_threads()
+        threads = Thread.objects.filter(archived=False)
         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:
                 thread.archived = True
                 thread.last_edit_time = timezone.now()
                 thread.save()
 
     def connect_replies(self, post):
         """
         Connect replies to a post to show them as a reflink map
         """
 
         for reply_number in re.finditer(REGEX_REPLY, post.text.raw):
             post_id = reply_number.group(1)
             ref_post = self.filter(id=post_id)
             if ref_post.count() > 0:
                 referenced_post = ref_post[0]
                 referenced_post.referenced_posts.add(post)
                 referenced_post.last_edit_time = post.pub_time
                 referenced_post.save()
 
                 referenced_thread = referenced_post.thread_new
                 referenced_thread.last_edit_time = post.pub_time
                 referenced_thread.save()
 
     def get_posts_per_day(self):
         """
         Get average count of posts per day for the last 7 days
         """
 
         today = date.today()
         ppd = cache.get(CACHE_KEY_PPD + str(today))
         if ppd:
             return ppd
 
         posts_per_days = []
         for i in POSTS_PER_DAY_RANGE:
             day_end = today - timedelta(i + 1)
             day_start = today - timedelta(i + 2)
 
             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_days.append(float(self.filter(
                 pub_time__lte=day_time_end,
                 pub_time__gte=day_time_start).count()))
 
         ppd = (sum(posts_per_day for posts_per_day in posts_per_days) /
                len(posts_per_days))
         cache.set(CACHE_KEY_PPD + str(today), ppd)
         return ppd
 
 
 class Post(models.Model):
     """A post is a message."""
 
     objects = PostManager()
 
     class Meta:
         app_label = APP_LABEL_BOARDS
 
     # TODO Save original file name to some field
     def _update_image_filename(self, filename):
         """Get unique image filename"""
 
         path = IMAGES_DIRECTORY
         new_name = str(int(time.mktime(time.gmtime())))
         new_name += str(int(random() * 1000))
         new_name += FILE_EXTENSION_DELIMITER
         new_name += filename.split(FILE_EXTENSION_DELIMITER)[-1:][0]
 
         return os.path.join(path, new_name)
 
     title = models.CharField(max_length=TITLE_MAX_LENGTH)
     pub_time = models.DateTimeField()
     text = MarkupField(default_markup_type=DEFAULT_MARKUP_TYPE,
                        escape_html=False)
 
     image_width = models.IntegerField(default=0)
     image_height = models.IntegerField(default=0)
 
     image_pre_width = models.IntegerField(default=0)
     image_pre_height = models.IntegerField(default=0)
 
     image = thumbs.ImageWithThumbsField(upload_to=_update_image_filename,
                                         blank=True, sizes=(IMAGE_THUMB_SIZE,),
                                         width_field='image_width',
                                         height_field='image_height',
                                         preview_width_field='image_pre_width',
                                         preview_height_field='image_pre_height')
     image_hash = models.CharField(max_length=36)
 
     poster_ip = models.GenericIPAddressField()
     poster_user_agent = models.TextField()
 
     thread = models.ForeignKey('Post', null=True, default=None)
     thread_new = models.ForeignKey('Thread', null=True, default=None)
     last_edit_time = models.DateTimeField()
     user = models.ForeignKey('User', null=True, default=None)
 
     referenced_posts = models.ManyToManyField('Post', symmetrical=False,
                                               null=True,
                                               blank=True, related_name='rfp+')
 
     def __unicode__(self):
         return '#' + str(self.id) + ' ' + self.title + ' (' + \
                self.text.raw[:50] + ')'
 
     def get_title(self):
         title = self.title
         if len(title) == 0:
             title = self.text.rendered
 
         return title
 
     def get_sorted_referenced_posts(self):
         return self.referenced_posts.order_by('id')
 
     def is_referenced(self):
         return self.referenced_posts.all().exists()
 
     def is_opening(self):
         return self.thread_new.get_opening_post() == self
 
     def save(self, *args, **kwargs):
         """
         Save the model and compute the image hash
         """
 
         if not self.pk and self.image:
             md5 = hashlib.md5()
             for chunk in self.image.chunks():
                 md5.update(chunk)
             self.image_hash = md5.hexdigest()
         super(Post, self).save(*args, **kwargs)
 
     @transaction.atomic
     def add_tag(self, tag):
         edit_time = timezone.now()
 
         thread = self.thread_new
         thread.add_tag(tag)
         self.last_edit_time = edit_time
         self.save()
 
         thread.last_edit_time = edit_time
         thread.save()
 
     @transaction.atomic
     def remove_tag(self, tag):
         edit_time = timezone.now()
 
         thread = self.thread_new
         thread.remove_tag(tag)
         self.last_edit_time = edit_time
         self.save()
 
         thread.last_edit_time = edit_time
         thread.save()
 
     def get_url(self):
         """
         Get full url to this post
         """
 
         cache_key = CACHE_KEY_POST_URL + str(self.id)
         link = cache.get(cache_key)
 
         if not link:
             opening_post = self.thread_new.get_opening_post()
             if self != opening_post:
                 link = reverse('thread',
                         kwargs={'post_id': opening_post.id}) + '#' + str(
                                 self.id)
             else:
                 link = reverse('thread', kwargs={'post_id': self.id})
 
             cache.set(cache_key, link)
 
         return link
 
 
 class Thread(models.Model):
 
     class Meta:
         app_label = APP_LABEL_BOARDS
 
     tags = models.ManyToManyField('Tag')
     bump_time = models.DateTimeField()
     last_edit_time = models.DateTimeField()
     replies = models.ManyToManyField('Post', symmetrical=False, null=True,
                                      blank=True, related_name='tre+')
     archived = models.BooleanField(default=False)
 
     def get_tags(self):
         """
         Get a sorted tag list
         """
 
         return self.tags.order_by('name')
 
     def bump(self):
         """
         Bump (move to up) thread
         """
 
         if self.can_bump():
             self.bump_time = timezone.now()
 
     def get_reply_count(self):
         return self.replies.count()
 
     def get_images_count(self):
         return self.replies.filter(image_width__gt=0).count()
 
     def can_bump(self):
         """
         Check if the thread can be bumped by replying
         """
 
         if self.archived:
             return False
 
         post_count = self.get_reply_count()
 
         return post_count < settings.MAX_POSTS_PER_THREAD
 
     def delete_with_posts(self):
         """
         Completely delete thread and all its posts
         """
 
         if self.replies.count() > 0:
             self.replies.all().delete()
 
         self.delete()
 
     def get_last_replies(self):
         """
         Get 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)
                 last_replies = self.replies.all().order_by('pub_time')[
                                reply_count - reply_count_to_show:]
 
                 return last_replies
 
     def get_skipped_replies_count(self):
         last_replies = self.get_last_replies()
         return self.get_reply_count() - len(last_replies) - 1
 
     def get_replies(self):
         """
         Get sorted thread posts
         """
 
         return self.replies.all().order_by('pub_time')
 
     def add_tag(self, tag):
         """
         Connect thread to a tag and tag to a thread
         """
 
         self.tags.add(tag)
         tag.threads.add(self)
 
     def remove_tag(self, tag):
         self.tags.remove(tag)
         tag.threads.remove(self)
 
     def get_opening_post(self):
         """
         Get first post of the thread
         """
 
         # cache_key = CACHE_KEY_OPENING_POST + str(self.id)
         # opening_post = cache.get(cache_key)
         # if not opening_post:
         opening_post = self.get_replies()[0]
             # cache.set(cache_key, opening_post)
 
         return opening_post
 
     def __unicode__(self):
         return str(self.id)
 
     def get_pub_time(self):
         """
         Thread does not have its own pub time, so we need to get it from
         the opening post
         """
 
         return self.get_opening_post().pub_time

boards/rss.py

@@ -1,79 +1,79 b''
 from django.contrib.syndication.views import Feed
 from django.core.urlresolvers import reverse
 from django.shortcuts import get_object_or_404
-from boards.models import Post, Tag
+from boards.models import Post, Tag, Thread
 from neboard import settings
 
 __author__ = 'neko259'
 
 
 # TODO Make tests for all of these
 class AllThreadsFeed(Feed):
 
     title = settings.SITE_NAME + ' - All threads'
     link = '/'
     description_template = 'boards/rss/post.html'
 
     def items(self):
-        return Post.objects.get_threads(order_by='-id')
+        return Thread.objects.filter(archived=False).order_by('-id')
 
     def item_title(self, item):
         return item.get_opening_post().title
 
     def item_link(self, item):
         return reverse('thread', args={item.get_opening_post().id})
 
     def item_pubdate(self, item):
         return item.get_pub_time()
 
 
 class TagThreadsFeed(Feed):
 
     link = '/'
     description_template = 'boards/rss/post.html'
 
     def items(self, obj):
-        return Post.objects.get_threads(tag=obj, order_by='-id')
+        return obj.threads.filter(archived=False).order_by('-id')
 
     def get_object(self, request, tag_name):
         return get_object_or_404(Tag, name=tag_name)
 
     def item_title(self, item):
         return item.get_opening_post().title
 
     def item_link(self, item):
         return reverse('thread', args={item.get_opening_post().id})
 
     def item_pubdate(self, item):
         return item.get_pub_time()
 
     def title(self, obj):
         return obj.name
 
 
 class ThreadPostsFeed(Feed):
 
     link = '/'
     description_template = 'boards/rss/post.html'
 
     def items(self, obj):
         return obj.thread_new.get_replies()
 
     def get_object(self, request, post_id):
         return get_object_or_404(Post, id=post_id)
 
     def item_title(self, item):
         return item.title
 
     def item_link(self, item):
         if not item.is_opening():
             return reverse('thread', args={item.thread_new.get_opening_post()
                                            .id}) + "#" + str(item.id)
         else:
             return reverse('thread', args={item.id})
 
     def item_pubdate(self, item):
         return item.pub_time
 
     def title(self, obj):
         return obj.title

boards/templates/boards/posting_general.html

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

boards/tests.py

@@ -1,257 +1,260 b''
 # coding=utf-8
 import time
 import logging
+from django.core.paginator import Paginator
 
 from django.test import TestCase
 from django.test.client import Client
 from django.core.urlresolvers import reverse, NoReverseMatch
 
-from boards.models import Post, Tag
+from boards.models import Post, Tag, Thread
 from boards import urls
 from neboard import settings
 
 PAGE_404 = 'boards/404.html'
 
 TEST_TEXT = 'test text'
 
 NEW_THREAD_PAGE = '/'
 THREAD_PAGE_ONE = '/thread/1/'
 THREAD_PAGE = '/thread/'
 TAG_PAGE = '/tag/'
 HTTP_CODE_REDIRECT = 302
 HTTP_CODE_OK = 200
 HTTP_CODE_NOT_FOUND = 404
 
 logger = logging.getLogger(__name__)
 
 
 class PostTests(TestCase):
 
     def _create_post(self):
         return Post.objects.create_post(title='title',
                                         text='text')
 
     def test_post_add(self):
         """Test adding post"""
 
         post = self._create_post()
 
         self.assertIsNotNone(post, 'No post was created')
 
     def test_delete_post(self):
         """Test post deletion"""
 
         post = self._create_post()
         post_id = post.id
 
         Post.objects.delete_post(post)
 
         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.thread_new
         reply = Post.objects.create_post("", "", thread=thread)
 
         thread.delete_with_posts()
 
         self.assertFalse(Post.objects.filter(id=reply.id).exists())
 
     def test_post_to_thread(self):
         """Test adding post to a thread"""
 
         op = self._create_post()
         post = Post.objects.create_post("", "", thread=op.thread_new)
 
         self.assertIsNotNone(post, 'Reply to thread wasn\'t created')
         self.assertEqual(op.thread_new.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(0, 2):
             Post.objects.create_post('title', 'text',
                                      thread=opening_post.thread_new)
 
         thread = opening_post.thread_new
 
         self.assertEqual(3, thread.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.thread_new
         self.assertIsNotNone(post, 'Post not created')
         self.assertTrue(tag in thread.tags.all(), 'Tag not added to thread')
         self.assertTrue(thread in tag.threads.all(), 'Thread not added to tag')
 
     def test_thread_max_count(self):
         """Test deletion of old posts when the max thread count is reached"""
 
         for i in range(settings.MAX_THREAD_COUNT + 1):
             self._create_post()
 
         self.assertEqual(settings.MAX_THREAD_COUNT,
-                         len(Post.objects.get_threads()))
+                         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.MAX_THREAD_COUNT):
             self._create_post()
 
-        all_threads = Post.objects.get_threads()
+        all_threads = Thread.objects.filter(archived=False)
 
-        posts_in_second_page = Post.objects.get_threads(page=2)
+        paginator = Paginator(Thread.objects.filter(archived=False),
+                              settings.THREADS_PER_PAGE)
+        posts_in_second_page = paginator.page(2).object_list
         first_post = posts_in_second_page[0]
 
         self.assertEqual(all_threads[settings.THREADS_PER_PAGE].id,
                          first_post.id)
 
     def test_linked_tag(self):
         """Test adding a linked tag"""
 
         linked_tag = Tag.objects.create(name=u'tag1')
         tag = Tag.objects.create(name=u'tag2', linked=linked_tag)
 
         post = Post.objects.create_post("", "", tags=[tag])
 
         self.assertTrue(linked_tag in post.thread_new.tags.all(),
                         'Linked tag was not added')
 
 
 class PagesTest(TestCase):
 
     def test_404(self):
         """Test receiving error 404 when opening a non-existent page"""
 
         tag_name = u'test_tag'
         tag = Tag.objects.create(name=tag_name)
         client = Client()
 
         Post.objects.create_post('title', TEST_TEXT, tags=[tag])
 
         existing_post_id = Post.objects.all()[0].id
         response_existing = client.get(THREAD_PAGE + str(existing_post_id) +
                                        '/')
         self.assertEqual(HTTP_CODE_OK, response_existing.status_code,
                          u'Cannot open existing thread')
 
         response_not_existing = client.get(THREAD_PAGE + str(
             existing_post_id + 1) + '/')
         self.assertEqual(PAGE_404,
                          response_not_existing.templates[0].name,
                          u'Not existing thread is opened')
 
         response_existing = client.get(TAG_PAGE + tag_name + '/')
         self.assertEqual(HTTP_CODE_OK,
                          response_existing.status_code,
                          u'Cannot open existing tag')
 
         response_not_existing = client.get(TAG_PAGE + u'not_tag' + '/')
         self.assertEqual(PAGE_404,
                          response_not_existing.templates[0].name,
                          u'Not existing tag is opened')
 
         reply_id = Post.objects.create_post('', TEST_TEXT,
                                             thread=Post.objects.all()[0]
                                             .thread)
         response_not_existing = client.get(THREAD_PAGE + str(
             reply_id) + '/')
         self.assertEqual(PAGE_404,
                          response_not_existing.templates[0].name,
                          u'Reply is opened as a thread')
 
 
 class FormTest(TestCase):
     def test_post_validation(self):
         # Disable captcha for the test
         captcha_enabled = settings.ENABLE_CAPTCHA
         settings.ENABLE_CAPTCHA = False
 
         client = Client()
 
         valid_tags = u'tag1 tag_2 тег_3'
         invalid_tags = u'$%_356 ---'
 
         response = client.post(NEW_THREAD_PAGE, {'title': 'test title',
                                                  'text': TEST_TEXT,
                                                  'tags': valid_tags})
         self.assertEqual(response.status_code, HTTP_CODE_REDIRECT,
                          msg='Posting new message failed: got code ' +
                              str(response.status_code))
 
         self.assertEqual(1, Post.objects.count(),
                          msg='No posts were created')
 
         client.post(NEW_THREAD_PAGE, {'text': TEST_TEXT,
                                       'tags': invalid_tags})
         self.assertEqual(1, Post.objects.count(), msg='The validation passed '
                                                       'where it should fail')
 
         # Change posting delay so we don't have to wait for 30 seconds or more
         old_posting_delay = settings.POSTING_DELAY
         # Wait fot the posting delay or we won't be able to post
         settings.POSTING_DELAY = 1
         time.sleep(settings.POSTING_DELAY + 1)
         response = client.post(THREAD_PAGE_ONE, {'text': TEST_TEXT,
                                                  'tags': valid_tags})
         self.assertEqual(HTTP_CODE_REDIRECT, response.status_code,
                          msg=u'Posting new message failed: got code ' +
                              str(response.status_code))
         # Restore posting delay
         settings.POSTING_DELAY = old_posting_delay
 
         self.assertEqual(2, Post.objects.count(),
                          msg=u'No posts were created')
 
         # Restore captcha setting
         settings.ENABLE_CAPTCHA = captcha_enabled
 
 
 class ViewTest(TestCase):
 
     def test_all_views(self):
         '''
         Try opening all views defined in ulrs.py that don't need additional
         parameters
         '''
 
         client = Client()
         for url in urls.urlpatterns:
             try:
                 view_name = url.name
                 logger.debug('Testing view %s' % view_name)
 
                 try:
                     response = client.get(reverse(view_name))
 
                     self.assertEqual(HTTP_CODE_OK, response.status_code,
                             '%s view not opened' % view_name)
                 except NoReverseMatch:
                     # This view just needs additional arguments
                     pass
                 except Exception, e:
                     self.fail('Got exception %s at %s view' % (e, view_name))
             except AttributeError:
                 # This is normal, some views do not have names
                 pass

boards/views/all_threads.py

@@ -1,125 +1,124 b''
 import string
 
-from django.core.paginator import Paginator
 from django.core.urlresolvers import reverse
 from django.db import transaction
 from django.shortcuts import render, redirect
 
 from boards import utils
+from boards.abstracts.paginator import get_paginator
 from boards.forms import ThreadForm, PlainErrorList
 from boards.models import Post, Thread, Ban, Tag
 from boards.views.banned import BannedView
 from boards.views.base import BaseBoardView, PARAMETER_FORM
 from boards.views.posting_mixin import PostMixin
 import neboard
 
 PARAMETER_CURRENT_PAGE = 'current_page'
 
 PARAMETER_PAGINATOR = 'paginator'
 
 PARAMETER_THREADS = 'threads'
 
 TEMPLATE = 'boards/posting_general.html'
 DEFAULT_PAGE = 1
 
 
 class AllThreadsView(PostMixin, BaseBoardView):
 
     def get(self, request, page=DEFAULT_PAGE, form=None):
         context = self.get_context_data(request=request)
 
         if not form:
             form = ThreadForm(error_class=PlainErrorList)
 
-        paginator = Paginator(self.get_threads(),
+        paginator = get_paginator(self.get_threads(),
                               neboard.settings.THREADS_PER_PAGE)
+        paginator.current_page = int(page)
 
         threads = paginator.page(page).object_list
 
         context[PARAMETER_THREADS] = threads
         context[PARAMETER_FORM] = form
 
         self._get_page_context(paginator, context, page)
 
         return render(request, TEMPLATE, context)
 
     def post(self, request, page=DEFAULT_PAGE):
-        context = self.get_context_data(request=request)
-
         form = ThreadForm(request.POST, request.FILES,
                           error_class=PlainErrorList)
         form.session = request.session
 
         if form.is_valid():
             return self._new_post(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, page, form)
 
     @staticmethod
     def _get_page_context(paginator, context, page):
         """
         Get pagination context variables
         """
 
         context[PARAMETER_PAGINATOR] = paginator
         context[PARAMETER_CURRENT_PAGE] = paginator.page(int(page))
 
     # TODO This method should be refactored
     @transaction.atomic
     def _new_post(self, request, form, opening_post=None, html_response=True):
         """
         Add a new thread 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['title']
         text = data['text']
 
         text = self._remove_invalid_links(text)
 
         if 'image' in data.keys():
             image = data['image']
         else:
             image = None
 
         tags = []
 
         tag_strings = data['tags']
 
         if tag_strings:
             tag_strings = tag_strings.split(' ')
             for tag_name in tag_strings:
                 tag_name = string.lower(tag_name.strip())
                 if len(tag_name) > 0:
                     tag, created = Tag.objects.get_or_create(name=tag_name)
                     tags.append(tag)
 
         post = Post.objects.create_post(title=title, text=text, ip=ip,
                                         image=image, tags=tags,
                                         user=self._get_user(request))
 
         thread_to_show = (opening_post.id if opening_post else post.id)
 
         if html_response:
             if opening_post:
                 return redirect(
                     reverse('thread', kwargs={'post_id': thread_to_show}) +
                     '#' + str(post.id))
             else:
                 return redirect('thread', post_id=thread_to_show)
 
     def get_threads(self):
         return Thread.objects.filter(archived=False).order_by('-bump_time')