Merge pull request #4 from lebouquetin/master

tracim/tracim/lib/content.py

@@ -150,7 +150,7 @@ class ContentApi(object):
 
         if do_save:
             self.save(item, ActionDescription.COMMENT)
-        return content
+        return item
 
 
     def get_one_from_revision(self, content_id: int, content_type: str, workspace: Workspace=None, revision_id=None) -> Content:
@@ -174,22 +174,14 @@ class ContentApi(object):
         return content
 
     def get_one(self, content_id: int, content_type: str, workspace: Workspace=None) -> Content:
-        assert content_id is None or isinstance(content_id, int) # DYN_REMOVE
-        assert content_type is not None # DYN_REMOVE
-        assert isinstance(content_type, str) # DYN_REMOVE
 
         if not content_id:
-            return
+            return None
 
         if content_type==ContentType.Any:
-            return self._base_query(workspace).\
-                filter(Content.content_id==content_id).\
-                one()
+            return self._base_query(workspace).filter(Content.content_id==content_id).one()
 
-        return self._base_query(workspace).\
-            filter(Content.content_id==content_id).\
-            filter(Content.type==content_type).\
-            one()
+        return self._base_query(workspace).filter(Content.content_id==content_id).filter(Content.type==content_type).one()
 
     def get_all(self, parent_id: int, content_type: str, workspace: Workspace=None) -> Content:
         assert parent_id is None or isinstance(parent_id, int) # DYN_REMOVE
@@ -218,12 +210,6 @@ class ContentApi(object):
             )
         :return:
         """
-        assert folder.type==ContentType.Folder
-        assert 'file' in allowed_content_dict.keys()
-        assert 'folder' in allowed_content_dict.keys()
-        assert 'page' in allowed_content_dict.keys()
-        assert 'thread' in allowed_content_dict.keys()
-
         properties = dict(allowed_content = allowed_content_dict)
         folder.properties = properties
 
@@ -245,32 +231,39 @@ class ContentApi(object):
         item.revision_type = ActionDescription.EDITION
 
 
-    def update_content(self, item: Content, new_label: str, new_content: str) -> Content:
+    def update_content(self, item: Content, new_label: str, new_content: str=None) -> Content:
+        item.owner = self._user
         item.label = new_label
-        item.description = new_content # TODO: convert urls into links
+        item.description = new_content if new_content else item.description # TODO: convert urls into links
         item.revision_type = ActionDescription.EDITION
         return item
 
     def update_file_data(self, item: Content, new_filename: str, new_mimetype: str, new_file_content) -> Content:
+        item.owner = self._user
         item.file_name = new_filename
         item.file_mimetype = new_mimetype
         item.file_content = new_file_content
+        item.revision_type = ActionDescription.REVISION
         return item
 
     def archive(self, content: Content):
+        content.owner = self._user
         content.is_archived = True
         content.revision_type = ActionDescription.ARCHIVING
 
     def unarchive(self, content: Content):
+        content.owner = self._user
         content.is_archived = False
         content.revision_type = ActionDescription.UNARCHIVING
 
 
     def delete(self, content: Content):
+        content.owner = self._user
         content.is_deleted = True
         content.revision_type = ActionDescription.DELETION
 
     def undelete(self, content: Content):
+        content.owner = self._user
         content.is_deleted = False
         content.revision_type = ActionDescription.UNDELETION
 
@@ -292,7 +285,9 @@ class ContentApi(object):
                 # The action has not been modified, so we set it to default edition
                 action_description = ActionDescription.EDITION
 
-        content.revision_type = action_description
+        if action_description:
+            content.revision_type = action_description
+
 
         if do_flush:
             DBSession.flush()

tracim/tracim/lib/notifications.py

@@ -32,7 +32,8 @@ class INotifier(object):
     Interface for Notifier instances
     """
     def __init__(self, current_user: User=None):
-        raise NotImplementedError
+        pass
+
 
     def notify_content_update(self, content: Content):
         raise NotImplementedError
@@ -43,7 +44,7 @@ class NotifierFactory(object):
     @classmethod
     def create(cls, current_user: User=None) -> INotifier:
         cfg = CFG.get_instance()
-        if cfg.EMAIL_NOTIFICATION_ACTIVATED:
+        if not cfg.EMAIL_NOTIFICATION_ACTIVATED:
             return DummyNotifier(current_user)
 
         return RealNotifier(current_user)
