Delete Content database view

tracim/tracim/controllers/__init__.py

 from tracim.lib.predicates import current_user_is_content_manager
 
 from tracim.model.auth import User
-from tracim.model.data import ActionDescription
+from tracim.model.data import ActionDescription, new_revision
 from tracim.model.data import BreadcrumbItem
 from tracim.model.data import Content
 from tracim.model.data import ContentType
         try:
             api = ContentApi(tmpl_context.current_user)
             item = api.get_one(int(item_id), self._item_type, workspace)
-            api.update_content(item, label, content)
-            api.save(item, ActionDescription.REVISION)
+            with new_revision(item):
+                api.update_content(item, label, content)
+                api.save(item, ActionDescription.REVISION)
 
             msg = _('{} updated').format(self._item_type_label)
             tg.flash(msg, CST.STATUS_OK)
         content_api = ContentApi(tmpl_context.current_user)
         item = content_api.get_one(item_id, self._item_type, tmpl_context.workspace)
         try:
-            content_api.set_status(item, status)
-            content_api.save(item, ActionDescription.STATUS_UPDATE)
+            with new_revision(item):
+                content_api.set_status(item, status)
+                content_api.save(item, ActionDescription.STATUS_UPDATE)
             msg = _('{} status updated').format(self._item_type_label)
             tg.flash(msg, CST.STATUS_OK)
             tg.redirect(self._std_url.format(item.workspace_id, item.parent_id, item.content_id))
             undo_url = self._std_url.format(item.workspace_id, item.parent_id, item.content_id)+'/put_archive_undo'
             msg = _('{} archived. <a class="alert-link" href="{}">Cancel action</a>').format(self._item_type_label, undo_url)
 
-            content_api.archive(item)
-            content_api.save(item, ActionDescription.ARCHIVING)
+            with new_revision(item):
+                content_api.archive(item)
+                content_api.save(item, ActionDescription.ARCHIVING)
 
             tg.flash(msg, CST.STATUS_OK, no_escape=True) # TODO allow to come back
             tg.redirect(next_url)
         try:
             next_url = self._std_url.format(item.workspace_id, item.parent_id, item.content_id)
             msg = _('{} unarchived.').format(self._item_type_label)
-            content_api.unarchive(item)
-            content_api.save(item, ActionDescription.UNARCHIVING)
+            with new_revision(item):
+                content_api.unarchive(item)
+                content_api.save(item, ActionDescription.UNARCHIVING)
 
             tg.flash(msg, CST.STATUS_OK)
             tg.redirect(next_url )
             next_url = self._parent_url.format(item.workspace_id, item.parent_id)
             undo_url = self._std_url.format(item.workspace_id, item.parent_id, item.content_id)+'/put_delete_undo'
             msg = _('{} deleted. <a class="alert-link" href="{}">Cancel action</a>').format(self._item_type_label, undo_url)
-            content_api.delete(item)
-            content_api.save(item, ActionDescription.DELETION)
+            with new_revision(item):
+                content_api.delete(item)
+                content_api.save(item, ActionDescription.DELETION)
 
             tg.flash(msg, CST.STATUS_OK, no_escape=True)
             tg.redirect(next_url)
         try:
             next_url = self._std_url.format(item.workspace_id, item.parent_id, item.content_id)
             msg = _('{} undeleted.').format(self._item_type_label)
-            content_api.undelete(item)
-            content_api.save(item, ActionDescription.UNDELETION)
+            with new_revision(item):
+                content_api.undelete(item)
+                content_api.save(item, ActionDescription.UNDELETION)
 
             tg.flash(msg, CST.STATUS_OK)
             tg.redirect(next_url)

tracim/tracim/controllers/content.py

 # -*- coding: utf-8 -*-
+import sys
+
 __author__ = 'damien'
 
 from cgi import FieldStorage
 from tracim.lib.predicates import require_current_user_is_owner
 
 from tracim.model.serializers import Context, CTX, DictLikeClass
-from tracim.model.data import ActionDescription
+from tracim.model.data import ActionDescription, new_revision
 from tracim.model.data import Content
 from tracim.model.data import ContentType
 from tracim.model.data import UserRoleInWorkspace
                                                                                                          item_id)
 
             msg = _('{} deleted. <a class="alert-link" href="{}">Cancel action</a>').format(self._item_type_label, undo_url)
-            content_api.delete(item)
-            content_api.save(item, ActionDescription.DELETION)
+            with new_revision(item):
+                content_api.delete(item)
+                content_api.save(item, ActionDescription.DELETION)
 
             tg.flash(msg, CST.STATUS_OK, no_escape=True)
             tg.redirect(next_url)
                                                                              tmpl_context.folder_id,
                                                                              tmpl_context.thread_id)
             msg = _('{} undeleted.').format(self._item_type_label)
-            content_api.undelete(item)
-            content_api.save(item, ActionDescription.UNDELETION)
+            with new_revision(item):
+                content_api.undelete(item)
+                content_api.save(item, ActionDescription.UNDELETION)
 
             tg.flash(msg, CST.STATUS_OK)
             tg.redirect(next_url)
             # TODO - D.A. - 2015-03-19
             # refactor this method in order to make code easier to understand
 
-            if comment and label:
-                updated_item = api.update_content(
-                    item, label if label else item.label,
-                    comment if comment else ''
-                )
-                api.save(updated_item, ActionDescription.EDITION)
-
-                # This case is the default "file title and description update"
-                # In this case the file itself is not revisionned
-
-            else:
-                # So, now we may have a comment and/or a file revision
-                if comment and ''==label:
-                    comment_item = api.create_comment(workspace,
-                                                      item, comment,
-                                                      do_save=False)
-
-                    if not isinstance(file_data, FieldStorage):
-                        api.save(comment_item, ActionDescription.COMMENT)
-                    else:
-                        # The notification is only sent
-                        # if the file is NOT updated
-                        #
-                        #  If the file is also updated,
-                        #  then a 'file revision' notification will be sent.
-                        api.save(comment_item,
-                                 ActionDescription.COMMENT,
-                                 do_notify=False)
-
-                if isinstance(file_data, FieldStorage):
-                    api.update_file_data(item, file_data.filename, file_data.type, file_data.file.read())
-                    api.save(item, ActionDescription.REVISION)
+            with new_revision(item):
+
+                if comment and label:
+                    updated_item = api.update_content(
+                        item, label if label else item.label,
+                        comment if comment else ''
+                    )
+                    api.save(updated_item, ActionDescription.EDITION)
+
+                    # This case is the default "file title and description update"
+                    # In this case the file itself is not revisionned
+
+                else:
+                    # So, now we may have a comment and/or a file revision
+                    if comment and ''==label:
+                        comment_item = api.create_comment(workspace,
+                                                          item, comment,
+                                                          do_save=False)
+
+                        if not isinstance(file_data, FieldStorage):
+                            api.save(comment_item, ActionDescription.COMMENT)
+                        else:
+                            # The notification is only sent
+                            # if the file is NOT updated
+                            #
+                            #  If the file is also updated,
+                            #  then a 'file revision' notification will be sent.
+                            api.save(comment_item,
+                                     ActionDescription.COMMENT,
+                                     do_notify=False)
+
+                    if isinstance(file_data, FieldStorage):
+                        api.update_file_data(item, file_data.filename, file_data.type, file_data.file.read())
+                        api.save(item, ActionDescription.REVISION)
 
             msg = _('{} updated').format(self._item_type_label)
             tg.flash(msg, CST.STATUS_OK)
         try:
             api = ContentApi(tmpl_context.current_user)
             item = api.get_one(int(item_id), self._item_type, workspace)
-            api.update_content(item, label, content)
-            api.save(item, ActionDescription.REVISION)
+            with new_revision(item):
+                api.update_content(item, label, content)
+                api.save(item, ActionDescription.REVISION)
 
             msg = _('{} updated').format(self._item_type_label)
             tg.flash(msg, CST.STATUS_OK)
 
             api = ContentApi(tmpl_context.current_user)
             item = api.get_one(item_id, ContentType.Any, workspace)
-            api.move_recursively(item, new_parent, new_workspace)
+
+            with new_revision(item):
+                api.move_recursively(item, new_parent, new_workspace)
 
             next_url = tg.url('/workspaces/{}/folders/{}'.format(
                 new_workspace.workspace_id, item_id))
             # Default move inside same workspace
             api = ContentApi(tmpl_context.current_user)
             item = api.get_one(item_id, ContentType.Any, workspace)
-            api.move(item, new_parent)
+            with new_revision(item):
+                api.move(item, new_parent)
             next_url = self.parent_controller.url(item_id)
             if new_parent:
                 tg.flash(_('Item moved to {}').format(new_parent.label), CST.STATUS_OK)
             logger.error(self, 'An unexpected exception has been catched. Look at the traceback below.')
             traceback.print_exc()
 
-            tg.flash(_('Folder not created: {}').format(e.with_traceback()), CST.STATUS_ERROR)
+            tb = sys.exc_info()[2]
+            tg.flash(_('Folder not created: {}').format(e.with_traceback(tb)), CST.STATUS_ERROR)
             if parent_id:
                 redirect_url = redirect_url_tmpl.format(tmpl_context.workspace_id, parent_id)
             else:
                 file = True if can_contain_files=='on' else False,
                 page = True if can_contain_pages=='on' else False
             )
