From 695d925c9e7a766770e7964c71cc244581925758 Mon Sep 17 00:00:00 2001
From: Sam Clements <sam@borntyping.co.uk>
Date: Fri, 1 Feb 2013 15:13:18 +0000
Subject: [PATCH] Post versioning (Part of #52)

---
 tentd/blueprints/posts.py            | 13 ++--
 tentd/documents/post.py              | 99 ++++++++++++++++++++--------
 tentd/flask.py                       |  4 ++
 tentd/tests/blueprints/test_posts.py | 24 +++----
 tentd/tests/documents/test_entity.py |  5 +-
 tentd/tests/documents/test_posts.py  | 30 +++++++--
 6 files changed, 121 insertions(+), 54 deletions(-)

diff --git a/tentd/blueprints/posts.py b/tentd/blueprints/posts.py
index faada81..f090437 100644
--- a/tentd/blueprints/posts.py
+++ b/tentd/blueprints/posts.py
@@ -32,20 +32,17 @@ def post(self):
         TODO: Separate between apps creating a new post and a notification
         from a non-followed entity.
         """
-        new_post = Post()
-        new_post.entity = g.entity
-        new_post.schema = request.json['schema']
-        new_post.content = request.json['content']
-
-        new_post.save()
+        post = Post(entity=g.entity, schema=request.json.pop('schema'))
+        post.new_version(**request.json)
+        post.save()
 
         # TODO: Do this asynchronously?
         for to_notify in g.entity.followers:
             notification_link = follow.get_notification_link(to_notify)
-            requests.post(notification_link, data=jsonify(new_post.to_json()))
+            requests.post(notification_link, data=jsonify(post.to_json()))
             # TODO: Handle failed notifications somehow
 
-        return jsonify(new_post)
+        return jsonify(post)
 
 @posts.route_class('/<string:post_id>', endpoint='post')
 class PostsView(MethodView):
diff --git a/tentd/documents/post.py b/tentd/documents/post.py
index 5606f71..667efbe 100644
--- a/tentd/documents/post.py
+++ b/tentd/documents/post.py
@@ -2,11 +2,46 @@
 
 __all__ = ['Post']
 
+from datetime import datetime
+
 from mongoengine import *
 
 from tentd.documents import db, EntityMixin
 from tentd.utils import time_to_string, json_attributes
 
+class Version(db.EmbeddedDocument):
+    """A specific version of a Post
+
+    TODO: 'mentions'
+    TODO: 'licenses'
+    TODO: 'attachments'
+    TODO: 'app'
+    TODO: 'views'
+    TODO: 'permissions'
+    """
+    meta = {
+        'allow_inheritance': False,
+    }
+
+    #: The time the post was published
+    published_at = DateTimeField(default=datetime.now, required=True)
+
+    #: The time we received the post from the publishing server
+    received_at = DateTimeField(default=datetime.now, required=True)
+
+    #: The content of the post
+    content = DictField(required=True)
+
+    def __repr__(self):
+        return '<Version {}: {}'.format(self.version, self.content)
+    
+    def to_json(self):
+        return {
+            'content': self.content,
+            'published_at': time_to_string(self.published_at),
+            'received_at':  time_to_string(self.received_at),
+        }
+
 class Post(EntityMixin, db.Document):
     """A post belonging to an entity.
     
@@ -19,36 +54,48 @@ class Post(EntityMixin, db.Document):
     meta = {
         'allow_inheritance': False,
         'indexes': ['schema'],
-        'ordering': ['-published_at'],
+        'ordering': ['-received_at'],
     }
 
     #: The post type
     schema = URLField(required=True)
 
-    #: The content of the post
-    content = DictField(required=True)
-    
-    #: The time the post was published
-    published_at = DateTimeField()
-    
-    #: The time we received the post from the publishing server
-    received_at = DateTimeField()
+    #: The versions of the post
+    versions = SortedListField(
+        EmbeddedDocumentField(Version),
+        ordering='published_at', reverse=True, required=True)
+
+    def __init__(self, **kwargs):
+        super(Post, self).__init__(**kwargs)
+
+    @classmethod
+    def new(cls, **k):
+        """Constucts a Post and an initial version from the same args"""
+        # Pop those arguments that are a Version field from the kwargs
+        version = {a: k.pop(a) for a in k.keys() if a in Version._fields}
+        # Create a new Post with the remaining arguments
+        post = cls(**k)
+        # And a new Version from the arguments we popped
+        post.new_version(**version)
+        return post
+
+    def new_version(self, **kwargs):
+        """Add a new version of the post"""
+        version = Version(**kwargs)
+        self.versions.append(version)
+        return version
+
+    @property
+    def latest(self):
+        return self.versions[0]
     
     def to_json(self):
-        """Returns the post as a python dictonary
-    
-        TODO: 'mentions'
-        TODO: 'licenses'
-        TODO: 'attachments'
-        TODO: 'app'
-        TODO: 'views'
-        TODO: 'permissions'
-        """
-        return json_attributes(self,
-            ('id', str),
-            'content',
-            ('published_at', time_to_string),
-            ('received_at', time_to_string),
-            entity=self.entity.core.identity,
-            type=self.schema
-        )
+        """Returns the post as a python dictonary"""
+        json = {
+            'id': self.id,
+            'type': self.schema,
+            'entity': self.entity.core.identity,
+            'version': len(self.versions),
+        }
+        json.update(self.latest.to_json())
+        return json
diff --git a/tentd/flask.py b/tentd/flask.py
index 158d49a..a146984 100644
--- a/tentd/flask.py
+++ b/tentd/flask.py
@@ -5,6 +5,7 @@
 import flask
 
 from flask import abort, g, url_for, json, current_app, request
+from bson import ObjectId
 from mongoengine.queryset import QuerySet
 from werkzeug.utils import cached_property
 from werkzeug.exceptions import NotFound
@@ -115,6 +116,9 @@ def default(self, obj):
         
         if isinstance(obj, (list, QuerySet)):
             return [self.default(o) for o in obj]
+
+        if isinstance(obj, ObjectId):
+            return str(obj)
         
         return super(JSONEncoder, self).default(obj)
 
diff --git a/tentd/tests/blueprints/test_posts.py b/tentd/tests/blueprints/test_posts.py
index 86ecb54..d9a834d 100644
--- a/tentd/tests/blueprints/test_posts.py
+++ b/tentd/tests/blueprints/test_posts.py
@@ -3,6 +3,7 @@
 from json import dumps
 
 from tentd.documents.entity import Post
+from tentd.flask import jsonify
 from tentd.tests import EntityTentdTestCase
 
 class PostTests(EntityTentdTestCase):
@@ -10,11 +11,10 @@ class PostTests(EntityTentdTestCase):
     
     def before(self):
         """Create a post in the DB."""
-        self.new_post = Post()
-        self.new_post.schema = 'https://tent.io/types/post/status/v0.1.0'
-        self.new_post.content = {'text': 'test', 'location': None}
-        self.new_post.entity = self.entity
-        self.new_post.save()
+        self.new_post = Post.new(
+            entity=self.entity,
+            schema='https://tent.io/types/post/status/v0.1.0',
+            content={'text': 'test', 'location': None}).save()
 
     def test_entity_header_posts(self):
         """Test the entity header is returned from the posts route."""
@@ -26,23 +26,23 @@ def test_entity_get_posts(self):
         self.assertStatus(resp, 200)
 
         posts = [post.to_json() for post in self.entity.posts]
-        self.assertEquals(resp.json(), posts)
+        self.assertEquals(resp.data, jsonify(posts).data)
 
     def test_entity_new_post(self):
         """Test that a new post can be added correctly."""
-        post_details = {
+        details = {
             'schema': 'https://tent.io/types/post/status/v0.1.0', 
             'content': {'text': 'test', 'location': None}}
             
         resp = self.client.post('/{}/posts'.format(self.name),
-            data=dumps(post_details))
+            data=dumps(details))
 
         self.assertStatus(resp, 200)
 
         created_post = self.entity.posts.get(id=resp.json()['id'])
         self.assertIsNotNone(created_post)
-        self.assertEquals(created_post.schema, post_details['schema'])
-        self.assertEquals(created_post.content, post_details['content'])
+        self.assertEquals(created_post.schema, details['schema'])
+        self.assertEquals(created_post.latest.content, details['content'])
 
     def test_entity_create_invalid_post(self):
         """Test that attempting to create an invalid post fails."""
@@ -56,7 +56,7 @@ def test_entity_get_single_post(self):
             '/{}/posts/{}'.format(self.name, self.new_post.id))
 
         self.assertStatus(resp, 200)
