Added signatures to the GET response. Added a view to get a full post response for one post. Don't show post key as it is present in the XML post view. Changed key display format

boards/models/post.py

@@ -1,491 +1,518 b''
 from datetime import datetime, timedelta, date
 from datetime import time as dtime
 import logging
 import re
 import xml.etree.ElementTree as et
 
 from django.core.cache import cache
 from django.core.urlresolvers import reverse
 from django.db import models, transaction
 from django.template.loader import render_to_string
 from django.utils import timezone
 
 from markupfield.fields import MarkupField
 
-from boards.models import PostImage, KeyPair, GlobalId
+from boards.models import PostImage, KeyPair, GlobalId, Signature
 from boards.models.base import Viewable
 from boards.models.thread import Thread
 from boards import utils
 
 
 APP_LABEL_BOARDS = 'boards'
 
 CACHE_KEY_PPD = 'ppd'
 CACHE_KEY_POST_URL = 'post_url'
 
 POSTS_PER_DAY_RANGE = 7
 
 BAN_REASON_AUTO = 'Auto'
 
 IMAGE_THUMB_SIZE = (200, 150)
 
 TITLE_MAX_LENGTH = 200
 
 DEFAULT_MARKUP_TYPE = 'bbcode'
 
 # TODO This should be removed
 NO_IP = '0.0.0.0'
 
 # TODO Real user agent should be saved instead of this
 UNKNOWN_UA = ''
 
 REGEX_REPLY = re.compile(r'\[post\](\d+)\[/post\]')
 
 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_EDIT_TIME = 'edit-time'
 TAG_PREVIOUS = 'previous'
 TAG_NEXT = 'next'
+TAG_SIGNATURES = 'signatures'
+TAG_SIGNATURE = 'signature'
 
 TYPE_GET = 'get'
 
 ATTR_VERSION = 'version'
 ATTR_TYPE = 'type'
 ATTR_NAME = 'name'
 ATTR_REF_ID = 'ref-id'
+ATTR_MODEL_REF = 'model-ref'
+ATTR_VALUE = 'value'
 
 STATUS_SUCCESS = 'success'
 
 logger = logging.getLogger(__name__)
 
 
 class PostManager(models.Manager):
     def create_post(self, title, text, image=None, thread=None, ip=NO_IP,
                     tags=None):
         """
         Creates new post
         """
 
         if not tags:
             tags = []
 
         posting_time = timezone.now()
         if not thread:
             thread = Thread.objects.create(bump_time=posting_time,
                                            last_edit_time=posting_time)
             new_thread = True
         else:
             thread.bump()
             thread.last_edit_time = posting_time
             thread.save()
             new_thread = False
 
         post = self.create(title=title,
                            text=text,
                            pub_time=posting_time,
                            thread_new=thread,
                            poster_ip=ip,
                            poster_user_agent=UNKNOWN_UA,  # TODO Get UA at
                            # last!
                            last_edit_time=posting_time)
 
         post.set_global_id()
 
         if image:
             post_image = PostImage.objects.create(image=image)
             post.images.add(post_image)
             logger.info('Created image #%d for post #%d' % (post_image.id,
                                                             post.id))
 
         thread.replies.add(post)
         list(map(thread.add_tag, tags))
 
         if new_thread:
             Thread.objects.process_oldest_threads()
         self.connect_replies(post)
 
         logger.info('Created post #%d with title %s'
                     % (post.id, post.get_title()))
 
         return post
 
     def delete_post(self, post):
         """
         Deletes post and update or delete its thread
         """
 
         post_id = post.id
 
         thread = post.get_thread()
 
         if post.is_opening():
             thread.delete()
         else:
             thread.last_edit_time = timezone.now()
             thread.save()
 
             post.delete()
 
         logger.info('Deleted post #%d (%s)' % (post_id, post.get_title()))
 
     def delete_posts_by_ip(self, ip):
         """
         Deletes all posts of the author with same IP
         """
 
         posts = self.filter(poster_ip=ip)
         for post in posts:
             self.delete_post(post)
 
     def connect_replies(self, post):
         """
         Connects replies to a post to show them as a reflink map
         """
 
         for reply_number in post.get_replied_ids():
             ref_post = self.filter(id=reply_number)
             if ref_post.count() > 0:
                 referenced_post = ref_post[0]
                 referenced_post.referenced_posts.add(post)
                 referenced_post.last_edit_time = post.pub_time
                 referenced_post.build_refmap()
                 referenced_post.save(update_fields=['refmap', 'last_edit_time'])
 
                 referenced_thread = referenced_post.get_thread()
                 referenced_thread.last_edit_time = post.pub_time
                 referenced_thread.save(update_fields=['last_edit_time'])
 
     def get_posts_per_day(self):
         """
         Gets average count of posts per day for the last 7 days
         """
 
         day_end = date.today()
         day_start = day_end - timedelta(POSTS_PER_DAY_RANGE)
 
         cache_key = CACHE_KEY_PPD + str(day_end)
         ppd = cache.get(cache_key)
         if ppd:
             return ppd
 
         day_time_start = timezone.make_aware(datetime.combine(
             day_start, dtime()), timezone.get_current_timezone())
         day_time_end = timezone.make_aware(datetime.combine(
             day_end, dtime()), timezone.get_current_timezone())
 
         posts_per_period = float(self.filter(
             pub_time__lte=day_time_end,
             pub_time__gte=day_time_start).count())
 
         ppd = posts_per_period / POSTS_PER_DAY_RANGE
 
         cache.set(cache_key, ppd)
         return ppd
 
