Merged with default branch

boards/abstracts/settingsmanager.py

@@ -1,143 +1,146 b''
 from django.shortcuts import get_object_or_404
 from boards.models import Tag
 
 __author__ = 'neko259'
 
 SESSION_SETTING = 'setting'
 
 PERMISSION_MODERATE = 'moderator'
 
 SETTING_THEME = 'theme'
 SETTING_FAVORITE_TAGS = 'favorite_tags'
 SETTING_HIDDEN_TAGS = 'hidden_tags'
 SETTING_PERMISSIONS = 'permissions'
 
 DEFAULT_THEME = 'md'
 
 
 def get_settings_manager(request):
     """
     Get settings manager based on the request object. Currently only
     session-based manager is supported. In the future, cookie-based or
     database-based managers could be implemented.
     """
     return SessionSettingsManager(request.session)
 
 
 class SettingsManager:
     """
     Base settings manager class. get_setting and set_setting methods should
     be overriden.
     """
     def __init__(self):
         pass
 
     def get_theme(self):
         theme = self.get_setting(SETTING_THEME)
         if not theme:
             theme = DEFAULT_THEME
             self.set_setting(SETTING_THEME, theme)
 
         return theme
 
     def set_theme(self, theme):
         self.set_setting(SETTING_THEME, theme)
 
     def has_permission(self, permission):
         permissions = self.get_setting(SETTING_PERMISSIONS)
         if permissions:
             return permission in permissions
         else:
             return False
 
     def get_setting(self, setting):
         pass
 
     def set_setting(self, setting, value):
         pass
 
     def add_permission(self, permission):
         permissions = self.get_setting(SETTING_PERMISSIONS)
         if not permissions:
             permissions = [permission]
         else:
             permissions.append(permission)
         self.set_setting(SETTING_PERMISSIONS, permissions)
 
     def del_permission(self, permission):
         permissions = self.get_setting(SETTING_PERMISSIONS)
         if not permissions:
             permissions = []
         else:
             permissions.remove(permission)
         self.set_setting(SETTING_PERMISSIONS, permissions)
 
     def get_fav_tags(self):
         tag_names = self.get_setting(SETTING_FAVORITE_TAGS)
         tags = []
         if tag_names:
             for tag_name in tag_names:
                 tag = get_object_or_404(Tag, name=tag_name)
                 tags.append(tag)
-
         return tags
 
     def add_fav_tag(self, tag):
         tags = self.get_setting(SETTING_FAVORITE_TAGS)
         if not tags:
             tags = [tag.name]
         else:
             if not tag.name in tags:
                 tags.append(tag.name)
+
+        tags.sort()
         self.set_setting(SETTING_FAVORITE_TAGS, tags)
 
     def del_fav_tag(self, tag):
         tags = self.get_setting(SETTING_FAVORITE_TAGS)
         if tag.name in tags:
             tags.remove(tag.name)
             self.set_setting(SETTING_FAVORITE_TAGS, tags)
 
     def get_hidden_tags(self):
         tag_names = self.get_setting(SETTING_HIDDEN_TAGS)
         tags = []
         if tag_names:
             for tag_name in tag_names:
                 tag = get_object_or_404(Tag, name=tag_name)
                 tags.append(tag)
 
         return tags
 
     def add_hidden_tag(self, tag):
         tags = self.get_setting(SETTING_HIDDEN_TAGS)
         if not tags:
             tags = [tag.name]
         else:
             if not tag.name in tags:
                 tags.append(tag.name)
+
+        tags.sort()
         self.set_setting(SETTING_HIDDEN_TAGS, tags)
 
     def del_hidden_tag(self, tag):
         tags = self.get_setting(SETTING_HIDDEN_TAGS)
         if tag.name in tags:
             tags.remove(tag.name)
             self.set_setting(SETTING_HIDDEN_TAGS, tags)
 
 
 class SessionSettingsManager(SettingsManager):
     """
     Session-based settings manager. All settings are saved to the user's
     session.
     """
     def __init__(self, session):
         SettingsManager.__init__(self)
         self.session = session
 
     def get_setting(self, setting):
         if setting in self.session:
             return self.session[setting]
         else:
             return None
 
     def set_setting(self, setting, value):
         self.session[setting] = value
 

