Rewriting views to class-based

boards/views/all_threads.py

@@ -0,0 +1,134 b''
+import string
+
+from django.core.paginator import Paginator
+from django.core.urlresolvers import reverse
+from django.db import transaction
+from django.shortcuts import render, redirect
+
+from boards import utils
+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, PARAMETER_FORM
+from boards.views.posting_mixin import PostMixin
+import neboard
+
+PARAMETER_CURRENT_PAGE = 'current_page'
+
+PARAMETER_PAGINATOR = 'paginator'
+
+PARAMETER_THREADS = 'threads'
+
+TEMPLATE = 'boards/posting_general.html'
+DEFAULT_PAGE = 1
+
+
+class AllThreadsView(PostMixin, BaseBoardView):
+
+    def get(self, request, page=DEFAULT_PAGE):
+        context = self.get_context_data(request=request)
+
+        form = ThreadForm(error_class=PlainErrorList)
+
+        paginator = Paginator(self.get_threads(),
+                              neboard.settings.THREADS_PER_PAGE)
+
+        threads = paginator.page(page).object_list
+
+        context[PARAMETER_THREADS] = threads
+        context[PARAMETER_FORM] = form
+
+        self._get_page_context(paginator, context, page)
+
+        return render(request, TEMPLATE, context)
+
+    def post(self, request, page=DEFAULT_PAGE):
+        context = self.get_context_data(request=request)
+
+        form = ThreadForm(request.POST, request.FILES,
+                          error_class=PlainErrorList)
+        form.session = request.session
+
+        if form.is_valid():
+            return self._new_post(request, form)
+        if form.need_to_ban:
+            # Ban user because he is suspected to be a bot
+            self._ban_current_user(request)
+
+        paginator = Paginator(self.get_threads(),
+                              neboard.settings.THREADS_PER_PAGE)
+
+        threads = paginator.page(page).object_list
+
+        context[PARAMETER_THREADS] = threads
+        context[PARAMETER_FORM] = form
+
+        self._get_page_context(paginator, context, page)
+
+        return render(request, TEMPLATE, context)
+
+    @staticmethod
+    def _get_page_context(paginator, context, page):
+        """
+        Get pagination context variables
+        """
+
+        context[PARAMETER_PAGINATOR] = paginator
+        context[PARAMETER_CURRENT_PAGE] = paginator.page(int(page))
+
+    # TODO This method should be refactored
+    @transaction.atomic
+    def _new_post(self, request, form, opening_post=None, html_response=True):
+        """
+        Add a new thread 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['title']
+        text = data['text']
+
+        text = self._remove_invalid_links(text)
+
+        if 'image' in data.keys():
+            image = data['image']
+        else:
+            image = None
+
+        tags = []
+
+        tag_strings = data['tags']
+
+        if tag_strings:
+            tag_strings = tag_strings.split(' ')
+            for tag_name in tag_strings:
+                tag_name = string.lower(tag_name.strip())
+                if len(tag_name) > 0:
+                    tag, created = Tag.objects.get_or_create(name=tag_name)
+                    tags.append(tag)
+
+        post = Post.objects.create_post(title=title, text=text, ip=ip,
+                                        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))
+            else:
+                return redirect('thread', post_id=thread_to_show)
+
+    def get_threads(self):
+        return Thread.objects.filter(archived=False)
  No newline at end of file

boards/views/archived_threads.py

@@ -0,0 +1,10 b''
+from boards.models import Thread
+from boards.views.all_threads import AllThreadsView
+
+__author__ = 'neko259'
+
+
+class ArchiveView(AllThreadsView):
+
+    def get_threads(self):
+        return Thread.objects.filter(archived=True)
  No newline at end of file

boards/views/banned.py

@@ -0,0 +1,16 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)
+
+        ban = get_object_or_404(Ban, ip=utils.get_client_ip(request))
+        context['ban_reason'] = ban.reason
+        return render(request, 'boards/staticpages/banned.html', context)

boards/views/base.py

@@ -0,0 +1,125 b''
+from datetime import datetime, timedelta
+import hashlib
+from django.db import transaction
+from django.db.models import Count
+from django.template import RequestContext
+from django.utils import timezone
+from django.views.generic import View
+from boards import utils
+from boards.models import User, Post
+from boards.models.post import SETTING_MODERATE
+from boards.models.user import RANK_USER, Ban
+import neboard
+
+BAN_REASON_SPAM = 'Autoban: spam bot'
+
+OLD_USER_AGE_DAYS = 90
+
+PARAMETER_FORM = 'form'
+
+
+class BaseBoardView(View):
+
+    def get_context_data(self, **kwargs):
+        request = kwargs['request']
+        context = self._default_context(request)
+
+        context['version'] = neboard.settings.VERSION
+        context['site_name'] = neboard.settings.SITE_NAME
+
+        return context
+
+    def _default_context(self, request):
+        """Create context with default values that are used in most views"""
+
+        context = RequestContext(request)
+
+        user = self._get_user(request)
+        context['user'] = user
+        context['tags'] = user.get_sorted_fav_tags()
+        context['posts_per_day'] = float(Post.objects.get_posts_per_day())
+
+        theme = self._get_theme(request, user)
+        context['theme'] = theme
+        context['theme_css'] = 'css/' + theme + '/base_page.css'
+
+        # This shows the moderator panel
+        moderate = user.get_setting(SETTING_MODERATE)
+        if moderate == 'True':
+            context['moderator'] = user.is_moderator()
+        else:
+            context['moderator'] = False
+
+        return context
+
+    def _get_user(self, request):
+        """
+        Get current user from the session. If the user does not exist, create
+        a new one.
+        """
+
+        session = request.session
+        if not 'user_id' in session:
+            request.session.save()
+
+            md5 = hashlib.md5()
+            md5.update(session.session_key)
+            new_id = md5.hexdigest()
+
+            while User.objects.filter(user_id=new_id).exists():
+                md5.update(str(timezone.now()))
+                new_id = md5.hexdigest()
+
+            time_now = timezone.now()
+            user = User.objects.create(user_id=new_id, rank=RANK_USER,
+                                       registration_time=time_now)
+
+            self._delete_old_users()
+
+            session['user_id'] = user.id
+        else:
+            user = User.objects.get(id=session['user_id'])
+
+        return user
+
+    def _get_theme(self, request, user=None):
+        """
+        Get user's CSS theme
+        """
+
+        if not user:
+            user = self._get_user(request)
+        theme = user.get_setting('theme')
+        if not theme:
+            theme = neboard.settings.DEFAULT_THEME
+
+        return theme
+
+    def _delete_old_users(self):
+        """
+        Delete users with no favorite tags and posted messages. These can be spam
+        bots or just old user accounts
+        """
+
+        old_registration_date = datetime.now().date() - timedelta(
+            OLD_USER_AGE_DAYS)
+
+        for user in User.objects.annotate(tags_count=Count('fav_tags')).filter(
+                tags_count=0).filter(
+                registration_time__lt=old_registration_date):
+            if not Post.objects.filter(user=user).exists():
+                user.delete()
+
+    @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/posting_mixin.py

@@ -0,0 +1,25 b''
+import re
+import string
+
+from boards.models import Post
+from boards.models.post import REGEX_REPLY
+
+REFLINK_PREFIX = '>>'
+
+
+class PostMixin:
+
+    @staticmethod
+    def _remove_invalid_links(text):
+        """
+        Replace invalid links in posts so that they won't be parsed.
+        Invalid links are links to non-existent posts
+        """
+
+        for reply_number in re.finditer(REGEX_REPLY, text):
+            post_id = reply_number.group(1)
+            post = Post.objects.filter(id=post_id)
+            if not post.exists():
+                text = string.replace(text, REFLINK_PREFIX + post_id, post_id)
+
+        return text

boards/views/tag_threads.py

@@ -0,0 +1,28 b''
+from django.shortcuts import get_object_or_404
+from boards.models import Tag, Post
+from boards.views.all_threads import AllThreadsView, DEFAULT_PAGE
+
+__author__ = 'neko259'
+
+
+class TagView(AllThreadsView):
+
+    tag_name = None
+
+    def get_threads(self):
+        tag = get_object_or_404(Tag, name=self.tag_name)
+
+        return tag.threads.filter(archived=False)
+
+    def get_context_data(self, **kwargs):
+        context = super(TagView, self).get_context_data(**kwargs)
+
+        tag = get_object_or_404(Tag, name=self.tag_name)
+        context['tag'] = tag
+
+        return context
+
+    def get(self, request, tag_name, page=DEFAULT_PAGE):
+        self.tag_name = tag_name
+
+        return super(TagView, self).get(request, page)
  No newline at end of file

boards/views/thread.py

@@ -0,0 +1,149 b''
+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):
+        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
+
+        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)
+
+            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)
+
+    @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))
  No newline at end of file

boards/middlewares.py

@@ -1,41 +1,41 b''
 from django.shortcuts import redirect
 from boards import views, utils
 from boards.models import Ban
 from django.utils.html import strip_spaces_between_tags
 from django.conf import settings
 
 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 process_view(self, request, view_func, view_args, view_kwargs):
 
-        if view_func != views.you_are_banned:
+        if view_func != views.banned.BannedView.as_view:
             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(views.you_are_banned)
+                    return redirect('banned')
 
 
 class MinifyHTMLMiddleware(object):
     def process_response(self, request, response):
         try:
             compress_html = settings.COMPRESS_HTML
         except AttributeError:
             compress_html = False
 
         if RESPONSE_CONTENT_TYPE in response\
             and TYPE_HTML in response[RESPONSE_CONTENT_TYPE] and compress_html:
             response.content = strip_spaces_between_tags(
                 response.content.strip())
         return response
  No newline at end of file

boards/models/post.py

@@ -1,390 +1,394 b''
 from datetime import datetime, timedelta
 from datetime import time as dtime
 import os
 from random import random
 import time
 import math
 import re
 import hashlib
 
 from django.core.cache import cache
 from django.core.paginator import Paginator
 
 from django.db import models
 from django.http import Http404
 from django.utils import timezone
 from markupfield.fields import MarkupField
 
 from neboard import settings
 from boards import thumbs
 
 MAX_TITLE_LENGTH = 50
 
 APP_LABEL_BOARDS = 'boards'
 
 CACHE_KEY_PPD = 'ppd'
 
 POSTS_PER_DAY_RANGE = range(7)
 
 BAN_REASON_AUTO = 'Auto'
 
 IMAGE_THUMB_SIZE = (200, 150)
 
 TITLE_MAX_LENGTH = 50
 
 DEFAULT_MARKUP_TYPE = 'markdown'
 
 NO_PARENT = -1
 NO_IP = '0.0.0.0'
 UNKNOWN_UA = ''
 ALL_PAGES = -1
 IMAGES_DIRECTORY = 'images/'
 FILE_EXTENSION_DELIMITER = '.'
 
 SETTING_MODERATE = "moderate"
 
 REGEX_REPLY = re.compile('>>(\d+)')
 
 
 class PostManager(models.Manager):
 
     def create_post(self, title, text, image=None, thread=None,
                     ip=NO_IP, tags=None, user=None):
         """
         Create new post
         """
 
         posting_time = timezone.now()
         if not thread:
             thread = Thread.objects.create(bump_time=posting_time,
                                            last_edit_time=posting_time)
         else:
             thread.bump()
             thread.last_edit_time = posting_time
             thread.save()
 
         post = self.create(title=title,
                            text=text,
                            pub_time=posting_time,
                            thread_new=thread,
                            image=image,
                            poster_ip=ip,
                            poster_user_agent=UNKNOWN_UA,  # TODO Get UA at
                            # last!
                            last_edit_time=posting_time,
                            user=user)
 
         thread.replies.add(post)
         if tags:
             linked_tags = []
             for tag in tags:
                 tag_linked_tags = tag.get_linked_tags()
                 if len(tag_linked_tags) > 0:
                     linked_tags.extend(tag_linked_tags)
 
             tags.extend(linked_tags)
             map(thread.add_tag, tags)
 
         self._delete_old_threads()
         self.connect_replies(post)
 
         return post
 
     def delete_post(self, post):
         """
         Delete post and update or delete its thread
         """
         
         thread = post.thread_new
 
         if thread.get_opening_post() == self:
             thread.replies.delete()
 
             thread.delete()
         else:
             thread.last_edit_time = timezone.now()
             thread.save()
 
             post.delete()
 
     def delete_posts_by_ip(self, ip):
         """
         Delete all posts of the author with same IP
         """
 
         posts = self.filter(poster_ip=ip)
         map(self.delete_post, posts)
 
     # TODO Move this method to thread manager
     def get_threads(self, tag=None, page=ALL_PAGES,
                     order_by='-bump_time', archived=False):
         if tag:
             threads = tag.threads
 
             if not threads.exists():
                 raise Http404
         else:
             threads = Thread.objects.all()
 
         threads = threads.filter(archived=archived).order_by(order_by)
 
         if page != ALL_PAGES:
             threads = Paginator(threads, settings.THREADS_PER_PAGE).page(
                     page).object_list
 
         return threads
 
     # TODO Move this method to thread manager
     def _delete_old_threads(self):
         """
         Preserves maximum thread count. If there are too many threads,
         archive the old ones.
         """
 
         threads = self.get_threads()
         thread_count = threads.count()
 
         if thread_count > settings.MAX_THREAD_COUNT:
             num_threads_to_delete = thread_count - settings.MAX_THREAD_COUNT
             old_threads = threads[thread_count - num_threads_to_delete:]
 
             for thread in old_threads:
                 thread.archived = True
                 thread.last_edit_time = timezone.now()
                 thread.save()
 
     def connect_replies(self, post):
         """
         Connect replies to a post to show them as a reflink map
         """
 
         for reply_number in re.finditer(REGEX_REPLY, post.text.raw):
             post_id = reply_number.group(1)
             ref_post = self.filter(id=post_id)
             if ref_post.count() > 0:
                 referenced_post = ref_post[0]
                 referenced_post.referenced_posts.add(post)
                 referenced_post.last_edit_time = post.pub_time
                 referenced_post.save()
 
                 referenced_thread = referenced_post.thread_new
                 referenced_thread.last_edit_time = post.pub_time
                 referenced_thread.save()
 
     def get_posts_per_day(self):
         """
         Get average count of posts per day for the last 7 days
         """
 
         today = datetime.now().date()
         ppd = cache.get(CACHE_KEY_PPD + str(today))
         if ppd:
             return ppd
 
         posts_per_days = []
         for i in POSTS_PER_DAY_RANGE:
             day_end = today - timedelta(i + 1)
             day_start = today - timedelta(i + 2)
 
             day_time_start = timezone.make_aware(datetime.combine(day_start,
                 dtime()), timezone.get_current_timezone())
             day_time_end = timezone.make_aware(datetime.combine(day_end,
                 dtime()), timezone.get_current_timezone())
 
             posts_per_days.append(float(self.filter(
                 pub_time__lte=day_time_end,
                 pub_time__gte=day_time_start).count()))
 
         ppd = (sum(posts_per_day for posts_per_day in posts_per_days) /
                len(posts_per_days))
         cache.set(CACHE_KEY_PPD, ppd)
         return ppd
 
 
 class Post(models.Model):
     """A post is a message."""
 
     objects = PostManager()
 
     class Meta:
         app_label = APP_LABEL_BOARDS
 
     # TODO Save original file name to some field
     def _update_image_filename(self, filename):
         """Get unique image filename"""
 
         path = IMAGES_DIRECTORY
         new_name = str(int(time.mktime(time.gmtime())))
         new_name += str(int(random() * 1000))
         new_name += FILE_EXTENSION_DELIMITER
         new_name += filename.split(FILE_EXTENSION_DELIMITER)[-1:][0]
 
         return os.path.join(path, new_name)
 
     title = models.CharField(max_length=TITLE_MAX_LENGTH)
     pub_time = models.DateTimeField()
     text = MarkupField(default_markup_type=DEFAULT_MARKUP_TYPE,
                        escape_html=False)
 
     image_width = models.IntegerField(default=0)
     image_height = models.IntegerField(default=0)
 
     image_pre_width = models.IntegerField(default=0)
     image_pre_height = models.IntegerField(default=0)
 
     image = thumbs.ImageWithThumbsField(upload_to=_update_image_filename,
                                         blank=True, sizes=(IMAGE_THUMB_SIZE,),
                                         width_field='image_width',
                                         height_field='image_height',
                                         preview_width_field='image_pre_width',
                                         preview_height_field='image_pre_height')
     image_hash = models.CharField(max_length=36)
 
     poster_ip = models.GenericIPAddressField()
     poster_user_agent = models.TextField()
 
     thread = models.ForeignKey('Post', null=True, default=None)
     thread_new = models.ForeignKey('Thread', null=True, default=None)
     last_edit_time = models.DateTimeField()
     user = models.ForeignKey('User', null=True, default=None)
 
     referenced_posts = models.ManyToManyField('Post', symmetrical=False,
                                               null=True,
                                               blank=True, related_name='rfp+')
 
     def __unicode__(self):
         return '#' + str(self.id) + ' ' + self.title + ' (' + \
                self.text.raw[:50] + ')'
 
     def get_title(self):
         title = self.title
         if len(title) == 0:
             title = self.text.rendered
 
         return title
 
     def get_sorted_referenced_posts(self):
         return self.referenced_posts.order_by('id')
 
     def is_referenced(self):
         return self.referenced_posts.all().exists()
 
     def is_opening(self):
         return self.thread_new.get_replies()[0] == self
 
     def save(self, *args, **kwargs):
         """
         Save the model and compute the image hash
         """
 
         if not self.pk and self.image:
             md5 = hashlib.md5()
             for chunk in self.image.chunks():
                 md5.update(chunk)
             self.image_hash = md5.hexdigest()
         super(Post, self).save(*args, **kwargs)
 
 
 class Thread(models.Model):
 
     class Meta:
         app_label = APP_LABEL_BOARDS
 
     tags = models.ManyToManyField('Tag')
     bump_time = models.DateTimeField()
     last_edit_time = models.DateTimeField()
     replies = models.ManyToManyField('Post', symmetrical=False, null=True,
                                      blank=True, related_name='tre+')
     archived = models.BooleanField(default=False)
 
     def get_tags(self):
         """
         Get a sorted tag list
         """
 
         return self.tags.order_by('name')
 
     def bump(self):
         """
         Bump (move to up) thread
         """
 
         if self.can_bump():
             self.bump_time = timezone.now()
 
     def get_reply_count(self):
         return self.replies.count()
 
     def get_images_count(self):
         return self.replies.filter(image_width__gt=0).count()
 
     def can_bump(self):
         """
         Check if the thread can be bumped by replying
         """
 
         if self.archived:
             return False
 
         post_count = self.get_reply_count()
 
         return post_count < settings.MAX_POSTS_PER_THREAD
 
     def delete_with_posts(self):
         """
         Completely delete thread and all its posts
         """
 
         if self.replies.count() > 0:
             self.replies.all().delete()
 
         self.delete()
 
     def get_last_replies(self):
         """
         Get last replies, not including opening post
         """
 
         if settings.LAST_REPLIES_COUNT > 0:
             reply_count = self.get_reply_count()
 
             if reply_count > 0:
                 reply_count_to_show = min(settings.LAST_REPLIES_COUNT,
                                           reply_count - 1)
                 last_replies = self.replies.all().order_by('pub_time')[
                                reply_count - reply_count_to_show:]
 
                 return last_replies
 
+    def get_skipped_replies_count(self):
+        last_replies = self.get_last_replies()
+        return self.get_reply_count() - len(last_replies) - 1
+
     def get_replies(self):
         """
         Get sorted thread posts
         """
 
         return self.replies.all().order_by('pub_time')
 
     def add_tag(self, tag):
         """
         Connect thread to a tag and tag to a thread
         """
 
         self.tags.add(tag)
         tag.threads.add(self)
 
     def get_opening_post(self):
         """
         Get first post of the thread
         """
 
         return self.get_replies()[0]
 
     def __unicode__(self):
         return str(self.get_replies()[0].id)
 
     def get_pub_time(self):
         """
         Thread does not have its own pub time, so we need to get it from
         the opening post
         """
 
         return self.get_opening_post().pub_time

boards/templates/boards/login.html

@@ -1,29 +1,29 b''
 {% extends "boards/base.html" %}
 
 {% load i18n %}
 
 {% block head %}
-    <title>{% trans 'Login' %}</title>
+    <title>{% trans 'Login' %} - {{ site_name }}</title>
 {% endblock %}
 
 {% block content %}
 
     <form enctype="multipart/form-data" method="post">
     <div class="post-form-w">
         <div class="post-form">
             <div class="form-row">
                 <div class="form-label">{% trans 'User ID' %}</div>
                 <div class="form-input">{{ form.user_id }}</div>
                 <div class="form-errors">{{ form.user_id.errors }}</div>
             </div>
         </div>
         <div class="form-submit">
             <input type="submit" value="{% trans "Login" %}"/>
         </div>
         <div>
             {% trans 'Insert your user id above' %}
         </div>
     </div>
     </form>
 
 {% endblock %}
  No newline at end of file

boards/templates/boards/post.html

@@ -1,83 +1,91 b''
 {% load i18n %}
 {% load board %}
 
 {% spaceless %}
-{% if post.thread_new.archived %}
-    <div class="post archive_post" id="{{ post.id }}">
-{% elif post.thread_new.can_bump %}
-    <div class="post" id="{{ post.id }}">
-{% else %}
-    <div class="post dead_post" id="{{ post.id }}">
-{% endif %}
-
-{% if post.image %}
-    <div class="image">
-        <a
-                class="thumb"
-                href="{{ post.image.url }}"><img
-                src="{{ post.image.url_200x150 }}"
-                alt="{{ post.id }}"
-                width="{{ post.image_pre_width }}"
-                height="{{ post.image_pre_height }}"
-                data-width="{{ post.image_width }}"
-                data-height="{{ post.image_height }}"/>
-        </a>
-    </div>
-{% endif %}
-<div class="message">
-    <div class="post-info">
-        <span class="title">{{ post.title }}</span>
-        <a class="post_id" href="{% post_url post.id %}">
-            ({{ post.id }}) </a>
-        [<span class="pub_time">{{ post.pub_time }}</span>]
-        {% if not truncated %}
-            [<a href="#" onclick="javascript:addQuickReply('{{ post.id }}')
-                ; return false;">&gt;&gt;</a>]
-        {% endif %}
-        {% if post.is_opening and need_open_link %}
-            [<a class="link" href="
-                    {% url 'thread' post.id %}#form">{% trans "Reply" %}</a>]
+    {% with thread=post.thread_new %}
+        {% if thread.archived %}
+            <div class="post archive_post" id="{{ post.id }}">
+        {% elif thread.can_bump %}
+            <div class="post" id="{{ post.id }}">
+        {% else %}
+            <div class="post dead_post" id="{{ post.id }}">
         {% endif %}
 
-        {% if moderator %}
-            <span class="moderator_info">
-                [<a href="{% url 'delete' post_id=post.id %}"
-                    >{% trans 'Delete' %}</a>]
-                ({{ post.poster_ip }})
-                [<a href="{% url 'ban' post_id=post.id %}?next={{ request.path }}"
-                    >{% trans 'Ban IP' %}</a>]
-            </span>
+    {% if post.image %}
+        <div class="image">
+            <a
+                    class="thumb"
+                    href="{{ post.image.url }}"><img
+                    src="{{ post.image.url_200x150 }}"
+                    alt="{{ post.id }}"
+                    width="{{ post.image_pre_width }}"
+                    height="{{ post.image_pre_height }}"
+                    data-width="{{ post.image_width }}"
+                    data-height="{{ post.image_height }}"/>
+            </a>
+        </div>
+    {% endif %}
+    <div class="message">
+        <div class="post-info">
+            <span class="title">{{ post.title }}</span>
+            <a class="post_id" href="{% post_url post.id %}">
+                ({{ post.id }}) </a>
+            [<span class="pub_time">{{ post.pub_time }}</span>]
+            {% if thread.archived %}
+                — [{{ thread.bump_time }}]
+            {% endif %}
+            {% if not truncated %}
+                [<a href="#" onclick="javascript:addQuickReply('{{ post.id }}')
+                    ; return false;">&gt;&gt;</a>]
+            {% endif %}
+            {% if post.is_opening and need_open_link %}
+                {% if post.thread_new.archived %}
+                    [<a class="link" href="{% url 'thread' post.id %}">{% trans "Open" %}</a>]
+                {% else %}
+                    [<a class="link" href="{% url 'thread' post.id %}#form">{% trans "Reply" %}</a>]
+                {% endif %}
+            {% endif %}
+
+            {% if moderator %}
+                <span class="moderator_info">
+                    [<a href="{% url 'delete' post_id=post.id %}"
+                        >{% trans 'Delete' %}</a>]
+                    ({{ post.poster_ip }})
+                    [<a href="{% url 'ban' post_id=post.id %}?next={{ request.path }}"
+                        >{% trans 'Ban IP' %}</a>]
+                </span>
+            {% endif %}
+        </div>
+        {% autoescape off %}
+            {% if truncated %}
+                {{ post.text.rendered|truncatewords_html:50 }}
+            {% else %}
+                {{ post.text.rendered }}
+            {% endif %}
+        {% endautoescape %}
+        {% if post.is_referenced %}
+            <div class="refmap">
+                {% trans "Replies" %}:
+                {% for ref_post in post.get_sorted_referenced_posts %}
+                    <a href="{% post_url ref_post.id %}">&gt;&gt;{{ ref_post.id }}</a
+                            >{% if not forloop.last %},{% endif %}
+                {% endfor %}
+            </div>
         {% endif %}
     </div>
-    {% autoescape off %}
-        {% if truncated %}
-            {{ post.text.rendered|truncatewords_html:50 }}
-        {% else %}
-            {{ post.text.rendered }}
-        {% endif %}
-    {% endautoescape %}
-    {% if post.is_referenced %}
-        <div class="refmap">
-            {% trans "Replies" %}:
-            {% for ref_post in post.get_sorted_referenced_posts %}
-                <a href="{% post_url ref_post.id %}">&gt;&gt;{{ ref_post.id }}</a
-                        >{% if not forloop.last %},{% endif %}
-            {% endfor %}
+    {% if post.is_opening and thread.tags.exists %}
+        <div class="metadata">
+            {% if post.is_opening and need_open_link %}
+                {{ thread.get_images_count }} {% trans 'images' %}.
+            {% endif %}
+            <span class="tags">
+                {% for tag in thread.get_tags %}
+                    <a class="tag" href="{% url 'tag' tag.name %}">
+                        #{{ tag.name }}</a>{% if not forloop.last %},{% endif %}
+                {% endfor %}
+            </span>
         </div>
     {% endif %}
-</div>
-{% if post.is_opening and post.thread_new.tags.exists %}
-    <div class="metadata">
-        {% if post.is_opening and need_open_link %}
-            {{ post.thread_new.get_images_count }} {% trans 'images' %}.
-        {% endif %}
-        <span class="tags">
-            {% for tag in post.thread_new.get_tags %}
-                <a class="tag" href="{% url 'tag' tag.name %}">
-                    #{{ tag.name }}</a>{% if not forloop.last %},{% endif %}
-            {% endfor %}
-        </span>
     </div>
-{% endif %}
-</div>
+    {% endwith %}
 {% endspaceless %}

boards/templates/boards/posting_general.html

@@ -1,149 +1,151 b''
 {% extends "boards/base.html" %}
 
 {% load i18n %}
 {% load cache %}
 {% load board %}
 {% load static %}
 
 {% block head %}
     {% if tag %}
-        <title>Neboard - {{ tag.name }}</title>
+        <title>{{ tag.name }} - {{ site_name }}</title>
     {% else %}
-        <title>Neboard</title>
+        <title>{{ site_name }}</title>
     {% endif %}
 
     {% if current_page.has_previous %}
         <link rel="prev" href="
             {% if tag %}
                 {% url "tag" tag_name=tag page=current_page.previous_page_number %}
             {% else %}
                 {% url "index" page=current_page.previous_page_number %}
             {% endif %}
         " />
     {% endif %}
     {% if current_page.has_next %}
         <link rel="next" href="
             {% if tag %}
                 {% url "tag" tag_name=tag page=current_page.next_page_number %}
             {% else %}
                 {% url "index" page=current_page.next_page_number %}
             {% endif %}
         " />
     {% endif %}
 
 {% endblock %}
 
 {% block content %}
 
     {% get_current_language as LANGUAGE_CODE %}
 
 {% if tag %}
     <div class="tag_info">
         <h2>
             {% if tag in user.fav_tags.all %}
                 <a href="{% url 'tag_unsubscribe' tag.name %}?next={{ request.path }}"
                    class="fav">★</a>
             {% else %}
                 <a href="{% url 'tag_subscribe' tag.name %}?next={{ request.path }}"
                    class="not_fav">★</a>
             {% endif %}
             #{{ tag.name }}
         </h2>
     </div>
 {% endif %}
 
     {% if threads %}
         {% if current_page.has_previous %}
             <div class="page_link">
                 <a href="
             {% if tag %}
                 {% url "tag" tag_name=tag page=current_page.previous_page_number %}
             {% else %}
                 {% url "index" page=current_page.previous_page_number %}
             {% endif %}
                 ">{% trans "Previous page" %}</a>
             </div>
         {% endif %}
 
         {% for thread in threads %}
-            {% cache 600 thread_short thread.thread.id thread.thread.last_edit_time moderator LANGUAGE_CODE %}
+            {% cache 600 thread_short thread.id thread.last_edit_time moderator LANGUAGE_CODE %}
             <div class="thread">
-                {% post_view_truncated thread.op True moderator %}
-            {% if thread.last_replies.exists %}
-                {% if thread.skipped_replies %}
+                {% post_view_truncated thread.get_opening_post True moderator %}
+            {% if not thread.archived %}
+            {% if thread.get_last_replies.exists %}
+                {% if thread.get_skipped_replies_count %}
                     <div class="skipped_replies">
-                        <a href="{% url 'thread' thread.op.id %}">
-                        {% blocktrans with count=thread.skipped_replies %}Skipped {{ count }} replies. Open thread to see all replies.{% endblocktrans %}
+                        <a href="{% url 'thread' thread.get_opening_post.id %}">
+                            {% blocktrans with count=thread.get_skipped_replies_count %}Skipped {{ count }} replies. Open thread to see all replies.{% endblocktrans %}
                         </a>
                     </div>
                 {% endif %}
                 <div class="last-replies">
-                    {% for post in thread.last_replies %}
+                    {% for post in thread.get_last_replies %}
                         {% post_view_truncated post moderator=moderator%}
                     {% endfor %}
                 </div>
             {% endif %}
+            {% endif %}
         </div>
         {% endcache %}
         {% endfor %}
 
         {% if current_page.has_next %}
             <div class="page_link">
                 <a href="
             {% if tag %}
                 {% url "tag" tag_name=tag page=current_page.next_page_number %}
             {% else %}
                 {% url "index" page=current_page.next_page_number %}
             {% endif %}
                 ">{% trans "Next page" %}</a>
             </div>
         {% endif %}
     {% else %}
         <div class="post">
             {% trans 'No threads exist. Create the first one!' %}</div>
     {% endif %}
 
     <div class="post-form-w">
         <script src="{% static 'js/panel.js' %}"></script>
         <div class="post-form">
             <div class="form-title">{% trans "Create new thread" %}</div>
             <form enctype="multipart/form-data" method="post">{% csrf_token %}
                 {{ form.as_div }}
                 <div class="form-submit">
                     <input type="submit" value="{% trans "Post" %}"/>
                 </div>
             </form>
             <div>
                 {% trans 'Tags must be delimited by spaces. Text or image is required.' %}
             </div>
             <div><a href="{% url "staticpage" name="help" %}">
                 {% trans 'Text syntax' %}</a></div>
         </div>
     </div>
 
 {% endblock %}
 
 {% block metapanel %}
 
     <span class="metapanel">
-        <b><a href="{% url "authors" %}">Neboard</a> 1.6 Amon</b>
+        <b><a href="{% url "authors" %}">{{ site_name }}</a> {{ version }}</b>
         {% trans "Pages:" %}[
         {% for page in paginator.page_range %}
             <a
                 {% ifequal page current_page.number %}
                     class="current_page"
                 {% endifequal %}
                 href="
             {% if tag %}
                 {% url "tag" tag_name=tag page=page %}
             {% else %}
                 {% url "index" page=page %}
             {% endif %}
             ">{{ page }}</a>
             {% if not forloop.last %},{% endif %}
         {% endfor %}
         ]
         [<a href="rss/">RSS</a>]
     </span>
 
 {% endblock %}

boards/templates/boards/settings.html

@@ -1,37 +1,37 b''
 {% extends "boards/base.html" %}
 
 {% load i18n %}
 {% load humanize %}
 
 {% block head %}
-    <title>Neboard settings</title>
+    <title>{% trans 'Settings' %} - {{ site_name }}</title>
 {% endblock %}
 
 {% block content %}
 
     <div class="post">
     <p>
         {% trans 'User:' %} <b>{{ user.user_id }}</b>.
         {% if user.is_moderator %}
             {% trans 'You are moderator.' %}
         {% endif %}
     </p>
     <p>{% trans 'Posts:' %} {{ user.get_post_count }}</p>
     <p>{% trans 'First access:' %} {{ user.registration_time|naturaltime }}</p>
     {% if user.get_last_access_time %}
         <p>{% trans 'Last access:' %} {{ user.get_last_access_time|naturaltime }}</p>
     {% endif %}
     </div>
 
     <div class="post-form-w">
     <div class="post-form">
         <form method="post">{% csrf_token %}
             {{ form.as_div }}
             <div class="form-submit">
                 <input type="submit" value="{% trans "Save" %}" />
             </div>
         </form>
     </div>
     </div>
 
 {% endblock %}

boards/templates/boards/thread.html

@@ -1,79 +1,80 b''
 {% extends "boards/base.html" %}
 
 {% load i18n %}
 {% load cache %}
 {% load static from staticfiles %}
 {% load board %}
 
 {% block head %}
-    <title>{{ thread.get_opening_post.get_title|striptags|truncatewords:10 }} - Neboard</title>
+    <title>{{ thread.get_opening_post.get_title|striptags|truncatewords:10 }}
+        - {{ site_name }}</title>
 {% endblock %}
 
 {% block content %}
     {% spaceless %}
     {% get_current_language as LANGUAGE_CODE %}
 
     {% cache 600 thread_view thread.id thread.last_edit_time moderator LANGUAGE_CODE %}
 
         <div class="image-mode-tab">
             <a class="current_mode" href="{% url 'thread' thread.get_opening_post.id %}">{% trans 'Normal mode' %}</a>,
             <a href="{% url 'thread_mode' thread.get_opening_post.id 'gallery' %}">{% trans 'Gallery mode' %}</a>
         </div>
 
         {% if bumpable %}
             <div class="bar-bg">
                 <div class="bar-value" style="width:{{ bumplimit_progress }}%" id="bumplimit_progress">
                 </div>
                 <div class="bar-text">
                     <span id="left_to_limit">{{ posts_left }}</span> {% trans 'posts to bumplimit' %}
                 </div>
             </div>
         {% endif %}
     <div class="thread">
     {% for post in posts %}
         {% post_view post moderator=moderator %}
     {% endfor %}
     </div>
     {% endcache %}
 
     {% if not thread.archived %}
 
     <div class="post-form-w">
         <script src="{% static 'js/panel.js' %}"></script>
         <div class="form-title">{% trans "Reply to thread" %} #{{ thread.get_opening_post.id }}</div>
         <div class="post-form">
             <form id="form" enctype="multipart/form-data" method="post"
                     >{% csrf_token %}
                 {{ form.as_div }}
                 <div class="form-submit">
                     <input type="submit" value="{% trans "Post" %}"/>
                 </div>
             </form>
             <div><a href="{% url "staticpage" name="help" %}">
                 {% trans 'Text syntax' %}</a></div>
         </div>
     </div>
 
     <script src="{% static 'js/jquery.form.min.js' %}"></script>
     <script src="{% static 'js/thread_update.js' %}"></script>
     {% endif %}
 
     <script src="{% static 'js/thread.js' %}"></script>
 
     {% endspaceless %}
 {% endblock %}
 
 {% block metapanel %}
 
     {% get_current_language as LANGUAGE_CODE %}
 
     <span class="metapanel" data-last-update="{{ last_update }}">
         {% cache 600 thread_meta thread.last_edit_time moderator LANGUAGE_CODE %}
             <span id="reply-count">{{ thread.get_reply_count }}</span> {% trans 'replies' %},
             <span id="image-count">{{ thread.get_images_count }}</span> {% trans 'images' %}.
             {% trans 'Last update: ' %}<span id="last-update">{{ thread.last_edit_time }}</span>
             [<a href="rss/">RSS</a>]
         {% endcache %}
     </span>
 
 {% endblock %}

boards/templates/boards/thread_gallery.html

@@ -1,64 +1,65 b''
 {% extends "boards/base.html" %}
 
 {% load i18n %}
 {% load cache %}
 {% load static from staticfiles %}
 {% load board %}
 
 {% block head %}
-    <title>{{ thread.get_opening_post.get_title|striptags|truncatewords:10 }} - Neboard</title>
+    <title>{{ thread.get_opening_post.get_title|striptags|truncatewords:10 }}
+        - {{ site_name }}</title>
 {% endblock %}
 
 {% block content %}
     {% spaceless %}
     {% get_current_language as LANGUAGE_CODE %}
 
     <script src="{% static 'js/thread.js' %}"></script>
 
     {% cache 600 thread_gallery_view thread.id thread.last_edit_time LANGUAGE_CODE request.get_host %}
     <div class="image-mode-tab">
         <a href="{% url 'thread' thread.get_opening_post.id %}">{% trans 'Normal mode' %}</a>,
         <a class="current_mode" href="{% url 'thread_mode' thread.get_opening_post.id 'gallery' %}">{% trans 'Gallery mode' %}</a>
     </div>
 
     <div id="posts-table">
     {% for post in posts %}
         <div class="gallery_image">
             <div>
                 <a
                         class="thumb"
                         href="{{ post.image.url }}"><img
                         src="{{ post.image.url_200x150 }}"
                         alt="{{ post.id }}"
                         width="{{ post.image_pre_width }}"
                         height="{{ post.image_pre_height }}"
                         data-width="{{ post.image_width }}"
                         data-height="{{ post.image_height }}"/>
                 </a>
             </div>
             <div class="gallery_image_metadata">
                 {{ post.image_width }}x{{ post.image_height }}
                 {% image_actions post.image.url request.get_host %}
             </div>
         </div>
     {% endfor %}
     </div>
     {% endcache %}
 
     {% endspaceless %}
 {% endblock %}
 
 {% block metapanel %}
 
     {% get_current_language as LANGUAGE_CODE %}
 
     <span class="metapanel" data-last-update="{{ last_update }}">
         {% cache 600 thread_meta thread.last_edit_time moderator LANGUAGE_CODE %}
             <span id="reply-count">{{ thread.get_reply_count }}</span> {% trans 'replies' %},
             <span id="image-count">{{ thread.get_images_count }}</span> {% trans 'images' %}.
             {% trans 'Last update: ' %}{{ thread.last_edit_time }}
             [<a href="rss/">RSS</a>]
         {% endcache %}
     </span>
 
 {% endblock %}

boards/templatetags/board.py

@@ -1,76 +1,76 b''
 from django.core.urlresolvers import reverse
 from django.shortcuts import get_object_or_404
 from boards.models import Post
 from boards.views import thread, api
 from django import template
 
 register = template.Library()
 
 actions = [
     {
         'name': 'google',
         'link': 'http://google.com/searchbyimage?image_url=%s',
     },
     {
         'name': 'iqdb',
         'link': 'http://iqdb.org/?url=%s',
     },
 ]
 
 
 @register.simple_tag(name='post_url')
 def post_url(*args, **kwargs):
     post_id = args[0]
 
     post = get_object_or_404(Post, id=post_id)
 
     if not post.is_opening():
-        link = reverse(thread, kwargs={
+        link = reverse('thread', kwargs={
             'post_id': post.thread_new.get_opening_post().id}) + '#' + str(
             post_id)
     else:
-        link = reverse(thread, kwargs={'post_id': post_id})
+        link = reverse('thread', kwargs={'post_id': post_id})
 
     return link
 
 
 @register.simple_tag(name='image_actions')
 def image_actions(*args, **kwargs):
     image_link = args[0]
     if len(args) > 1:
         image_link = 'http://' + args[1] + image_link # TODO https?
 
     result = ''
 
     for action in actions:
         result += '[<a href="' + action['link'] % image_link + '">' + \
                   action['name'] + '</a>]'
 
     return result
 
 
 @register.inclusion_tag('boards/post.html', name='post_view')
 def post_view(post, moderator=False):
     """
     Get post
     """
 
     return {
         'post': post,
         'moderator': moderator,
     }
 
 
 @register.inclusion_tag('boards/post.html', name='post_view_truncated')
 def post_view_truncated(post, need_open_link=False, moderator=False):
     """
     Get post with truncated text. If the 'open' or 'reply' link is needed, pass
     the second parameter as True.
     """
 
     return {
         'post': post,
         'truncated': True,
         'need_open_link': need_open_link,
         'moderator': moderator,
     }
  No newline at end of file

boards/urls.py

@@ -1,70 +1,76 b''
 from django.conf.urls import patterns, url, include
 from boards import views
 from boards.rss import AllThreadsFeed, TagThreadsFeed, ThreadPostsFeed
-from boards.views import api
+from boards.views import api, tag_threads, all_threads, archived_threads
 
 js_info_dict = {
     'packages': ('boards',),
 }
 
 urlpatterns = patterns('',
 
     # /boards/
-    url(r'^$', views.index, name='index'),
+    url(r'^$', all_threads.AllThreadsView.as_view(), name='index'),
     # /boards/page/
-    url(r'^page/(?P<page>\w+)/$', views.index, name='index'),
+    url(r'^page/(?P<page>\w+)/$', all_threads.AllThreadsView.as_view(),
+        name='index'),
 
-    url(r'^archive/$', views.archive, name='archive'),
-    url(r'^archive/page/(?P<page>\w+)/$', views.archive, name='archive'),
+    url(r'^archive/$', archived_threads.ArchiveView.as_view(), name='archive'),
+    url(r'^archive/page/(?P<page>\w+)/$',
+        archived_threads.ArchiveView.as_view(), name='archive'),
 
     # login page
     url(r'^login/$', views.login, name='login'),
 
     # /boards/tag/tag_name/
-    url(r'^tag/(?P<tag_name>\w+)/$', views.tag, name='tag'),
+    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+)/$', views.tag, name='tag'),
+    url(r'^tag/(?P<tag_name>\w+)/page/(?P<page>\w+)/$',
+        tag_threads.TagView.as_view(), name='tag'),
 
     # /boards/tag/tag_name/unsubscribe/
     url(r'^tag/(?P<tag_name>\w+)/subscribe/$', views.tag_subscribe,
         name='tag_subscribe'),
     # /boards/tag/tag_name/unsubscribe/
     url(r'^tag/(?P<tag_name>\w+)/unsubscribe/$', views.tag_unsubscribe,
         name='tag_unsubscribe'),
 
     # /boards/thread/
-    url(r'^thread/(?P<post_id>\w+)/$', views.thread, name='thread'),
-    url(r'^thread/(?P<post_id>\w+)/(?P<mode>\w+)/$', views.thread, name='thread_mode'),
+    url(r'^thread/(?P<post_id>\w+)/$', views.thread.ThreadView.as_view(),
+        name='thread'),
+    url(r'^thread/(?P<post_id>\w+)/(?P<mode>\w+)/$', views.thread.ThreadView
+        .as_view(), name='thread_mode'),
     url(r'^settings/$', views.settings, name='settings'),
     url(r'^tags/$', views.all_tags, name='tags'),
     url(r'^captcha/', include('captcha.urls')),
     url(r'^jump/(?P<post_id>\w+)/$', views.jump_to_post, name='jumper'),
     url(r'^authors/$', views.authors, name='authors'),
     url(r'^delete/(?P<post_id>\w+)/$', views.delete, name='delete'),
     url(r'^ban/(?P<post_id>\w+)/$', views.ban, name='ban'),
 
-    url(r'^banned/$', views.you_are_banned, name='banned'),
+    url(r'^banned/$', views.banned.BannedView.as_view, name='banned'),
     url(r'^staticpage/(?P<name>\w+)/$', views.static_page, name='staticpage'),
 
     # RSS feeds
     url(r'^rss/$', AllThreadsFeed()),
     url(r'^page/(?P<page>\w+)/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>\w+)/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>\w+)/$', api.get_post, name="get_post"),
     url(r'^api/diff_thread/(?P<thread_id>\w+)/(?P<last_update_time>\w+)/$',
         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,
+    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/add_post/(?P<opening_post_id>\w+)/$', api.api_add_post, name='add_post'),
 
 )

boards/utils.py

@@ -1,73 +1,80 b''
 """
 This module contains helper functions and helper classes.
 """
+from django.utils import timezone
 
 from neboard import settings
 import time
 
 
 KEY_CAPTCHA_FAILS = 'key_captcha_fails'
 KEY_CAPTCHA_DELAY_TIME = 'key_captcha_delay_time'
 KEY_CAPTCHA_LAST_ACTIVITY = 'key_captcha_last_activity'
 
 
 def need_include_captcha(request):
     """
     Check if request is made by a user.
     It contains rules which check for bots.
     """
 
     if not settings.ENABLE_CAPTCHA:
         return False
 
     enable_captcha = False
 
     #newcomer
     if KEY_CAPTCHA_LAST_ACTIVITY not in request.session:
         return settings.ENABLE_CAPTCHA
 
     last_activity = request.session[KEY_CAPTCHA_LAST_ACTIVITY]
     current_delay = int(time.time()) - last_activity
 
     delay_time = (request.session[KEY_CAPTCHA_DELAY_TIME]
                   if KEY_CAPTCHA_DELAY_TIME in request.session
                   else settings.CAPTCHA_DEFAULT_SAFE_TIME)
 
     if current_delay < delay_time:
         enable_captcha = True
 
     print 'ENABLING' + str(enable_captcha)
 
     return enable_captcha
 
 
 def update_captcha_access(request, passed):
     """
     Update captcha fields.
     It will reduce delay time if user passed captcha verification and
     it will increase it otherwise.
     """
     session = request.session
 
     delay_time = (request.session[KEY_CAPTCHA_DELAY_TIME]
                   if KEY_CAPTCHA_DELAY_TIME in request.session
                   else settings.CAPTCHA_DEFAULT_SAFE_TIME)
 
     print "DELAY TIME = " + str(delay_time)
 
     if passed:
         delay_time -= 2 if delay_time >= 7 else 5
     else:
         delay_time += 10
 
     session[KEY_CAPTCHA_LAST_ACTIVITY] = int(time.time())
     session[KEY_CAPTCHA_DELAY_TIME] = delay_time
 
 
 def get_client_ip(request):
     x_forwarded_for = request.META.get('HTTP_X_FORWARDED_FOR')
     if x_forwarded_for:
         ip = x_forwarded_for.split(',')[-1].strip()
     else:
         ip = request.META.get('REMOTE_ADDR')
-    return ip
  No newline at end of file
+    return ip
+
+
+def datetime_to_epoch(datetime):
+    return int(time.mktime(timezone.localtime(
+        datetime,timezone.get_current_timezone()).timetuple())
+               * 1000000 + datetime.microsecond)
  No newline at end of file

boards/views/__init__.py

@@ -1,609 +1,356 b''
 from datetime import datetime, timedelta
 
 from django.db.models import Count
 
-
-OLD_USER_AGE_DAYS = 90
-
 __author__ = 'neko259'
 
 import hashlib
 import string
-import time
 import re
 
 from django.core import serializers
 from django.core.urlresolvers import reverse
-from django.http import HttpResponseRedirect, Http404
+from django.http import HttpResponseRedirect
 from django.http.response import HttpResponse
 from django.template import RequestContext
 from django.shortcuts import render, redirect, get_object_or_404
 from django.utils import timezone
 from django.db import transaction
 from django.views.decorators.cache import cache_page
 from django.views.i18n import javascript_catalog
-from django.core.paginator import Paginator
 
-from boards import forms
 import boards
 from boards import utils
-from boards.forms import ThreadForm, PostForm, SettingsForm, PlainErrorList, \
-    ThreadCaptchaForm, PostCaptchaForm, LoginForm, ModeratorSettingsForm
-from boards.models import Post, Tag, Ban, User, Thread
+from boards.forms import SettingsForm, PlainErrorList, \
+    LoginForm, ModeratorSettingsForm
+from boards.models import Post, Tag, Ban, User
 from boards.models.post import SETTING_MODERATE, REGEX_REPLY
 from boards.models.user import RANK_USER
 from boards import authors
-from boards.utils import get_client_ip
 import neboard
 
+import all_threads
+
 
 BAN_REASON_SPAM = 'Autoban: spam bot'
-MODE_GALLERY = 'gallery'
-MODE_NORMAL = 'normal'
 
 DEFAULT_PAGE = 1
 
 
-def index(request, page=DEFAULT_PAGE):
-    context = _init_default_context(request)
-
-    if utils.need_include_captcha(request):
-        threadFormClass = ThreadCaptchaForm
-        kwargs = {'request': request}
-    else:
-        threadFormClass = ThreadForm
-        kwargs = {}
-
-    if request.method == 'POST':
-        form = threadFormClass(request.POST, request.FILES,
-                               error_class=PlainErrorList, **kwargs)
-        form.session = request.session
-
-        if form.is_valid():
-            return _new_post(request, form)
-        if form.need_to_ban:
-            # Ban user because he is suspected to be a bot
-            _ban_current_user(request)
-    else:
-        form = threadFormClass(error_class=PlainErrorList, **kwargs)
-
-    threads = []
-    for thread_to_show in Post.objects.get_threads(page=int(page)):
-        threads.append(_get_template_thread(thread_to_show))
-
-    # TODO Make this generic for tag and threads list pages
-    context['threads'] = None if len(threads) == 0 else threads
-    context['form'] = form
-
-    paginator = Paginator(Thread.objects.filter(archived=False),
-            neboard.settings.THREADS_PER_PAGE)
-    _get_page_context(paginator, context, page)
-
-    return render(request, 'boards/posting_general.html',
-                  context)
-
-
-def archive(request, page=DEFAULT_PAGE):
-    """
-    Get archived posts
-    """
-
-    context = _init_default_context(request)
-
-    threads = []
-    for thread_to_show in Post.objects.get_threads(page=int(page),
-                                                   archived=True):
-        threads.append(_get_template_thread(thread_to_show))
-
-    context['threads'] = threads
-
-    paginator = Paginator(Thread.objects.filter(archived=True),
-            neboard.settings.THREADS_PER_PAGE)
-    _get_page_context(paginator, context, page)
-
-    return render(request, 'boards/archive.html', context)
-
-
[e-mail]
-def _new_post(request, form, opening_post=None, html_response=True):
-    """Add a new post (in thread or as a reply)."""
-
-    ip = get_client_ip(request)
-    is_banned = Ban.objects.filter(ip=ip).exists()
-
-    if is_banned:
-        if html_response:
-            return redirect(you_are_banned)
-        else:
-            return
-
-    data = form.cleaned_data
-
-    title = data['title']
-    text = data['text']
-
-    text = _remove_invalid_links(text)
-
-    if 'image' in data.keys():
-        image = data['image']
-    else:
-        image = None
-
-    tags = []
-
-    if not opening_post:
-        tag_strings = data['tags']
-
-        if tag_strings:
-            tag_strings = tag_strings.split(' ')
-            for tag_name in tag_strings:
-                tag_name = string.lower(tag_name.strip())
-                if len(tag_name) > 0:
-                    tag, created = Tag.objects.get_or_create(name=tag_name)
-                    tags.append(tag)
-        post_thread = None
-    else:
-        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=_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))
-        else:
-            return redirect(thread, post_id=thread_to_show)
-
-
-def tag(request, tag_name, page=DEFAULT_PAGE):
-    """
-    Get all tag threads. Threads are split in pages, so some page is
-    requested.
-    """
-
-    tag = get_object_or_404(Tag, name=tag_name)
-    threads = []
-    for thread_to_show in Post.objects.get_threads(page=int(page), tag=tag):
-        threads.append(_get_template_thread(thread_to_show))
-
-    if request.method == 'POST':
-        form = ThreadForm(request.POST, request.FILES,
-                          error_class=PlainErrorList)
-        form.session = request.session
-
-        if form.is_valid():
-            return _new_post(request, form)
-        if form.need_to_ban:
-            # Ban user because he is suspected to be a bot
-            _ban_current_user(request)
-    else:
-        form = forms.ThreadForm(initial={'tags': tag_name},
-                                error_class=PlainErrorList)
-
-    context = _init_default_context(request)
-    context['threads'] = None if len(threads) == 0 else threads
-    context['tag'] = tag
-
-    paginator = Paginator(Post.objects.get_threads(tag=tag),
-            neboard.settings.THREADS_PER_PAGE)
-    _get_page_context(paginator, context, page)
-
-    context['form'] = form
-
-    return render(request, 'boards/posting_general.html',
-                  context)
-
-
-def thread(request, post_id, mode=MODE_NORMAL):
-    """Get all thread posts"""
-
-    if utils.need_include_captcha(request):
-        postFormClass = PostCaptchaForm
-        kwargs = {'request': request}
-    else:
-        postFormClass = PostForm
-        kwargs = {}
-
-    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 request.method == 'POST' and not opening_post.thread_new.archived:
-        form = postFormClass(request.POST, request.FILES,
-                             error_class=PlainErrorList, **kwargs)
-        form.session = request.session
-
-        if form.is_valid():
-            return _new_post(request, form, opening_post)
-        if form.need_to_ban:
-            # Ban user because he is suspected to be a bot
-            _ban_current_user(request)
-    else:
-        form = postFormClass(error_class=PlainErrorList, **kwargs)
-
-    thread_to_show = opening_post.thread_new
-
-    context = _init_default_context(request)
-
-    posts = thread_to_show.get_replies()
-    context['form'] = form
-    context["last_update"] = _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 login(request):
     """Log in with user id"""
 
     context = _init_default_context(request)
 
     if request.method == 'POST':
         form = LoginForm(request.POST, request.FILES,
                          error_class=PlainErrorList)
         form.session = request.session
 
         if form.is_valid():
             user = User.objects.get(user_id=form.cleaned_data['user_id'])
             request.session['user_id'] = user.id
-            return redirect(index)
+            return redirect('index')
 
     else:
         form = LoginForm()
 
     context['form'] = form
 
     return render(request, 'boards/login.html', context)
 
 
 def settings(request):
     """User's settings"""
 
     context = _init_default_context(request)
     user = _get_user(request)
     is_moderator = user.is_moderator()
 
     if request.method == 'POST':
         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)
     else:
         selected_theme = _get_theme(request)
 
         if is_moderator:
             form = ModeratorSettingsForm(initial={'theme': selected_theme,
                                                   'moderate': context['moderator']},
                                          error_class=PlainErrorList)
         else:
             form = SettingsForm(initial={'theme': selected_theme},
                                 error_class=PlainErrorList)
 
     context['form'] = form
 
     return render(request, 'boards/settings.html', context)
 
 
 def all_tags(request):
     """All tags list"""
 
     context = _init_default_context(request)
     context['all_tags'] = Tag.objects.get_not_empty_tags()
 
     return render(request, 'boards/tags.html', context)
 
 
 def jump_to_post(request, post_id):
     """Determine thread in which the requested post is and open it's page"""
 
     post = get_object_or_404(Post, id=post_id)
 
     if not post.thread:
-        return redirect(thread, post_id=post.id)
+        return redirect('thread', post_id=post.id)
     else:
-        return redirect(reverse(thread, kwargs={'post_id': post.thread.id})
+        return redirect(reverse('thread', kwargs={'post_id': post.thread.id})
                         + '#' + str(post.id))
 
 
 def authors(request):
     """Show authors list"""
 
     context = _init_default_context(request)
     context['authors'] = boards.authors.authors
 
     return render(request, 'boards/authors.html', context)
 
 
 @transaction.atomic
 def delete(request, post_id):
     """Delete post"""
 
     user = _get_user(request)
     post = get_object_or_404(Post, id=post_id)
 
     if user.is_moderator():
         # TODO Show confirmation page before deletion
         Post.objects.delete_post(post)
 
     if not post.thread:
         return _redirect_to_next(request)
     else:
-        return redirect(thread, post_id=post.thread.id)
+        return redirect('thread', post_id=post.thread.id)
 
 
 @transaction.atomic
 def ban(request, post_id):
     """Ban user"""
 
     user = _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 _redirect_to_next(request)
 
 
-def you_are_banned(request):
-    """Show the page that notifies that user is banned"""
-
-    context = _init_default_context(request)
-
-    ban = get_object_or_404(Ban, ip=utils.get_client_ip(request))
-    context['ban_reason'] = ban.reason
-    return render(request, 'boards/staticpages/banned.html', context)
-
-
 def page_404(request):
     """Show page 404 (not found error)"""
 
     context = _init_default_context(request)
     return render(request, 'boards/404.html', context)
 
 
 @transaction.atomic
 def tag_subscribe(request, tag_name):
     """Add tag to favorites"""
 
     user = _get_user(request)
     tag = get_object_or_404(Tag, name=tag_name)
 
     if not tag in user.fav_tags.all():
         user.add_tag(tag)
 
     return _redirect_to_next(request)
 
 
 @transaction.atomic
 def tag_unsubscribe(request, tag_name):
     """Remove tag from favorites"""
 
     user = _get_user(request)
     tag = get_object_or_404(Tag, name=tag_name)
 
     if tag in user.fav_tags.all():
         user.remove_tag(tag)
 
     return _redirect_to_next(request)
 
 
 def static_page(request, name):
     """Show a static page that needs only tags list and a CSS"""
 
     context = _init_default_context(request)
     return render(request, 'boards/staticpages/' + name + '.html', context)
 
 
 def api_get_post(request, post_id):
     """
     Get the JSON of a post. This can be
     used as and API for external clients.
     """
 
     post = get_object_or_404(Post, id=post_id)
 
     json = serializers.serialize("json", [post], fields=(
         "pub_time", "_text_rendered", "title", "text", "image",
         "image_width", "image_height", "replies", "tags"
     ))
 
     return HttpResponse(content=json)
 
 
 @cache_page(86400)
 def cached_js_catalog(request, domain='djangojs', packages=None):
     return javascript_catalog(request, domain, packages)
 
 
+# TODO This method is deprecated and should be removed after switching to
+# class-based view
 def _get_theme(request, user=None):
     """Get user's CSS theme"""
 
     if not user:
         user = _get_user(request)
     theme = user.get_setting('theme')
     if not theme:
         theme = neboard.settings.DEFAULT_THEME
 
     return theme
 
 
+# TODO This method is deprecated and should be removed after switching to
+# class-based view
 def _init_default_context(request):
     """Create context with default values that are used in most views"""
 
     context = RequestContext(request)
 
     user = _get_user(request)
     context['user'] = user
     context['tags'] = user.get_sorted_fav_tags()
     context['posts_per_day'] = float(Post.objects.get_posts_per_day())
 
     theme = _get_theme(request, user)
     context['theme'] = theme
     context['theme_css'] = 'css/' + theme + '/base_page.css'
 
     # This shows the moderator panel
     moderate = user.get_setting(SETTING_MODERATE)
     if moderate == 'True':
         context['moderator'] = user.is_moderator()
     else:
         context['moderator'] = False
 
     return context
 
 
+# TODO This method is deprecated and should be removed after switching to
+# class-based view
 def _get_user(request):
     """
     Get current user from the session. If the user does not exist, create
     a new one.
     """
 
     session = request.session
     if not 'user_id' in session:
         request.session.save()
 
         md5 = hashlib.md5()
         md5.update(session.session_key)
         new_id = md5.hexdigest()
 
         while User.objects.filter(user_id=new_id).exists():
             md5.update(str(timezone.now()))
             new_id = md5.hexdigest()
 
         time_now = timezone.now()
         user = User.objects.create(user_id=new_id, rank=RANK_USER,
                                    registration_time=time_now)
 
-        _delete_old_users()
+        # TODO This is just a test. This method should be removed
+        # _delete_old_users()
 
         session['user_id'] = user.id
     else:
         user = User.objects.get(id=session['user_id'])
 
     return user
 
 
 def _redirect_to_next(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)
+        return redirect('index')
 
 
 @transaction.atomic
 def _ban_current_user(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()
 
 
 def _remove_invalid_links(text):
     """
     Replace invalid links in posts so that they won't be parsed.
     Invalid links are links to non-existent posts
     """
 
     for reply_number in re.finditer(REGEX_REPLY, text):
         post_id = reply_number.group(1)
         post = Post.objects.filter(id=post_id)
         if not post.exists():
             text = string.replace(text, '>>' + post_id, post_id)
 
     return text
 
 
-def _datetime_to_epoch(datetime):
-    return int(time.mktime(timezone.localtime(
-        datetime,timezone.get_current_timezone()).timetuple())
-               * 1000000 + datetime.microsecond)
-
-
 def _get_template_thread(thread_to_show):
     """Get template values for thread"""
 
     last_replies = thread_to_show.get_last_replies()
     skipped_replies_count = thread_to_show.get_replies().count() \
                             - len(last_replies) - 1
     return {
         'thread': thread_to_show,
         'op': thread_to_show.get_replies()[0],
         'bumpable': thread_to_show.can_bump(),
         'last_replies': last_replies,
         'skipped_replies': skipped_replies_count,
         }
-
-
-def _delete_old_users():
-    """
-    Delete users with no favorite tags and posted messages. These can be spam
-    bots or just old user accounts
-    """
-
-    old_registration_date = datetime.now().date() - timedelta(OLD_USER_AGE_DAYS)
-
-    for user in User.objects.annotate(tags_count=Count('fav_tags')).filter(
-            tags_count=0).filter(registration_time__lt=old_registration_date):
-        if not Post.objects.filter(user=user).exists():
-            user.delete()
-
-
-def _get_page_context(paginator, context, page):
-    """
-    Get pagination context variables
-    """
-
-    context['paginator'] = paginator
-    context['current_page'] = paginator.page(int(page))

boards/views/api.py

@@ -1,205 +1,206 b''
 from datetime import datetime
 import json
 from django.db import transaction
 from django.http import HttpResponse
 from django.shortcuts import get_object_or_404, render
 from django.template import RequestContext
 from django.utils import timezone
 from boards.forms import PostForm, PlainErrorList
 from boards.models import Post, Thread, Tag
-from boards.views import _datetime_to_epoch, _new_post, \
-    _ban_current_user
+from boards.utils import datetime_to_epoch
+from boards.views.thread import ThreadView
 
 __author__ = 'neko259'
 
 PARAMETER_TRUNCATED = 'truncated'
 PARAMETER_TAG = 'tag'
 PARAMETER_OFFSET = 'offset'
 PARAMETER_DIFF_TYPE = 'type'
 
 DIFF_TYPE_HTML = 'html'
 DIFF_TYPE_JSON = 'json'
 
 STATUS_OK = 'ok'
 STATUS_ERROR = 'error'
 
 
 @transaction.atomic
 def api_get_threaddiff(request, thread_id, last_update_time):
     """Get posts that were changed or added since time"""
 
     thread = get_object_or_404(Post, id=thread_id).thread_new
 
     filter_time = datetime.fromtimestamp(float(last_update_time) / 1000000,
                                          timezone.get_current_timezone())
 
     json_data = {
         'added': [],
         'updated': [],
         'last_update': None,
     }
     added_posts = Post.objects.filter(thread_new=thread,
                                       pub_time__gt=filter_time) \
         .order_by('pub_time')
     updated_posts = Post.objects.filter(thread_new=thread,
                                         pub_time__lte=filter_time,
                                         last_edit_time__gt=filter_time)
 
     diff_type = DIFF_TYPE_HTML
     if PARAMETER_DIFF_TYPE in request.GET:
         diff_type = request.GET[PARAMETER_DIFF_TYPE]
 
     for post in added_posts:
         json_data['added'].append(_get_post_data(post.id, diff_type, request))
     for post in updated_posts:
         json_data['updated'].append(_get_post_data(post.id, diff_type, request))
-    json_data['last_update'] = _datetime_to_epoch(thread.last_edit_time)
+    json_data['last_update'] = datetime_to_epoch(thread.last_edit_time)
 
     return HttpResponse(content=json.dumps(json_data))
 
 
 def api_add_post(request, opening_post_id):
     """
     Add a post and return the JSON response for it
     """
 
     opening_post = get_object_or_404(Post, id=opening_post_id)
 
     status = STATUS_OK
     errors = []
 
     if request.method == 'POST':
         form = PostForm(request.POST, request.FILES,
                           error_class=PlainErrorList)
         form.session = request.session
 
         #if form.need_to_ban:
         #    # Ban user because he is suspected to be a bot
         #    _ban_current_user(request)
         #    status = STATUS_ERROR
         if form.is_valid():
-            _new_post(request, form, opening_post, html_response=False)
+            ThreadView().new_post(request, form, opening_post,
+                                  html_response=False)
         else:
             status = STATUS_ERROR
             errors = form.as_json_errors()
 
     response = {
         'status': status,
         'errors': errors,
     }
 
     return HttpResponse(content=json.dumps(response))
 
 
 def get_post(request, post_id):
     """
     Get the html of a post. Used for popups. Post can be truncated if used
     in threads list with 'truncated' get parameter.
     """
 
     post = get_object_or_404(Post, id=post_id)
 
     context = RequestContext(request)
     context['post'] = post
     if PARAMETER_TRUNCATED in request.GET:
         context[PARAMETER_TRUNCATED] = True
 
     return render(request, 'boards/post.html', context)
 
 
 # TODO Test this
 def api_get_threads(request, count):
     """
     Get the JSON thread opening posts list.
     Parameters that can be used for filtering:
     tag, offset (from which thread to get results)
     """
 
     if PARAMETER_TAG in request.GET:
         tag_name = request.GET[PARAMETER_TAG]
         if tag_name is not None:
             tag = get_object_or_404(Tag, name=tag_name)
             threads = tag.threads.filter(archived=False)
     else: 
         threads = Thread.objects.filter(archived=False)
 
     if PARAMETER_OFFSET in request.GET:
         offset = request.GET[PARAMETER_OFFSET]
         offset = int(offset) if offset is not None else 0
     else:
         offset = 0
 
     threads = threads.order_by('-bump_time')
     threads = threads[offset:offset + int(count)]
 
     opening_posts = []
     for thread in threads:
         opening_post = thread.get_opening_post()
 
         # TODO Add tags, replies and images count
         opening_posts.append(_get_post_data(opening_post.id,
             include_last_update=True))
 
     return HttpResponse(content=json.dumps(opening_posts))
 
 
 # TODO Test this
 def api_get_tags(request):
     """
     Get all tags or user tags.
     """
 
     # TODO Get favorite tags for the given user ID
 
     tags = Tag.objects.get_not_empty_tags()
     tag_names = []
     for tag in tags:
         tag_names.append(tag.name)
 
     return HttpResponse(content=json.dumps(tag_names))
 
 
 # TODO The result can be cached by the thread last update time
 # TODO Test this
 def api_get_thread_posts(request, opening_post_id):
     """
     Get the JSON array of thread posts
     """
 
     opening_post = get_object_or_404(Post, id=opening_post_id)
     thread = opening_post.thread_new
     posts = thread.get_replies()
 
     json_data = {
         'posts': [],
         'last_update': None,
     }
     json_post_list = []
 
     for post in posts:
         json_post_list.append(_get_post_data(post.id))
-    json_data['last_update'] = _datetime_to_epoch(thread.last_edit_time)
+    json_data['last_update'] = datetime_to_epoch(thread.last_edit_time)
     json_data['posts'] = json_post_list
 
     return HttpResponse(content=json.dumps(json_data))
 
 
 # TODO Add pub time and replies
 def _get_post_data(post_id, format_type=DIFF_TYPE_JSON, request=None,
         include_last_update=False):
     if format_type == DIFF_TYPE_HTML:
         return get_post(request, post_id).content.strip()
     elif format_type == DIFF_TYPE_JSON:
         post = get_object_or_404(Post, id=post_id)
         post_json = {
             'id': post.id,
             'title': post.title,
             'text': post.text.rendered,
         }
         if post.image:
             post_json['image'] = post.image.url
             post_json['image_preview'] = post.image.url_200x150
         if include_last_update:
-            post_json['bump_time'] = _datetime_to_epoch(
+            post_json['bump_time'] = datetime_to_epoch(
                     post.thread_new.bump_time)
         return post_json

neboard/settings.py

@@ -1,247 +1,249 b''
 # Django settings for neboard project.
 import os
 from boards.mdx_neboard import markdown_extended
 
 DEBUG = True
 TEMPLATE_DEBUG = DEBUG
 
 ADMINS = (
     # ('Your Name', '[e-mail]'),
     ('admin', '[e-mail]')
 )
 
 MANAGERS = ADMINS
 
 DATABASES = {
     'default': {
         'ENGINE': 'django.db.backends.sqlite3', # Add 'postgresql_psycopg2', 'mysql', 'sqlite3' or 'oracle'.
         'NAME': 'database.db',                      # Or path to database file if using sqlite3.
         'USER': '',                      # Not used with sqlite3.
         'PASSWORD': '',                  # Not used with sqlite3.
         'HOST': '',                      # Set to empty string for localhost. Not used with sqlite3.
         'PORT': '',                      # Set to empty string for default. Not used with sqlite3.
 	'CONN_MAX_AGE': None,
     }
 }
 
 # Local time zone for this installation. Choices can be found here:
 # http://en.wikipedia.org/wiki/List_of_tz_zones_by_name
 # although not all choices may be available on all operating systems.
 # In a Windows environment this must be set to your system time zone.
 TIME_ZONE = 'Europe/Kiev'
 
 # Language code for this installation. All choices can be found here:
 # http://www.i18nguy.com/unicode/language-identifiers.html
 LANGUAGE_CODE = 'en'
 
 SITE_ID = 1
 
 # If you set this to False, Django will make some optimizations so as not
 # to load the internationalization machinery.
 USE_I18N = True
 
 # If you set this to False, Django will not format dates, numbers and
 # calendars according to the current locale.
 USE_L10N = True
 
 # If you set this to False, Django will not use timezone-aware datetimes.
 USE_TZ = True
 
 # Absolute filesystem path to the directory that will hold user-uploaded files.
 # Example: "/home/media/media.lawrence.com/media/"
 MEDIA_ROOT = './media/' 
 
 # URL that handles the media served from MEDIA_ROOT. Make sure to use a
 # trailing slash.
 # Examples: "http://media.lawrence.com/media/", "http://example.com/media/"
 MEDIA_URL = '/media/'
 
 # Absolute path to the directory static files should be collected to.
 # Don't put anything in this directory yourself; store your static files
 # in apps' "static/" subdirectories and in STATICFILES_DIRS.
 # Example: "/home/media/media.lawrence.com/static/"
 STATIC_ROOT = ''
 
 # URL prefix for static files.
 # Example: "http://media.lawrence.com/static/"
 STATIC_URL = '/static/'
 
 # Additional locations of static files
 # It is really a hack, put real paths, not related
 STATICFILES_DIRS = (
     os.path.dirname(__file__) + '/boards/static',
 
 #    '/d/work/python/django/neboard/neboard/boards/static',
     # Put strings here, like "/home/html/static" or "C:/www/django/static".
     # Always use forward slashes, even on Windows.
     # Don't forget to use absolute paths, not relative paths.
 )
 
 # List of finder classes that know how to find static files in
 # various locations.
 STATICFILES_FINDERS = (
     'django.contrib.staticfiles.finders.FileSystemFinder',
     'django.contrib.staticfiles.finders.AppDirectoriesFinder',
 )
 
 if DEBUG:
     STATICFILES_STORAGE = \
         'django.contrib.staticfiles.storage.StaticFilesStorage'
 else:
     STATICFILES_STORAGE = \
         'django.contrib.staticfiles.storage.CachedStaticFilesStorage'
 
 # Make this unique, and don't share it with anybody.
 SECRET_KEY = '@1rc$o(7=tt#kd+4s$u6wchm**z^)4x90)7f6z(i&55@o11*8o'
 
 # List of callables that know how to import templates from various sources.
 TEMPLATE_LOADERS = (
     'django.template.loaders.filesystem.Loader',
     'django.template.loaders.app_directories.Loader',
 )
 
 TEMPLATE_CONTEXT_PROCESSORS = (
     'django.core.context_processors.media',
     'django.core.context_processors.static',
     'django.core.context_processors.request',
     'django.contrib.auth.context_processors.auth',
 )
 
 MIDDLEWARE_CLASSES = (
     'django.contrib.sessions.middleware.SessionMiddleware',
     'django.middleware.locale.LocaleMiddleware',
     'django.middleware.common.CommonMiddleware',
     'django.contrib.auth.middleware.AuthenticationMiddleware',
     'django.contrib.messages.middleware.MessageMiddleware',
     'boards.middlewares.BanMiddleware',
     'boards.middlewares.MinifyHTMLMiddleware',
 )
 
 ROOT_URLCONF = 'neboard.urls'
 
 # Python dotted path to the WSGI application used by Django's runserver.
 WSGI_APPLICATION = 'neboard.wsgi.application'
 
 TEMPLATE_DIRS = (
     # Put strings here, like "/home/html/django_templates" or "C:/www/django/templates".
     # Always use forward slashes, even on Windows.
     # Don't forget to use absolute paths, not relative paths.
     'templates',
 )
 
 INSTALLED_APPS = (
     'django.contrib.auth',
     'django.contrib.contenttypes',
     'django.contrib.sessions',
     # 'django.contrib.sites',
     'django.contrib.messages',
     'django.contrib.staticfiles',
     # Uncomment the next line to enable the admin:
      'django.contrib.admin',
     # Uncomment the next line to enable admin documentation:
     # 'django.contrib.admindocs',
     'django.contrib.humanize',
     'django_cleanup',
     'boards',
     'captcha',
     'south',
     'debug_toolbar',
 )
 
 DEBUG_TOOLBAR_PANELS = (
     'debug_toolbar.panels.version.VersionDebugPanel',
     'debug_toolbar.panels.timer.TimerDebugPanel',
     'debug_toolbar.panels.settings_vars.SettingsVarsDebugPanel',
     'debug_toolbar.panels.headers.HeaderDebugPanel',
     'debug_toolbar.panels.request_vars.RequestVarsDebugPanel',
     'debug_toolbar.panels.template.TemplateDebugPanel',
     'debug_toolbar.panels.sql.SQLDebugPanel',
     'debug_toolbar.panels.signals.SignalDebugPanel',
     'debug_toolbar.panels.logger.LoggingPanel',
 )
 
 # TODO: NEED DESIGN FIXES
 CAPTCHA_OUTPUT_FORMAT = (u' %(hidden_field)s '
                          u'<div class="form-label">%(image)s</div>'
                          u'<div class="form-text">%(text_field)s</div>')
 
 # A sample logging configuration. The only tangible logging
 # performed by this configuration is to send an email to
 # the site admins on every HTTP 500 error when DEBUG=False.
 # See http://docs.djangoproject.com/en/dev/topics/logging for
 # more details on how to customize your logging configuration.
 LOGGING = {
     'version': 1,
     'disable_existing_loggers': False,
     'filters': {
         'require_debug_false': {
             '()': 'django.utils.log.RequireDebugFalse'
         }
     },
     'handlers': {
         'mail_admins': {
             'level': 'ERROR',
             'filters': ['require_debug_false'],
             'class': 'django.utils.log.AdminEmailHandler'
         }
     },
     'loggers': {
         'django.request': {
             'handlers': ['mail_admins'],
             'level': 'ERROR',
             'propagate': True,
         },
     }
 }
 
 MARKUP_FIELD_TYPES = (
     ('markdown', markdown_extended),
 )
 # Custom imageboard settings
 # TODO These should me moved to
 MAX_POSTS_PER_THREAD = 10  # Thread bumplimit
 MAX_THREAD_COUNT = 500  # Old threads will be deleted to preserve this count
 THREADS_PER_PAGE = 3
 SITE_NAME = 'Neboard'
 
 THEMES = [
     ('md', 'Mystic Dark'),
     ('md_centered', 'Mystic Dark (centered)'),
     ('sw', 'Snow White'),
     ('pg', 'Photon Gray'),
 ]
 
 DEFAULT_THEME = 'md'
 
 POPULAR_TAGS = 10
 LAST_REPLIES_COUNT = 3
 
 ENABLE_CAPTCHA = False
 # if user tries to post before CAPTCHA_DEFAULT_SAFE_TIME. Captcha will be shown
 CAPTCHA_DEFAULT_SAFE_TIME = 30  # seconds
 POSTING_DELAY = 20  # seconds
 
 COMPRESS_HTML = True
 
+VERSION = '1.7 Anubis'
+
 # Debug mode middlewares
 if DEBUG:
     MIDDLEWARE_CLASSES += (
         'boards.profiler.ProfilerMiddleware',
         'debug_toolbar.middleware.DebugToolbarMiddleware',
     )
 
     def custom_show_toolbar(request):
         return DEBUG
 
     DEBUG_TOOLBAR_CONFIG = {
         'INTERCEPT_REDIRECTS': False,
         'SHOW_TOOLBAR_CALLBACK': custom_show_toolbar,
         'HIDE_DJANGO_SQL': False,
         'ENABLE_STACKTRACES': True,
     }
 
     # FIXME Uncommenting this fails somehow. Need to investigate this
     #DEBUG_TOOLBAR_PANELS += (
     #    'debug_toolbar.panels.profiling.ProfilingDebugPanel',
     #)