-            if label != folder.label:
-                # TODO - D.A. - 2015-05-25 - Allow to set folder description
-                api.update_content(folder, label, folder.description)
-            api.set_allowed_content(folder, subcontent)
-            api.save(folder)
+            with new_revision(folder):
+                if label != folder.label:
+                    # TODO - D.A. - 2015-05-25 - Allow to set folder description
+                    api.update_content(folder, label, folder.description)
+                api.set_allowed_content(folder, subcontent)
+                api.save(folder)
 
             tg.flash(_('Folder updated'), CST.STATUS_OK)
 
             undo_url = self._std_url.format(item.workspace_id, item.content_id)+'/put_archive_undo'
             msg = _('{} archived. <a class="alert-link" href="{}">Cancel action</a>').format(self._item_type_label, undo_url)
 
-            content_api.archive(item)
-            content_api.save(item, ActionDescription.ARCHIVING)
+            with new_revision(item):
+                content_api.archive(item)
+                content_api.save(item, ActionDescription.ARCHIVING)
 
             tg.flash(msg, CST.STATUS_OK, no_escape=True) # TODO allow to come back
             tg.redirect(next_url)
         try:
             next_url = self._std_url.format(item.workspace_id, item.content_id)
             msg = _('{} unarchived.').format(self._item_type_label)
-            content_api.unarchive(item)
-            content_api.save(item, ActionDescription.UNARCHIVING)
+            with new_revision(item):
+                content_api.unarchive(item)
+                content_api.save(item, ActionDescription.UNARCHIVING)
 
             tg.flash(msg, CST.STATUS_OK)
             tg.redirect(next_url )
             next_url = self._parent_url.format(item.workspace_id, item.parent_id)
             undo_url = self._std_url.format(item.workspace_id, item.content_id)+'/put_delete_undo'
             msg = _('{} deleted. <a class="alert-link" href="{}">Cancel action</a>').format(self._item_type_label, undo_url)
-            content_api.delete(item)
-            content_api.save(item, ActionDescription.DELETION)
+            with new_revision(item):
+                content_api.delete(item)
+                content_api.save(item, ActionDescription.DELETION)
 
             tg.flash(msg, CST.STATUS_OK, no_escape=True)
             tg.redirect(next_url)
         try:
             next_url = self._std_url.format(item.workspace_id, item.content_id)
             msg = _('{} undeleted.').format(self._item_type_label)
-            content_api.undelete(item)
-            content_api.save(item, ActionDescription.UNDELETION)
+            with new_revision(item):
+                content_api.undelete(item)
+                content_api.save(item, ActionDescription.UNDELETION)
 
             tg.flash(msg, CST.STATUS_OK)
             tg.redirect(next_url)

tracim/tracim/lib/content.py

 # -*- coding: utf-8 -*-
-
 __author__ = 'damien'
 
 import datetime
 from sqlalchemy.orm.attributes import get_history
 from sqlalchemy import desc
 from sqlalchemy import distinct
-from sqlalchemy import not_
 from sqlalchemy import or_
+from sqlalchemy.sql.elements import and_
 from tracim.lib import cmp_to_key
 from tracim.lib.notifications import NotifierFactory
 from tracim.lib.utils import SameValueError
 from tracim.model import DBSession
 from tracim.model.auth import User
-from tracim.model.data import ActionDescription
+from tracim.model.data import ActionDescription, new_revision
 from tracim.model.data import BreadcrumbItem
 from tracim.model.data import ContentStatus
 from tracim.model.data import ContentRevisionRO
         self._show_deleted = show_deleted
         self._show_all_type_of_contents_in_treeview = all_content_in_treeview
 
+    @classmethod
+    def get_revision_join(cls):
+        """
+        Return the Content/ContentRevision query join condition
+        :return: Content/ContentRevision query join condition
+        :rtype sqlalchemy.sql.elements.BooleanClauseList
+        """
+        return and_(Content.id == ContentRevisionRO.content_id,
+                    ContentRevisionRO.revision_id == DBSession.query(
+                        ContentRevisionRO.revision_id)
+                    .filter(ContentRevisionRO.content_id == Content.id)
+                    .order_by(ContentRevisionRO.revision_id.desc())
+                    .limit(1)
+                    .correlate(Content))
+
+    @classmethod
+    def get_base_query(cls):
+        """
+        Return the Content/ContentRevision base query who join these table on the last revision.
+        :return: Content/ContentRevision Query
+        :rtype sqlalchemy.orm.query.Query
+        """
+        return DBSession.query(Content).join(ContentRevisionRO, cls.get_revision_join())
 
     @classmethod
     def sort_tree_items(cls, content_list: [NodeTreeItem])-> [Content]:
         return breadcrumb
 
     def __real_base_query(self, workspace: Workspace=None):
-        result = DBSession.query(Content)
+        result = self.get_base_query()
 
         if workspace:
             result = result.filter(Content.workspace_id==workspace.workspace_id)
         self.save(item, do_notify=False)
 
         for child in item.children:
-            self.move_recursively(child, item, new_workspace)
+            with new_revision(child):
+                self.move_recursively(child, item, new_workspace)
         return
 
     def update_content(self, item: Content, new_label: str, new_content: str=None) -> Content:
         content.is_archived = False
         content.revision_type = ActionDescription.UNARCHIVING
 
-
     def delete(self, content: Content):
         content.owner = self._user
         content.is_deleted = True
 
         if not action_description:
             # See if the last action has been modified
-            if content.revision_type==None or len(get_history(content, 'revision_type'))<=0:
+            if content.revision_type==None or len(get_history(content.revision, 'revision_type'))<=0:
                 # The action has not been modified, so we set it to default edition
                 action_description = ActionDescription.EDITION
 
         filter_group_desc = list(Content.description.ilike('%{}%'.format(keyword)) for keyword in keywords)
         title_keyworded_items = self._hard_filtered_base_query().\
             filter(or_(*(filter_group_label+filter_group_desc))).\
-            options(joinedload('children')).\
+            options(joinedload('children_revisions')).\
             options(joinedload('parent'))
 
         return title_keyworded_items

tracim/tracim/lib/exception.py

     pass
 
 
+class RunTimeError(TracimError):
+    pass
+
+
+class ContentRevisionUpdateError(RuntimeError):
+    pass
+
+
+class ContentRevisionDeleteError(ContentRevisionUpdateError):
+    pass
+
+
 class ConfigurationError(TracimError):
     pass
 

tracim/tracim/model/__init__.py

 # -*- coding: utf-8 -*-
 """The application's model objects"""
+from sqlalchemy import event, inspect
+from sqlalchemy.ext.declarative import declarative_base
+from sqlalchemy.orm import scoped_session, sessionmaker
 
 from zope.sqlalchemy import ZopeTransactionExtension
-from sqlalchemy.orm import scoped_session, sessionmaker
-#from sqlalchemy import MetaData
-from sqlalchemy.ext.declarative import declarative_base
+
+from tracim.lib.exception import ContentRevisionUpdateError, ContentRevisionDeleteError
+
+
+class RevisionsIntegrity(object):
+    _updatable_revisions = []
+
+    @classmethod
+    def add_to_updatable(cls, revision):
+        if inspect(revision).has_identity:
+            raise ContentRevisionUpdateError("ContentRevision is not updatable. %s already have identity." % revision)
+
+        if revision not in cls._updatable_revisions:
+            cls._updatable_revisions.append(revision)
+
+    @classmethod
+    def remove_from_updatable(cls, revision):
+        cls._updatable_revisions.remove(revision)
+
+    @classmethod
+    def is_updatable(cls, revision):
+        return revision in cls._updatable_revisions
 
 # Global session manager: DBSession() returns the Thread-local
 # session object appropriate for the current web request.
 #
 ######
 
+
 def init_model(engine):
     """Call me before using any of the tables or classes in the model."""
     DBSession.configure(bind=engine)
 
 # Import your model modules here.
 from tracim.model.auth import User, Group, Permission
-from tracim.model.data import Content
+from tracim.model.data import Content, ContentRevisionRO
+
+
+@event.listens_for(DBSession, 'before_flush')
+def prevent_content_revision_delete(session, flush_context, instances):
+    for instance in session.deleted:
+        if isinstance(instance, ContentRevisionRO) and instance.revision_id is not None:
+            raise ContentRevisionDeleteError("ContentRevision is not deletable. You must make a new revision with" +
+                                             "is_deleted set to True. Look at tracim.model.data.new_revision context " +
+                                             "manager to make a new revision")

tracim/tracim/model/data.py

 # -*- coding: utf-8 -*-
 
-import tg
-from datetime import datetime
-from babel.dates import format_timedelta
-
-from bs4 import BeautifulSoup
 import datetime as datetime_root
 import json
+from datetime import datetime
 
-from sqlalchemy.ext.associationproxy import association_proxy
-from sqlalchemy import Column
-from sqlalchemy import func
+import tg
+from babel.dates import format_timedelta
+from bs4 import BeautifulSoup
+from decorator import contextmanager
+from sqlalchemy import Column, inspect
 from sqlalchemy import ForeignKey
 from sqlalchemy import Sequence
-
+from sqlalchemy import func
+from sqlalchemy.ext.associationproxy import association_proxy
 from sqlalchemy.ext.hybrid import hybrid_property
-
 from sqlalchemy.orm import backref
