Refactored views

boards/middlewares.py

@@ -1,42 +1,44
 import pytz
 
 from django.shortcuts import redirect
 from django.utils import timezone
 
 from boards import utils
 from boards.models import Ban
 
+SESSION_TIMEZONE = 'django_timezone'
+
 RESPONSE_CONTENT_TYPE = 'Content-Type'
 
 TYPE_HTML = 'text/html'
 
 
 class BanMiddleware:
     """
     This is run before showing the thread. Banned users don't need to see
     anything
     """
 
     def __init__(self):
         pass
 
     def process_view(self, request, view_func, view_args, view_kwargs):
 
         if request.path != '/banned/':
             ip = utils.get_client_ip(request)
             bans = Ban.objects.filter(ip=ip)
 
             if bans.exists():
                 ban = bans[0]
                 if not ban.can_read:
                     return redirect('banned')
 
 
 class TimezoneMiddleware(object):
     def process_request(self, request):
-        tzname = request.session.get('django_timezone')
+        tzname = request.session.get(SESSION_TIMEZONE)
         if tzname:
             timezone.activate(pytz.timezone(tzname))
         else:
             timezone.deactivate()
 

boards/urls.py

@@ -1,81 +1,80
-from django.conf.urls import patterns, url, include
-from django.contrib import admin
+from django.conf.urls import patterns, url
+
 from boards import views
 from boards.rss import AllThreadsFeed, TagThreadsFeed, ThreadPostsFeed
 from boards.views import api, tag_threads, all_threads, \
     settings, all_tags
 from boards.views.authors import AuthorsView
-from boards.views.ban import BanUserView
 from boards.views.notifications import NotificationView
 from boards.views.search import BoardSearchView
 from boards.views.static import StaticPageView
 from boards.views.preview import PostPreviewView
 
+
 js_info_dict = {
     'packages': ('boards',),
 }
 
 urlpatterns = patterns('',
     # /boards/
     url(r'^$', all_threads.AllThreadsView.as_view(), name='index'),
     # /boards/page/
     url(r'^page/(?P<page>\w+)/$', all_threads.AllThreadsView.as_view(),
         name='index'),
 
     # /boards/tag/tag_name/
     url(r'^tag/(?P<tag_name>\w+)/$', tag_threads.TagView.as_view(),
         name='tag'),
     # /boards/tag/tag_id/page/
     url(r'^tag/(?P<tag_name>\w+)/page/(?P<page>\w+)/$',
         tag_threads.TagView.as_view(), name='tag'),
 
     # /boards/thread/
     url(r'^thread/(?P<post_id>\d+)/$', views.thread.normal.NormalThreadView.as_view(),
         name='thread'),
     url(r'^thread/(?P<post_id>\d+)/mode/gallery/$', views.thread.gallery.GalleryThreadView.as_view(),
         name='thread_gallery'),
 
     url(r'^settings/$', settings.SettingsView.as_view(), name='settings'),
     url(r'^tags/(?P<query>\w+)?/?$', all_tags.AllTagsView.as_view(), name='tags'),
     url(r'^authors/$', AuthorsView.as_view(), name='authors'),
-    url(r'^ban/(?P<post_id>\w+)/$', BanUserView.as_view(), name='ban'),
 
     url(r'^banned/$', views.banned.BannedView.as_view(), name='banned'),
     url(r'^staticpage/(?P<name>\w+)/$', StaticPageView.as_view(),
         name='staticpage'),
 
     # RSS feeds
     url(r'^rss/$', AllThreadsFeed()),
     url(r'^page/(?P<page>\d+)/rss/$', AllThreadsFeed()),
     url(r'^tag/(?P<tag_name>\w+)/rss/$', TagThreadsFeed()),
     url(r'^tag/(?P<tag_name>\w+)/page/(?P<page>\w+)/rss/$', TagThreadsFeed()),
     url(r'^thread/(?P<post_id>\d+)/rss/$', ThreadPostsFeed()),
 
     # i18n
     url(r'^jsi18n/$', 'boards.views.cached_js_catalog', js_info_dict,
         name='js_info_dict'),
 
     # API
     url(r'^api/post/(?P<post_id>\d+)/$', api.get_post, name="get_post"),
     url(r'^api/diff_thread$',
         api.api_get_threaddiff, name="get_thread_diff"),
     url(r'^api/threads/(?P<count>\w+)/$', api.api_get_threads,
             name='get_threads'),
     url(r'^api/tags/$', api.api_get_tags, name='get_tags'),
     url(r'^api/thread/(?P<opening_post_id>\w+)/$', api.api_get_thread_posts,
             name='get_thread'),
     url(r'^api/add_post/(?P<opening_post_id>\w+)/$', api.api_add_post,
             name='add_post'),
     url(r'^api/notifications/(?P<username>\w+)/$', api.api_get_notifications,
             name='api_notifications'),
 
     # Search
     url(r'^search/$', BoardSearchView.as_view(), name='search'),
 
     # Notifications
     url(r'^notifications/(?P<username>\w+)$', NotificationView.as_view(), name='notifications'),
 
     # Post preview
     url(r'^preview/$', PostPreviewView.as_view(), name='preview')
 
 )