@@ -54,7 +55,7 @@ class DummyNotifier(INotifier):
         logger.info(self, 'Instantiating Dummy Notifier')
 
     def notify_content_update(self, content: Content):
-        logger.info(self, 'Fake notifier, do not send email-notification for update of content {} by user {}'.format(content.content_id, self._user.user_id))
+        logger.info(self, 'Fake notifier, do not send email-notification for update of content {}'.format(content.content_id))
 
 
 class RealNotifier(object):

tracim/tracim/tests/library/test_content_api.py

@@ -1,14 +1,20 @@
 # -*- coding: utf-8 -*-
 
 from nose.tools import eq_
+from nose.tools import raises
 
 import transaction
 
 from tracim.lib.content import compare_content_for_sorting_by_type_and_name
 from tracim.lib.content import ContentApi
+from tracim.lib.user import UserApi
+from tracim.lib.user import UserStaticApi
 
+from tracim.model.auth import User
+from tracim.model.data import ActionDescription
 from tracim.model.data import Content
 from tracim.model.data import ContentType
+from tracim.model.data import ContentStatus
 
 from tracim.tests import TestStandard
 
@@ -81,8 +87,6 @@ class TestContentApi(TestStandard):
         eq_(sorteds[0], c2, 'value is {} instead of {}'.format(sorteds[0].content_id, c2.content_id))
         eq_(sorteds[1], c1, 'value is {} instead of {}'.format(sorteds[1].content_id, c1.content_id))
 
-class TestContentApiFilteringDeletedItem(TestStandard):
-
     def test_delete(self):
         api = ContentApi(None)
         item = api.create(ContentType.Folder, None, None, 'not_deleted', True)
@@ -127,3 +131,249 @@ class TestContentApiFilteringDeletedItem(TestStandard):
         api = ContentApi(None, show_archived=True)
         items = api.get_all(None, ContentType.Any, None)
         eq_(2, len(items))