-from sqlalchemy.orm import relationship
 from sqlalchemy.orm import deferred
+from sqlalchemy.orm import relationship
 from sqlalchemy.orm.collections import attribute_mapped_collection
-
 from sqlalchemy.types import Boolean
 from sqlalchemy.types import DateTime
 from sqlalchemy.types import Integer
 from sqlalchemy.types import LargeBinary
 from sqlalchemy.types import Text
 from sqlalchemy.types import Unicode
-
 from tg.i18n import lazy_ugettext as l_, ugettext as _
 
-from tracim.model import DeclarativeBase
+from tracim.lib.exception import ContentRevisionUpdateError
+from tracim.model import DeclarativeBase, DBSession, RevisionsIntegrity
 from tracim.model.auth import User
 
+
 class BreadcrumbItem(object):
 
     def __init__(self, icon_string: str, label: str, url: str, is_active: bool = False):
     label   = Column(Unicode(1024), unique=False, nullable=False, default='')
     description = Column(Text(), unique=False, nullable=False, default='')
 
-    created = Column(DateTime, unique=False, nullable=False)
-    updated = Column(DateTime, unique=False, nullable=False)
+    created = Column(DateTime, unique=False, nullable=False, default=datetime.now())
+    updated = Column(DateTime, unique=False, nullable=False, default=datetime.now())
 
     is_deleted = Column(Boolean, unique=False, nullable=False, default=False)
 
+    revisions = relationship("ContentRevisionRO")
+
+    @hybrid_property
+    def contents(self):
+        # Return a list of unique revisions parent content
+        return list(set([revision.node for revision in self.revisions]))
+
     def get_user_role(self, user: User) -> int:
         for role in user.roles:
             if role.workspace.workspace_id==self.workspace_id:
                     label=self.label,
                     priority=self.priority)
 
-class Content(DeclarativeBase):
 
-    __tablename__ = 'contents'
+class ContentChecker(object):
 
-    revision_to_serialize = -0  # This flag allow to serialize a given revision if required by the user
+    @classmethod
+    def check_properties(cls, item):
+        if item.type==ContentType.Folder:
+            properties = item.properties
+            if 'allowed_content' not in properties.keys():
+                return False
+            if 'folders' not in properties['allowed_content']:
+                return False
+            if 'files' not in properties['allowed_content']:
+                return False
+            if 'pages' not in properties['allowed_content']:
+                return False
+            if 'threads' not in properties['allowed_content']:
+                return False
 
-    content_id = Column(Integer, Sequence('seq__contents__content_id'), autoincrement=True, primary_key=True)
-    parent_id = Column(Integer, ForeignKey('contents.content_id'), nullable=True, default=None)
-    owner_id = Column(Integer, ForeignKey('users.user_id'), nullable=True, default=None)
+            return True
 
-    type = Column(Unicode(32), unique=False, nullable=False)
-    status = Column(Unicode(32), unique=False, nullable=False, default=ContentStatus.OPEN)
+        raise NotImplementedError
 
-    created = Column(DateTime, unique=False, nullable=False)
-    updated = Column(DateTime, unique=False, nullable=False)
+    @classmethod
+    def reset_properties(cls, item):
+        if item.type==ContentType.Folder:
+            item.properties = dict(
+                allowed_content = dict (
+                    folder = True,
+                    file = True,
+                    page = True,
+                    thread = True
+                )
+            )
+            return
 
-    workspace_id = Column(Integer, ForeignKey('workspaces.workspace_id'), unique=False, nullable=True)
+        raise NotImplementedError
 
-    workspace = relationship('Workspace', remote_side=[Workspace.workspace_id], backref='contents')
 
+class ContentRevisionRO(DeclarativeBase):
+    """
+    Revision of Content. It's immutable, update or delete an existing ContentRevisionRO will throw
+    ContentRevisionUpdateError errors.
+    """
 
-    is_deleted = Column(Boolean, unique=False, nullable=False, default=False)
-    is_archived = Column(Boolean, unique=False, nullable=False, default=False)
+    __tablename__ = 'content_revisions'
 
-    label = Column(Unicode(1024), unique=False, nullable=False, default='')
-    description = Column(Text(), unique=False, nullable=False, default='')
-    _properties = Column('properties', Text(), unique=False, nullable=False, default='')
+    revision_id = Column(Integer, primary_key=True)
+    content_id = Column(Integer, ForeignKey('content.id'))
+    owner_id = Column(Integer, ForeignKey('users.user_id'), nullable=True)
 
+    label = Column(Unicode(1024), unique=False, nullable=False)
+    description = Column(Text(), unique=False, nullable=False, default='')
     file_name = Column(Unicode(255),  unique=False, nullable=False, default='')
     file_mimetype = Column(Unicode(255),  unique=False, nullable=False, default='')
-    file_content = deferred(Column(LargeBinary(), unique=False, nullable=False, default=None))
+    file_content = deferred(Column(LargeBinary(), unique=False, nullable=True))
+    properties = Column('properties', Text(), unique=False, nullable=False, default='')
 
+    type = Column(Unicode(32), unique=False, nullable=False)
+    status = Column(Unicode(32), unique=False, nullable=False, default=ContentStatus.OPEN)
+    created = Column(DateTime, unique=False, nullable=False, default=datetime.now())
+    updated = Column(DateTime, unique=False, nullable=False, default=datetime.now())
+    is_deleted = Column(Boolean, unique=False, nullable=False, default=False)
+    is_archived = Column(Boolean, unique=False, nullable=False, default=False)
     revision_type = Column(Unicode(32), unique=False, nullable=False, default='')
 
-    parent = relationship('Content', remote_side=[content_id], backref='children')
+    workspace_id = Column(Integer, ForeignKey('workspaces.workspace_id'), unique=False, nullable=True)
+    workspace = relationship('Workspace', remote_side=[Workspace.workspace_id])
+
+    parent_id = Column(Integer, ForeignKey('content.id'), nullable=True, default=None)
+    parent = relationship("Content", foreign_keys=[parent_id], back_populates="children_revisions")
+
+    node = relationship("Content", foreign_keys=[content_id], back_populates="revisions")
     owner = relationship('User', remote_side=[User.user_id])
 
