Refactoring

boards/models/post.py

@@ -1,438 +1,438
 from datetime import datetime, timedelta, date
 from datetime import time as dtime
 import logging
 import re
 
 from adjacent import Client
 from django.core.cache import cache
 from django.core.urlresolvers import reverse
 from django.db import models, transaction
 from django.db.models import TextField
-from django.template import RequestContext
 from django.template.loader import render_to_string
 from django.utils import timezone
 
 from boards import settings
 from boards.mdx_neboard import bbcode_extended
 from boards.models import PostImage
 from boards.models.base import Viewable
 from boards.models.thread import Thread
 from boards.utils import datetime_to_epoch
 
+
 WS_NOTIFICATION_TYPE_NEW_POST = 'new_post'
 WS_NOTIFICATION_TYPE = 'notification_type'
 
 WS_CHANNEL_THREAD = "thread:"
 
 APP_LABEL_BOARDS = 'boards'
 
 CACHE_KEY_PPD = 'ppd'
 CACHE_KEY_POST_URL = 'post_url'
 
 POSTS_PER_DAY_RANGE = 7
 
 BAN_REASON_AUTO = 'Auto'
 
 IMAGE_THUMB_SIZE = (200, 150)
 
 TITLE_MAX_LENGTH = 200
 
 # TODO This should be removed
 NO_IP = '0.0.0.0'
 
 # TODO Real user agent should be saved instead of this
 UNKNOWN_UA = ''
 
 REGEX_REPLY = re.compile(r'\[post\](\d+)\[/post\]')
 
 PARAMETER_TRUNCATED = 'truncated'
 PARAMETER_TAG = 'tag'
 PARAMETER_OFFSET = 'offset'
 PARAMETER_DIFF_TYPE = 'type'
