Simplify paginator page list building and unified it between different views

boards/abstracts/paginator.py

@@ -1,93 +1,106 b''
+from django.core.paginator import Paginator
 from boards.abstracts.constants import PARAM_PAGE
 
 __author__ = 'neko259'
 
-from django.core.paginator import Paginator
-
+PATTERN_PAGE_URL = '<a {} href="{}">{}</a>'
 PAGINATOR_LOOKAROUND_SIZE = 2
 
 
 def get_paginator(*args, **kwargs):
     return DividedPaginator(*args, **kwargs)
 
 
 class DividedPaginator(Paginator):
 
     lookaround_size = PAGINATOR_LOOKAROUND_SIZE
 
     def __init__(self, object_list, per_page, orphans=0,
-                 allow_empty_first_page=True, current_page=1):
+                 allow_empty_first_page=True, current_page=1, link=None, params=None):
         super().__init__(object_list, per_page, orphans, allow_empty_first_page)
 
-        self.link = None
-        self.params = None
+        self.link = link
+        self.params = params
         self.current_page = current_page
 
     def _left_range(self):
         return self.page_range[:self.lookaround_size]
 
     def _right_range(self):
         pages = self.num_pages-self.lookaround_size
         if pages <= 0:
             return []
         else:
             return self.page_range[pages:]
 
     def _center_range(self):
         index = self.page_range.index(self.current_page)
 
         start = max(self.lookaround_size, index - self.lookaround_size)
         end = min(self.num_pages - self.lookaround_size, index + self.lookaround_size + 1)
         return self.page_range[start:end]
 
     def get_divided_range(self):
         dr = list()
 
         dr += self._left_range()
         dr += self._center_range()
         dr += self._right_range()
 
         # Remove duplicates
         dr = list(set(dr))
         dr.sort()
 
         return dr
 
     def get_dividers(self):
         dividers = []
 
         prev_page = 1
         for page in self.get_divided_range():
             if page - prev_page > 1:
                 dividers.append(page)
 
                 # There can be no more than 2 dividers, so don't bother going
                 # further
                 if len(dividers) > 2:
                     break
             prev_page = page
 
         return dividers
 
-    def set_url(self, link, params):
-        self.link = link
-        self.params = params
-
     def get_page_url(self, page):
         self.params[PARAM_PAGE] = page
         url_params = '&'.join(['{}={}'.format(key, self.params[key])
                                for key in self.params.keys()])
         return '{}?{}'.format(self.link, url_params)
 
     def supports_urls(self):
         return self.link is not None and self.params is not None
 
     def get_next_page_url(self):
         current = self.page(self.current_page)
         if current.has_next():
             return self.get_page_url(current.next_page_number())
 
     def get_prev_page_url(self):
         current = self.page(self.current_page)
         if current.has_previous():
             return self.get_page_url(current.previous_page_number())
+
+    def get_page_url_list(self):
+        output = []
+
+        dividers = self.get_dividers()
+        for page in self.get_divided_range():
+            if page in dividers:
+                output.append('...')
+
+            if page == self.current_page:
+                cls = 'class="current_page'
+            else:
+                cls = ''
+            output.append(PATTERN_PAGE_URL.format(cls, self.get_page_url(page),
+                                                  page))
+
+        return ', '.join(output)

boards/templates/boards/all_threads.html

