Code cleanup part 2

boards/abstracts/paginator.py

@@ -1,22 +1,22 b''
-from django.core.paginator import Paginator
+__author__ = 'neko259'
 
-__author__ = 'neko259'
+from django.core.paginator import Paginator
 
 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/views/all_threads.py

@@ -1,133 +1,138 b''
 import string
 
 from django.db import transaction
 from django.shortcuts import render, redirect
 
 from boards import utils, settings
 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.base import BaseBoardView, CONTEXT_FORM
 from boards.views.posting_mixin import PostMixin
 
+FORM_TAGS = 'tags'
+FORM_TEXT = 'text'
+FORM_TITLE = 'title'
+FORM_IMAGE = 'image'
+
 TAG_DELIMITER = ' '
 
 PARAMETER_CURRENT_PAGE = 'current_page'
 PARAMETER_PAGINATOR = 'paginator'
 PARAMETER_THREADS = 'threads'
 
 TEMPLATE = 'boards/posting_general.html'
 DEFAULT_PAGE = 1
 
 
 class AllThreadsView(PostMixin, BaseBoardView):
 
     user = None
 
     def get(self, request, page=DEFAULT_PAGE, form=None):
         context = self.get_context_data(request=request)
 
         self.user = utils.get_user(request)
 
         if not form:
             form = ThreadForm(error_class=PlainErrorList)
 
         paginator = get_paginator(self.get_threads(),
                                   settings.THREADS_PER_PAGE)
         paginator.current_page = int(page)
 
         threads = paginator.page(page).object_list
 
         context[PARAMETER_THREADS] = threads