+PARAMETER_BUMPABLE = 'bumpable'
+PARAMETER_THREAD = 'thread'
+PARAMETER_IS_OPENING = 'is_opening'
+PARAMETER_MODERATOR = 'moderator'
+PARAMETER_POST = 'post'
+PARAMETER_OP_ID = 'opening_post_id'
+PARAMETER_NEED_OPEN_LINK = 'need_open_link'
 
 DIFF_TYPE_HTML = 'html'
 DIFF_TYPE_JSON = 'json'
 
 PREPARSE_PATTERNS = {
     r'>>(\d+)': r'[post]\1[/post]',  # Reflink ">>123"
     r'^>(.+)': r'[quote]\1[/quote]',  # Quote ">text"
     r'^//(.+)': r'[comment]\1[/comment]',  # Comment "//text"
 }
 
 
 class PostManager(models.Manager):
     @transaction.atomic
     def create_post(self, title: str, text: str, image=None, thread=None,
                     ip=NO_IP, tags: list=None):
         """
         Creates new post
         """
 
         if not tags:
             tags = []
 
         posting_time = timezone.now()
         if not thread:
             thread = Thread.objects.create(bump_time=posting_time,
                                            last_edit_time=posting_time)
             new_thread = True
         else:
             new_thread = False
 
         pre_text = self._preparse_text(text)
 
         post = self.create(title=title,
                            text=pre_text,
                            pub_time=posting_time,
                            thread_new=thread,
                            poster_ip=ip,
                            poster_user_agent=UNKNOWN_UA,  # TODO Get UA at
                            # last!
                            last_edit_time=posting_time)
 
         logger = logging.getLogger('boards.post.create')
 
         logger.info('Created post {} by {}'.format(
             post, post.poster_ip))
 
         if image:
             post_image = PostImage.objects.create(image=image)
             post.images.add(post_image)
             logger.info('Created image #{} for post #{}'.format(
                 post_image.id, post.id))
 
         thread.replies.add(post)
         list(map(thread.add_tag, tags))
 
         if new_thread:
             Thread.objects.process_oldest_threads()
         else:
             thread.bump()
             thread.last_edit_time = posting_time
             thread.save()
 
         self.connect_replies(post)
 
         return post
 
     def delete_posts_by_ip(self, ip):
         """
         Deletes all posts of the author with same IP
         """
 
         posts = self.filter(poster_ip=ip)
         for post in posts:
             post.delete()
 
     def  connect_replies(self, post):
         """
         Connects replies to a post to show them as a reflink map
         """
 
         for reply_number in re.finditer(REGEX_REPLY, post.get_raw_text()):
             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.build_refmap()
                 referenced_post.save(update_fields=['refmap', 'last_edit_time'])
 
                 referenced_thread = referenced_post.get_thread()
                 referenced_thread.last_edit_time = post.pub_time
                 referenced_thread.save(update_fields=['last_edit_time'])
 
     def get_posts_per_day(self):
         """
         Gets average count of posts per day for the last 7 days
         """
 
         day_end = date.today()
         day_start = day_end - timedelta(POSTS_PER_DAY_RANGE)
 
         cache_key = CACHE_KEY_PPD + str(day_end)
         ppd = cache.get(cache_key)
         if ppd:
             return ppd
 
         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_period = float(self.filter(
             pub_time__lte=day_time_end,
             pub_time__gte=day_time_start).count())
 
         ppd = posts_per_period / POSTS_PER_DAY_RANGE
 
         cache.set(cache_key, ppd)
         return ppd
 
     def _preparse_text(self, text):
         """
         Preparses text to change patterns like '>>' to a proper bbcode
         tags.
         """
 
         for key, value in PREPARSE_PATTERNS.items():
             text = re.sub(key, value, text, flags=re.MULTILINE)
 
         return text
 
 
 class Post(models.Model, Viewable):
     """A post is a message."""
 
     objects = PostManager()
 
     class Meta:
         app_label = APP_LABEL_BOARDS
         ordering = ('id',)
 
     title = models.CharField(max_length=TITLE_MAX_LENGTH)
     pub_time = models.DateTimeField()
     text = TextField(blank=True, null=True)
     _text_rendered = TextField(blank=True, null=True, editable=False)
 
     images = models.ManyToManyField(PostImage, null=True, blank=True,
                                     related_name='ip+', db_index=True)
 
     poster_ip = models.GenericIPAddressField()
     poster_user_agent = models.TextField()
 
     thread_new = models.ForeignKey('Thread', null=True, default=None,
                                    db_index=True)
     last_edit_time = models.DateTimeField()
 
     referenced_posts = models.ManyToManyField('Post', symmetrical=False,
                                               null=True,
                                               blank=True, related_name='rfp+',
                                               db_index=True)
     refmap = models.TextField(null=True, blank=True)
 
     def __str__(self):
         return 'P#{}/{}'.format(self.id, self.title)
 
     def get_title(self) -> str:
         """
         Gets original post title or part of its text.
         """
 
         title = self.title
         if not title:
             title = self.get_text()
 
         return title
 
     def build_refmap(self) -> None:
         """
         Builds a replies map string from replies list. This is a cache to stop
         the server from recalculating the map on every post show.
         """
         map_string = ''
 
         first = True
         for refpost in self.referenced_posts.all():
             if not first:
                 map_string += ', '
             map_string += '<a href="%s">&gt;&gt;%s</a>' % (refpost.get_url(),
                                                            refpost.id)
             first = False
 
         self.refmap = map_string
 
     def get_sorted_referenced_posts(self):
         return self.refmap
 
     def is_referenced(self) -> bool:
         if not self.refmap:
             return False
         else:
             return len(self.refmap) > 0
 
     def is_opening(self) -> bool:
         """
         Checks if this is an opening post or just a reply.
         """
 
         return self.get_thread().get_opening_post_id() == self.id
 
     @transaction.atomic
     def add_tag(self, tag):
         edit_time = timezone.now()
 
         thread = self.get_thread()
         thread.add_tag(tag)
         self.last_edit_time = edit_time
         self.save(update_fields=['last_edit_time'])
 
         thread.last_edit_time = edit_time
         thread.save(update_fields=['last_edit_time'])
 
     def get_url(self, thread=None):
         """
         Gets full url to the post.
         """
 
         cache_key = CACHE_KEY_POST_URL + str(self.id)
         link = cache.get(cache_key)
 
         if not link:
             if not thread:
                 thread = self.get_thread()
 
             opening_id = thread.get_opening_post_id()
 
             if self.id != opening_id:
                 link = reverse('thread', kwargs={
                     'post_id': opening_id}) + '#' + str(self.id)
             else:
                 link = reverse('thread', kwargs={'post_id': self.id})
 
             cache.set(cache_key, link)
 
         return link
 
     def get_thread(self) -> Thread:
         """
         Gets post's thread.
         """
 
         return self.thread_new
 
     def get_referenced_posts(self):
         return self.referenced_posts.only('id', 'thread_new')
 
     def get_view(self, moderator=False, need_open_link=False,
                  truncated=False, *args, **kwargs):
