Merge branch 'develop' of github.com:tracim/tracim_v2 into develop

backend/tracim_backend/__init__.py

 # -*- coding: utf-8 -*-
+
 try:  # Python 3.5+
     from http import HTTPStatus
 except ImportError:
 from tracim_backend.views.core_api.workspace_controller import WorkspaceController
 from tracim_backend.views.contents_api.comment_controller import CommentController
 from tracim_backend.views.contents_api.file_controller import FileController
+from tracim_backend.views.contents_api.folder_controller import FolderController
 from tracim_backend.views.frontend import FrontendController
 from tracim_backend.views.errors import ErrorSchema
 from tracim_backend.exceptions import NotAuthenticated
     html_document_controller = HTMLDocumentController()
     thread_controller = ThreadController()
     file_controller = FileController()
+    folder_controller = FolderController()
     configurator.include(session_controller.bind, route_prefix=BASE_API_V2)
     configurator.include(system_controller.bind, route_prefix=BASE_API_V2)
     configurator.include(user_controller.bind, route_prefix=BASE_API_V2)
     configurator.include(html_document_controller.bind, route_prefix=BASE_API_V2)  # nopep8
     configurator.include(thread_controller.bind, route_prefix=BASE_API_V2)
     configurator.include(file_controller.bind, route_prefix=BASE_API_V2)
+    configurator.include(folder_controller.bind, route_prefix=BASE_API_V2)
 
     if app_config.FRONTEND_SERVE:
         configurator.include('pyramid_mako')

backend/tracim_backend/exceptions.py

 class PreviewDimNotAllowed(TracimException):
     pass
 
+class UnallowedSubContent(TracimException):
+    pass
 
 class TooShortAutocompleteString(TracimException):
     pass

backend/tracim_backend/lib/core/content.py

 from tracim_backend.lib.utils.utils import cmp_to_key
 from tracim_backend.lib.core.notifications import NotifierFactory
 from tracim_backend.exceptions import SameValueError
+from tracim_backend.exceptions import UnallowedSubContent
+from tracim_backend.exceptions import ContentTypeNotExist
 from tracim_backend.exceptions import PageOfPreviewNotFound
 from tracim_backend.exceptions import PreviewDimNotAllowed
 from tracim_backend.exceptions import RevisionDoesNotMatchThisContent
 
     def create(self, content_type_slug: str, workspace: Workspace, parent: Content=None, label: str = '', filename: str = '', do_save=False, is_temporary: bool=False, do_notify=True) -> Content:
         # TODO - G.M - 2018-07-16 - raise Exception instead of assert
-        assert content_type_slug in CONTENT_TYPES.query_allowed_types_slugs()
         assert content_type_slug != CONTENT_TYPES.Any_SLUG
         assert not (label and filename)
 
         if content_type_slug == CONTENT_TYPES.Folder.slug and not label:
             label = self.generate_folder_label(workspace, parent)
 
+        # TODO BS 2018-08-13: Despite that workspace is required, create_comment
+        # can call here with None. Must update create_comment tu require the
+        # workspace.
+        if not workspace:
+            workspace = parent.workspace
+
+        content_type = CONTENT_TYPES.get_one_by_slug(content_type_slug)
+        if parent and parent.properties and 'allowed_content' in parent.properties:
+            if content_type.slug not in parent.properties['allowed_content'] or not parent.properties['allowed_content'][content_type.slug]:
+                raise UnallowedSubContent(' SubContent of type {subcontent_type}  not allowed in content {content_id}'.format(  # nopep8
+                    subcontent_type=content_type.slug,
+                    content_id=parent.content_id,
+                ))
+        if not workspace and parent:
+            workspace = parent.workspace
+
+        if workspace:
+            if content_type.slug not in workspace.get_allowed_content_types():
+                raise UnallowedSubContent(
+                    ' SubContent of type {subcontent_type}  not allowed in workspace {content_id}'.format(  # nopep8
+                        subcontent_type=content_type.slug,
+                        content_id=workspace.workspace_id,
+                    )
+                )
+
         content = Content()
 
         if filename:
 
         content.owner = self._user
         content.parent = parent
+
         content.workspace = workspace
-        content.type = content_type_slug
+        content.type = content_type.slug
         content.is_temporary = is_temporary
         content.revision_type = ActionDescription.CREATION
 
         return content
 
     def create_comment(self, workspace: Workspace=None, parent: Content=None, content:str ='', do_save=False) -> Content:
+        # TODO: check parent allowed_type and workspace allowed_ type
         assert parent and parent.type != CONTENT_TYPES.Folder.slug
         if not content:
             raise EmptyCommentContentNotAllowed()
-        item = Content()
-        item.owner = self._user
-        item.parent = parent
-        if not workspace:
-            workspace = item.parent.workspace
-        item.workspace = workspace
-        item.type = CONTENT_TYPES.Comment.slug
+
+        item = self.create(
+            content_type_slug=CONTENT_TYPES.Comment.slug,
+            workspace=workspace,
+            parent=parent,
+            do_notify=False,
+            do_save=False,
+            label='',
+        )
         item.description = content
-        item.label = ''
         item.revision_type = ActionDescription.COMMENT
 
         if do_save:
     #
     #     return result
 
-    def set_allowed_content(self, folder: Content, allowed_content_dict:dict):
+    def _set_allowed_content(self, content: Content, allowed_content_dict: dict) -> None:  # nopep8
         """
-        :param folder: the given folder instance
+        :param content: the given content instance
         :param allowed_content_dict: must be something like this:
             dict(
                 folder = True
                 file = False,
                 page = True
             )
-        :return:
+        :return: nothing
+        """
+        properties = content.properties.copy()
+        properties['allowed_content'] = allowed_content_dict
+        content.properties = properties
+
+    def set_allowed_content(self, content: Content, allowed_content_type_slug_list: typing.List[str]) -> None:  # nopep8
+        """
+        :param content: the given content instance
+        :param allowed_content_type_slug_list: list of content_type_slug to
+        accept as subcontent.
+        :return: nothing
+        """
+        allowed_content_dict = {}
+        for allowed_content_type_slug in allowed_content_type_slug_list:
+            if allowed_content_type_slug not in CONTENT_TYPES.extended_endpoint_allowed_types_slug():
+                raise ContentTypeNotExist('Content_type {} does not exist'.format(allowed_content_type_slug))  # nopep8
+            allowed_content_dict[allowed_content_type_slug] = True
+
+        self._set_allowed_content(content, allowed_content_dict)
+
+    def restore_content_default_allowed_content(self, content: Content) -> None:
+        """
+        Return to default allowed_content_types
+        :param content: the given content instance
+        :return: nothing
         """
-        properties = dict(allowed_content = allowed_content_dict)
-        folder.properties = properties
+        if content._properties and 'allowed_content' in content._properties:
+            properties = content.properties.copy()
+            del properties['allowed_content']
+            content.properties = properties
 
     def set_status(self, content: Content, new_status: str):
         if new_status in CONTENT_STATUS.get_all_slugs_values():

backend/tracim_backend/lib/webdav/resources.py

             parent=self.content
         )
 
-        subcontent = dict(
-            folder=True,
-            thread=True,
-            file=True,
-            page=True
-        )
-
-        self.content_api.set_allowed_content(folder, subcontent)
         self.content_api.save(folder)
 
         transaction.commit()

backend/tracim_backend/models/contents.py

             creation_label: str,
             available_statuses: typing.List[ContentStatus],
             slug_alias: typing.List[str] = None,
+            allow_sub_content: bool = False,
     ):
         self.slug = slug
         self.fa_icon = fa_icon
         self.creation_label = creation_label
         self.available_statuses = available_statuses
         self.slug_alias = slug_alias
+        self.allow_sub_content = allow_sub_content
 
 
 thread_type = ContentType(
     label='Folder',
     creation_label='Create a folder',
     available_statuses=CONTENT_STATUS.get_all(),
+    allow_sub_content=True,
 )
 
 
         """
         content_types = self._content_types.copy()
         content_types.extend(self._special_contents_types)
+        content_types.append(self.Event)
         for item in content_types:
             if item.slug == slug or (item.slug_alias and slug in item.slug_alias):  # nopep8
                 return item
         allowed_type_slug = [contents_type.slug for contents_type in self._content_types]  # nopep8
         return allowed_type_slug
 
+    def extended_endpoint_allowed_types_slug(self) -> typing.List[str]:
+        allowed_types_slug = self.endpoint_allowed_types_slug().copy()
+        for content_type in self._special_contents_types:
+            allowed_types_slug.append(content_type.slug)
+        return allowed_types_slug
+
     def query_allowed_types_slugs(self) -> typing.List[str]:
         """
         Return alls allowed types slug : content_type slug + all alias, any
         allowed_types_slug.extend(self._extra_slugs)
         return allowed_types_slug
 