boards/admin.py

@@ -1,38 +1,43 b''
 from django.contrib import admin
 from boards.models import Post, Tag, Ban, Thread, KeyPair
 
 
 class PostAdmin(admin.ModelAdmin):
 
     list_display = ('id', 'title', 'text')
     list_filter = ('pub_time', 'thread_new')
     search_fields = ('id', 'title', 'text')
 
 
 class TagAdmin(admin.ModelAdmin):
 
     list_display = ('name',)
 
 class ThreadAdmin(admin.ModelAdmin):
 
     def title(self, obj):
         return obj.get_opening_post().title
 
     def reply_count(self, obj):
         return obj.get_reply_count()
 
     list_display = ('id', 'title', 'reply_count', 'archived')
     list_filter = ('bump_time', 'archived')
     search_fields = ('id', 'title')
 
 
 class KeyPairAdmin(admin.ModelAdmin):
     list_display = ('public_key', 'primary')
     list_filter = ('primary',)
     search_fields = ('public_key',)
 
+class BanAdmin(admin.ModelAdmin):
+    list_display = ('ip', 'can_read')
+    list_filter = ('can_read',)
+    search_fields = ('ip',)
+
 admin.site.register(Post, PostAdmin)
 admin.site.register(Tag, TagAdmin)
-admin.site.register(Ban)
+admin.site.register(Ban, BanAdmin)
 admin.site.register(Thread, ThreadAdmin)
 admin.site.register(KeyPair, KeyPairAdmin)

boards/mdx_neboard.py

@@ -1,178 +1,178 b''
 # coding=utf-8
 
 import re
 import bbcode
 
 import boards
 
 
 __author__ = 'neko259'
 
 
-REFLINK_PATTERN = re.compile(r'\d+')
+REFLINK_PATTERN = re.compile(r'^\d+$')
 MULTI_NEWLINES_PATTERN = re.compile(r'(\r?\n){2,}')
 ONE_NEWLINE = '\n'
 
 
 class TextFormatter():
     """
     An interface for formatter that can be used in the text format panel
     """
 
     def __init__(self):
         pass
 
     name = ''
 
     # Left and right tags for the button preview
     preview_left = ''
     preview_right = ''
 
     # Left and right characters for the textarea input
     format_left = ''
     format_right = ''
 
 
 class AutolinkPattern():
     def handleMatch(self, m):
         link_element = etree.Element('a')
         href = m.group(2)
         link_element.set('href', href)
         link_element.text = href
 
         return link_element
 
 
 class QuotePattern(TextFormatter):
     name = 'q'
     preview_left = '<span class="multiquote">'
     preview_right = '</span>'
 
     format_left = '[quote]'
     format_right = '[/quote]'
 
 
 class SpoilerPattern(TextFormatter):
     name = 'spoiler'
     preview_left = '<span class="spoiler">'
     preview_right = '</span>'
 
     format_left = '[spoiler]'
     format_right = '[/spoiler]'
 
     def handleMatch(self, m):
         quote_element = etree.Element('span')
         quote_element.set('class', 'spoiler')
         quote_element.text = m.group(2)
 
         return quote_element
 
 
 class CommentPattern(TextFormatter):
     name = ''
     preview_left = '<span class="comment">// '
     preview_right = '</span>'
 
     format_left = '[comment]'
     format_right = '[/comment]'
 
 
 # TODO Use <s> tag here
 class StrikeThroughPattern(TextFormatter):
     name = 's'
     preview_left = '<span class="strikethrough">'
     preview_right = '</span>'
 
     format_left = '[s]'
     format_right = '[/s]'
 
 
 class ItalicPattern(TextFormatter):
     name = 'i'
     preview_left = '<i>'
     preview_right = '</i>'
 
     format_left = '[i]'
     format_right = '[/i]'
 
 
 class BoldPattern(TextFormatter):
     name = 'b'
     preview_left = '<b>'
     preview_right = '</b>'
 
     format_left = '[b]'
     format_right = '[/b]'
 
 
 class CodePattern(TextFormatter):
     name = 'code'
     preview_left = '<code>'
     preview_right = '</code>'
 
     format_left = '[code]'
     format_right = '[/code]'
 
 
 def render_reflink(tag_name, value, options, parent, context):
     if not REFLINK_PATTERN.match(value):
         return u'>>%s' % value
 
     post_id = int(value)
 
     posts = boards.models.Post.objects.filter(id=post_id)
     if posts.exists():
         post = posts[0]
 
