Minor style fixes to view classes. Fixed ban view

boards/views/authors.py

@@ -1,12 +1,13
 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
 
         return render(request, 'boards/authors.html', context)

boards/views/ban.py

@@ -1,20 +1,22
 from django.db import transaction
+from django.shortcuts import get_object_or_404
 
 from boards.views.base import BaseBoardView
 from boards.models import Post, Ban
 
+
 class BanUserView(BaseBoardView):
 
     @transaction.atomic
     def get(self, request, post_id):
         user = self._get_user(request)
         post = get_object_or_404(Post, id=post_id)
 
         if user.is_moderator():
             # TODO Show confirmation page before ban
             ban, created = Ban.objects.get_or_create(ip=post.poster_ip)
             if created:
                 ban.reason = 'Banned for post ' + str(post_id)
                 ban.save()
 
         return self.redirect_to_next(request)

boards/views/delete_post.py

@@ -1,25 +1,26
 from django.shortcuts import redirect, get_object_or_404
 from django.db import transaction
 
 from boards.views.base import BaseBoardView
 from boards.views.redirect_next_mixin import RedirectNextMixin
 from boards.models import Post
 
+
 class DeletePostView(BaseBoardView, RedirectNextMixin):
 
     @transaction.atomic
     def get(self, request, post_id):
         user = self._get_user(request)
         post = get_object_or_404(Post, id=post_id)
 
         opening_post = post.is_opening()
 
         if user.is_moderator():
             # TODO Show confirmation page before deletion
             Post.objects.delete_post(post)
 
         if not opening_post:
             thread = post.thread_new
             return redirect('thread', post_id=thread.get_opening_post().id)
         else:
             return self.redirect_to_next(request)

boards/views/not_found.py

@@ -1,12 +1,13
 from django.shortcuts import render
 
 from boards.views.base import BaseBoardView
 
+
 class NotFoundView(BaseBoardView):
-    '''
+    """
     Page 404 (not found)
-    '''
+    """
 
     def get(self, request):
         context = self.get_context_data(request=request)
         return render(request, 'boards/404.html', context)

boards/views/redirect_next_mixin.py

@@ -1,17 +1,18
 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']
             return HttpResponseRedirect(next_page)
         else:
             return redirect('index')

boards/views/settings.py

@@ -1,50 +1,52
 from django.db import transaction
 from django.shortcuts import render, redirect
 
 from boards.views.base import BaseBoardView, PARAMETER_FORM
 from boards.forms import SettingsForm, ModeratorSettingsForm, PlainErrorList
 from boards.views import SETTING_MODERATE
 
+
 class SettingsView(BaseBoardView):
 
     def get(self, request):
         context = self.get_context_data(request=request)
         user = context['user']
         is_moderator = user.is_moderator()
 
         selected_theme = context['theme']
 
         if is_moderator:
-            form = ModeratorSettingsForm(initial={'theme': selected_theme,
-                                                  'moderate': context['moderator']},
-                                         error_class=PlainErrorList)
+            form = ModeratorSettingsForm(initial={
+                'theme': selected_theme,
+                'moderate': context['moderator']
+            }, error_class=PlainErrorList)
         else:
             form = SettingsForm(initial={'theme': selected_theme},
                                 error_class=PlainErrorList)
 
         context[PARAMETER_FORM] = form
 
         return render(request, 'boards/settings.html', context)
 
     def post(self, request):
         context = self.get_context_data(request=request)
         user = context['user']
         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,121 +1,121
 import string
 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 boards import utils
 from boards.forms import PostForm, PlainErrorList
 from boards.models import Post, Ban, Tag
 from boards.views.banned import BannedView
 from boards.views.base import BaseBoardView, PARAMETER_FORM
 from boards.views.posting_mixin import PostMixin
 import neboard
 
 MODE_GALLERY = 'gallery'
 MODE_NORMAL = 'normal'
 
 
 class ThreadView(BaseBoardView, PostMixin):
 
     def get(self, request, post_id, mode=MODE_NORMAL, form=None):
         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 form:
             form = PostForm(error_class=PlainErrorList)
 
         thread_to_show = opening_post.thread_new
 
         context = self.get_context_data(request=request)
 
         posts = thread_to_show.get_replies()
         context[PARAMETER_FORM] = form
         context["last_update"] = utils.datetime_to_epoch(
             thread_to_show.last_edit_time)
         context["thread"] = thread_to_show
 
         if MODE_NORMAL == mode:
             context['bumpable'] = thread_to_show.can_bump()
             if context['bumpable']:
                 context['posts_left'] = neboard.settings.MAX_POSTS_PER_THREAD - posts \
                     .count()
                 context['bumplimit_progress'] = str(
                     float(context['posts_left']) /
                     neboard.settings.MAX_POSTS_PER_THREAD * 100)
 
             context['posts'] = posts
 
             document = 'boards/thread.html'
         elif MODE_GALLERY == mode:
             context['posts'] = posts.filter(image_width__gt=0)
 
             document = 'boards/thread_gallery.html'
         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.thread_new.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
 
         data = form.cleaned_data
 
         title = data['title']
         text = data['text']
 
         text = self._remove_invalid_links(text)
 
         if 'image' in data.keys():
             image = data['image']
         else:
             image = None
 
         tags = []
 
         post_thread = opening_post.thread_new
 
         post = Post.objects.create_post(title=title, text=text, ip=ip,
                                         thread=post_thread, image=image,
                                         tags=tags,
                                         user=self._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))