+    """ List of column copied when make a new revision from another """
+    _cloned_columns = (
+        'content_id', 'owner_id', 'label', 'description', 'file_name', 'file_mimetype',
+        'file_content', 'type', 'status', 'created', 'updated', 'is_deleted', 'is_archived',
+        'revision_type', 'workspace_id', 'workspace', 'parent_id', 'parent', 'node', 'owner'
+    )
+
+    @classmethod
+    def new_from(cls, revision):
+        """
+
+        Return new instance of ContentRevisionRO where properties are copied from revision parameter.
+        Look at ContentRevisionRO._cloned_columns to see what columns are copieds.
+
+        :param revision: revision to copy
+        :type revision: ContentRevisionRO
+        :return: new revision from revision parameter
+        :rtype: ContentRevisionRO
+        """
+        new_rev = cls()
+
+        for column_name in cls._cloned_columns:
+            column_value = getattr(revision, column_name)
+            setattr(new_rev, column_name, column_value)
+
+        return new_rev
+
+    def __setattr__(self, key, value):
+        """
+        ContentRevisionUpdateError is raised if tried to update column and revision own identity
+        :param key: attribute name
+        :param value: attribute value
+        :return:
+        """
+        if key in ('_sa_instance_state', ):  # Prevent infinite loop from SQLAlchemy code and altered set
+            return super().__setattr__(key, value)
+
+        if inspect(self).has_identity \
+                and key in self._cloned_columns \
+                and not RevisionsIntegrity.is_updatable(self):
+                raise ContentRevisionUpdateError(
+                    "Can't modify revision. To work on new revision use tracim.model.data.new_revision " +
+                    "context manager.")
+
+        super().__setattr__(key, value)
+
+    def get_status(self):
+        return ContentStatus(self.status)
+
+    def get_label(self):
+        return self.label if self.label else self.file_name if self.file_name else ''
+
+    def get_last_action(self) -> ActionDescription:
+        return ActionDescription(self.revision_type)
+
+    # Read by must be used like this:
+    # read_datetime = revision.ready_by[<User instance>]
+    # if user did not read the content, then a key error is raised
+    read_by = association_proxy(
+        'revision_read_statuses',  # name of the attribute
+        'view_datetime',  # attribute the value is taken from
+        creator=lambda k, v: \
+            RevisionReadStatus(user=k, view_datetime=v)
+    )
+
+    def has_new_information_for(self, user: User) -> bool:
+        """
+        :param user: the session current user
+        :return: bool, True if there is new information for given user else False
+                       False if the user is None
+        """
+        if not user:
+            return False
+
+        if user not in self.read_by.keys():
+            return True
+
+        return False
+
+
+class Content(DeclarativeBase):
+    """
+    Content is used as a virtual representation of ContentRevisionRO.
+    content.PROPERTY (except for content.id, content.revisions, content.children_revisions) will return
+    value of most recent revision of content.
+
+    # UPDATE A CONTENT
+
+    To update an existing Content, you must use tracim.model.data.new_revision context manager:
+    content = my_sontent_getter_method()
+    with new_revision(content):
+        content.description = 'foo bar baz'
+    DBSession.flush()
+
+    # QUERY CONTENTS
+
+    To query contents you will need to join your content query with ContentRevisionRO. Join
+    condition is available at tracim.lib.content.ContentApi#get_revision_join:
+
+    content = DBSession.query(Content).join(ContentRevisionRO, ContentApi.get_revision_join())
+                  .filter(Content.label == 'foo')
+                  .one()
+
+    ContentApi provide also prepared Content at tracim.lib.content.ContentApi#get_base_query:
+
+    content = ContentApi.get_base_query()
+              .filter(Content.label == 'foo')
+              .one()
+    """
+
+    __tablename__ = 'content'
+
+    revision_to_serialize = -0  # This flag allow to serialize a given revision if required by the user
+
+    id = Column(Integer, primary_key=True)
+    revisions = relationship("ContentRevisionRO",
+                             foreign_keys=[ContentRevisionRO.content_id],
+                             back_populates="node")
+    children_revisions = relationship("ContentRevisionRO",
+                                      foreign_keys=[ContentRevisionRO.parent_id],
+                                      back_populates="parent")
+
+    @hybrid_property
+    def content_id(self):
+        return self.revision.content_id
+
+    @content_id.setter
+    def content_id(self, value):
+        self.revision.content_id = value
+
+    @content_id.expression
+    def content_id(cls):
+        return ContentRevisionRO.content_id
+
+    @hybrid_property
+    def revision_id(self):
+        return self.revision.revision_id
+
+    @revision_id.setter
+    def revision_id(self, value):
+        self.revision.revision_id = value
+
+    @revision_id.expression
+    def revision_id(cls):
+        return ContentRevisionRO.revision_id
+
+    @hybrid_property
+    def owner_id(self):
+        return self.revision.owner_id
+
+    @owner_id.setter
+    def owner_id(self, value):
+        self.revision.owner_id = value
+
+    @owner_id.expression
+    def owner_id(cls):
+        return ContentRevisionRO.owner_id
+
+    @hybrid_property
+    def label(self):
+        return self.revision.label
+
+    @label.setter
+    def label(self, value):
+        self.revision.label = value
+
+    @label.expression
+    def label(cls):
+        return ContentRevisionRO.label
+
+    @hybrid_property
+    def description(self):
+        return self.revision.description
+
+    @description.setter
+    def description(self, value):
+        self.revision.description = value
+
+    @description.expression
+    def description(cls):
+        return ContentRevisionRO.description
+
+    @hybrid_property
+    def file_name(self):
+        return self.revision.file_name
+
+    @file_name.setter
+    def file_name(self, value):
+        self.revision.file_name = value
+
+    @file_name.expression
+    def file_name(cls):
+        return ContentRevisionRO.file_name
+
+    @hybrid_property
+    def file_mimetype(self):
+        return self.revision.file_mimetype
+
+    @file_mimetype.setter
+    def file_mimetype(self, value):
+        self.revision.file_mimetype = value
+
+    @file_mimetype.expression
+    def file_mimetype(cls):
+        return ContentRevisionRO.file_mimetype
+
+    @hybrid_property
+    def file_content(self):
+        return self.revision.file_content
+
+    @file_content.setter
+    def file_content(self, value):
+        self.revision.file_content = value
+
+    @file_content.expression
+    def file_content(cls):
+        return ContentRevisionRO.file_content
+
+    @hybrid_property
+    def _properties(self):
+        return self.revision.properties
+
+    @_properties.setter
+    def _properties(self, value):
+        self.revision.properties = value
+
+    @_properties.expression
+    def _properties(cls):
+        return ContentRevisionRO.properties
+
+    @hybrid_property
+    def type(self):
+        return self.revision.type
+
+    @type.setter
+    def type(self, value):
+        self.revision.type = value
+
+    @type.expression
+    def type(cls):
+        return ContentRevisionRO.type
+
+    @hybrid_property
+    def status(self):
+        return self.revision.status
+
+    @status.setter
+    def status(self, value):
+        self.revision.status = value
+
+    @status.expression
+    def status(cls):
+        return ContentRevisionRO.status
+
+    @hybrid_property
+    def created(self):
+        return self.revision.created
+
+    @created.setter
+    def created(self, value):
+        self.revision.created = value
+
+    @created.expression
+    def created(cls):
+        return ContentRevisionRO.created
+
+    @hybrid_property
+    def updated(self):
+        return self.revision.updated
+
+    @updated.setter
+    def updated(self, value):
+        self.revision.updated = value
+
+    @updated.expression
+    def updated(cls):
+        return ContentRevisionRO.updated
+
+    @hybrid_property
+    def is_deleted(self):
+        return self.revision.is_deleted
+
+    @is_deleted.setter
+    def is_deleted(self, value):
+        self.revision.is_deleted = value
+
+    @is_deleted.expression
+    def is_deleted(cls):
+        return ContentRevisionRO.is_deleted
+
+    @hybrid_property
+    def is_archived(self):
+        return self.revision.is_archived
+
+    @is_archived.setter
+    def is_archived(self, value):
+        self.revision.is_archived = value
+
+    @is_archived.expression
+    def is_archived(cls):
+        return ContentRevisionRO.is_archived
+
+    @hybrid_property
+    def revision_type(self):
+        return self.revision.revision_type
+
+    @revision_type.setter
+    def revision_type(self, value):
+        self.revision.revision_type = value
+
+    @revision_type.expression
+    def revision_type(cls):
+        return ContentRevisionRO.revision_type
+
+    @hybrid_property
+    def workspace_id(self):
+        return self.revision.workspace_id
+
+    @workspace_id.setter
+    def workspace_id(self, value):
+        self.revision.workspace_id = value
+
+    @workspace_id.expression
+    def workspace_id(cls):
+        return ContentRevisionRO.workspace_id
+
+    @hybrid_property
+    def workspace(self):
+        return self.revision.workspace
+
+    @workspace.setter
+    def workspace(self, value):
+        self.revision.workspace = value
+
+    @workspace.expression
+    def workspace(cls):
+        return ContentRevisionRO.workspace
+
+    @hybrid_property
+    def parent_id(self):
+        return self.revision.parent_id
+
+    @parent_id.setter
+    def parent_id(self, value):
+        self.revision.parent_id = value
+
+    @parent_id.expression
+    def parent_id(cls):
+        return ContentRevisionRO.parent_id
+
+    @hybrid_property
+    def parent(self):
+        return self.revision.parent
+
+    @parent.setter
+    def parent(self, value):
+        self.revision.parent = value
+
+    @parent.expression
+    def parent(cls):
+        return ContentRevisionRO.parent
+
+    @hybrid_property
+    def node(self):
+        return self.revision.node
+
+    @node.setter
+    def node(self, value):
+        self.revision.node = value
+
+    @node.expression
+    def node(cls):
+        return ContentRevisionRO.node
+
+    @hybrid_property
+    def owner(self):
+        return self.revision.owner
+
+    @owner.setter
+    def owner(self, value):
+        self.revision.owner = value
+
+    @owner.expression
+    def owner(cls):
+        return ContentRevisionRO.owner
+
+    @hybrid_property
+    def children(self):
+        """
+        :return: list of children Content
+        :rtype Content
+        """
+        # Return a list of unique revisions parent content
+        return list(set([revision.node for revision in self.children_revisions]))
+
+    @property
+    def revision(self):
+        return self.get_current_revision()
+
+    def get_current_revision(self):
+        if not self.revisions:
+            return self.new_revision()
+
+        # If last revisions revision don't have revision_id, return it we just add it.
+        if self.revisions[-1].revision_id is None:
+            return self.revisions[-1]
+
+        # Revisions should be ordred by revision_id but we ensure that here
+        revisions = sorted(self.revisions, key=lambda revision: revision.revision_id)
+        return revisions[-1]
+
+    def new_revision(self):
+        """
+        Return and assign to this content a new revision.
+        If it's a new content, revision is totally new.
+        If this content already own revision, revision is build from last revision.
+        :return:
+        """
+        if not self.revisions:
+            self.revisions.append(ContentRevisionRO())
+            return self.revisions[0]
+
+        new_rev = ContentRevisionRO.new_from(self.get_current_revision())
+        self.revisions.append(new_rev)
+        return new_rev
+
     def get_valid_children(self, content_types: list=None) -> ['Content']:
         for child in self.children:
             if not child.is_deleted and not child.is_archived:
                 if not content_types or child.type in content_types:
-                    yield child
+                    yield child.node
 
     @hybrid_property
     def properties(self):
             'html.parser'  # Fixes hanging bug - http://stackoverflow.com/questions/12618567/problems-running-beautifulsoup4-within-apache-mod-python-django
         )
 
-
         for link in soup.findAll('a'):
             href = link.get('href')
             label = link.contents
         ## FIXME - Does this return a sorted list ???!
         return sorted_links
 
-
     def get_child_nb(self, content_type: ContentType, content_status = ''):
         child_nb = 0
         for child in self.get_valid_children():
         children = []
         for child in self.children:
             if ContentType.Comment==child.type and not child.is_deleted and not child.is_archived:
-                children.append(child)
+                children.append(child.node)
         return children
 
     def get_last_comment_from(self, user: User) -> 'Content':
 
         return None
 