@@ -1,184 +1,162 b''
 {% extends "boards/paginated.html" %}
 
 {% load i18n %}
 {% load board %}
 {% load static %}
 {% load tz %}
 
 {% block head %}
     <meta name="robots" content="noindex">
 
     {% if tag %}
         <title>{{ tag.get_localized_name }} - {{ site_name }}</title>
     {% else %}
         <title>{{ site_name }}</title>
     {% endif %}
 
     {% if prev_page_link %}
         <link rel="prev" href="{{ prev_page_link|safe }}" />
     {% endif %}
     {% if next_page_link %}
         <link rel="next" href="{{ next_page_link|safe }}" />
     {% endif %}
 
 {% endblock %}
 
 {% block content %}
 
     {% get_current_language as LANGUAGE_CODE %}
     {% get_current_timezone as TIME_ZONE %}
 
     {% for banner in banners %}
         <div class="post">
             <div class="title">{{ banner.title }}</div>
             <div>{{ banner.get_text|safe }}</div>
             <div>{% trans 'Details' %}: <a href="{{ banner.post.get_absolute_url|safe }}">>>{{ banner.post.id }}</a></div>
         </div>
     {% endfor %}
 
 {% if tag %}
     <div class="tag_info" style="border: solid .5ex #{{ tag.get_color }}">
         {% if random_image_post %}
             <div class="tag-image">
                 {% with image=random_image_post.get_first_image %}
                     <a href="{{ random_image_post.get_absolute_url|safe }}"><img
                         src="{{ image.get_thumb_url|safe }}"
                         width="{{ image.get_preview_size.0 }}"
                         height="{{ image.get_preview_size.1 }}"
                         alt="{{ random_image_post.id }}"/></a>
                 {% endwith %}
             </div>
         {% endif %}
         <div class="tag-text-data">
             <h2>
                 /{{ tag.get_view|safe }}/
             </h2>
             {% if perms.change_tag %}
                 <div class="moderator_info"><a href="{% url 'admin:boards_tag_change' tag.id %}">{% trans 'Edit tag' %}</a></div>
             {% endif %}
             <p>
                 <form action="{% url 'tag' tag.get_name %}" method="post" class="post-button-form">
                     {% if is_favorite %}
                         <button name="method" value="unsubscribe" class="fav">★ {% trans "Remove from favorites" %}</button>
                     {% else %}
                         <button name="method" value="subscribe" class="not_fav">★ {% trans "Add to favorites" %}</button>
                     {% endif %}
                 </form>
                 &bull;
                 <form action="{% url 'tag' tag.get_name %}" method="post" class="post-button-form">
                     {% if is_hidden %}
                         <button name="method" value="unhide" class="fav">{% trans "Show" %}</button>
                     {% else %}
                         <button name="method" value="hide" class="not_fav">{% trans "Hide" %}</button>
                     {% endif %}
                 </form>
                 &bull;
                 <a href="{% url 'tag_gallery' tag.get_name %}">{% trans 'Gallery' %}</a>
             </p>
             {% if tag.get_description %}
                 <p>{{ tag.get_description|safe }}</p>
             {% endif %}
             <p>
                 {% with active_count=tag.get_active_thread_count bumplimit_count=tag.get_bumplimit_thread_count archived_count=tag.get_archived_thread_count %}
                     {% if active_count %}
                         ● {{ active_count }}&ensp;
                     {% endif %}
                     {% if bumplimit_count %}
                         ◍ {{ bumplimit_count }}&ensp;
                     {% endif %}
                     {% if archived_count %}
                         ○ {{ archived_count }}&ensp;
                     {% endif %}
                 {% endwith %}
                 ♥ {{ tag.get_post_count }}
             </p>
             {% if tag.get_all_parents %}
                 <p>
                     {% for parent in tag.get_all_parents %}
                         {{ parent.get_view|safe }} &gt;
                     {% endfor %}
                     {{ tag.get_view|safe }}
                 </p>
             {% endif %}
             {% if tag.get_children.all %}
                 <p>
                 {% trans "Subsections: " %}
                 {% for child in tag.get_children.all %}
                     {{ child.get_view|safe }}{% if not forloop.last%}, {% endif %}
                 {% endfor %}
                 </p>
             {% endif %}
         </div>
     </div>
 {% endif %}
 
     {% if threads %}
         {% if prev_page_link %}
             <div class="page_link">
                 <a href="{{ prev_page_link }}">&lt;&lt; {% trans "Previous page" %} &lt;&lt;</a>
             </div>
         {% endif %}
 
         {% for thread in threads %}
             <div class="thread">
                 {% post_view thread.get_opening_post thread=thread truncated=True need_open_link=True %}
                 {% if not thread.archived %}
                     {% with last_replies=thread.get_last_replies %}
                         {% if last_replies %}
                             {% with skipped_replies_count=thread.get_skipped_replies_count %}
                                 {% if skipped_replies_count %}
                                     <div class="skipped_replies">
                                         <a href="{% url 'thread' thread.get_opening_post_id %}">
                                             {% blocktrans count count=skipped_replies_count %}Skipped {{ count }} reply. Open thread to see all replies.{% plural %}Skipped {{ count }} replies. Open thread to see all replies.{% endblocktrans %}
                                         </a>
                                     </div>
                                 {% endif %}
                             {% endwith %}
                             <div class="last-replies">
                                 {% for post in last_replies %}
                                     {% post_view post truncated=True %}
                                 {% endfor %}
                             </div>
                         {% endif %}
                     {% endwith %}
                 {% endif %}
             </div>
         {% endfor %}
 
         {% if next_page_link %}
             <div class="page_link">
                 <a href="{{ next_page_link }}">&gt;&gt; {% trans "Next page" %} &gt;&gt;</a>
             </div>
         {% endif %}
     {% else %}
         <div class="post">
             {% trans 'No threads exist. Create the first one!' %}</div>
     {% endif %}
 
     {% form_view form=form new_thread=True %}
 
     <script src="{% static 'js/thread_create.js' %}"></script>
 
 {% endblock %}
