Merge tip

boards/abstracts/sync_filters.py

@@ -0,0 +1,31 b''
+import xml.etree.ElementTree as et
+
+from boards.models import Post
+
+TAG_THREAD = 'thread'
+
+
+class PostFilter:
+    def __init__(self, content=None):
+        self.content = content
+
+    def filter(self, posts):
+        return posts
+
+    def add_filter(self, model_tag, value):
+        return model_tag
+
+
+class ThreadFilter(PostFilter):
+    def filter(self, posts):
+        op_id = self.content.text
+
+        op = Post.objects.filter(opening=True, id=op_id).first()
+        if op:
+            return posts.filter(thread=op.get_thread())
+        else:
+            return posts.none()
+
+    def add_filter(self, model_tag, value):
+        thread_tag = et.SubElement(model_tag, TAG_THREAD)
+        thread_tag.text = str(value)

boards/migrations/0056_auto_20170123_1620.py

@@ -0,0 +1,24 b''
+# -*- coding: utf-8 -*-
+# Generated by Django 1.10.5 on 2017-01-23 14:20
+from __future__ import unicode_literals
+
+from django.db import migrations, models
+
+
+class Migration(migrations.Migration):
+
+    dependencies = [
+        ('boards', '0055_auto_20161229_1132'),
+    ]
+
+    operations = [
+        migrations.AlterModelOptions(
+            name='attachment',
+            options={'ordering': ('id',)},
+        ),
+        migrations.AlterField(
+            model_name='post',
+            name='uid',
+            field=models.TextField(),
+        ),
+    ]

boards/config/default_settings.ini

@@ -1,48 +1,49 b''
 [Version]
 Version = 4.1.0 2017
 SiteName = Neboard DEV
 
 [Cache]
 # Timeout for caching, if cache is used
 CacheTimeout = 600
 
 [Forms]
 # Max post length in characters
 MaxTextLength = 30000
 MaxFileSize = 8000000
 LimitFirstPosting = true
 LimitPostingSpeed = false
 PowDifficulty = 0
 # Delay in seconds
 PostingDelay = 30
 Autoban = false
 DefaultTag = test
 MaxFileCount = 1
+AdditionalSpoilerSpaces = false
 
 [Messages]
 # Thread bumplimit
 MaxPostsPerThread = 10
 ThreadArchiveDays = 300
 AnonymousMode = false
 
 [View]
 DefaultTheme = md
 DefaultImageViewer = simple
 LastRepliesCount = 3
 ThreadsPerPage = 3
 PostsPerPage = 10
 ImagesPerPageGallery = 20
 MaxFavoriteThreads = 20
 MaxLandingThreads = 20
 Themes=md:Mystic Dark,md_centered:Mystic Dark (centered),sw:Snow White,pg:Photon Grey,ad:Amanita Dark,iw:Inocibe White
 ImageViewers=simple:Simple,popup:Popup
 
 [Storage]
 # Enable archiving threads instead of deletion when the thread limit is reached
 ArchiveThreads = true
 
 [RSS]
 MaxItems = 20
 
 [External]
 ImageSearchHost=

boards/management/commands/sync_with_server.py

@@ -1,96 +1,99 b''
 import re
 import logging
 import xml.etree.ElementTree as ET
 
 import httplib2
 from django.core.management import BaseCommand
 
 from boards.models import GlobalId
 from boards.models.post.sync import SyncManager, TAG_ID, TAG_VERSION
 
 __author__ = 'neko259'
 
 
 REGEX_GLOBAL_ID = re.compile(r'(\w+)::([\w\+/]+)::(\d+)')
 
 
 class Command(BaseCommand):
     help = 'Send a sync or get request to the server.'
 
     def add_arguments(self, parser):
         parser.add_argument('url', type=str, help='Server root url')
         parser.add_argument('--global-id', type=str, default='',
                             help='Post global ID')
         parser.add_argument('--split-query', type=int, default=1,
                             help='Split GET query into separate by the given'
                                  ' number of posts in one')
+        parser.add_argument('--thread', type=int,
+                            help='Get posts of one specific thread')
 
     def handle(self, *args, **options):
         logger = logging.getLogger('boards.sync')
 
         url = options.get('url')
 
         list_url = url + 'api/sync/list/'
         get_url = url + 'api/sync/get/'
         file_url = url[:-1]
 
         global_id_str = options.get('global_id')
         if global_id_str:
             match = REGEX_GLOBAL_ID.match(global_id_str)
             if match:
                 key_type = match.group(1)
                 key = match.group(2)
                 local_id = match.group(3)
 
                 global_id = GlobalId(key_type=key_type, key=key,
                                      local_id=local_id)
 
-                xml = GlobalId.objects.generate_request_get([global_id])
+                xml = SyncManager.generate_request_get([global_id])
                 h = httplib2.Http()
                 response, content = h.request(get_url, method="POST", body=xml)
 
                 SyncManager.parse_response_get(content, file_url)
             else:
                 raise Exception('Invalid global ID')
         else:
             logger.info('Running LIST request...')
             h = httplib2.Http()
-            xml = GlobalId.objects.generate_request_list()
+            xml = SyncManager.generate_request_list(
+                opening_post=options.get('thread'))
             response, content = h.request(list_url, method="POST", body=xml)
             logger.info('Processing response...')
 
             root = ET.fromstring(content)
             status = root.findall('status')[0].text
             if status == 'success':
                 ids_to_sync = list()
 
                 models = root.findall('models')[0]
                 for model in models:
                     tag_id = model.find(TAG_ID)
                     global_id, exists = GlobalId.from_xml_element(tag_id)
                     tag_version = model.find(TAG_VERSION)
                     if tag_version is not None:
                         version = int(tag_version.text) or 1
                     else:
                         version = 1
                     if not exists or global_id.post.version < version:
                         logger.debug('Processed (+) post {}'.format(global_id))
                         ids_to_sync.append(global_id)
                     else:
                         logger.debug('* Processed (-) post {}'.format(global_id))
                 logger.info('Starting sync...')
 
                 if len(ids_to_sync) > 0:
                     limit = options.get('split_query', len(ids_to_sync))
                     for offset in range(0, len(ids_to_sync), limit):
-                        xml = GlobalId.objects.generate_request_get(ids_to_sync[offset:offset+limit])
+                        xml = SyncManager.generate_request_get(ids_to_sync[offset:offset + limit])
                         h = httplib2.Http()
                         logger.info('Running GET request...')
                         response, content = h.request(get_url, method="POST", body=xml)
                         logger.info('Processing response...')
 
                         SyncManager.parse_response_get(content, file_url)
                 else:
                     logger.info('Nothing to get, everything synced')
             else:
                 raise Exception('Invalid response status')

boards/mdx_neboard.py

@@ -1,276 +1,282 b''
 # coding=utf-8
 
 import re
 import random
 import bbcode
 
 from urllib.parse import unquote
 
 from django.core.exceptions import ObjectDoesNotExist
 from django.core.urlresolvers import reverse
 
 import boards
+from boards import settings
 
 
 __author__ = 'neko259'
 
 
 REFLINK_PATTERN = re.compile(r'^\d+$')
 GLOBAL_REFLINK_PATTERN = re.compile(r'(\w+)::([^:]+)::(\d+)')
 MULTI_NEWLINES_PATTERN = re.compile(r'(\r?\n){2,}')
 ONE_NEWLINE = '\n'
 REGEX_URL = re.compile(r'https?\://[a-zA-Z0-9\-\.]+\.[a-zA-Z]{2,3}(/\S*)?')
 LINE_BREAK_HTML = '<div class="br"></div>'
 SPOILER_SPACE = '&nbsp;'
 
 MAX_SPOILER_MULTIPLIER = 2
+MAX_SPOILER_SPACE_COUNT = 20
 
 
 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="quote">'
     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]'
 
 
 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]'
 
 
 class HintPattern(TextFormatter):
     name = 'hint'
     preview_left = '<span class="hint">'
     preview_right = '</span>'
 
     format_left = '[hint]'
     format_right = '[/hint]'
 
 
 def render_reflink(tag_name, value, options, parent, context):
     result = '>>%s' % value
 
     post = None
     if REFLINK_PATTERN.match(value):
         post_id = int(value)
 
         try:
             post = boards.models.Post.objects.get(id=post_id)
 
         except ObjectDoesNotExist:
             pass
     elif GLOBAL_REFLINK_PATTERN.match(value):
         match = GLOBAL_REFLINK_PATTERN.search(value)
         try:
             global_id = boards.models.GlobalId.objects.get(
                 key_type=match.group(1), key=match.group(2),
                 local_id=match.group(3))
             post = global_id.post
         except ObjectDoesNotExist:
             pass
 
     if post is not None:
         result = post.get_link_view()
 
     return result
 
 
 def render_quote(tag_name, value, options, parent, context):
     source = ''
     if 'source' in options:
         source = options['source']
     elif 'quote' in options:
         source = options['quote']
 
     if source:
         result = '<div class="multiquote"><div class="quote-header">%s</div><div class="quote-text">%s</div></div>' % (source, value)
     else:
         # Insert a ">" at the start of every line
         result = '<span class="quote">&gt;{}</span>'.format(
                 value.replace(LINE_BREAK_HTML,
                     '{}&gt;'.format(LINE_BREAK_HTML)))
 
     return result
 
 
 def render_hint(tag_name, value, options, parent, context):
     if 'hint' in options:
         hint = options['hint']
         result = '<span class="hint" title="{}">{}</span>'.format(hint, value)
     else:
         result = value
     return result
 
 
 def render_notification(tag_name, value, options, parent, content):
     username = value.lower()
 
     return '<a href="{}" class="user-cast">@{}</a>'.format(
         reverse('notifications', kwargs={'username': username}), username)
 
 
 def render_tag(tag_name, value, options, parent, context):
     tag_name = value.lower()
 
     try:
         url = boards.models.Tag.objects.get(name=tag_name).get_view()
     except ObjectDoesNotExist:
         url = tag_name
 
     return url
 
 
 def render_spoiler(tag_name, value, options, parent, context):
