Merge branch 'develop' of github.com:tracim/tracim_backend into feature/671_read_unread_endpoints

README.md

 
 run tracim_backend web api:
 
-    pserve developement.ini
+    pserve development.ini
 
 run wsgidav server:
 

tracim/exceptions.py

 
 class EmptyCommentContentNotAllowed(EmptyValueNotAllowed):
     pass
+
+class ParentNotFound(NotFound):
+    pass

tracim/lib/core/content.py

             # INFO - G.M - 2018-07-05 - convert with
             #  content type object to support legacy slug
             content_type_object = ContentType(content_type)
-            resultset = resultset.filter(Content.type.in_(content_type_object.alias()))
+            resultset = resultset.filter(Content.type.in_(content_type_object.get_slug_aliases()))
 
         if parent_id:
             resultset = resultset.filter(Content.parent_id==parent_id)
         self.save(item, do_notify=False)
 
         for child in item.children:
-            with new_revision(child):
+            with new_revision(
+                session=self._session,
+                tm=transaction.manager,
+                content=child
+            ):
                 self.move_recursively(child, item, new_workspace)
         return
 

tracim/lib/webdav/dav_provider.py

 
         # If the requested path is the root, then we return a RootResource resource
         if path == root_path:
-            return resources.RootResource(path, environ, user=user, session=session)
+            return resources.RootResource(
+                path=path,
+                environ=environ,
+                user=user,
+                session=session
+            )
 
         workspace_api = WorkspaceApi(
             current_user=user,
 
         # Easy cases : path either end with /.deleted, /.archived or /.history, then we return corresponding resources
         if path.endswith(SpecialFolderExtension.Archived) and self._show_archive:
-            return resources.ArchivedFolderResource(path, environ, workspace, content)
+            return resources.ArchivedFolderResource(
+                path=path,
+                environ=environ,
+                workspace=workspace,
+                user=user,
+                content=content,
+                session=session,
+            )
 
         if path.endswith(SpecialFolderExtension.Deleted) and self._show_delete:
-            return resources.DeletedFolderResource(path, environ, workspace, content)
+            return resources.DeletedFolderResource(
+                path=path,
+                environ=environ,
+                workspace=workspace,
+                user=user,
+                content=content,
+                session=session,
+            )
 
         if path.endswith(SpecialFolderExtension.History) and self._show_history:
             is_deleted_folder = re.search(r'/\.deleted/\.history$', path) is not None
                 else HistoryType.Archived if is_archived_folder \
                 else HistoryType.Standard
 
-            return resources.HistoryFolderResource(path, environ, workspace, content, type)
+            return resources.HistoryFolderResource(
+                path=path,
+                environ=environ,
+                workspace=workspace,
+                user=user,
+                content=content,
+                session=session,
+                type=type
+            )
 
         # Now that's more complicated, we're trying to find out if the path end with /.history/file_name
         is_history_file_folder = re.search(r'/\.history/([^/]+)$', path) is not None
             return resources.HistoryFileFolderResource(
                 path=path,
                 environ=environ,
-                content=content
+                user=user,
+                content=content,
+                session=session,
             )
-
         # And here next step :
         is_history_file = re.search(r'/\.history/[^/]+/\((\d+) - [a-zA-Z]+\) .+', path) is not None
 
             content = self.get_content_from_revision(content_revision, content_api)
 
             if content.type == ContentType.File:
-                return resources.HistoryFileResource(path, environ, content, content_revision)
+                return resources.HistoryFileResource(
+                    path=path,
+                    environ=environ,
+                    user=user,
+                    content=content,
+                    content_revision=content_revision,
+                    session=session,
+                )
             else:
-                return resources.HistoryOtherFile(path, environ, content, content_revision)
+                return resources.HistoryOtherFile(
+                    path=path,
+                    environ=environ,
+                    user=user,
+                    content=content,
+                    content_revision=content_revision,
+                    session=session,
+                )
 
         # And if we're still going, the client is asking for a standard Folder/File/Page/Thread so we check the type7
         # and return the corresponding resource

tracim/lib/webdav/resources.py

         workspace_api = WorkspaceApi(
             current_user=self.user,
             session=self.session,
+            config=self.provider.app_config,
         )
         workspace = self.provider.get_workspace_from_path(
             normpath(destpath), workspace_api
         workspace_api = WorkspaceApi(
             current_user=self.user,
             session=self.session,
+            config=self.provider.app_config,
         )
         content_api = ContentApi(
             current_user=self.user,

tracim/models/contents.py

                 return
         raise ContentTypeNotExist()
 
-    def alias(self) -> typing.List[str]:
-        """ Get all alias of a content, useful for legacy code convertion"""
+    def get_slug_aliases(self) -> typing.List[str]:
+        """
+        Get all slug aliases of a content,
+        useful for legacy code convertion
+        """
         # TODO - G.M - 2018-07-05 - Remove this legacy compat code
         # when possible.
         page_alias = [self.Page, self.PageLegacy]

tracim/models/context_models.py

             self,
             label: str,
             content_type: str,
+            parent_id: typing.Optional[int] = None,
     ) -> None:
         self.label = label
         self.content_type = content_type
+        self.parent_id = parent_id
 
 
 class CommentCreation(object):
         return self.revision.label
 
     @property
+    def revision_type(self) -> str:
+        return self.revision.revision_type
+
+    @property
     def content_type(self) -> str:
         content_type = ContentType(self.revision.type)
         if content_type:

tracim/tests/functional/test_contents.py

 # -*- coding: utf-8 -*-
+import transaction
+
+from tracim import models
+from tracim.lib.core.content import ContentApi
+from tracim.lib.core.workspace import WorkspaceApi
+from tracim.models import get_tm_session
+from tracim.models.contents import ContentTypeLegacy as ContentType
+from tracim.models.revision_protection import new_revision
 from tracim.tests import FunctionalTest
 from tracim.tests import set_html_document_slug_to_legacy
 from tracim.fixtures.content import Content as ContentFixtures
         assert revision['status'] == 'open'
         assert revision['workspace_id'] == 2
         assert revision['revision_id'] == 6
+        assert revision['revision_type'] == 'creation'
         assert revision['sub_content_types']
         # TODO - G.M - 2018-06-173 - Test with real comments
         assert revision['comment_ids'] == []
         assert revision['status'] == 'open'
         assert revision['workspace_id'] == 2
         assert revision['revision_id'] == 7
+        assert revision['revision_type'] == 'edition'
         assert revision['sub_content_types']
         # TODO - G.M - 2018-06-173 - Test with real comments
         assert revision['comment_ids'] == []
         assert revision['status'] == 'open'
         assert revision['workspace_id'] == 2
         assert revision['revision_id'] == 27
+        assert revision['revision_type'] == 'edition'
         assert revision['sub_content_types']
         # TODO - G.M - 2018-06-173 - Test with real comments
         assert revision['comment_ids'] == []
         assert revision['workspace_id'] == 2
         assert revision['revision_id'] == 8
         assert revision['sub_content_types']
+        assert revision['revision_type'] == 'creation'
         assert revision['comment_ids'] == [18, 19, 20]
         # TODO - G.M - 2018-06-173 - check date format
         assert revision['created']
         assert revision['status'] == 'open'
         assert revision['workspace_id'] == 2
         assert revision['revision_id'] == 26
+        assert revision['revision_type'] == 'edition'
         assert revision['sub_content_types']
         assert revision['comment_ids'] == []
         # TODO - G.M - 2018-06-173 - check date format
         assert revision['author']['avatar_url'] is None
         assert revision['author']['public_name'] == 'Bob i.'
 
+    def test_api__get_thread_revisions__ok_200__most_revision_type(self) -> None:
+        """
+        get threads revisions
+        """
+        dbsession = get_tm_session(self.session_factory, transaction.manager)
+        admin = dbsession.query(models.User) \
+            .filter(models.User.email == 'admin@admin.admin') \
+            .one()
+        workspace_api = WorkspaceApi(
+            current_user=admin,
+            session=dbsession,
+            config=self.app_config
+        )
+        business_workspace = workspace_api.get_one(1)
+        content_api = ContentApi(
+            current_user=admin,
+            session=dbsession,
+            config=self.app_config
+        )
+        tool_folder = content_api.get_one(1, content_type=ContentType.Any)
+        test_thread = content_api.create(
+            content_type=ContentType.Thread,
+            workspace=business_workspace,
+            parent=tool_folder,
+            label='Test Thread',
+            do_save=True,
+            do_notify=False,
+        )
+        with new_revision(
+           session=dbsession,
+           tm=transaction.manager,
+           content=test_thread,
+        ):
+            content_api.update_content(
+                test_thread,
+                new_label='test_thread_updated',
+                new_content='Just a test'
+            )
+        content_api.save(test_thread)
+        with new_revision(
+           session=dbsession,
+           tm=transaction.manager,
+           content=test_thread,
+        ):
+            content_api.archive(test_thread)
+        content_api.save(test_thread)
+
+        with new_revision(
+           session=dbsession,
+           tm=transaction.manager,
+           content=test_thread,
+        ):
+            content_api.unarchive(test_thread)
+        content_api.save(test_thread)
+
+        with new_revision(
+           session=dbsession,
+           tm=transaction.manager,
+           content=test_thread,
+        ):
+            content_api.delete(test_thread)
+        content_api.save(test_thread)
+
+        with new_revision(
+           session=dbsession,
+           tm=transaction.manager,
+           content=test_thread,
+        ):
+            content_api.undelete(test_thread)
+        content_api.save(test_thread)
+        dbsession.flush()
+        transaction.commit()
+        self.testapp.authorization = (
+            'Basic',
+            (
+                'admin@admin.admin',
+                'admin@admin.admin'
+            )
+        )
+        res = self.testapp.get(
+            '/api/v2/workspaces/1/threads/{}/revisions'.format(test_thread.content_id),  # nopep8
+            status=200
+        )
+        revisions = res.json_body
+        assert len(revisions) == 6
+        for revision in revisions:
+            revision['content_type'] == 'thread'
+            revision['workspace_id'] == 1
+            revision['content_id'] == test_thread.content_id
+        revision = revisions[0]
+        revision['revision_type'] == 'creation'
+        revision = revisions[1]
+        revision['revision_type'] == 'archiving'
+        revision = revisions[2]
+        revision['revision_type'] == 'unarchiving'
+        revision = revisions[3]
+        revision['revision_type'] == 'deletion'
+        revision = revisions[4]
+        revision['revision_type'] == 'undeletion'
+
     def test_api__set_thread_status__ok_200__nominal_case(self) -> None:
         """
         Set thread status

tracim/tests/functional/test_workspaces.py

         active_contents = self.testapp.get('/api/v2/workspaces/1/contents', params=params_active, status=200).json_body  # nopep8
         assert res.json_body in active_contents
 
+    def test_api__post_content_create_generic_content__ok_200__in_folder(self) -> None:  # nopep8
+        """
+        Create generic content in folder
+        """
+        self.testapp.authorization = (
+            'Basic',
+            (
+                'admin@admin.admin',
+                'admin@admin.admin'
+            )
+        )
+        params = {
+            'label': 'GenericCreatedContent',
+            'content_type': 'markdownpage',
+            'parent_id': 10,
+        }
+        res = self.testapp.post_json(
+            '/api/v2/workspaces/1/contents',
+            params=params,
+            status=200
+        )
+        assert res
+        assert res.json_body
+        assert res.json_body['status'] == 'open'
+        assert res.json_body['content_id']
+        assert res.json_body['content_type'] == 'markdownpage'
+        assert res.json_body['is_archived'] is False
+        assert res.json_body['is_deleted'] is False
+        assert res.json_body['workspace_id'] == 1
+        assert res.json_body['slug'] == 'genericcreatedcontent'
+        assert res.json_body['parent_id'] == 10
+        assert res.json_body['show_in_ui'] is True
+        assert res.json_body['sub_content_types']
+        params_active = {
+            'parent_id': 10,
+            'show_archived': 0,
+            'show_deleted': 0,
+            'show_active': 1,
+        }
+        # INFO - G.M - 2018-06-165 - Verify if new content is correctly created
+        active_contents = self.testapp.get('/api/v2/workspaces/1/contents', params=params_active, status=200).json_body  # nopep8
+        assert res.json_body in active_contents
+
     def test_api__post_content_create_generic_content__err_400__empty_label(self) -> None:  # nopep8
         """
         Create generic content

tracim/views/core_api/schemas.py

 from tracim.models.context_models import ContentFilter
 from tracim.models.context_models import LoginCredentials
 from tracim.models.data import UserRoleInWorkspace
+from tracim.models.data import ActionDescription
 
 
 class UserDigestSchema(marshmallow.Schema):
         example='html-documents',
         validate=OneOf(ContentType.allowed_types_for_folding()),  # nopep8
     )
+    parent_id = marshmallow.fields.Integer(
+        example=35,
+        description='content_id of parent content, if content should be placed in a folder, this should be folder content_id.'
+    )
+
 
     @post_load
     def make_content_filter(self, data):
         example=12,
         validate=Range(min=1, error="Value must be greater than 0"),
     )
