Even more refactoring

boards/abstracts/constants.py

@@ -1,5 +1,7 b''
 import re
 
 FILE_DIRECTORY = 'files/'
 REGEX_TAGS = re.compile(r'^[\w\s\d\']+$', re.UNICODE)
-REGEX_REPLY = re.compile(r'\[post\](\d+)\[/post\]')
  No newline at end of file
+REGEX_REPLY = re.compile(r'\[post\](\d+)\[/post\]')
+
+PARAM_PAGE = 'page'
  No newline at end of file

boards/views/all_threads.py

@@ -1,133 +1,137 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.views.base import BaseBoardView, CONTEXT_FORM
 from boards.views.mixins import FileUploadMixin, 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_MAX_FILE_SIZE = 'max_file_size'
 PARAMETER_RSS_URL = 'rss_url'
 PARAMETER_MAX_FILES = 'max_files'
 
 TEMPLATE = 'boards/all_threads.html'
 DEFAULT_PAGE = 1
 
 
 class AllThreadsView(FileUploadMixin, 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('page', DEFAULT_PAGE)
+        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})
+                              initial={FORM_TAGS: self.tag_name})
 
         self.settings_manager = get_settings_manager(request)
 
         threads = self.get_threads()
 
-        order = request.GET.get('order', 'bump')
-        if order == 'bump':
+        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')
-        filter = request.GET.get('filter')
         threads = threads.distinct()
 
-        paginator = get_paginator(threads,
-                                  settings.get_int(SECTION_VIEW, 'ThreadsPerPage'))
+        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_MAX_FILE_SIZE] = self.get_max_upload_size()
         params[PARAMETER_RSS_URL] = self.get_rss_url()
         params[PARAMETER_MAX_FILES] = settings.get_int(SECTION_FORMS, 'MaxFileCount')
 
         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('index')  # FIXME Different for different modes
+            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/feed.py

@@ -1,131 +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)
             fav_thread_ops = Post.objects.filter(id__in=settings_manager.get_fav_threads().keys())
             fav_threads = [op.get_thread() for op in fav_thread_ops]
             filtered_posts = filtered_posts.filter(thread__in=fav_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('page', DEFAULT_PAGE)
+        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.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/mixins.py

@@ -1,60 +1,61 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)
 
 
 class FileUploadMixin:
     def get_max_upload_size(self):
-        return boards.settings.get_int('Forms', 'MaxFileSize')
+        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/notifications.py

@@ -1,49 +1,48 b''
 from django.shortcuts import render
 
+from boards.abstracts.constants import PARAM_PAGE
 from boards.abstracts.paginator import get_paginator
 from boards.abstracts.settingsmanager import get_settings_manager, \
-    SETTING_USERNAME, SETTING_LAST_NOTIFICATION_ID
+    SETTING_LAST_NOTIFICATION_ID
 from boards.models.user import Notification
 from boards.views.base import BaseBoardView
 
 DEFAULT_PAGE = '1'
 
 TEMPLATE = 'boards/notifications.html'
-PARAM_PAGE = 'page'
 PARAM_USERNAMES = 'notification_usernames'
-REQUEST_PAGE = 'page'
 RESULTS_PER_PAGE = 10
 
 
 class NotificationView(BaseBoardView):
 
     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)
 
         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(REQUEST_PAGE, DEFAULT_PAGE))
+        page = int(request.GET.get(PARAM_PAGE, DEFAULT_PAGE))
 
         params[PARAM_PAGE] = paginator.page(page)
         params[PARAM_USERNAMES] = notification_usernames
 
         return render(request, TEMPLATE, params)

boards/views/tag_gallery.py

@@ -1,33 +1,34 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('page', 1))
+        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)
         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)

boards/views/utils.py

@@ -1,31 +1,31 b''
+from django.contrib.auth.decorators import permission_required
 from django.shortcuts import redirect
 from django.utils.decorators import method_decorator
 from django.views.decorators.csrf import csrf_protect
-from django.contrib.auth.decorators import permission_required
 
-from boards.views.base import BaseBoardView, CONTEXT_FORM
-from boards.views.mixins import DispatcherMixin, PARAMETER_METHOD
 from boards.models import Post, Ban
+from boards.views.base import BaseBoardView
+from boards.views.mixins import DispatcherMixin
 
 
 class UtilsView(BaseBoardView, DispatcherMixin):
     @method_decorator(csrf_protect)
     def get(self, request):
         self.dispatch_method(request)
 
         return redirect('index')
 
     @permission_required('boards.delete_post')
     def ban_and_delete(self, request):
         post = Post.objects.get(id=request.GET['post_id'])
         Ban.objects.get_or_create(ip=post.poster_ip)
         if post.is_opening():
             post.get_thread().delete()
         else:
             post.delete()
 
     @permission_required('boards.add_ban')
     def ban(self, request):
         post = Post.objects.get(id=request.GET['post_id'])
         Ban.objects.get_or_create(ip=post.poster_ip)