Added images and attachments to the XML post response

boards/models/post/sync.py

@@ -1,201 +1,218 b''
 import xml.etree.ElementTree as et
+
+from boards.utils import get_file_mimetype
 from django.db import transaction
 from boards.models import KeyPair, GlobalId, Signature, Post, Tag
 
 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'
 
 TYPE_GET = 'get'
 
 ATTR_VERSION = 'version'
 ATTR_TYPE = 'type'
 ATTR_NAME = 'name'
 ATTR_VALUE = 'value'
 ATTR_MIMETYPE = 'mimetype'
 ATTR_KEY = 'key'
 
 STATUS_SUCCESS = 'success'
 
 
 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')
 
             content_tag = et.SubElement(model, TAG_CONTENT)
 
             tag_id = et.SubElement(content_tag, TAG_ID)
             post.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())
 
+            images = post.images.all()
+            attachments = post.attachments.all()
+            if len(images) > 0 or len(attachments) > 0:
+                attachments_tag = et.SubElement(content_tag, TAG_ATTACHMENTS)
+                for image in images:
+                    mimetype = get_file_mimetype(image.image.file)
+                    attachment = et.SubElement(attachments_tag, TAG_ATTACHMENT)
+                    attachment.set(ATTR_MIMETYPE, mimetype)
+                    attachment.text = image.hash
+                for file in attachments:
+                    mimetype = get_file_mimetype(file.file.file)
+                    attachment = et.SubElement(attachments_tag, TAG_ATTACHMENT)
+                    attachment.set(ATTR_MIMETYPE, mimetype)
+                    attachment.text = file.hash
+
             signatures_tag = et.SubElement(model, TAG_SIGNATURES)
             post_signatures = post.global_id.signature_set.all()
             if post_signatures:
                 signatures = post_signatures
                 # TODO Adding signature to a post is not yet added. For now this
                 # block is useless
             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)
                 signature = Signature(
                     key_type=key.key_type,
                     key=key.public_key,
                     signature=key.sign(et.tostring(content_tag, encoding=ENCODING_UNICODE)),
                     global_id=post.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
     @transaction.atomic
     def parse_response_get(response_xml):
         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:
                 tag_content = tag_model.find(TAG_CONTENT)
 
                 signatures = SyncManager._verify_model(tag_content, tag_model)
 
                 tag_id = tag_content.find(TAG_ID)
                 global_id, exists = GlobalId.from_xml_element(tag_id)
 
                 if exists:
                     print('Post with same ID already exists')
                 else:
                     global_id.save()
                     for signature in signatures:
                         signature.global_id = global_id
                         signature.save()
 
                     title = tag_content.find(TAG_TITLE).text
                     text = tag_content.find(TAG_TEXT).text
                     pub_time = tag_content.find(TAG_PUB_TIME).text
 
                     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:
                             raise Exception('Load the OP first')
                     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
 
                     # TODO Get images
 
                     post = Post.objects.import_post(
                         title=title, text=text, pub_time=pub_time,
                         opening_post=opening_post, tags=tags,
                         global_id=global_id)
         else:
             # TODO Throw an exception?
             pass
 
     @staticmethod
     def generate_response_pull():
         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.all():
             tag_id = et.SubElement(models, TAG_ID)
             post.global_id.to_xml_element(tag_id)
 
         return et.tostring(response, ENCODING_UNICODE)
 
     @staticmethod
     def _verify_model(tag_content, tag_model):
         """
         Verifies all signatures for a single model.
         """
 
         signatures = []
 
         tag_signatures = tag_model.find(TAG_SIGNATURES)
         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)
 
             signature = Signature(key_type=signature_type,
                                   key=signature_key,
                                   signature=signature_value)
 
             content = et.tostring(tag_content, ENCODING_UNICODE)
 
             if not KeyPair.objects.verify(
                     signature, content):
                 raise Exception('Invalid model signature for {}'.format(content))
 
             signatures.append(signature)
 
         return signatures