+    def default_allowed_content_properties(self, slug) -> dict:
+        content_type = self.get_one_by_slug(slug)
+        if content_type.allow_sub_content:
+            sub_content_allowed = self.extended_endpoint_allowed_types_slug()
+        else:
+            sub_content_allowed = [self.Comment.slug]
+
+        properties_dict = {}
+        for elem in sub_content_allowed:
+            properties_dict[elem] = True
+        return properties_dict
+
 
 CONTENT_TYPES = ContentTypeList(
     [

backend/tracim_backend/models/context_models.py

     Content creation model
     """
     def __init__(
-            self,
-            label: str,
-            content_type: str,
-            parent_id: typing.Optional[int] = None,
+        self,
+        label: str,
+        content_type: str,
+        parent_id: typing.Optional[int] = None,
     ) -> None:
         self.label = label
         self.content_type = content_type
     Comment creation model
     """
     def __init__(
-            self,
-            raw_content: str,
+        self,
+        raw_content: str,
     ) -> None:
         self.raw_content = raw_content
 
     Set content status
     """
     def __init__(
-            self,
-            status: str,
+        self,
+        status: str,
     ) -> None:
         self.status = status
 
     TextBasedContent update model
     """
     def __init__(
-            self,
-            label: str,
-            raw_content: str,
+        self,
+        label: str,
+        raw_content: str,
+    ) -> None:
+        self.label = label
+        self.raw_content = raw_content
+
+
+class FolderContentUpdate(object):
+    """
+    Folder Content update model
+    """
+    def __init__(
+        self,
+        label: str,
+        raw_content: str,
+        sub_content_types: typing.List[str],
     ) -> None:
         self.label = label
         self.raw_content = raw_content
+        self.sub_content_types = sub_content_types
 
 
 class TypeUser(Enum):

backend/tracim_backend/models/data.py

 from tracim_backend.models.auth import User
 from tracim_backend.models.roles import WorkspaceRoles
 
-DEFAULT_PROPERTIES = dict(
-    allowed_content=dict(
-        folder=True,
-        file=True,
-        page=True,
-        thread=True,
-    ),
-)
-
 
 class Workspace(DeclarativeBase):
 
 
     def get_allowed_content_types(self):
         # @see Content.get_allowed_content_types()
-        return CONTENT_TYPES.endpoint_allowed_types_slug()
+        return CONTENT_TYPES.extended_endpoint_allowed_types_slug()
 
     def get_valid_children(
             self,
 
     @classmethod
     def check_properties(cls, item):
-        if item.type == CONTENT_TYPES.Folder.slug:
-            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
-
+        properties = item.properties
         if item.type == CONTENT_TYPES.Event.slug:
-            properties = item.properties
             if 'name' not in properties.keys():
                 return False
             if 'raw' not in properties.keys():
             if 'end' not in properties.keys():
                 return False
             return True
-
-        # TODO - G.M - 15-03-2018 - Choose only correct Content-type for origin
-        # Only content who can be copied need this
-        if item.type == CONTENT_TYPES.Any_SLUG:
-            properties = item.properties
+        else:
+            if 'allowed_content' in properties.keys():
+                for content_slug, value in properties['allowed_content'].items():  # nopep8
+                    if not isinstance(value, bool):
+                        return False
+                    if not content_slug in CONTENT_TYPES.extended_endpoint_allowed_types_slug():  # nopep8
+                        return False
             if 'origin' in properties.keys():
-                return True
-        raise NotImplementedError
-
-    @classmethod
-    def reset_properties(cls, item):
-        if item.type == CONTENT_TYPES.Folder.slug:
-            item.properties = DEFAULT_PROPERTIES
-            return
-
-        raise NotImplementedError
+                pass
+            return True
 
 
 class ContentRevisionRO(DeclarativeBase):
     @hybrid_property
     def properties(self) -> dict:
         """ return a structure decoded from json content of _properties """
+
         if not self._properties:
-            return DEFAULT_PROPERTIES
-        return json.loads(self._properties)
+            properties = {}
+        else:
+            properties = json.loads(self._properties)
+        if CONTENT_TYPES.get_one_by_slug(self.type) != CONTENT_TYPES.Event:
+            if not 'allowed_content' in properties:
+                properties['allowed_content'] = CONTENT_TYPES.default_allowed_content_properties(self.type)  # nopep8
+        return properties
 
     @properties.setter
     def properties(self, properties_struct: dict) -> None:
             allowed_types = self.properties['allowed_content']
             for type_label, is_allowed in allowed_types.items():
                 if is_allowed:
-                    types.append(CONTENT_TYPES.get_one_by_slug(type_label))
+                   types.append(
+                        CONTENT_TYPES.get_one_by_slug(type_label)
+                   )
+        # TODO BS 2018-08-13: This try/except is not correct: except exception
+        # if we know what to except.
         except Exception as e:
             print(e.__str__())
             print('----- /*\ *****')

backend/tracim_backend/tests/functional/test_contents.py

 from tracim_backend.fixtures.content import Content as ContentFixtures
 from tracim_backend.fixtures.users_and_groups import Base as BaseFixture
 
+class TestFolder(FunctionalTest):
+    """
+    Tests for /api/v2/workspaces/{workspace_id}/folders/{content_id}
+    endpoint
+    """
+
+    fixtures = [BaseFixture]
+
+    def test_api__get_folder__ok_200__nominal_case(self) -> None:
+        """
+        Get one folder content
+        """
+        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
+        )
+        content_api = ContentApi(
+            current_user=admin,
+            session=dbsession,
+            config=self.app_config
+        )
+        test_workspace = workspace_api.create_workspace(
+            label='test',
+            save_now=True,
+        )
+        folder = content_api.create(
+            label='test-folder',
+            content_type_slug=CONTENT_TYPES.Folder.slug,
+            workspace=test_workspace,
+            do_save=True,
+            do_notify=False
+        )
+        transaction.commit()
+
+        self.testapp.authorization = (
+            'Basic',
+            (
+                'admin@admin.admin',
+                'admin@admin.admin'
+            )
+        )
+        res = self.testapp.get(
+            '/api/v2/workspaces/{workspace_id}/folders/{content_id}'.format(
+                workspace_id=test_workspace.workspace_id,
+                content_id=folder.content_id,
+            ),
+            status=200
+        )
+        content = res.json_body
+        assert content['content_type'] == 'folder'
+        assert content['content_id'] == folder.content_id
+        assert content['is_archived'] is False
+        assert content['is_deleted'] is False
+        assert content['label'] == 'test-folder'
+        assert content['parent_id'] is None
+        assert content['show_in_ui'] is True
+        assert content['slug'] == 'test-folder'
+        assert content['status'] == 'open'
+        assert content['workspace_id'] == test_workspace.workspace_id
+        assert content['current_revision_id'] == folder.revision_id
+        # TODO - G.M - 2018-06-173 - check date format
+        assert content['created']
+        assert content['author']
+        assert content['author']['user_id'] == 1
+        assert content['author']['avatar_url'] is None
+        assert content['author']['public_name'] == 'Global manager'
+        # TODO - G.M - 2018-06-173 - check date format
+        assert content['modified']
+        assert content['last_modifier']['user_id'] == 1
+        assert content['last_modifier']['public_name'] == 'Global manager'
+        assert content['last_modifier']['avatar_url'] is None
+        assert content['raw_content'] == ''
+
+    def test_api__get_folder__err_400__wrong_content_type(self) -> None:
+        """
+        Get one folder of a content content 7 is not folder
+        """
+        self.testapp.authorization = (
+            'Basic',
+            (
+                'admin@admin.admin',
+                'admin@admin.admin'
+            )
+        )
+        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
+        )
+        content_api = ContentApi(
+            current_user=admin,
+            session=dbsession,
+            config=self.app_config
+        )
+        test_workspace = workspace_api.create_workspace(
+            label='test',
+            save_now=True,
+        )
+        thread = content_api.create(
+            label='thread',
+            content_type_slug=CONTENT_TYPES.Thread.slug,
+            workspace=test_workspace,
+            do_save=True,
+            do_notify=False
+        )
+        transaction.commit()
+        self.testapp.get(
+            '/api/v2/workspaces/2/folders/7',
+            status=400
+        )
+
+    def test_api__get_folder__err_400__content_does_not_exist(self) -> None:  # nopep8
+        """
+        Get one folder content (content 170 does not exist in db)
+        """
+        self.testapp.authorization = (
+            'Basic',
+            (
+                'admin@admin.admin',
+                'admin@admin.admin'
+            )
+        )
+        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
+        )
+        content_api = ContentApi(
+            current_user=admin,
+            session=dbsession,
+            config=self.app_config
+        )
+        test_workspace = workspace_api.create_workspace(
+            label='test',
+            save_now=True,
+        )
+        transaction.commit()
+        self.testapp.get(
+            '/api/v2/workspaces/{workspace_id}/folders/170'.format(workspace_id=test_workspace.workspace_id),  # nopep8
+            status=400
+        )
+
+    def test_api__get_folder__err_400__content_not_in_workspace(self) -> None:  # nopep8
+        """
+        Get one folders of a content (content is in another workspace)
+        """
+        self.testapp.authorization = (
+            'Basic',
+            (
+                'admin@admin.admin',
+                'admin@admin.admin'
+            )
+        )
+        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
+        )
+        content_api = ContentApi(
+            current_user=admin,
+            session=dbsession,
+            config=self.app_config
+        )
+        test_workspace = workspace_api.create_workspace(
+            label='test',
+            save_now=True,
+        )
+        folder = content_api.create(
+            label='test_folder',
+            content_type_slug=CONTENT_TYPES.Folder.slug,
+            workspace=test_workspace,
+            do_save=True,
+            do_notify=False
+        )
+        test_workspace2 = workspace_api.create_workspace(
+            label='test2',
+            save_now=True,
+        )
+        transaction.commit()
+        self.testapp.authorization = (
+            'Basic',
+            (
+                'admin@admin.admin',
+                'admin@admin.admin'
+            )
+        )
+        self.testapp.get(
+            '/api/v2/workspaces/{workspace_id}/folders/{content_id}'.format(
+                workspace_id=test_workspace2.workspace_id,
+                content_id=folder.content_id,
+            ),
+            status=400
+        )
+
+    def test_api__get_folder__err_400__workspace_does_not_exist(self) -> None:  # nopep8
+        """
+        Get one folder content (Workspace 40 does not exist)
+        """
+        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
+        )
+        content_api = ContentApi(
+            current_user=admin,
+            session=dbsession,
+            config=self.app_config
+        )
+        test_workspace = workspace_api.create_workspace(
+            label='test',
+            save_now=True,
+        )
+        folder = content_api.create(
+            label='test_folder',
+            content_type_slug=CONTENT_TYPES.Folder.slug,
+            workspace=test_workspace,
+            do_save=True,
+            do_notify=False
+        )
+        transaction.commit()
+        self.testapp.authorization = (
+            'Basic',
+            (
+                'admin@admin.admin',
+                'admin@admin.admin'
+            )
+        )
+        self.testapp.get(
+            '/api/v2/workspaces/40/folders/{content_id}'.format(content_id=folder.content_id),  # nopep8
+            status=400
+        )
+
+    def test_api__get_folder__err_400__workspace_id_is_not_int(self) -> None:  # nopep8
+        """
+        Get one folder content, workspace id is not int
+        """
+        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
+        )
+        content_api = ContentApi(
+            current_user=admin,
+            session=dbsession,
+            config=self.app_config
+        )
+        test_workspace = workspace_api.create_workspace(
+            label='test',
+            save_now=True,
+        )
+        folder = content_api.create(
+            label='test_folder',
+            content_type_slug=CONTENT_TYPES.Folder.slug,
+            workspace=test_workspace,
+            do_save=True,
+            do_notify=False
+        )
+        transaction.commit()
+        self.testapp.authorization = (
+            'Basic',
+            (
+                'admin@admin.admin',
+                'admin@admin.admin'
+            )
+        )
+        self.testapp.get(
+            '/api/v2/workspaces/coucou/folders/{content_id}'.format(content_id=folder.content_id),  # nopep8
+            status=400
+        )
+
+    def test_api__get_folder__err_400__content_id_is_not_int(self) -> None:  # nopep8
+        """
+        Get one folder content, content_id is not int
+        """
+        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
+        )
+        content_api = ContentApi(
+            current_user=admin,
+            session=dbsession,
+            config=self.app_config
+        )
+        test_workspace = workspace_api.create_workspace(
+            label='test',
+            save_now=True,
+        )
+        folder = content_api.create(
+            label='test_folder',
+            content_type_slug=CONTENT_TYPES.Folder.slug,
+            workspace=test_workspace,
+            do_save=True,
+            do_notify=False
+        )
+        transaction.commit()
+
+        self.testapp.authorization = (
+            'Basic',
+            (
+                'admin@admin.admin',
+                'admin@admin.admin'
+            )
+        )
+        self.testapp.get(
+            '/api/v2/workspaces/{workspace_id}/folders/coucou'.format(workspace_id=test_workspace.workspace_id),  # nopep8
+            status=400
+        )
+
+    def test_api__update_folder__err_400__empty_label(self) -> None:  # nopep8
+        """
+        Update(put) one folder content
+        """
+        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
+        )
+        content_api = ContentApi(
+            current_user=admin,
+            session=dbsession,
+            config=self.app_config
+        )
+        test_workspace = workspace_api.create_workspace(
+            label='test',
+            save_now=True,
+        )
+        folder = content_api.create(
+            label='test_folder',
+            content_type_slug=CONTENT_TYPES.Folder.slug,
+            workspace=test_workspace,
+            do_save=True,
+            do_notify=False
+        )
+        transaction.commit()
+        self.testapp.authorization = (
+            'Basic',
+            (
+                'admin@admin.admin',
+                'admin@admin.admin'
+            )
+        )
+        params = {
+            'label': '',
+            'raw_content': '<p> Le nouveau contenu </p>',
+            'sub_content_types': [CONTENT_TYPES.Folder.slug]
+        }
+        self.testapp.put_json(
+            '/api/v2/workspaces/{workspace_id}/folders/{content_id}'.format(
+                workspace_id=test_workspace.workspace_id,
+                content_id=folder.content_id,
+            ),
+            params=params,
+            status=400
+        )
+
+    def test_api__update_folder__ok_200__nominal_case(self) -> None:
+        """
+        Update(put) one html document of a content
+        """
+        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
+        )
+        content_api = ContentApi(
+            current_user=admin,
+            session=dbsession,
+            config=self.app_config
+        )
+        test_workspace = workspace_api.create_workspace(
+            label='test',
+            save_now=True,
+        )
+        folder = content_api.create(
+            label='test_folder',
+            content_type_slug=CONTENT_TYPES.Folder.slug,
+            workspace=test_workspace,
+            do_save=True,
+            do_notify=False
+        )
+        transaction.commit()
+        self.testapp.authorization = (
+            'Basic',
+            (
+                'admin@admin.admin',
+                'admin@admin.admin'
+            )
+        )
+        params = {
+            'label': 'My New label',
+            'raw_content': '<p> Le nouveau contenu </p>',
+            'sub_content_types': [CONTENT_TYPES.Folder.slug]
+        }
+        res = self.testapp.put_json(
+            '/api/v2/workspaces/{workspace_id}/folders/{content_id}'.format(
+                workspace_id=test_workspace.workspace_id,
+                content_id=folder.content_id,
+            ),
+            params=params,
+            status=200
+        )
+        content = res.json_body
+        assert content['content_type'] == 'folder'
+        assert content['content_id'] == folder.content_id
+        assert content['is_archived'] is False
+        assert content['is_deleted'] is False
+        assert content['label'] == 'My New label'
+        assert content['parent_id'] is None
+        assert content['show_in_ui'] is True
+        assert content['slug'] == 'my-new-label'
+        assert content['status'] == 'open'
+        assert content['workspace_id'] == test_workspace.workspace_id
+        assert content['current_revision_id']
+        # TODO - G.M - 2018-06-173 - check date format
+        assert content['created']
+        assert content['author']
+        assert content['author']['user_id'] == 1
+        assert content['author']['avatar_url'] is None
+        assert content['author']['public_name'] == 'Global manager'
+        # TODO - G.M - 2018-06-173 - check date format
+        assert content['modified']
+        assert content['last_modifier'] == content['author']
+        assert content['raw_content'] == '<p> Le nouveau contenu </p>'
+        assert content['sub_content_types'] == [CONTENT_TYPES.Folder.slug]
+
+    def test_api__get_folder_revisions__ok_200__nominal_case(
+            self
+    ) -> None:
+        """
+        Get one html document of a content
+        """
+        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
+        )
+        content_api = ContentApi(
+            current_user=admin,
+            session=dbsession,
+            config=self.app_config
+        )
+        test_workspace = workspace_api.create_workspace(
+            label='test',
+            save_now=True,
+        )
+        folder = content_api.create(
+            label='test-folder',
+            content_type_slug=CONTENT_TYPES.Folder.slug,
+            workspace=test_workspace,
+            do_save=True,
+            do_notify=False
+        )
+        with new_revision(
+           session=dbsession,
+           tm=transaction.manager,
+           content=folder,
+        ):
+            content_api.update_content(
+                folder,
+                new_label='test-folder-updated',
+                new_content='Just a test'
+            )
+        content_api.save(folder)
+        with new_revision(
+           session=dbsession,
+           tm=transaction.manager,
+           content=folder,
+        ):
+            content_api.archive(
+                folder,
+            )
+        content_api.save(folder)
+        with new_revision(
+           session=dbsession,
+           tm=transaction.manager,
+           content=folder,
+        ):
+            content_api.unarchive(
+                folder,
+            )
+        content_api.save(folder)
+        transaction.commit()
+        self.testapp.authorization = (
+            'Basic',
+            (
+                'admin@admin.admin',
+                'admin@admin.admin'
+            )
+        )
+        res = self.testapp.get(
+            '/api/v2/workspaces/{workspace_id}/folders/{content_id}/revisions'.format(  # nopep8
+                workspace_id=test_workspace.workspace_id,
+                content_id=folder.content_id,
+            ),
+            status=200
+        )
+        revisions = res.json_body
+        assert len(revisions) == 4
+        revision = revisions[0]
+        assert revision['content_type'] == 'folder'
+        assert revision['content_id'] == folder.content_id
+        assert revision['is_archived'] is False
+        assert revision['is_deleted'] is False
+        assert revision['label'] == 'test-folder'
+        assert revision['parent_id'] is None
+        assert revision['show_in_ui'] is True
+        assert revision['slug'] == 'test-folder'
+        assert revision['status'] == 'open'
+        assert revision['workspace_id'] == test_workspace.workspace_id
+        assert revision['revision_id']
+        assert revision['revision_type'] == 'creation'
+        assert revision['sub_content_types']
+        # TODO - G.M - 2018-06-173 - Test with real comments
+        assert revision['comment_ids'] == []
+        # TODO - G.M - 2018-06-173 - check date format
+        assert revision['created']
+        assert revision['author']
+        assert revision['author']['user_id'] == 1
+        assert revision['author']['avatar_url'] is None
+        assert revision['author']['public_name'] == 'Global manager'
+
+        revision = revisions[1]
+        assert revision['content_type'] == 'folder'
+        assert revision['content_id'] == folder.content_id
+        assert revision['is_archived'] is False
+        assert revision['is_deleted'] is False
+        assert revision['label'] == 'test-folder-updated'
+        assert revision['parent_id'] is None
+        assert revision['show_in_ui'] is True
+        assert revision['slug'] == 'test-folder-updated'
+        assert revision['status'] == 'open'
+        assert revision['workspace_id'] == test_workspace.workspace_id
+        assert revision['revision_id']
+        assert revision['revision_type'] == 'edition'
+        assert revision['sub_content_types']
+        # TODO - G.M - 2018-06-173 - Test with real comments
+        assert revision['comment_ids'] == []
+        # TODO - G.M - 2018-06-173 - check date format
+        assert revision['created']
+        assert revision['author']
+        assert revision['author']['user_id'] == 1
+        assert revision['author']['avatar_url'] is None
+        assert revision['author']['public_name'] == 'Global manager'
+
+        revision = revisions[2]
+        assert revision['content_type'] == 'folder'
+        assert revision['content_id'] == folder.content_id
+        assert revision['is_archived'] is True
+        assert revision['is_deleted'] is False
+        assert revision['label'] != 'test-folder-updated'
+        assert revision['label'].startswith('test-folder-updated')
+        assert revision['parent_id'] is None
+        assert revision['show_in_ui'] is True
+        assert revision['slug'] != 'test-folder-updated'
+        assert revision['slug'].startswith('test-folder-updated')
+        assert revision['status'] == 'open'
+        assert revision['workspace_id'] == test_workspace.workspace_id
+        assert revision['revision_id']
+        assert revision['revision_type'] == 'archiving'
+        assert revision['sub_content_types']
+        # TODO - G.M - 2018-06-173 - Test with real comments
+        assert revision['comment_ids'] == []
+        # TODO - G.M - 2018-06-173 - check date format
+        assert revision['created']
+        assert revision['author']
+        assert revision['author']['user_id'] == 1
+        assert revision['author']['avatar_url'] is None
+        assert revision['author']['public_name'] == 'Global manager'
+
+        revision = revisions[3]
+        assert revision['content_type'] == 'folder'
+        assert revision['content_id'] == folder.content_id
+        assert revision['is_archived'] is False
+        assert revision['is_deleted'] is False
+        assert revision['label'].startswith('test-folder-updated')
+        assert revision['parent_id'] is None
+        assert revision['show_in_ui'] is True
+        assert revision['slug'].startswith('test-folder-updated')
+        assert revision['status'] == 'open'
+        assert revision['workspace_id'] == test_workspace.workspace_id
+        assert revision['revision_id']
+        assert revision['revision_type'] == 'unarchiving'
+        assert revision['sub_content_types']
+        # TODO - G.M - 2018-06-173 - Test with real comments
+        assert revision['comment_ids'] == []
+        # TODO - G.M - 2018-06-173 - check date format
+        assert revision['created']
+        assert revision['author']
+        assert revision['author']['user_id'] == 1
+        assert revision['author']['avatar_url'] is None
+        assert revision['author']['public_name'] == 'Global manager'
+
+    def test_api__set_folder_status__ok_200__nominal_case(self) -> None:
+        """
+        Get one folder content
+        """
+        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
+        )
+        content_api = ContentApi(
+            current_user=admin,
+            session=dbsession,
+            config=self.app_config
+        )
+        test_workspace = workspace_api.create_workspace(
+            label='test',
+            save_now=True,
+        )
+        folder = content_api.create(
+            label='test_folder',
+            content_type_slug=CONTENT_TYPES.Folder.slug,
+            workspace=test_workspace,
+            do_save=True,
+            do_notify=False
+        )
+        transaction.commit()
+        self.testapp.authorization = (
+            'Basic',
+            (
+                'admin@admin.admin',
+                'admin@admin.admin'
+            )
+        )
+        params = {
+            'status': 'closed-deprecated',
+        }
+
+        # before
+        res = self.testapp.get(
+            '/api/v2/workspaces/{workspace_id}/folders/{content_id}'.format(  # nopep8
+                # nopep8
+                workspace_id=test_workspace.workspace_id,
+                content_id=folder.content_id,
+            ),
+            status=200
+        )
+        content = res.json_body
+        assert content['content_type'] == 'folder'
+        assert content['content_id'] == folder.content_id
+        assert content['status'] == 'open'
+
+        # set status
+        self.testapp.put_json(
+            '/api/v2/workspaces/{workspace_id}/folders/{content_id}/status'.format(  # nopep8
+                workspace_id=test_workspace.workspace_id,
+                content_id=folder.content_id,
+            ),
+            params=params,
+            status=204
+        )
+
+        # after
+        res = self.testapp.get(
+            '/api/v2/workspaces/{workspace_id}/folders/{content_id}'.format(
+                workspace_id=test_workspace.workspace_id,
+                content_id=folder.content_id,
+            ),
+            status=200
+        )
+        content = res.json_body
+        assert content['content_type'] == 'folder'
+        assert content['content_id'] == folder.content_id
+        assert content['status'] == 'closed-deprecated'
+
+    def test_api__set_folder_status__err_400__wrong_status(self) -> None:
+        """
+        Get one folder content
+        """
+        self.testapp.authorization = (
+            'Basic',
+            (
+                'admin@admin.admin',
+                'admin@admin.admin'
+            )
+        )
+        params = {
+            'status': 'unexistant-status',
+        }
+        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
+        )
+        content_api = ContentApi(
+            current_user=admin,
+            session=dbsession,
+            config=self.app_config
+        )
+        test_workspace = workspace_api.create_workspace(
+            label='test',
+            save_now=True,
+        )
+        folder = content_api.create(
+            label='test_folder',
+            content_type_slug=CONTENT_TYPES.Folder.slug,
+            workspace=test_workspace,
+            do_save=True,
+            do_notify=False
+        )
+        transaction.commit()
+        self.testapp.put_json(
+            '/api/v2/workspaces/{workspace_id}/folders/{content_id}/status'.format(  # nopep8
+                workspace_id=test_workspace.workspace_id,
+                content_id=folder.content_id,
+            ),
+            params=params,
+            status=400
+        )
+
 
 class TestHtmlDocuments(FunctionalTest):
     """

backend/tracim_backend/tests/functional/test_workspaces.py

         assert content['show_in_ui'] is True
         assert content['slug'] == 'tools'
         assert content['status'] == 'open'
-        assert set(content['sub_content_types']) == {'thread', 'html-document', 'folder', 'file'}  # nopep8
+        assert len(content['sub_content_types']) > 1
+        assert 'comment' in content['sub_content_types']
+        assert 'folder' in content['sub_content_types']
         assert content['workspace_id'] == 1
         content = res[1]
         assert content['content_id'] == 2
         assert content['show_in_ui'] is True
         assert content['slug'] == 'menus'
         assert content['status'] == 'open'
-        assert set(content['sub_content_types']) == {'thread', 'html-document', 'folder', 'file'}  # nopep8
+        assert len(content['sub_content_types']) > 1
+        assert 'comment' in content['sub_content_types']
+        assert 'folder' in content['sub_content_types']
         assert content['workspace_id'] == 1
         content = res[2]
         assert content['content_id'] == 11
         assert content['show_in_ui'] is True
         assert content['slug'] == 'current-menu'
         assert content['status'] == 'open'
-        assert set(content['sub_content_types']) == {'thread', 'html-document', 'folder', 'file'}  # nopep8
+        assert set(content['sub_content_types']) == {'comment'}
         assert content['workspace_id'] == 1
 
     def test_api__get_workspace_content__ok_200__get_default_html_documents(self):
         assert content['show_in_ui'] is True
         assert content['slug'] == 'current-menu'
         assert content['status'] == 'open'
-        assert set(content['sub_content_types']) == {'thread', 'html-document', 'folder', 'file'}  # nopep8
+        assert set(content['sub_content_types']) == {'comment'}
         assert content['workspace_id'] == 1
 
     # Root related
         assert content['show_in_ui'] is True
         assert content['slug'] == 'new-fruit-salad'
         assert content['status'] == 'open'
-        assert set(content['sub_content_types']) == {'thread', 'html-document', 'folder', 'file'}  # nopep8
+        assert set(content['sub_content_types']) == {'comment'}
         assert content['workspace_id'] == 3
 
         content = res[2]
         assert content['show_in_ui'] is True
         assert content['slug'].startswith('fruit-salad')
         assert content['status'] == 'open'
-        assert set(content['sub_content_types']) == {'thread', 'html-document', 'folder', 'file'}  # nopep8
+        assert set(content['sub_content_types']) == {'comment'}
         assert content['workspace_id'] == 3
 
         content = res[3]
         assert content['show_in_ui'] is True
         assert content['slug'].startswith('bad-fruit-salad')
         assert content['status'] == 'open'
-        assert set(content['sub_content_types']) == {'thread', 'html-document', 'folder', 'file'}  # nopep8
+        assert set(content['sub_content_types']) == {'comment'}
         assert content['workspace_id'] == 3
 
     def test_api__get_workspace_content__ok_200__get_all_root_content(self):
         assert content['show_in_ui'] is True
         assert content['slug'] == 'new-fruit-salad'
         assert content['status'] == 'open'
-        assert set(content['sub_content_types']) == {'thread', 'html-document', 'folder', 'file'}  # nopep8
+        assert set(content['sub_content_types']) == {'comment'}
         assert content['workspace_id'] == 3
 
         content = res[2]
         assert content['show_in_ui'] is True
         assert content['slug'].startswith('fruit-salad')
         assert content['status'] == 'open'
-        assert set(content['sub_content_types']) == {'thread', 'html-document', 'folder', 'file'}  # nopep8
+        assert set(content['sub_content_types']) == {'comment'}
         assert content['workspace_id'] == 3
 
         content = res[3]
         assert content['show_in_ui'] is True
         assert content['slug'].startswith('bad-fruit-salad')
         assert content['status'] == 'open'
-        assert set(content['sub_content_types']) == {'thread', 'html-document', 'folder', 'file'}  # nopep8
+        assert set(content['sub_content_types']) == {'comment'}
         assert content['workspace_id'] == 3
 
     def test_api__get_workspace_content__ok_200__get_only_active_root_content(self):  # nopep8
         assert content['show_in_ui'] is True
         assert content['slug'] == 'new-fruit-salad'
         assert content['status'] == 'open'
-        assert set(content['sub_content_types']) == {'thread', 'html-document', 'folder', 'file'}  # nopep8
+        assert set(content['sub_content_types']) == {'comment'}
         assert content['workspace_id'] == 3
 
     def test_api__get_workspace_content__ok_200__get_only_archived_root_content(self):  # nopep8
         assert content['show_in_ui'] is True
         assert content['slug'].startswith('fruit-salad')
         assert content['status'] == 'open'
-        assert set(content['sub_content_types']) == {'thread', 'html-document', 'folder', 'file'}  # nopep8
+        assert set(content['sub_content_types']) == {'comment'}
         assert content['workspace_id'] == 3
 
     def test_api__get_workspace_content__ok_200__get_only_deleted_root_content(self):  # nopep8
         assert content['show_in_ui'] is True
         assert content['slug'].startswith('bad-fruit-salad')
         assert content['status'] == 'open'
-        assert set(content['sub_content_types']) == {'thread', 'html-document', 'folder', 'file'}  # nopep8
+        assert set(content['sub_content_types']) == {'comment'}
         assert content['workspace_id'] == 3
 
     def test_api__get_workspace_content__ok_200__get_nothing_root_content(self):
         assert content['show_in_ui'] is True
         assert content['slug'] == 'test-thread'
         assert content['status'] == 'open'
-        assert set(content['sub_content_types']) == {'thread', 'html-document', 'folder', 'file'}  # nopep8
+        assert set(content['sub_content_types']) == {'comment'}
         assert content['workspace_id'] == 1
 
     def test_api__get_workspace_content__ok_200__get_all_filter_content_html_and_legacy_page(self):  # nopep8
         assert content['show_in_ui'] is True
         assert content['slug'] == 'test-page'
         assert content['status'] == 'open'
-        assert set(content['sub_content_types']) == {'thread', 'html-document', 'folder', 'file'}  # nopep8
+        assert set(content['sub_content_types']) == {'comment'}  # nopep8
         assert content['workspace_id'] == 1
         content = res[1]
         assert content['content_type'] == 'html-document'
         assert content['show_in_ui'] is True
         assert content['slug'] == 'test-html-page'
         assert content['status'] == 'open'
-        assert set(content['sub_content_types']) == {'thread', 'html-document', 'folder', 'file'}  # nopep8
+        assert set(content['sub_content_types']) == {'comment'}  # nopep8
         assert content['workspace_id'] == 1
         assert res[0]['content_id'] != res[1]['content_id']
 
         assert content['show_in_ui'] is True
         assert content['slug'] == 'new-fruit-salad'
         assert content['status'] == 'open'
-        assert set(content['sub_content_types']) == {'thread', 'html-document', 'folder', 'file'}  # nopep8
+        assert set(content['sub_content_types']) == {'comment'}  # nopep8
         assert content['workspace_id'] == 2
 
         content = res[1]
         assert content['show_in_ui'] is True
         assert content['slug'].startswith('fruit-salad')
         assert content['status'] == 'open'
-        assert set(content['sub_content_types']) == {'thread', 'html-document', 'folder', 'file'}  # nopep8
+        assert set(content['sub_content_types']) == {'comment'}  # nopep8
         assert content['workspace_id'] == 2
 
         content = res[2]
         assert content['show_in_ui'] is True
         assert content['slug'].startswith('bad-fruit-salad')
         assert content['status'] == 'open'
-        assert set(content['sub_content_types']) == {'thread', 'html-document', 'folder', 'file'}  # nopep8
+        assert set(content['sub_content_types']) == {'comment'}  # nopep8
         assert content['workspace_id'] == 2
 
     def test_api__get_workspace_content__ok_200__get_only_active_folder_content(self):  # nopep8
         assert content['show_in_ui'] is True
         assert content['slug'] == 'new-fruit-salad'
         assert content['status'] == 'open'
-        assert set(content['sub_content_types']) == {'thread', 'html-document', 'folder', 'file'}  # nopep8
+        assert set(content['sub_content_types']) == {'comment'}  # nopep8
         assert content['workspace_id'] == 2
 
     def test_api__get_workspace_content__ok_200__get_only_archived_folder_content(self):  # nopep8
         assert content['show_in_ui'] is True
         assert content['slug'].startswith('fruit-salad')
         assert content['status'] == 'open'
-        assert set(content['sub_content_types']) == {'thread', 'html-document', 'folder', 'file'}  # nopep8
+        assert set(content['sub_content_types']) == {'comment'}  # nopep8
         assert content['workspace_id'] == 2
 
     def test_api__get_workspace_content__ok_200__get_only_deleted_folder_content(self):  # nopep8
         assert content['show_in_ui'] is True
         assert content['slug'].startswith('bad-fruit-salad')
         assert content['status'] == 'open'
-        assert set(content['sub_content_types']) == {'thread', 'html-document', 'folder', 'file'}  # nopep8
+        assert set(content['sub_content_types']) == {'comment'}  # nopep8
         assert content['workspace_id'] == 2
 
     def test_api__get_workspace_content__ok_200__get_nothing_folder_content(self):  # nopep8
             status=400,
         )
 
+    def test_api__post_content_create_generic_content__err_400__unallowed_content_type(self) -> None:  # nopep8
+        """
+        Create generic content
+        """
+        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
+        )
+        content_api = ContentApi(
+            current_user=admin,
+            session=dbsession,
+            config=self.app_config
+        )
+        test_workspace = workspace_api.create_workspace(
+            label='test',
+            save_now=True,
+        )
+        folder = content_api.create(
+            label='test-folder',
+            content_type_slug=CONTENT_TYPES.Folder.slug,
+            workspace=test_workspace,
+            do_save=False,
+            do_notify=False
+        )
+        content_api.set_allowed_content(folder, [CONTENT_TYPES.Folder.slug])
+        content_api.save(folder)
+        transaction.commit()
+        self.testapp.authorization = (
+            'Basic',
+            (
+                'admin@admin.admin',
+                'admin@admin.admin'
+            )
+        )
+        # unallowed_content_type
+        params = {
+            'label': 'GenericCreatedContent',
+            'content_type': 'markdownpage',
+            'parent_id': folder.content_id
+        }
+        res = self.testapp.post_json(
+            '/api/v2/workspaces/{workspace_id}/contents'.format(workspace_id=test_workspace.workspace_id),
+            params=params,
+            status=400,
+        )
+
+        # allowed_content_type
+        params = {
+            'label': 'GenericCreatedContent',
+            'content_type': 'folder',
+            'parent_id': folder.content_id
+        }
+        res = self.testapp.post_json(
+            '/api/v2/workspaces/{workspace_id}/contents'.format(workspace_id=test_workspace.workspace_id),
+            params=params,
+            status=200,
+        )
+
     def test_api_put_move_content__ok_200__nominal_case(self):
         """
         Move content