-
-{% block metapanel %}
-
-    <span class="metapanel">
-        {% trans "Pages:" %}
-        [
-        {% with dividers=paginator.get_dividers %}
-            {% for page in paginator.get_divided_range %}
-                {% if page in dividers %}
-                    …,
-                {% endif %}
-                <a
-                    {% ifequal page current_page.number %}
-                        class="current_page"
-                    {% endifequal %}
-                    href="{% page_url paginator page %}">{{ page }}</a>{% if not forloop.last %},{% endif %}
-            {% endfor %}
-        {% endwith %}
-        ]
-    </span>
-
-{% endblock %}

boards/templates/boards/notifications.html

@@ -1,35 +1,35 b''
-{% extends 'boards/base.html' %}
+{% extends 'boards/paginated.html' %}
 
 {% load board %}
 {% load i18n %}
 
 {% block head %}
     <meta name="robots" content="noindex">
     <title>{{ site_name }} - {% trans 'Notifications' %} - {{ notification_usernames|join:', ' }}</title>
 {% endblock %}
 
 {% block content %}
     <div class="tag_info">
     {% for username in notification_usernames %}
         <a href="{% url 'notifications' username %}" class="user-cast">@{{ username }}</a>
     {% endfor %}
     </div>
 
     {% if page %}
         {% if page.has_previous %}
             <div class="page_link">
             <a href="?page={{ page.previous_page_number }}">{% trans "Previous page" %}</a>
             </div>
         {% endif %}
 
         {% for post in page.object_list %}
             {% post_view post need_op_data=True %}
         {% endfor %}
 
         {% if page.has_next %}
             <div class="page_link">
                 <a href="?page={{ page.next_page_number }}">{% trans "Next page" %}</a>
             </div>
         {% endif %}
     {% endif %}
 {% endblock %}

boards/templates/boards/paginated.html

@@ -1,26 +1,12 b''
 {% extends 'boards/base.html' %}
 
 {% load i18n %}
 {% load board %}
 
 {% block metapanel %}
 
     <span class="metapanel">
-        {% trans "Pages:" %}
-        [
-        {% with dividers=paginator.get_dividers %}
-            {% for page in paginator.get_divided_range %}
-                {% if page in dividers %}
-                    …,
-                {% endif %}
-                <a
-                    {% ifequal page current_page.number %}
-                        class="current_page"
-                    {% endifequal %}
-                    href="{% page_url paginator page %}">{{ page }}</a>{% if not forloop.last %},{% endif %}
-            {% endfor %}
-        {% endwith %}
-        ]
+        {% trans "Pages:" %} [{{ paginator.get_page_url_list|safe }}]
     </span>
 
 {% endblock %}

boards/templates/boards/tag_gallery.html