-    def get_current_revision(self) -> 'ContentRevisionRO':
-        # TODO - D.A. - 2015-08-26
-        # This code is not efficient at all!!!
-        # We should get the revision id directly from the view
-        rev_ids = [revision.revision_id for revision in self.revisions]
-        rev_ids.sort()
-
-        for revision in self.revisions:
-            if revision.revision_id == rev_ids[-1]:
-                return revision
-
-        return None
-
     def description_as_raw_text(self):
         # 'html.parser' fixes a hanging bug
         # see http://stackoverflow.com/questions/12618567/problems-running-beautifulsoup4-within-apache-mod-python-django
         return url_template.format(wid=wid, fid=fid, ctype=ctype, cid=cid)
 
 
-class ContentChecker(object):
-
-    @classmethod
-    def check_properties(cls, item: Content):
-        if item.type==ContentType.Folder:
-            properties = item.properties
-            if 'allowed_content' not in properties.keys():
-                return False
-            if 'folders' not in properties['allowed_content']:
-                return False
-            if 'files' not in properties['allowed_content']:
-                return False
-            if 'pages' not in properties['allowed_content']:
-                return False
-            if 'threads' not in properties['allowed_content']:
-                return False
-
-            return True
-
-        raise NotImplementedError
-
-    @classmethod
-    def reset_properties(cls, item: Content):
-        if item.type==ContentType.Folder:
-            item.properties = dict(
-                allowed_content = dict (
-                    folder = True,
-                    file = True,
-                    page = True,
-                    thread = True
-                )
-            )
-            return
-
-        raise NotImplementedError
-
-
-class ContentRevisionRO(DeclarativeBase):
-
-    __tablename__ = 'content_revisions'
-
-    revision_id = Column(Integer, Sequence('seq__content_revisions__revision_id'), primary_key=True)
-    content_id = Column(Integer, ForeignKey('contents.content_id'))
-    owner_id = Column(Integer, ForeignKey('users.user_id'), nullable=True)
-    label = Column(Unicode(1024), unique=False, nullable=False)
-    description = Column(Text(), unique=False, nullable=False, default='')
-    file_name = Column(Unicode(255),  unique=False, nullable=False, default='')
-    file_mimetype = Column(Unicode(255),  unique=False, nullable=False, default='')
-    file_content = deferred(Column(LargeBinary(), unique=False, nullable=False, default=None))
-
-    type = Column(Unicode(32), unique=False, nullable=False)
-    status = Column(Unicode(32), unique=False, nullable=False)
-    created = Column(DateTime, unique=False, nullable=False)
-    updated = Column(DateTime, unique=False, nullable=False)
-    is_deleted = Column(Boolean, unique=False, nullable=False)
-    is_archived = Column(Boolean, unique=False, nullable=False)
-    revision_type = Column(Unicode(32), unique=False, nullable=False, default='')
-
-    workspace_id = Column(Integer, ForeignKey('workspaces.workspace_id'), unique=False, nullable=True)
-    workspace = relationship('Workspace', remote_side=[Workspace.workspace_id])
-
-    node = relationship('Content', remote_side=[Content.content_id], backref='revisions')
-    owner = relationship('User', remote_side=[User.user_id])
-
-    def get_status(self):
-        return ContentStatus(self.status)
-
-    def get_label(self):
-        return self.label if self.label else self.file_name if self.file_name else ''
-
-    def get_last_action(self) -> ActionDescription:
-        return ActionDescription(self.revision_type)
-
-    # Read by must be used like this:
-    # read_datetime = revision.ready_by[<User instance>]
-    # if user did not read the content, then a key error is raised
-    read_by = association_proxy(
-        'revision_read_statuses',  # name of the attribute
-        'view_datetime',  # attribute the value is taken from
-        creator=lambda k, v: \
-            RevisionReadStatus(user=k, view_datetime=v)
-    )
-
-    def has_new_information_for(self, user: User) -> bool:
-        """
-        :param user: the session current user
-        :return: bool, True if there is new information for given user else False
-                       False if the user is None
-        """
-        if not user:
-            return False
-
-        if user not in self.read_by.keys():
-            return True
+@contextmanager
+def new_revision(content):
+    """
+    Prepare context to update a Content. It will add a new updatable revision to the content.
+    :param content: Content instance to update
+    :return:
+    """
+    with DBSession.no_autoflush:
+        try:
+            if inspect(content.revision).has_identity:
+                content.new_revision()
+            RevisionsIntegrity.add_to_updatable(content.revision)
+            yield content.revision
+        finally:
+            RevisionsIntegrity.remove_from_updatable(content.revision)
 
-        return False
 
 class RevisionReadStatus(DeclarativeBase):
 
     user_id = Column(Integer, ForeignKey('users.user_id', ondelete='CASCADE', onupdate='CASCADE'), primary_key=True)
     view_datetime = Column(DateTime, unique=False, nullable=False, server_default=func.now())
 
-    # content_revision = relationship(
-    #     'ContentRevisionRO',
-    #     remote_side=[ContentRevisionRO.revision_id],
-    #     backref='revision_read_statuses')
-
     content_revision = relationship(
         'ContentRevisionRO',
         backref=backref(

tracim/tracim/model/serializers.py

         try:
             converter = Context._converters[context_string][model_class]
             return converter
-        except:
+        except KeyError:
             if CTX.DEFAULT in Context._converters:
                 if model_class in Context._converters[CTX.DEFAULT]:
                     return Context._converters[CTX.DEFAULT][model_class]

tracim/tracim/tests/__init__.py

 """Unit and functional test suite for tracim."""
 import argparse
 import os
+import time
 from os import getcwd
 
 import ldap3
 import tg
-import time
 import transaction
 from gearbox.commands.setup_app import SetupAppCommand
 from ldap_test import LdapServer
+from nose.tools import eq_
 from nose.tools import ok_
 from paste.deploy import loadapp
 from sqlalchemy.engine import reflection
 from tracim.fixtures import FixturesLoader
 from tracim.fixtures.users_and_groups import Base as BaseFixture
 from tracim.lib.base import logger
-from tracim.model import DBSession
+from tracim.lib.content import ContentApi
+from tracim.model import DBSession, Content
+from tracim.model.data import Workspace, ContentType, ContentRevisionRO
 
 __all__ = ['setup_app', 'setup_db', 'teardown_db', 'TestController']
 
 class ArgumentParser(argparse.ArgumentParser):
     def exit(self, status=0, message=None):
         raise Exception(message)
+
+
+class BaseTest(object):
+
+    def _create_workspace(self, name, *args, **kwargs):
+        """
+        All extra parameters (*args, **kwargs) are for Workspace init
+        :return: Created workspace instance
+        :rtype: Workspace
+        """
+        workspace = Workspace(label=name, *args, **kwargs)
+        DBSession.add(workspace)
+        DBSession.flush()
+
+        eq_(1, DBSession.query(Workspace).filter(Workspace.label == name).count())
+        return DBSession.query(Workspace).filter(Workspace.label == name).one()
+
+    def _create_content(self, name, workspace, *args, **kwargs):
+        """
+        All extra parameters (*args, **kwargs) are for Content init
+        :return: Created Content instance
+        :rtype: Content
+        """
+        content = Content(*args, **kwargs)
+        content.label = name
+        content.workspace = workspace
+        DBSession.add(content)
+        DBSession.flush()
+
+        eq_(1, ContentApi.get_base_query().filter(Content.label == name).count())
+        return ContentApi.get_base_query().filter(Content.label == name).one()
+
+
+class BaseTestThread(BaseTest):
+
+    def _create_thread(self, workspace_name='workspace_1', folder_name='folder_1', thread_name='thread_1'):
+        """
+        :return: Thread
+        :rtype: Content
+        """
+        workspace = self._create_workspace(workspace_name)
+        folder = self._create_content(folder_name, workspace, type=ContentType.Folder)
+        thread = self._create_content(thread_name, workspace, type=ContentType.Thread, parent=folder)
+        return thread

tracim/tracim/tests/library/test_content_api.py

 from tracim.lib.user import UserApi
 from tracim.lib.workspace import RoleApi
 from tracim.lib.workspace import WorkspaceApi
+from tracim.model import DBSession
 
 from tracim.model.auth import Group
 
-from tracim.model.data import ActionDescription
+from tracim.model.data import ActionDescription, ContentRevisionRO, Workspace, new_revision
 from tracim.model.data import Content
 from tracim.model.data import ContentType
 from tracim.model.data import UserRoleInWorkspace
         eq_(2, len(items))
 
         items = api.get_all(None, ContentType.Any, workspace)
-        api.delete(items[0])
+        with new_revision(items[0]):
+            api.delete(items[0])
         transaction.commit()
 
         # Refresh instances after commit
         eq_(2, len(items))
 
         items = api.get_all(None, ContentType.Any, workspace)
-        api.archive(items[0])
+        with new_revision(items[0]):
+            api.archive(items[0])
         transaction.commit()
 
         # Refresh instances after commit
                                                         save_now=True)
         api = ContentApi(user)
         c = api.create(ContentType.Folder, workspace, None, 'parent', True)
-        api.set_status(c, 'unknown-status')
+        with new_revision(c):
+            api.set_status(c, 'unknown-status')
 
     def test_set_status_ok(self):
         uapi = UserApi(None)
                                                         save_now=True)
         api = ContentApi(user)
         c = api.create(ContentType.Folder, workspace, 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)
+        with new_revision(c):
+            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)
         u2 = UserApi(None).get_one(u2id)
         api2 = ContentApi(u2)
         content2 = api2.get_one(pcid, ContentType.Any, workspace)