+    revision_type = marshmallow.fields.String(
+        example=ActionDescription.CREATION,
+        validate=OneOf(ActionDescription.allowed_values()),
+    )
     created = marshmallow.fields.DateTime(
         format=DATETIME_FORMAT,
         description='Content creation date',

tracim/views/core_api/workspace_controller.py

 from tracim.models.context_models import UserRoleWorkspaceInContext
 from tracim.models.context_models import ContentInContext
 from tracim.exceptions import EmptyLabelNotAllowed
+from tracim.exceptions import ContentNotFound
 from tracim.exceptions import WorkspacesDoNotMatch
+from tracim.exceptions import ParentNotFound
 from tracim.views.controllers import Controller
 from tracim.views.core_api.schemas import FilterContentQuerySchema
 from tracim.views.core_api.schemas import ContentMoveSchema
         api = ContentApi(
             current_user=request.current_user,
             session=request.dbsession,
-            config=app_config,
+            config=app_config
         )
+        parent = None
+        if creation_data.parent_id:
+            try:
+                parent = api.get_one(content_id=creation_data.parent_id, content_type=ContentType.Any)  # nopep8
+            except ContentNotFound as exc:
+                raise ParentNotFound(
+                    'Parent with content_id {} not found'.format(creation_data.parent_id)
+                ) from exc
         content = api.create(
             label=creation_data.label,
             content_type=creation_data.content_type,
             workspace=request.current_workspace,
+            parent=parent,
         )
         api.save(content, ActionDescription.CREATION)
         content = api.get_content_in_context(content)