-        return u'<a href=%s>&gt;&gt;%s</a>' % (post.get_url(), post_id)
+        return u'<a href="%s">&gt;&gt;%s</a>' % (post.get_url(), post_id)
     else:
         return u'>>%s' % value
 
 
 def render_quote(tag_name, value, options, parent, context):
     source = u''
     if 'source' in options:
         source = options['source']
 
     result = u''
     if source:
         result = u'<div class="multiquote"><div class="quote-header">%s</div><div class="quote-text">%s</div></div>' % (source, value)
     else:
         result = u'<div class="multiquote"><div class="quote-text">%s</div></div>' % value
 
     return result
 
 
 def preparse_text(text):
     """
     Performs manual parsing before the bbcode parser is used.
     """
 
     return MULTI_NEWLINES_PATTERN.sub(ONE_NEWLINE, text)
 
 
 def bbcode_extended(markup):
     parser = bbcode.Parser()
     parser.add_formatter('post', render_reflink, strip=True)
     parser.add_formatter('quote', render_quote, strip=True)
     parser.add_simple_formatter('comment',
             u'<span class="comment">//%(value)s</span>')
     parser.add_simple_formatter('spoiler',
             u'<span class="spoiler">%(value)s</span>')
     parser.add_simple_formatter('s',
             u'<span class="strikethrough">%(value)s</span>')
     parser.add_simple_formatter('code',
             u'<pre><code>%(value)s</pre></code>')
 
     text = preparse_text(markup)
     return parser.format(text)
 
 formatters = [
     QuotePattern,
     SpoilerPattern,
     ItalicPattern,
     BoldPattern,
     CommentPattern,
     StrikeThroughPattern,
     CodePattern,
 ]

boards/static/css/md/base_page.css