boards/views/mixins.py

@@ -1,40 +1,21
 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 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/notifications.py

@@ -1,44 +1,46
 from django.shortcuts import render
+
 from boards.abstracts.paginator import get_paginator
 from boards.abstracts.settingsmanager import get_settings_manager, \
     SETTING_USERNAME, SETTING_LAST_NOTIFICATION_ID
-from boards.models import Post
 from boards.models.user import Notification
 from boards.views.base import BaseBoardView
 
+DEFAULT_PAGE = '1'
+
 TEMPLATE = 'boards/notifications.html'
 PARAM_PAGE = 'page'
 PARAM_USERNAME = 'notification_username'
 REQUEST_PAGE = 'page'
 RESULTS_PER_PAGE = 10
 
 
 class NotificationView(BaseBoardView):
 
     def get(self, request, username):
         params = self.get_context_data()
 
         settings_manager = get_settings_manager(request)
 
         # If we open our notifications, reset the "new" count
         my_username = settings_manager.get_setting(SETTING_USERNAME)
 
         notification_username = username.lower()
 
         posts = Notification.objects.get_notification_posts(
-                username=notification_username)
+            username=notification_username)
         if notification_username == my_username:
             last = posts.first()
             if last is not None:
                 last_id = last.id
                 settings_manager.set_setting(SETTING_LAST_NOTIFICATION_ID,
                                              last_id)
 
         paginator = get_paginator(posts, RESULTS_PER_PAGE)
 
-        page = int(request.GET.get(REQUEST_PAGE, '1'))
+        page = int(request.GET.get(REQUEST_PAGE, DEFAULT_PAGE))
 
         params[PARAM_PAGE] = paginator.page(page)
         params[PARAM_USERNAME] = notification_username
 
         return render(request, TEMPLATE, params)

boards/views/preview.py

@@ -1,39 +1,38
 from django.shortcuts import render
 from django.template import RequestContext
 from django.views.generic import View
 
 from boards.mdx_neboard import Parser
 
 
 FORM_QUERY = 'query'
 
 CONTEXT_RESULT = 'result'
 CONTEXT_QUERY = 'query'
 
 __author__ = 'neko259'
 
 TEMPLATE = 'boards/preview.html'
 
 
 class PostPreviewView(View):
     def get(self, request):
         context = RequestContext(request)
 
         # TODO Use dict here
         return render(request, TEMPLATE, context_instance=context)
 
     def post(self, request):
-        context = RequestContext(request)
+        params = dict()
 
         if FORM_QUERY in request.POST:
             raw_text = request.POST[FORM_QUERY]
 
             if len(raw_text) >= 0:
                 parser = Parser()
                 rendered_text = parser.parse(parser.preparse(raw_text))
 
-                context[CONTEXT_RESULT] = rendered_text
-                context[CONTEXT_QUERY] = raw_text
+                params[CONTEXT_RESULT] = rendered_text
+                params[CONTEXT_QUERY] = raw_text
 
-        # TODO Use dict here
-        return render(request, TEMPLATE, context_instance=context)
+        return render(request, TEMPLATE, params)

boards/views/settings.py

@@ -1,69 +1,70
-import pytz
-
 from django.db import transaction
 from django.shortcuts import render, redirect
 from django.utils import timezone
 
 from boards.abstracts.settingsmanager import get_settings_manager, \
     SETTING_USERNAME, SETTING_LAST_NOTIFICATION_ID
+from boards.middlewares import SESSION_TIMEZONE
 from boards.views.base import BaseBoardView, CONTEXT_FORM
 from boards.forms import SettingsForm, PlainErrorList
 