-        self.assertEquals(resp.json(), self.new_post.to_json())
+        self.assertEquals(resp.data, jsonify(self.new_post).data)
 
     def test_entity_update_single_post(self):
         """Test a single post can be updated."""
@@ -69,7 +69,7 @@ def test_entity_update_single_post(self):
 
         new_post = Post.objects.get(entity=self.entity)
         self.assertStatus(resp, 200)
-        self.assertEquals(resp.json(), new_post.to_json())
+        self.assertEquals(resp.data, jsonify(new_post).data)
 
     def test_entity_update_post_invalid(self):
         """Test that attempting to update an invalid post fails."""
diff --git a/tentd/tests/documents/test_entity.py b/tentd/tests/documents/test_entity.py
index 1cf0d70..078625c 100644
--- a/tentd/tests/documents/test_entity.py
+++ b/tentd/tests/documents/test_entity.py
@@ -10,7 +10,8 @@ def test_create_entity(self):
         assert self.entity == Entity.objects.get(name="testuser")
 
     def test_create_identical_entity(self):
-        """Check that properly inserting a document does not overwrite an existing one"""
+        """Check that properly inserting a document does not overwrite an
+        existing one"""
         with self.assertRaises(db.NotUniqueError):
             entity = Entity(name="testuser")
             entity.save()
