Pass all GET params over thread list links

boards/views/all_threads.py

@@ -1,153 +1,157 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().order_by('-bump_time'),
                                   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)
+        self.get_page_context(paginator, params, page, request.GET.dict())
 
         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):
+    def get_page_context(self, paginator, params, page, url_params):
         """
         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)
+                    current_page, url_params)
         if current_page.has_next():
-            params[PARAMETER_NEXT_LINK] = self.get_next_page_link(current_page)
+            params[PARAMETER_NEXT_LINK] = self.get_next_page_link(current_page,
+                    url_params)
+
+    def get_previous_page_link(self, current_page, params):
+        params['page'] = current_page.previous_page_number()
+        return self.get_reverse_url(params)
 
-    def get_previous_page_link(self, current_page):
-        return self.get_reverse_url() + '?page=' \
-                + str(current_page.previous_page_number())
+    def get_next_page_link(self, current_page, params):
+        params['page'] = current_page.next_page_number()
+        return self.get_reverse_url(params)
 
-    def get_next_page_link(self, current_page):
-        return self.get_reverse_url() + '?page=' \
-                + str(current_page.next_page_number())
+    def get_url_params(self, params):
+        return '?' + '&'.join(['{}={}'.format(key, params[key]) for key in params.keys()])
 
-    def get_reverse_url(self):
-        return reverse('index')
+    def get_reverse_url(self, params):
+        return reverse('index') + self.get_url_params(params)
 
     @transaction.atomic
     def create_thread(self, request, form: ThreadForm, html_response=True):
         """
         Creates a new thread with an opening post.
         """
 
         ip = utils.get_client_ip(request)
         is_banned = Ban.objects.filter(ip=ip).exists()
 
         if is_banned:
             if html_response:
                 return redirect(BannedView().as_view())
             else:
                 return
 
         data = form.cleaned_data
 
         title = form.get_title()
         text = data[FORM_TEXT]
         file = form.get_file()
         threads = data[FORM_THREADS]
 
         text = self._remove_invalid_links(text)
 
         tags = data[FORM_TAGS]
 
         post = Post.objects.create_post(title=title, text=text, file=file,
                                         ip=ip, tags=tags, opening_posts=threads,
                                         tripcode=form.get_tripcode())
 
         # 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\
             .exclude(tags__in=self.settings_manager.get_hidden_tags())

boards/views/tag_threads.py

@@ -1,119 +1,118 b''
 from django.shortcuts import get_object_or_404, redirect
 from django.core.urlresolvers import reverse
 
 from boards.abstracts.settingsmanager import get_settings_manager, \
         SETTING_FAVORITE_TAGS, SETTING_HIDDEN_TAGS
 from boards.models import Tag, PostImage
 from boards.views.all_threads import AllThreadsView, DEFAULT_PAGE
 from boards.views.mixins import DispatcherMixin, PARAMETER_METHOD
 from boards.forms import ThreadForm, PlainErrorList
 
 PARAM_HIDDEN_TAGS = 'hidden_tags'
 PARAM_TAG = 'tag'
 PARAM_IS_FAVORITE = 'is_favorite'
 PARAM_IS_HIDDEN = 'is_hidden'
 PARAM_RANDOM_IMAGE_POST = 'random_image_post'
 PARAM_RELATED_TAGS = 'related_tags'
 
 
 __author__ = 'neko259'
 
 
 class TagView(AllThreadsView, DispatcherMixin):
 
     tag_name = None
 
     def get_threads(self):
         tag = get_object_or_404(Tag, name=self.tag_name)
 
         hidden_tags = self.settings_manager.get_hidden_tags()
 
         try:
             hidden_tags.remove(tag)
         except ValueError:
             pass
 
         return tag.get_threads().exclude(
             tags__in=hidden_tags)
 
     def get_context_data(self, **kwargs):
         params = super(TagView, self).get_context_data(**kwargs)
 
         settings_manager = get_settings_manager(kwargs['request'])
 
         tag = get_object_or_404(Tag, name=self.tag_name)
         params[PARAM_TAG] = tag
 
         fav_tag_names = settings_manager.get_setting(SETTING_FAVORITE_TAGS)
         hidden_tag_names = settings_manager.get_setting(SETTING_HIDDEN_TAGS)
 
         params[PARAM_IS_FAVORITE] = fav_tag_names is not None and tag.name in fav_tag_names
         params[PARAM_IS_HIDDEN] = hidden_tag_names is not None and tag.name in hidden_tag_names
 
         params[PARAM_RANDOM_IMAGE_POST] = tag.get_random_image_post()
         params[PARAM_RELATED_TAGS] = tag.get_related_tags()
 
         return params
 
-    def get_reverse_url(self):
-        return reverse('tag', kwargs={
-            'tag_name': self.tag_name})
+    def get_reverse_url(self, params):
+        return reverse('tag', kwargs={'tag_name': self.tag_name}) + self.get_url_params(params)
 
     def get(self, request, tag_name, form=None):
         self.tag_name = tag_name
 
         return super(TagView, self).get(request, form)
 
 
     def post(self, request, tag_name):
         self.tag_name = tag_name
 
         if PARAMETER_METHOD in request.POST:
             self.dispatch_method(request)
 
             return redirect('tag', tag_name)
         else:
             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, tag_name, form)
 
     def subscribe(self, request):
         tag = get_object_or_404(Tag, name=self.tag_name)
 
         settings_manager = get_settings_manager(request)
         settings_manager.add_fav_tag(tag)
 
     def unsubscribe(self, request):
         tag = get_object_or_404(Tag, name=self.tag_name)
 
         settings_manager = get_settings_manager(request)
         settings_manager.del_fav_tag(tag)
 
     def hide(self, request):
         """
         Adds tag to user's hidden tags. Threads with this tag will not be
         shown.
         """
 
         tag = get_object_or_404(Tag, name=self.tag_name)
 
         settings_manager = get_settings_manager(request)
         settings_manager.add_hidden_tag(tag)
 
     def unhide(self, request):
         """
         Removed tag from user's hidden tags.
         """
 
         tag = get_object_or_404(Tag, name=self.tag_name)
 
         settings_manager = get_settings_manager(request)
         settings_manager.del_hidden_tag(tag)