+
 FORM_THEME = 'theme'
 FORM_USERNAME = 'username'
 FORM_TIMEZONE = 'timezone'
 
 CONTEXT_HIDDEN_TAGS = 'hidden_tags'
 
 TEMPLATE = 'boards/settings.html'
 
 
 class SettingsView(BaseBoardView):
 
     def get(self, request):
         params = dict()
         settings_manager = get_settings_manager(request)
 
         selected_theme = settings_manager.get_theme()
 
         form = SettingsForm(
             initial={
                 FORM_THEME: selected_theme,
                 FORM_USERNAME: settings_manager.get_setting(SETTING_USERNAME),
-                FORM_TIMEZONE: request.session.get('django_timezone', timezone.get_current_timezone()),
+                FORM_TIMEZONE: request.session.get(
+                    SESSION_TIMEZONE, timezone.get_current_timezone()),
             },
             error_class=PlainErrorList)
 
         params[CONTEXT_FORM] = form
         params[CONTEXT_HIDDEN_TAGS] = settings_manager.get_hidden_tags()
 
         return render(request, TEMPLATE, params)
 
     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[FORM_THEME]
                 username = form.cleaned_data[FORM_USERNAME].lower()
 
                 settings_manager.set_theme(selected_theme)
 
                 old_username = settings_manager.get_setting(SETTING_USERNAME)
                 if username != old_username:
                     settings_manager.set_setting(SETTING_USERNAME, username)
                     settings_manager.set_setting(SETTING_LAST_NOTIFICATION_ID, None)
 
-                request.session['django_timezone'] = form.cleaned_data[FORM_TIMEZONE]
+                request.session[SESSION_TIMEZONE] = form.cleaned_data[FORM_TIMEZONE]
 
                 return redirect('settings')
             else:
                 params = dict()
 
                 params[CONTEXT_FORM] = form
                 params[CONTEXT_HIDDEN_TAGS] = settings_manager.get_hidden_tags()
 
                 return render(request, TEMPLATE, params)
 

boards/views/tag_threads.py

@@ -1,107 +1,107
 from django.shortcuts import get_object_or_404
 
 from boards.abstracts.settingsmanager import get_settings_manager, \
         SETTING_FAVORITE_TAGS, SETTING_HIDDEN_TAGS
 from boards.models import Tag
 from boards.views.all_threads import AllThreadsView, DEFAULT_PAGE
-from boards.views.mixins import DispatcherMixin, RedirectNextMixin
+from boards.views.mixins import DispatcherMixin
 from boards.forms import ThreadForm, PlainErrorList
 
 PARAM_HIDDEN_TAGS = 'hidden_tags'
 PARAM_TAG = 'tag'
 PARAM_IS_FAVORITE = 'is_favorite'
 PARAM_IS_HIDDEN = 'is_hidden'
 
 __author__ = 'neko259'
 
 
-class TagView(AllThreadsView, DispatcherMixin, RedirectNextMixin):
+class TagView(AllThreadsView, DispatcherMixin):
 
     tag_name = None
 
     def get_threads(self):
         tag = get_object_or_404(Tag, name=self.tag_name)
 
         hidden_tags = self.settings_manager.get_hidden_tags()
 
         try:
             hidden_tags.remove(tag)
         except ValueError:
             pass
 
         return tag.get_threads().exclude(
             tags__in=hidden_tags)
 
     def get_context_data(self, **kwargs):
         params = super(TagView, self).get_context_data(**kwargs)
 
         settings_manager = get_settings_manager(kwargs['request'])
 
         tag = get_object_or_404(Tag, name=self.tag_name)
         params[PARAM_TAG] = tag
 
         fav_tag_names = settings_manager.get_setting(SETTING_FAVORITE_TAGS)
         hidden_tag_names = settings_manager.get_setting(SETTING_HIDDEN_TAGS)
 
         params[PARAM_IS_FAVORITE] = fav_tag_names is not None and tag.name in fav_tag_names
         params[PARAM_IS_HIDDEN] = hidden_tag_names is not None and tag.name in hidden_tag_names
 
         return params
 
     def get(self, request, tag_name, page=DEFAULT_PAGE, form=None):
         self.tag_name = tag_name
 
         return super(TagView, self).get(request, page, form)
 
 
     def post(self, request, tag_name, page=DEFAULT_PAGE):
         self.tag_name = tag_name
 
         if 'method' in request.POST:
             self.dispatch_method(request)
             form = None
         else:
             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)
 
     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)
 
     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)