-
     def generate_request_get(self, model_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 post in model_list:
             tag_id = et.SubElement(model, TAG_ID)
             post.global_id.to_xml_element(tag_id)
 
         return et.tostring(request, 'unicode')
 
     def generate_response_get(self, model_list: list):
         response = et.Element(TAG_RESPONSE)
 
         status = et.SubElement(response, TAG_STATUS)
         status.text = STATUS_SUCCESS
 
         models = et.SubElement(response, TAG_MODELS)
+        signatures = {}
 
         ref_id = 1
         for post in model_list:
             model = et.SubElement(models, TAG_MODEL)
             model.set(ATTR_NAME, 'post')
             model.set(ATTR_REF_ID, str(ref_id))
-            ref_id += 1
 
             tag_id = et.SubElement(model, TAG_ID)
             post.global_id.to_xml_element(tag_id)
 
             title = et.SubElement(model, TAG_TITLE)
             title.text = post.title
 
             text = et.SubElement(model, TAG_TEXT)
             text.text = post.text.raw
 
             if not post.is_opening():
                 thread = et.SubElement(model, TAG_THREAD)
                 thread.text = str(post.get_thread().get_opening_post_id())
 
             pub_time = et.SubElement(model, TAG_PUB_TIME)
             pub_time.text = str(post.get_pub_time_epoch())
 
             edit_time = et.SubElement(model, TAG_EDIT_TIME)
             edit_time.text = str(post.get_edit_time_epoch())
 
             previous_ids = post.get_replied_ids()
             if len(previous_ids) > 0:
                 previous = et.SubElement(model, TAG_PREVIOUS)
                 for id in previous_ids:
                     prev_id = et.SubElement(previous, TAG_ID)
                     replied_post = Post.objects.get(id=id)
                     replied_post.global_id.to_xml_element(prev_id)
 
-
             next_ids = post.referenced_posts.order_by('id').all()
             if len(next_ids) > 0:
                 next_el = et.SubElement(model, TAG_NEXT)
                 for ref_post in next_ids:
                     next_id = et.SubElement(next_el, TAG_ID)
                     ref_post.global_id.to_xml_element(next_id)
 
+            post_signatures = post.signature.all()
+            if post_signatures:
+                signatures[ref_id] = post.signatures
+            else:
+                # TODO Maybe the signature can be computed only once after
+                # the post is added? Need to add some on_save signal queue
+                # and add this there.
+                key = KeyPair.objects.get(public_key=post.global_id.key)
+                signatures[ref_id] = [Signature(
+                    key_type=key.key_type,
+                    key=key.public_key,
+                    signature=key.sign(et.tostring(model, 'unicode')),
+                    )]
+            ref_id += 1
+
+        signatures_tag = et.SubElement(response, TAG_SIGNATURES)
+        for ref_id in signatures.keys():
+            signatures = signatures[ref_id]
+
+            for signature in signatures:
+                signature_tag = et.SubElement(signatures_tag, TAG_SIGNATURE)
+                signature_tag.set(ATTR_MODEL_REF, str(ref_id))
+                signature_tag.set(ATTR_TYPE, signature.key_type)
+                signature_tag.set(ATTR_VALUE, signature.signature)
+
         return et.tostring(response, 'unicode')
 
 
 class Post(models.Model, Viewable):
     """A post is a message."""
 
     objects = PostManager()
 
     class Meta:
         app_label = APP_LABEL_BOARDS
         ordering = ('id',)
 
     title = models.CharField(max_length=TITLE_MAX_LENGTH)
     pub_time = models.DateTimeField()
     text = MarkupField(default_markup_type=DEFAULT_MARKUP_TYPE,
                        escape_html=False)
 
     images = models.ManyToManyField(PostImage, null=True, blank=True,
                                     related_name='ip+', db_index=True)
 
     poster_ip = models.GenericIPAddressField()
     poster_user_agent = models.TextField()
 
     thread_new = models.ForeignKey('Thread', null=True, default=None,
                                    db_index=True)
     last_edit_time = models.DateTimeField()
 
     # Replies to the post
     referenced_posts = models.ManyToManyField('Post', symmetrical=False,
                                               null=True,
                                               blank=True, related_name='rfp+',
                                               db_index=True)
 
     # Replies map. This is built from the referenced posts list to speed up
     # page loading (no need to get all the referenced posts from the database).
     refmap = models.TextField(null=True, blank=True)
 
     # 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)
 
     # One post can be signed by many nodes that give their trust to it
     signature = models.ManyToManyField('Signature', null=True, blank=True)
 
     def __unicode__(self):
         return '#' + str(self.id) + ' ' + self.title + ' (' + \
                self.text.raw[:50] + ')'
 
     def get_title(self):
         """
         Gets original post title or part of its text.
         """
 
         title = self.title
         if not title:
             title = self.text.rendered
 
         return title
 
     def build_refmap(self):
         """
         Builds a replies map string from replies list. This is a cache to stop
         the server from recalculating the map on every post show.
         """
         map_string = ''
 
         first = True
         for refpost in self.referenced_posts.all():
             if not first:
                 map_string += ', '
             map_string += '<a href="%s">&gt;&gt;%s</a>' % (refpost.get_url(),
                                                            refpost.id)
             first = False
 
         self.refmap = map_string
 
     def get_sorted_referenced_posts(self):
         return self.refmap
 
     def is_referenced(self):
         return len(self.refmap) > 0
 
     def is_opening(self):
         """
         Checks if this is an opening post or just a reply.
         """
 
         return self.get_thread().get_opening_post_id() == self.id
 
     @transaction.atomic
     def add_tag(self, tag):
         edit_time = timezone.now()
 
         thread = self.get_thread()
         thread.add_tag(tag)
         self.last_edit_time = edit_time
         self.save(update_fields=['last_edit_time'])
 
         thread.last_edit_time = edit_time
         thread.save(update_fields=['last_edit_time'])
 
     @transaction.atomic
     def remove_tag(self, tag):
         edit_time = timezone.now()
 
         thread = self.get_thread()
         thread.remove_tag(tag)
         self.last_edit_time = edit_time
         self.save(update_fields=['last_edit_time'])
 
         thread.last_edit_time = edit_time
         thread.save(update_fields=['last_edit_time'])
 
     def get_url(self, thread=None):
         """
         Gets full url to the post.
         """
 
         cache_key = CACHE_KEY_POST_URL + str(self.id)
         link = cache.get(cache_key)
 
         if not link:
             if not thread:
                 thread = self.get_thread()
 
             opening_id = thread.get_opening_post_id()
 
             if self.id != opening_id:
                 link = reverse('thread', kwargs={
                     'post_id': opening_id}) + '#' + str(self.id)
             else:
                 link = reverse('thread', kwargs={'post_id': self.id})
 
             cache.set(cache_key, link)
 
         return link
 
     def get_thread(self):
         """
         Gets post's thread.
         """
 
         return self.thread_new
 
     def get_referenced_posts(self):
         return self.referenced_posts.only('id', 'thread_new')
 
     def get_text(self):
         return self.text
 
     def get_view(self, moderator=False, need_open_link=False,
                  truncated=False, *args, **kwargs):
         if 'is_opening' in kwargs:
             is_opening = kwargs['is_opening']
         else:
             is_opening = self.is_opening()
 
         if 'thread' in kwargs:
             thread = kwargs['thread']
         else:
             thread = self.get_thread()
 
         if 'can_bump' in kwargs:
             can_bump = kwargs['can_bump']
         else:
             can_bump = thread.can_bump()
 
         if is_opening:
             opening_post_id = self.id
         else:
             opening_post_id = thread.get_opening_post_id()
 
         return render_to_string('boards/post.html', {
             'post': self,
             'moderator': moderator,
             'is_opening': is_opening,
             'thread': thread,
             'bumpable': can_bump,
             'need_open_link': need_open_link,
             'truncated': truncated,
             'opening_post_id': opening_post_id,
         })
 
     def get_first_image(self):
         return self.images.earliest('id')
 
     def delete(self, using=None):
         """
         Deletes all post images and the post itself.
         """
 
         self.images.all().delete()
         self.signature.all().delete()
         if self.global_id:
             self.global_id.delete()
 
         super(Post, self).delete(using)
 
     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_epoch(self):
         return utils.datetime_to_epoch(self.pub_time)
 
     def get_edit_time_epoch(self):
         return utils.datetime_to_epoch(self.last_edit_time)
 
     def get_replied_ids(self):
         return re.findall(REGEX_REPLY, self.text.raw)

boards/models/signature.py

@@ -1,67 +1,75 b''
 import xml.etree.ElementTree as et
 from django.db import models
 
 
 ATTR_KEY = 'key'
 ATTR_KEY_TYPE = 'type'
 ATTR_LOCAL_ID = 'local-id'
 
 
 class GlobalId(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 '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()
 
     def __str__(self):
-        return '%s | %s | %d' % (self.key_type, self.key, self.local_id)
+        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, existing=False):
         """
         Parses XML id tag and gets global id from it.
 
         Arguments:
         element -- the XML 'id' element
         existing -- if this is False, a new instance of GlobalId will be
          created. Otherwise, we will search for an existing GlobalId instance
          and throw DoesNotExist if there isn't one.
         """
 
         if existing:
             return GlobalId.objects.get(key=element.get(ATTR_KEY),
                                         key_type=element.get(ATTR_KEY_TYPE),
                                         local_id=int(element.get(
                                             ATTR_LOCAL_ID)))
         else:
             return GlobalId(key=element.get(ATTR_KEY),
                             key_type=element.get(ATTR_KEY_TYPE),
                             local_id=int(element.get(ATTR_LOCAL_ID)))
 
 
 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()

boards/models/sync_key.py

@@ -1,61 +1,61 b''
 import base64
 from ecdsa import SigningKey, VerifyingKey, BadSignatureError
 from django.db import models
 
 TYPE_ECDSA = 'ecdsa'
 
 APP_LABEL_BOARDS = 'boards'
 
 
 class KeyPairManager(models.Manager):
     def generate_key(self, key_type=TYPE_ECDSA, primary=False):
         if primary and self.filter(primary=True).exists():
             raise Exception('There can be only one primary key')
 
         if key_type == TYPE_ECDSA:
             private = SigningKey.generate()
             public = private.get_verifying_key()
 
             private_key_str = base64.b64encode(private.to_string()).decode()
             public_key_str = base64.b64encode(public.to_string()).decode()
 
             return self.create(public_key=public_key_str,
                                private_key=private_key_str,
                                key_type=TYPE_ECDSA, primary=primary)
         else:
             raise Exception('Key type not supported')
 
     def verify(self, public_key_str, string, signature, key_type=TYPE_ECDSA):
         if key_type == TYPE_ECDSA:
             public = VerifyingKey.from_string(base64.b64decode(public_key_str))
             signature_byte = base64.b64decode(signature)
             try:
                 return public.verify(signature_byte, string.encode())
             except BadSignatureError:
                 return False
         else:
             raise Exception('Key type not supported')
 
     def has_primary(self):
         return self.filter(primary=True).exists()
 
 
 class KeyPair(models.Model):
     class Meta:
         app_label = APP_LABEL_BOARDS
 
     objects = KeyPairManager()
 
     public_key = models.TextField()
     private_key = models.TextField()
     key_type = models.TextField()
     primary = models.BooleanField(default=False)
 
     def __str__(self):
-        return '%s | %s' % (self.key_type, self.public_key)
+        return '[%s][%s]' % (self.key_type, self.public_key)
 
     def sign(self, string):
         private = SigningKey.from_string(base64.b64decode(
             self.private_key.encode()))
-        signature_byte = private.sign(string.encode())
-        return base64.b64encode(signature_byte)
+        signature_byte = private.sign_deterministic(string.encode())
+        return base64.b64encode(signature_byte).decode()

boards/templates/boards/post.html

@@ -1,103 +1,104 b''
 {% load i18n %}
 {% load board %}
 {% load cache %}
 
 {% get_current_language as LANGUAGE_CODE %}
 
 {% spaceless %}
     {% cache 600 post post.id post.last_edit_time thread.archived bumpable truncated moderator LANGUAGE_CODE need_open_link %}
         {% if thread.archived %}
             <div class="post archive_post" id="{{ post.id }}">
         {% elif bumpable %}
             <div class="post" id="{{ post.id }}">
         {% else %}
             <div class="post dead_post" id="{{ post.id }}">
         {% endif %}
 
         <div class="post-info">
             <a class="post_id" href="{% post_object_url post thread=thread %}"
                 {% if not truncated and not thread.archived %}
                     onclick="javascript:addQuickReply('{{ post.id }}'); return false;"
                     title="{% trans 'Quote' %}"
                 {% endif %}
                 >({{ post.id }}) </a>
             <span class="title">{{ post.title }} </span>
             <span class="pub_time">{{ post.pub_time }}</span>
             {% if thread.archived %}
                 — {{ thread.bump_time }}
             {% endif %}
             {% if is_opening and need_open_link %}
                 {% if thread.archived %}
                     [<a class="link" href="{% url 'thread' post.id %}">{% trans "Open" %}</a>]
                 {% else %}
                     [<a class="link" href="{% url 'thread' post.id %}#form">{% trans "Reply" %}</a>]
                 {% endif %}
             {% endif %}
 
             {% if post.global_id %}
-                <span class="global-id"> {{ post.global_id }} </span>
+                <a class="global-id" href="
+                {% url 'post_sync_data' post.id %}"> [RAW] </a>
             {% endif %}
 
             {% if moderator %}
                 <span class="moderator_info">
                     [<a href="{% url 'post_admin' post_id=post.id %}"
                         >{% trans 'Edit' %}</a>]
                     [<a href="{% url 'delete' post_id=post.id %}"
                         >{% trans 'Delete' %}</a>]
                     ({{ post.poster_ip }})
                     [<a href="{% url 'ban' post_id=post.id %}?next={{ request.path }}"
                         >{% trans 'Ban IP' %}</a>]
                 </span>
             {% endif %}
         </div>
         {% if post.images.exists %}
             {% with post.images.all.0 as image %}
             <div class="image">
                 <a
                         class="thumb"
                         href="{{ image.image.url }}"><img
                         src="{{ image.image.url_200x150 }}"
                         alt="{{ post.id }}"
                         width="{{ image.pre_width }}"
                         height="{{ image.pre_height }}"
                         data-width="{{ image.width }}"
                         data-height="{{ image.height }}"/>
                 </a>
             </div>
             {% endwith %}
         {% endif %}
         <div class="message">
             {% autoescape off %}
                 {% if truncated %}
                     {{ post.text.rendered|truncatewords_html:50 }}
                 {% else %}
                     {{ post.text.rendered }}
                 {% endif %}
             {% endautoescape %}
             {% if post.is_referenced %}
                 <div class="refmap">
                     {% autoescape off %}
                         {% trans "Replies" %}: {{ post.refmap }}
                     {% endautoescape %}
                 </div>
             {% endif %}
         </div>
     {% endcache %}
         {% if is_opening %}
         {% cache 600 post_thread thread.id thread.last_edit_time LANGUAGE_CODE need_open_link %}
             <div class="metadata">
                 {% if is_opening and need_open_link %}
                     {{ thread.get_reply_count }} {% trans 'messages' %},
                     {{ thread.get_images_count }} {% trans 'images' %}.
                 {% endif %}
                 <span class="tags">
                     {% for tag in thread.get_tags %}
                         <a class="tag" href="{% url 'tag' tag.name %}">
                             #{{ tag.name }}</a>{% if not forloop.last %},{% endif %}
                     {% endfor %}
                 </span>
             </div>
         {% endcache %}
         {% endif %}
         </div>
 {% endspaceless %}

boards/tests/test_keys.py

@@ -1,95 +1,103 b''
+from base64 import b64encode
 import logging
 
 from django.test import TestCase
 from boards.models import KeyPair, GlobalId, Post
 
 
 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 = key.sign(message)
         valid = KeyPair.objects.verify(key.public_key, message, signature,
                                        key_type='ecdsa')
 
         self.assertTrue(valid, 'Message verification failed.')
 
     def test_primary_constraint(self):
         KeyPair.objects.generate_key(key_type='ecdsa', primary=True)
 
         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 = Post.objects.generate_request_get([post])
         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="pubkey" local-id="1" type="test_key_type" />'
+                        '<id key="%s" local-id="1" type="%s" />'
                         '</model>'
-                        '</request>' in request,
+                        '</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())
         reply_reply_post = Post.objects.create_post(title='',
                                                     text='[post]%d[/post]'
                                                          % reply_post.id,
                                                     thread=post.get_thread())
 
         response = Post.objects.generate_response_get([reply_post])
         logger.debug(response)
 
-        self.assertTrue('<response>'
-                        '<status>success</status>'
+        key = KeyPair.objects.get(primary=True)
+        self.assertTrue('<status>success</status>'
                         '<models>'
                         '<model name="post" ref-id="1">'
-                        '<id key="pubkey" local-id="%d" type="test_key_type" />'
+                        '<id key="%s" local-id="%d" type="%s" />'
                         '<title>test_title</title>'
                         '<text>[post]%d[/post]</text>'
                         '<thread>%d</thread>'
                         '<pub-time>%s</pub-time>'
                         '<edit-time>%s</edit-time>'
                         '<previous>'
-                        '<id key="pubkey" local-id="%d" type="test_key_type" />'
+                        '<id key="%s" local-id="%d" type="%s" />'
                         '</previous>'
                         '<next>'
-                        '<id key="pubkey" local-id="%d" type="test_key_type" />'
+                        '<id key="%s" local-id="%d" type="%s" />'
                         '</next>'
                         '</model>'
-                        '</models>'
-                        '</response>' % (
+                        '</models>' % (
+                            key.public_key,
                             reply_post.id,
+                            key.key_type,
                             post.id,
                             post.id,
                             str(reply_post.get_edit_time_epoch()),
                             str(reply_post.get_pub_time_epoch()),
+                            key.public_key,
                             post.id,
+                            key.key_type,
+                            key.public_key,
                             reply_reply_post.id,
+                            key.key_type,
                         ) in response,
                         'Wrong XML generated for the GET response.')
 
     def _create_post_with_key(self):
-        key = KeyPair(public_key='pubkey', private_key='privkey',
-                      key_type='test_key_type', primary=True)
-        key.save()
+        KeyPair.objects.generate_key(primary=True)
 
         return Post.objects.create_post(title='test_title', text='test_text')

boards/tests/test_sync.py

@@ -1,55 +1,50 b''
 from boards.models import KeyPair, Post
 from boards.tests.mocks import MockRequest
 from boards.views.sync import respond_get
 
 __author__ = 'neko259'
 
 
 from django.test import TestCase
 
 
 class SyncTest(TestCase):
     def test_get(self):
         """
         Forms a GET request of a post and checks the response.
         """
 
-        key = KeyPair(public_key='pubkey', private_key='privkey',
-                      key_type='test_key_type', primary=True)
-        key.save()
-
+        KeyPair.objects.generate_key(primary=True)
         post = Post.objects.create_post(title='test_title', text='test_text')
 
         request = MockRequest()
         request.POST['xml'] = (
             '<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)
         )
 
         self.assertTrue(
-            '<response>'
             '<status>success</status>'
             '<models>'
             '<model name="post" ref-id="1">'
             '<id key="%s" local-id="%d" type="%s" />'
             '<title>%s</title>'
             '<text>%s</text>'
             '<pub-time>%d</pub-time>'
             '<edit-time>%d</edit-time>'
             '</model>'
-            '</models>'
-            '</response>' % (
+            '</models>' % (
                 post.global_id.key,
                 post.id,
                 post.global_id.key_type,
                 post.title,
                 post.text.raw,
                 post.get_pub_time_epoch(),
                 post.get_edit_time_epoch(),
             ) in respond_get(request).content.decode(),
             'Wrong response generated for the GET request.')
  No newline at end of file

boards/urls.py

@@ -1,83 +1,87 b''
 from django.conf.urls import patterns, url, include
 from django.contrib import admin
 from boards import views
 from boards.rss import AllThreadsFeed, TagThreadsFeed, ThreadPostsFeed
 from boards.views import api, tag_threads, all_threads, \
     settings, all_tags
 from boards.views.authors import AuthorsView
 from boards.views.delete_post import DeletePostView
 from boards.views.ban import BanUserView
 from boards.views.search import BoardSearchView
 from boards.views.static import StaticPageView
 from boards.views.post_admin import PostAdminView
 from boards.views.preview import PostPreviewView
+from boards.views.sync import get_post_sync_data
 
 js_info_dict = {
     'packages': ('boards',),
 }
 
 urlpatterns = patterns('',
     # /boards/
     url(r'^$', all_threads.AllThreadsView.as_view(), name='index'),
     # /boards/page/
     url(r'^page/(?P<page>\w+)/$', all_threads.AllThreadsView.as_view(),
         name='index'),
 
     # /boards/tag/tag_name/
     url(r'^tag/(?P<tag_name>\w+)/$', tag_threads.TagView.as_view(),
         name='tag'),
     # /boards/tag/tag_id/page/
     url(r'^tag/(?P<tag_name>\w+)/page/(?P<page>\w+)/$',
         tag_threads.TagView.as_view(), name='tag'),
 
     # /boards/thread/
     url(r'^thread/(?P<post_id>\w+)/$', views.thread.ThreadView.as_view(),
         name='thread'),
     url(r'^thread/(?P<post_id>\w+)/mode/(?P<mode>\w+)/$', views.thread.ThreadView
         .as_view(), name='thread_mode'),
 
     # /boards/post_admin/
     url(r'^post_admin/(?P<post_id>\w+)/$', PostAdminView.as_view(),
             name='post_admin'),
 
     url(r'^settings/$', settings.SettingsView.as_view(), name='settings'),
     url(r'^tags/$', all_tags.AllTagsView.as_view(), name='tags'),
     url(r'^authors/$', AuthorsView.as_view(), name='authors'),
     url(r'^delete/(?P<post_id>\w+)/$', DeletePostView.as_view(),
             name='delete'),
     url(r'^ban/(?P<post_id>\w+)/$', BanUserView.as_view(), name='ban'),
 
     url(r'^banned/$', views.banned.BannedView.as_view(), name='banned'),
     url(r'^staticpage/(?P<name>\w+)/$', StaticPageView.as_view(),
         name='staticpage'),
 
     # RSS feeds
     url(r'^rss/$', AllThreadsFeed()),
     url(r'^page/(?P<page>\w+)/rss/$', AllThreadsFeed()),
     url(r'^tag/(?P<tag_name>\w+)/rss/$', TagThreadsFeed()),
     url(r'^tag/(?P<tag_name>\w+)/page/(?P<page>\w+)/rss/$', TagThreadsFeed()),
     url(r'^thread/(?P<post_id>\w+)/rss/$', ThreadPostsFeed()),
 
     # i18n
     url(r'^jsi18n/$', 'boards.views.cached_js_catalog', js_info_dict,
         name='js_info_dict'),
 
     # API
     url(r'^api/post/(?P<post_id>\w+)/$', api.get_post, name="get_post"),
     url(r'^api/diff_thread/(?P<thread_id>\w+)/(?P<last_update_time>\w+)/$',
         api.api_get_threaddiff, name="get_thread_diff"),
     url(r'^api/threads/(?P<count>\w+)/$', api.api_get_threads,
             name='get_threads'),
     url(r'^api/tags/$', api.api_get_tags, name='get_tags'),
     url(r'^api/thread/(?P<opening_post_id>\w+)/$', api.api_get_thread_posts,
             name='get_thread'),
     url(r'^api/add_post/(?P<opening_post_id>\w+)/$', api.api_add_post,
             name='add_post'),
 
     # Search
     url(r'^search/$', BoardSearchView.as_view(), name='search'),
 
     # Post preview
-    url(r'^preview/$', PostPreviewView.as_view(), name='preview')
+    url(r'^preview/$', PostPreviewView.as_view(), name='preview'),
+
+    url(r'^post_xml/(?P<post_id>\d+)$', get_post_sync_data,
+        name='post_sync_data'),
 
 )

boards/views/sync.py

@@ -1,33 +1,49 b''
 import xml.etree.ElementTree as et
-from django.http import HttpResponse
+from django.http import HttpResponse, Http404
 from boards.models import GlobalId, Post
 
 
 def respond_pull(request):
     pass
 
 
 def respond_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.POST['xml']
 
     posts = []
 
     root_tag = et.fromstring(request_xml)
     model_tag = root_tag[0]
     for id_tag in model_tag:
         try:
             global_id = GlobalId.from_xml_element(id_tag, existing=True)
             posts += Post.objects.filter(global_id=global_id)
         except GlobalId.DoesNotExist:
             # This is normal. If we don't have such GlobalId in the system,
             # just ignore this ID and proceed to the next one.
             pass
 
     response_xml = Post.objects.generate_response_get(posts)
 
-    return HttpResponse(content=response_xml)
  No newline at end of file
+    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()
+
+    content = 'Global ID: %s\n\nXML: %s' \
+              % (post.global_id, Post.objects.generate_response_get([post]))
+
+
+    return HttpResponse(
+        content_type='text/plain',
+        content=content,
+    )
  No newline at end of file