+
+    def test_get_all_with_filter(self):
+        api = ContentApi(None)
+        item = api.create(ContentType.Folder, None, None, 'thefolder', True)
+        item2 = api.create(ContentType.File, None, None, 'thefile', True)
+        transaction.commit()
+
+        items = api.get_all(None, ContentType.Any, None)
+        eq_(2, len(items))
+
+        items2 = api.get_all(None, ContentType.File, None)
+        eq_(1, len(items2))
+        eq_('thefile', items2[0].label)
+
+        items3 = api.get_all(None, ContentType.Folder, None)
+        eq_(1, len(items3))
+        eq_('thefolder', items3[0].label)
+
+    def test_get_all_with_parent_id(self):
+        api = ContentApi(None)
+        item = api.create(ContentType.Folder, None, None, 'parent', True)
+        item2 = api.create(ContentType.File, None, item, 'file1', True)
+        item3 = api.create(ContentType.File, None, None, 'file2', True)
+        parent_id = item.content_id
+        child_id = item2.content_id
+        transaction.commit()
+
+        items = api.get_all(None, ContentType.Any, None)
+        eq_(3, len(items))
+
+        items2 = api.get_all(parent_id, ContentType.File, None)
+        eq_(1, len(items2))
+        eq_(child_id, items2[0].content_id)
+
+    @raises(ValueError)
+    def test_set_status_unknown_status(self):
+        api = ContentApi(None)
+        c = api.create(ContentType.Folder, None, None, 'parent', True)
+        api.set_status(c, 'unknown-status')
+
+    def test_set_status_ok(self):
+        api = ContentApi(None)
+        c = api.create(ContentType.Folder, None, None, 'parent', True)
+        for new_status in ['open', 'closed-validated', 'closed-unvalidated', 'closed-deprecated']:
+            api.set_status(c, new_status)
+            eq_(new_status, c.status)
+            eq_(ActionDescription.STATUS_UPDATE, c.revision_type)
+
+    def test_create_comment_ok(self):
+        uapi = UserApi(None)
+        user = uapi.create_user()
+        user.email = 'this.is@user'
+        uapi.save(user)
+
+        api = ContentApi(user)
+        p = api.create(ContentType.Page, None, None, 'this_is_a_page')
+        transaction.commit()
+
+        c = api.create_comment(None, p, 'this is the comment', True)
+        transaction.commit()
+
+        eq_(Content, c.__class__)
+        eq_(p.content_id, c.parent_id)
+        eq_(user, c.owner)
+        eq_(None, c.workspace)
+        eq_(ContentType.Comment, c.type)
+        eq_('this is the comment', c.description)
+        eq_('', c.label)
+        eq_(ActionDescription.COMMENT, c.revision_type)
+
+
+    def test_update(self):
+        uapi = UserApi(None)
+
+        user1 = uapi.create_user()
+        user1.email = 'this.is@user'
+        uapi.save(user1)
+
+        user2 = uapi.create_user()
+        user2.email = 'this.is@another.user'
+        uapi.save(user2)
+
+        api = ContentApi(user1)
+        p = api.create(ContentType.Page, None, None, 'this_is_a_page', True)
+
+        u1id = user1.user_id
+        u2id = user2.user_id
+        pcid = p.content_id
+        poid = p.owner_id
+
+        transaction.commit()
+
+        content = api.get_one(pcid, ContentType.Any, None)
+        eq_(u1id, content.owner_id)
+        eq_(poid, content.owner_id)
+
+        u2 = UserApi(None).get_one(u2id)
+        api2 = ContentApi(u2)
+        content2 = api2.get_one(pcid, ContentType.Any, None)
+        api2.update_content(content2, 'this is an updated page', 'new content')
+        api2.save(content2)
+        transaction.commit()
+
+        updated = api.get_one(pcid, ContentType.Any, None)
+        eq_(u2id, updated.owner_id, 'the owner id should be {} (found {})'.format(u2id, updated.owner_id))
+        eq_('this is an updated page', updated.label)
+        eq_('new content', updated.description)
+        eq_(ActionDescription.EDITION, updated.revision_type)
+
+
+    def test_update_file_data(self):
+        uapi = UserApi(None)
+
+        user1 = uapi.create_user()
+        user1.email = 'this.is@user'
+        uapi.save(user1)
+
+        user2 = uapi.create_user()
+        user2.email = 'this.is@another.user'
+        uapi.save(user2)
+
+        api = ContentApi(user1)
+        p = api.create(ContentType.File, None, None, 'this_is_a_page', True)
+
+        u1id = user1.user_id
+        u2id = user2.user_id
+        pcid = p.content_id
+        poid = p.owner_id
+
+        transaction.commit()
+
+        content = api.get_one(pcid, ContentType.Any, None)
+        eq_(u1id, content.owner_id)
+        eq_(poid, content.owner_id)
+
+        u2 = UserApi(None).get_one(u2id)
+        api2 = ContentApi(u2)
+        content2 = api2.get_one(pcid, ContentType.Any, None)
+        api2.update_file_data(content2, 'index.html', 'text/html', b'<html>hello world</html>')
+        api2.save(content2)
+        transaction.commit()
+
+        updated = api.get_one(pcid, ContentType.Any, None)
+        eq_(u2id, updated.owner_id, 'the owner id should be {} (found {})'.format(u2id, updated.owner_id))
+        eq_('index.html', updated.file_name)
+        eq_('text/html', updated.file_mimetype)
+        eq_(b'<html>hello world</html>', updated.file_content)
+        eq_(ActionDescription.REVISION, updated.revision_type)
+
+
+    def test_archive_unarchive(self):
+        uapi = UserApi(None)
+
+        user1 = uapi.create_user()
+        user1.email = 'this.is@user'
+        uapi.save(user1)
+
+        user2 = uapi.create_user()
+        user2.email = 'this.is@another.user'
+        uapi.save(user2)
+
+        api = ContentApi(user1, show_archived=True) # show archived is used at the top end of the test
+        p = api.create(ContentType.File, None, None, 'this_is_a_page', True)
+
+        u1id = user1.user_id
+        u2id = user2.user_id
+        pcid = p.content_id
+        poid = p.owner_id
+
+        transaction.commit()
+
+        ####
+
+        content = api.get_one(pcid, ContentType.Any, None)
+        eq_(u1id, content.owner_id)
+        eq_(poid, content.owner_id)
+
+        u2 = UserApi(None).get_one(u2id)
+        api2 = ContentApi(u2, show_archived=True)
+        content2 = api2.get_one(pcid, ContentType.Any, None)
+        api2.archive(content2)
+        api2.save(content2)
+        transaction.commit()
+
+        updated = api2.get_one(pcid, ContentType.Any, None)
+        eq_(u2id, updated.owner_id, 'the owner id should be {} (found {})'.format(u2id, updated.owner_id))
+        eq_(True, updated.is_archived)
+        eq_(ActionDescription.ARCHIVING, updated.revision_type)
+
+        ####
+
+        updated2 = api.get_one(pcid, ContentType.Any, None)
+        api.unarchive(updated)
+        api.save(updated2)
+        eq_(False, updated2.is_archived)
+        eq_(ActionDescription.UNARCHIVING, updated2.revision_type)
+        eq_(u1id, updated2.owner_id)
+
+
+    def test_delete_undelete(self):
+        uapi = UserApi(None)
+
+        user1 = uapi.create_user()
+        user1.email = 'this.is@user'
+        uapi.save(user1)
+
+        user2 = uapi.create_user()
+        user2.email = 'this.is@another.user'
+        uapi.save(user2)
+
+        api = ContentApi(user1, show_deleted=True) # show archived is used at the top end of the test
+        p = api.create(ContentType.File, None, None, 'this_is_a_page', True)
+
+        u1id = user1.user_id
+        u2id = user2.user_id
+        pcid = p.content_id
+        poid = p.owner_id
+
+        transaction.commit()
+
+        ####
+
+        content = api.get_one(pcid, ContentType.Any, None)
+        eq_(u1id, content.owner_id)
+        eq_(poid, content.owner_id)
+
+        u2 = UserApi(None).get_one(u2id)
+        api2 = ContentApi(u2, show_deleted=True)
+        content2 = api2.get_one(pcid, ContentType.Any, None)
+        api2.delete(content2)
+        api2.save(content2)
+        transaction.commit()
+
+        updated = api2.get_one(pcid, ContentType.Any, None)
+        eq_(u2id, updated.owner_id, 'the owner id should be {} (found {})'.format(u2id, updated.owner_id))
+        eq_(True, updated.is_deleted)
+        eq_(ActionDescription.DELETION, updated.revision_type)
+
+        ####
+
+        updated2 = api.get_one(pcid, ContentType.Any, None)
+        api.undelete(updated)
+        api.save(updated2)
+        eq_(False, updated2.is_deleted)
+        eq_(ActionDescription.UNDELETION, updated2.revision_type)
+        eq_(u1id, updated2.owner_id)