@@ -1,460 +1,467 b''
 html {
     background: #555;
     color: #ffffff;
 }
 
 body {
     margin: 0;
 }
 
 #admin_panel {
     background: #FF0000;
     color: #00FF00
 }
 
 .input_field_error {
     color: #FF0000;
 }
 
 .title {
     font-weight: bold;
     color: #ffcc00;
 }
 
 .link, a {
     color: #afdcec;
 }
 
 .block {
     display: inline-block;
     vertical-align: top;
 }
 
 .tag {
     color: #FFD37D;
 }
 
 .post_id {
     color: #fff380;
 }
 
 .post, .dead_post, .archive_post, #posts-table {
     background: #333;
     padding: 10px;
     clear: left;
     word-wrap: break-word;
     border-top: 1px solid #777;
     border-bottom: 1px solid #777;
 }
 
 .post + .post {
     border-top: none;
 }
 
 .dead_post + .dead_post {
     border-top: none;
 }
 
 .archive_post + .archive_post {
     border-top: none;
 }
 
 .metadata {
     padding-top: 5px;
     margin-top: 10px;
     border-top: solid 1px #666;
     color: #ddd;
 }
 
 .navigation_panel, .tag_info {
     background: #444;
     margin-bottom: 5px;
     margin-top: 5px;
     padding: 10px;
     border-bottom: solid 1px #888;
     border-top: solid 1px #888;
     color: #eee;
 }
 
 .navigation_panel .link {
     border-right: 1px solid #fff;
     font-weight: bold;
     margin-right: 1ex;
     padding-right: 1ex;
 }
 .navigation_panel .link:last-child {
     border-left: 1px solid #fff;
     border-right: none;
     float: right;
     margin-left: 1ex;
     margin-right: 0;
     padding-left: 1ex;
     padding-right: 0;
 }
 
 .navigation_panel::after, .post::after {
     clear: both;
     content: ".";
     display: block;
     height: 0;
     line-height: 0;
     visibility: hidden;
 }
 
 p {
     margin-top: .5em;
     margin-bottom: .5em;
 }
 
 br {
     margin-bottom: .5em;
 }
 
 .post-form-w {
     background: #333344;
     border-top: solid 1px #888;
     border-bottom: solid 1px #888;
     color: #fff;
     padding: 10px;
     margin-bottom: 5px;
     margin-top: 5px;
 }
 
 .form-row {
     width: 100%;
 }
 
 .form-label {
     padding: .25em 1ex .25em 0;
     vertical-align: top;
 }
 
 .form-input {
     padding: .25em 0;
 }
 
 .form-errors {
     font-weight: bolder;
     vertical-align: middle;
 }
 
 .post-form input:not([name="image"]), .post-form textarea {
     background: #333;
     color: #fff;
     border: solid 1px;
     padding: 0;
     font: medium sans-serif;
     width: 100%;
 }
 
 .form-submit {
     display: table;
     margin-bottom: 1ex;
     margin-top: 1ex;
 }
 
 .form-title {
     font-weight: bold;
     font-size: 2ex;
     margin-bottom: 0.5ex;
 }
 
 .post-form input[type="submit"], input[type="submit"] {
     background: #222;
     border: solid 2px #fff;
     color: #fff;
     padding: 0.5ex;
 }
 
 input[type="submit"]:hover {
     background: #060;
 }
 
 blockquote {
     border-left: solid 2px;
     padding-left: 5px;
     color: #B1FB17;
     margin: 0;
 }
 
 .post > .image {
     float: left;
     margin: 0 1ex .5ex 0;
     min-width: 1px;
     text-align: center;
     display: table-row;
 }
 
 .post > .metadata {
     clear: left;
 }
 
 .get {
     font-weight: bold;
     color: #d55;
 }
 
 * {
     text-decoration: none;
 }
 
 .dead_post {
     background-color: #442222;
 }
 
 .archive_post {
     background-color: #000;
 }
 
 .mark_btn {
     border: 1px solid;
     min-width: 2ex;
     padding: 2px 2ex;
 }
 
 .mark_btn:hover {
     background: #555;
 }
 
 .quote {
     color: #92cf38;
     font-style: italic;
 }
 
 .multiquote {
     padding: 3px;
     display: inline-block;
     background: #222;
     border-style: solid;
     border-width: 1px 1px 1px 4px;
     font-size: 0.9em;
 }
 
 .spoiler {
     background: white;
     color: white;
 }
 
 .spoiler:hover {
     color: black;
 }
 
 .comment {
     color: #eb2;
 }
 
 a:hover {
     text-decoration: underline;
 }
 
 .last-replies {
     margin-left: 3ex;
     margin-right: 3ex;
+    border-left: solid 1px #777;
+    border-right: solid 1px #777;
 }
 
 .thread {
     margin-bottom: 3ex;
     margin-top: 1ex;
 }
 
 .post:target {
     border: solid 2px white;
 }
 
 pre{
     white-space:pre-wrap
 }
 
 li {
     list-style-position: inside;
 }
 
 .fancybox-skin {
     position: relative;
     background-color: #fff;
     color: #ddd;
     text-shadow: none;
 }
 
 .fancybox-image {
     border: 1px solid black;
 }
 
 .image-mode-tab {
     background: #444;
     color: #eee;
     margin-top: 5px;
     padding: 5px;
     border-top: 1px solid #888;
     border-bottom: 1px solid #888;
 }
 
 .image-mode-tab > label {
     margin: 0 1ex;
 }
 
 .image-mode-tab > label > input {
     margin-right: .5ex;
 }
 
 #posts-table {
     margin-top: 5px;
     margin-bottom: 5px;
 }
 
 .tag_info > h2 {
     margin: 0;
 }
 
 .post-info {
     color: #ddd;
     margin-bottom: 1ex;
 }
 
 .moderator_info {
     color: #e99d41;
     float: right;
     font-weight: bold;
 }
 
 .refmap {
     font-size: 0.9em;
     color: #ccc;
     margin-top: 1em;
 }
 
 .fav {
     color: yellow;
 }
 
 .not_fav {
     color: #ccc;
 }
 
 .role {
     text-decoration: underline;
 }
 
 .form-email {
     display: none;
 }
 
 .footer {
     margin: 5px;
 }
 
 .bar-value {
     background: rgba(50, 55, 164, 0.45);
     font-size: 0.9em;
     height: 1.5em;
 }
 
 .bar-bg {
     position: relative;
     border-top: solid 1px #888;
     border-bottom: solid 1px #888;
     margin-top: 5px;
     overflow: hidden;
 }
 
 .bar-text {
     padding: 2px;
     position: absolute;
     left: 0;
     top: 0;
 }
 
 .page_link {
     background: #444;
     border-top: solid 1px #888;
     border-bottom: solid 1px #888;
     padding: 5px;
     color: #eee;
     font-size: 2ex;
 }
 
 .skipped_replies {
-    margin: 5px;
+    padding: 5px;
+    margin-left: 3ex;
+    margin-right: 3ex;
+    border-left: solid 1px #888;
+    border-right: solid 1px #888;
+    background: #000;
 }
 
 .current_page {
     border: solid 1px #afdcec;
     padding: 2px;
 }
 
 .current_mode {
     font-weight: bold;
 }
 
 .gallery_image {
     border: solid 1px;
     padding: 0.5ex;
     margin: 0.5ex;
     text-align: center;
 }
 
 code {
     border: dashed 1px #ccc;
     background: #111;
     padding: 2px;
     font-size: 1.2em;
     display: inline-block;
 }
 
 pre {
     overflow: auto;
 }
 
 .img-full {
     background: #222;
     border: solid 1px white;
 }
 
 .tag_item {
     display: inline-block;
     border: 1px dashed #666;
     margin: 0.2ex;
     padding: 0.1ex;
 }
 
 #id_models li {
     list-style: none;
 }
 
 #id_q {
     margin-left: 1ex;
 }
 
 ul {
     padding-left: 0px;
 }
 
 .quote-header {
     border-bottom: 2px solid #ddd;
     margin-bottom: 1ex;
     padding-bottom: .5ex;
     color: #ddd;
     font-size: 1.2em;
 }
 
 /* Post */
 .post > .message, .post > .image {
         padding-left: 1em;
 }
 
 /* Reflink preview */
 .post_preview {
     border-left: 1px solid #777;
     border-right: 1px solid #777;
 }
 
 /* Code highlighter */
 .hljs {
     color: #fff;
     background: #000;
     display: inline-block;
 }
 
 .hljs, .hljs-subst, .hljs-tag .hljs-title, .lisp .hljs-title, .clojure .hljs-built_in, .nginx .hljs-title {
     color: #fff;
 }

