Views refactoring

boards/views/all_threads.py

@@ -1,142 +1,143 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.abstracts.settingsmanager import get_settings_manager
 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, 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):
 
     def __init__(self):
         self.settings_manager = None
         super(AllThreadsView, self).__init__()
 
     def get(self, request, page=DEFAULT_PAGE, form=None):
         context = 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(),
                                   settings.THREADS_PER_PAGE)
         paginator.current_page = int(page)
 
         threads = paginator.page(page).object_list
 
         context[PARAMETER_THREADS] = threads
         context[CONTEXT_FORM] = form
 
         self._get_page_context(paginator, context, page)
 
         # TODO Use dict here
         return render(request, TEMPLATE, context_instance=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 = tag_name.strip().lower()
                 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[FORM_TITLE]
         text = data[FORM_TEXT]
 
         text = self._remove_invalid_links(text)
 
         if FORM_IMAGE in list(data.keys()):
             image = data[FORM_IMAGE]
         else:
             image = None
 
         tag_strings = data[FORM_TAGS]
 
         tags = self.parse_tags_string(tag_strings)
 
         post = Post.objects.create_post(title=title, text=text, image=image,
                                         ip=ip, tags=tags)
-        # FIXME
+
+        # This is required to update the threads to which posts we have replied
+        # when creating this one
         post.send_to_websocket(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.settings_manager.get_hidden_tags())

boards/views/base.py

@@ -1,35 +1,39 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'
 
 CONTEXT_FORM = 'form'
 
 
 class BaseBoardView(View):
 
     def get_context_data(self, **kwargs):
+        """
+        This method is deprecated. You need to use dicts instead of context
+        instances in all places it is used now.
+        """
+
         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/mixins.py

@@ -1,39 +1,40 b''
+PARAM_NEXT = 'next'
 PARAMETER_METHOD = 'method'
 
 from django.shortcuts import redirect
 from django.http import HttpResponseRedirect
 
 
 class RedirectNextMixin:
 
     def redirect_to_next(self, request):
         """
         If a 'next' parameter was specified, redirect to the next page. This
         is used when the user is required to return to some page after the
         current view has finished its work.
         """
 
-        if 'next' in request.GET:
-            next_page = request.GET['next']
+        if PARAM_NEXT in request.GET:
+            next_page = request.GET[PARAM_NEXT]
             return HttpResponseRedirect(next_page)
         else:
             return redirect('index')
 
 
 class DispatcherMixin:
     """
     This class contains a dispather method that can run a method specified by
     'method' request parameter.
     """
 
     def dispatch_method(self, *args, **kwargs):
         request = args[0]
 
         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)

boards/views/settings.py

@@ -1,39 +1,41 b''
 from django.db import transaction
 from django.shortcuts import render, redirect
 
 from boards.abstracts.settingsmanager import get_settings_manager
 from boards.views.base import BaseBoardView, CONTEXT_FORM
 from boards.forms import SettingsForm, PlainErrorList
 
+FORM_THEME = 'theme'
+
 CONTEXT_HIDDEN_TAGS = 'hidden_tags'
 
 
 class SettingsView(BaseBoardView):
 
     def get(self, request):
         context = self.get_context_data(request=request)
         settings_manager = get_settings_manager(request)
 
         selected_theme = settings_manager.get_theme()
 