-        api2.update_content(content2, 'this is an updated page', 'new content')
+        with new_revision(content2):
+            api2.update_content(content2, 'this is an updated page', 'new content')
         api2.save(content2)
         transaction.commit()
 
         u2 = UserApi(None).get_one(u2id)
         api2 = ContentApi(u2)
         content2 = api2.get_one(pcid, ContentType.Any, workspace)
-        api2.update_file_data(content2, 'index.html', 'text/html',
-                              b'<html>hello world</html>')
+        with new_revision(content2):
+            api2.update_file_data(content2, 'index.html', 'text/html',
+                                  b'<html>hello world</html>')
         api2.save(content2)
         transaction.commit()
 
         u2 = UserApi(None).get_one(u2id)
         api2 = ContentApi(u2, show_archived=True)
         content2 = api2.get_one(pcid, ContentType.Any, workspace)
-        api2.archive(content2)
+        with new_revision(content2):
+            api2.archive(content2)
         api2.save(content2)
         transaction.commit()
 
         ####
 
         updated2 = api.get_one(pcid, ContentType.Any, workspace)
-        api.unarchive(updated)
+        with new_revision(updated):
+            api.unarchive(updated)
         api.save(updated2)
         eq_(False, updated2.is_archived)
         eq_(ActionDescription.UNARCHIVING, updated2.revision_type)
         u2 = UserApi(None).get_one(u2id)
         api2 = ContentApi(u2, show_deleted=True)
         content2 = api2.get_one(pcid, ContentType.Any, workspace)
-        api2.delete(content2)
+        with new_revision(content2):
+            api2.delete(content2)
         api2.save(content2)
         transaction.commit()
 
         ####
 
         updated2 = api.get_one(pcid, ContentType.Any, workspace)
-        api.undelete(updated)
+        with new_revision(updated2):
+            api.undelete(updated2)
         api.save(updated2)
         eq_(False, updated2.is_deleted)
         eq_(ActionDescription.UNDELETION, updated2.revision_type)
                        'this is randomized folder', True)
         p = api.create(ContentType.Page, workspace, a,
                        'this is randomized label content', True)
-        p.description = 'This is some amazing test'
+
+        with new_revision(p):
+            p.description = 'This is some amazing test'
+
         api.save(p)
         original_id = p.content_id
 
                        'this is randomized folder', True)
         p = api.create(ContentType.Page, workspace, a,
                        'this is dummy label content', True)
-        p.description = 'This is some amazing test'
+
+        with new_revision(p):
+            p.description = 'This is some amazing test'
+
         api.save(p)
         original_id = p.content_id
 
                        'this is randomized folder', True)
         p1 = api.create(ContentType.Page, workspace, a,
                         'this is dummy label content', True)
-        p1.description = 'This is some amazing test'
         p2 = api.create(ContentType.Page, workspace, a, 'Hey ! Jon !', True)
-        p2.description = 'What\'s up ?'
+
+        with new_revision(p1):
+            p1.description = 'This is some amazing test'
+
+        with new_revision(p2):
+            p2.description = 'What\'s up ?'
+
         api.save(p1)
         api.save(p2)
 
         id1 = p1.content_id
         id2 = p2.content_id
 
+        eq_(1, DBSession.query(Workspace).filter(Workspace.label == 'test workspace').count())
+        eq_(1, DBSession.query(ContentRevisionRO).filter(ContentRevisionRO.label == 'this is randomized folder').count())
+        eq_(2, DBSession.query(ContentRevisionRO).filter(ContentRevisionRO.label == 'this is dummy label content').count())
+        eq_(1, DBSession.query(ContentRevisionRO).filter(ContentRevisionRO.description == 'This is some amazing test').count())
+        eq_(2, DBSession.query(ContentRevisionRO).filter(ContentRevisionRO.label == 'Hey ! Jon !').count())
+        eq_(1, DBSession.query(ContentRevisionRO).filter(ContentRevisionRO.description == 'What\'s up ?').count())
+
         res = api.search(['dummy', 'jon'])
         eq_(2, len(res.all()))
 

tracim/tracim/tests/library/test_serializers.py

 from nose.tools import ok_
 from nose.tools import raises
 
-from sqlalchemy.orm.exc import NoResultFound
-
-import transaction
 import tg
 
 from tracim.model import DBSession
 
 from tracim.model.data import ActionDescription
 
-from tracim.lib.user import UserApi
-
 from tracim.tests import TestStandard
 
 
     def test_serializer_content__menui_api_context__children(self):
         folder_without_child = Content()
         folder_without_child.type = ContentType.Folder
+        folder_without_child.label = 'folder_without_child'
         res = Context(CTX.MENU_API).toDict(folder_without_child)
         eq_(False, res['children'])
 
         folder_with_child = Content()
         folder_with_child.type = ContentType.Folder
+        folder_with_child.label = 'folder_with_child'
         folder_without_child.parent = folder_with_child
         DBSession.add(folder_with_child)
         DBSession.add(folder_without_child)
             if curtype not in (ContentType.Folder, ContentType.Comment):
                 item = Content()
                 item.type = curtype
+                item.label = 'item'
 
                 fake_child = Content()
                 fake_child.type = curtype
+                fake_child.label = 'fake_child'
                 fake_child.parent = item
 
                 DBSession.add(item)

tracim/tracim/tests/library/test_thread.py

+# -*- coding: utf-8 -*-
+import transaction
+from nose.tools import eq_
+
+from tracim.tests import BaseTestThread, TestStandard
+
+
+class TestThread(BaseTestThread, TestStandard):
+
+    def test_create_thread(self, key='1'):
+        return self._create_thread(
+            workspace_name='workspace_%s' % key,
+            folder_name='folder_%s' % key,
+            thread_name='thread_%s' % key,
+        )

tracim/tracim/tests/library/test_workspace.py

+# -*- coding: utf-8 -*-
+import transaction
+from nose.tools import eq_
+
+from tracim.lib.content import ContentApi
+from tracim.model import DBSession, Content
+from tracim.model.data import Workspace
+from tracim.tests import BaseTestThread, TestStandard
+
+
+class TestThread(BaseTestThread, TestStandard):
+
+    def test_children(self):
+        self._create_thread(
+            workspace_name='workspace_1',
+            folder_name='folder_1',
+            thread_name='thread_1',
+        )
+        workspace = DBSession.query(Workspace).filter(Workspace.label == 'workspace_1').one()
+        folder = ContentApi.get_base_query().filter(Content.label == 'folder_1').one()
+        eq_([folder, ], list(workspace.get_valid_children()))

tracim/tracim/tests/models/test_content.py

