Generate GET request and response (not full yet). Add global id to the posts

based on the primary key pair

boards/migrations/0034_auto__del_field_post_public_key__add_field_post_global_id.py

@@ -0,0 +1,90 b''
+# -*- coding: utf-8 -*-
+from south.utils import datetime_utils as datetime
+from south.db import db
+from south.v2 import SchemaMigration
+from django.db import models
+
+
+class Migration(SchemaMigration):
+
+    def forwards(self, orm):
+        # Deleting field 'Post.public_key'
+        db.delete_column('boards_post', 'public_key')
+
+        # Adding field 'Post.global_id'
+        db.add_column('boards_post', 'global_id',
+                      self.gf('django.db.models.fields.TextField')(null=True, blank=True),
+                      keep_default=False)
+
+
+    def backwards(self, orm):
+        # Adding field 'Post.public_key'
+        db.add_column('boards_post', 'public_key',
+                      self.gf('django.db.models.fields.TextField')(null=True, blank=True),
+                      keep_default=False)
+
+        # Deleting field 'Post.global_id'
+        db.delete_column('boards_post', 'global_id')
+
+
+    models = {
+        'boards.ban': {
+            'Meta': {'object_name': 'Ban'},
+            'can_read': ('django.db.models.fields.BooleanField', [], {'default': 'True'}),
+            'id': ('django.db.models.fields.AutoField', [], {'primary_key': 'True'}),
+            'ip': ('django.db.models.fields.GenericIPAddressField', [], {'max_length': '39'}),
+            'reason': ('django.db.models.fields.CharField', [], {'max_length': '200', 'default': "'Auto'"})
+        },
+        'boards.keypair': {
+            'Meta': {'object_name': 'KeyPair'},
+            'id': ('django.db.models.fields.AutoField', [], {'primary_key': 'True'}),
+            'key_type': ('django.db.models.fields.TextField', [], {}),
+            'primary': ('django.db.models.fields.BooleanField', [], {'default': 'False'}),
+            'private_key': ('django.db.models.fields.TextField', [], {}),
+            'public_key': ('django.db.models.fields.TextField', [], {})
+        },
+        'boards.post': {
+            'Meta': {'ordering': "('id',)", 'object_name': 'Post'},
+            '_text_rendered': ('django.db.models.fields.TextField', [], {}),
+            'global_id': ('django.db.models.fields.TextField', [], {'null': 'True', 'blank': 'True'}),
+            'id': ('django.db.models.fields.AutoField', [], {'primary_key': 'True'}),
+            'images': ('django.db.models.fields.related.ManyToManyField', [], {'db_index': 'True', 'null': 'True', 'to': "orm['boards.PostImage']", 'related_name': "'ip+'", 'blank': 'True', 'symmetrical': 'False'}),
+            'last_edit_time': ('django.db.models.fields.DateTimeField', [], {}),
+            'poster_ip': ('django.db.models.fields.GenericIPAddressField', [], {'max_length': '39'}),
+            'poster_user_agent': ('django.db.models.fields.TextField', [], {}),
+            'pub_time': ('django.db.models.fields.DateTimeField', [], {}),
+            'referenced_posts': ('django.db.models.fields.related.ManyToManyField', [], {'db_index': 'True', 'null': 'True', 'to': "orm['boards.Post']", 'related_name': "'rfp+'", 'blank': 'True', 'symmetrical': 'False'}),
+            'refmap': ('django.db.models.fields.TextField', [], {'null': 'True', 'blank': 'True'}),
+            'text': ('markupfield.fields.MarkupField', [], {'rendered_field': 'True'}),
+            'text_markup_type': ('django.db.models.fields.CharField', [], {'max_length': '30', 'default': "'bbcode'"}),
+            'thread_new': ('django.db.models.fields.related.ForeignKey', [], {'null': 'True', 'default': 'None', 'to': "orm['boards.Thread']"}),
+            'title': ('django.db.models.fields.CharField', [], {'max_length': '200'})
+        },
+        'boards.postimage': {
+            'Meta': {'ordering': "('id',)", 'object_name': 'PostImage'},
+            'hash': ('django.db.models.fields.CharField', [], {'max_length': '36'}),
+            'height': ('django.db.models.fields.IntegerField', [], {'default': '0'}),
+            'id': ('django.db.models.fields.AutoField', [], {'primary_key': 'True'}),
+            'image': ('boards.thumbs.ImageWithThumbsField', [], {'max_length': '100', 'blank': 'True'}),
+            'pre_height': ('django.db.models.fields.IntegerField', [], {'default': '0'}),
+            'pre_width': ('django.db.models.fields.IntegerField', [], {'default': '0'}),
+            'width': ('django.db.models.fields.IntegerField', [], {'default': '0'})
+        },
+        'boards.tag': {
+            'Meta': {'ordering': "('name',)", 'object_name': 'Tag'},
+            'id': ('django.db.models.fields.AutoField', [], {'primary_key': 'True'}),
+            'name': ('django.db.models.fields.CharField', [], {'db_index': 'True', 'max_length': '100'}),
+            'threads': ('django.db.models.fields.related.ManyToManyField', [], {'null': 'True', 'to': "orm['boards.Thread']", 'symmetrical': 'False', 'blank': 'True', 'related_name': "'tag+'"})
+        },
+        'boards.thread': {
+            'Meta': {'object_name': 'Thread'},
+            'archived': ('django.db.models.fields.BooleanField', [], {'default': 'False'}),
+            'bump_time': ('django.db.models.fields.DateTimeField', [], {}),
+            'id': ('django.db.models.fields.AutoField', [], {'primary_key': 'True'}),
+            'last_edit_time': ('django.db.models.fields.DateTimeField', [], {}),
+            'replies': ('django.db.models.fields.related.ManyToManyField', [], {'null': 'True', 'to': "orm['boards.Post']", 'symmetrical': 'False', 'blank': 'True', 'related_name': "'tre+'"}),
+            'tags': ('django.db.models.fields.related.ManyToManyField', [], {'symmetrical': 'False', 'to': "orm['boards.Tag']"})
+        }
+    }
+
+    complete_apps = ['boards']
  No newline at end of file