-        context[PARAMETER_FORM] = form
+        context[CONTEXT_FORM] = form
 
         self._get_page_context(paginator, context, page)
 
         return render(request, TEMPLATE, context)
 
     def post(self, request, page=DEFAULT_PAGE):
         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, 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))
 
     @staticmethod
     def parse_tags_string(tag_strings):
         """
         Parses tag list string and returns tag object list.
         """
 
         tags = []
 
         if tag_strings:
             tag_strings = tag_strings.split(TAG_DELIMITER)
             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)
 
         return tags
 
     @transaction.atomic
     def create_thread(self, request, form, 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 = data['title']
-        text = data['text']
+        title = data[FORM_TITLE]
+        text = data[FORM_TEXT]
 
         text = self._remove_invalid_links(text)
 
-        if 'image' in data.keys():
-            image = data['image']
+        if FORM_IMAGE in data.keys():
+            image = data[FORM_IMAGE]
         else:
             image = None
 
-        tag_strings = data['tags']
+        tag_strings = data[FORM_TAGS]
 
         tags = self.parse_tags_string(tag_strings)
 
         post = Post.objects.create_post(title=title, text=text, ip=ip,
                                         image=image, tags=tags,
                                         user=utils.get_user(request))
 
         if html_response:
             return redirect(post.get_url())
 
     def get_threads(self):
         """
         Gets list of threads that will be shown on a page.
         """
 
         return Thread.objects.all().order_by('-bump_time')\
             .exclude(tags__in=self.user.hidden_tags.all())

boards/views/base.py

@@ -1,35 +1,35 b''
 from django.db import transaction
 from django.template import RequestContext
 from django.views.generic import View
 
 from boards import utils
 from boards.models.user import Ban
 
 
 BAN_REASON_SPAM = 'Autoban: spam bot'
 
-PARAMETER_FORM = 'form'
+CONTEXT_FORM = 'form'
 
 
 class BaseBoardView(View):
 
     def get_context_data(self, **kwargs):
         request = kwargs['request']
         # context = self._default_context(request)
         context = RequestContext(request)
 
         return context
 
     @transaction.atomic
     def _ban_current_user(self, request):
         """
         Add current user to the IP ban list
         """
 
         ip = utils.get_client_ip(request)
         ban, created = Ban.objects.get_or_create(ip=ip)
         if created:
             ban.can_read = False
             ban.reason = BAN_REASON_SPAM
         ban.save()
 

boards/views/login.py

@@ -1,30 +1,30 b''
 from django.shortcuts import render, redirect
 from boards.forms import LoginForm, PlainErrorList
 from boards.models import User
-from boards.views.base import BaseBoardView, PARAMETER_FORM
+from boards.views.base import BaseBoardView, CONTEXT_FORM
 
 __author__ = 'neko259'
 
 
 class LoginView(BaseBoardView):
 
     def get(self, request, form=None):
         context = self.get_context_data(request=request)
 
         if not form:
             form = LoginForm()
-        context[PARAMETER_FORM] = form
+        context[CONTEXT_FORM] = form
 
         return render(request, 'boards/login.html', context)
 
     def post(self, request):
         form = LoginForm(request.POST, request.FILES,
                          error_class=PlainErrorList)
         form.session = request.session
 
         if form.is_valid():
             user = User.objects.get(user_id=form.cleaned_data['user_id'])
             request.session['user_id'] = user.id
             return redirect('index')
         else:
             return self.get(request, form)

boards/views/settings.py

@@ -1,53 +1,53 b''
 from django.db import transaction
 from django.shortcuts import render, redirect
 from boards import utils
 
-from boards.views.base import BaseBoardView, PARAMETER_FORM
+from boards.views.base import BaseBoardView, CONTEXT_FORM
 from boards.forms import SettingsForm, ModeratorSettingsForm, PlainErrorList
 from boards.models.post import SETTING_MODERATE
 
 
 class SettingsView(BaseBoardView):
 
     def get(self, request):
         context = self.get_context_data(request=request)
         user = utils.get_user(request)
         is_moderator = user.is_moderator()
 
         selected_theme = utils.get_theme(request, user)
 
         if is_moderator:
             form = ModeratorSettingsForm(initial={
                 'theme': selected_theme,
                 'moderate': user.get_setting(SETTING_MODERATE) and \
                             user.is_moderator()
             }, error_class=PlainErrorList)
         else:
             form = SettingsForm(initial={'theme': selected_theme},
                                 error_class=PlainErrorList)
 
-        context[PARAMETER_FORM] = form
+        context[CONTEXT_FORM] = form
 
         return render(request, 'boards/settings.html', context)
 
     def post(self, request):
         user = utils.get_user(request)
         is_moderator = user.is_moderator()
 
         with transaction.atomic():
             if is_moderator:
                 form = ModeratorSettingsForm(request.POST,
                                              error_class=PlainErrorList)
             else:
                 form = SettingsForm(request.POST, error_class=PlainErrorList)
 
             if form.is_valid():
                 selected_theme = form.cleaned_data['theme']
 
                 user.save_setting('theme', selected_theme)
 
                 if is_moderator:
                     moderate = form.cleaned_data['moderate']
                     user.save_setting(SETTING_MODERATE, moderate)
 
             return redirect('settings')

boards/views/thread.py

@@ -1,132 +1,144 b''
 from django.core.urlresolvers import reverse
 from django.db import transaction
 from django.http import Http404
 from django.shortcuts import get_object_or_404, render, redirect
 from django.views.generic.edit import FormMixin
 
 from boards import utils, settings
 from boards.forms import PostForm, PlainErrorList
 from boards.models import Post, Ban
 from boards.views.banned import BannedView
-from boards.views.base import BaseBoardView, PARAMETER_FORM
+from boards.views.base import BaseBoardView, CONTEXT_FORM
 from boards.views.posting_mixin import PostMixin
 
+TEMPLATE_GALLERY = 'boards/thread_gallery.html'
+TEMPLATE_NORMAL = 'boards/thread.html'
+
+CONTEXT_POSTS = 'posts'
+CONTEXT_OP = 'opening_post'
+CONTEXT_BUMPLIMIT_PRG = 'bumplimit_progress'
+CONTEXT_POSTS_LEFT = 'posts_left'
+CONTEXT_LASTUPDATE = "last_update"
+CONTEXT_MAX_REPLIES = 'max_replies'
+CONTEXT_THREAD = 'thread'
+CONTEXT_BUMPABLE = 'bumpable'
+
+FORM_TITLE = 'title'
+FORM_TEXT = 'text'
+FORM_IMAGE = 'image'
 
 MODE_GALLERY = 'gallery'
 MODE_NORMAL = 'normal'
 
-PARAMETER_MAX_REPLIES = 'max_replies'
-PARAMETER_THREAD = 'thread'
-PARAMETER_BUMPABLE = 'bumpable'
-
 
 class ThreadView(BaseBoardView, PostMixin, FormMixin):
 
     def get(self, request, post_id, mode=MODE_NORMAL, form=None):
         try:
             opening_post = Post.objects.filter(id=post_id).only('thread_new')[0]
         except IndexError:
             raise Http404
 
         # If this is not OP, don't show it as it is
         if not opening_post or not opening_post.is_opening():
             raise Http404
 
         if not form:
             form = PostForm(error_class=PlainErrorList)
 
         thread_to_show = opening_post.get_thread()
 
         context = self.get_context_data(request=request)
 
-        context[PARAMETER_FORM] = form
-        context["last_update"] = utils.datetime_to_epoch(
+        context[CONTEXT_FORM] = form
+        context[CONTEXT_LASTUPDATE] = utils.datetime_to_epoch(
             thread_to_show.last_edit_time)
-        context[PARAMETER_THREAD] = thread_to_show
-        context[PARAMETER_MAX_REPLIES] = settings.MAX_POSTS_PER_THREAD
+        context[CONTEXT_THREAD] = thread_to_show
+        context[CONTEXT_MAX_REPLIES] = settings.MAX_POSTS_PER_THREAD
 
         if MODE_NORMAL == mode:
-            context[PARAMETER_BUMPABLE] = thread_to_show.can_bump()
-            if context[PARAMETER_BUMPABLE]:
-                context['posts_left'] = settings.MAX_POSTS_PER_THREAD \
-                        - thread_to_show.get_reply_count()
-                context['bumplimit_progress'] = str(
-                    float(context['posts_left']) /
-                    settings.MAX_POSTS_PER_THREAD * 100)
+            bumpable = thread_to_show.can_bump()
+            context[CONTEXT_BUMPABLE] = bumpable
+            if bumpable:
+                left_posts = settings.MAX_POSTS_PER_THREAD \
+                             - thread_to_show.get_reply_count()
+                context[CONTEXT_POSTS_LEFT] = left_posts
+                context[CONTEXT_BUMPLIMIT_PRG] = str(
+                    float(left_posts) / settings.MAX_POSTS_PER_THREAD * 100)
 
-            context['opening_post'] = opening_post
+            context[CONTEXT_OP] = opening_post
 
-            document = 'boards/thread.html'
+            document = TEMPLATE_NORMAL
         elif MODE_GALLERY == mode:
-            context['posts'] = thread_to_show.get_replies_with_images(
+            context[CONTEXT_POSTS] = thread_to_show.get_replies_with_images(
                 view_fields_only=True)
 
-            document = 'boards/thread_gallery.html'
+            document = TEMPLATE_GALLERY
         else:
             raise Http404
 
         return render(request, document, context)
 
     def post(self, request, post_id, mode=MODE_NORMAL):
         opening_post = get_object_or_404(Post, id=post_id)
 
         # If this is not OP, don't show it as it is
         if not opening_post.is_opening():
             raise Http404
 
         if not opening_post.get_thread().archived:
             form = PostForm(request.POST, request.FILES,
                             error_class=PlainErrorList)
             form.session = request.session
 
             if form.is_valid():
                 return self.new_post(request, form, opening_post)
             if form.need_to_ban:
                 # Ban user because he is suspected to be a bot
                 self._ban_current_user(request)
 
             return self.get(request, post_id, mode, form)
 
     @transaction.atomic
     def new_post(self, request, form, opening_post=None, html_response=True):
         """Add a new post (in thread or as a reply)."""
 
         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 None
 
         data = form.cleaned_data
 
-        title = data['title']
-        text = data['text']
+        title = data[FORM_TITLE]
+        text = data[FORM_TEXT]
 
         text = self._remove_invalid_links(text)
 
-        if 'image' in data.keys():
-            image = data['image']
+        if FORM_IMAGE in data.keys():
+            image = data[FORM_IMAGE]
         else:
             image = None
 
         tags = []
 
         post_thread = opening_post.get_thread()
 
         post = Post.objects.create_post(title=title, text=text, ip=ip,
                                         thread=post_thread, image=image,
                                         tags=tags,
                                         user=utils.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))
+                return redirect(
+                    reverse('thread', kwargs={'post_id': thread_to_show})
+                    + '#' + str(post.id))
         else:
             return post