Fixed calls to render shortcut to use dict instead of context instance

boards/views/all_tags.py

@@ -1,14 +1,14 b''
 from django.shortcuts import render
 
 from boards.views.base import BaseBoardView
 from boards.models.tag import Tag
 
 
 class AllTagsView(BaseBoardView):
 
     def get(self, request):
-        context = self.get_context_data(request=request)
-        context['all_tags'] = Tag.objects.get_not_empty_tags()
+        params = dict()
 
-        # TODO Use dict here
-        return render(request, 'boards/tags.html', context_instance=context)
+        params['all_tags'] = Tag.objects.get_not_empty_tags()
+
+        return render(request, 'boards/tags.html', params)

boards/views/all_threads.py

@@ -1,139 +1,137 b''
 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)
+        params = dict()
 
         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
+        params[PARAMETER_THREADS] = threads
+        params[CONTEXT_FORM] = form
 
-        self._get_page_context(paginator, context, page)
+        self._get_page_context(paginator, params, page)
 
-        # TODO Use dict here
-        return render(request, TEMPLATE, context_instance=context)
+        return render(request, TEMPLATE, params)
 
     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):
+    def _get_page_context(self, paginator, params, page):
         """
         Get pagination context variables
         """
 
-        context[PARAMETER_PAGINATOR] = paginator
-        context[PARAMETER_CURRENT_PAGE] = paginator.page(int(page))
+        params[PARAMETER_PAGINATOR] = paginator
+        params[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]
         image = data.get(FORM_IMAGE)
 
         text = self._remove_invalid_links(text)
 
         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)
 
         # 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/authors.py

@@ -1,14 +1,13 b''
 from django.shortcuts import render
 
 from boards.authors import authors
 from boards.views.base import BaseBoardView
 
 
 class AuthorsView(BaseBoardView):
 
     def get(self, request):
-        context = self.get_context_data(request=request)
-        context['authors'] = authors
+        params = dict()
+        params['authors'] = authors
 
-        # TODO Use dict here
-        return render(request, 'boards/authors.html', context_instance=context)
+        return render(request, 'boards/authors.html', params)

boards/views/banned.py

@@ -1,19 +1,17 b''
 from django.shortcuts import get_object_or_404, render
 from boards import utils
 from boards.models import Ban
 from boards.views.base import BaseBoardView
 
 
 class BannedView(BaseBoardView):
 
     def get(self, request):
         """Show the page that notifies that user is banned"""
 
-        context = self.get_context_data(request=request)
+        params = dict()
 
         ban = get_object_or_404(Ban, ip=utils.get_client_ip(request))
-        context['ban_reason'] = ban.reason
+        params['ban_reason'] = ban.reason
 
-        # TODO Use dict here
-        return render(request, 'boards/staticpages/banned.html',
-                      context_instance=context)
+        return render(request, 'boards/staticpages/banned.html', params)

boards/views/thread.py

@@ -1,143 +1,142 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)
+        params = dict()
 
-        context[CONTEXT_FORM] = form
-        context[CONTEXT_LASTUPDATE] = str(utils.datetime_to_epoch(
+        params[CONTEXT_FORM] = form
+        params[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
+        params[CONTEXT_THREAD] = thread_to_show
+        params[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
+            params[CONTEXT_WS_TOKEN] = utils.get_websocket_token(
+                timestamp=params[CONTEXT_LASTUPDATE])
+            params[CONTEXT_WS_PROJECT] = neboard.settings.CENTRIFUGE_PROJECT_ID
+            params[CONTEXT_WS_HOST] = request.get_host().split(':')[0]
+            params[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
+            params[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(
+                params[CONTEXT_POSTS_LEFT] = left_posts
+                params[CONTEXT_BUMPLIMIT_PRG] = str(
                     float(left_posts) / settings.MAX_POSTS_PER_THREAD * 100)
 
-            context[CONTEXT_OP] = opening_post
+            params[CONTEXT_OP] = opening_post
 
             document = TEMPLATE_NORMAL
         elif MODE_GALLERY == mode:
-            context[CONTEXT_POSTS] = thread_to_show.get_replies_with_images(
+            params[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)
+        return render(request, document, params)
 
     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)
 
     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)
 
         data = form.cleaned_data
 
         title = data[FORM_TITLE]
         text = data[FORM_TEXT]
         image = data.get(FORM_IMAGE)
 
         text = self._remove_invalid_links(text)
 
         post_thread = opening_post.get_thread()
 
         post = Post.objects.create_post(title=title, text=text, image=image,
                                         thread=post_thread, ip=ip)
         post.send_to_websocket(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))
         else:
             return post