@@ -28,7 +29,7 @@ class DeletionTest(TentdTestCase):
 
     def test_post_delete(self):
         self.entity = Entity(name="testuser").save()
-        self.post = Post(
+        self.post = Post.new(
             entity=self.entity,
             schema="http://example.com/thisisnotrelevant",
             content={'a': 'b'}).save()
diff --git a/tentd/tests/documents/test_posts.py b/tentd/tests/documents/test_posts.py
index 46220a3..6b8bd91 100644
--- a/tentd/tests/documents/test_posts.py
+++ b/tentd/tests/documents/test_posts.py
@@ -8,10 +8,22 @@
 
 class PostTest(EntityTentdTestCase):
     def before(self):
+        """Create a post with several versions"""
         self.post = Post(
             entity=self.entity,
-            schema='https://tent.io/types/post/status/v0.1.0',
-            content={'text': "Hello world"})
+            schema='https://tent.io/types/post/status/v0.1.0')
+        self.post.new_version(content={
+            'text': "Hello world",
+            'coordinates': [0, 0],
+        })
+        self.post.new_version(content={
+            'text': "How are you, world?",
+            'coordinates': [1, 1],
+        })
+        self.post.new_version(content={
+            'text': "Goodbye world",
+            'coordinates': [2, 2],
+        })
         self.post.save()
     
     def test_post_owner(self):
@@ -21,14 +33,20 @@ def test_post_owner(self):
 
     def test_post_content(self):
         post = Post.objects.get(entity=self.entity)
-        assert post.content['text'] == "Hello world"
+        assert post.latest.content['text'] == "Goodbye world"
+        assert post.latest.content['coordinates'] == [2, 2]
 
     def test_post_json(self):
+        """Test that posts can be exported to json"""
         assert 'content' in self.post.to_json()
 
+    def test_post_versions(self):
+        """Test that the versions are numbered correctly"""
+        assert self.post.to_json()['version'] == 3
+
 class UnicodePostTest(EntityTentdTestCase):
     def before(self):
-        self.essay = Post(
+        self.essay = Post.new(
             entity=self.entity,
             schema='https://tent.io/types/post/status/v0.1.0',
             content={
@@ -44,5 +62,5 @@ def before(self):
         self.essay.save()
 
     def test_post_content(self):
-        assert "⛺" in self.essay.content['title']
-        assert "⛺" in self.essay.content['body']
+        assert "⛺" in self.essay.latest.content['title']
+        assert "⛺" in self.essay.latest.content['body']