-        if 'is_opening' in kwargs:
-            is_opening = kwargs['is_opening']
-        else:
-            is_opening = self.is_opening()
+        """
+        Renders post's HTML view. Some of the post params can be passed over
+        kwargs for the means of caching (if we view the thread, some params
+        are same for every post and don't need to be computed over and over.
+        """
 
-        if 'thread' in kwargs:
-            thread = kwargs['thread']
-        else:
-            thread = self.get_thread()
-
-        if 'can_bump' in kwargs:
-            can_bump = kwargs['can_bump']
-        else:
-            can_bump = thread.can_bump()
+        is_opening = kwargs.get(PARAMETER_IS_OPENING, self.is_opening())
+        thread = kwargs.get(PARAMETER_THREAD, self.get_thread())
+        can_bump = kwargs.get(PARAMETER_BUMPABLE, thread.can_bump())
 
         if is_opening:
             opening_post_id = self.id
         else:
             opening_post_id = thread.get_opening_post_id()
 
         return render_to_string('boards/post.html', {
-            'post': self,
-            'moderator': moderator,
-            'is_opening': is_opening,
-            'thread': thread,
-            'bumpable': can_bump,
-            'need_open_link': need_open_link,
-            'truncated': truncated,
-            'opening_post_id': opening_post_id,
+            PARAMETER_POST: self,
+            PARAMETER_MODERATOR: moderator,
+            PARAMETER_IS_OPENING: is_opening,
+            PARAMETER_THREAD: thread,
+            PARAMETER_BUMPABLE: can_bump,
+            PARAMETER_NEED_OPEN_LINK: need_open_link,
+            PARAMETER_TRUNCATED: truncated,
+            PARAMETER_OP_ID: opening_post_id,
         })
 
     def get_first_image(self) -> PostImage:
         return self.images.earliest('id')
 
     def delete(self, using=None):
         """
         Deletes all post images and the post itself. If the post is opening,
         thread with all posts is deleted.
         """
 
         self.images.all().delete()
 
         if self.is_opening():
             self.get_thread().delete()
         else:
             thread = self.get_thread()
             thread.last_edit_time = timezone.now()
             thread.save()
 
         super(Post, self).delete(using)
 
         logging.getLogger('boards.post.delete').info(
             'Deleted post {}'.format(self))
 
     def get_post_data(self, format_type=DIFF_TYPE_JSON, request=None,
                       include_last_update=False):
         """
         Gets post HTML or JSON data that can be rendered on a page or used by
         API.
         """
 
         if format_type == DIFF_TYPE_HTML:
-            context = RequestContext(request)
-            context['post'] = self
+            params = dict()
+            params['post'] = self
             if PARAMETER_TRUNCATED in request.GET:
-                context[PARAMETER_TRUNCATED] = True
+                params[PARAMETER_TRUNCATED] = True
 