@@ -1,114 +1,90 b''
-{% extends "boards/base.html" %}
+{% extends "boards/paginated.html" %}
 
 {% load i18n %}
 {% load board %}
 {% load static %}
 {% load tz %}
 
 {% block head %}
     <meta name="robots" content="noindex">
 
     <title>{{ tag.name }} - {% trans 'Gallery' %} - {{ site_name }}</title>
 
     {% if prev_page_link %}
         <link rel="prev" href="{{ prev_page_link }}" />
     {% endif %}
     {% if next_page_link %}
         <link rel="next" href="{{ next_page_link }}" />
     {% endif %}
 
 {% endblock %}
 
 {% block content %}
 
     {% get_current_language as LANGUAGE_CODE %}
     {% get_current_timezone as TIME_ZONE %}
 
     {% for banner in banners %}
         <div class="post">
             <div class="title">{{ banner.title }}</div>
             <div>{{ banner.get_text }}</div>
             <div>{% trans 'Details' %}: <a href="{{ banner.post.get_absolute_url }}">>>{{ banner.post.id }}</a></div>
         </div>
     {% endfor %}
 
     <div class="tag_info" style="border-bottom: solid .5ex #{{ tag.get_color }}">
         {% if random_image_post %}
             <div class="tag-image">
                 {% with image=random_image_post.get_first_image %}
                     <a href="{{ random_image_post.get_absolute_url }}"><img 
                         src="{{ image.get_thumb_url }}"
                         width="{{ image.get_preview_size.0 }}"
                         height="{{ image.get_preview_size.1 }}"
                         alt="{{ random_image_post.id }}"/></a>
                 {% endwith %}
             </div>
         {% endif %}
         <div class="tag-text-data">
             <h2>
                 /{{ tag.get_view|safe }}/
                 {% if perms.change_tag %}
                 <span class="moderator_info">| <a href="{% url 'admin:boards_tag_change' tag.id %}">{% trans 'Edit tag' %}</a></span>
                 {% endif %}
             </h2>
             {% if tag.get_description %}
                 <p>{{ tag.get_description|safe }}</p>
             {% endif %}
             {% if tag.get_all_parents %}
                 <p>
                     {% for parent in tag.get_all_parents %}
                         {{ parent.get_view|safe }} &gt;
                     {% endfor %}
                     {{ tag.get_view|safe }}
                 </p>
             {% endif %}
         </div>
     </div>
 
     {% if prev_page_link %}
         <div class="page_link">
             <a href="{{ prev_page_link }}">{% trans "Previous page" %}</a>
         </div>
     {% endif %}
 
     <div id="posts-table">
     {% for image in images %}
         <div class="gallery_image">
             {{ image.get_view|safe }}
             <div class="gallery_image_metadata">
                 {{ image.get_size.0 }}x{{ image.get_size.1 }}
             </div>
         </div>
     {% endfor %}
     </div>
 
     {% if next_page_link %}
         <div class="page_link">
             <a href="{{ next_page_link }}">{% trans "Next page" %}</a>
         </div>
     {% endif %}
 {% endblock %}
-
-{% block metapanel %}
-
-    <span class="metapanel">
-        <b><a href="{% url "authors" %}">{{ site_name }}</a> {{ version }}</b>
-        {% trans "Pages:" %}
-        [
-        {% with dividers=paginator.get_dividers %}
-            {% for page in paginator.get_divided_range %}
-                {% if page in dividers %}
-                    …,
-                {% endif %}
-                <a
-                    {% ifequal page paginator.current_page %}
-                        class="current_page"
-                    {% endifequal %}
-                    href="{% page_url paginator page %}">{{ page }}</a>
-                {% if not forloop.last %},{% endif %}
-            {% endfor %}
-        {% endwith %}
-        ]
-    </span>
-
-{% endblock %}

boards/views/all_threads.py