boards/migrations/0035_auto__add_signature__add_globalid__chg_field_post_global_id__add_index.py

@@ -0,0 +1,147 b''
+# -*- coding: utf-8 -*-
+from south.utils import datetime_utils as datetime
+from south.db import db
+from south.v2 import SchemaMigration
+from django.db import models
+
+
+class Migration(SchemaMigration):
+
+    def forwards(self, orm):
+        # Adding model 'Signature'
+        db.create_table('boards_signature', (
+            ('id', self.gf('django.db.models.fields.AutoField')(primary_key=True)),
+            ('key_type', self.gf('django.db.models.fields.TextField')()),
+            ('key', self.gf('django.db.models.fields.TextField')()),
+            ('signature', self.gf('django.db.models.fields.TextField')()),
+        ))
+        db.send_create_signal('boards', ['Signature'])
+
+        # Adding model 'GlobalId'
+        db.create_table('boards_globalid', (
+            ('id', self.gf('django.db.models.fields.AutoField')(primary_key=True)),
+            ('key', self.gf('django.db.models.fields.TextField')()),
+            ('key_type', self.gf('django.db.models.fields.TextField')()),
+            ('local_id', self.gf('django.db.models.fields.IntegerField')()),
+        ))
+        db.send_create_signal('boards', ['GlobalId'])
+
+        # Adding M2M table for field signature on 'Post'
+        m2m_table_name = db.shorten_name('boards_post_signature')
+        db.create_table(m2m_table_name, (
+            ('id', models.AutoField(verbose_name='ID', primary_key=True, auto_created=True)),
+            ('post', models.ForeignKey(orm['boards.post'], null=False)),
+            ('signature', models.ForeignKey(orm['boards.signature'], null=False))
+        ))
+        db.create_unique(m2m_table_name, ['post_id', 'signature_id'])
+
+
+        # Renaming column for 'Post.global_id' to match new field type.
+        db.rename_column('boards_post', 'global_id', 'global_id_id')
+        # Changing field 'Post.global_id'
+        db.alter_column('boards_post', 'global_id_id', self.gf('django.db.models.fields.related.OneToOneField')(null=True, to=orm['boards.GlobalId'], unique=True))
+        # Adding index on 'Post', fields ['global_id']
+        db.create_index('boards_post', ['global_id_id'])
+
+        # Adding unique constraint on 'Post', fields ['global_id']
+        db.create_unique('boards_post', ['global_id_id'])
+
+
+    def backwards(self, orm):
+        # Removing unique constraint on 'Post', fields ['global_id']
+        db.delete_unique('boards_post', ['global_id_id'])
+
+        # Removing index on 'Post', fields ['global_id']
+        db.delete_index('boards_post', ['global_id_id'])
+
+        # Deleting model 'Signature'
+        db.delete_table('boards_signature')
+
+        # Deleting model 'GlobalId'
+        db.delete_table('boards_globalid')
+
+        # Removing M2M table for field signature on 'Post'
+        db.delete_table(db.shorten_name('boards_post_signature'))
+
+
+        # Renaming column for 'Post.global_id' to match new field type.
+        db.rename_column('boards_post', 'global_id_id', 'global_id')
+        # Changing field 'Post.global_id'
+        db.alter_column('boards_post', 'global_id', self.gf('django.db.models.fields.TextField')(null=True))
+
+    models = {
+        'boards.ban': {
+            'Meta': {'object_name': 'Ban'},
+            'can_read': ('django.db.models.fields.BooleanField', [], {'default': 'True'}),
+            'id': ('django.db.models.fields.AutoField', [], {'primary_key': 'True'}),
+            'ip': ('django.db.models.fields.GenericIPAddressField', [], {'max_length': '39'}),
+            'reason': ('django.db.models.fields.CharField', [], {'default': "'Auto'", 'max_length': '200'})
+        },
+        'boards.globalid': {
+            'Meta': {'object_name': 'GlobalId'},
+            'id': ('django.db.models.fields.AutoField', [], {'primary_key': 'True'}),
+            'key': ('django.db.models.fields.TextField', [], {}),
+            'key_type': ('django.db.models.fields.TextField', [], {}),
+            'local_id': ('django.db.models.fields.IntegerField', [], {})
+        },
+        'boards.keypair': {
+            'Meta': {'object_name': 'KeyPair'},
+            'id': ('django.db.models.fields.AutoField', [], {'primary_key': 'True'}),
+            'key_type': ('django.db.models.fields.TextField', [], {}),
+            'primary': ('django.db.models.fields.BooleanField', [], {'default': 'False'}),
+            'private_key': ('django.db.models.fields.TextField', [], {}),
+            'public_key': ('django.db.models.fields.TextField', [], {})
+        },
+        'boards.post': {
+            'Meta': {'object_name': 'Post', 'ordering': "('id',)"},
+            '_text_rendered': ('django.db.models.fields.TextField', [], {}),
+            'global_id': ('django.db.models.fields.related.OneToOneField', [], {'null': 'True', 'to': "orm['boards.GlobalId']", 'unique': 'True', 'blank': 'True'}),
+            'id': ('django.db.models.fields.AutoField', [], {'primary_key': 'True'}),
+            'images': ('django.db.models.fields.related.ManyToManyField', [], {'symmetrical': 'False', 'to': "orm['boards.PostImage']", 'blank': 'True', 'db_index': 'True', 'related_name': "'ip+'", 'null': 'True'}),
+            'last_edit_time': ('django.db.models.fields.DateTimeField', [], {}),
+            'poster_ip': ('django.db.models.fields.GenericIPAddressField', [], {'max_length': '39'}),
+            'poster_user_agent': ('django.db.models.fields.TextField', [], {}),
+            'pub_time': ('django.db.models.fields.DateTimeField', [], {}),
+            'referenced_posts': ('django.db.models.fields.related.ManyToManyField', [], {'symmetrical': 'False', 'to': "orm['boards.Post']", 'blank': 'True', 'db_index': 'True', 'related_name': "'rfp+'", 'null': 'True'}),
+            'refmap': ('django.db.models.fields.TextField', [], {'blank': 'True', 'null': 'True'}),
+            'signature': ('django.db.models.fields.related.ManyToManyField', [], {'null': 'True', 'to': "orm['boards.Signature']", 'symmetrical': 'False', 'blank': 'True'}),
+            'text': ('markupfield.fields.MarkupField', [], {'rendered_field': 'True'}),
+            'text_markup_type': ('django.db.models.fields.CharField', [], {'default': "'bbcode'", 'max_length': '30'}),
+            'thread_new': ('django.db.models.fields.related.ForeignKey', [], {'to': "orm['boards.Thread']", 'default': 'None', 'null': 'True'}),
+            'title': ('django.db.models.fields.CharField', [], {'max_length': '200'})
+        },
+        'boards.postimage': {
+            'Meta': {'object_name': 'PostImage', 'ordering': "('id',)"},
+            'hash': ('django.db.models.fields.CharField', [], {'max_length': '36'}),
+            'height': ('django.db.models.fields.IntegerField', [], {'default': '0'}),
+            'id': ('django.db.models.fields.AutoField', [], {'primary_key': 'True'}),
+            'image': ('boards.thumbs.ImageWithThumbsField', [], {'blank': 'True', 'max_length': '100'}),
+            'pre_height': ('django.db.models.fields.IntegerField', [], {'default': '0'}),
+            'pre_width': ('django.db.models.fields.IntegerField', [], {'default': '0'}),
+            'width': ('django.db.models.fields.IntegerField', [], {'default': '0'})
+        },
+        'boards.signature': {
+            'Meta': {'object_name': 'Signature'},
+            'id': ('django.db.models.fields.AutoField', [], {'primary_key': 'True'}),
+            'key': ('django.db.models.fields.TextField', [], {}),
+            'key_type': ('django.db.models.fields.TextField', [], {}),
+            'signature': ('django.db.models.fields.TextField', [], {})
+        },
+        'boards.tag': {
+            'Meta': {'object_name': 'Tag', 'ordering': "('name',)"},
+            'id': ('django.db.models.fields.AutoField', [], {'primary_key': 'True'}),
+            'name': ('django.db.models.fields.CharField', [], {'max_length': '100', 'db_index': 'True'}),
+            'threads': ('django.db.models.fields.related.ManyToManyField', [], {'null': 'True', 'to': "orm['boards.Thread']", 'symmetrical': 'False', 'related_name': "'tag+'", 'blank': 'True'})
+        },
+        'boards.thread': {
+            'Meta': {'object_name': 'Thread'},
+            'archived': ('django.db.models.fields.BooleanField', [], {'default': 'False'}),
+            'bump_time': ('django.db.models.fields.DateTimeField', [], {}),
+            'id': ('django.db.models.fields.AutoField', [], {'primary_key': 'True'}),
+            'last_edit_time': ('django.db.models.fields.DateTimeField', [], {}),
+            'replies': ('django.db.models.fields.related.ManyToManyField', [], {'null': 'True', 'to': "orm['boards.Post']", 'symmetrical': 'False', 'related_name': "'tre+'", 'blank': 'True'}),
+            'tags': ('django.db.models.fields.related.ManyToManyField', [], {'to': "orm['boards.Tag']", 'symmetrical': 'False'})
+        }
+    }
+
+    complete_apps = ['boards']
  No newline at end of file

