Removed unused mixin. Refactored paginator a bit

boards/abstracts/paginator.py

@@ -1,91 +1,93 b''
+from boards.abstracts.constants import PARAM_PAGE
+
 __author__ = 'neko259'
 
 from django.core.paginator import Paginator
 
 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):
         super().__init__(object_list, per_page, orphans, allow_empty_first_page)
 
         self.link = None
         self.params = None
         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['page'] = page
-        url_params = '?' + '&'.join(['{}={}'.format(key, self.params[key])
+        self.params[PARAM_PAGE] = page
+        url_params = '&'.join(['{}={}'.format(key, self.params[key])
                                      for key in self.params.keys()])
-        return self.link + url_params
+        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())
  No newline at end of file
+            return self.get_page_url(current.previous_page_number())

boards/views/all_threads.py

@@ -1,132 +1,132 b''
 from django.core.paginator import EmptyPage
 from django.http import Http404
-from django.shortcuts import render, redirect
+from django.shortcuts import render
 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 FileUploadMixin, PaginatedMixin, \
+from boards.views.mixins import PaginatedMixin, \
     DispatcherMixin, PARAMETER_METHOD
-from boards.settings import SECTION_VIEW, SECTION_FORMS
 
 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'))
         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 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/mixins.py

@@ -1,62 +1,53 b''
-import boards
-from boards.settings import SECTION_FORMS
-
 PARAM_NEXT = 'next'
 PARAMETER_METHOD = 'method'
 
 PARAMETER_CURRENT_PAGE = 'current_page'
 PARAMETER_PAGINATOR = 'paginator'
 
 PARAMETER_PREV_LINK = 'prev_page_link'
 PARAMETER_NEXT_LINK = 'next_page_link'
 
 
 class DispatcherMixin:
     """
     This class contains a dispather method that can run a method specified by
     'method' request parameter.
     """
 
     def __init__(self):
         self.user = None
 
     def dispatch_method(self, *args, **kwargs):
         request = args[0]
 
         self.user = request.user
 
         method_name = None
         if PARAMETER_METHOD in request.GET:
             method_name = request.GET[PARAMETER_METHOD]
         elif PARAMETER_METHOD in request.POST:
             method_name = request.POST[PARAMETER_METHOD]
 
         if method_name:
             return getattr(self, method_name)(*args, **kwargs)
 
 
-# TODO Check if it is still used anywhere and safely remove
-class FileUploadMixin:
-    def get_max_upload_size(self):
-        return boards.settings.get_int(SECTION_FORMS, 'MaxFileSize')
-
-
 class PaginatedMixin:
     def get_page_context(self, paginator, page):
         """
         Get pagination context variables
         """
 
         params = {}
 
         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] = paginator.get_page_url(
                     current_page.previous_page_number())
         if current_page.has_next():
             params[PARAMETER_NEXT_LINK] = paginator.get_page_url(
                     current_page.next_page_number())
 
         return params

boards/views/thread/normal.py

@@ -1,33 +1,30 b''
-from boards import settings
-from boards.settings import SECTION_FORMS
 from boards.views.thread import ThreadView
-from boards.views.mixins import FileUploadMixin
 
 TEMPLATE_NORMAL = 'boards/thread_normal.html'
 
 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_mode(self):
         return 'normal'
 
     def get_data(self, thread):
         params = dict()
 
         bumpable = thread.can_bump()
         params[CONTEXT_BUMPABLE] = bumpable
         max_posts = thread.max_posts
         if bumpable and thread.has_post_limit():
             left_posts = max_posts - thread.get_reply_count()
             params[CONTEXT_POSTS_LEFT] = left_posts
             params[CONTEXT_BUMPLIMIT_PRG] = str(
                 float(left_posts) / max_posts * 100)
 
         return params