-            # TODO Use dict here
-            return render_to_string('boards/api_post.html',
-                                    context_instance=context)
+            return render_to_string('boards/api_post.html', params)
         elif format_type == DIFF_TYPE_JSON:
             post_json = {
                 'id': self.id,
                 'title': self.title,
                 'text': self._text_rendered,
                 }
             if self.images.exists():
                 post_image = self.get_first_image()
                 post_json['image'] = post_image.image.url
                 post_json['image_preview'] = post_image.image.url_200x150
             if include_last_update:
                 post_json['bump_time'] = datetime_to_epoch(
                     self.thread_new.bump_time)
             return post_json
 
     def send_to_websocket(self, request, recursive=True):
         """
         Sends post HTML data to the thread web socket.
         """
 
         if not settings.WEBSOCKETS_ENABLED:
             return
 
         client = Client()
 
         thread = self.get_thread()
         thread_id = thread.id
         channel_name = WS_CHANNEL_THREAD + str(thread.get_opening_post_id())
         client.publish(channel_name, {
             WS_NOTIFICATION_TYPE: WS_NOTIFICATION_TYPE_NEW_POST,
         })
         client.send()
 
         logger = logging.getLogger('boards.post.websocket')
 
         logger.info('Sent notification from post #{} to channel {}'.format(
             self.id, channel_name))
 
         if recursive:
             for reply_number in re.finditer(REGEX_REPLY, self.get_raw_text()):
                 post_id = reply_number.group(1)
                 ref_post = Post.objects.filter(id=post_id)[0]
 
                 # If post is in this thread, its thread was already notified.
                 # Otherwise, notify its thread separately.
                 if ref_post.thread_new_id != thread_id:
                     ref_post.send_to_websocket(request, recursive=False)
 
     def save(self, force_insert=False, force_update=False, using=None,
              update_fields=None):
         self._text_rendered = bbcode_extended(self.get_raw_text())
 
         super().save(force_insert, force_update, using, update_fields)
 
     def get_text(self) -> str:
         return self._text_rendered
 
     def get_raw_text(self) -> str:
         return self.text

boards/templates/boards/thread.html