backend/tracim_backend/tests/library/test_content_api.py

 from tracim_backend.lib.core.group import GroupApi
 from tracim_backend.lib.core.user import UserApi
 from tracim_backend.exceptions import SameValueError
+from tracim_backend.exceptions import EmptyLabelNotAllowed
+from tracim_backend.exceptions import UnallowedSubContent
 # TODO - G.M - 28-03-2018 - [RoleApi] Re-enable RoleApi
 from tracim_backend.lib.core.workspace import RoleApi
 # TODO - G.M - 28-03-2018 - [WorkspaceApi] Re-enable WorkspaceApi
             'value is {} instead of {}'.format(sorteds[1].content_id,
                                                c1.content_id))
 
+    def test_unit__create_content__OK_nominal_case(self):
+        uapi = UserApi(
+            session=self.session,
+            config=self.app_config,
+            current_user=None,
+        )
+        group_api = GroupApi(
+            current_user=None,
+            session=self.session,
+            config=self.app_config,
+        )
+        groups = [group_api.get_one(Group.TIM_USER),
+                  group_api.get_one(Group.TIM_MANAGER),
+                  group_api.get_one(Group.TIM_ADMIN)]
+
+        user = uapi.create_minimal_user(email='this.is@user',
+                                        groups=groups, save_now=True)
+        workspace = WorkspaceApi(
+            current_user=user,
+            session=self.session,
+            config=self.app_config,
+        ).create_workspace('test workspace', save_now=True)
+        api = ContentApi(
+            current_user=user,
+            session=self.session,
+            config=self.app_config,
+        )
+        item = api.create(
+            content_type_slug=CONTENT_TYPES.Folder.slug,
+            workspace=workspace,
+            parent=None,
+            label='not_deleted',
+            do_save=True
+        )
+        assert isinstance(item, Content)
+
+    def test_unit__create_content__err_empty_label(self):
+        uapi = UserApi(
+            session=self.session,
+            config=self.app_config,
+            current_user=None,
+        )
+        group_api = GroupApi(
+            current_user=None,
+            session=self.session,
+            config=self.app_config,
+        )
+        groups = [group_api.get_one(Group.TIM_USER),
+                  group_api.get_one(Group.TIM_MANAGER),
+                  group_api.get_one(Group.TIM_ADMIN)]
+
+        user = uapi.create_minimal_user(email='this.is@user',
+                                        groups=groups, save_now=True)
+        workspace = WorkspaceApi(
+            current_user=user,
+            session=self.session,
+            config=self.app_config,
+        ).create_workspace('test workspace', save_now=True)
+        api = ContentApi(
+            current_user=user,
+            session=self.session,
+            config=self.app_config,
+        )
+        with pytest.raises(EmptyLabelNotAllowed):
+            api.create(
+                content_type_slug=CONTENT_TYPES.Thread.slug,
+                workspace=workspace,
+                parent=None,
+                label='',
+                do_save=True
+            )
+
+    def test_unit__create_content__err_content_type_not_allowed_in_this_folder(self):
+        uapi = UserApi(
+            session=self.session,
+            config=self.app_config,
+            current_user=None,
+        )
+        group_api = GroupApi(
+            current_user=None,
+            session=self.session,
+            config=self.app_config,
+        )
+        groups = [group_api.get_one(Group.TIM_USER),
+                  group_api.get_one(Group.TIM_MANAGER),
+                  group_api.get_one(Group.TIM_ADMIN)]
+
+        user = uapi.create_minimal_user(email='this.is@user',
+                                        groups=groups, save_now=True)
+        workspace = WorkspaceApi(
+            current_user=user,
+            session=self.session,
+            config=self.app_config,
+        ).create_workspace('test workspace', save_now=True)
+        api = ContentApi(
+            current_user=user,
+            session=self.session,
+            config=self.app_config,
+        )
+        folder = api.create(
+            content_type_slug=CONTENT_TYPES.Folder.slug,
+            workspace=workspace,
+            parent=None,
+            label='plop',
+            do_save=False
+        )
+        allowed_content_dict = {CONTENT_TYPES.Folder.slug: True, CONTENT_TYPES.File.slug: False} # nopep8
+        api._set_allowed_content(
+            folder,
+            allowed_content_dict=allowed_content_dict
+        )
+        api.save(content=folder)
+        # not in list -> do not allow
+        with pytest.raises(UnallowedSubContent):
+            api.create(
+                content_type_slug=CONTENT_TYPES.Event.slug,
+                workspace=workspace,
+                parent=folder,
+                label='lapin',
+                do_save=True
+            )
+        # in list but false -> do not allow
+        with pytest.raises(UnallowedSubContent):
+            api.create(
+                content_type_slug=CONTENT_TYPES.File.slug,
+                workspace=workspace,
+                parent=folder,
+                label='lapin',
+                do_save=True
+            )
+        # in list and true -> allow
+        api.create(
+            content_type_slug=CONTENT_TYPES.Folder.slug,
+            workspace=workspace,
+            parent=folder,
+            label='lapin',
+            do_save=True
+        )
+
+    def test_unit__create_content__err_content_type_not_allowed_in_this_workspace(self):
+        uapi = UserApi(
+            session=self.session,
+            config=self.app_config,
+            current_user=None,
+        )
+        group_api = GroupApi(
+            current_user=None,
+            session=self.session,
+            config=self.app_config,
+        )
+        groups = [group_api.get_one(Group.TIM_USER),
+                  group_api.get_one(Group.TIM_MANAGER),
+                  group_api.get_one(Group.TIM_ADMIN)]
+
+        user = uapi.create_minimal_user(email='this.is@user',
+                                        groups=groups, save_now=True)
+        workspace = WorkspaceApi(
+            current_user=user,
+            session=self.session,
+            config=self.app_config,
+        ).create_workspace('test workspace', save_now=True)
+        api = ContentApi(
+            current_user=user,
+            session=self.session,
+            config=self.app_config,
+        )
+        with pytest.raises(UnallowedSubContent):
+            api.create(
+                content_type_slug=CONTENT_TYPES.Event.slug,
+                workspace=workspace,
+                parent=None,
+                label='lapin',
+                do_save=True
+           )
+
+    def test_unit__set_allowed_content__ok__private_method(self):
+        uapi = UserApi(
+            session=self.session,
+            config=self.app_config,
+            current_user=None,
+        )
+        group_api = GroupApi(
+            current_user=None,
+            session=self.session,
+            config=self.app_config,
+        )
+        groups = [group_api.get_one(Group.TIM_USER),
+                  group_api.get_one(Group.TIM_MANAGER),
+                  group_api.get_one(Group.TIM_ADMIN)]
+
+        user = uapi.create_minimal_user(email='this.is@user',
+                                        groups=groups, save_now=True)
+        workspace = WorkspaceApi(
+            current_user=user,
+            session=self.session,
+            config=self.app_config,
+        ).create_workspace('test workspace', save_now=True)
+        api = ContentApi(
+            current_user=user,
+            session=self.session,
+            config=self.app_config,
+        )
+        folder = api.create(
+            content_type_slug=CONTENT_TYPES.Folder.slug,
+            workspace=workspace,
+            parent=None,
+            label='plop',
+            do_save=False
+        )
+        allowed_content_dict = {CONTENT_TYPES.Folder.slug: True, CONTENT_TYPES.File.slug: False}  # nopep8
+        api._set_allowed_content(
+            folder,
+            allowed_content_dict=allowed_content_dict
+        )
+        assert 'allowed_content' in folder.properties
+        assert folder.properties['allowed_content'] == {CONTENT_TYPES.Folder.slug: True, CONTENT_TYPES.File.slug: False}
+
+    def test_unit__set_allowed_content__ok__nominal_case(self):
+        uapi = UserApi(
+            session=self.session,
+            config=self.app_config,
+            current_user=None,
+        )
+        group_api = GroupApi(
+            current_user=None,
+            session=self.session,
+            config=self.app_config,
+        )
+        groups = [group_api.get_one(Group.TIM_USER),
+                  group_api.get_one(Group.TIM_MANAGER),
+                  group_api.get_one(Group.TIM_ADMIN)]
+
+        user = uapi.create_minimal_user(email='this.is@user',
+                                        groups=groups, save_now=True)
+        workspace = WorkspaceApi(
+            current_user=user,
+            session=self.session,
+            config=self.app_config,
+        ).create_workspace('test workspace', save_now=True)
+        api = ContentApi(
+            current_user=user,
+            session=self.session,
+            config=self.app_config,
+        )
+        folder = api.create(
+            content_type_slug=CONTENT_TYPES.Folder.slug,
+            workspace=workspace,
+            parent=None,
+            label='plop',
+            do_save=False
+        )
+        allowed_content_type_slug_list = [CONTENT_TYPES.Folder.slug, CONTENT_TYPES.File.slug]  # nopep8
+        api.set_allowed_content(
+            folder,
+            allowed_content_type_slug_list=allowed_content_type_slug_list
+        )
+        assert 'allowed_content' in folder.properties
+        assert folder.properties['allowed_content'] == {CONTENT_TYPES.Folder.slug: True, CONTENT_TYPES.File.slug: True}
+
+    def test_unit__restore_content_default_allowed_content__ok__nominal_case(self):
+        uapi = UserApi(
+            session=self.session,
+            config=self.app_config,
+            current_user=None,
+        )
+        group_api = GroupApi(
+            current_user=None,
+            session=self.session,
+            config=self.app_config,
+        )
+        groups = [group_api.get_one(Group.TIM_USER),
+                  group_api.get_one(Group.TIM_MANAGER),
+                  group_api.get_one(Group.TIM_ADMIN)]
+
+        user = uapi.create_minimal_user(email='this.is@user',
+                                        groups=groups, save_now=True)
+        workspace = WorkspaceApi(
+            current_user=user,
+            session=self.session,
+            config=self.app_config,
+        ).create_workspace('test workspace', save_now=True)
+        api = ContentApi(
+            current_user=user,
+            session=self.session,
+            config=self.app_config,
+        )
+        folder = api.create(
+            content_type_slug=CONTENT_TYPES.Folder.slug,
+            workspace=workspace,
+            parent=None,
+            label='plop',
+            do_save=False
+        )
+        allowed_content_type_slug_list = [CONTENT_TYPES.Folder.slug, CONTENT_TYPES.File.slug]  # nopep8
+        api.set_allowed_content(
+            folder,
+            allowed_content_type_slug_list=allowed_content_type_slug_list
+        )
+        assert 'allowed_content' in folder.properties
+        assert folder.properties['allowed_content'] == {CONTENT_TYPES.Folder.slug: True, CONTENT_TYPES.File.slug: True} # nopep8
+        api.restore_content_default_allowed_content(folder)
+        assert 'allowed_content' in folder.properties
+        assert folder.properties['allowed_content'] == CONTENT_TYPES.default_allowed_content_properties(folder.type)  # nopep8
+
     def test_delete(self):
         uapi = UserApi(
             session=self.session,

backend/tracim_backend/views/contents_api/folder_controller.py

+# coding=utf-8
+import typing
+
+import transaction
+from pyramid.config import Configurator
+from tracim_backend.models.data import UserRoleInWorkspace
+
+try:  # Python 3.5+
+    from http import HTTPStatus
+except ImportError:
+    from http import client as HTTPStatus
+
+from tracim_backend import TracimRequest
+from tracim_backend.extensions import hapic
+from tracim_backend.lib.core.content import ContentApi
+from tracim_backend.views.controllers import Controller
+from tracim_backend.views.core_api.schemas import TextBasedContentSchema
+from tracim_backend.views.core_api.schemas import FolderContentModifySchema
+from tracim_backend.views.core_api.schemas import TextBasedRevisionSchema
+from tracim_backend.views.core_api.schemas import SetContentStatusSchema
+from tracim_backend.views.core_api.schemas import WorkspaceAndContentIdPathSchema  # nopep8
+from tracim_backend.views.core_api.schemas import NoContentSchema
+from tracim_backend.lib.utils.authorization import require_content_types
+from tracim_backend.lib.utils.authorization import require_workspace_role
+from tracim_backend.exceptions import EmptyLabelNotAllowed
+from tracim_backend.models.context_models import ContentInContext
+from tracim_backend.models.context_models import RevisionInContext
+from tracim_backend.models.contents import CONTENT_TYPES
+from tracim_backend.models.contents import folder_type
+from tracim_backend.models.revision_protection import new_revision
+
+SWAGGER_TAG__Folders_ENDPOINTS = 'Folders'
+
+
+class FolderController(Controller):
+
+    @hapic.with_api_doc(tags=[SWAGGER_TAG__Folders_ENDPOINTS])
+    @require_workspace_role(UserRoleInWorkspace.READER)
+    @require_content_types([folder_type])
+    @hapic.input_path(WorkspaceAndContentIdPathSchema())
+    @hapic.output_body(TextBasedContentSchema())
+    def get_folder(self, context, request: TracimRequest, hapic_data=None) -> ContentInContext:  # nopep8
+        """
+        Get folder info
+        """
+        app_config = request.registry.settings['CFG']
+        api = ContentApi(
+            show_archived=True,
+            show_deleted=True,
+            current_user=request.current_user,
+            session=request.dbsession,
+            config=app_config,
+        )
+        content = api.get_one(
+            hapic_data.path.content_id,
+            content_type=CONTENT_TYPES.Any_SLUG
+        )
+        return api.get_content_in_context(content)
+
+    @hapic.with_api_doc(tags=[SWAGGER_TAG__Folders_ENDPOINTS])
+    @hapic.handle_exception(EmptyLabelNotAllowed, HTTPStatus.BAD_REQUEST)
+    @require_workspace_role(UserRoleInWorkspace.CONTRIBUTOR)
+    @require_content_types([folder_type])
+    @hapic.input_path(WorkspaceAndContentIdPathSchema())
+    @hapic.input_body(FolderContentModifySchema())
+    @hapic.output_body(TextBasedContentSchema())
+    def update_folder(self, context, request: TracimRequest, hapic_data=None) -> ContentInContext:  # nopep8
+        """
+        update folder
+        """
+        app_config = request.registry.settings['CFG']
+        api = ContentApi(
+            show_archived=True,
+            show_deleted=True,
+            current_user=request.current_user,
+            session=request.dbsession,
+            config=app_config,
+        )
+        content = api.get_one(
+            hapic_data.path.content_id,
+            content_type=CONTENT_TYPES.Any_SLUG
+        )
+        with new_revision(
+                session=request.dbsession,
+                tm=transaction.manager,
+                content=content
+        ):
+            api.update_content(
+                item=content,
+                new_label=hapic_data.body.label,
+                new_content=hapic_data.body.raw_content,
+
+            )
+            api.set_allowed_content(
+                content=content,
+                allowed_content_type_slug_list=hapic_data.body.sub_content_types  # nopep8
+            )
+            api.save(content)
+        return api.get_content_in_context(content)
+
+    @hapic.with_api_doc(tags=[SWAGGER_TAG__Folders_ENDPOINTS])
+    @require_workspace_role(UserRoleInWorkspace.READER)
+    @require_content_types([folder_type])
+    @hapic.input_path(WorkspaceAndContentIdPathSchema())
+    @hapic.output_body(TextBasedRevisionSchema(many=True))
+    def get_folder_revisions(
+            self,
+            context,
+            request: TracimRequest,
+            hapic_data=None
+    ) -> typing.List[RevisionInContext]:
+        """
+        get folder revisions
+        """
+        app_config = request.registry.settings['CFG']
+        api = ContentApi(
+            show_archived=True,
+            show_deleted=True,
+            current_user=request.current_user,
+            session=request.dbsession,
+            config=app_config,
+        )
+        content = api.get_one(
+            hapic_data.path.content_id,
+            content_type=CONTENT_TYPES.Any_SLUG
+        )
+        revisions = content.revisions
+        return [
+            api.get_revision_in_context(revision)
+            for revision in revisions
+        ]
+
+    @hapic.with_api_doc(tags=[SWAGGER_TAG__Folders_ENDPOINTS])
+    @require_workspace_role(UserRoleInWorkspace.CONTRIBUTOR)
+    @require_content_types([folder_type])
+    @hapic.input_path(WorkspaceAndContentIdPathSchema())
+    @hapic.input_body(SetContentStatusSchema())
+    @hapic.output_body(NoContentSchema(), default_http_code=HTTPStatus.NO_CONTENT)  # nopep8
+    def set_folder_status(self, context, request: TracimRequest, hapic_data=None) -> None:  # nopep8
+        """
+        set folder status
+        """
+        app_config = request.registry.settings['CFG']
+        api = ContentApi(
+            show_archived=True,
+            show_deleted=True,
+            current_user=request.current_user,
+            session=request.dbsession,
+            config=app_config,
+        )
+        content = api.get_one(
+            hapic_data.path.content_id,
+            content_type=CONTENT_TYPES.Any_SLUG
+        )
+        with new_revision(
+                session=request.dbsession,
+                tm=transaction.manager,
+                content=content
+        ):
+            api.set_status(
+                content,
+                hapic_data.body.status,
+            )
+            api.save(content)
+        return
+
+    def bind(self, configurator: Configurator) -> None:
+        # Get folder
+        configurator.add_route(
+            'folder',
+            '/workspaces/{workspace_id}/folders/{content_id}',
+            request_method='GET'
+        )
+        configurator.add_view(self.get_folder, route_name='folder')  # nopep8
+
+        # update folder
+        configurator.add_route(
+            'update_folder',
+            '/workspaces/{workspace_id}/folders/{content_id}',
+            request_method='PUT'
+        )  # nopep8
+        configurator.add_view(self.update_folder, route_name='update_folder')  # nopep8
+
+        # get folder revisions
+        configurator.add_route(
+            'folder_revisions',
+            '/workspaces/{workspace_id}/folders/{content_id}/revisions',  # nopep8
+            request_method='GET'
+        )
+        configurator.add_view(self.get_folder_revisions, route_name='folder_revisions')  # nopep8
+
+        # get folder revisions
+        configurator.add_route(
+            'set_folder_status',
+            '/workspaces/{workspace_id}/folders/{content_id}/status',  # nopep8
+            request_method='PUT'
+        )
+        configurator.add_view(self.set_folder_status, route_name='set_folder_status')  # nopep8

backend/tracim_backend/views/core_api/schemas.py

 from tracim_backend.models.contents import CONTENT_TYPES
 from tracim_backend.models.contents import open_status
 from tracim_backend.models.context_models import ActiveContentFilter
+from tracim_backend.models.context_models import FolderContentUpdate
 from tracim_backend.models.context_models import AutocompleteQuery
 from tracim_backend.models.context_models import ContentIdsQuery
 from tracim_backend.models.context_models import UserWorkspaceAndContentPath
     sub_content_types = marshmallow.fields.List(
         marshmallow.fields.String(
             example='html-content',
-            validate=OneOf(CONTENT_TYPES.endpoint_allowed_types_slug())
+            validate=OneOf(CONTENT_TYPES.extended_endpoint_allowed_types_slug())
         ),
         description='list of content types allowed as sub contents. '
                     'This field is required for folder contents, '
         return TextBasedContentUpdate(**data)
 
 
+class FolderContentModifySchema(ContentModifyAbstractSchema, TextBasedDataAbstractSchema):  # nopep
+    sub_content_types = marshmallow.fields.List(
+        marshmallow.fields.String(
+            example='html-document',
+            validate=OneOf(CONTENT_TYPES.extended_endpoint_allowed_types_slug())
+        ),
+        description='list of content types allowed as sub contents. '
+                    'This field is required for folder contents, '
+                    'set it to empty list in other cases'
+    )
+
+    @post_load
+    def folder_content_update(self, data):
+        return FolderContentUpdate(**data)
+
+
 class FileContentModifySchema(TextBasedContentModifySchema):
     pass
 

backend/tracim_backend/views/core_api/workspace_controller.py

 from tracim_backend.models.context_models import UserRoleWorkspaceInContext
 from tracim_backend.models.context_models import ContentInContext
 from tracim_backend.exceptions import EmptyLabelNotAllowed
+from tracim_backend.exceptions import UnallowedSubContent
 from tracim_backend.exceptions import EmailValidationFailed
 from tracim_backend.exceptions import UserCreationFailed
 from tracim_backend.exceptions import UserDoesNotExist
     @hapic.with_api_doc(tags=[SWAGGER_TAG_WORKSPACE_ENDPOINTS])
     @require_workspace_role(UserRoleInWorkspace.CONTRIBUTOR)
     @hapic.handle_exception(EmptyLabelNotAllowed, HTTPStatus.BAD_REQUEST)
+    @hapic.handle_exception(UnallowedSubContent, HTTPStatus.BAD_REQUEST)
     @hapic.input_path(WorkspaceIdPathSchema())
     @hapic.input_body(ContentCreationSchema())
     @hapic.output_body(ContentDigestSchema())