boards/templates/boards/thread_gallery.html

@@ -1,68 +1,66 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 }}
         - {{ 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">
         {% with post.get_first_image as image %}
             <div>
                 <a
                         class="thumb"
                         href="{{ image.image.url }}"><img
                         src="{{ image.image.url_200x150 }}"
                         alt="{{ post.id }}"
                         width="{{ image.pre_width }}"
                         height="{{ image.pre_height }}"
                         data-width="{{ image.width }}"
                         data-height="{{ image.height }}"/>
                 </a>
             </div>
             <div class="gallery_image_metadata">
                 {{ image.width }}x{{ image.height }}
                 {% image_actions image.image.url request.get_host %}
             </div>
         {% endwith %}
         </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>/{{ max_replies }}
             {% trans 'messages' %},
             <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/tests.py

@@ -1,288 +1,336 b''
 # coding=utf-8
 import time
 import logging
+import simplejson
 from django.core.paginator import Paginator
 
 from django.test import TestCase
 from django.test.client import Client
 from django.core.urlresolvers import reverse, NoReverseMatch
 from boards.abstracts.settingsmanager import get_settings_manager
 
 from boards.models import Post, Tag, Thread, KeyPair
 from boards import urls
 from boards import settings
+from boards.views.api import api_get_threaddiff
+from boards.utils import datetime_to_epoch
 import neboard
 
 TEST_TAG = 'test_tag'
 
 PAGE_404 = 'boards/404.html'
 
 TEST_TEXT = 'test text'
 
 NEW_THREAD_PAGE = '/'
 THREAD_PAGE_ONE = '/thread/1/'
 THREAD_PAGE = '/thread/'
 TAG_PAGE = '/tag/'
 HTTP_CODE_REDIRECT = 302
 HTTP_CODE_OK = 200
 HTTP_CODE_NOT_FOUND = 404
 
 logger = logging.getLogger(__name__)
 
 
 class PostTests(TestCase):
 
     def _create_post(self):
         tag = Tag.objects.create(name=TEST_TAG)
         return Post.objects.create_post(title='title', text='text',
                                         tags=[tag])
 
     def test_post_add(self):
         """Test adding post"""
 
         post = self._create_post()
 
         self.assertIsNotNone(post, 'No post was created.')
         self.assertEqual(TEST_TAG, post.get_thread().tags.all()[0].name,
                          'No tags were added to the post.')
 
     def test_delete_post(self):
         """Test post deletion"""
 
         post = self._create_post()
         post_id = post.id
 
         Post.objects.delete_post(post)
 
         self.assertFalse(Post.objects.filter(id=post_id).exists())
 
     def test_delete_thread(self):
         """Test thread deletion"""
 
         opening_post = self._create_post()
         thread = opening_post.get_thread()
         reply = Post.objects.create_post("", "", thread=thread)
 
         thread.delete()
 
         self.assertFalse(Post.objects.filter(id=reply.id).exists())
 
     def test_post_to_thread(self):
         """Test adding post to a thread"""
 
         op = self._create_post()
         post = Post.objects.create_post("", "", thread=op.get_thread())
 
         self.assertIsNotNone(post, 'Reply to thread wasn\'t created')
         self.assertEqual(op.get_thread().last_edit_time, post.pub_time,
                          'Post\'s create time doesn\'t match thread last edit'
                          ' time')
 
     def test_delete_posts_by_ip(self):
         """Test deleting posts with the given ip"""
 
         post = self._create_post()
         post_id = post.id
 
         Post.objects.delete_posts_by_ip('0.0.0.0')
 
         self.assertFalse(Post.objects.filter(id=post_id).exists())
 
     def test_get_thread(self):
         """Test getting all posts of a thread"""
 
         opening_post = self._create_post()
 
         for i in range(0, 2):
             Post.objects.create_post('title', 'text',
                                      thread=opening_post.get_thread())
 
         thread = opening_post.get_thread()
 
         self.assertEqual(3, thread.replies.count())
 
     def test_create_post_with_tag(self):
         """Test adding tag to post"""
 
         tag = Tag.objects.create(name='test_tag')
         post = Post.objects.create_post(title='title', text='text', tags=[tag])
 
         thread = post.get_thread()
         self.assertIsNotNone(post, 'Post not created')
         self.assertTrue(tag in thread.tags.all(), 'Tag not added to thread')
         self.assertTrue(thread in tag.threads.all(), 'Thread not added to tag')
 
     def test_thread_max_count(self):
         """Test deletion of old posts when the max thread count is reached"""
 
         for i in range(settings.MAX_THREAD_COUNT + 1):
             self._create_post()
 
         self.assertEqual(settings.MAX_THREAD_COUNT,
                          len(Thread.objects.filter(archived=False)))
 
     def test_pages(self):
         """Test that the thread list is properly split into pages"""
 
         for i in range(settings.MAX_THREAD_COUNT):
             self._create_post()
 
         all_threads = Thread.objects.filter(archived=False)
 
         paginator = Paginator(Thread.objects.filter(archived=False),
                               settings.THREADS_PER_PAGE)
         posts_in_second_page = paginator.page(2).object_list
         first_post = posts_in_second_page[0]
 
         self.assertEqual(all_threads[settings.THREADS_PER_PAGE].id,
                          first_post.id)
 
 
 class PagesTest(TestCase):
 
     def test_404(self):
         """Test receiving error 404 when opening a non-existent page"""
 
         tag_name = u'test_tag'
         tag = Tag.objects.create(name=tag_name)
         client = Client()
 
         Post.objects.create_post('title', TEST_TEXT, tags=[tag])
 
         existing_post_id = Post.objects.all()[0].id
         response_existing = client.get(THREAD_PAGE + str(existing_post_id) +
                                        '/')
         self.assertEqual(HTTP_CODE_OK, response_existing.status_code,
                          u'Cannot open existing thread')
 
         response_not_existing = client.get(THREAD_PAGE + str(
             existing_post_id + 1) + '/')
         self.assertEqual(PAGE_404, response_not_existing.templates[0].name,
                          u'Not existing thread is opened')
 
         response_existing = client.get(TAG_PAGE + tag_name + '/')
         self.assertEqual(HTTP_CODE_OK,
                          response_existing.status_code,
                          u'Cannot open existing tag')
 
         response_not_existing = client.get(TAG_PAGE + u'not_tag' + '/')
         self.assertEqual(PAGE_404,
                          response_not_existing.templates[0].name,
                          u'Not existing tag is opened')
 
         reply_id = Post.objects.create_post('', TEST_TEXT,
                                             thread=Post.objects.all()[0]
                                             .get_thread())
         response_not_existing = client.get(THREAD_PAGE + str(
             reply_id) + '/')
         self.assertEqual(PAGE_404,
                          response_not_existing.templates[0].name,
                          u'Reply is opened as a thread')
 
 
 class FormTest(TestCase):
     def test_post_validation(self):
         client = Client()
 
         valid_tags = u'tag1 tag_2 тег_3'
         invalid_tags = u'$%_356 ---'
 
         response = client.post(NEW_THREAD_PAGE, {'title': 'test title',
                                                  'text': TEST_TEXT,
                                                  'tags': valid_tags})
         self.assertEqual(response.status_code, HTTP_CODE_REDIRECT,
                          msg='Posting new message failed: got code ' +
                              str(response.status_code))
 
         self.assertEqual(1, Post.objects.count(),
                          msg='No posts were created')
 
         client.post(NEW_THREAD_PAGE, {'text': TEST_TEXT,
                                       'tags': invalid_tags})
         self.assertEqual(1, Post.objects.count(), msg='The validation passed '
                                                       'where it should fail')
 
         # Change posting delay so we don't have to wait for 30 seconds or more
         old_posting_delay = neboard.settings.POSTING_DELAY
         # Wait fot the posting delay or we won't be able to post
         settings.POSTING_DELAY = 1
         time.sleep(neboard.settings.POSTING_DELAY + 1)
         response = client.post(THREAD_PAGE_ONE, {'text': TEST_TEXT,
                                                  'tags': valid_tags})
         self.assertEqual(HTTP_CODE_REDIRECT, response.status_code,
                          msg=u'Posting new message failed: got code ' +
                              str(response.status_code))
         # Restore posting delay
         settings.POSTING_DELAY = old_posting_delay
 
         self.assertEqual(2, Post.objects.count(),
                          msg=u'No posts were created')
 
 
 class ViewTest(TestCase):
 
     def test_all_views(self):
         """
         Try opening all views defined in ulrs.py that don't need additional
         parameters
         """
 
         client = Client()
         for url in urls.urlpatterns:
             try:
                 view_name = url.name
                 logger.debug('Testing view %s' % view_name)
 
                 try:
                     response = client.get(reverse(view_name))
 
                     self.assertEqual(HTTP_CODE_OK, response.status_code,
                                      '%s view not opened' % view_name)
                 except NoReverseMatch:
                     # This view just needs additional arguments
                     pass
                 except Exception as e:
                     self.fail('Got exception %s at %s view' % (e, view_name))
             except AttributeError:
                 # This is normal, some views do not have names
                 pass
 
 
 class AbstractTest(TestCase):
     def test_settings_manager(self):
         request = MockRequest()
         settings_manager = get_settings_manager(request)
 
         settings_manager.set_setting('test_setting', 'test_value')
         self.assertEqual('test_value', settings_manager.get_setting(
             'test_setting'), u'Setting update failed.')
 
 
 class MockRequest:
     def __init__(self):
         self.session = dict()
+        self.GET = dict()
+        self.POST = dict()
 
 
 class KeyTest(TestCase):
     def test_create_key(self):
         key = KeyPair.objects.generate_key('ecdsa')
 
         self.assertIsNotNone(key, 'The key was not created.')
 
     def test_validation(self):
         key = KeyPair.objects.generate_key(key_type='ecdsa')
         message = 'msg'
         signature = key.sign(message)
         valid = KeyPair.objects.verify(key.public_key, message, signature,
                 key_type='ecdsa')
 
         self.assertTrue(valid, 'Message verification failed.')
 
     def test_primary_constraint(self):
         KeyPair.objects.generate_key(key_type='ecdsa', primary=True)
 
         try:
             KeyPair.objects.generate_key(key_type='ecdsa', primary=True)
             self.fail('Exception should be thrown indicating there can be only one primary key.')
         except Exception:
             pass
+        
+        
+class ApiTest(TestCase):
+    def test_thread_diff(self):
+        tag = Tag.objects.create(name=TEST_TAG)
+        opening_post = Post.objects.create_post(title='title', text='text',
+                                                tags=[tag])
+
+        last_edit_time = datetime_to_epoch(opening_post.last_edit_time)
+
+        # Check the exact timestamp post was added
+        empty_response = api_get_threaddiff(MockRequest(),
+                                            str(opening_post.thread_new.id),
+                                            str(last_edit_time))
+        diff = simplejson.loads(empty_response.content)
+        self.assertEqual(0, len(diff['added']),
+                         'There must be no added posts in the diff.')
+        self.assertEqual(0, len(diff['updated']),
+                         'There must be no updated posts in the diff.')
+
+        reply = Post.objects.create_post(title='',
+                                         text='[post]%d[/post]\ntext' % opening_post.id,
+                                         thread=opening_post.thread_new)
+
+        # Check the timestamp before post was added
+        response = api_get_threaddiff(MockRequest(),
+                                      str(opening_post.thread_new.id),
+                                      str(last_edit_time))
+        diff = simplejson.loads(response.content)
+        self.assertEqual(1, len(diff['added']),
+                         'There must be 1 added posts in the diff.')
+        self.assertEqual(1, len(diff['updated']),
+                         'There must be 1 updated posts in the diff.')
+
+        empty_response = api_get_threaddiff(MockRequest(),
+                                            str(opening_post.thread_new.id),
+                                            str(datetime_to_epoch(reply.last_edit_time)))
+        diff = simplejson.loads(empty_response.content)
+        self.assertEqual(0, len(diff['added']),
+                         'There must be no added posts in the diff.')
+        self.assertEqual(0, len(diff['updated']),
+                         'There must be no updated posts in the diff.')
+

boards/views/api.py

@@ -1,245 +1,248 b''
 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 django.template.loader import render_to_string
 
 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()
 
-    filter_time = datetime.fromtimestamp(float(last_update_time) / 1000000,
+    # 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]
 
     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.
     """
 
     logger.info('Getting post #%s' % post_id)
 
     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/api_post.html', 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.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 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:
         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_to_string('boards/api_post.html', context)
     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.images.exists():
             post_image = post.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(
                 post.thread_new.bump_time)
         return post_json