@@ -1,96 +1,96
 {% extends "boards/base.html" %}
 
 {% load i18n %}
 {% load cache %}
 {% load static from staticfiles %}
 {% load board %}
 
 {% block head %}
     <title>{{ opening_post.get_title|striptags|truncatewords:10 }}
         - {{ site_name }}</title>
 {% endblock %}
 
 {% block content %}
     {% 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' opening_post.id %}">{% trans 'Normal mode' %}</a>,
         <a href="{% url 'thread_mode' 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">
         {% with can_bump=thread.can_bump %}
         {% for post in thread.get_replies %}
             {% with is_opening=forloop.first %}
-                {% post_view post moderator=moderator is_opening=is_opening thread=thread can_bump=can_bump opening_post_id=opening_post.id %}
+                {% post_view post moderator=moderator is_opening=is_opening thread=thread bumpable=can_bump opening_post_id=opening_post.id %}
             {% endwith %}
         {% endfor %}
         {% endwith %}
     </div>
 
     {% if not thread.archived %}
         <div class="post-form-w" id="form">
             <script src="{% static 'js/panel.js' %}"></script>
             <div class="form-title">{% trans "Reply to thread" %} #{{ opening_post.id }}</div>
             <div class="post-form" id="compact-form">
                 <div class="swappable-form-full">
                     <form enctype="multipart/form-data" method="post"
                             >{% csrf_token %}
                         <div class="compact-form-text"></div>
                         {{ form.as_div }}
                         <div class="form-submit">
                             <input type="submit" value="{% trans "Post" %}"/>
                         </div>
                     </form>
                 </div>
                 <a onclick="swapForm(); return false;" href="#">
                     {% trans 'Switch mode' %}
                 </a>
                 <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>
         <script src="{% static 'js/3party/centrifuge.js' %}"></script>
     {% endif %}
 
     <script src="{% static 'js/form.js' %}"></script>
     <script src="{% static 'js/thread.js' %}"></script>
 
     {% endcache %}
 {% endblock %}
 
 {% block metapanel %}
 
     {% get_current_language as LANGUAGE_CODE %}
 
     <span class="metapanel"
           data-last-update="{{ last_update }}"
           data-ws-token="{{ ws_token }}"
           data-ws-project="{{ ws_project }}"
           data-ws-host="{{ ws_host }}"
           data-ws-port="{{ ws_port }}">
         {% cache 600 thread_meta thread.last_edit_time moderator LANGUAGE_CODE %}
             <span id="autoupdate">[-]</span>
             <span id="reply-count">{{ thread.get_reply_count }}</span>/{{ max_replies }} {% trans 'messages' %},
             <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/views/all_threads.py

@@ -1,143 +1,139
 from django.db import transaction
 from django.shortcuts import render, redirect
 
 from boards import utils, settings
 from boards.abstracts.paginator import get_paginator
 from boards.abstracts.settingsmanager import get_settings_manager
 from boards.forms import ThreadForm, PlainErrorList
 from boards.models import Post, Thread, Ban, Tag
 from boards.views.banned import BannedView
 from boards.views.base import BaseBoardView, CONTEXT_FORM
 from boards.views.posting_mixin import PostMixin
 
 
 FORM_TAGS = 'tags'
 FORM_TEXT = 'text'
 FORM_TITLE = 'title'
 FORM_IMAGE = 'image'
 
 TAG_DELIMITER = ' '
 
 PARAMETER_CURRENT_PAGE = 'current_page'
 PARAMETER_PAGINATOR = 'paginator'
 PARAMETER_THREADS = 'threads'
 
 TEMPLATE = 'boards/posting_general.html'
 DEFAULT_PAGE = 1
 
 
 class AllThreadsView(PostMixin, BaseBoardView):
 
     def __init__(self):
         self.settings_manager = None
         super(AllThreadsView, self).__init__()
 
     def get(self, request, page=DEFAULT_PAGE, form=None):
         context = self.get_context_data(request=request)
 
         if not form:
             form = ThreadForm(error_class=PlainErrorList)
 
         self.settings_manager = get_settings_manager(request)
         paginator = get_paginator(self.get_threads(),
                                   settings.THREADS_PER_PAGE)
         paginator.current_page = int(page)
 
         threads = paginator.page(page).object_list
 
         context[PARAMETER_THREADS] = threads
         context[CONTEXT_FORM] = form
 
         self._get_page_context(paginator, context, page)
 
         # TODO Use dict here
         return render(request, TEMPLATE, context_instance=context)
 
     def post(self, request, page=DEFAULT_PAGE):
         form = ThreadForm(request.POST, request.FILES,
                           error_class=PlainErrorList)
         form.session = request.session
 
         if form.is_valid():
             return self.create_thread(request, form)
         if form.need_to_ban:
             # Ban user because he is suspected to be a bot
             self._ban_current_user(request)
 
         return self.get(request, page, form)
 
     @staticmethod
     def _get_page_context(paginator, context, page):
         """
         Get pagination context variables
         """
 
         context[PARAMETER_PAGINATOR] = paginator
         context[PARAMETER_CURRENT_PAGE] = paginator.page(int(page))
 
     @staticmethod
     def parse_tags_string(tag_strings):
         """
         Parses tag list string and returns tag object list.
         """
 
         tags = []
 
         if tag_strings:
             tag_strings = tag_strings.split(TAG_DELIMITER)
             for tag_name in tag_strings:
                 tag_name = tag_name.strip().lower()
                 if len(tag_name) > 0:
                     tag, created = Tag.objects.get_or_create(name=tag_name)
                     tags.append(tag)
 
         return tags
 
     @transaction.atomic
     def create_thread(self, request, form, html_response=True):
         """
         Creates a new thread with an opening post.
         """
 
         ip = utils.get_client_ip(request)
         is_banned = Ban.objects.filter(ip=ip).exists()
 
         if is_banned:
             if html_response:
                 return redirect(BannedView().as_view())
             else:
                 return
 
         data = form.cleaned_data
 
         title = data[FORM_TITLE]
         text = data[FORM_TEXT]
+        image = data.get(FORM_IMAGE)
 
         text = self._remove_invalid_links(text)
 
-        if FORM_IMAGE in list(data.keys()):
-            image = data[FORM_IMAGE]
-        else:
-            image = None
-
         tag_strings = data[FORM_TAGS]
 
         tags = self.parse_tags_string(tag_strings)
 
         post = Post.objects.create_post(title=title, text=text, image=image,
                                         ip=ip, tags=tags)
 
         # This is required to update the threads to which posts we have replied
         # when creating this one
         post.send_to_websocket(request)
 
         if html_response:
             return redirect(post.get_url())
 
     def get_threads(self):
         """
         Gets list of threads that will be shown on a page.
         """
 
         return Thread.objects.all().order_by('-bump_time')\
             .exclude(tags__in=self.settings_manager.get_hidden_tags())

boards/views/api.py

@@ -1,225 +1,223
 from datetime import datetime
 import json
 import logging
 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 django.core import serializers
 
 from boards.forms import PostForm, PlainErrorList
 from boards.models import Post, Thread, Tag
 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'
 
 logger = logging.getLogger(__name__)
 
 
 @transaction.atomic
 def api_get_threaddiff(request, thread_id, last_update_time):
     """
     Gets posts that were changed or added since time
     """
 
     thread = get_object_or_404(Post, id=thread_id).get_thread()
 
     # Add 1 to ensure we don't load the same post over and over
     last_update_timestamp = float(last_update_time) + 1
 
     filter_time = datetime.fromtimestamp(last_update_timestamp / 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]
+    diff_type = request.GET.get(PARAMETER_DIFF_TYPE, DIFF_TYPE_HTML)
 
     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)
 
     return HttpResponse(content=json.dumps(json_data))
 
 
 def api_add_post(request, opening_post_id):
     """
     Adds a post and return the JSON response for it
     """
 
     opening_post = get_object_or_404(Post, id=opening_post_id)
 
     logger.info('Adding post via api...')
 
     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():
             post = ThreadView().new_post(request, form, opening_post,
                                          html_response=False)
             if not post:
                 status = STATUS_ERROR
             else:
                 logger.info('Added post #%d via api.' % post.id)
         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):
     """
     Gets 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
 
     # TODO Use dict here
     return render(request, 'boards/api_post.html', context_instance=context)
 
 
 # TODO Test this
 def api_get_threads(request, count):
     """
     Gets 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.get_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):
     """
     Gets 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):
     """
     Gets the JSON array of thread posts
     """
 
     opening_post = get_object_or_404(Post, id=opening_post_id)
     thread = opening_post.get_thread()
     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['posts'] = json_post_list
 
     return HttpResponse(content=json.dumps(json_data))
 
 
 def api_get_post(request, post_id):
     """
     Gets 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)
 
 
 # TODO Remove this method and use post method directly
 def get_post_data(post_id, format_type=DIFF_TYPE_JSON, request=None,
                   include_last_update=False):
     post = get_object_or_404(Post, id=post_id)
     return post.get_post_data(format_type=format_type, request=request,
                               include_last_update=include_last_update)

