Added ability to filter posts in the LIST request

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/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/models/post/sync.py

@@ -1,331 +1,378 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
 
 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)
                     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)
 
             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)
+
+    @staticmethod
+    def generate_request_get(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')
+
+    @staticmethod
+    def generate_request_list(opening_post=None):
+        """
+        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')
+
+        if opening_post:
+            ThreadFilter().add_filter(model, opening_post)
+
+        return et.tostring(request, 'unicode')
  No newline at end of file

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/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,
     )