-        form = SettingsForm(initial={'theme': selected_theme},
+        form = SettingsForm(initial={FORM_THEME: selected_theme},
                             error_class=PlainErrorList)
 
         context[CONTEXT_FORM] = form
         context[CONTEXT_HIDDEN_TAGS] = settings_manager.get_hidden_tags()
 
         # TODO Use dict here
         return render(request, 'boards/settings.html', context_instance=context)
 
     def post(self, request):
         settings_manager = get_settings_manager(request)
 
         with transaction.atomic():
             form = SettingsForm(request.POST, error_class=PlainErrorList)
 
             if form.is_valid():
-                selected_theme = form.cleaned_data['theme']
+                selected_theme = form.cleaned_data[FORM_THEME]
 
                 settings_manager.set_theme(selected_theme)
 
             return redirect('settings')

boards/views/tag_threads.py

@@ -1,92 +1,95 b''
 from django.shortcuts import get_object_or_404
 
 from boards.abstracts.settingsmanager import get_settings_manager
 from boards.models import Tag
 from boards.views.all_threads import AllThreadsView, DEFAULT_PAGE
 from boards.views.mixins import DispatcherMixin, RedirectNextMixin
 from boards.forms import ThreadForm, PlainErrorList
 
+PARAM_HIDDEN_TAGS = 'hidden_tags'
+PARAM_FAV_TAGS = 'fav_tags'
+PARAM_TAG = 'tag'
 
 __author__ = 'neko259'
 
 
 class TagView(AllThreadsView, DispatcherMixin, RedirectNextMixin):
 
     tag_name = None
 
     def get_threads(self):
         tag = get_object_or_404(Tag, name=self.tag_name)
 
         return tag.threads.all().order_by('-bump_time')
 
     def get_context_data(self, **kwargs):
         context = super(TagView, self).get_context_data(**kwargs)
 
         settings_manager = get_settings_manager(kwargs['request'])
 
         tag = get_object_or_404(Tag, name=self.tag_name)
-        context['tag'] = tag
+        context[PARAM_TAG] = tag
 
-        context['fav_tags'] = settings_manager.get_fav_tags()
-        context['hidden_tags'] = settings_manager.get_hidden_tags()
+        context[PARAM_FAV_TAGS] = settings_manager.get_fav_tags()
+        context[PARAM_HIDDEN_TAGS] = settings_manager.get_hidden_tags()
 
         return context
 
     def get(self, request, tag_name, page=DEFAULT_PAGE, form=None):
         self.tag_name = tag_name
 
         dispatch_result = self.dispatch_method(request)
         if dispatch_result:
             return dispatch_result
         else:
             return super(TagView, self).get(request, page, form)
 
     def post(self, request, tag_name, 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, tag_name, page, 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)
 
         return self.redirect_to_next(request)
 
     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)
 
         return self.redirect_to_next(request)
 
     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)

boards/views/thread.py

@@ -1,157 +1,150 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, CONTEXT_FORM
 from boards.views.posting_mixin import PostMixin
 import neboard
 
 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'
 CONTEXT_WS_TOKEN = 'ws_token'
 CONTEXT_WS_PROJECT = 'ws_project'
 CONTEXT_WS_HOST = 'ws_host'
 CONTEXT_WS_PORT = 'ws_port'
 
 FORM_TITLE = 'title'
 FORM_TEXT = 'text'
 FORM_IMAGE = 'image'
 
 MODE_GALLERY = 'gallery'
 MODE_NORMAL = 'normal'
 
 
 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[CONTEXT_FORM] = form
         context[CONTEXT_LASTUPDATE] = str(utils.datetime_to_epoch(
             thread_to_show.last_edit_time))
         context[CONTEXT_THREAD] = thread_to_show
         context[CONTEXT_MAX_REPLIES] = settings.MAX_POSTS_PER_THREAD
 
         if settings.WEBSOCKETS_ENABLED:
             context[CONTEXT_WS_TOKEN] = utils.get_websocket_token(
                 timestamp=context[CONTEXT_LASTUPDATE])
             context[CONTEXT_WS_PROJECT] = neboard.settings.CENTRIFUGE_PROJECT_ID
             context[CONTEXT_WS_HOST] = request.get_host().split(':')[0]
             context[CONTEXT_WS_PORT] = neboard.settings.CENTRIFUGE_PORT
 
         # TODO Move this to subclasses: NormalThreadView, GalleryThreadView etc
         if MODE_NORMAL == mode:
             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[CONTEXT_OP] = opening_post
 
             document = TEMPLATE_NORMAL
         elif MODE_GALLERY == mode:
             context[CONTEXT_POSTS] = thread_to_show.get_replies_with_images(
                 view_fields_only=True)
 
             document = TEMPLATE_GALLERY
         else:
             raise Http404
 
         # TODO Use dict here
         return render(request, document, context_instance=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[FORM_TITLE]
         text = data[FORM_TEXT]
 
         text = self._remove_invalid_links(text)
 
         if FORM_IMAGE in list(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, image=image,
                                         thread=post_thread, ip=ip, tags=tags)
         post.send_to_websocket(request, recursive=False)
 
         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))
         else:
             return post