@@ -1,132 +1,133 b''
 from django.core.paginator import EmptyPage
 from django.http import Http404
 from django.shortcuts import render, redirect
 from django.urls import reverse
 from django.utils.decorators import method_decorator
 from django.views.decorators.csrf import csrf_protect
 
 from boards import settings
 from boards.abstracts.constants import PARAM_PAGE
 from boards.abstracts.paginator import get_paginator
 from boards.abstracts.settingsmanager import get_settings_manager, \
     SETTING_ONLY_FAVORITES
 from boards.forms import ThreadForm, PlainErrorList
 from boards.models import Post, Thread
 from boards.settings import SECTION_VIEW
 from boards.views.base import BaseBoardView, CONTEXT_FORM
 from boards.views.mixins import PaginatedMixin, \
     DispatcherMixin, PARAMETER_METHOD
 
 ORDER_BUMP = 'bump'
 
 PARAM_ORDER = 'order'
 
 FORM_TAGS = 'tags'
 FORM_TEXT = 'text'
 FORM_TITLE = 'title'
 FORM_IMAGE = 'image'
 FORM_THREADS = 'threads'
 
 TAG_DELIMITER = ' '
 
 PARAMETER_CURRENT_PAGE = 'current_page'
 PARAMETER_PAGINATOR = 'paginator'
 PARAMETER_THREADS = 'threads'
 PARAMETER_ADDITIONAL = 'additional_params'
 PARAMETER_RSS_URL = 'rss_url'
 
 TEMPLATE = 'boards/all_threads.html'
 DEFAULT_PAGE = 1
 
 
 class AllThreadsView(BaseBoardView, PaginatedMixin, DispatcherMixin):
 
     tag_name = ''
 
     def __init__(self):
         self.settings_manager = None
         super(AllThreadsView, self).__init__()
 
     @method_decorator(csrf_protect)
     def get(self, request, form: ThreadForm=None):
         page = request.GET.get(PARAM_PAGE, DEFAULT_PAGE)
 
         params = self.get_context_data(request=request)
 
         if not form:
             form = ThreadForm(error_class=PlainErrorList,
                               initial={FORM_TAGS: self.tag_name})
 
         self.settings_manager = get_settings_manager(request)
 
         threads = self.get_threads()
 
         order = request.GET.get(PARAM_ORDER, ORDER_BUMP)
         if order == ORDER_BUMP:
             threads = threads.order_by('-bump_time')
         else:
             threads = threads.filter(replies__opening=True)\
                 .order_by('-replies__pub_time')
         threads = threads.distinct()
 
         paginator = get_paginator(threads, settings.get_int(
-            SECTION_VIEW, 'ThreadsPerPage'))
+            SECTION_VIEW, 'ThreadsPerPage'),
+                                  link=self.get_reverse_url(),
+                                  params=request.GET.dict())
         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_RSS_URL] = self.get_rss_url()
 
-        paginator.set_url(self.get_reverse_url(), request.GET.dict())
         params.update(self.get_page_context(paginator, page))
 
         return render(request, TEMPLATE, params)
 
     @method_decorator(csrf_protect)
     def post(self, request):
         if PARAMETER_METHOD in request.POST:
             self.dispatch_method(request)
 
             return redirect(self.get_reverse_url())
 
         form = ThreadForm(request.POST, request.FILES,
                           error_class=PlainErrorList)
         form.session = request.session
 
         if form.is_valid():
             return Post.objects.create_from_form(request, form, None)
         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_reverse_url(self):
         return reverse('index')
 
     def get_threads(self):
         """
         Gets list of threads that will be shown on a page.
         """
 
         threads = Thread.objects\
             .exclude(tags__in=self.settings_manager.get_hidden_tags())
         if self.settings_manager.get_setting(SETTING_ONLY_FAVORITES):
             fav_tags = self.settings_manager.get_fav_tags()
             if len(fav_tags) > 0:
                 threads = threads.filter(tags__in=fav_tags)
 
         return threads
 
     def get_rss_url(self):
         return self.get_reverse_url() + 'rss/'
 
     def toggle_fav(self, request):
         settings_manager = get_settings_manager(request)
         settings_manager.set_setting(SETTING_ONLY_FAVORITES,
                 not settings_manager.get_setting(SETTING_ONLY_FAVORITES, False))

boards/views/feed.py