boards/views/search.py

@@ -1,41 +1,43
 from django.shortcuts import render
-from django.template import RequestContext
 from django.views.generic import View
 from haystack.query import SearchQuerySet
+
 from boards.abstracts.paginator import get_paginator
 from boards.forms import SearchForm, PlainErrorList
 
+
+MIN_QUERY_LENGTH = 3
+RESULTS_PER_PAGE = 10
+
 FORM_QUERY = 'query'
 
 CONTEXT_QUERY = 'query'
 CONTEXT_FORM = 'form'
 CONTEXT_PAGE = 'page'
 
 REQUEST_PAGE = 'page'
 
 __author__ = 'neko259'
 
 TEMPLATE = 'search/search.html'
 
 
 class BoardSearchView(View):
     def get(self, request):
-        context = RequestContext(request)
+        params = dict()
+
         form = SearchForm(request.GET, error_class=PlainErrorList)
-        context[CONTEXT_FORM] = form
+        params[CONTEXT_FORM] = form
 
         if form.is_valid():
             query = form.cleaned_data[FORM_QUERY]
-            if len(query) >= 3:
+            if len(query) >= MIN_QUERY_LENGTH:
                 results = SearchQuerySet().auto_query(query).order_by('-id')
-                paginator = get_paginator(results, 10)
+                paginator = get_paginator(results, RESULTS_PER_PAGE)
 
-                if REQUEST_PAGE in request.GET:
-                    page = int(request.GET[REQUEST_PAGE])
-                else:
-                    page = 1
-                context[CONTEXT_PAGE] = paginator.page(page)
-                context[CONTEXT_QUERY] = query
+                page = int(request.GET.get(REQUEST_PAGE, '1'))
 
-        # TODO Use dict here
-        return render(request, TEMPLATE, context_instance=context)
+                params[CONTEXT_PAGE] = paginator.page(page)
+                params[CONTEXT_QUERY] = query
+
+        return render(request, TEMPLATE, params)