Refactored thread views

boards/views/thread/gallery.py

@@ -1,24 +1,22 b''
 from boards.views.thread import ThreadView
 
 TEMPLATE_GALLERY = 'boards/thread_gallery.html'
 
 CONTEXT_POSTS = 'posts'
-CONTEXT_OP = 'opening_post'
 
 
 class GalleryThreadView(ThreadView):
 
     def get_template(self):
         return TEMPLATE_GALLERY
 
     def get_data(self, thread):
         params = dict()
 
         params[CONTEXT_POSTS] = thread.get_replies_with_images(
             view_fields_only=True)
-        params[CONTEXT_OP] = thread.get_opening_post()
 
         return params
 
     def get_mode(self):
         return 'gallery'

boards/views/thread/normal.py

@@ -1,34 +1,30 b''
-from boards import settings
 from boards.views.thread import ThreadView
 
 TEMPLATE_NORMAL = 'boards/thread_normal.html'
 
-CONTEXT_OP = 'opening_post'
 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)
 
-        params[CONTEXT_OP] = thread.get_opening_post()
-
         return params

boards/views/thread/thread.py

@@ -1,136 +1,138 b''
 from django.core.exceptions import ObjectDoesNotExist
 from django.http import Http404
 from django.shortcuts import get_object_or_404, render, redirect
 from django.views.generic.edit import FormMixin
 from django.utils import timezone
 from django.utils.dateformat import format
 
 from boards import utils, settings
 from boards.forms import PostForm, PlainErrorList
 from boards.models import Post
 from boards.views.base import BaseBoardView, CONTEXT_FORM
 from boards.views.posting_mixin import PostMixin
 
 import neboard
 
 
 CONTEXT_LASTUPDATE = "last_update"
 CONTEXT_THREAD = 'thread'
 CONTEXT_WS_TOKEN = 'ws_token'
 CONTEXT_WS_PROJECT = 'ws_project'
 CONTEXT_WS_HOST = 'ws_host'
 CONTEXT_WS_PORT = 'ws_port'
 CONTEXT_WS_TIME = 'ws_token_time'
 CONTEXT_MODE = 'mode'
+CONTEXT_OP = 'opening_post'
 
 FORM_TITLE = 'title'
 FORM_TEXT = 'text'
 FORM_IMAGE = 'image'
 FORM_THREADS = 'threads'
 
 
 class ThreadView(BaseBoardView, PostMixin, FormMixin):
 
     def get(self, request, post_id, form: PostForm=None):
         try:
             opening_post = Post.objects.get(id=post_id)
         except ObjectDoesNotExist:
             raise Http404
 
         # If this is not OP, don't show it as it is
         if not opening_post.is_opening():
             return redirect(opening_post.get_thread().get_opening_post()
                 .get_absolute_url())
 
         if not form:
             form = PostForm(error_class=PlainErrorList)
 
         thread_to_show = opening_post.get_thread()
 
         params = dict()
 
         params[CONTEXT_FORM] = form
         params[CONTEXT_LASTUPDATE] = str(thread_to_show.last_edit_time)
         params[CONTEXT_THREAD] = thread_to_show
         params[CONTEXT_MODE] = self.get_mode()
+        params[CONTEXT_OP] = opening_post
 
         if settings.get_bool('External', 'WebsocketsEnabled'):
             token_time = format(timezone.now(), u'U')
 
             params[CONTEXT_WS_TIME] = token_time
             params[CONTEXT_WS_TOKEN] = utils.get_websocket_token(
                 timestamp=token_time)
             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
 
         params.update(self.get_data(thread_to_show))
 
         return render(request, self.get_template(), params)
 
     def post(self, request, post_id):
         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, form)
 
     def new_post(self, request, form: PostForm, opening_post: Post=None,
                  html_response=True):
         """
         Adds 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 = form.get_image()
         threads = data[FORM_THREADS]
 
         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,
                                         threads=threads)
         post.notify_clients()
 
         if html_response:
             if opening_post:
                 return redirect(post.get_absolute_url())
         else:
             return post
 
-    def get_data(self, thread):
+    def get_data(self, thread) -> dict:
         """
         Returns context params for the view.
         """
 
-        pass
+        return dict()
 
-    def get_template(self):
+    def get_template(self) -> str:
         """
         Gets template to show the thread mode on.
         """
 
         pass
 
-    def get_mode(self):
+    def get_mode(self) -> str:
         pass

boards/views/thread/tree.py

@@ -1,27 +1,12 b''
-from boards import settings
 from boards.views.thread import ThreadView
 
 TEMPLATE_TREE = 'boards/thread_tree.html'
 
-CONTEXT_OP = 'opening_post'
-CONTEXT_BUMPABLE = 'bumpable'
-
 
 class TreeThreadView(ThreadView):
 
     def get_template(self):
         return TEMPLATE_TREE
 
-    def get_data(self, thread):
-        params = dict()
-
-        bumpable = thread.can_bump()
-        params[CONTEXT_BUMPABLE] = bumpable
-        max_posts = thread.max_posts
-
-        params[CONTEXT_OP] = thread.get_opening_post()
-
-        return params
-
     def get_mode(self):
         return 'tree'