tracim/tracim/tests/library/test_notification.py

@@ -0,0 +1,66 @@
+# -*- coding: utf-8 -*-
+
+from nose.tools import eq_
+from nose.tools import ok_
+from nose.tools import raises
+
+from sqlalchemy.orm.exc import NoResultFound
+
+import transaction
+
+from tracim.lib.user import UserApi
+from tracim.tests import TestStandard
+
+
+
+class TestUserApi(TestStandard):
+
+    def test_create_and_update_user(self):
+        api = UserApi(None)
+        u = api.create_user()
+        api.update(u, 'bob', 'bob@bob', True)
+
+        nu = api.get_one_by_email('bob@bob')
+        ok_(nu!=None)
+        eq_('bob@bob', nu.email)
+        eq_('bob', nu.display_name)
+
+
+    def test_user_with_email_exists(self):
+        api = UserApi(None)
+        u = api.create_user()
+        api.update(u, 'bibi', 'bibi@bibi', True)
+        transaction.commit()
+
+        eq_(True, api.user_with_email_exists('bibi@bibi'))
+        eq_(False, api.user_with_email_exists('unknown'))
+
+
+    def test_get_one_by_email(self):
+        api = UserApi(None)
+        u = api.create_user()
+        api.update(u, 'bibi', 'bibi@bibi', True)
+        uid = u.user_id
+        transaction.commit()
+
+        eq_(uid, api.get_one_by_email('bibi@bibi').user_id)
+
+    @raises(NoResultFound)
+    def test_get_one_by_email_exception(self):
+        api = UserApi(None)
+        api.get_one_by_email('unknown')
+
+    def test_get_all(self):
+        api = UserApi(None)
+        # u1 = api.create_user(True)
+        # u2 = api.create_user(True)
+
+        # users = api.get_all()
+        # ok_(2==len(users))
+
+    def test_get_one(self):
+        api = UserApi(None)
+        u = api.create_user()
+        api.update(u, 'titi', 'titi@titi', True)
+        one = api.get_one(u.user_id)
+        eq_(u.user_id, one.user_id)