@@ -1,132 +1,132 b''
 from django.urls import reverse
 from django.shortcuts import render
 
 from boards import settings
 from boards.abstracts.constants import PARAM_PAGE
 from boards.abstracts.paginator import get_paginator
 from boards.abstracts.settingsmanager import get_settings_manager
 from boards.models import Post
 from boards.settings import SECTION_VIEW
 from boards.views.base import BaseBoardView
 from boards.views.mixins import PaginatedMixin
 
 POSTS_PER_PAGE = settings.get_int(SECTION_VIEW, 'PostsPerPage')
 
 PARAMETER_POSTS = 'posts'
 PARAMETER_QUERIES = 'queries'
 
 TEMPLATE = 'boards/feed.html'
 DEFAULT_PAGE = 1
 
 
 class FeedFilter:
     @staticmethod
     def get_filtered_posts(request, posts):
         return posts
 
     @staticmethod
     def get_query(request):
         return None
 
 
 class TripcodeFilter(FeedFilter):
     @staticmethod
     def get_filtered_posts(request, posts):
         filtered_posts = posts
         tripcode = request.GET.get('tripcode', None)
         if tripcode:
             filtered_posts = filtered_posts.filter(tripcode=tripcode)
         return filtered_posts
 
     @staticmethod
     def get_query(request):
         tripcode = request.GET.get('tripcode', None)
         if tripcode:
             return 'Tripcode: {}'.format(tripcode)
 
 
 class FavoritesFilter(FeedFilter):
     @staticmethod
     def get_filtered_posts(request, posts):
         filtered_posts = posts
 
         favorites = 'favorites' in request.GET
         if favorites:
             settings_manager = get_settings_manager(request)
             last_posts = settings_manager.get_last_posts()
             threads = [post.get_thread() for post in last_posts]
             filtered_posts = filtered_posts.filter(thread__in=threads)
         return filtered_posts
 
 
 class IpFilter(FeedFilter):
     @staticmethod
     def get_filtered_posts(request, posts):
         filtered_posts = posts
 
         ip = request.GET.get('ip', None)
         if ip and request.user.has_perm('post_delete'):
             filtered_posts = filtered_posts.filter(poster_ip=ip)
         return filtered_posts
 
     @staticmethod
     def get_query(request):
         ip = request.GET.get('ip', None)
         if ip:
             return 'IP: {}'.format(ip)
 
 
 class ImageFilter(FeedFilter):
     @staticmethod
     def get_filtered_posts(request, posts):
         filtered_posts = posts
 
         image = request.GET.get('image', None)
         if image:
             filtered_posts = filtered_posts.filter(attachments__file=image)
         return filtered_posts
 
     @staticmethod
     def get_query(request):
         image = request.GET.get('image', None)
         if image:
             return 'File: {}'.format(image)
 
 
 class FeedView(PaginatedMixin, BaseBoardView):
     filters = (
             TripcodeFilter,
             FavoritesFilter,
             IpFilter,
             ImageFilter,
     )
 
     def get(self, request):
         page = request.GET.get(PARAM_PAGE, DEFAULT_PAGE)
 
         params = self.get_context_data(request=request)
 
         settings_manager = get_settings_manager(request)
 
         posts = Post.objects.exclude(
             thread__tags__in=settings_manager.get_hidden_tags()).order_by(
             '-pub_time').prefetch_related('attachments', 'thread')
         queries = []
         for filter in self.filters:
             posts = filter.get_filtered_posts(request, posts)
             query = filter.get_query(request)
             if query:
                 queries.append(query)
         params[PARAMETER_QUERIES] = queries
 
-        paginator = get_paginator(posts, POSTS_PER_PAGE)
+        paginator = get_paginator(posts, POSTS_PER_PAGE,
+                                  link=reverse('feed'),
+                                  params=request.GET.dict())
         paginator.current_page = int(page)
 
         params[PARAMETER_POSTS] = paginator.page(page).object_list
 
-        paginator.set_url(reverse('feed'), request.GET.dict())
-
         params.update(self.get_page_context(paginator, page))
 
         return render(request, TEMPLATE, params)
 

boards/views/notifications.py

@@ -1,48 +1,51 b''
 from django.shortcuts import render
+from django.urls import reverse
 
 from boards.abstracts.constants import PARAM_PAGE
 from boards.abstracts.paginator import get_paginator
 from boards.abstracts.settingsmanager import get_settings_manager, \
     SETTING_LAST_NOTIFICATION_ID
 from boards.models.user import Notification
 from boards.views.base import BaseBoardView
+from boards.views.mixins import PaginatedMixin
 
 DEFAULT_PAGE = '1'
 
 TEMPLATE = 'boards/notifications.html'
 PARAM_USERNAMES = 'notification_usernames'
 RESULTS_PER_PAGE = 10
 
 
-class NotificationView(BaseBoardView):
+class NotificationView(BaseBoardView, PaginatedMixin):
 
     def get(self, request, username=None):
         params = self.get_context_data()
 
         settings_manager = get_settings_manager(request)
 
         # If we open our notifications, reset the "new" count
         if username is None:
             notification_usernames = settings_manager.get_notification_usernames()
         else:
             notification_usernames = [username]
 
         posts = Notification.objects.get_notification_posts(
                 usernames=notification_usernames, user_settings=settings_manager.get_user_settings())
 
         if username is None:
             last = posts.first()
             if last is not None:
                 last_id = last.id
                 settings_manager.set_setting(SETTING_LAST_NOTIFICATION_ID,
                                              last_id)
 