boards/models/__init__.py

@@ -1,9 +1,9 b''
 __author__ = 'neko259'
 
 from boards.models.signature import GlobalId, Signature
+from boards.models.sync_key import KeyPair
 from boards.models.image import PostImage
 from boards.models.thread import Thread
 from boards.models.post import Post
 from boards.models.tag import Tag
 from boards.models.user import Ban
-from boards.models.sync_key import KeyPair

boards/models/post.py

@@ -1,357 +1,447 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
+from boards.models import PostImage, KeyPair, GlobalId
 from boards.models.base import Viewable
 from boards.models.thread import Thread
 
 
 APP_LABEL_BOARDS = 'boards'
 
 CACHE_KEY_PPD = 'ppd'
 CACHE_KEY_POST_URL = 'post_url'
 
 POSTS_PER_DAY_RANGE = 7
 
 BAN_REASON_AUTO = 'Auto'
 
 IMAGE_THUMB_SIZE = (200, 150)
 
 TITLE_MAX_LENGTH = 200
 
 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'
+
+TYPE_GET = 'get'
+
+ATTR_VERSION = 'version'
+ATTR_TYPE = 'type'
+ATTR_NAME = 'name'
+ATTR_REF_ID = 'ref-id'
+
+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 re.finditer(REGEX_REPLY, post.text.raw):
             post_id = reply_number.group(1)
             ref_post = self.filter(id=post_id)
             if ref_post.count() > 0:
                 referenced_post = ref_post[0]
                 referenced_post.referenced_posts.add(post)
                 referenced_post.last_edit_time = post.pub_time
                 referenced_post.build_refmap()
                 referenced_post.save(update_fields=['refmap', 'last_edit_time'])
 
                 referenced_thread = referenced_post.get_thread()
                 referenced_thread.last_edit_time = post.pub_time
                 referenced_thread.save(update_fields=['last_edit_time'])
 
     def get_posts_per_day(self):
         """
         Gets average count of posts per day for the last 7 days
         """
 
         day_end = date.today()
         day_start = day_end - timedelta(POSTS_PER_DAY_RANGE)
 
         cache_key = CACHE_KEY_PPD + str(day_end)
         ppd = cache.get(cache_key)
         if ppd:
             return ppd
 
         day_time_start = timezone.make_aware(datetime.combine(
             day_start, dtime()), timezone.get_current_timezone())
         day_time_end = timezone.make_aware(datetime.combine(
             day_end, dtime()), timezone.get_current_timezone())
 
         posts_per_period = float(self.filter(
             pub_time__lte=day_time_end,
             pub_time__gte=day_time_start).count())
 
         ppd = posts_per_period / POSTS_PER_DAY_RANGE
 
         cache.set(cache_key, ppd)
         return ppd
 
 