+# -*- coding: utf-8 -*-
+from nose.tools import raises
+from sqlalchemy.orm import aliased
+from sqlalchemy.sql.elements import and_
+from sqlalchemy.testing import eq_
+
+from tracim.lib.content import ContentApi
+from tracim.lib.exception import ContentRevisionUpdateError
+from tracim.model import DBSession, User, Content
+from tracim.model.data import ContentRevisionRO, Workspace, ActionDescription, ContentType, new_revision
+from tracim.tests import TestStandard
+
+
+class TestContent(TestStandard):
+
+    @raises(ContentRevisionUpdateError)
+    def test_update_without_prepare(self):
+        content1 = self.test_create()
+        content1.description = 'FOO'  # Raise ContentRevisionUpdateError because revision can't be updated
+
+    def test_query(self):
+        content1 = self.test_create()
+        with new_revision(content1):
+            content1.description = 'TEST_CONTENT_DESCRIPTION_1_UPDATED'
+        DBSession.flush()
+
+        content2 = self.test_create(key='2')
+        with new_revision(content2):
+            content2.description = 'TEST_CONTENT_DESCRIPTION_2_UPDATED'
+        DBSession.flush()
+
+        workspace1 = DBSession.query(Workspace).filter(Workspace.label == 'TEST_WORKSPACE_1').one()
+        workspace2 = DBSession.query(Workspace).filter(Workspace.label == 'TEST_WORKSPACE_2').one()
+
+        # To get Content in database we have to join Content and ContentRevisionRO with particular condition:
+        # Join have to be on most recent revision
+        join_sub_query = DBSession.query(ContentRevisionRO.revision_id)\
+            .filter(ContentRevisionRO.content_id == Content.id)\
+            .order_by(ContentRevisionRO.revision_id.desc())\
+            .limit(1)\
+            .correlate(Content)
+
+        base_query = DBSession.query(Content)\
+            .join(ContentRevisionRO, and_(Content.id == ContentRevisionRO.content_id,
+                                          ContentRevisionRO.revision_id == join_sub_query))
+
+        eq_(2, base_query.count())
+
+        eq_(1, base_query.filter(Content.workspace == workspace1).count())
+        eq_(1, base_query.filter(Content.workspace == workspace2).count())
+
+        content1_from_query = base_query.filter(Content.workspace == workspace1).one()
+        eq_(content1.id, content1_from_query.id)
+        eq_('TEST_CONTENT_DESCRIPTION_1_UPDATED', content1_from_query.description)
+
+        user_admin = DBSession.query(User).filter(User.email == 'admin@admin.admin').one()
+        api = ContentApi(None)
+
+        content1_from_api = api.get_one(content1.id, ContentType.Page, workspace1)
+
+    def test_update(self):
+        created_content = self.test_create()
+        content = DBSession.query(Content).filter(Content.id == created_content.id).one()
+        eq_(1, DBSession.query(ContentRevisionRO).filter(ContentRevisionRO.label == 'TEST_CONTENT_1').count())
+
+        with new_revision(content):
+            content.description = 'TEST_CONTENT_DESCRIPTION_1_UPDATED'
+        DBSession.flush()
+
+        eq_(2, DBSession.query(ContentRevisionRO).filter(ContentRevisionRO.label == 'TEST_CONTENT_1').count())
+        eq_(1, DBSession.query(Content).filter(Content.id == created_content.id).count())
+
+        with new_revision(content):
+            content.description = 'TEST_CONTENT_DESCRIPTION_1_UPDATED_2'
+            content.label = 'TEST_CONTENT_1_UPDATED_2'
+        DBSession.flush()
+
+        eq_(1, DBSession.query(ContentRevisionRO).filter(ContentRevisionRO.label == 'TEST_CONTENT_1_UPDATED_2').count())
+        eq_(1, DBSession.query(Content).filter(Content.id == created_content.id).count())
+
+    def test_creates(self):
+        eq_(0, DBSession.query(ContentRevisionRO).filter(ContentRevisionRO.label == 'TEST_CONTENT_1').count())
+        eq_(0, DBSession.query(Workspace).filter(Workspace.label == 'TEST_WORKSPACE_1').count())
+
+        user_admin = DBSession.query(User).filter(User.email == 'admin@admin.admin').one()
+        workspace = Workspace(label="TEST_WORKSPACE_1")
+        DBSession.add(workspace)
+        DBSession.flush()
+        eq_(1, DBSession.query(Workspace).filter(Workspace.label == 'TEST_WORKSPACE_1').count())
+
+        first_content = self._create_content(
+            owner=user_admin,
+            workspace=workspace,
+            type=ContentType.Page,
+            label='TEST_CONTENT_1',
+            description='TEST_CONTENT_DESCRIPTION_1',
+            revision_type=ActionDescription.CREATION,
+            is_deleted=False,  # TODO: pk ?
+            is_archived=False,  # TODO: pk ?
+            #file_content=None,  # TODO: pk ? (J'ai du mettre nullable=True)
+        )
+
+        eq_(1, DBSession.query(ContentRevisionRO).filter(ContentRevisionRO.label == 'TEST_CONTENT_1').count())
+
+        content = DBSession.query(Content).filter(Content.id == first_content.id).one()
+        eq_('TEST_CONTENT_1', content.label)
+        eq_('TEST_CONTENT_DESCRIPTION_1', content.description)
+
+        # Create a second content
+        second_content = self._create_content(
+            owner=user_admin,
+            workspace=workspace,
+            type=ContentType.Page,
+            label='TEST_CONTENT_2',
+            description='TEST_CONTENT_DESCRIPTION_2',
+            revision_type=ActionDescription.CREATION
+        )
+
+        eq_(1, DBSession.query(ContentRevisionRO).filter(ContentRevisionRO.label == 'TEST_CONTENT_2').count())
+
+        content = DBSession.query(Content).filter(Content.id == second_content.id).one()
+        eq_('TEST_CONTENT_2', content.label)
+        eq_('TEST_CONTENT_DESCRIPTION_2', content.description)
+
+    def test_create(self, key='1'):
+        eq_(0, DBSession.query(ContentRevisionRO).filter(ContentRevisionRO.label == 'TEST_CONTENT_%s' % key).count())
+        eq_(0, DBSession.query(Workspace).filter(Workspace.label == 'TEST_WORKSPACE_%s' % key).count())
+
+        user_admin = DBSession.query(User).filter(User.email == 'admin@admin.admin').one()
+        workspace = Workspace(label="TEST_WORKSPACE_%s" % key)
+        DBSession.add(workspace)
+        DBSession.flush()
+        eq_(1, DBSession.query(Workspace).filter(Workspace.label == 'TEST_WORKSPACE_%s' % key).count())
+
+        created_content = self._create_content(
+            owner=user_admin,
+            workspace=workspace,
+            type=ContentType.Page,
+            label='TEST_CONTENT_%s' % key,
+            description='TEST_CONTENT_DESCRIPTION_%s' % key,
+            revision_type=ActionDescription.CREATION
+        )
+
+        eq_(1, DBSession.query(ContentRevisionRO).filter(ContentRevisionRO.label == 'TEST_CONTENT_%s' % key).count())
+
+        content = DBSession.query(Content).filter(Content.id == created_content.id).one()
+        eq_('TEST_CONTENT_%s' % key, content.label)
+        eq_('TEST_CONTENT_DESCRIPTION_%s' % key, content.description)
+
+        return created_content
+
+    def _create_content(self, *args, **kwargs):
+        content = Content(*args, **kwargs)
+        DBSession.add(content)
+        DBSession.flush()
+
+        return content

tracim/tracim/websetup/schema.py

     
     # <websetup.websetup.schema.before.metadata.create_all>
     print("Creating tables")
-    # model.metadata.create_all(bind=config['tg.app_globals'].sa_engine)
-
-    # result = config['tg.app_globals'].sa_engine.execute(get_initial_schema())
-    from sqlalchemy import DDL
-    result = model.DBSession.execute(DDL(get_initial_schema()))
-    print("Initial schema created.")
+    model.metadata.create_all(bind=config['tg.app_globals'].sa_engine)
 
     #ALTER TABLE bibi ADD COLUMN popo integer;
 
     alembic_cfg.set_main_option("script_location", "migration")
     alembic_cfg.set_main_option("sqlalchemy.url", config['sqlalchemy.url'])
     alembic.command.stamp(alembic_cfg, "head")