-
-        paginator = get_paginator(posts, RESULTS_PER_PAGE)
-
         page = int(request.GET.get(PARAM_PAGE, DEFAULT_PAGE))
+        paginator = get_paginator(posts, RESULTS_PER_PAGE,
+                                  link=reverse('notifications'),
+                                  params=request.GET.dict())
 
         params[PARAM_PAGE] = paginator.page(page)
         params[PARAM_USERNAMES] = notification_usernames
+        params.update(self.get_page_context(paginator, page))
 
         return render(request, TEMPLATE, params)

boards/views/search.py

@@ -1,54 +1,55 b''
 from django.shortcuts import render
 from django.views.generic import View
 from django.db.models import Q
 from django.urls import reverse
 
 from boards.abstracts.paginator import get_paginator
 from boards.forms import SearchForm, PlainErrorList
 from boards.models import Post, Tag
 from boards.views.mixins import PaginatedMixin
 
 
 MIN_QUERY_LENGTH = 3
 RESULTS_PER_PAGE = 10
 
 FORM_QUERY = 'query'
 
 CONTEXT_QUERY = 'query'
 CONTEXT_FORM = 'form'
 CONTEXT_PAGE = 'page'
 CONTEXT_TAGS = 'tags'
 
 REQUEST_PAGE = 'page'
 
 __author__ = 'neko259'
 
 TEMPLATE = 'search/search.html'
 
 
 class BoardSearchView(View, PaginatedMixin):
     def get(self, request):
         params = dict()
 
         form = SearchForm(request.GET, error_class=PlainErrorList)
         params[CONTEXT_FORM] = form
 
         if form.is_valid():
             query = form.cleaned_data[FORM_QUERY]
             if len(query) >= MIN_QUERY_LENGTH:
                 results = Post.objects.filter(Q(text__icontains=query)
                         | Q(title__icontains=query) | Q(opening=True,
                             thread__tags__aliases__name__icontains=query)
                         | Q(attachments__url__icontains=query)).order_by('-id').distinct()
-                paginator = get_paginator(results, RESULTS_PER_PAGE)
-                paginator.set_url(reverse('search'), request.GET.dict())
+                paginator = get_paginator(results, RESULTS_PER_PAGE,
+                                          link=reverse('search'),
+                                          params=request.GET.dict())
 
                 page = int(request.GET.get(REQUEST_PAGE, '1'))
 
                 params[CONTEXT_QUERY] = query
                 params.update(self.get_page_context(paginator, page))
 
                 tags = Tag.objects.get_tag_url_list(Tag.objects.filter(aliases__name__icontains=query))
                 params[CONTEXT_TAGS] = tags
 
         return render(request, TEMPLATE, params)

boards/views/tag_gallery.py

@@ -1,34 +1,36 b''
 from django.shortcuts import get_object_or_404, render
 from django.urls import reverse
 
 from boards import settings
 from boards.abstracts.constants import PARAM_PAGE
 from boards.abstracts.paginator import get_paginator
 from boards.models import TagAlias
 from boards.settings import SECTION_VIEW
 from boards.views.base import BaseBoardView
 from boards.views.mixins import PaginatedMixin
 
 IMAGES_PER_PAGE = settings.get_int(SECTION_VIEW, 'ImagesPerPageGallery')
 
 TEMPLATE = 'boards/tag_gallery.html'
 
 
 class TagGalleryView(BaseBoardView, PaginatedMixin):
 
     def get(self, request, tag_name):
         page = int(request.GET.get(PARAM_PAGE, 1))
 
         params = dict()
         tag_alias = get_object_or_404(TagAlias, name=tag_name)
         tag = tag_alias.parent
         params['tag'] = tag
-        paginator = get_paginator(tag.get_images(), IMAGES_PER_PAGE,
-                                  current_page=page)
+        paginator = get_paginator(
+            tag.get_images(),
+            IMAGES_PER_PAGE,
+            current_page=page,
+            link=reverse('tag_gallery', kwargs={'tag_name': tag_name}),
+            params=request.GET.dict())
         params['paginator'] = paginator
         params['images'] = paginator.page(page).object_list
-        paginator.set_url(reverse('tag_gallery', kwargs={'tag_name': tag_name}),
-                          request.GET.dict())
         params.update(self.get_page_context(paginator, page))
 
         return render(request, TEMPLATE, params)