-    text_len = len(value)
-    space_count = random.randint(0, text_len * MAX_SPOILER_MULTIPLIER)
-    side_spaces = SPOILER_SPACE * (space_count // 2)
-    return '<span class="spoiler">{}{}{}</span>'.format(side_spaces, value,
-            side_spaces)
+    if settings.get_bool('Forms', 'AdditionalSpoilerSpaces'):
+        text_len = len(value)
+        space_count = min(random.randint(0, text_len * MAX_SPOILER_MULTIPLIER),
+                MAX_SPOILER_SPACE_COUNT)
+        side_spaces = SPOILER_SPACE * (space_count // 2)
+    else:
+        side_spaces = ''
+    return '<span class="spoiler">{}{}{}</span>'.format(side_spaces,
+            value, side_spaces)
 
 
 formatters = [
     QuotePattern,
     SpoilerPattern,
     ItalicPattern,
     BoldPattern,
     CommentPattern,
     StrikeThroughPattern,
     CodePattern,
     HintPattern,
 ]
 
 
 PREPARSE_PATTERNS = {
     r'(?<!>)>>(\d+)': r'[post]\1[/post]',  # Reflink ">>123"
     r'^>([^>].+)': r'[quote]\1[/quote]',  # Quote ">text"
     r'^//\s?(.+)': r'[comment]\1[/comment]',  # Comment "//text"
     r'\B@(\w+)': r'[user]\1[/user]',  # User notification "@user"
 }
 
 
 class Parser:
     def __init__(self):
         # The newline hack is added because br's margin does not work in all
         # browsers except firefox, when the div's does.
         self.parser = bbcode.Parser(newline=LINE_BREAK_HTML)
 
         self.parser.add_formatter('post', render_reflink, strip=True)
         self.parser.add_formatter('quote', render_quote, strip=True)
         self.parser.add_formatter('hint', render_hint, strip=True)
         self.parser.add_formatter('user', render_notification, strip=True)
         self.parser.add_formatter('tag', render_tag, strip=True)
         self.parser.add_formatter('spoiler', render_spoiler, strip=True)
         self.parser.add_simple_formatter(
             'comment', '<span class="comment">// %(value)s</span>', strip=True)
         self.parser.add_simple_formatter(
             's', '<span class="strikethrough">%(value)s</span>')
         self.parser.add_simple_formatter('code',
                                          '<pre><code>%(value)s</pre></code>',
                                          render_embedded=False,
                                          escape_html=True,
                                          replace_links=False,
                                          replace_cosmetic=False)
 
     def preparse(self, text):
         """
         Performs manual parsing before the bbcode parser is used.
         Preparsed text is saved as raw and the text before preparsing is lost.
         """
         new_text = MULTI_NEWLINES_PATTERN.sub(ONE_NEWLINE, text)
 
         for key, value in PREPARSE_PATTERNS.items():
             new_text = re.sub(key, value, new_text, flags=re.MULTILINE)
 
         for link in REGEX_URL.findall(text):
             new_text = new_text.replace(link, unquote(link))
 
         return new_text
 
     def parse(self, text):
         return self.parser.format(text)
 
 
 parser = Parser()
 def get_parser():
     return parser

boards/models/attachment/downloaders.py

@@ -1,101 +1,101 b''
 import re
 
 import requests
 from django.core.files.uploadedfile import TemporaryUploadedFile
 from pytube import YouTube
 
 from boards.utils import validate_file_size
 
 YOUTUBE_VIDEO_FORMAT = 'webm'
 
 HTTP_RESULT_OK = 200
 
 HEADER_CONTENT_LENGTH = 'content-length'
 HEADER_CONTENT_TYPE = 'content-type'
 
 FILE_DOWNLOAD_CHUNK_BYTES = 200000
 
 REGEX_YOUTUBE_URL = re.compile(r'https?://((www\.)?youtube\.com/watch\?v=|youtu.be/)[-\w]+')
 REGEX_MAGNET = re.compile(r'magnet:\?xt=urn:(btih:)?[a-z0-9]{20,50}.*')
 
 TYPE_URL_ONLY = (
     'application/xhtml+xml',
     'text/html',
 )
 
 
 class Downloader:
     @staticmethod
     def handles(url: str) -> bool:
         return True
 
     @staticmethod
-    def download(url: str):
+    def download(url: str, validate):
         # Verify content headers
         response_head = requests.head(url, verify=False)
         content_type = response_head.headers[HEADER_CONTENT_TYPE].split(';')[0]
-        if content_type in TYPE_URL_ONLY:
+        if validate and content_type in TYPE_URL_ONLY:
             return None
 
         length_header = response_head.headers.get(HEADER_CONTENT_LENGTH)
-        if length_header:
+        if validate and length_header:
             length = int(length_header)
             validate_file_size(length)
         # Get the actual content into memory
         response = requests.get(url, verify=False, stream=True)
 
         if response.status_code == HTTP_RESULT_OK:
             # Download file, stop if the size exceeds limit
             size = 0
 
             # Set a dummy file name that will be replaced
             # anyway, just keep the valid extension
             filename = 'file.' + content_type.split('/')[1]
 
             file = TemporaryUploadedFile(filename, content_type, 0, None, None)
             for chunk in response.iter_content(FILE_DOWNLOAD_CHUNK_BYTES):
                 size += len(chunk)
                 validate_file_size(size)
                 file.write(chunk)
 
             return file
 
 
 class YouTubeDownloader(Downloader):
     @staticmethod
-    def download(url: str):
+    def download(url: str, validate):
         yt = YouTube()
         yt.from_url(url)
         videos = yt.filter(YOUTUBE_VIDEO_FORMAT)
         if len(videos) > 0:
             video = videos[0]
             return Downloader.download(video.url)
 
     @staticmethod
     def handles(url: str) -> bool:
         return REGEX_YOUTUBE_URL.match(url) is not None
 
 
 class NothingDownloader(Downloader):
     @staticmethod
     def handles(url: str) -> bool:
         return REGEX_MAGNET.match(url)
 
     @staticmethod
-    def download(url: str):
+    def download(url: str, validate):
         return None
 
 
 DOWNLOADERS = (
     YouTubeDownloader,
     NothingDownloader,
     Downloader,
 )
 
 
-def download(url):
+def download(url, validate=True):
     for downloader in DOWNLOADERS:
         if downloader.handles(url):
-            return downloader.download(url)
+            return downloader.download(url, validate=validate)
     raise Exception('No downloader supports this URL.')
 

boards/models/post/__init__.py

@@ -1,364 +1,364 b''
 import uuid
 import hashlib
 import re
 
 from boards import settings
 from boards.abstracts.tripcode import Tripcode
 from boards.models import Attachment, KeyPair, GlobalId
 from boards.models.attachment import FILE_TYPES_IMAGE
 from boards.models.base import Viewable
 from boards.models.post.export import get_exporter, DIFF_TYPE_JSON
 from boards.models.post.manager import PostManager, NO_IP
 from boards.utils import datetime_to_epoch
 from django.core.exceptions import ObjectDoesNotExist
 from django.core.urlresolvers import reverse
 from django.db import models
 from django.db.models import TextField, QuerySet, F
 from django.template.defaultfilters import truncatewords, striptags
 from django.template.loader import render_to_string
 
 CSS_CLS_HIDDEN_POST = 'hidden_post'
 CSS_CLS_DEAD_POST = 'dead_post'
 CSS_CLS_ARCHIVE_POST = 'archive_post'
 CSS_CLS_POST = 'post'
 CSS_CLS_MONOCHROME = 'monochrome'
 
 TITLE_MAX_WORDS = 10
 
 APP_LABEL_BOARDS = 'boards'
 
 BAN_REASON_AUTO = 'Auto'
 
 TITLE_MAX_LENGTH = 200
 
 REGEX_REPLY = re.compile(r'\[post\](\d+)\[/post\]')
 REGEX_GLOBAL_REPLY = re.compile(r'\[post\](\w+)::([^:]+)::(\d+)\[/post\]')
 REGEX_URL = re.compile(r'https?\://[a-zA-Z0-9\-\.]+\.[a-zA-Z]{2,3}(/\S*)?')
 REGEX_NOTIFICATION = re.compile(r'\[user\](\w+)\[/user\]')
 
 PARAMETER_TRUNCATED = 'truncated'
 PARAMETER_TAG = 'tag'
 PARAMETER_OFFSET = 'offset'
 PARAMETER_DIFF_TYPE = 'type'
 PARAMETER_CSS_CLASS = 'css_class'
 PARAMETER_THREAD = 'thread'
 PARAMETER_IS_OPENING = 'is_opening'
 PARAMETER_POST = 'post'
 PARAMETER_OP_ID = 'opening_post_id'
 PARAMETER_NEED_OPEN_LINK = 'need_open_link'
 PARAMETER_REPLY_LINK = 'reply_link'
 PARAMETER_NEED_OP_DATA = 'need_op_data'
 
 POST_VIEW_PARAMS = (
     'need_op_data',
     'reply_link',
     'need_open_link',
     'truncated',
     'mode_tree',
     'perms',
     'tree_depth',
 )
 
 
 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, blank=True, default='')
     pub_time = models.DateTimeField(db_index=True)
     text = TextField(blank=True, default='')
     _text_rendered = TextField(blank=True, null=True, editable=False)
 
     attachments = models.ManyToManyField(Attachment, null=True, blank=True,
                                          related_name='attachment_posts')
 
     poster_ip = models.GenericIPAddressField()
 
     # Used for cache and threads updating
     last_edit_time = models.DateTimeField()
 
     referenced_posts = models.ManyToManyField('Post', symmetrical=False,
                                               null=True,
                                               blank=True, related_name='refposts',
                                               db_index=True)
     refmap = models.TextField(null=True, blank=True)
     thread = models.ForeignKey('Thread', db_index=True, related_name='replies')
 
     url = models.TextField()
-    uid = models.TextField(db_index=True)
+    uid = models.TextField()
 
     # Global ID with author key. If the message was downloaded from another
     # server, this indicates the server.
     global_id = models.OneToOneField(GlobalId, null=True, blank=True,
                                      on_delete=models.CASCADE)
 
     tripcode = models.CharField(max_length=50, blank=True, default='')
     opening = models.BooleanField(db_index=True)
     hidden = models.BooleanField(default=False)
     version = models.IntegerField(default=1)
 
     def __str__(self):
         return 'P#{}/{}'.format(self.id, self.get_title())
 
     def get_title(self) -> str:
         return self.title
 
     def get_title_or_text(self):
         title = self.get_title()
         if not title:
             title = truncatewords(striptags(self.get_text()), TITLE_MAX_WORDS)
 
         return title
 
     def build_refmap(self, excluded_ids=None) -> 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.
         """
 
         replies = self.referenced_posts
         if excluded_ids is not None:
             replies = replies.exclude(id__in=excluded_ids)
         else:
             replies = replies.all()
 
         post_urls = [refpost.get_link_view() for refpost in replies]
 
         self.refmap = ', '.join(post_urls)
 
     def is_referenced(self) -> bool:
         return self.refmap and len(self.refmap) > 0
 
     def is_opening(self) -> bool:
         """
         Checks if this is an opening post or just a reply.
         """
 
         return self.opening
 
     def get_absolute_url(self, thread=None):
         # Url is cached only for the "main" thread. When getting url
         # for other threads, do it manually.
         return self.url
 
     def get_thread(self):
         return self.thread
 
     def get_thread_id(self):
         return self.thread_id
 
     def _get_cache_key(self):
         return [datetime_to_epoch(self.last_edit_time)]
 
     def get_view_params(self, *args, **kwargs):
         """
         Gets the parameters required for viewing the post based on the arguments
         given and the post itself.
         """
         thread = kwargs.get('thread') or self.get_thread()
 
         css_classes = [CSS_CLS_POST]
         if thread.is_archived():
             css_classes.append(CSS_CLS_ARCHIVE_POST)
         elif not thread.can_bump():
             css_classes.append(CSS_CLS_DEAD_POST)
         if self.is_hidden():
             css_classes.append(CSS_CLS_HIDDEN_POST)
         if thread.is_monochrome():
             css_classes.append(CSS_CLS_MONOCHROME)
 
         params = dict()
         for param in POST_VIEW_PARAMS:
             if param in kwargs:
                 params[param] = kwargs[param]
 
         params.update({
             PARAMETER_POST: self,
             PARAMETER_IS_OPENING: self.is_opening(),
             PARAMETER_THREAD: thread,
             PARAMETER_CSS_CLASS: ' '.join(css_classes),
         })
 
         return params
 
     def get_view(self, *args, **kwargs) -> str:
         """
         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.
         """
         params = self.get_view_params(*args, **kwargs)
 
         return render_to_string('boards/post.html', params)
 
     def get_images(self) -> Attachment:
         return self.attachments.filter(mimetype__in=FILE_TYPES_IMAGE)
 
     def get_first_image(self) -> Attachment:
         try:
             return self.get_images().earliest('-id')
         except Attachment.DoesNotExist:
             return None
 
     def set_global_id(self, key_pair=None):
         """
         Sets global id based on the given key pair. If no key pair is given,
         default one is used.
         """
 
         if key_pair:
             key = key_pair
         else:
             try:
                 key = KeyPair.objects.get(primary=True)
             except KeyPair.DoesNotExist:
                 # Do not update the global id because there is no key defined
                 return
         global_id = GlobalId(key_type=key.key_type,
                              key=key.public_key,
                              local_id=self.id)
         global_id.save()
 
         self.global_id = global_id
 
         self.save(update_fields=['global_id'])
 
     def get_pub_time_str(self):
         return str(self.pub_time)
 
     def get_replied_ids(self):
         """
         Gets ID list of the posts that this post replies.
         """
 
         raw_text = self.get_raw_text()
 
         local_replied = REGEX_REPLY.findall(raw_text)
         global_replied = []
         for match in REGEX_GLOBAL_REPLY.findall(raw_text):
             key_type = match[0]
             key = match[1]
             local_id = match[2]
 
             try:
                 global_id = GlobalId.objects.get(key_type=key_type,
                                                  key=key, local_id=local_id)
                 for post in Post.objects.filter(global_id=global_id).only('id'):
                     global_replied.append(post.id)
             except GlobalId.DoesNotExist:
                 pass
         return local_replied + global_replied
 
     def get_post_data(self, format_type=DIFF_TYPE_JSON, request=None,
                       include_last_update=False) -> str:
         """
         Gets post HTML or JSON data that can be rendered on a page or used by
         API.
         """
 
         return get_exporter(format_type).export(self, request,
                                                 include_last_update)
 
     def _build_url(self):
         opening = self.is_opening()
         opening_id = self.id if opening else self.get_thread().get_opening_post_id()
         url = reverse('thread', kwargs={'post_id': opening_id})
         if not opening:
             url += '#' + str(self.id)
 
         return url
 
     def save(self, force_insert=False, force_update=False, using=None,
              update_fields=None):
         new_post = self.id is None
 
         self.uid = str(uuid.uuid4())
         if update_fields is not None and 'uid' not in update_fields:
             update_fields += ['uid']
 
         if not new_post:
             thread = self.get_thread()
             if thread:
                 thread.last_edit_time = self.last_edit_time
                 thread.save(update_fields=['last_edit_time', 'status'])
 
         super().save(force_insert, force_update, using, update_fields)
 
         if new_post:
             self.url = self._build_url()
             super().save(update_fields=['url'])
 
     def get_text(self) -> str:
         return self._text_rendered
 
     def get_raw_text(self) -> str:
         return self.text
 
     def get_sync_text(self) -> str:
         """
         Returns text applicable for sync. It has absolute post reflinks.
         """
 
         replacements = dict()
         for post_id in REGEX_REPLY.findall(self.get_raw_text()):
             try:
                 absolute_post_id = str(Post.objects.get(id=post_id).global_id)
                 replacements[post_id] = absolute_post_id
             except Post.DoesNotExist:
                 pass
 
         text = self.get_raw_text() or ''
         for key in replacements:
             text = text.replace('[post]{}[/post]'.format(key),
                                 '[post]{}[/post]'.format(replacements[key]))
         text = text.replace('\r\n', '\n').replace('\r', '\n')
 
         return text
 
     def get_tripcode(self):
         if self.tripcode:
             return Tripcode(self.tripcode)
 
     def get_link_view(self):
         """
         Gets view of a reflink to the post.
         """
         result = '<a href="{}">&gt;&gt;{}</a>'.format(self.get_absolute_url(),
                                                       self.id)
         if self.is_opening():
             result = '<b>{}</b>'.format(result)
 
         return result
 
     def is_hidden(self) -> bool:
         return self.hidden
 
     def set_hidden(self, hidden):
         self.hidden = hidden
 
     def increment_version(self):
         self.version = F('version') + 1
 
     def clear_cache(self):
         """
         Clears sync data (content cache, signatures etc).
         """
         global_id = self.global_id
         if global_id is not None and global_id.is_local()\
                 and global_id.content is not None:
             global_id.clear_cache()
 
     def get_tags(self):
         return self.get_thread().get_tags()
 
     def get_ip_color(self):
         return hashlib.md5(self.poster_ip.encode()).hexdigest()[:6]
 
     def has_ip(self):
         return self.poster_ip != NO_IP
 

boards/models/post/sync.py

@@ -1,337 +1,345 b''
 import xml.etree.ElementTree as et
 import logging
+from xml.etree import ElementTree
 
 from boards.abstracts.exceptions import SyncException
+from boards.abstracts.sync_filters import ThreadFilter
 from boards.models import KeyPair, GlobalId, Signature, Post, Tag
 from boards.models.attachment.downloaders import download
+from boards.models.signature import TAG_REQUEST, ATTR_TYPE, TYPE_GET, \
+    ATTR_VERSION, TAG_MODEL, ATTR_NAME, TAG_ID, TYPE_LIST
 from boards.utils import get_file_mimetype, get_file_hash
 from django.db import transaction
 from django import forms
 
 EXCEPTION_NODE = 'Sync node returned an error: {}.'
 EXCEPTION_DOWNLOAD = 'File was not downloaded.'
 EXCEPTION_HASH = 'File hash does not match attachment hash.'
 EXCEPTION_SIGNATURE = 'Invalid model signature for {}.'
 EXCEPTION_AUTHOR_SIGNATURE = 'Model {} has no author signature.'
 ENCODING_UNICODE = 'unicode'
 
 TAG_MODEL = 'model'
 TAG_REQUEST = 'request'
 TAG_RESPONSE = 'response'
 TAG_ID = 'id'
 TAG_STATUS = 'status'
 TAG_MODELS = 'models'
 TAG_TITLE = 'title'
 TAG_TEXT = 'text'
 TAG_THREAD = 'thread'
 TAG_PUB_TIME = 'pub-time'
 TAG_SIGNATURES = 'signatures'
 TAG_SIGNATURE = 'signature'
 TAG_CONTENT = 'content'
 TAG_ATTACHMENTS = 'attachments'
 TAG_ATTACHMENT = 'attachment'
 TAG_TAGS = 'tags'
 TAG_TAG = 'tag'
 TAG_ATTACHMENT_REFS = 'attachment-refs'
 TAG_ATTACHMENT_REF = 'attachment-ref'
 TAG_TRIPCODE = 'tripcode'
 TAG_VERSION = 'version'
 
 TYPE_GET = 'get'
 
 ATTR_VERSION = 'version'
 ATTR_TYPE = 'type'
 ATTR_NAME = 'name'
 ATTR_VALUE = 'value'
 ATTR_MIMETYPE = 'mimetype'
 ATTR_KEY = 'key'
 ATTR_REF = 'ref'
 ATTR_URL = 'url'
 ATTR_ID_TYPE = 'id-type'
 
 ID_TYPE_MD5 = 'md5'
 ID_TYPE_URL = 'url'
 
 STATUS_SUCCESS = 'success'
 
 
 logger = logging.getLogger('boards.sync')
 
 
 class SyncManager:
     @staticmethod
     def generate_response_get(model_list: list):
         response = et.Element(TAG_RESPONSE)
 
         status = et.SubElement(response, TAG_STATUS)
         status.text = STATUS_SUCCESS
 
         models = et.SubElement(response, TAG_MODELS)
 
         for post in model_list:
             model = et.SubElement(models, TAG_MODEL)
             model.set(ATTR_NAME, 'post')
 
             global_id = post.global_id
 
             attachments = post.attachments.all()
             if global_id.content:
                 model.append(et.fromstring(global_id.content))
                 if len(attachments) > 0:
                     internal_attachments = False
                     for attachment in attachments:
                         if attachment.is_internal():
                             internal_attachments = True
                             break
 
                     if internal_attachments:
                         attachment_refs = et.SubElement(model, TAG_ATTACHMENT_REFS)
                         for file in attachments:
                             SyncManager._attachment_to_xml(
                                 None, attachment_refs, file)
             else:
                 content_tag = et.SubElement(model, TAG_CONTENT)
 
                 tag_id = et.SubElement(content_tag, TAG_ID)
                 global_id.to_xml_element(tag_id)
 
                 title = et.SubElement(content_tag, TAG_TITLE)
                 title.text = post.title
 
                 text = et.SubElement(content_tag, TAG_TEXT)
                 text.text = post.get_sync_text()
 
                 thread = post.get_thread()
                 if post.is_opening():
                     tag_tags = et.SubElement(content_tag, TAG_TAGS)
                     for tag in thread.get_tags():
                         tag_tag = et.SubElement(tag_tags, TAG_TAG)
                         tag_tag.text = tag.name
                 else:
                     tag_thread = et.SubElement(content_tag, TAG_THREAD)
                     thread_id = et.SubElement(tag_thread, TAG_ID)
                     thread.get_opening_post().global_id.to_xml_element(thread_id)
 
                 pub_time = et.SubElement(content_tag, TAG_PUB_TIME)
                 pub_time.text = str(post.get_pub_time_str())
 
                 if post.tripcode:
                     tripcode = et.SubElement(content_tag, TAG_TRIPCODE)
                     tripcode.text = post.tripcode
 
                 if len(attachments) > 0:
                     attachments_tag = et.SubElement(content_tag, TAG_ATTACHMENTS)
                     
                     internal_attachments = False
                     for attachment in attachments:
                         if attachment.is_internal():
                             internal_attachments = True
                             break
 
                     if internal_attachments:
                         attachment_refs = et.SubElement(model, TAG_ATTACHMENT_REFS)
                     else:
                         attachment_refs = None
 
                     for file in attachments:
                         SyncManager._attachment_to_xml(
                             attachments_tag, attachment_refs, file)
                 version_tag = et.SubElement(content_tag, TAG_VERSION)
                 version_tag.text = str(post.version)
 
                 global_id.content = et.tostring(content_tag, ENCODING_UNICODE)
                 global_id.save()
 
             signatures_tag = et.SubElement(model, TAG_SIGNATURES)
             post_signatures = global_id.signature_set.all()
             if post_signatures:
                 signatures = post_signatures
             else:
                 key = KeyPair.objects.get(public_key=global_id.key)
                 signature = Signature(
                     key_type=key.key_type,
                     key=key.public_key,
                     signature=key.sign(global_id.content),
                     global_id=global_id,
                 )
                 signature.save()
                 signatures = [signature]
             for signature in signatures:
                 signature_tag = et.SubElement(signatures_tag, TAG_SIGNATURE)
                 signature_tag.set(ATTR_TYPE, signature.key_type)
                 signature_tag.set(ATTR_VALUE, signature.signature)
                 signature_tag.set(ATTR_KEY, signature.key)
 
         return et.tostring(response, ENCODING_UNICODE)
 
     @staticmethod
     def parse_response_get(response_xml, hostname):
         tag_root = et.fromstring(response_xml)
         tag_status = tag_root.find(TAG_STATUS)
         if STATUS_SUCCESS == tag_status.text:
             tag_models = tag_root.find(TAG_MODELS)
             for tag_model in tag_models:
                 SyncManager.parse_post(tag_model, hostname)
         else:
             raise SyncException(EXCEPTION_NODE.format(tag_status.text))
 
     @staticmethod
     @transaction.atomic
     def parse_post(tag_model, hostname):
         tag_content = tag_model.find(TAG_CONTENT)
 
         content_str = et.tostring(tag_content, ENCODING_UNICODE)
 
         tag_id = tag_content.find(TAG_ID)
         global_id, exists = GlobalId.from_xml_element(tag_id)
         signatures = SyncManager._verify_model(global_id, content_str, tag_model)
 
         version = int(tag_content.find(TAG_VERSION).text)
         is_old = exists and global_id.post.version < version
         if exists and not is_old:
             print('Post with same ID exists and is up to date.')
         else:
             global_id.content = content_str
             global_id.save()
             for signature in signatures:
                 signature.global_id = global_id
                 signature.save()
 
             title = tag_content.find(TAG_TITLE).text or ''
             text = tag_content.find(TAG_TEXT).text or ''
             pub_time = tag_content.find(TAG_PUB_TIME).text
             tripcode_tag = tag_content.find(TAG_TRIPCODE)
             if tripcode_tag is not None:
                 tripcode = tripcode_tag.text or ''
             else:
                 tripcode = ''
 
             thread = tag_content.find(TAG_THREAD)
             tags = []
             if thread:
                 thread_id = thread.find(TAG_ID)
                 op_global_id, exists = GlobalId.from_xml_element(thread_id)
                 if exists:
                     opening_post = Post.objects.get(global_id=op_global_id)
                 else:
                     logger.debug('No thread exists for post {}'.format(global_id))
             else:
                 opening_post = None
                 tag_tags = tag_content.find(TAG_TAGS)
                 for tag_tag in tag_tags:
                     tag, created = Tag.objects.get_or_create(
                         name=tag_tag.text)
                     tags.append(tag)
 
             # TODO Check that the replied posts are already present
             # before adding new ones
 
             files = []
             urls = []
             tag_attachments = tag_content.find(TAG_ATTACHMENTS) or list()
             tag_refs = tag_model.find(TAG_ATTACHMENT_REFS)
             for attachment in tag_attachments:
                 if attachment.get(ATTR_ID_TYPE) == ID_TYPE_URL:
                     urls.append(attachment.text)
                 else:
                     tag_ref = tag_refs.find("{}[@ref='{}']".format(
                         TAG_ATTACHMENT_REF, attachment.text))
                     url = tag_ref.get(ATTR_URL)
                     try:
-                        attached_file = download(hostname + url)
+                        attached_file = download(hostname + url, validate=False)
 
                         if attached_file is None:
                             raise SyncException(EXCEPTION_DOWNLOAD)
 
                         hash = get_file_hash(attached_file)
                         if hash != attachment.text:
                             raise SyncException(EXCEPTION_HASH)
 
                         files.append(attached_file)
                     except forms.ValidationError:
                         urls.append(hostname+url)
                         
 
             if is_old:
                 post = global_id.post
                 Post.objects.update_post(
                     post, title=title, text=text, pub_time=pub_time,
                     tags=tags, files=files, file_urls=urls,
                     tripcode=tripcode, version=version)
                 logger.debug('Parsed updated post {}'.format(global_id))
             else:
                 Post.objects.import_post(
                     title=title, text=text, pub_time=pub_time,
                     opening_post=opening_post, tags=tags,
                     global_id=global_id, files=files,
                     file_urls=urls, tripcode=tripcode,
                     version=version)
                 logger.debug('Parsed new post {}'.format(global_id))
 
     @staticmethod
-    def generate_response_list():
+    def generate_response_list(filters):
         response = et.Element(TAG_RESPONSE)
 
         status = et.SubElement(response, TAG_STATUS)
         status.text = STATUS_SUCCESS
 
         models = et.SubElement(response, TAG_MODELS)
 
-        for post in Post.objects.prefetch_related('global_id').all():
+        posts = Post.objects.prefetch_related('global_id')
+        for post_filter in filters:
+            posts = post_filter.filter(posts)
+
+        for post in posts:
             tag_model = et.SubElement(models, TAG_MODEL)
             tag_id = et.SubElement(tag_model, TAG_ID)
             post.global_id.to_xml_element(tag_id)
             tag_version = et.SubElement(tag_model, TAG_VERSION)
             tag_version.text = str(post.version)
 
         return et.tostring(response, ENCODING_UNICODE)
 
     @staticmethod
     def _verify_model(global_id, content_str, tag_model):
         """
         Verifies all signatures for a single model.
         """
 
         signatures = []
 
         tag_signatures = tag_model.find(TAG_SIGNATURES)
         has_author_signature = False
         for tag_signature in tag_signatures:
             signature_type = tag_signature.get(ATTR_TYPE)
             signature_value = tag_signature.get(ATTR_VALUE)
             signature_key = tag_signature.get(ATTR_KEY)
 
             if global_id.key_type == signature_type and\
                     global_id.key == signature_key:
                 has_author_signature = True
 
             signature = Signature(key_type=signature_type,
                                   key=signature_key,
                                   signature=signature_value)
 
             if not KeyPair.objects.verify(signature, content_str):
                 raise SyncException(EXCEPTION_SIGNATURE.format(content_str))
 
             signatures.append(signature)
         if not has_author_signature:
             raise SyncException(EXCEPTION_AUTHOR_SIGNATURE.format(content_str))
 
         return signatures
 
     @staticmethod
     def _attachment_to_xml(tag_attachments, tag_refs, attachment):
         if tag_attachments is not None:
             attachment_tag = et.SubElement(tag_attachments, TAG_ATTACHMENT)
             if attachment.is_internal():
                 mimetype = get_file_mimetype(attachment.file.file)
                 attachment_tag.set(ATTR_MIMETYPE, mimetype)
                 attachment_tag.set(ATTR_ID_TYPE, ID_TYPE_MD5)
                 attachment_tag.text = attachment.hash
             else:
                 attachment_tag.set(ATTR_ID_TYPE, ID_TYPE_URL)
                 attachment_tag.text = attachment.url
 
         if tag_refs is not None:
             attachment_ref = et.SubElement(tag_refs, TAG_ATTACHMENT_REF)
             attachment_ref.set(ATTR_REF, attachment.hash)
-            attachment_ref.set(ATTR_URL, attachment.file.url)
+            attachment_ref.set(ATTR_URL, attachment.file.url)	

boards/models/signature.py

@@ -1,158 +1,125 b''
 import xml.etree.ElementTree as et
+
 from django.db import models
+
 from boards.models import KeyPair
 
-
 TAG_MODEL = 'model'
 TAG_REQUEST = 'request'
 TAG_ID = 'id'
 
 TYPE_GET = 'get'
 TYPE_LIST = 'list'
 
 ATTR_VERSION = 'version'
 ATTR_TYPE = 'type'
 ATTR_NAME = 'name'
 
 ATTR_KEY = 'key'
 ATTR_KEY_TYPE = 'type'
 ATTR_LOCAL_ID = 'local-id'
 
 
 class GlobalIdManager(models.Manager):
-    def generate_request_get(self, global_id_list: list):
-        """
-        Form a get request from a list of ModelId objects.
-        """
-
-        request = et.Element(TAG_REQUEST)
-        request.set(ATTR_TYPE, TYPE_GET)
-        request.set(ATTR_VERSION, '1.0')
-
-        model = et.SubElement(request, TAG_MODEL)
-        model.set(ATTR_VERSION, '1.0')
-        model.set(ATTR_NAME, 'post')
-
-        for global_id in global_id_list:
-            tag_id = et.SubElement(model, TAG_ID)
-            global_id.to_xml_element(tag_id)
-
-        return et.tostring(request, 'unicode')
-
-    def generate_request_list(self):
-        """
-        Form a pull request from a list of ModelId objects.
-        """
-
-        request = et.Element(TAG_REQUEST)
-        request.set(ATTR_TYPE, TYPE_LIST)
-        request.set(ATTR_VERSION, '1.0')
-
-        model = et.SubElement(request, TAG_MODEL)
-        model.set(ATTR_VERSION, '1.0')
-        model.set(ATTR_NAME, 'post')
-
-        return et.tostring(request, 'unicode')
-
     def global_id_exists(self, global_id):
         """
         Checks if the same global id already exists in the system.
         """
 
         return self.filter(key=global_id.key,
                            key_type=global_id.key_type,
                            local_id=global_id.local_id).exists()
 
 
 class GlobalId(models.Model):
     """
     Global model ID and cache.
     Key, key type and local ID make a single global identificator of the model.
     Content is an XML cache of the model that can be passed along between nodes
     without manual serialization each time.
     """
     class Meta:
         app_label = 'boards'
 
     objects = GlobalIdManager()
 
     def __init__(self, *args, **kwargs):
         models.Model.__init__(self, *args, **kwargs)
 
         if 'key' in kwargs and 'key_type' in kwargs and 'local_id' in kwargs:
             self.key = kwargs['key']
             self.key_type = kwargs['key_type']
             self.local_id = kwargs['local_id']
 
     key = models.TextField()
     key_type = models.TextField()
     local_id = models.IntegerField()
     content = models.TextField(blank=True, null=True)
 
     def __str__(self):
         return '%s::%s::%d' % (self.key_type, self.key, self.local_id)
 
     def to_xml_element(self, element: et.Element):
         """
         Exports global id to an XML element.
         """
 
         element.set(ATTR_KEY, self.key)
         element.set(ATTR_KEY_TYPE, self.key_type)
         element.set(ATTR_LOCAL_ID, str(self.local_id))
 
     @staticmethod
     def from_xml_element(element: et.Element):
         """
         Parses XML id tag and gets global id from it.
 
         Arguments:
         element -- the XML 'id' element
 
         Returns:
         global_id -- id itself
         exists -- True if the global id was taken from database, False if it
         did not exist and was created.
         """
 
         try:
             return GlobalId.objects.get(key=element.get(ATTR_KEY),
                                         key_type=element.get(ATTR_KEY_TYPE),
                                         local_id=int(element.get(
                                             ATTR_LOCAL_ID))), True
         except GlobalId.DoesNotExist:
             return GlobalId(key=element.get(ATTR_KEY),
                             key_type=element.get(ATTR_KEY_TYPE),
                             local_id=int(element.get(ATTR_LOCAL_ID))), False
 
     def is_local(self):
         """Checks fo the ID is local model's"""
         return KeyPair.objects.filter(
                 key_type=self.key_type, public_key=self.key).exists()
 
     def clear_cache(self):
         """
         Removes content cache and signatures.
         """
         self.content = None
         self.save()
         self.signature_set.all().delete()
 
 
 class Signature(models.Model):
     class Meta:
         app_label = 'boards'
 
     def __init__(self, *args, **kwargs):
         models.Model.__init__(self, *args, **kwargs)
 
         if 'key' in kwargs and 'key_type' in kwargs and 'signature' in kwargs:
             self.key_type = kwargs['key_type']
             self.key = kwargs['key']
             self.signature = kwargs['signature']
 
     key_type = models.TextField()
     key = models.TextField()
     signature = models.TextField()
 
     global_id = models.ForeignKey('GlobalId')

boards/signals.py

@@ -1,132 +1,135 b''
 import re
 import os
 
 from django.db.models.signals import post_save, pre_save, pre_delete, \
     post_delete
 from django.dispatch import receiver
 from django.utils import timezone
 
 from boards import thumbs
 from boards.mdx_neboard import get_parser
 
 from boards.models import Post, GlobalId, Attachment
 from boards.models.attachment.viewers import FILE_TYPES_IMAGE
 from boards.models.post import REGEX_NOTIFICATION, REGEX_REPLY,\
         REGEX_GLOBAL_REPLY
 from boards.models.post.manager import post_import_deps
 from boards.models.user import Notification
 from neboard.settings import MEDIA_ROOT
 
 
 THUMB_SIZES = ((200, 150),)
 
 
 @receiver(post_save, sender=Post)
 def connect_replies(instance, **kwargs):
-    for reply_number in re.finditer(REGEX_REPLY, instance.get_raw_text()):
-        post_id = reply_number.group(1)
+    if not kwargs['update_fields']:
+        for reply_number in re.finditer(REGEX_REPLY, instance.get_raw_text()):
+            post_id = reply_number.group(1)
 
-        try:
-            referenced_post = Post.objects.get(id=post_id)
+            try:
+                referenced_post = Post.objects.get(id=post_id)
 
-            if not referenced_post.referenced_posts.filter(
-                    id=instance.id).exists():
-                referenced_post.referenced_posts.add(instance)
-                referenced_post.last_edit_time = instance.pub_time
-                referenced_post.build_refmap()
-                referenced_post.save(update_fields=['refmap', 'last_edit_time'])
-        except Post.DoesNotExist:
-            pass
+                if not referenced_post.referenced_posts.filter(
+                        id=instance.id).exists():
+                    referenced_post.referenced_posts.add(instance)
+                    referenced_post.last_edit_time = instance.pub_time
+                    referenced_post.build_refmap()
+                    referenced_post.save(update_fields=['refmap', 'last_edit_time'])
+            except Post.DoesNotExist:
+                pass
 
 
 @receiver(post_save, sender=Post)
 @receiver(post_import_deps, sender=Post)
 def connect_global_replies(instance, **kwargs):
-    for reply_number in re.finditer(REGEX_GLOBAL_REPLY, instance.get_raw_text()):
-        key_type = reply_number.group(1)
-        key = reply_number.group(2)
-        local_id = reply_number.group(3)
+    if not kwargs['update_fields']:
+        for reply_number in re.finditer(REGEX_GLOBAL_REPLY, instance.get_raw_text()):
+            key_type = reply_number.group(1)
+            key = reply_number.group(2)
+            local_id = reply_number.group(3)
 
-        try:
-            global_id = GlobalId.objects.get(key_type=key_type, key=key,
-                    local_id=local_id)
-            referenced_post = Post.objects.get(global_id=global_id)
-            referenced_post.referenced_posts.add(instance)
-            referenced_post.last_edit_time = instance.pub_time
-            referenced_post.build_refmap()
-            referenced_post.save(update_fields=['refmap', 'last_edit_time'])
-        except (GlobalId.DoesNotExist, Post.DoesNotExist):
-            pass
+            try:
+                global_id = GlobalId.objects.get(key_type=key_type, key=key,
+                        local_id=local_id)
+                referenced_post = Post.objects.get(global_id=global_id)
+                referenced_post.referenced_posts.add(instance)
+                referenced_post.last_edit_time = instance.pub_time
+                referenced_post.build_refmap()
+                referenced_post.save(update_fields=['refmap', 'last_edit_time'])
+            except (GlobalId.DoesNotExist, Post.DoesNotExist):
+                pass
 
 
 @receiver(post_save, sender=Post)
 def connect_notifications(instance, **kwargs):
-    for reply_number in re.finditer(REGEX_NOTIFICATION, instance.get_raw_text()):
-        user_name = reply_number.group(1).lower()
-        Notification.objects.get_or_create(name=user_name, post=instance)
+    if not kwargs['update_fields']:
+        for reply_number in re.finditer(REGEX_NOTIFICATION, instance.get_raw_text()):
+            user_name = reply_number.group(1).lower()
+            Notification.objects.get_or_create(name=user_name, post=instance)
 
 
 @receiver(pre_save, sender=Post)
 @receiver(post_import_deps, sender=Post)
 def parse_text(instance, **kwargs):
     instance._text_rendered = get_parser().parse(instance.get_raw_text())
 
 
 @receiver(pre_delete, sender=Post)
 def delete_attachments(instance, **kwargs):
     for attachment in instance.attachments.all():
         attachment_refs_count = attachment.attachment_posts.count()
         if attachment_refs_count == 1:
             attachment.delete()
 
 
 @receiver(post_delete, sender=Post)
 def update_thread_on_delete(instance, **kwargs):
     thread = instance.get_thread()
     thread.last_edit_time = timezone.now()
     thread.save()
 
 
 @receiver(post_delete, sender=Post)
 def delete_global_id(instance, **kwargs):
     if instance.global_id and instance.global_id.id:
         instance.global_id.delete()
 
 
 @receiver(post_save, sender=Attachment)
 def generate_thumb(instance, **kwargs):
     if instance.mimetype in FILE_TYPES_IMAGE:
         for size in THUMB_SIZES:
             (w, h) = size
             split = instance.file.name.rsplit('.', 1)
             thumb_name = '%s.%sx%s.%s' % (split[0], w, h, split[1])
 
             if not instance.file.storage.exists(thumb_name):
                 # you can use another thumbnailing function if you like
                 thumb_content = thumbs.generate_thumb(instance.file, size, split[1])
 
                 thumb_name_ = instance.file.storage.save(thumb_name, thumb_content)
 
                 if not thumb_name == thumb_name_:
                     raise ValueError(
                         'There is already a file named %s' % thumb_name_)
 
 
 @receiver(pre_delete, sender=Post)
 def rebuild_refmap(instance, **kwargs):
     for referenced_post in instance.refposts.all():
         referenced_post.build_refmap(excluded_ids=[instance.id])
         referenced_post.save(update_fields=['refmap'])
 
 
 @receiver(post_delete, sender=Attachment)
 def delete_file(instance, **kwargs):
     if instance.is_internal():
         file = MEDIA_ROOT + instance.file.name
         os.remove(file)
         if instance.mimetype in FILE_TYPES_IMAGE:
             for size in THUMB_SIZES:
                 file_name_parts = instance.file.name.split('.')
                 thumb_file = MEDIA_ROOT + '{}.{}x{}.{}'.format(file_name_parts[0], size[0], size[1], file_name_parts[1])
                 os.remove(thumb_file)
 

boards/static/js/thread.js

@@ -1,160 +1,155 b''
 /*
  @licstart  The following is the entire license notice for the
  JavaScript code in this page.
 
 
  Copyright (C) 2013  neko259
 
  The JavaScript code in this page is free software: you can
  redistribute it and/or modify it under the terms of the GNU
  General Public License (GNU GPL) as published by the Free Software
  Foundation, either version 3 of the License, or (at your option)
  any later version.  The code is distributed WITHOUT ANY WARRANTY;
  without even the implied warranty of MERCHANTABILITY or FITNESS
  FOR A PARTICULAR PURPOSE.  See the GNU GPL for more details.
 
  As additional permission under GNU GPL version 3 section 7, you
  may distribute non-source (e.g., minimized or compacted) forms of
  that code without the copy of the GNU GPL normally required by
  section 4, provided you include this license notice and a URL
  through which recipients can access the Corresponding Source.
 
  @licend  The above is the entire license notice
  for the JavaScript code in this page.
  */
 
 var CLOSE_BUTTON = '#form-close-button';
 var REPLY_TO_MSG = '.reply-to-message';
 var REPLY_TO_MSG_ID = '#reply-to-message-id';
 
 var $html = $("html, body");
 
 function moveCaretToEnd(el) {
     var newPos = el.val().length;
     el[0].setSelectionRange(newPos, newPos);
 }
 
 function getForm() {
     return $('.post-form-w');
 }
 
 function resetFormPosition() {
     var form = getForm();
     form.insertAfter($('.thread'));
 
     $(CLOSE_BUTTON).hide();
     $(REPLY_TO_MSG).hide();
 }
 
 function showFormAfter(blockToInsertAfter) {
     var form = getForm();
     form.insertAfter(blockToInsertAfter);
 
     $(CLOSE_BUTTON).show();
     form.show();
     $(REPLY_TO_MSG_ID).text(blockToInsertAfter.attr('id'));
     $(REPLY_TO_MSG).show();
 }
 
 function addQuickReply(postId) {
-    // If we click "reply" on the same post, it means "cancel"
-    if (getForm().prev().attr('id') == postId) {
-        resetFormPosition();
-    } else {
-        var blockToInsert = null;
-        var textAreaJq = getPostTextarea();
-        var postLinkRaw = '[post]' + postId + '[/post]'
-        var textToAdd = '';
+    var blockToInsert = null;
+    var textAreaJq = getPostTextarea();
+    var postLinkRaw = '[post]' + postId + '[/post]'
+    var textToAdd = '';
 
-        if (postId != null) {
-            var post = $('#' + postId);
+    if (postId != null) {
+        var post = $('#' + postId);
 
-            // If this is not OP, add reflink to the post. If there already is
-            // the same reflink, don't add it again.
-            var postText = textAreaJq.val();
-            if (!post.is(':first-child') && postText.indexOf(postLinkRaw) < 0) {
-                // Insert line break if none is present.
-                if (postText.length > 0 && !postText.endsWith('\n') && !postText.endsWith('\r')) {
-                    textToAdd += '\n';
-                }
-                textToAdd += postLinkRaw + '\n';
+        // If this is not OP, add reflink to the post. If there already is
+        // the same reflink, don't add it again.
+        var postText = textAreaJq.val();
+        if (!post.is(':first-child') && postText.indexOf(postLinkRaw) < 0) {
+            // Insert line break if none is present.
+            if (postText.length > 0 && !postText.endsWith('\n') && !postText.endsWith('\r')) {
+                textToAdd += '\n';
             }
+            textToAdd += postLinkRaw + '\n';
+        }
 
-            textAreaJq.val(textAreaJq.val()+ textToAdd);
-            blockToInsert = post;
-        } else {
-            blockToInsert = $('.thread');
-        }
-        showFormAfter(blockToInsert);
-    
-        textAreaJq.focus();
+        textAreaJq.val(textAreaJq.val()+ textToAdd);
+        blockToInsert = post;
+    } else {
+        blockToInsert = $('.thread');
+    }
+    showFormAfter(blockToInsert);
 
-        moveCaretToEnd(textAreaJq);
-    }
+    textAreaJq.focus();
+
+    moveCaretToEnd(textAreaJq);
 }
 
 function addQuickQuote() {
     var textAreaJq = getPostTextarea();
 
     var quoteButton = $("#quote-button");
     var postId = quoteButton.attr('data-post-id');
-    if (postId != null && getForm().prev().attr('id') != postId) {
+    if (postId != null) {
         addQuickReply(postId);
     }
 
     var textToAdd = '';
     var selection = window.getSelection().toString();
     if (selection.length == 0) {
         selection = quoteButton.attr('data-text');
     }
     if (selection.length > 0) {
         textToAdd += '[quote]' + selection + '[/quote]\n';
     }
 
     textAreaJq.val(textAreaJq.val() + textToAdd);
 
     textAreaJq.focus();
 
     moveCaretToEnd(textAreaJq);
 }
 
 function scrollToBottom() {
     $html.animate({scrollTop: $html.height()}, "fast");
 }
 
 function showQuoteButton() {
     var selection = window.getSelection().getRangeAt(0).getBoundingClientRect();
     var quoteButton = $("#quote-button");
     if (selection.width > 0) {
         // quoteButton.offset({ top: selection.top - selection.height, left: selection.left });
         quoteButton.css({top: selection.top + $(window).scrollTop() - 30, left: selection.left});
         quoteButton.show();
 
         var text = window.getSelection().toString();
         quoteButton.attr('data-text', text);
 
         var rect = window.getSelection().getRangeAt(0).getBoundingClientRect();
         var element = $(document.elementFromPoint(rect.x, rect.y));
         var postId = null;
         if (element.hasClass('post')) {
             postId = element.attr('id');
         } else {
             var postParent = element.parents('.post');
             if (postParent.length > 0) {
                 postId = postParent.attr('id');
             }
         }
         quoteButton.attr('data-post-id', postId);
     } else {
         quoteButton.hide();
     }
 }
 
 $(document).ready(function() {
     $('body').on('mouseup', function() {
         showQuoteButton();
     });
     $("#quote-button").click(function() {
         addQuickQuote();
     })
 });

boards/tests/test_keys.py

@@ -1,91 +1,90 b''
-from base64 import b64encode
 import logging
 
 from django.test import TestCase
 from boards.models import KeyPair, GlobalId, Post, Signature
 from boards.models.post.sync import SyncManager
 
 logger = logging.getLogger(__name__)
 
 
 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_value = key.sign(message)
 
         signature = Signature(key_type='ecdsa', key=key.public_key,
                               signature=signature_value)
         valid = KeyPair.objects.verify(signature, message)
 
         self.assertTrue(valid, 'Message verification failed.')
 
     def test_primary_constraint(self):
         KeyPair.objects.generate_key(key_type='ecdsa', primary=True)
 
         with self.assertRaises(Exception):
             KeyPair.objects.generate_key(key_type='ecdsa', primary=True)
 
     def test_model_id_save(self):
         model_id = GlobalId(key_type='test', key='test key', local_id='1')
         model_id.save()
 
     def test_request_get(self):
         post = self._create_post_with_key()
 
-        request = GlobalId.objects.generate_request_get([post.global_id])
+        request = SyncManager.generate_request_get([post.global_id])
         logger.debug(request)
 
         key = KeyPair.objects.get(primary=True)
         self.assertTrue('<request type="get" version="1.0">'
                         '<model name="post" version="1.0">'
                         '<id key="%s" local-id="1" type="%s" />'
                         '</model>'
                         '</request>' % (
                             key.public_key,
                             key.key_type,
                         ) in request,
                         'Wrong XML generated for the GET request.')
 
     def test_response_get(self):
         post = self._create_post_with_key()
         reply_post = Post.objects.create_post(title='test_title',
                                               text='[post]%d[/post]' % post.id,
                                               thread=post.get_thread())
 
         response = SyncManager.generate_response_get([reply_post])
         logger.debug(response)
 
         key = KeyPair.objects.get(primary=True)
         self.assertTrue('<status>success</status>'
                         '<models>'
                         '<model name="post">'
                         '<content>'
                         '<id key="%s" local-id="%d" type="%s" />'
                         '<title>test_title</title>'
                         '<text>[post]%s[/post]</text>'
                         '<thread><id key="%s" local-id="%d" type="%s" /></thread>'
                         '<pub-time>%s</pub-time>'
                         '<version>%s</version>'
                         '</content>' % (
                             key.public_key,
                             reply_post.id,
                             key.key_type,
                             str(post.global_id),
                             key.public_key,
                             post.id,
                             key.key_type,
                             str(reply_post.get_pub_time_str()),
                             post.version,
                         ) in response,
                         'Wrong XML generated for the GET response.')
 
     def _create_post_with_key(self):
         KeyPair.objects.generate_key(primary=True)
 
         return Post.objects.create_post(title='test_title', text='test_text')

boards/tests/test_sync.py

@@ -1,105 +1,214 b''
 from django.test import TestCase
 
 from boards.models import KeyPair, Post, Tag
 from boards.models.post.sync import SyncManager
 from boards.tests.mocks import MockRequest
-from boards.views.sync import response_get
+from boards.views.sync import response_get, response_list
 
 __author__ = 'neko259'
 
 
 class SyncTest(TestCase):
     def test_get(self):
         """
         Forms a GET request of a post and checks the response.
         """
 
         key = KeyPair.objects.generate_key(primary=True)
         tag = Tag.objects.create(name='tag1')
         post = Post.objects.create_post(title='test_title',
                                         text='test_text\rline two',
                                         tags=[tag])
 
         request = MockRequest()
         request.body = (
             '<request type="get" version="1.0">'
             '<model name="post" version="1.0">'
             '<id key="%s" local-id="%d" type="%s" />'
             '</model>'
             '</request>' % (post.global_id.key,
                             post.id,
                             post.global_id.key_type)
         )
 
         response = response_get(request).content.decode()
         self.assertTrue(
             '<status>success</status>'
             '<models>'
             '<model name="post">'
             '<content>'
             '<id key="%s" local-id="%d" type="%s" />'
             '<title>%s</title>'
             '<text>%s</text>'
             '<tags><tag>%s</tag></tags>'
             '<pub-time>%s</pub-time>'
             '<version>%s</version>'
             '</content>' % (
                 post.global_id.key,
                 post.global_id.local_id,
                 post.global_id.key_type,
                 post.title,
                 post.get_sync_text(),
                 post.get_thread().get_tags().first().name,
                 post.get_pub_time_str(),
                 post.version,
             ) in response,
             'Wrong response generated for the GET request.')
 
         post.delete()
         key.delete()
 
         KeyPair.objects.generate_key(primary=True)
 
         SyncManager.parse_response_get(response, None)
         self.assertEqual(1, Post.objects.count(),
                          'Post was not created from XML response.')
 
         parsed_post = Post.objects.first()
         self.assertEqual('tag1',
                          parsed_post.get_thread().get_tags().first().name,
                          'Invalid tag was parsed.')
 
         SyncManager.parse_response_get(response, None)
         self.assertEqual(1, Post.objects.count(),
                          'The same post was imported twice.')
 
         self.assertEqual(1, parsed_post.global_id.signature_set.count(),
                          'Signature was not saved.')
 
         post = parsed_post
 
         # Trying to sync the same once more
         response = response_get(request).content.decode()
 
         self.assertTrue(
             '<status>success</status>'
             '<models>'
             '<model name="post">'
             '<content>'
             '<id key="%s" local-id="%d" type="%s" />'
             '<title>%s</title>'
             '<text>%s</text>'
             '<tags><tag>%s</tag></tags>'
             '<pub-time>%s</pub-time>'
             '<version>%s</version>'
             '</content>' % (
                 post.global_id.key,
                 post.global_id.local_id,
                 post.global_id.key_type,
                 post.title,
                 post.get_sync_text(),
                 post.get_thread().get_tags().first().name,
                 post.get_pub_time_str(),
                 post.version,
             ) in response,
             'Wrong response generated for the GET request.')
+
+    def test_list_all(self):
+        key = KeyPair.objects.generate_key(primary=True)
+        tag = Tag.objects.create(name='tag1')
+        post = Post.objects.create_post(title='test_title',
+                                        text='test_text\rline two',
+                                        tags=[tag])
+        post2 = Post.objects.create_post(title='test title 2',
+                                         text='test text 2',
+                                         tags=[tag])
+
+        request_all = MockRequest()
+        request_all.body = (
+            '<request type="list" version="1.0">'
+            '<model name="post" version="1.0">'
+            '</model>'
+            '</request>'
+        )
+
+        response_all = response_list(request_all).content.decode()
+        self.assertTrue(
+            '<status>success</status>'
+            '<models>'
+            '<model>'
+            '<id key="{}" local-id="{}" type="{}" />'
+            '<version>{}</version>'
+            '</model>'
+            '<model>'
+            '<id key="{}" local-id="{}" type="{}" />'
+            '<version>{}</version>'
+            '</model>'
+            '</models>'.format(
+                post.global_id.key,
+                post.global_id.local_id,
+                post.global_id.key_type,
+                post.version,
+                post2.global_id.key,
+                post2.global_id.local_id,
+                post2.global_id.key_type,
+                post2.version,
+            ) in response_all,
+            'Wrong response generated for the LIST request for all posts.')
+
+    def test_list_existing_thread(self):
+        key = KeyPair.objects.generate_key(primary=True)
+        tag = Tag.objects.create(name='tag1')
+        post = Post.objects.create_post(title='test_title',
+                                        text='test_text\rline two',
+                                        tags=[tag])
+        post2 = Post.objects.create_post(title='test title 2',
+                                         text='test text 2',
+                                         tags=[tag])
+
+        request_thread = MockRequest()
+        request_thread.body = (
+            '<request type="list" version="1.0">'
+            '<model name="post" version="1.0">'
+            '<thread>{}</thread>'
+            '</model>'
+            '</request>'.format(
+                post.id,
+            )
+        )
+
+        response_thread = response_list(request_thread).content.decode()
+        self.assertTrue(
+            '<status>success</status>'
+            '<models>'
+            '<model>'
+            '<id key="{}" local-id="{}" type="{}" />'
+            '<version>{}</version>'
+            '</model>'
+            '</models>'.format(
+                post.global_id.key,
+                post.global_id.local_id,
+                post.global_id.key_type,
+                post.version,
+            ) in response_thread,
+            'Wrong response generated for the LIST request for posts of '
+            'existing thread.')
+
+    def test_list_non_existing_thread(self):
+        key = KeyPair.objects.generate_key(primary=True)
+        tag = Tag.objects.create(name='tag1')
+        post = Post.objects.create_post(title='test_title',
+                                        text='test_text\rline two',
+                                        tags=[tag])
+        post2 = Post.objects.create_post(title='test title 2',
+                                         text='test text 2',
+                                         tags=[tag])
+
+        request_thread = MockRequest()
+        request_thread.body = (
+            '<request type="list" version="1.0">'
+            '<model name="post" version="1.0">'
+            '<thread>{}</thread>'
+            '</model>'
+            '</request>'.format(
+                0,
+            )
+        )
+
+        response_thread = response_list(request_thread).content.decode()
+        self.assertTrue(
+            '<status>success</status>'
+            '<models />'
+            in response_thread,
+            'Wrong response generated for the LIST request for posts of '
+            'non-existing thread.')

boards/views/sync.py

@@ -1,55 +1,79 b''
+import logging
+
 import xml.etree.ElementTree as et
 
 from django.http import HttpResponse, Http404
+
+from boards.abstracts.sync_filters import ThreadFilter, TAG_THREAD
 from boards.models import GlobalId, Post
 from boards.models.post.sync import SyncManager
 
 
+logger = logging.getLogger('boards.sync')
+
+
+FILTERS = {
+        TAG_THREAD: ThreadFilter,
+}
+
+
 def response_list(request):
     request_xml = request.body
 
+    filters = []
+
     if request_xml is None or len(request_xml) == 0:
         return HttpResponse(content='Use the API')
+    else:
+        root_tag = et.fromstring(request_xml)
+        model_tag = root_tag[0]
 
-    response_xml = SyncManager.generate_response_list()
+        for tag_filter in model_tag:
+            filter_name = tag_filter.tag
+            model_filter = FILTERS.get(filter_name)(tag_filter)
+            if not model_filter:
+                logger.warning('Unavailable filter: {}'.format(filter_name))
+            filters.append(model_filter)
+
+    response_xml = SyncManager.generate_response_list(filters)
 
     return HttpResponse(content=response_xml)
 
 
 def response_get(request):
     """
     Processes a GET request with post ID list and returns the posts XML list.
     Request should contain an 'xml' post attribute with the actual request XML.
     """
 
     request_xml = request.body
 
     if request_xml is None or len(request_xml) == 0:
         return HttpResponse(content='Use the API')
 
     posts = []
 
     root_tag = et.fromstring(request_xml)
     model_tag = root_tag[0]
     for id_tag in model_tag:
         global_id, exists = GlobalId.from_xml_element(id_tag)
         if exists:
             posts.append(Post.objects.get(global_id=global_id))
 
     response_xml = SyncManager.generate_response_get(posts)
 
     return HttpResponse(content=response_xml)
 
 
 def get_post_sync_data(request, post_id):
     try:
         post = Post.objects.get(id=post_id)
     except Post.DoesNotExist:
         raise Http404()
 
     xml_str = SyncManager.generate_response_get([post])
 
     return HttpResponse(
         content_type='text/xml; charset=utf-8',
         content=xml_str,
     )

readme.markdown

@@ -1,66 +1,66 b''
 # INTRO #
 
 This project aims to create centralized forum-like discussion platform with
 anonymity in mind.
 
 Main repository: https://bitbucket.org/neko259/neboard/
 
 Site: http://neboard.me/
 
 # INSTALLATION #
 
 1. Download application and move inside it:
 
 `hg clone https://bitbucket.org/neko259/neboard`
 
 `cd neboard`
 
 2. Install all application dependencies:
 
 Some minimal system-wide depenencies:
 
 * python3
 * pip/pip3
 * jpeg
 
 Python dependencies:
 
 `pip3 install -r requirements.txt`
 
 You can use virtualenv to speed up the process or avoid conflicts.
 
 3. Setup a database in `neboard/settings.py`. You can also change other settings like search engine.
 
 Depending on configured database and search engine, you need to install corresponding dependencies manually.
 
-Default database is *sqlite*, default search engine is *simple*.
+Default database is *sqlite*. If you want to change the database backend, refer to the django documentation for the correct settings. Please note that sqlite accepts only one connection at a time, so you won't be able to run 2 servers or a server and a sync at the same time.
 
 4. Setup SECRET_KEY to a secret value in `neboard/settings.py
 5. Run `./manage.py migrate` to apply all migrations
-6. Apply config changes to `boards/config/config.ini`. You can see the default settings in `boards/config/default_config.ini`
+6. Apply config changes to `boards/config/settings.ini`. You can see the default settings in `boards/config/default_config.ini`(do not delete or overwrite it).
 7. If you want to use decetral engine, run `./manage.py generate_keypair` to generate keys
 
 # RUNNING #
 
 You can run the server using django default embedded webserver by running:
 
     ./manage.py runserver <address>:<port>
 
 See django-admin command help for details.
 
 Also consider using wsgi or fcgi interfaces on production servers.
 
 When running for the first time, you need to setup at least one section tag.
 Go to the admin page and manually create one tag with "required" property set.
 
 # UPGRADE #
 
 1. Backup your project data.
 2. Copy the project contents over the old project directory
 3. Run migrations by `./manage.py migrate`
 
 You can also just clone the mercurial project and pull it to update
 
 # CONCLUSION #
 
 Enjoy our software and thank you!