+    def 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)
+
+        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.rendered
+
+        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()
 
         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)
+
+        self.global_id = global_id
+
+        self.save(update_fields=['global_id'])

boards/models/signature.py

@@ -1,30 +1,45 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)
 
+    def to_xml_element(self, element: et.SubElement):
+        """
+        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))
+
 
 class Signature(models.Model):
     class Meta:
         app_label = 'boards'
 
     key_type = models.TextField()
     key = models.TextField()
     signature = models.TextField()

boards/tests/test_keys.py

@@ -1,39 +1,69 b''
+import logging
+
 from django.test import TestCase
-from boards.models import KeyPair, GlobalId
-from boards.views.sync import generate_request_get
+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)
 
         try:
             KeyPair.objects.generate_key(key_type='ecdsa', primary=True)
             self.fail('Exception should be thrown indicating there can be only'
                       ' one primary key.')
         except Exception:
             pass
 
-    def test_request_get(self):
+    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)
+
         self.assertTrue('<request type="get" version="1.0"><model '
-                        'name="post" version="1.0"><id key="test key" '
-                        'local-id="1" type="test" /></model></request>' in
-                        generate_request_get([model_id]),
+                        'name="post" version="1.0"><id key="pubkey" '
+                        'local-id="1" type="test_key_type" /></model></request>' in
+                        request,
                         'Wrong XML generated for the GET request.')
+
+    def test_response_get(self):
+        post = self._create_post_with_key()
+
+        response = Post.objects.generate_response_get([post])
+        logger.debug(response)
+
+        self.assertTrue('<response><status>success</status><models><model '
+                        'name="post" ref-id="1"><id key="pubkey" local-id="1"'
+                        ' type="test_key_type" /><title>test_title</title>'
+                        '<text>test_text</text>'
+                        '</model></models></response>' 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()
+
+        return Post.objects.create_post(title='test_title', text='test_text')

boards/views/sync.py

@@ -1,44 +1,6 b''
-import xml.etree.ElementTree as et
-
-TAG_MODEL = 'model'
-TAG_REQUEST = 'request'
-TAG_ID = 'id'
-
-TYPE_GET = 'get'
-
-ATTR_VERSION = 'version'
-ATTR_TYPE = 'type'
-ATTR_NAME = 'name'
-ATTR_KEY = 'key'
-ATTR_KEY_TYPE = 'type'
-ATTR_LOCAL_ID = 'local-id'
-
-
 def respond_pull(request):
     pass
 
 
 def respond_get(request):
     pass
-
-
-def generate_request_get(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 model_id in id_list:
-        tag_id = et.SubElement(model, TAG_ID)
-        tag_id.set(ATTR_KEY, model_id.key)
-        tag_id.set(ATTR_KEY_TYPE, model_id.key_type)
-        tag_id.set(ATTR_LOCAL_ID, model_id.local_id)
-
-    return et.tostring(request, 'unicode')