-
-
-def get_initial_schema():
-    return """
-SET statement_timeout = 0;
-SET client_encoding = 'UTF8';
-SET standard_conforming_strings = on;
-SET check_function_bodies = false;
-SET client_min_messages = warning;
-
-SET search_path = public, pg_catalog;
-
-
-CREATE OR REPLACE FUNCTION update_node() RETURNS trigger
-    LANGUAGE plpgsql
-    AS $$
-BEGIN
-INSERT INTO content_revisions (content_id, parent_id, type, created, updated,
-       label, description, status,
-       file_name, file_content, file_mimetype,
-       owner_id, revision_id, workspace_id, is_deleted, is_archived, properties, revision_type) VALUES (NEW.content_id, NEW.parent_id, NEW.type, NEW.created, NEW.updated, NEW.label, NEW.description, NEW.status, NEW.file_name, NEW.file_content, NEW.file_mimetype, NEW.owner_id, nextval('seq__content_revisions__revision_id'), NEW.workspace_id, NEW.is_deleted, NEW.is_archived, NEW.properties, NEW.revision_type);
-return new;
-END;
-$$;
-
-CREATE OR REPLACE FUNCTION set_created() RETURNS trigger
-    LANGUAGE plpgsql
-    AS $$
-BEGIN
-    NEW.created = CURRENT_TIMESTAMP;
-    NEW.updated = CURRENT_TIMESTAMP;
-    RETURN NEW;
-END;
-$$;
-
-CREATE OR REPLACE FUNCTION set_updated() RETURNS trigger
-    LANGUAGE plpgsql
-    AS $$
-BEGIN
-    NEW.updated = CURRENT_TIMESTAMP;
-    RETURN NEW;
-END;
-$$;
-
-SET default_tablespace = '';
-SET default_with_oids = false;
-
-
-CREATE TABLE groups (
-    group_id integer NOT NULL,
-    group_name character varying(16) NOT NULL,
-    display_name character varying(255),
-    created timestamp without time zone
-);
-
-CREATE SEQUENCE seq__groups__group_id
-    START WITH 1
-    INCREMENT BY 1
-    NO MINVALUE
-    NO MAXVALUE
-    CACHE 1;
-
-ALTER SEQUENCE seq__groups__group_id OWNED BY groups.group_id;
-
-CREATE TABLE group_permission (
-    group_id integer NOT NULL,
-    permission_id integer NOT NULL
-);
-
-CREATE SEQUENCE seq__content_revisions__revision_id
-    START WITH 1
-    INCREMENT BY 1
-    NO MINVALUE
-    NO MAXVALUE
-    CACHE 1;
-
-CREATE TABLE content_revisions (
-    content_id integer NOT NULL,
-    parent_id integer,
-    type character varying(16) DEFAULT 'data'::character varying NOT NULL,
-    created timestamp without time zone,
-    updated timestamp without time zone,
-    label character varying(1024),
-    description text DEFAULT ''::text NOT NULL,
-    status character varying(32) DEFAULT 'new'::character varying,
-    file_name character varying(255),
-    file_content bytea,
-    file_mimetype character varying(255),
-    owner_id integer,
-    revision_id integer DEFAULT nextval('seq__content_revisions__revision_id'::regclass) NOT NULL,
-    workspace_id integer,
-    is_deleted boolean DEFAULT false NOT NULL,
-    is_archived boolean DEFAULT false NOT NULL,
-    properties text,
-    revision_type character varying(32)
-);
-
-COMMENT ON COLUMN content_revisions.properties IS 'This column contain properties specific to a given type. these properties are json encoded (so there is no structure "a priori")';
-
-CREATE VIEW contents AS
-    SELECT DISTINCT ON (content_revisions.content_id) content_revisions.content_id, content_revisions.parent_id, content_revisions.type, content_revisions.created, content_revisions.updated, content_revisions.label, content_revisions.description, content_revisions.status, content_revisions.file_name, content_revisions.file_content, content_revisions.file_mimetype, content_revisions.owner_id, content_revisions.workspace_id, content_revisions.is_deleted, content_revisions.is_archived, content_revisions.properties, content_revisions.revision_type FROM content_revisions ORDER BY content_revisions.content_id, content_revisions.updated DESC, content_revisions.created DESC;
-
-CREATE SEQUENCE seq__contents__content_id
-    START WITH 1
-    INCREMENT BY 1
-    NO MINVALUE
-    NO MAXVALUE
-    CACHE 1;
-
-ALTER SEQUENCE seq__contents__content_id OWNED BY content_revisions.content_id;
-
-CREATE TABLE permissions (
-    permission_id integer NOT NULL,
-    permission_name character varying(63) NOT NULL,
-    description character varying(255)
-);
-
-CREATE SEQUENCE seq__permissions__permission_id
-    START WITH 1
-    INCREMENT BY 1
-    NO MINVALUE
-    NO MAXVALUE
-    CACHE 1;
-
-ALTER SEQUENCE seq__permissions__permission_id OWNED BY permissions.permission_id;
-
-CREATE TABLE users (
-    user_id integer NOT NULL,
-    email character varying(255) NOT NULL,
-    display_name character varying(255),
-    password character varying(128),
-    created timestamp without time zone,
-    is_active boolean DEFAULT true NOT NULL,
-    imported_from character varying(32)
-);
-
-CREATE TABLE user_group (
-    user_id integer NOT NULL,
-    group_id integer NOT NULL
-);
-
-CREATE SEQUENCE seq__users__user_id
-    START WITH 1
-    INCREMENT BY 1
-    NO MINVALUE
-    NO MAXVALUE
-    CACHE 1;
-
-ALTER SEQUENCE seq__users__user_id OWNED BY users.user_id;
-
-CREATE TABLE user_workspace (
-    user_id integer NOT NULL,
-    workspace_id integer NOT NULL,
-    role integer,
-    do_notify boolean DEFAULT FALSE NOT NULL
-);
-
-CREATE TABLE workspaces (
-    workspace_id integer NOT NULL,
-    label character varying(1024),
-    description text,
-    created timestamp without time zone,
-    updated timestamp without time zone,
-    is_deleted boolean DEFAULT false NOT NULL
-);
-
-CREATE SEQUENCE seq__workspaces__workspace_id
-    START WITH 11
-    INCREMENT BY 1
-    NO MINVALUE
-    NO MAXVALUE
-    CACHE 1;
-
-ALTER TABLE ONLY groups ALTER COLUMN group_id SET DEFAULT nextval('seq__groups__group_id'::regclass);
-ALTER TABLE ONLY content_revisions ALTER COLUMN content_id SET DEFAULT nextval('seq__contents__content_id'::regclass);
-ALTER TABLE ONLY permissions ALTER COLUMN permission_id SET DEFAULT nextval('seq__permissions__permission_id'::regclass);
-ALTER TABLE ONLY users ALTER COLUMN user_id SET DEFAULT nextval('seq__users__user_id'::regclass);
-ALTER TABLE ONLY workspaces ALTER COLUMN workspace_id SET DEFAULT nextval('seq__workspaces__workspace_id'::regclass);
-
-
-SELECT pg_catalog.setval('seq__groups__group_id', 4, true);
-SELECT pg_catalog.setval('seq__contents__content_id', 1, true);
-SELECT pg_catalog.setval('seq__content_revisions__revision_id', 2568, true);
-SELECT pg_catalog.setval('seq__permissions__permission_id', 1, true);
-SELECT pg_catalog.setval('seq__users__user_id', 2, true);
-
-SELECT pg_catalog.setval('seq__workspaces__workspace_id', 1, true);
-
-ALTER TABLE ONLY user_workspace
-    ADD CONSTRAINT pk__user_workspace__user_id__workspace_id PRIMARY KEY (user_id, workspace_id);
-
-ALTER TABLE ONLY workspaces
-    ADD CONSTRAINT pk__workspace__workspace_id PRIMARY KEY (workspace_id);
-
-ALTER TABLE ONLY groups
-    ADD CONSTRAINT uk__groups__group_name UNIQUE (group_name);
-
-ALTER TABLE ONLY group_permission
-    ADD CONSTRAINT pk__group_permission__group_id__permission_id PRIMARY KEY (group_id, permission_id);
-
-ALTER TABLE ONLY groups
-    ADD CONSTRAINT pk__groups__group_id PRIMARY KEY (group_id);
-
-ALTER TABLE ONLY content_revisions
-    ADD CONSTRAINT pk__content_revisions__revision_id PRIMARY KEY (revision_id);
-
-ALTER TABLE ONLY permissions
-    ADD CONSTRAINT uk__permissions__permission_name UNIQUE (permission_name);
-
-ALTER TABLE ONLY permissions
-    ADD CONSTRAINT pk__permissions__permission_id PRIMARY KEY (permission_id);
-
-ALTER TABLE ONLY users
-    ADD CONSTRAINT uk__users__email UNIQUE (email);
-
-ALTER TABLE ONLY user_group
-    ADD CONSTRAINT pk__user_group__user_id__group_id PRIMARY KEY (user_id, group_id);
-
-ALTER TABLE ONLY users
-    ADD CONSTRAINT pk__users__user_id PRIMARY KEY (user_id);
-
-CREATE INDEX idx__content_revisions__owner_id ON content_revisions USING btree (owner_id);
-
-CREATE INDEX idx__content_revisions__parent_id ON content_revisions USING btree (parent_id);
-
-CREATE RULE rul__insert__new_node AS ON INSERT TO contents DO INSTEAD INSERT INTO content_revisions (content_id, parent_id, type, created, updated, label, description, status, file_name, file_content, file_mimetype, owner_id, revision_id, workspace_id, is_deleted, is_archived, properties, revision_type) VALUES (nextval('seq__contents__content_id'::regclass), new.parent_id, new.type, new.created, new.updated, new.label, new.description, new.status, new.file_name, new.file_content, new.file_mimetype, new.owner_id, nextval('seq__content_revisions__revision_id'::regclass), new.workspace_id, new.is_deleted, new.is_archived, new.properties, new.revision_type) RETURNING content_revisions.content_id, content_revisions.parent_id, content_revisions.type, content_revisions.created, content_revisions.updated, content_revisions.label, content_revisions.description, content_revisions.status, content_revisions.file_name, content_revisions.file_content, content_revisions.file_mimetype, content_revisions.owner_id, content_revisions.workspace_id, content_revisions.is_deleted, content_revisions.is_archived, content_revisions.properties, content_revisions.revision_type;
-
-CREATE TRIGGER trg__contents__on_insert__set_created BEFORE INSERT ON content_revisions FOR EACH ROW EXECUTE PROCEDURE set_created();
-CREATE TRIGGER trg__contents__on_update__set_updated BEFORE UPDATE ON content_revisions FOR EACH ROW EXECUTE PROCEDURE set_updated();
-
-CREATE TRIGGER trg__contents__on_update INSTEAD OF UPDATE ON contents FOR EACH ROW EXECUTE PROCEDURE update_node();
-CREATE TRIGGER trg__workspaces__on_insert__set_created BEFORE INSERT ON workspaces FOR EACH ROW EXECUTE PROCEDURE set_created();
-CREATE TRIGGER trg__workspaces__on_update__set_updated BEFORE UPDATE ON workspaces FOR EACH ROW EXECUTE PROCEDURE set_updated();
-
-ALTER TABLE ONLY user_workspace
-    ADD CONSTRAINT fk__user_workspace__user_id FOREIGN KEY (user_id) REFERENCES users(user_id) ON UPDATE CASCADE ON DELETE CASCADE;
-
-ALTER TABLE ONLY user_workspace
-    ADD CONSTRAINT fk__user_workspace__workspace_id FOREIGN KEY (workspace_id) REFERENCES workspaces(workspace_id) ON UPDATE CASCADE ON DELETE CASCADE;
-
-ALTER TABLE ONLY group_permission
-    ADD CONSTRAINT fk__group_permission__group_id FOREIGN KEY (group_id) REFERENCES groups(group_id) ON UPDATE CASCADE ON DELETE CASCADE;
-
-ALTER TABLE ONLY group_permission
-    ADD CONSTRAINT fk__group_permission__permission_id FOREIGN KEY (permission_id) REFERENCES permissions(permission_id) ON UPDATE CASCADE ON DELETE CASCADE;
-
-ALTER TABLE ONLY content_revisions
-    ADD CONSTRAINT fk__content_revisions__owner_id FOREIGN KEY (owner_id) REFERENCES users(user_id);
-
-ALTER TABLE ONLY user_group
-    ADD CONSTRAINT fk__user_group__group_id FOREIGN KEY (group_id) REFERENCES groups(group_id) ON UPDATE CASCADE ON DELETE CASCADE;
-
-ALTER TABLE ONLY user_group
-    ADD CONSTRAINT fk__user_group__user_id FOREIGN KEY (user_id) REFERENCES users(user_id) ON UPDATE CASCADE ON DELETE CASCADE;
-
-COMMIT;
-"""