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

backend/doc/roles.md

 
 ## Global profile
 
+|                               | Normal User | Managers    | Admin          |
+|-------------------------------|-------------|-------------|----------------|
+| slug                            | users       | managers    | administrators |
+|-------------------------------|-------------|-------------|---------|
+
 
 |                               | Normal User | Managers    | Admin   |
 |-------------------------------|-------------|-------------|---------|
 | access to all user data (/users/{user_id} endpoints) |personal-only|personal-only| yes     |
 
 
+
+
 ## Workspace Roles
 
 
 |                              | Reader | Contributor | Content Manager | Workspace Manager |
 |------------------------------|--------|-------------|-----------------|-------------------|
+| slug                         | reader | contributor | content-manager |  workspace-manager|
+|------------------------------|--------|-------------|-----------------|-------------------|
+
+|                              | Reader | Contributor | Content Manager | Workspace Manager |
+|------------------------------|--------|-------------|-----------------|-------------------|
 | read content                 |  yes   | yes         | yes             | yes               |
 |------------------------------|--------|-------------|-----------------|-------------------|
 | create content               |  no    | yes         | yes             | yes               |

backend/tracim_backend/config.py

 from paste.deploy.converters import asbool
 from tracim_backend.lib.utils.logger import logger
 from depot.manager import DepotManager
+from tracim_backend.models.contents import CONTENT_TYPES
+from tracim_backend.models.data import ActionDescription
 
-from tracim_backend.models.data import ActionDescription, ContentType
 
 
 class CFG(object):
         ]
 
         self.EMAIL_NOTIFICATION_NOTIFIED_CONTENTS = [
-            ContentType.Page,
-            ContentType.Thread,
-            ContentType.File,
-            ContentType.Comment,
-            # ContentType.Folder -- Folder is skipped
+            CONTENT_TYPES.Page.slug,
+            CONTENT_TYPES.Thread.slug,
+            CONTENT_TYPES.File.slug,
+            CONTENT_TYPES.Comment.slug,
+            # CONTENT_TYPES.Folder.slug -- Folder is skipped
         ]
         if settings.get('email.notification.from'):
             raise Exception(

backend/tracim_backend/fixtures/content.py

 from tracim_backend.lib.core.content import ContentApi
 from tracim_backend.lib.core.userworkspace import RoleApi
 from tracim_backend.lib.core.workspace import WorkspaceApi
-from tracim_backend.models.data import ContentType
+from tracim_backend.models.contents import CONTENT_TYPES
 from tracim_backend.models.data import UserRoleInWorkspace
 from tracim_backend.models.revision_protection import new_revision
 
         # Folders
 
         tool_workspace = content_api.create(
-            content_type=ContentType.Folder,
+            content_type_slug=CONTENT_TYPES.Folder.slug,
             workspace=business_workspace,
             label='Tools',
             do_save=True,
             do_notify=False,
         )
         menu_workspace = content_api.create(
-            content_type=ContentType.Folder,
+            content_type_slug=CONTENT_TYPES.Folder.slug,
             workspace=business_workspace,
             label='Menus',
             do_save=True,
         )
 
         dessert_folder = content_api.create(
-            content_type=ContentType.Folder,
+            content_type_slug=CONTENT_TYPES.Folder.slug,
             workspace=recipe_workspace,
             label='Desserts',
             do_save=True,
             do_notify=False,
         )
         salads_folder = content_api.create(
-            content_type=ContentType.Folder,
+            content_type_slug=CONTENT_TYPES.Folder.slug,
             workspace=recipe_workspace,
             label='Salads',
             do_save=True,
             do_notify=False,
         )
         other_folder = content_api.create(
-            content_type=ContentType.Folder,
+            content_type_slug=CONTENT_TYPES.Folder.slug,
             workspace=other_workspace,
             label='Infos',
             do_save=True,
 
         # Pages, threads, ..
         tiramisu_page = content_api.create(
-            content_type=ContentType.Page,
+            content_type_slug=CONTENT_TYPES.Page.slug,
             workspace=recipe_workspace,
             parent=dessert_folder,
             label='Tiramisu Recipes!!!',
             content_api.save(tiramisu_page)
 
         best_cake_thread = content_api.create(
-            content_type=ContentType.Thread,
+            content_type_slug=CONTENT_TYPES.Thread.slug,
             workspace=recipe_workspace,
             parent=dessert_folder,
             label='Best Cake',
         best_cake_thread.description = 'Which is the best cake?'
         self._session.add(best_cake_thread)
         apple_pie_recipe = content_api.create(
-            content_type=ContentType.File,
+            content_type_slug=CONTENT_TYPES.File.slug,
             workspace=recipe_workspace,
             parent=dessert_folder,
             label='Apple_Pie',
         )
         self._session.add(apple_pie_recipe)
         Brownie_recipe = content_api.create(
-            content_type=ContentType.File,
+            content_type_slug=CONTENT_TYPES.File.slug,
             workspace=recipe_workspace,
             parent=dessert_folder,
             label='Brownie Recipe',
         )
         self._session.add(Brownie_recipe)
         fruits_desserts_folder = content_api.create(
-            content_type=ContentType.Folder,
+            content_type_slug=CONTENT_TYPES.Folder.slug,
             workspace=recipe_workspace,
             label='Fruits Desserts',
             parent=dessert_folder,
         )
 
         menu_page = content_api.create(
-            content_type=ContentType.Page,
+            content_type_slug=CONTENT_TYPES.Page.slug,
             workspace=business_workspace,
             parent=menu_workspace,
             label='Current Menu',
         )
 
         new_fruit_salad = content_api.create(
-            content_type=ContentType.Page,
+            content_type_slug=CONTENT_TYPES.Page.slug,
             workspace=recipe_workspace,
             parent=fruits_desserts_folder,
             label='New Fruit Salad',
             do_save=True,
         )
         old_fruit_salad = content_api.create(
-            content_type=ContentType.Page,
+            content_type_slug=CONTENT_TYPES.Page.slug,
             workspace=recipe_workspace,
             parent=fruits_desserts_folder,
             label='Fruit Salad',
         content_api.save(old_fruit_salad)
 
         bad_fruit_salad = content_api.create(
-            content_type=ContentType.Page,
+            content_type_slug=CONTENT_TYPES.Page.slug,
             workspace=recipe_workspace,
             parent=fruits_desserts_folder,
             label='Bad Fruit Salad',
 
         # File at the root for test
         new_fruit_salad = content_api.create(
-            content_type=ContentType.Page,
+            content_type_slug=CONTENT_TYPES.Page.slug,
             workspace=other_workspace,
             label='New Fruit Salad',
             do_save=True,
         )
         old_fruit_salad = content_api.create(
-            content_type=ContentType.Page,
+            content_type_slug=CONTENT_TYPES.Page.slug,
             workspace=other_workspace,
             label='Fruit Salad',
             do_save=True,
         content_api.save(old_fruit_salad)
 
         bad_fruit_salad = content_api.create(
-            content_type=ContentType.Page,
+            content_type_slug=CONTENT_TYPES.Page.slug,
             workspace=other_workspace,
             label='Bad Fruit Salad',
             do_save=True,

backend/tracim_backend/lib/core/content.py

 from tracim_backend.exceptions import ContentNotFound
 from tracim_backend.exceptions import WorkspacesDoNotMatch
 from tracim_backend.lib.utils.utils import current_date_for_filename
+from tracim_backend.models.contents import CONTENT_STATUS
+from tracim_backend.models.contents import ContentType
+from tracim_backend.models.contents import CONTENT_TYPES
 from tracim_backend.models.revision_protection import new_revision
 from tracim_backend.models.auth import User
 from tracim_backend.models.data import ActionDescription
-from tracim_backend.models.data import ContentStatus
 from tracim_backend.models.data import ContentRevisionRO
 from tracim_backend.models.data import Content
-from tracim_backend.models.data import ContentType
+
 from tracim_backend.models.data import NodeTreeItem
 from tracim_backend.models.data import RevisionReadStatus
 from tracim_backend.models.data import UserRoleInWorkspace
     else:
         # TODO - D.A. - 2014-12-02 - Manage Content Types Dynamically
         content_type_order = [
-            ContentType.Folder,
-            ContentType.Page,
-            ContentType.Thread,
-            ContentType.File,
+            CONTENT_TYPES.Folder.slug,
+            CONTENT_TYPES.Page.slug,
+            CONTENT_TYPES.Thread.slug,
+            CONTENT_TYPES.File.slug,
         ]
 
         content_1_type_index = content_type_order.index(content1.type)
     SEARCH_SEPARATORS = ',| '
     SEARCH_DEFAULT_RESULT_NB = 50
 
-    DISPLAYABLE_CONTENTS = (
-        ContentType.Folder,
-        ContentType.File,
-        ContentType.Comment,
-        ContentType.Thread,
-        ContentType.Page,
-        ContentType.PageLegacy,
-        ContentType.MarkdownPage,
-    )
+    # DISPLAYABLE_CONTENTS = (
+    #     CONTENT_TYPES.Folder.slug,
+    #     CONTENT_TYPES.File.slug,
+    #     CONTENT_TYPES.Comment.slug,
+    #     CONTENT_TYPES.Thread.slug,
+    #     CONTENT_TYPES.Page.slug,
+    #     CONTENT_TYPES.Page.slugLegacy,
+    #     ContentType.MarkdownPage,
+    # )
 
     def __init__(
             self,
 
         # Exclude non displayable types
         if not self._force_show_all_types:
-            result = result.filter(Content.type.in_(self.DISPLAYABLE_CONTENTS))
+            result = result.filter(Content.type.in_(CONTENT_TYPES.query_allowed_types_slugs()))
 
         if workspace:
             result = result.filter(Content.workspace_id == workspace.workspace_id)
     #     removed_item_ids = removed_item_ids or []  # FDV
     # 
     #     if not allowed_node_types:
-    #         allowed_node_types = [ContentType.Folder]
-    #     elif allowed_node_types==ContentType.Any:
+    #         allowed_node_types = [CONTENT_TYPES.Folder.slug]
+    #     elif allowed_node_types==CONTENT_TYPES.Any_SLUG:
     #         allowed_node_types = ContentType.all()
     # 
     #     parent_id = parent.content_id if parent else None
     #     for folder in folders:
     #         for allowed_content_type in filter_by_allowed_content_types:
     # 
-    #             is_folder = folder.type == ContentType.Folder
+    #             is_folder = folder.type == CONTENT_TYPES.Folder.slug
     #             content_type__allowed = folder.properties['allowed_content'][allowed_content_type] == True
     # 
     #             if is_folder and content_type__allowed:
     # 
     #     return result
 
-    def create(self, content_type: str, workspace: Workspace, parent: Content=None, label: str ='', filename: str = '', do_save=False, is_temporary: bool=False, do_notify=True) -> Content:
+    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 in ContentType.allowed_types()
+        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 == ContentType.Folder and not label:
+        if content_type_slug == CONTENT_TYPES.Folder.slug and not label:
             label = self.generate_folder_label(workspace, parent)
 
         content = Content()
         elif label:
             content.label = label
         else:
-            if content_type == ContentType.Comment:
+            if content_type_slug == CONTENT_TYPES.Comment.slug:
                 # INFO - G.M - 2018-07-16 - Default label for comments is
                 # empty string.
                 content.label = ''
         content.owner = self._user
         content.parent = parent
         content.workspace = workspace
-        content.type = content_type
+        content.type = content_type_slug
         content.is_temporary = is_temporary
         content.revision_type = ActionDescription.CREATION
 
         if content.type in (
-                ContentType.Page,
-                ContentType.Thread,
+                CONTENT_TYPES.Page.slug,
+                CONTENT_TYPES.Thread.slug,
         ):
             content.file_extension = '.html'
 
         return content
 
     def create_comment(self, workspace: Workspace=None, parent: Content=None, content:str ='', do_save=False) -> Content:
-        assert parent and parent.type != ContentType.Folder
+        assert parent and parent.type != CONTENT_TYPES.Folder.slug
         if not content:
             raise EmptyCommentContentNotAllowed()
         item = Content()
         if not workspace:
             workspace = item.parent.workspace
         item.workspace = workspace
-        item.type = ContentType.Comment
+        item.type = CONTENT_TYPES.Comment.slug
         item.description = content
         item.label = ''
         item.revision_type = ActionDescription.COMMENT
 
         base_request = self._base_query(workspace).filter(Content.content_id==content_id)
 
-        if content_type!=ContentType.Any:
+        if content_type!=CONTENT_TYPES.Any_SLUG:
             base_request = base_request.filter(Content.type==content_type)
 
         if parent:
         return query.filter(
             or_(
                 and_(
-                    Content.type == ContentType.File,
+                    Content.type == CONTENT_TYPES.File.slug,
                     Content.label == file_name,
                     Content.file_extension == file_extension,
                 ),
                 and_(
-                    Content.type == ContentType.Thread,
+                    Content.type == CONTENT_TYPES.Thread.slug,
                     Content.label == file_name,
                 ),
                 and_(
-                    Content.type == ContentType.Page,
+                    Content.type == CONTENT_TYPES.Page.slug,
                     Content.label == file_name,
                 ),
                 and_(
-                    Content.type == ContentType.Folder,
+                    Content.type == CONTENT_TYPES.Folder.slug,
                     Content.label == content_label,
                 ),
             )
             # Filter query on label
             folder_query = query \
                 .filter(
-                    Content.type == ContentType.Folder,
+                    Content.type == CONTENT_TYPES.Folder.slug,
                     Content.label == label,
                     Content.workspace_id == workspace.workspace_id,
                 )
 
         return query.filter(or_(
             and_(
-                Content.type == ContentType.File,
+                Content.type == CONTENT_TYPES.File.slug,
                 file_name_filter,
                 file_extension_filter,
             ),
             and_(
-                Content.type == ContentType.Thread,
+                Content.type == CONTENT_TYPES.Thread.slug,
                 file_name_filter,
                 file_extension_filter,
             ),
             and_(
-                Content.type == ContentType.Page,
+                Content.type == CONTENT_TYPES.Page.slug,
                 file_name_filter,
                 file_extension_filter,
             ),
             and_(
-                Content.type == ContentType.Folder,
+                Content.type == CONTENT_TYPES.Folder.slug,
                 label_filter,
             ),
         ))
     def _get_all_query(
         self,
         parent_id: int = None,
-        content_type: str = ContentType.Any,
+        content_type_slug: str = CONTENT_TYPES.Any_SLUG,
         workspace: Workspace = None
     ) -> Query:
         """
         Extended filter for better "get all data" query
         :param parent_id: filter by parent_id
-        :param content_type: filter by content_type slug
+        :param content_type_slug: filter by content_type slug
         :param workspace: filter by workspace
         :return:
         """
         assert parent_id is None or isinstance(parent_id, int)
-        assert content_type is not None
+        assert content_type_slug is not None
         resultset = self._base_query(workspace)
 
-        if content_type!=ContentType.Any:
+        if content_type_slug != CONTENT_TYPES.Any_SLUG:
             # 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.get_slug_aliases()))
+            content_type_object = CONTENT_TYPES.get_one_by_slug(content_type_slug)
+            all_slug_alias = [content_type_object.slug]
+            if content_type_object.slug_alias:
+                all_slug_alias.extend(content_type_object.slug_alias)
+            resultset = resultset.filter(Content.type.in_(all_slug_alias))
 
         if parent_id:
             resultset = resultset.filter(Content.parent_id==parent_id)
 
         return resultset
 
-    def get_all(self, parent_id: int=None, content_type: str=ContentType.Any, workspace: Workspace=None) -> typing.List[Content]:
+    def get_all(self, parent_id: int=None, content_type: str=CONTENT_TYPES.Any_SLUG, workspace: Workspace=None) -> typing.List[Content]:
         return self._get_all_query(parent_id, content_type, workspace).all()
 
     # TODO - G.M - 2018-07-17 - [Cleanup] Drop this method if unneeded
 
     # TODO - G.M - 2018-07-17 - [Cleanup] Drop this method if unneeded
     # TODO find an other name to filter on is_deleted / is_archived
-    def get_all_with_filter(self, parent_id: int=None, content_type: str=ContentType.Any, workspace: Workspace=None) -> typing.List[Content]:
+    def get_all_with_filter(self, parent_id: int=None, content_type: str=CONTENT_TYPES.Any_SLUG, workspace: Workspace=None) -> typing.List[Content]:
         assert parent_id is None or isinstance(parent_id, int) # DYN_REMOVE
         assert content_type is not None# DYN_REMOVE
         assert isinstance(content_type, str) # DYN_REMOVE
 
         resultset = self._base_query(workspace)
 
-        if content_type != ContentType.Any:
+        if content_type != CONTENT_TYPES.Any_SLUG:
             resultset = resultset.filter(Content.type==content_type)
 
         resultset = resultset.filter(Content.is_deleted == self._show_deleted)
 
         resultset = self._base_query(workspace)
 
-        if content_type != ContentType.Any:
+        if content_type != CONTENT_TYPES.Any_SLUG:
             resultset = resultset.filter(Content.type==content_type)
 
         return resultset.all()
     #
     #     resultset = self._base_query(workspace)
     #
-    #     if content_type != ContentType.Any:
+    #     if content_type != CONTENT_TYPES.Any_SLUG:
     #         resultset = resultset.filter(Content.type==content_type)
     #
     #     return resultset.all()
                     Content.content_id.in_(content_ids),
                     and_(
                         Content.parent_id.in_(content_ids),
-                        Content.type == ContentType.Comment
+                        Content.type == CONTENT_TYPES.Comment.slug
                     )
                 )
             )
         before_content_find = False
         for content in resultset:
             related_active_content = None
-            if ContentType.Comment == content.type:
+            if CONTENT_TYPES.Comment.slug == content.type:
                 related_active_content = content.parent
             else:
                 related_active_content = content
     #         .filter(Content.content_id.in_(not_read_content_ids)) \
     #         .order_by(desc(Content.updated))
     #
-    #     if content_type != ContentType.Any:
+    #     if content_type != CONTENT_TYPES.Any_SLUG:
     #         not_read_contents = not_read_contents.filter(
     #             Content.type==content_type)
     #     else:
     #         not_read_contents = not_read_contents.filter(
-    #             Content.type!=ContentType.Folder)
+    #             Content.type!=CONTENT_TYPES.Folder.slug)
     #
     #     if parent_id:
     #         not_read_contents = not_read_contents.filter(
     #     result = []
     #     for item in not_read_contents:
     #         new_item = None
-    #         if ContentType.Comment == item.type:
+    #         if CONTENT_TYPES.Comment.slug == item.type:
     #             new_item = item.parent
     #         else:
     #             new_item = item
         folder.properties = properties
 
     def set_status(self, content: Content, new_status: str):
-        if new_status in ContentStatus.allowed_values():
+        if new_status in CONTENT_STATUS.get_all_slugs_values():
             content.status = new_status
             content.revision_type = ActionDescription.STATUS_UPDATE
         else:
                 self.mark_read(child, read_datetime=read_datetime,
                                do_flush=False)
 
-            if ContentType.Comment == content.type:
+            if CONTENT_TYPES.Comment.slug == content.type:
                 self.mark_read(content.parent, read_datetime=read_datetime,
                                do_flush=False, recursive=False)
                 for comment in content.parent.get_comments():
         return title_keyworded_items
 
     def get_all_types(self) -> typing.List[ContentType]:
-        labels = ContentType.all()
+        labels = CONTENT_TYPES.endpoint_allowed_types_slug()
         content_types = []
         for label in labels:
-            content_types.append(ContentType(label))
+            content_types.append(CONTENT_TYPES.get_one_by_slug(label))
 
-        return ContentType.sorted(content_types)
+        return content_types
 
     # TODO - G.M - 2018-07-24 - [Cleanup] Is this method already needed ?
     def exclude_unavailable(

backend/tracim_backend/lib/mail_notifier/notifier.py

 from tracim_backend.lib.utils.logger import logger
 from tracim_backend.models import User
 from tracim_backend.models.auth import User
+from tracim_backend.models.contents import CONTENT_TYPES
 from tracim_backend.models.data import ActionDescription
 from tracim_backend.models.data import Content
-from tracim_backend.models.data import ContentType
 from tracim_backend.models.data import UserRoleInWorkspace
 from tracim_backend.lib.utils.translation import fake_translator as l_, \
     fake_translator as _
             config=self.config,
             show_archived=True,
             show_deleted=True,
-        ).get_one(event_content_id, ContentType.Any)
-        main_content = content.parent if content.type == ContentType.Comment else content
+        ).get_one(event_content_id, CONTENT_TYPES.Any_SLUG)
+        main_content = content.parent if content.type == CONTENT_TYPES.Comment.slug else content
         notifiable_roles = WorkspaceApi(
             current_user=user,
             session=self.session,
             content_text = content.description
             call_to_action_text = l_('View online')
 
-            if ContentType.Thread == content.type:
+            if CONTENT_TYPES.Thread.slug == content.type:
                 call_to_action_text = l_('Answer')
                 content_intro = l_('<span id="content-intro-username">{}</span> started a thread entitled:').format(actor.display_name)
                 content_text = '<p id="content-body-intro">{}</p>'.format(content.label) + \
                                content.get_last_comment_from(actor).description
 
-            elif ContentType.File == content.type:
+            elif CONTENT_TYPES.File.slug == content.type:
                 content_intro = l_('<span id="content-intro-username">{}</span> added a file entitled:').format(actor.display_name)
                 if content.description:
                     content_text = content.description
                 else:
                     content_text = '<span id="content-body-only-title">{}</span>'.format(content.label)
 
-            elif ContentType.Page == content.type:
+            elif CONTENT_TYPES.Page.slug == content.type:
                 content_intro = l_('<span id="content-intro-username">{}</span> added a page entitled:').format(actor.display_name)
                 content_text = '<span id="content-body-only-title">{}</span>'.format(content.label)
 
             content_text = content.description
             call_to_action_text = l_('View online')
 
-            if ContentType.File == content.type:
+            if CONTENT_TYPES.File.slug == content.type:
                 content_intro = l_('<span id="content-intro-username">{}</span> uploaded a new revision.').format(actor.display_name)
                 content_text = ''
 
-            elif ContentType.Page == content.type:
+            elif CONTENT_TYPES.Page.slug == content.type:
                 content_intro = l_('<span id="content-intro-username">{}</span> updated this page.').format(actor.display_name)
                 previous_revision = content.get_previous_revision()
                 title_diff = ''
                     title_diff + \
                     htmldiff(previous_revision.description, content.description)
 
-            elif ContentType.Thread == content.type:
+            elif CONTENT_TYPES.Thread.slug == content.type:
                 content_intro = l_('<span id="content-intro-username">{}</span> updated the thread description.').format(actor.display_name)
                 previous_revision = content.get_previous_revision()
                 title_diff = ''
         elif ActionDescription.EDITION == action:
             call_to_action_text = l_('View online')
 
-            if ContentType.File == content.type:
+            if CONTENT_TYPES.File.slug == content.type:
                 content_intro = l_('<span id="content-intro-username">{}</span> updated the file description.').format(actor.display_name)
                 content_text = '<p id="content-body-intro">{}</p>'.format(content.get_label()) + \
                     content.description

backend/tracim_backend/lib/utils/authorization.py

 from pyramid.interfaces import IAuthorizationPolicy
 from zope.interface import implementer
 
-from tracim_backend.models.contents import NewContentType
-from tracim_backend.models.context_models import ContentInContext
+from tracim_backend.models.contents import ContentType
+from tracim_backend.models.contents import CONTENT_TYPES
 
 try:
     from json.decoder import JSONDecodeError
 except ImportError:  # python3.4
     JSONDecodeError = ValueError
 
-from tracim_backend.models.contents import ContentTypeLegacy as ContentType
+from tracim_backend.models.contents import ContentType
 from tracim_backend.exceptions import InsufficientUserRoleInWorkspace
 from tracim_backend.exceptions import ContentTypeNotAllowed
 from tracim_backend.exceptions import InsufficientUserProfile
     return decorator
 
 
-def require_content_types(content_types: typing.List['NewContentType']) -> typing.Callable:  # nopep8
+def require_content_types(content_types: typing.List['ContentType']) -> typing.Callable:  # nopep8
     """
     Restricts access to specific file type or raise an exception.
     Check role for candidate_workspace.
-    :param content_types: list of NewContentType object
+    :param content_types: list of ContentType object
     :return: decorator
     """
     def decorator(func: typing.Callable) -> typing.Callable:
         @functools.wraps(func)
         def wrapper(self, context, request: 'TracimRequest') -> typing.Callable:
             content = request.current_content
-            current_content_type_slug = ContentType(content.type).slug
+            current_content_type_slug = CONTENT_TYPES.get_one_by_slug(content.type).slug
             content_types_slug = [content_type.slug for content_type in content_types]  # nopep8
             if current_content_type_slug in content_types_slug:
                 return func(self, context, request)

backend/tracim_backend/lib/utils/request.py

 from tracim_backend.exceptions import UserDoesNotExist
 from tracim_backend.exceptions import WorkspaceNotFound
 from tracim_backend.exceptions import ImmutableAttribute
-from tracim_backend.models.contents import ContentTypeLegacy as ContentType
+from tracim_backend.models.contents import CONTENT_TYPES
 from tracim_backend.lib.core.content import ContentApi
 from tracim_backend.lib.core.user import UserApi
 from tracim_backend.lib.core.workspace import WorkspaceApi
             )
             comment = api.get_one(
                 comment_id,
-                content_type=ContentType.Comment,
+                content_type=CONTENT_TYPES.Comment.slug,
                 workspace=workspace,
                 parent=content,
             )
                 session=request.dbsession,
                 config=request.registry.settings['CFG']
             )
-            content = api.get_one(content_id=content_id, workspace=workspace, content_type=ContentType.Any)  # nopep8
+            content = api.get_one(content_id=content_id, workspace=workspace, content_type=CONTENT_TYPES.Any_SLUG)  # nopep8
         except NoResultFound as exc:
             raise ContentNotFound(
                 'Content {} does not exist '

backend/tracim_backend/lib/webdav/dav_provider.py

 from tracim_backend import CFG
 from tracim_backend.lib.webdav.utils import transform_to_bdd, HistoryType, \
     SpecialFolderExtension
+from tracim_backend.models.contents import CONTENT_TYPES
 
 from wsgidav.dav_provider import DAVProvider
 from wsgidav.lock_manager import LockManager
 from tracim_backend.lib.core.workspace import WorkspaceApi
 from tracim_backend.lib.webdav import resources
 from tracim_backend.lib.webdav.utils import normpath
-from tracim_backend.models.data import ContentType, Content, Workspace
+from tracim_backend.models.data import Content
+from tracim_backend.models.data import Workspace
 
 
 class Provider(DAVProvider):
             content_revision = content_api.get_one_revision(revision_id)
             content = self.get_content_from_revision(content_revision, content_api)
 
-            if content.type == ContentType.File:
+            if content.type == CONTENT_TYPES.File.slug:
                 return resources.HistoryFileResource(
                     path=path,
                     environ=environ,
 
         if content is None:
             return None
-        if content.type == ContentType.Folder:
+        if content.type == CONTENT_TYPES.Folder.slug:
             return resources.FolderResource(
                 path=path,
                 environ=environ,
                 session=session,
                 user=user,
             )
-        elif content.type == ContentType.File:
+        elif content.type == CONTENT_TYPES.File.slug:
             return resources.FileResource(
                 path=path,
                 environ=environ,
 
     def get_content_from_revision(self, revision: ContentRevisionRO, api: ContentApi) -> Content:
         try:
-            return api.get_one(revision.content_id, ContentType.Any)
+            return api.get_one(revision.content_id, CONTENT_TYPES.Any_SLUG)
         except NoResultFound:
             return None
 

backend/tracim_backend/lib/webdav/design.py

 #coding: utf8
 from datetime import datetime
 
+from tracim_backend.models.contents import CONTENT_TYPES
 from tracim_backend.models.data import VirtualEvent
-from tracim_backend.models.data import ContentType
 from tracim_backend.models import data
 
 # FIXME: fix temporaire ...
 
     return page
 
+
 def designThread(content: data.Content, content_revision: data.ContentRevisionRO, comments) -> str:
         hist = content.get_history(drop_empty_revision=False)
 
         disc = ''
         participants = {}
         for t in allT:
-            if t.type == ContentType.Comment:
+            if t.type == CONTENT_TYPES.Comment.slug:
                 disc += '''
                     <div class="row comment comment-row">
                         <i class="fa fa-comment-o comment-icon"></i>

backend/tracim_backend/lib/webdav/resources.py

     FakeFileStream
 from tracim_backend.lib.webdav.utils import transform_to_bdd
 from tracim_backend.lib.core.workspace import WorkspaceApi
+from tracim_backend.models.contents import CONTENT_TYPES
 from tracim_backend.models.data import User, ContentRevisionRO
 from tracim_backend.models.data import Workspace
-from tracim_backend.models.data import Content, ActionDescription
-from tracim_backend.models.data import ContentType
+from tracim_backend.models.data import Content
+from tracim_backend.models.data import ActionDescription
 from tracim_backend.lib.webdav.design import designThread, designPage
 
 from wsgidav import compat
 
         for content in children:
             # the purpose is to display .history only if there's at least one content's type that has a history
-            if content.type != ContentType.Folder:
+            if content.type != CONTENT_TYPES.Folder.slug:
                 self._file_count += 1
             retlist.append(content.get_label_as_file())
 
             raise DAVError(HTTP_FORBIDDEN)
 
         folder = self.content_api.create(
-            content_type=ContentType.Folder,
+            content_type_slug=CONTENT_TYPES.Folder.slug,
             workspace=self.workspace,
             label=label,
             parent=self.content
     def getMemberList(self) -> [_DAVResource]:
         members = []
 
-        children = self.content_api.get_all(False, ContentType.Any, self.workspace)
+        children = self.content_api.get_all(False, CONTENT_TYPES.Any_SLUG, self.workspace)
 
         for content in children:
             content_path = '%s/%s' % (self.path, transform_to_display(content.get_label_as_file()))
 
-            if content.type == ContentType.Folder:
+            if content.type == CONTENT_TYPES.Folder.slug:
                 members.append(
                     FolderResource(
                         path=content_path,
                         session=self.session,
                     )
                 )
-            elif content.type == ContentType.File:
+            elif content.type == CONTENT_TYPES.File.slug:
                 self._file_count += 1
                 members.append(
                     FileResource(
         )
         visible_children = content_api.get_all(
             self.content.content_id,
-            ContentType.Any,
+            CONTENT_TYPES.Any_SLUG,
             self.workspace,
         )
 
             content_path = '%s/%s' % (self.path, transform_to_display(content.get_label_as_file()))
 
             try:
-                if content.type == ContentType.Folder:
+                if content.type == CONTENT_TYPES.Folder.slug:
                     members.append(
                         FolderResource(
                             path=content_path,
                             session=self.session,
                         )
                     )
-                elif content.type == ContentType.File:
+                elif content.type == CONTENT_TYPES.File.slug:
                     self._file_count += 1
                     members.append(
                         FileResource(
                             user=self.user,
                             session=self.session,
                         ))
-            except Exception as exc:
-                logger.exception(
-                    'Unable to construct member {}'.format(
-                        content_path,
-                    ),
-                    exc_info=True,
-                )
+            except NotImplementedError as exc:
+                pass
+            # except Exception as exc:
+            #     logger.exception(
+            #         'Unable to construct member {}'.format(
+            #             content_path,
+            #         ),
+            #         exc_info=True,
+            #     )
 
         if self._file_count > 0 and self.provider.show_history():
             members.append(
         ret = []
 
         content_id = None if self.content is None else self.content.id
-        for content in self.content_api.get_all(content_id, ContentType.Any, self.workspace):
+        for content in self.content_api.get_all(content_id, CONTENT_TYPES.Any_SLUG, self.workspace):
             if (self._is_archived and content.is_archived or
                 self._is_deleted and content.is_deleted or
                 not (content.is_archived or self._is_archived or content.is_deleted or self._is_deleted))\
-                    and content.type != ContentType.Folder:
+                    and content.type != CONTENT_TYPES.Folder.slug:
                 ret.append(content.get_label_as_file())
 
         return ret
         if self.content:
             children = self.content.children
         else:
-            children = self.content_api.get_all(False, ContentType.Any, self.workspace)
+            children = self.content_api.get_all(False, CONTENT_TYPES.Any_SLUG, self.workspace)
         
         for content in children:
             if content.is_archived == self._is_archived and content.is_deleted == self._is_deleted:
         if self.content:
             children = self.content.children
         else:
-            children = self.content_api.get_all(False, ContentType.Any, self.workspace)
+            children = self.content_api.get_all(False, CONTENT_TYPES.Any_SLUG, self.workspace)
 
         for content in children:
             if content.is_deleted:
                 retlist.append(content.get_label_as_file())
 
-                if content.type != ContentType.Folder:
+                if content.type != CONTENT_TYPES.Folder.slug:
                     self._file_count += 1
 
         return retlist
         if self.content:
             children = self.content.children
         else:
-            children = self.content_api.get_all(False, ContentType.Any, self.workspace)
+            children = self.content_api.get_all(False, CONTENT_TYPES.Any_SLUG, self.workspace)
 
         for content in children:
             if content.is_deleted:
                 content_path = '%s/%s' % (self.path, transform_to_display(content.get_label_as_file()))
 
-                if content.type == ContentType.Folder:
+                if content.type == CONTENT_TYPES.Folder.slug:
                     members.append(
                         FolderResource(
                             content_path,
                             user=self.user,
                             session=self.session,
                         ))
-                elif content.type == ContentType.File:
+                elif content.type == CONTENT_TYPES.File.slug:
                     self._file_count += 1
                     members.append(
                         FileResource(
         retlist = []
 
         for content in self.content_api.get_all_with_filter(
-                self.content if self.content is None else self.content.id, ContentType.Any):
+                self.content if self.content is None else self.content.id, CONTENT_TYPES.Any_SLUG):
             retlist.append(content.get_label_as_file())
 
-            if content.type != ContentType.Folder:
+            if content.type != CONTENT_TYPES.Folder.slug:
                 self._file_count += 1
 
         return retlist
         if self.content:
             children = self.content.children
         else:
-            children = self.content_api.get_all(False, ContentType.Any, self.workspace)
+            children = self.content_api.get_all(False, CONTENT_TYPES.Any_SLUG, self.workspace)
 
         for content in children:
             if content.is_archived:
                 content_path = '%s/%s' % (self.path, transform_to_display(content.get_label_as_file()))
 
-                if content.type == ContentType.Folder:
+                if content.type == CONTENT_TYPES.Folder.slug:
                     members.append(
                         FolderResource(
                             content_path,
                             user=self.user,
                             session=self.session,
                         ))
-                elif content.type == ContentType.File:
+                elif content.type == CONTENT_TYPES.File.slug:
                     self._file_count += 1
                     members.append(
                         FileResource(
 
         left_side = '%s/(%d - %s) ' % (self.path, revision.revision_id, revision.revision_type)
 
-        if self.content.type == ContentType.File:
+        if self.content.type == CONTENT_TYPES.File.slug:
             return HistoryFileResource(
                 path='%s%s' % (left_side, transform_to_display(revision.file_name)),
                 environ=self.environ,
 
             left_side = '%s/(%d - %s) ' % (self.path, content.revision_id, content.revision_type)
 
-            if self.content.type == ContentType.File:
+            if self.content.type == CONTENT_TYPES.File.slug:
                 members.append(HistoryFileResource(
                     path='%s%s' % (left_side, transform_to_display(content.file_name)),
                     environ=self.environ,
         return filestream
 
     def design(self):
-        if self.content.type == ContentType.Page:
+        if self.content.type == CONTENT_TYPES.Page.slug:
             return designPage(self.content, self.content_revision)
         else:
             return designThread(
                 self.content,
                 self.content_revision,
-                self.content_api.get_all(self.content.content_id, ContentType.Comment)
+                self.content_api.get_all(self.content.content_id, CONTENT_TYPES.Comment.slug)
             )
 
 

backend/tracim_backend/lib/webdav/utils.py

 from os.path import normpath as base_normpath
 
 from sqlalchemy.orm import Session
+from tracim_backend.models.contents import CONTENT_TYPES
 from wsgidav import util
 from wsgidav import compat
 
 from tracim_backend.lib.core.content import ContentApi
-from tracim_backend.models.data import Workspace, Content, ContentType, \
-    ActionDescription
+from tracim_backend.models.data import Workspace
+from tracim_backend.models.data import Content
+from tracim_backend.models.data import ActionDescription
 from tracim_backend.models.revision_protection import new_revision
 
 
 
         file = self._api.create(
             filename=self._file_name,
-            content_type=ContentType.File,
+            content_type_slug=CONTENT_TYPES.File.slug,
             workspace=self._workspace,
             parent=self._parent,
             is_temporary=is_temporary

backend/tracim_backend/models/contents.py

     CLOSED = 'closed'
 
 
-class NewContentStatus(object):
+class ContentStatus(object):
     """
-    Future ContentStatus object class
+    ContentStatus object class
     """
     def __init__(
             self,
         self.hexcolor = hexcolor
 
 
-open_status = NewContentStatus(
+open_status = ContentStatus(
     slug='open',
     global_status=GlobalStatus.OPEN.value,
     label='Open',
     hexcolor='#3f52e3',
 )
 
-closed_validated_status = NewContentStatus(
+closed_validated_status = ContentStatus(
     slug='closed-validated',
     global_status=GlobalStatus.CLOSED.value,
     label='Validated',
     hexcolor='#008000',
 )
 
-closed_unvalidated_status = NewContentStatus(
+closed_unvalidated_status = ContentStatus(
     slug='closed-unvalidated',
     global_status=GlobalStatus.CLOSED.value,
     label='Cancelled',
     hexcolor='#f63434',
 )
 
-closed_deprecated_status = NewContentStatus(
+closed_deprecated_status = ContentStatus(
     slug='closed-deprecated',
     global_status=GlobalStatus.CLOSED.value,
     label='Deprecated',
 )
 
 
-CONTENT_DEFAULT_STATUS = [
-    open_status,
-    closed_validated_status,
-    closed_unvalidated_status,
-    closed_deprecated_status,
-]
+class ContentStatusList(object):
 
+    OPEN = open_status
 
-class ContentStatusLegacy(NewContentStatus):
-    """
-    Temporary remplacement object for Legacy ContentStatus Object
-    """
-    OPEN = open_status.slug
-    CLOSED_VALIDATED = closed_validated_status.slug
-    CLOSED_UNVALIDATED = closed_unvalidated_status.slug
-    CLOSED_DEPRECATED = closed_deprecated_status.slug
-
-    def __init__(self, slug: str):
-        for status in CONTENT_DEFAULT_STATUS:
-            if slug == status.slug:
-                super(ContentStatusLegacy, self).__init__(
-                    slug=status.slug,
-                    global_status=status.global_status,
-                    label=status.label,
-                    fa_icon=status.fa_icon,
-                    hexcolor=status.hexcolor,
-                )
-                return
+    def __init__(self, extend_content_status: typing.List[ContentStatus]):
+        self._content_status = [self.OPEN]
+        self._content_status.extend(extend_content_status)
+
+    def get_one_by_slug(self, slug: str) -> ContentStatus:
+        for item in self._content_status:
+            if item.slug == slug:
+                return item
         raise ContentStatusNotExist()
 
-    @classmethod
-    def all(cls, type='') -> ['NewContentStatus']:
-        return CONTENT_DEFAULT_STATUS
+    def get_all_slugs_values(self) -> typing.List[str]:
+        """ Get alls slugs"""
+        return [item.slug for item in self._content_status]
+
+    def get_all(self) -> typing.List[ContentStatus]:
+        """ Get all status"""
+        return [item for item in self._content_status]
 
-    @classmethod
-    def allowed_values(cls):
-        return [status.slug for status in CONTENT_DEFAULT_STATUS]
+    def get_default_status(self) -> ContentStatus:
+        return self.OPEN
 
 
+CONTENT_STATUS = ContentStatusList(
+    [
+        closed_validated_status,
+        closed_unvalidated_status,
+        closed_deprecated_status,
+    ]
+)
 ####
 # ContentType
 
 
-class NewContentType(object):
+class ContentType(object):
     """
     Future ContentType object class
     """
             hexcolor: str,
             label: str,
             creation_label: str,
-            available_statuses: typing.List[NewContentStatus],
-
+            available_statuses: typing.List[ContentStatus],
+            slug_alias: typing.List[str] = None,
     ):
         self.slug = slug
         self.fa_icon = fa_icon
         self.label = label
         self.creation_label = creation_label
         self.available_statuses = available_statuses
+        self.slug_alias = slug_alias
 
 
-thread_type = NewContentType(
+thread_type = ContentType(
     slug='thread',
     fa_icon=thread.fa_icon,
     hexcolor=thread.hexcolor,
     label='Thread',
     creation_label='Discuss about a topic',
-    available_statuses=CONTENT_DEFAULT_STATUS,
+    available_statuses=CONTENT_STATUS.get_all(),
 )
 
-file_type = NewContentType(
+file_type = ContentType(
     slug='file',
     fa_icon=_file.fa_icon,
     hexcolor=_file.hexcolor,
     label='File',
     creation_label='Upload a file',
-    available_statuses=CONTENT_DEFAULT_STATUS,
+    available_statuses=CONTENT_STATUS.get_all(),
 )
 
-markdownpluspage_type = NewContentType(
+markdownpluspage_type = ContentType(
     slug='markdownpage',
     fa_icon=markdownpluspage.fa_icon,
     hexcolor=markdownpluspage.hexcolor,
     label='Rich Markdown File',
     creation_label='Create a Markdown document',
-    available_statuses=CONTENT_DEFAULT_STATUS,
+    available_statuses=CONTENT_STATUS.get_all(),
 )
 
-html_documents_type = NewContentType(
+html_documents_type = ContentType(
     slug='html-document',
     fa_icon=html_documents.fa_icon,
     hexcolor=html_documents.hexcolor,
     label='Text Document',
     creation_label='Write a document',
-    available_statuses=CONTENT_DEFAULT_STATUS,
+    available_statuses=CONTENT_STATUS.get_all(),
+    slug_alias=['page']
 )
 
 # TODO - G.M - 31-05-2018 - Set Better folder params
-folder_type = NewContentType(
+folder_type = ContentType(
     slug='folder',
     fa_icon=thread.fa_icon,
     hexcolor=thread.hexcolor,
     label='Folder',
     creation_label='Create collection of any documents',
-    available_statuses=CONTENT_DEFAULT_STATUS,
+    available_statuses=CONTENT_STATUS.get_all(),
 )
 
-CONTENT_DEFAULT_TYPE = [
-    thread_type,
-    file_type,
-    markdownpluspage_type,
-    html_documents_type,
-    folder_type,
-]
 
 # TODO - G.M - 31-05-2018 - Set Better Event params
-event_type = NewContentType(
+event_type = ContentType(
     slug='event',
     fa_icon=thread.fa_icon,
     hexcolor=thread.hexcolor,
     label='Event',
     creation_label='Event',
-    available_statuses=CONTENT_DEFAULT_STATUS,
+    available_statuses=CONTENT_STATUS.get_all(),
 )
 
 # TODO - G.M - 31-05-2018 - Set Better Event params
-comment_type = NewContentType(
+comment_type = ContentType(
     slug='comment',
     fa_icon=thread.fa_icon,
     hexcolor=thread.hexcolor,
     label='Comment',
     creation_label='Comment',
-    available_statuses=CONTENT_DEFAULT_STATUS,
+    available_statuses=CONTENT_STATUS.get_all(),
 )
 
-CONTENT_DEFAULT_TYPE_SPECIAL = [
-    event_type,
-    comment_type,
-]
-
-ALL_CONTENTS_DEFAULT_TYPES = CONTENT_DEFAULT_TYPE + CONTENT_DEFAULT_TYPE_SPECIAL
 
-
-class ContentTypeLegacy(NewContentType):
+class ContentTypeList(object):
     """
-    Temporary remplacement object for Legacy ContentType Object
+    ContentType List
     """
-
-    # special type
-    Any = 'any'
-    Folder = 'folder'
-    Event = 'event'
-    Comment = 'comment'
-
-    File = file_type.slug
-    Thread = thread_type.slug
-    Page = html_documents_type.slug
-    PageLegacy = 'page'
-    MarkdownPage = markdownpluspage_type.slug
-
-    def __init__(self, slug: str):
-        if slug == 'page':
-            slug = ContentTypeLegacy.Page
-        for content_type in ALL_CONTENTS_DEFAULT_TYPES:
-            if slug == content_type.slug:
-                super(ContentTypeLegacy, self).__init__(
-                    slug=content_type.slug,
-                    fa_icon=content_type.fa_icon,
-                    hexcolor=content_type.hexcolor,
-                    label=content_type.label,
-                    creation_label=content_type.creation_label,
-                    available_statuses=content_type.available_statuses
-                )
-                return
+    Any_SLUG = 'any'
+    Folder = folder_type
+    Comment = comment_type
+    Event = event_type
+    File = file_type
+    Page = html_documents_type
+    Thread = thread_type
+
+    def __init__(self, extend_content_status: typing.List[ContentType]):
+        self._content_types = [self.Folder]
+        self._content_types.extend(extend_content_status)
+        self._special_contents_types = [self.Comment]
+        self._extra_slugs = [self.Any_SLUG]
+
+    def get_one_by_slug(self, slug: str) -> ContentType:
+        """
+        Get ContentType object according to slug
+        match for both slug and slug_alias
+        """
+        content_types = self._content_types.copy()
+        content_types.extend(self._special_contents_types)
+        for item in content_types:
+            if item.slug == slug or (item.slug_alias and slug in item.slug_alias):  # nopep8
+                return item
         raise ContentTypeNotExist()
 
-    def get_slug_aliases(self) -> typing.List[str]:
+    def endpoint_allowed_types_slug(self) -> typing.List[str]:
         """
-        Get all slug aliases of a content,
-        useful for legacy code convertion
+        Return restricted list of content_type:
+        dont return special content_type like  comment, don't return
+        "any" slug, dont return content type slug alias , don't return event.
+        Useful to restrict slug param in schema.
         """
-        # TODO - G.M - 2018-07-05 - Remove this legacy compat code
-        # when possible.
-        page_alias = [self.Page, self.PageLegacy]
-        if self.slug in page_alias:
-            return page_alias
-        else:
-            return [self.slug]
-
-    @classmethod
-    def all(cls) -> typing.List[str]:
-        return cls.allowed_types()
-
-    @classmethod
-    def allowed_types(cls) -> typing.List[str]:
-        contents_types = [status.slug for status in ALL_CONTENTS_DEFAULT_TYPES]
-        return contents_types
-
-    @classmethod
-    def allowed_type_values(cls) -> typing.List[str]:
+        allowed_type_slug = [contents_type.slug for contents_type in self._content_types]  # nopep8
+        return allowed_type_slug
+
+    def query_allowed_types_slugs(self) -> typing.List[str]:
         """
-        All content type slug + special values like any
+        Return alls allowed types slug : content_type slug + all alias, any
+        and special content_type like comment. Do not return event.
+        Usefull allowed value to perform query to database.
         """
-        content_types = cls.allowed_types()
-        content_types.append(ContentTypeLegacy.Any)
-        return content_types
-
-    @classmethod
-    def allowed_types_for_folding(cls):
-        # This method is used for showing only "main"
-        # types in the left-side treeview
-        contents_types = [status.slug for status in CONTENT_DEFAULT_TYPE]
-        return contents_types
-
-    # TODO - G.M - 30-05-2018 - This method don't do anything.
-    @classmethod
-    def sorted(cls, types: ['ContentType']) -> ['ContentType']:
-        return types
-
-    @property
-    def id(self):
-        return self.slug
-
-    def toDict(self):
-        raise NotImplementedError()
+        allowed_types_slug = []
+        for content_type in self._content_types:
+            allowed_types_slug.append(content_type.slug)
+            if content_type.slug_alias:
+                allowed_types_slug.extend(content_type.slug_alias)
+        for content_type in self._special_contents_types:
+            allowed_types_slug.append(content_type.slug)
+        allowed_types_slug.extend(self._extra_slugs)
+        return allowed_types_slug
+
+
+CONTENT_TYPES = ContentTypeList(
+    [
+        thread_type,
+        file_type,
+        markdownpluspage_type,
+        html_documents_type,
+    ]
+)

backend/tracim_backend/models/context_models.py

 from tracim_backend.models.roles import WorkspaceRoles
 from tracim_backend.models.workspace_menu_entries import default_workspace_menu_entry
 from tracim_backend.models.workspace_menu_entries import WorkspaceMenuEntry
-from tracim_backend.models.contents import ContentTypeLegacy as ContentType
+from tracim_backend.models.contents import CONTENT_TYPES
 
 
 class PreviewAllowedDim(object):
 
     @property
     def content_type(self) -> str:
-        content_type = ContentType(self.content.type)
+        content_type = CONTENT_TYPES.get_one_by_slug(self.content.type)
         return content_type.slug
 
     @property
 
     @property
     def content_type(self) -> str:
-        content_type = ContentType(self.revision.type)
-        if content_type:
-            return content_type.slug
-        else:
-            return None
+        return CONTENT_TYPES.get_one_by_slug(self.revision.type).slug
 
     @property
     def sub_content_types(self) -> typing.List[str]:

backend/tracim_backend/models/data.py

 
     def get_allowed_content_types(self):
         # @see Content.get_allowed_content_types()
-        return [ContentType('folder')]
+        return CONTENT_TYPES.endpoint_allowed_types_slug()
 
     def get_valid_children(
             self,
                 ]
 
 
-from tracim_backend.models.contents import ContentStatusLegacy as ContentStatus
-from tracim_backend.models.contents import ContentTypeLegacy as ContentType
+from tracim_backend.models.contents import CONTENT_STATUS
+from tracim_backend.models.contents import ContentStatus
+from tracim_backend.models.contents import CONTENT_TYPES
 # TODO - G.M - 30-05-2018 - Drop this old code when whe are sure nothing
 # is lost .
 
 #         # self.icon = ContentStatus._ICONS[id]
 #         # self.css = ContentStatus._CSS[id]
 #         #
-#         # if type==ContentType.Thread:
+#         # if type==CONTENT_TYPES.Thread.slug:
 #         #     self.label = ContentStatus._LABELS_THREAD[id]
-#         # elif type==ContentType.File:
+#         # elif type==CONTENT_TYPES.File.slug:
 #         #     self.label = ContentStatus._LABELS_FILE[id]
 #         # else:
 #         #     self.label = ContentStatus._LABELS[id]
 #     #     # TODO - DYNDATATYPE - D.A. - 2014-12-02
 #     #     # Make this code dynamic loading data types
 #     #
-#     #     if content.type==ContentType.Folder:
+#     #     if content.type==CONTENT_TYPES.Folder.slug:
 #     #         return '/workspaces/{}/folders/{}'.format(content.workspace_id, content.content_id)
-#     #     elif content.type==ContentType.File:
+#     #     elif content.type==CONTENT_TYPES.File.slug:
 #     #         return '/workspaces/{}/folders/{}/files/{}'.format(content.workspace_id, content.parent_id, content.content_id)
-#     #     elif content.type==ContentType.Thread:
+#     #     elif content.type==CONTENT_TYPES.Thread.slug:
 #     #         return '/workspaces/{}/folders/{}/threads/{}'.format(content.workspace_id, content.parent_id, content.content_id)
-#     #     elif content.type==ContentType.Page:
+#     #     elif content.type==CONTENT_TYPES.Page.slug:
 #     #         return '/workspaces/{}/folders/{}/pages/{}'.format(content.workspace_id, content.parent_id, content.content_id)
 #     #
 #     # @classmethod
 
     @classmethod
     def check_properties(cls, item):
-        if item.type == ContentType.Folder:
+        if item.type == CONTENT_TYPES.Folder.slug:
             properties = item.properties
             if 'allowed_content' not in properties.keys():
                 return False
                 return False
             return True
 
-        if item.type == ContentType.Event:
+        if item.type == CONTENT_TYPES.Event.slug:
             properties = item.properties
             if 'name' not in properties.keys():
                 return False
 
         # TODO - G.M - 15-03-2018 - Choose only correct Content-type for origin
         # Only content who can be copied need this
-        if item.type == ContentType.Any:
+        if item.type == CONTENT_TYPES.Any_SLUG:
             properties = item.properties
             if 'origin' in properties.keys():
                 return True
 
     @classmethod
     def reset_properties(cls, item):
-        if item.type == ContentType.Folder:
+        if item.type == CONTENT_TYPES.Folder.slug:
             item.properties = DEFAULT_PROPERTIES
             return
 
     properties = Column('properties', Text(), unique=False, nullable=False, default='')
 
     type = Column(Unicode(32), unique=False, nullable=False)
-    status = Column(Unicode(32), unique=False, nullable=False, default=ContentStatus.OPEN)
+    status = Column(Unicode(32), unique=False, nullable=False, default=str(CONTENT_STATUS.get_default_status().slug))
     created = Column(DateTime, unique=False, nullable=False, default=datetime.utcnow)
     updated = Column(DateTime, unique=False, nullable=False, default=datetime.utcnow)
     is_deleted = Column(Boolean, unique=False, nullable=False, default=False)
         super().__setattr__(key, value)
 
     def get_status(self) -> ContentStatus:
-        return ContentStatus(self.status)
+        return CONTENT_STATUS.get_one_by_slug(self.status)
 
     def get_label(self) -> str:
         return self.label or self.file_name or ''
     def get_label_as_file(self):
         file_extension = self.file_extension or ''
 
-        if self.type == ContentType.Thread:
+        if self.type == CONTENT_TYPES.Thread.slug:
             file_extension = '.html'
-        elif self.type == ContentType.Page:
+        elif self.type == CONTENT_TYPES.Page.slug:
             file_extension = '.html'
 
         return '{0}{1}'.format(
         return format_timedelta(delta_from_datetime - datetime_object,
                                 locale=get_locale())
 
-    def get_child_nb(self, content_type: ContentType, content_status = ''):
+    def get_child_nb(self, content_type: str, content_status = ''):
         child_nb = 0
         for child in self.get_valid_children():
-            if child.type == content_type or content_type == ContentType.Any:
+            if child.type == content_type or content_type.slug == CONTENT_TYPES.Any_SLUG:
                 if not content_status:
                     child_nb = child_nb+1
                 elif content_status==child.status:
         return self.revision.get_label_as_file()
 
     def get_status(self) -> ContentStatus:
-        return ContentStatus(
+        return CONTENT_STATUS.get_one_by_slug(
             self.status,
-            # TODO - G.M - 10-04-2018 - [Cleanup] Drop this
-            # self.type.__str__()
         )
 
     def get_last_action(self) -> ActionDescription:
     def get_comments(self):
         children = []
         for child in self.children:
-            if ContentType.Comment==child.type and not child.is_deleted and not child.is_archived:
+            if CONTENT_TYPES.Comment.slug == child.type and not child.is_deleted and not child.is_archived:
                 children.append(child.node)
         return children
 
             allowed_types = self.properties['allowed_content']
             for type_label, is_allowed in allowed_types.items():
                 if is_allowed:
-                    types.append(ContentType(type_label))
+                    types.append(CONTENT_TYPES.get_one_by_slug(type_label))
         except Exception as e:
             print(e.__str__())
             print('----- /*\ *****')
             raise ValueError('Not allowed content property')
 
-        return ContentType.sorted(types)
+        return types
 
     def get_history(self, drop_empty_revision=False) -> '[VirtualEvent]':
         events = []
 
     @classmethod
     def create_from_content(cls, content: Content):
-        content_type = ContentType(content.type)
 
         label = content.get_label()
-        if content.type == ContentType.Comment:
+        if content.type == CONTENT_TYPES.Comment.slug:
             # TODO - G.M  - 10-04-2018 - [Cleanup] Remove label param
             # from this object ?
             label = l_('<strong>{}</strong> wrote:').format(content.owner.get_display_name())
         return VirtualEvent(id=content.content_id,
                             created=content.created,
                             owner=content.owner,
-                            type=content_type,
+                            type=ActionDescription(content.revision_type),
                             label=label,
                             content=content.description,
                             ref_object=content)

backend/tracim_backend/tests/__init__.py

 from tracim_backend.models import DeclarativeBase
 from tracim_backend.models import get_session_factory
 from tracim_backend.models import get_tm_session
+from tracim_backend.models.contents import CONTENT_TYPES
 from tracim_backend.models.data import Workspace
-from tracim_backend.models.data import ContentType
 from tracim_backend.models.data import ContentRevisionRO
 from tracim_backend.models.data import Content
 from tracim_backend.lib.utils.logger import logger
         workspace = self._create_workspace_and_test(workspace_name, user)
         folder = self._create_content_and_test(
             folder_name, workspace,
-            type=ContentType.Folder,
+            type=CONTENT_TYPES.Folder.slug,
             owner=user
         )
         thread = self._create_content_and_test(
             thread_name,
             workspace,
-            type=ContentType.Thread,
+            type=CONTENT_TYPES.Thread.slug,
             parent=folder,
             owner=user
         )

backend/tracim_backend/tests/functional/test_contents.py

 from tracim_backend.lib.core.content import ContentApi
 from tracim_backend.lib.core.workspace import WorkspaceApi
 from tracim_backend.models import get_tm_session
-from tracim_backend.models.contents import ContentTypeLegacy as ContentType
+from tracim_backend.models.contents import CONTENT_TYPES
 from tracim_backend.models.revision_protection import new_revision
 import io
 
 from tracim_backend import models
 from tracim_backend.lib.core.content import ContentApi
 from tracim_backend.lib.core.workspace import WorkspaceApi
-from tracim_backend.models.data import ContentType
 from tracim_backend.models import get_tm_session
 from tracim_backend.models.revision_protection import new_revision
 from tracim_backend.tests import FunctionalTest
             config=self.app_config
         )
         business_workspace = workspace_api.get_one(1)
-        tool_folder = content_api.get_one(1, content_type=ContentType.Any)
+        tool_folder = content_api.get_one(1, content_type=CONTENT_TYPES.Any_SLUG)
         test_file = content_api.create(
-            content_type=ContentType.File,
+            content_type_slug=CONTENT_TYPES.File.slug,
             workspace=business_workspace,
             parent=tool_folder,
             label='Test file',
             config=self.app_config
         )
         business_workspace = workspace_api.get_one(1)
-        tool_folder = content_api.get_one(1, content_type=ContentType.Any)
+        tool_folder = content_api.get_one(1, content_type=CONTENT_TYPES.Any_SLUG)
         test_file = content_api.create(
-            content_type=ContentType.File,
+            content_type_slug=CONTENT_TYPES.File.slug,
             workspace=business_workspace,
             parent=tool_folder,
             label='Test file',
             config=self.app_config
         )
         business_workspace = workspace_api.get_one(1)
-        tool_folder = content_api.get_one(1, content_type=ContentType.Any)
+        tool_folder = content_api.get_one(1, content_type=CONTENT_TYPES.Any_SLUG)
         test_file = content_api.create(
-            content_type=ContentType.File,
+            content_type_slug=CONTENT_TYPES.File.slug,
             workspace=business_workspace,
             parent=tool_folder,
             label='Test file',
             config=self.app_config
         )
         business_workspace = workspace_api.get_one(1)
-        tool_folder = content_api.get_one(1, content_type=ContentType.Any)
+        tool_folder = content_api.get_one(1, content_type=CONTENT_TYPES.Any_SLUG)
         test_file = content_api.create(
-            content_type=ContentType.File,
+            content_type_slug=CONTENT_TYPES.File.slug,
             workspace=business_workspace,
             parent=tool_folder,
             label='Test file',
             config=self.app_config
         )
         business_workspace = workspace_api.get_one(1)
-        tool_folder = content_api.get_one(1, content_type=ContentType.Any)
+        tool_folder = content_api.get_one(1, content_type=CONTENT_TYPES.Any_SLUG)
         test_file = content_api.create(
-            content_type=ContentType.File,
+            content_type_slug=CONTENT_TYPES.File.slug,
             workspace=business_workspace,
             parent=tool_folder,
             label='Test file',
             config=self.app_config
         )
         business_workspace = workspace_api.get_one(1)
-        tool_folder = content_api.get_one(1, content_type=ContentType.Any)
+        tool_folder = content_api.get_one(1, content_type=CONTENT_TYPES.Any_SLUG)
         test_file = content_api.create(
-            content_type=ContentType.File,
+            content_type_slug=CONTENT_TYPES.File.slug,
             workspace=business_workspace,
             parent=tool_folder,
             label='Test file',
             config=self.app_config
         )
         business_workspace = workspace_api.get_one(1)
-        tool_folder = content_api.get_one(1, content_type=ContentType.Any)
+        tool_folder = content_api.get_one(1, content_type=CONTENT_TYPES.Any_SLUG)
         test_file = content_api.create(
-            content_type=ContentType.File,
+            content_type_slug=CONTENT_TYPES.File.slug,
             workspace=business_workspace,
             parent=tool_folder,
             label='Test file',
             config=self.app_config
         )
         business_workspace = workspace_api.get_one(1)
-        tool_folder = content_api.get_one(1, content_type=ContentType.Any)
+        tool_folder = content_api.get_one(1, content_type=CONTENT_TYPES.Any_SLUG)
         test_file = content_api.create(
-            content_type=ContentType.File,
+            content_type_slug=CONTENT_TYPES.File.slug,
             workspace=business_workspace,
             parent=tool_folder,
             label='Test file',
             config=self.app_config
         )
         business_workspace = workspace_api.get_one(1)
-        tool_folder = content_api.get_one(1, content_type=ContentType.Any)
+        tool_folder = content_api.get_one(1, content_type=CONTENT_TYPES.Any_SLUG)
         test_file = content_api.create(
-            content_type=ContentType.File,
+            content_type_slug=CONTENT_TYPES.File.slug,
             workspace=business_workspace,
             parent=tool_folder,
             label='Test file',
             config=self.app_config
         )
         business_workspace = workspace_api.get_one(1)
-        tool_folder = content_api.get_one(1, content_type=ContentType.Any)
+        tool_folder = content_api.get_one(1, content_type=CONTENT_TYPES.Any_SLUG)
         test_file = content_api.create(
-            content_type=ContentType.File,
+            content_type_slug=CONTENT_TYPES.File.slug,
             workspace=business_workspace,
             parent=tool_folder,
             label='Test file',
             config=self.app_config
         )
         business_workspace = workspace_api.get_one(1)
-        tool_folder = content_api.get_one(1, content_type=ContentType.Any)
+        tool_folder = content_api.get_one(1, content_type=CONTENT_TYPES.Any_SLUG)
         test_file = content_api.create(
-            content_type=ContentType.File,
+            content_type_slug=CONTENT_TYPES.File.slug,
             workspace=business_workspace,
             parent=tool_folder,
             label='Test file',
             config=self.app_config
         )
         business_workspace = workspace_api.get_one(1)
-        tool_folder = content_api.get_one(1, content_type=ContentType.Any)
+        tool_folder = content_api.get_one(1, content_type=CONTENT_TYPES.Any_SLUG)
         test_file = content_api.create(
-            content_type=ContentType.File,
+            content_type_slug=CONTENT_TYPES.File.slug,
             workspace=business_workspace,
             parent=tool_folder,
             label='Test file',
             config=self.app_config
         )
         business_workspace = workspace_api.get_one(1)
-        tool_folder = content_api.get_one(1, content_type=ContentType.Any)
+        tool_folder = content_api.get_one(1, content_type=CONTENT_TYPES.Any_SLUG)
         test_file = content_api.create(
-            content_type=ContentType.File,
+            content_type_slug=CONTENT_TYPES.File.slug,
             workspace=business_workspace,
             parent=tool_folder,
             label='Test file',
             config=self.app_config
         )
         business_workspace = workspace_api.get_one(1)
-        tool_folder = content_api.get_one(1, content_type=ContentType.Any)
+        tool_folder = content_api.get_one(1, content_type=CONTENT_TYPES.Any_SLUG)
         test_file = content_api.create(
-            content_type=ContentType.File,
+            content_type_slug=CONTENT_TYPES.File.slug,
             workspace=business_workspace,
             parent=tool_folder,
             label='Test file',
             config=self.app_config
         )
         business_workspace = workspace_api.get_one(1)
-        tool_folder = content_api.get_one(1, content_type=ContentType.Any)
+        tool_folder = content_api.get_one(1, content_type=CONTENT_TYPES.Any_SLUG)
         test_file = content_api.create(
-            content_type=ContentType.File,
+            content_type_slug=CONTENT_TYPES.File.slug,
             workspace=business_workspace,
             parent=tool_folder,
             label='Test file',
             config=self.app_config
         )
         business_workspace = workspace_api.get_one(1)
-        tool_folder = content_api.get_one(1, content_type=ContentType.Any)
+        tool_folder = content_api.get_one(1, content_type=CONTENT_TYPES.Any_SLUG)
         test_file = content_api.create(
-            content_type=ContentType.File,
+            content_type_slug=CONTENT_TYPES.File.slug,
             workspace=business_workspace,
             parent=tool_folder,
             label='Test file',
             config=self.app_config
         )
         business_workspace = workspace_api.get_one(1)
-        tool_folder = content_api.get_one(1, content_type=ContentType.Any)
+        tool_folder = content_api.get_one(1, content_type=CONTENT_TYPES.Any_SLUG)
         test_file = content_api.create(
-            content_type=ContentType.File,
+            content_type_slug=CONTENT_TYPES.File.slug,
             workspace=business_workspace,
             parent=tool_folder,
             label='Test file',
             session=dbsession,
             config=self.app_config
         )
-        tool_folder = content_api.get_one(1, content_type=ContentType.Any)
+        tool_folder = content_api.get_one(1, content_type=CONTENT_TYPES.Any_SLUG)
         test_thread = content_api.create(
-            content_type=ContentType.Thread,
+            content_type_slug=CONTENT_TYPES.Thread.slug,
             workspace=business_workspace,
             parent=tool_folder,
             label='Test Thread',

backend/tracim_backend/tests/functional/test_mail_notification.py

 from tracim_backend.fixtures.content import Content as ContentFixture
 from tracim_backend.lib.utils.utils import get_redis_connection
 from tracim_backend.lib.utils.utils import get_rq_queue
-from tracim_backend.models.data import ContentType
+from tracim_backend.models.contents import CONTENT_TYPES
 
 from tracim_backend.lib.core.content import ContentApi
 from tracim_backend.lib.core.user import UserApi
             config=self.app_config,
         )
         item = api.create(
-            ContentType.Folder,
+            CONTENT_TYPES.Folder.slug,
             workspace,
             None,
             'parent',
             do_notify=False,
         )
         item2 = api.create(
-            ContentType.File,
+            CONTENT_TYPES.File.slug,
             workspace,
             item,
             'file1',
             config=self.app_config,
         )
         item = api.create(
-            ContentType.Folder,
+            CONTENT_TYPES.Folder.slug,
             workspace,
             None,
             'parent',
             do_notify=False,
         )
         item2 = api.create(
-            ContentType.File,
+            CONTENT_TYPES.File.slug,
             workspace,
             item,
             'file1',

backend/tracim_backend/tests/functional/test_system.py

 Tests for /api/v2/system subpath endpoints.
 """
 
+
 class TestApplicationEndpoint(FunctionalTest):
     """
     Tests for /api/v2/system/applications
         res = self.testapp.get('/api/v2/system/content_types', status=200)
         res = res.json_body
 
-        content_type = res[0]
+        content_type = res[1]
         assert content_type['slug'] == 'thread'
         assert content_type['fa_icon'] == 'comments-o'
         assert content_type['hexcolor'] == '#ad4cf9'
         assert 'available_statuses' in content_type
         assert len(content_type['available_statuses']) == 4
 
-        content_type = res[1]
+        content_type = res[2]
         assert content_type['slug'] == 'file'
         assert content_type['fa_icon'] == 'paperclip'
         assert content_type['hexcolor'] == '#FF9900'
         assert 'available_statuses' in content_type
         assert len(content_type['available_statuses']) == 4
 
-        content_type = res[2]
+        content_type = res[3]
         assert content_type['slug'] == 'markdownpage'
         assert content_type['fa_icon'] == 'file-code-o'
         assert content_type['hexcolor'] == '#f12d2d'
         assert 'available_statuses' in content_type
         assert len(content_type['available_statuses']) == 4
 
-        content_type = res[3]
+        content_type = res[4]
         assert content_type['slug'] == 'html-document'
         assert content_type['fa_icon'] == 'file-text-o'
         assert content_type['hexcolor'] == '#3f52e3'

backend/tracim_backend/tests/functional/test_user.py

 from tracim_backend.lib.core.userworkspace import RoleApi
 from tracim_backend.lib.core.workspace import WorkspaceApi
 from tracim_backend.models import get_tm_session
-from tracim_backend.models.contents import ContentTypeLegacy as ContentType
+from tracim_backend.models.contents import CONTENT_TYPES
 from tracim_backend.models.data import UserRoleInWorkspace
 from tracim_backend.models.revision_protection import new_revision
 from tracim_backend.tests import FunctionalTest
             session=dbsession,
             config=self.app_config,
         )
-        main_folder_workspace2 = api.create(ContentType.Folder, workspace2, None, 'Hepla', '', True)  # nopep8
-        main_folder = api.create(ContentType.Folder, workspace, None, 'this is randomized folder', '', True)  # nopep8
+        main_folder_workspace2 = api.create(CONTENT_TYPES.Folder.slug, workspace2, None, 'Hepla', '', True)  # nopep8
+        main_folder = api.create(CONTENT_TYPES.Folder.slug, workspace, None, 'this is randomized folder', '', True)  # nopep8
         # creation order test
-        firstly_created = api.create(ContentType.Page, workspace, main_folder, 'creation_order_test', '', True)  # nopep8
-        secondly_created = api.create(ContentType.Page, workspace, main_folder, 'another creation_order_test', '', True)  # nopep8
+        firstly_created = api.create(CONTENT_TYPES.Page.slug, workspace, main_folder, 'creation_order_test', '', True)  # nopep8
+        secondly_created = api.create(CONTENT_TYPES.Page.slug, workspace, main_folder, 'another creation_order_test', '', True)  # nopep8
         # update order test
-        firstly_created_but_recently_updated = api.create(ContentType.Page, workspace, main_folder, 'update_order_test', '', True)  # nopep8
-        secondly_created_but_not_updated = api.create(ContentType.Page, workspace, main_folder, 'another update_order_test', '', True)  # nopep8
+        firstly_created_but_recently_updated = api.create(CONTENT_TYPES.Page.slug, workspace, main_folder, 'update_order_test', '', True)  # nopep8
+        secondly_created_but_not_updated = api.create(CONTENT_TYPES.Page.slug, workspace, main_folder, 'another update_order_test', '', True)  # nopep8
         with new_revision(
             session=dbsession,
             tm=transaction.manager,
             firstly_created_but_recently_updated.description = 'Just an update'
         api.save(firstly_created_but_recently_updated)
         # comment change order
-        firstly_created_but_recently_commented = api.create(ContentType.Page, workspace, main_folder, 'this is randomized label content', '', True)  # nopep8
-        secondly_created_but_not_commented = api.create(ContentType.Page, workspace, main_folder, 'this is another randomized label content', '', True)  # nopep8
+        firstly_created_but_recently_commented = api.create(CONTENT_TYPES.Page.slug, workspace, main_folder, 'this is randomized label content', '', True)  # nopep8
+        secondly_created_but_not_commented = api.create(CONTENT_TYPES.Page.slug, workspace, main_folder, 'this is another randomized label content', '', True)  # nopep8
         comments = api.create_comment(workspace, firstly_created_but_recently_commented, 'juste a super comment', True)  # nopep8
-        content_workspace_2 = api.create(ContentType.Page, workspace2,main_folder_workspace2, 'content_workspace_2', '',True)  # nopep8
+        content_workspace_2 = api.create(CONTENT_TYPES.Page.slug, workspace2,main_folder_workspace2, 'content_workspace_2', '',True)  # nopep8
         dbsession.flush()
         transaction.commit()
 
             session=dbsession,
             config=self.app_config,
         )
-        main_folder_workspace2 = api.create(ContentType.Folder, workspace2, None, 'Hepla', '', True)  # nopep8
-        main_folder = api.create(ContentType.Folder, workspace, None, 'this is randomized folder', '', True)  # nopep8
+        main_folder_workspace2 = api.create(CONTENT_TYPES.Folder.slug, workspace2, None, 'Hepla', '', True)  # nopep8
+        main_folder = api.create(CONTENT_TYPES.Folder.slug, workspace, None, 'this is randomized folder', '', True)  # nopep8
         # creation order test
-        firstly_created = api.create(ContentType.Page, workspace, main_folder, 'creation_order_test', '', True)  # nopep8
-        secondly_created = api.create(ContentType.Page, workspace, main_folder, 'another creation_order_test', '', True)  # nopep8
+        firstly_created = api.create(CONTENT_TYPES.Page.slug, workspace, main_folder, 'creation_order_test', '', True)  # nopep8
+        secondly_created = api.create(CONTENT_TYPES.Page.slug, workspace, main_folder, 'another creation_order_test', '', True)  # nopep8
         # update order test
-        firstly_created_but_recently_updated = api.create(ContentType.Page, workspace, main_folder, 'update_order_test', '', True)  # nopep8
-        secondly_created_but_not_updated = api.create(ContentType.Page, workspace, main_folder, 'another update_order_test', '', True)  # nopep8
+        firstly_created_but_recently_updated = api.create(CONTENT_TYPES.Page.slug, workspace, main_folder, 'update_order_test', '', True)  # nopep8
+        secondly_created_but_not_updated = api.create(CONTENT_TYPES.Page.slug, workspace, main_folder, 'another update_order_test', '', True)  # nopep8
+
         with new_revision(
             session=dbsession,
             tm=transaction.manager,
             firstly_created_but_recently_updated.description = 'Just an update'
         api.save(firstly_created_but_recently_updated)
         # comment change order
-        firstly_created_but_recently_commented = api.create(ContentType.Page, workspace, main_folder, 'this is randomized label content', '', True)  # nopep8
-        secondly_created_but_not_commented = api.create(ContentType.Page, workspace, main_folder, 'this is another randomized label content', '', True)  # nopep8
+        firstly_created_but_recently_commented = api.create(CONTENT_TYPES.Page.slug, workspace, main_folder, 'this is randomized label content', '', True)  # nopep8
+        secondly_created_but_not_commented = api.create(CONTENT_TYPES.Page.slug, workspace, main_folder, 'this is another randomized label content', '', True)  # nopep8
         comments = api.create_comment(workspace, firstly_created_but_recently_commented, 'juste a super comment', True)  # nopep8
-        content_workspace_2 = api.create(ContentType.Page, workspace2,main_folder_workspace2, 'content_workspace_2', '',True)  # nopep8
+        content_workspace_2 = api.create(CONTENT_TYPES.Page.slug, workspace2,main_folder_workspace2, 'content_workspace_2', '',True)  # nopep8
         dbsession.flush()
         transaction.commit()
 
             session=dbsession,
             config=self.app_config,
         )
-        main_folder_workspace2 = api.create(ContentType.Folder, workspace2, None, 'Hepla', '', True)  # nopep8
-        main_folder = api.create(ContentType.Folder, workspace, None, 'this is randomized folder', '', True)  # nopep8
+        main_folder_workspace2 = api.create(CONTENT_TYPES.Folder.slug, workspace2, None, 'Hepla', '', True)  # nopep8
+        main_folder = api.create(CONTENT_TYPES.Folder.slug, workspace, None, 'this is randomized folder', '', True)  # nopep8
         # creation order test
-        firstly_created = api.create(ContentType.Page, workspace, main_folder, 'creation_order_test', '', True)  # nopep8
-        secondly_created = api.create(ContentType.Page, workspace, main_folder, 'another creation_order_test', '', True)  # nopep8
+        firstly_created = api.create(CONTENT_TYPES.Page.slug, workspace, main_folder, 'creation_order_test', '', True)  # nopep8
+        secondly_created = api.create(CONTENT_TYPES.Page.slug, workspace, main_folder, 'another creation_order_test', '', True)  # nopep8
         # update order test
-        firstly_created_but_recently_updated = api.create(ContentType.Page, workspace, main_folder, 'update_order_test', '', True)  # nopep8
-        secondly_created_but_not_updated = api.create(ContentType.Page, workspace, main_folder, 'another update_order_test', '', True)  # nopep8
+        firstly_created_but_recently_updated = api.create(CONTENT_TYPES.Page.slug, workspace, main_folder, 'update_order_test', '', True)  # nopep8
+        secondly_created_but_not_updated = api.create(CONTENT_TYPES.Page.slug, workspace, main_folder, 'another update_order_test', '', True)  # nopep8
         with new_revision(
             session=dbsession,
             tm=transaction.manager,
             firstly_created_but_recently_updated.description = 'Just an update'
         api.save(firstly_created_but_recently_updated)
         # comment change order
-        firstly_created_but_recently_commented = api.create(ContentType.Page, workspace, main_folder, 'this is randomized label content', '', True)  # nopep8
-        secondly_created_but_not_commented = api.create(ContentType.Page, workspace, main_folder, 'this is another randomized label content', '', True)  # nopep8
+        firstly_created_but_recently_commented = api.create(CONTENT_TYPES.Page.slug, workspace, main_folder, 'this is randomized label content', '', True)  # nopep8
+        secondly_created_but_not_commented = api.create(CONTENT_TYPES.Page.slug, workspace, main_folder, 'this is another randomized label content', '', True)  # nopep8
         comments = api.create_comment(workspace, firstly_created_but_recently_commented, 'juste a super comment', True)  # nopep8
-        content_workspace_2 = api.create(ContentType.Page, workspace2,main_folder_workspace2, 'content_workspace_2', '',True)  # nopep8
+        content_workspace_2 = api.create(CONTENT_TYPES.Page.slug, workspace2,main_folder_workspace2, 'content_workspace_2', '',True)  # nopep8
         dbsession.flush()
         transaction.commit()
 
             session=dbsession,
             config=self.app_config,
         )
-        main_folder_workspace2 = api.create(ContentType.Folder, workspace2, None, 'Hepla', '', True)  # nopep8
-        main_folder = api.create(ContentType.Folder, workspace, None, 'this is randomized folder', '', True)  # nopep8
+        main_folder_workspace2 = api.create(CONTENT_TYPES.Folder.slug, workspace2, None, 'Hepla', '', True)  # nopep8
+        main_folder = api.create(CONTENT_TYPES.Folder.slug, workspace, None, 'this is randomized folder', '', True)  # nopep8
         # creation order test
-        firstly_created = api.create(ContentType.Page, workspace, main_folder, 'creation_order_test', '', True)  # nopep8
-        secondly_created = api.create(ContentType.Page, workspace, main_folder, 'another creation_order_test', '', True)  # nopep8
+        firstly_created = api.create(CONTENT_TYPES.Page.slug, workspace, main_folder, 'creation_order_test', '', True)  # nopep8
+        secondly_created = api.create(CONTENT_TYPES.Page.slug, workspace, main_folder, 'another creation_order_test', '', True)  # nopep8
         # update order test
-        firstly_created_but_recently_updated = api.create(ContentType.Page, workspace, main_folder, 'update_order_test', '', True)  # nopep8
-        secondly_created_but_not_updated = api.create(ContentType.Page, workspace, main_folder, 'another update_order_test', '', True)  # nopep8
+        firstly_created_but_recently_updated = api.create(CONTENT_TYPES.Page.slug, workspace, main_folder, 'update_order_test', '', True)  # nopep8
+        secondly_created_but_not_updated = api.create(CONTENT_TYPES.Page.slug, workspace, main_folder, 'another update_order_test', '', True)  # nopep8
         with new_revision(
             session=dbsession,
             tm=transaction.manager,
             firstly_created_but_recently_updated.description = 'Just an update'
         api.save(firstly_created_but_recently_updated)
         # comment change order
-        firstly_created_but_recently_commented = api.create(ContentType.Page, workspace, main_folder, 'this is randomized label content', '', True)  # nopep8
-        secondly_created_but_not_commented = api.create(ContentType.Page, workspace, main_folder, 'this is another randomized label content', '', True)  # nopep8
+        firstly_created_but_recently_commented = api.create(CONTENT_TYPES.Page.slug, workspace, main_folder, 'this is randomized label content', '', True)  # nopep8
+        secondly_created_but_not_commented = api.create(CONTENT_TYPES.Page.slug, workspace, main_folder, 'this is another randomized label content', '', True)  # nopep8
         comments = api.create_comment(workspace, firstly_created_but_recently_commented, 'juste a super comment', True)  # nopep8
-        content_workspace_2 = api.create(ContentType.Page, workspace2,main_folder_workspace2, 'content_workspace_2', '',True)  # nopep8
+        content_workspace_2 = api.create(CONTENT_TYPES.Page.slug, workspace2,main_folder_workspace2, 'content_workspace_2', '',True)  # nopep8
         dbsession.flush()
         transaction.commit()
 
             session=dbsession,
             config=self.app_config,
         )
-        main_folder_workspace2 = api.create(ContentType.Folder, workspace2, None, 'Hepla', '', True)  # nopep8
-        main_folder = api.create(ContentType.Folder, workspace, None, 'this is randomized folder', '', True)  # nopep8
+        main_folder_workspace2 = api.create(CONTENT_TYPES.Folder.slug, workspace2, None, 'Hepla', '', True)  # nopep8
+        main_folder = api.create(CONTENT_TYPES.Folder.slug, workspace, None, 'this is randomized folder', '', True)  # nopep8
         # creation order test
-        firstly_created = api.create(ContentType.Page, workspace, main_folder, 'creation_order_test', '', True)  # nopep8
-        secondly_created = api.create(ContentType.Page, workspace, main_folder, 'another creation_order_test', '', True)  # nopep8
+        firstly_created = api.create(CONTENT_TYPES.Page.slug, workspace, main_folder, 'creation_order_test', '', True)  # nopep8
+        secondly_created = api.create(CONTENT_TYPES.Page.slug, workspace, main_folder, 'another creation_order_test', '', True)  # nopep8
         # update order test
-        firstly_created_but_recently_updated = api.create(ContentType.Page, workspace, main_folder, 'update_order_test', '', True)  # nopep8
-        secondly_created_but_not_updated = api.create(ContentType.Page, workspace, main_folder, 'another update_order_test', '', True)  # nopep8
+        firstly_created_but_recently_updated = api.create(CONTENT_TYPES.Page.slug, workspace, main_folder, 'update_order_test', '', True)  # nopep8
+        secondly_created_but_not_updated = api.create(CONTENT_TYPES.Page.slug, workspace, main_folder, 'another update_order_test', '', True)  # nopep8
         with new_revision(
             session=dbsession,
             tm=transaction.manager,
             firstly_created_but_recently_updated.description = 'Just an update'
         api.save(firstly_created_but_recently_updated)
         # comment change order
-        firstly_created_but_recently_commented = api.create(ContentType.Page, workspace, main_folder, 'this is randomized label content', '', True)  # nopep8
-        secondly_created_but_not_commented = api.create(ContentType.Page, workspace, main_folder, 'this is another randomized label content', '', True)  # nopep8
+        firstly_created_but_recently_commented = api.create(CONTENT_TYPES.Page.slug, workspace, main_folder, 'this is randomized label content', '', True)  # nopep8
+        secondly_created_but_not_commented = api.create(CONTENT_TYPES.Page.slug, workspace, main_folder, 'this is another randomized label content', '', True)  # nopep8
         comments = api.create_comment(workspace, firstly_created_but_recently_commented, 'juste a super comment', True)  # nopep8
-        content_workspace_2 = api.create(ContentType.Page, workspace2,main_folder_workspace2, 'content_workspace_2', '',True)  # nopep8
+        content_workspace_2 = api.create(CONTENT_TYPES.Page.slug, workspace2,main_folder_workspace2, 'content_workspace_2', '',True)  # nopep8
         dbsession.flush()
         transaction.commit()
 
             session=dbsession,
             config=self.app_config,
         )
-        main_folder_workspace2 = api.create(ContentType.Folder, workspace2, None, 'Hepla', '', True)  # nopep8
-        main_folder = api.create(ContentType.Folder, workspace, None, 'this is randomized folder', '', True)  # nopep8
+        main_folder_workspace2 = api.create(CONTENT_TYPES.Folder.slug, workspace2, None, 'Hepla', '', True)  # nopep8
+        main_folder = api.create(CONTENT_TYPES.Folder.slug, workspace, None, 'this is randomized folder', '', True)  # nopep8
         # creation order test
-        firstly_created = api.create(ContentType.Page, workspace, main_folder, 'creation_order_test', '', True)  # nopep8
-        secondly_created = api.create(ContentType.Page, workspace, main_folder, 'another creation_order_test', '', True)  # nopep8
+        firstly_created = api.create(CONTENT_TYPES.Page.slug, workspace, main_folder, 'creation_order_test', '', True)  # nopep8
+        secondly_created = api.create(CONTENT_TYPES.Page.slug, workspace, main_folder, 'another creation_order_test', '', True)  # nopep8
         # update order test
-        firstly_created_but_recently_updated = api.create(ContentType.Page, workspace, main_folder, 'update_order_test', '', True)  # nopep8
-        secondly_created_but_not_updated = api.create(ContentType.Page, workspace, main_folder, 'another update_order_test', '', True)  # nopep8
+        firstly_created_but_recently_updated = api.create(CONTENT_TYPES.Page.slug, workspace, main_folder, 'update_order_test', '', True)  # nopep8
+        secondly_created_but_not_updated = api.create(CONTENT_TYPES.Page.slug, workspace, main_folder, 'another update_order_test', '', True)  # nopep8
         with new_revision(
             session=dbsession,
             tm=transaction.manager,
             firstly_created_but_recently_updated.description = 'Just an update'
         api.save(firstly_created_but_recently_updated)
         # comment change order
-        firstly_created_but_recently_commented = api.create(ContentType.Page, workspace, main_folder, 'this is randomized label content', '', True)  # nopep8
-        secondly_created_but_not_commented = api.create(ContentType.Page, workspace, main_folder, 'this is another randomized label content', '', True)  # nopep8
+        firstly_created_but_recently_commented = api.create(CONTENT_TYPES.Page.slug, workspace, main_folder, 'this is randomized label content', '', True)  # nopep8
+        secondly_created_but_not_commented = api.create(CONTENT_TYPES.Page.slug, workspace, main_folder, 'this is another randomized label content', '', True)  # nopep8
         comments = api.create_comment(workspace, firstly_created_but_recently_commented, 'juste a super comment', True)  # nopep8
-        content_workspace_2 = api.create(ContentType.Page, workspace2,main_folder_workspace2, 'content_workspace_2', '',True)  # nopep8
+        content_workspace_2 = api.create(CONTENT_TYPES.Page.slug, workspace2,main_folder_workspace2, 'content_workspace_2', '',True)  # nopep8
         dbsession.flush()
         transaction.commit()
 
             session=dbsession,
             config=self.app_config,
         )
-        main_folder_workspace2 = api.create(ContentType.Folder, workspace2, None, 'Hepla', '', True)  # nopep8
-        main_folder = api.create(ContentType.Folder, workspace, None, 'this is randomized folder', '', True)  # nopep8
+        main_folder_workspace2 = api.create(CONTENT_TYPES.Folder.slug, workspace2, None, 'Hepla', '', True)  # nopep8
+        main_folder = api.create(CONTENT_TYPES.Folder.slug, workspace, None, 'this is randomized folder', '', True)  # nopep8
         # creation order test
-        firstly_created = api.create(ContentType.Page, workspace, main_folder, 'creation_order_test', '', True)  # nopep8
-        secondly_created = api.create(ContentType.Page, workspace, main_folder, 'another creation_order_test', '', True)  # nopep8
+        firstly_created = api.create(CONTENT_TYPES.Page.slug, workspace, main_folder, 'creation_order_test', '', True)  # nopep8
+        secondly_created = api.create(CONTENT_TYPES.Page.slug, workspace, main_folder, 'another creation_order_test', '', True)  # nopep8
         # update order test
-        firstly_created_but_recently_updated = api.create(ContentType.Page, workspace, main_folder, 'update_order_test', '', True)  # nopep8
-        secondly_created_but_not_updated = api.create(ContentType.Page, workspace, main_folder, 'another update_order_test', '', True)  # nopep8
+        firstly_created_but_recently_updated = api.create(CONTENT_TYPES.Page.slug, workspace, main_folder, 'update_order_test', '', True)  # nopep8
+        secondly_created_but_not_updated = api.create(CONTENT_TYPES.Page.slug, workspace, main_folder, 'another update_order_test', '', True)  # nopep8
         with new_revision(
             session=dbsession,
             tm=transaction.manager,
             firstly_created_but_recently_updated.description = 'Just an update'
         api.save(firstly_created_but_recently_updated)
         # comment change order
-        firstly_created_but_recently_commented = api.create(ContentType.Page, workspace, main_folder, 'this is randomized label content', '', True)  # nopep8
-        secondly_created_but_not_commented = api.create(ContentType.Page, workspace, main_folder, 'this is another randomized label content', '', True)  # nopep8
+        firstly_created_but_recently_commented = api.create(CONTENT_TYPES.Page.slug, workspace, main_folder, 'this is randomized label content', '', True)  # nopep8
+        secondly_created_but_not_commented = api.create(CONTENT_TYPES.Page.slug, workspace, main_folder, 'this is another randomized label content', '', True)  # nopep8
         comments = api.create_comment(workspace, firstly_created_but_recently_commented, 'juste a super comment', True)  # nopep8
-        content_workspace_2 = api.create(ContentType.Page, workspace2,main_folder_workspace2, 'content_workspace_2', '',True)  # nopep8
+        content_workspace_2 = api.create(CONTENT_TYPES.Page.slug, workspace2,main_folder_workspace2, 'content_workspace_2', '',True)  # nopep8
         dbsession.flush()
         transaction.commit()
 
             session=dbsession,
             config=self.app_config,
         )
-        main_folder_workspace2 = api.create(ContentType.Folder, workspace2, None, 'Hepla', '', True)  # nopep8
-        main_folder = api.create(ContentType.Folder, workspace, None, 'this is randomized folder', '', True)  # nopep8
+        main_folder_workspace2 = api.create(CONTENT_TYPES.Folder.slug, workspace2, None, 'Hepla', '', True)  # nopep8
+        main_folder = api.create(CONTENT_TYPES.Folder.slug, workspace, None, 'this is randomized folder', '', True)  # nopep8
         # creation order test
-        firstly_created = api.create(ContentType.Page, workspace, main_folder, 'creation_order_test', '', True)  # nopep8
-        secondly_created = api.create(ContentType.Page, workspace, main_folder, 'another creation_order_test', '', True)  # nopep8
+        firstly_created = api.create(CONTENT_TYPES.Page.slug, workspace, main_folder, 'creation_order_test', '', True)  # nopep8
+        secondly_created = api.create(CONTENT_TYPES.Page.slug, workspace, main_folder, 'another creation_order_test', '', True)  # nopep8
         # update order test
-        firstly_created_but_recently_updated = api.create(ContentType.Page, workspace, main_folder, 'update_order_test', '', True)  # nopep8
-        secondly_created_but_not_updated = api.create(ContentType.Page, workspace, main_folder, 'another update_order_test', '', True)  # nopep8
+        firstly_created_but_recently_updated = api.create(CONTENT_TYPES.Page.slug, workspace, main_folder, 'update_order_test', '', True)  # nopep8
+        secondly_created_but_not_updated = api.create(CONTENT_TYPES.Page.slug, workspace, main_folder, 'another update_order_test', '', True)  # nopep8
         with new_revision(
             session=dbsession,
             tm=transaction.manager,
             firstly_created_but_recently_updated.description = 'Just an update'
         api.save(firstly_created_but_recently_updated)
         # comment change order
-        firstly_created_but_recently_commented = api.create(ContentType.Page, workspace, main_folder, 'this is randomized label content', '', True)  # nopep8
-        secondly_created_but_not_commented = api.create(ContentType.Page, workspace, main_folder, 'this is another randomized label content', '', True)  # nopep8
+        firstly_created_but_recently_commented = api.create(CONTENT_TYPES.Page.slug, workspace, main_folder, 'this is randomized label content', '', True)  # nopep8
+        secondly_created_but_not_commented = api.create(CONTENT_TYPES.Page.slug, workspace, main_folder, 'this is another randomized label content', '', True)  # nopep8
         comments = api.create_comment(workspace, firstly_created_but_recently_commented, 'juste a super comment', True)  # nopep8
-        content_workspace_2 = api.create(ContentType.Page, workspace2,main_folder_workspace2, 'content_workspace_2', '',True)  # nopep8
+        content_workspace_2 = api.create(CONTENT_TYPES.Page.slug, workspace2,main_folder_workspace2, 'content_workspace_2', '',True)  # nopep8
         dbsession.flush()
         transaction.commit()
 
             session=dbsession,
             config=self.app_config,
         )
-        main_folder_workspace2 = api.create(ContentType.Folder, workspace2, None, 'Hepla', '', True)  # nopep8
-        main_folder = api.create(ContentType.Folder, workspace, None, 'this is randomized folder', '', True)  # nopep8
+        main_folder_workspace2 = api.create(CONTENT_TYPES.Folder.slug, workspace2, None, 'Hepla', '', True)  # nopep8
+        main_folder = api.create(CONTENT_TYPES.Folder.slug, workspace, None, 'this is randomized folder', '', True)  # nopep8
         # creation order test
-        firstly_created = api.create(ContentType.Page, workspace, main_folder, 'creation_order_test', '', True)  # nopep8
-        secondly_created = api.create(ContentType.Page, workspace, main_folder, 'another creation_order_test', '', True)  # nopep8
+        firstly_created = api.create(CONTENT_TYPES.Page.slug, workspace, main_folder, 'creation_order_test', '', True)  # nopep8
+        secondly_created = api.create(CONTENT_TYPES.Page.slug, workspace, main_folder, 'another creation_order_test', '', True)  # nopep8
         # update order test
-        firstly_created_but_recently_updated = api.create(ContentType.Page, workspace, main_folder, 'update_order_test', '', True)  # nopep8
-        secondly_created_but_not_updated = api.create(ContentType.Page, workspace, main_folder, 'another update_order_test', '', True)  # nopep8
+        firstly_created_but_recently_updated = api.create(CONTENT_TYPES.Page.slug, workspace, main_folder, 'update_order_test', '', True)  # nopep8
+        secondly_created_but_not_updated = api.create(CONTENT_TYPES.Page.slug, workspace, main_folder, 'another update_order_test', '', True)  # nopep8
         with new_revision(
             session=dbsession,
             tm=transaction.manager,
             firstly_created_but_recently_updated.description = 'Just an update'
         api.save(firstly_created_but_recently_updated)
         # comment change order
-        firstly_created_but_recently_commented = api.create(ContentType.Page, workspace, main_folder, 'this is randomized label content', '', True)  # nopep8
-        secondly_created_but_not_commented = api.create(ContentType.Page, workspace, main_folder, 'this is another randomized label content', '', True)  # nopep8
+        firstly_created_but_recently_commented = api.create(CONTENT_TYPES.Page.slug, workspace, main_folder, 'this is randomized label content', '', True)  # nopep8
+        secondly_created_but_not_commented = api.create(CONTENT_TYPES.Page.slug, workspace, main_folder, 'this is another randomized label content', '', True)  # nopep8
         comments = api.create_comment(workspace, firstly_created_but_recently_commented, 'juste a super comment', True)  # nopep8
-        content_workspace_2 = api.create(ContentType.Page, workspace2,main_folder_workspace2, 'content_workspace_2', '',True)  # nopep8
+        content_workspace_2 = api.create(CONTENT_TYPES.Page.slug, workspace2,main_folder_workspace2, 'content_workspace_2', '',True)  # nopep8
         dbsession.flush()
         transaction.commit()
 
             session=dbsession,
             config=self.app_config,
         )
-        main_folder = api.create(ContentType.Folder, workspace, None, 'this is randomized folder', '', True)  # nopep8
+        main_folder = api.create(CONTENT_TYPES.Folder.slug, workspace, None, 'this is randomized folder', '', True)  # nopep8
         # creation order test
-        firstly_created = api.create(ContentType.Page, workspace, main_folder, 'creation_order_test', '', True)  # nopep8
+        firstly_created = api.create(CONTENT_TYPES.Page.slug, workspace, main_folder, 'creation_order_test', '', True)  # nopep8
         api.mark_unread(firstly_created)
         api2.mark_unread(firstly_created)
         dbsession.flush()
             session=dbsession,
             config=self.app_config,
         )
-        main_folder = api.create(ContentType.Folder, workspace, None, 'this is randomized folder', '', True)  # nopep8
+        main_folder = api.create(CONTENT_TYPES.Folder.slug, workspace, None, 'this is randomized folder', '', True)  # nopep8
         # creation order test
-        firstly_created = api.create(ContentType.Page, workspace, main_folder, 'creation_order_test', '', True)  # nopep8
+        firstly_created = api.create(CONTENT_TYPES.Page.slug, workspace, main_folder, 'creation_order_test', '', True)  # nopep8
         api.mark_unread(firstly_created)
         api2.mark_unread(firstly_created)
         dbsession.flush()
             session=dbsession,
             config=self.app_config,
         )
-        main_folder = api.create(ContentType.Folder, workspace, None, 'this is randomized folder', '', True)  # nopep8
+        main_folder = api.create(CONTENT_TYPES.Folder.slug, workspace, None, 'this is randomized folder', '', True)  # nopep8
         # creation order test
-        firstly_created = api.create(ContentType.Page, workspace, main_folder, 'creation_order_test', '', True)  # nopep8
+        firstly_created = api.create(CONTENT_TYPES.Page.slug, workspace, main_folder, 'creation_order_test', '', True)  # nopep8
         api.mark_unread(firstly_created)
         api2.mark_unread(firstly_created)
         dbsession.flush()
             session=dbsession,
             config=self.app_config,
         )
-        main_folder = api.create(ContentType.Folder, workspace, None, 'this is randomized folder', '', True)  # nopep8
+        main_folder = api.create(CONTENT_TYPES.Folder.slug, workspace, None, 'this is randomized folder', '', True)  # nopep8
         # creation order test
-        firstly_created = api.create(ContentType.Page, workspace, main_folder, 'creation_order_test', '', True)  # nopep8
+        firstly_created = api.create(CONTENT_TYPES.Page.slug, workspace, main_folder, 'creation_order_test', '', True)  # nopep8
         api.mark_unread(firstly_created)
         api2.mark_unread(firstly_created)
         dbsession.flush()
             session=dbsession,
             config=self.app_config,
         )
-        main_folder = api.create(ContentType.Folder, workspace, None, 'this is randomized folder', '', True)  # nopep8
+        main_folder = api.create(CONTENT_TYPES.Folder.slug, workspace, None, 'this is randomized folder', '', True)  # nopep8
         # creation order test
-        firstly_created = api.create(ContentType.Page, workspace, main_folder, 'creation_order_test', '', True)  # nopep8
+        firstly_created = api.create(CONTENT_TYPES.Page.slug, workspace, main_folder, 'creation_order_test', '', True)  # nopep8
         api.mark_unread(firstly_created)
         api2.mark_unread(firstly_created)
         dbsession.flush()
             session=dbsession,
             config=self.app_config,
         )
-        main_folder = api.create(ContentType.Folder, workspace, None, 'this is randomized folder', '', True)  # nopep8
+        main_folder = api.create(CONTENT_TYPES.Folder.slug, workspace, None, 'this is randomized folder', '', True)  # nopep8
         # creation order test
-        firstly_created = api.create(ContentType.Page, workspace, main_folder, 'creation_order_test', '', True)  # nopep8
+        firstly_created = api.create(CONTENT_TYPES.Page.slug, workspace, main_folder, 'creation_order_test', '', True)  # nopep8
         comments = api.create_comment(workspace, firstly_created, 'juste a super comment', True)  # nopep8
         api.mark_unread(firstly_created)
         api.mark_unread(comments)
             session=dbsession,
             config=self.app_config,
         )
-        main_folder = api.create(ContentType.Folder, workspace, None, 'this is randomized folder', '', True)  # nopep8
+        main_folder = api.create(CONTENT_TYPES.Folder.slug, workspace, None, 'this is randomized folder', '', True)  # nopep8
         # creation order test
-        firstly_created = api.create(ContentType.Page, workspace, main_folder, 'creation_order_test', '', True)  # nopep8
+        firstly_created = api.create(CONTENT_TYPES.Page.slug, workspace, main_folder, 'creation_order_test', '', True)  # nopep8
         api.mark_read(firstly_created)
         api2.mark_read(firstly_created)
         dbsession.flush()
             session=dbsession,
             config=self.app_config,
         )
-        main_folder = api.create(ContentType.Folder, workspace, None, 'this is randomized folder', '', True)  # nopep8
+        main_folder = api.create(CONTENT_TYPES.Folder.slug, workspace, None, 'this is randomized folder', '', True)  # nopep8
         # creation order test
-        firstly_created = api.create(ContentType.Page, workspace, main_folder, 'creation_order_test', '', True)  # nopep8
+        firstly_created = api.create(CONTENT_TYPES.Page.slug, workspace, main_folder, 'creation_order_test', '', True)  # nopep8
         api.mark_read(firstly_created)
         api2.mark_read(firstly_created)
         dbsession.flush()
             session=dbsession,
             config=self.app_config,
         )
-        main_folder = api.create(ContentType.Folder, workspace, None, 'this is randomized folder', '', True)  # nopep8
+        main_folder = api.create(CONTENT_TYPES.Folder.slug, workspace, None, 'this is randomized folder', '', True)  # nopep8
         # creation order test
-        firstly_created = api.create(ContentType.Page, workspace, main_folder, 'creation_order_test', '', True)  # nopep8
+        firstly_created = api.create(CONTENT_TYPES.Page.slug, workspace, main_folder, 'creation_order_test', '', True)  # nopep8
         api.mark_read(firstly_created)
         api2.mark_read(firstly_created)
         dbsession.flush()
             session=dbsession,
             config=self.app_config,
         )
-        main_folder = api.create(ContentType.Folder, workspace, None, 'this is randomized folder', '', True)  # nopep8
+        main_folder = api.create(CONTENT_TYPES.Folder.slug, workspace, None, 'this is randomized folder', '', True)  # nopep8
         # creation order test
-        firstly_created = api.create(ContentType.Page, workspace, main_folder, 'creation_order_test', '', True)  # nopep8
+        firstly_created = api.create(CONTENT_TYPES.Page.slug, workspace, main_folder, 'creation_order_test', '', True)  # nopep8
         api.mark_read(firstly_created)
         api2.mark_read(firstly_created)
         dbsession.flush()
             session=dbsession,
             config=self.app_config,
         )
-        main_folder = api.create(ContentType.Folder, workspace, None, 'this is randomized folder', '', True)  # nopep8
+        main_folder = api.create(CONTENT_TYPES.Folder.slug, workspace, None, 'this is randomized folder', '', True)  # nopep8
         # creation order test
-        firstly_created = api.create(ContentType.Page, workspace, main_folder, 'creation_order_test', '', True)  # nopep8
+        firstly_created = api.create(CONTENT_TYPES.Page.slug, workspace, main_folder, 'creation_order_test', '', True)  # nopep8
         api.mark_read(firstly_created)
         api2.mark_read(firstly_created)
         dbsession.flush()
             session=dbsession,
             config=self.app_config,
         )
-        main_folder = api.create(ContentType.Folder, workspace, None, 'this is randomized folder', '', True)  # nopep8
+        main_folder = api.create(CONTENT_TYPES.Folder.slug, workspace, None, 'this is randomized folder', '', True)  # nopep8
         # creation order test
-        firstly_created = api.create(ContentType.Page, workspace, main_folder, 'creation_order_test', '', True)  # nopep8
+        firstly_created = api.create(CONTENT_TYPES.Page.slug, workspace, main_folder, 'creation_order_test', '', True)  # nopep8
         comments = api.create_comment(workspace, firstly_created, 'juste a super comment', True)  # nopep8
         api.mark_read(firstly_created)
         api.mark_read(comments)
             session=dbsession,
             config=self.app_config,
         )
-        main_folder = api.create(ContentType.Folder, workspace, None, 'this is randomized folder', '', True)  # nopep8
+        main_folder = api.create(CONTENT_TYPES.Folder.slug, workspace, None, 'this is randomized folder', '', True)  # nopep8
         # creation order test
-        firstly_created = api.create(ContentType.Page, workspace, main_folder, 'creation_order_test', '', True)  # nopep8
+        firstly_created = api.create(CONTENT_TYPES.Page.slug, workspace, main_folder, 'creation_order_test', '', True)  # nopep8
         api.mark_unread(main_folder)
         api.mark_unread(firstly_created)
         api2.mark_unread(main_folder)
             session=dbsession,
             config=self.app_config,
         )
-        main_folder = api.create(ContentType.Folder, workspace, None, 'this is randomized folder', '', True)  # nopep8
+        main_folder = api.create(CONTENT_TYPES.Folder.slug, workspace, None, 'this is randomized folder', '', True)  # nopep8
         # creation order test
-        firstly_created = api.create(ContentType.Page, workspace, main_folder, 'creation_order_test', '', True)  # nopep8
+        firstly_created = api.create(CONTENT_TYPES.Page.slug, workspace, main_folder, 'creation_order_test', '', True)  # nopep8
         api.mark_unread(main_folder)
         api.mark_unread(firstly_created)
         api2.mark_unread(main_folder)
             session=dbsession,
             config=self.app_config,
         )
-        main_folder = api.create(ContentType.Folder, workspace, None, 'this is randomized folder', '', True)  # nopep8
+        main_folder = api.create(CONTENT_TYPES.Folder.slug, workspace, None, 'this is randomized folder', '', True)  # nopep8
         # creation order test
-        firstly_created = api.create(ContentType.Page, workspace, main_folder, 'creation_order_test', '', True)  # nopep8
+        firstly_created = api.create(CONTENT_TYPES.Page.slug, workspace, main_folder, 'creation_order_test', '', True)  # nopep8
         api.mark_unread(main_folder)
         api.mark_unread(firstly_created)
         api2.mark_unread(main_folder)

backend/tracim_backend/tests/functional/test_workspaces.py

 from tracim_backend.lib.core.content import ContentApi
 from tracim_backend.lib.core.workspace import WorkspaceApi
 from tracim_backend.models import get_tm_session
-from tracim_backend.models.data import ContentType
+from tracim_backend.models.contents import CONTENT_TYPES
 from tracim_backend.tests import FunctionalTest
 from tracim_backend.tests import set_html_document_slug_to_legacy
 from tracim_backend.fixtures.content import Content as ContentFixtures
             session=dbsession,
             config=self.app_config
         )
-        tool_folder = content_api.get_one(1, content_type=ContentType.Any)
+        tool_folder = content_api.get_one(1, content_type=CONTENT_TYPES.Any_SLUG)
         test_thread = content_api.create(
-            content_type=ContentType.Thread,
+            content_type_slug=CONTENT_TYPES.Thread.slug,
             workspace=business_workspace,
             parent=tool_folder,
             label='Test Thread',
         test_thread.description = 'Thread description'
         dbsession.add(test_thread)
         test_file = content_api.create(
-            content_type=ContentType.File,
+            content_type_slug=CONTENT_TYPES.File.slug,
             workspace=business_workspace,
             parent=tool_folder,
             label='Test file',
             'text/plain',
         )
         test_page_legacy = content_api.create(
-            content_type=ContentType.Page,
+            content_type_slug=CONTENT_TYPES.Page.slug,
             workspace=business_workspace,
             label='test_page',
             do_save=False,
             do_notify=False,
         )
-        test_page_legacy.type = ContentType.PageLegacy
+        test_page_legacy.type = 'page'
         content_api.update_content(test_page_legacy, 'test_page', '<p>PAGE</p>')
         test_html_document = content_api.create(
-            content_type=ContentType.Page,
+            content_type_slug=CONTENT_TYPES.Page.slug,
             workspace=business_workspace,
             label='test_html_page',
             do_save=False,
             session=dbsession,
             config=self.app_config
         )
-        tool_folder = content_api.get_one(1, content_type=ContentType.Any)
+        tool_folder = content_api.get_one(1, content_type=CONTENT_TYPES.Any_SLUG)
         test_thread = content_api.create(
-            content_type=ContentType.Thread,
+            content_type_slug=CONTENT_TYPES.Thread.slug,
             workspace=business_workspace,
             parent=tool_folder,
             label='Test Thread',
         test_thread.description = 'Thread description'
         dbsession.add(test_thread)
         test_file = content_api.create(
-            content_type=ContentType.File,
+            content_type_slug=CONTENT_TYPES.File.slug,
             workspace=business_workspace,
             parent=tool_folder,
             label='Test file',
             'text/plain',
         )
         test_page_legacy = content_api.create(
-            content_type=ContentType.Page,
+            content_type_slug=CONTENT_TYPES.Page.slug,
             workspace=business_workspace,
             parent=tool_folder,
             label='test_page',
             do_save=False,
             do_notify=False,
         )
-        test_page_legacy.type = ContentType.PageLegacy
+        test_page_legacy.type = 'page'
         content_api.update_content(test_page_legacy, 'test_page', '<p>PAGE</p>')
         test_html_document = content_api.create(
-            content_type=ContentType.Page,
+            content_type_slug=CONTENT_TYPES.Page.slug,
             workspace=business_workspace,
             parent=tool_folder,
             label='test_html_page',
             'show_archived': 1,
             'show_deleted': 1,
             'show_active': 1,
-            'content_type': 'any'
+         #   'content_type': 'any'
         }
         self.testapp.authorization = (
             'Basic',

backend/tracim_backend/tests/library/test_content_api.py

 from tracim_backend.lib.core.workspace import RoleApi
 # TODO - G.M - 28-03-2018 - [WorkspaceApi] Re-enable WorkspaceApi
 from tracim_backend.lib.core.workspace import WorkspaceApi
+from tracim_backend.models.contents import CONTENT_TYPES
 from tracim_backend.models.revision_protection import new_revision
 from tracim_backend.models.auth import User
 from tracim_backend.models.auth import Group
 from tracim_backend.models.data import ContentRevisionRO
 from tracim_backend.models.data import Workspace
 from tracim_backend.models.data import Content
-from tracim_backend.models.data import ContentType
 from tracim_backend.models.data import UserRoleInWorkspace
 from tracim_backend.fixtures.users_and_groups import Test as FixtureTest
 from tracim_backend.tests import DefaultTest
             config=self.app_config,
         )
         item = api.create(
-            content_type=ContentType.Folder,
+            content_type_slug=CONTENT_TYPES.Folder.slug,
             workspace=workspace,
             parent=None,
             label='not_deleted',
             do_save=True
         )
         item2 = api.create(
-            content_type=ContentType.Folder,
+            content_type_slug=CONTENT_TYPES.Folder.slug,
             workspace=workspace,
             parent=None,
             label='to_delete',
             session=self.session,
             config=self.app_config,
         )
-        items = api.get_all(None, ContentType.Any, workspace)
+        items = api.get_all(None, CONTENT_TYPES.Any_SLUG, workspace)
         eq_(2, len(items))
 
-        items = api.get_all(None, ContentType.Any, workspace)
+        items = api.get_all(None, CONTENT_TYPES.Any_SLUG, workspace)
         with new_revision(
                 session=self.session,
                 tm=transaction.manager,
             session=self.session,
             config=self.app_config,
         )
-        items = api.get_all(None, ContentType.Any, workspace)
+        items = api.get_all(None, CONTENT_TYPES.Any_SLUG, workspace)
         eq_(1, len(items))
         transaction.commit()
 
             config=self.app_config,
             show_deleted=True,
         )
-        items = api.get_all(None, ContentType.Any, workspace)
+        items = api.get_all(None, CONTENT_TYPES.Any_SLUG, workspace)
         eq_(2, len(items))
 
     def test_archive(self):
             config=self.app_config,
         )
         item = api.create(
-            content_type=ContentType.Folder,
+            content_type_slug=CONTENT_TYPES.Folder.slug,
             workspace=workspace,
             parent=None,
             label='not_archived',
             do_save=True
         )
         item2 = api.create(
-            content_type=ContentType.Folder,
+            content_type_slug=CONTENT_TYPES.Folder.slug,
             workspace=workspace,
             parent=None,
             label='to_archive',
             config=self.app_config,
         )
 
-        items = api.get_all(None, ContentType.Any, workspace)
+        items = api.get_all(None, CONTENT_TYPES.Any_SLUG, workspace)
         eq_(2, len(items))
 
-        items = api.get_all(None, ContentType.Any, workspace)
+        items = api.get_all(None, CONTENT_TYPES.Any_SLUG, workspace)
         with new_revision(
                 session=self.session,
                 tm=transaction.manager,
             config=self.app_config,
         )
 
-        items = api.get_all(None, ContentType.Any, workspace)
+        items = api.get_all(None, CONTENT_TYPES.Any_SLUG, workspace)
         eq_(1, len(items))
         transaction.commit()
 
             config=self.app_config,
             show_archived=True,
         )
-        items = api.get_all(None, ContentType.Any, workspace)
+        items = api.get_all(None, CONTENT_TYPES.Any_SLUG, workspace)
         eq_(2, len(items))
 
     def test_get_all_with_filter(self):
             config=self.app_config,
         )
         item = api.create(
-            content_type=ContentType.Folder,
+            content_type_slug=CONTENT_TYPES.Folder.slug,
             workspace=workspace,
             parent=None,
             label='thefolder',
             do_save=True
         )
         item2 = api.create(
-            content_type=ContentType.File,
+            content_type_slug=CONTENT_TYPES.File.slug,
             workspace=workspace,
             parent=None,
             label='thefile',
             config=self.app_config,
         )
 
-        items = api.get_all(None, ContentType.Any, workspace)
+        items = api.get_all(None, CONTENT_TYPES.Any_SLUG, workspace)
         eq_(2, len(items))
 
-        items2 = api.get_all(None, ContentType.File, workspace)
+        items2 = api.get_all(None, CONTENT_TYPES.File.slug, workspace)
         eq_(1, len(items2))
         eq_('thefile', items2[0].label)
 
-        items3 = api.get_all(None, ContentType.Folder, workspace)
+        items3 = api.get_all(None, CONTENT_TYPES.Folder.slug, workspace)
         eq_(1, len(items3))
         eq_('thefolder', items3[0].label)
 
             config=self.app_config,
         )
         item = api.create(
-            ContentType.Folder,
+            CONTENT_TYPES.Folder.slug,
             workspace,
             None,
             'parent',
             do_save=True,
         )
         item2 = api.create(
-            ContentType.File,
+            CONTENT_TYPES.File.slug,
             workspace,
             item,
             'file1',
             do_save=True,
         )
         item3 = api.create(
-            ContentType.File,
+            CONTENT_TYPES.File.slug,
             workspace,
             None,
             'file2',
             config=self.app_config,
         )
 
-        items = api.get_all(None, ContentType.Any, workspace)
+        items = api.get_all(None, CONTENT_TYPES.Any_SLUG, workspace)
         eq_(3, len(items))
 
-        items2 = api.get_all(parent_id, ContentType.File, workspace)
+        items2 = api.get_all(parent_id, CONTENT_TYPES.File.slug, workspace)
         eq_(1, len(items2))
         eq_(child_id, items2[0].content_id)
 
             session=self.session,
             config=self.app_config,
         )
-        c = api.create(ContentType.Folder, workspace, None, 'parent', '', True)
+        c = api.create(CONTENT_TYPES.Folder.slug, workspace, None, 'parent', '', True)
         with new_revision(
             session=self.session,
             tm=transaction.manager,
             session=self.session,
             config=self.app_config,
         )
-        c = api.create(ContentType.Folder, workspace, None, 'parent', '', True)
+        c = api.create(CONTENT_TYPES.Folder.slug, workspace, None, 'parent', '', True)
         with new_revision(
             session=self.session,
             tm=transaction.manager,
             session=self.session,
             config=self.app_config,
         )
-        p = api.create(ContentType.Page, workspace, None, 'this_is_a_page')
+        p = api.create(CONTENT_TYPES.Page.slug, workspace, None, 'this_is_a_page')
         c = api.create_comment(workspace, p, 'this is the comment', True)
 
         eq_(Content, c.__class__)
         eq_(p.content_id, c.parent_id)
         eq_(user, c.owner)
         eq_(workspace, c.workspace)
-        eq_(ContentType.Comment, c.type)
+        eq_(CONTENT_TYPES.Comment.slug, c.type)
         eq_('this is the comment', c.description)
         eq_('', c.label)
         eq_(ActionDescription.COMMENT, c.revision_type)
             config=self.app_config,
         )
         foldera = api.create(
-            ContentType.Folder,
+            CONTENT_TYPES.Folder.slug,
             workspace,
             None,
             'folder a',
         )
         with self.session.no_autoflush:
             text_file = api.create(
-                content_type=ContentType.File,
+                content_type_slug=CONTENT_TYPES.File.slug,
                 workspace=workspace,
                 parent=foldera,
                 label='test_file',
             save_now=True
         )
         folderb = api2.create(
-            ContentType.Folder,
+            CONTENT_TYPES.Folder.slug,
             workspace2,
             None,
             'folder b',
             config=self.app_config,
         )
         foldera = api.create(
-            ContentType.Folder,
+            CONTENT_TYPES.Folder.slug,
             workspace,
             None,
             'folder a',
         )
         with self.session.no_autoflush:
             text_file = api.create(
-                content_type=ContentType.File,
+                content_type_slug=CONTENT_TYPES.File.slug,
                 workspace=workspace,
                 parent=foldera,
                 label='test_file',
             save_now=True
         )
         folderb = api2.create(
-            ContentType.Folder,
+            CONTENT_TYPES.Folder.slug,
             workspace2,
             None,
             'folder b',
             config=self.app_config,
         )
         foldera = api.create(
-            ContentType.Folder,
+            CONTENT_TYPES.Folder.slug,
             workspace,
             None,
             'folder a',
         )
         with self.session.no_autoflush:
             text_file = api.create(
-                content_type=ContentType.File,
+                content_type_slug=CONTENT_TYPES.File.slug,
                 workspace=workspace,
                 parent=foldera,
                 label='test_file',
 
         # Creates page_1 & page_2 in workspace 1
         #     and page_3 & page_4 in workspace 2
-        page_1 = cont_api_a.create(ContentType.Page, workspace1, None,
+        page_1 = cont_api_a.create(CONTENT_TYPES.Page.slug, workspace1, None,
                                    'this is a page', do_save=True)
-        page_2 = cont_api_a.create(ContentType.Page, workspace1, None,
+        page_2 = cont_api_a.create(CONTENT_TYPES.Page.slug, workspace1, None,
                                    'this is page1', do_save=True)
-        page_3 = cont_api_a.create(ContentType.Thread, workspace2, None,
+        page_3 = cont_api_a.create(CONTENT_TYPES.Thread.slug, workspace2, None,
                                    'this is page2', do_save=True)
-        page_4 = cont_api_a.create(ContentType.File, workspace2, None,
+        page_4 = cont_api_a.create(CONTENT_TYPES.File.slug, workspace2, None,
                                    'this is page3', do_save=True)
 
         for rev in page_1.revisions:
             config=self.app_config,
         )
 
-        page_1 = cont_api_a.create(ContentType.Page, workspace, None,
+        page_1 = cont_api_a.create(CONTENT_TYPES.Page.slug, workspace, None,
                                    'this is a page', do_save=True)
 
         for rev in page_1.revisions:
         )
 
         page_2 = cont_api_a.create(
-            ContentType.Page,
+            CONTENT_TYPES.Page.slug,
             workspace,
             None,
             'this is page1',
             do_save=True
         )
         page_3 = cont_api_a.create(
-            ContentType.Thread,
+            CONTENT_TYPES.Thread.slug,
             workspace,
             None,
             'this is page2',
             do_save=True
         )
         page_4 = cont_api_a.create(
-            ContentType.File,
+            CONTENT_TYPES.File.slug,
             workspace,
             None,
             'this is page3',
         )
 
         p = api.create(
-            content_type=ContentType.Page,
+            content_type_slug=CONTENT_TYPES.Page.slug,
             workspace=workspace,
             parent=None,
             label='this_is_a_page',
             config=self.app_config,
         )
 
-        content = api.get_one(pcid, ContentType.Any, workspace)
+        content = api.get_one(pcid, CONTENT_TYPES.Any_SLUG, workspace)
         eq_(u1id, content.owner_id)
         eq_(poid, content.owner_id)
 
             session=self.session,
             config=self.app_config,
         )
-        content2 = api2.get_one(pcid, ContentType.Any, workspace)
+        content2 = api2.get_one(pcid, CONTENT_TYPES.Any_SLUG, workspace)
         with new_revision(
            session=self.session,
            tm=transaction.manager,
             config=self.app_config,
         )
 
-        updated = api.get_one(pcid, ContentType.Any, workspace)
+        updated = api.get_one(pcid, CONTENT_TYPES.Any_SLUG, workspace)
         eq_(u2id, updated.owner_id,
             'the owner id should be {} (found {})'.format(u2id,
                                                           updated.owner_id))
         )
         with self.session.no_autoflush:
             page = api.create(
-                content_type=ContentType.Page,
+                content_type_slug=CONTENT_TYPES.Page.slug,
                 workspace=workspace,
                 label="same_content",
                 do_save=False
             session=self.session,
             config=self.app_config,
         )
-        content2 = api2.get_one(page.content_id, ContentType.Any, workspace)
+        content2 = api2.get_one(page.content_id, CONTENT_TYPES.Any_SLUG, workspace)
         with new_revision(
            session=self.session,
            tm=transaction.manager,
             config=self.app_config,
         )
         p = api.create(
-            content_type=ContentType.File,
+            content_type_slug=CONTENT_TYPES.File.slug,
             workspace=workspace,
             parent=None,
             label='this_is_a_page',
             config=self.app_config,
         )
 
-        content = api.get_one(pcid, ContentType.Any, workspace)
+        content = api.get_one(pcid, CONTENT_TYPES.Any_SLUG, workspace)
         eq_(u1id, content.owner_id)
         eq_(poid, content.owner_id)
 
             session=self.session,
             config=self.app_config,
         )
-        content2 = api2.get_one(pcid, ContentType.Any, workspace)
+        content2 = api2.get_one(pcid, CONTENT_TYPES.Any_SLUG, workspace)
         with new_revision(
             session=self.session,
             tm=transaction.manager,
             config=self.app_config,
         ).get_one(wid)
 
-        updated = api.get_one(pcid, ContentType.Any, workspace)
+        updated = api.get_one(pcid, CONTENT_TYPES.Any_SLUG, workspace)
         eq_(u2id, updated.owner_id,
             'the owner id should be {} (found {})'.format(u2id,
                                                           updated.owner_id))
         )
         with self.session.no_autoflush:
             page = api.create(
-                content_type=ContentType.Page,
+                content_type_slug=CONTENT_TYPES.Page.slug,
                 workspace=workspace,
                 label="same_content",
                 do_save=False
             session=self.session,
             config=self.app_config,
         )
-        content2 = api2.get_one(page.content_id, ContentType.Any, workspace)
+        content2 = api2.get_one(page.content_id, CONTENT_TYPES.Any_SLUG, workspace)
         with new_revision(
             session=self.session,
             tm=transaction.manager,
             config=self.app_config,
         )
         p = api.create(
-            content_type=ContentType.File,
+            content_type_slug=CONTENT_TYPES.File.slug,
             workspace=workspace,
             parent=None,
             label='this_is_a_page',
             config=self.app_config,
         ).get_one(wid)
 
-        content = api.get_one(pcid, ContentType.Any, workspace)
+        content = api.get_one(pcid, CONTENT_TYPES.Any_SLUG, workspace)
         eq_(u1id, content.owner_id)
         eq_(poid, content.owner_id)
 
             config=self.app_config,
             show_archived=True,
         )
-        content2 = api2.get_one(pcid, ContentType.Any, workspace)
+        content2 = api2.get_one(pcid, CONTENT_TYPES.Any_SLUG, workspace)
         with new_revision(
                 session=self.session,
                 tm=transaction.manager,
             show_archived=True,
         )
 
-        updated = api2.get_one(pcid, ContentType.Any, workspace)
+        updated = api2.get_one(pcid, CONTENT_TYPES.Any_SLUG, workspace)
         eq_(u2id, updated.owner_id,
             'the owner id should be {} (found {})'.format(u2id,
                                                           updated.owner_id))
 
         ####
 
-        updated2 = api.get_one(pcid, ContentType.Any, workspace)
+        updated2 = api.get_one(pcid, CONTENT_TYPES.Any_SLUG, workspace)
         with new_revision(
             session=self.session,
             tm=transaction.manager,
             show_deleted=True,
         )
         p = api.create(
-            content_type=ContentType.File,
+            content_type_slug=CONTENT_TYPES.File.slug,
             workspace=workspace,
             parent=None,
             label='this_is_a_page',
             config=self.app_config,
         ).get_one(wid)
 
-        content = api.get_one(pcid, ContentType.Any, workspace)
+        content = api.get_one(pcid, CONTENT_TYPES.Any_SLUG, workspace)
         eq_(u1id, content.owner_id)
         eq_(poid, content.owner_id)
 
             config=self.app_config,
             show_deleted=True,
         )
-        content2 = api2.get_one(pcid, ContentType.Any, workspace)
+        content2 = api2.get_one(pcid, CONTENT_TYPES.Any_SLUG, workspace)
         with new_revision(
                 session=self.session,
                 tm=transaction.manager,
             show_deleted=True
         )
 
-        updated = api2.get_one(pcid, ContentType.Any, workspace)
+        updated = api2.get_one(pcid, CONTENT_TYPES.Any_SLUG, workspace)
         eq_(u2id, updated.owner_id,
             'the owner id should be {} (found {})'.format(u2id,
                                                           updated.owner_id))
 
         ####
 
-        updated2 = api.get_one(pcid, ContentType.Any, workspace)
+        updated2 = api.get_one(pcid, CONTENT_TYPES.Any_SLUG, workspace)
         with new_revision(
             tm=transaction.manager,
             session=self.session,
             session=self.session,
             config=self.app_config,
         )
-        main_folder_workspace2 = api.create(ContentType.Folder, workspace2, None, 'Hepla', '', True)  # nopep8
-        main_folder = api.create(ContentType.Folder, workspace, None, 'this is randomized folder', '', True)  # nopep8
+        main_folder_workspace2 = api.create(CONTENT_TYPES.Folder.slug, workspace2, None, 'Hepla', '', True)  # nopep8
+        main_folder = api.create(CONTENT_TYPES.Folder.slug, workspace, None, 'this is randomized folder', '', True)  # nopep8
         # creation order test
-        firstly_created = api.create(ContentType.Page, workspace, main_folder, 'creation_order_test', '', True)  # nopep8
-        secondly_created = api.create(ContentType.Page, workspace, main_folder, 'another creation_order_test', '', True)  # nopep8
+        firstly_created = api.create(CONTENT_TYPES.Page.slug, workspace, main_folder, 'creation_order_test', '', True)  # nopep8
+        secondly_created = api.create(CONTENT_TYPES.Page.slug, workspace, main_folder, 'another creation_order_test', '', True)  # nopep8
         # update order test
-        firstly_created_but_recently_updated = api.create(ContentType.Page, workspace, main_folder, 'update_order_test', '', True)  # nopep8
-        secondly_created_but_not_updated = api.create(ContentType.Page, workspace, main_folder, 'another update_order_test', '', True)  # nopep8
+        firstly_created_but_recently_updated = api.create(CONTENT_TYPES.Page.slug, workspace, main_folder, 'update_order_test', '', True)  # nopep8
+        secondly_created_but_not_updated = api.create(CONTENT_TYPES.Page.slug, workspace, main_folder, 'another update_order_test', '', True)  # nopep8
         with new_revision(
             session=self.session,
             tm=transaction.manager,
             firstly_created_but_recently_updated.description = 'Just an update'
         api.save(firstly_created_but_recently_updated)
         # comment change order
-        firstly_created_but_recently_commented = api.create(ContentType.Page, workspace, main_folder, 'this is randomized label content', '', True)  # nopep8
-        secondly_created_but_not_commented = api.create(ContentType.Page, workspace, main_folder, 'this is another randomized label content', '', True)  # nopep8
+        firstly_created_but_recently_commented = api.create(CONTENT_TYPES.Page.slug, workspace, main_folder, 'this is randomized label content', '', True)  # nopep8
+        secondly_created_but_not_commented = api.create(CONTENT_TYPES.Page.slug, workspace, main_folder, 'this is another randomized label content', '', True)  # nopep8
         comments = api.create_comment(workspace, firstly_created_but_recently_commented, 'juste a super comment', True)  # nopep8
 
-        content_workspace_2 = api.create(ContentType.Page, workspace2 ,main_folder_workspace2, 'content_workspace_2', '',True)  # nopep8
+        content_workspace_2 = api.create(CONTENT_TYPES.Page.slug, workspace2 ,main_folder_workspace2, 'content_workspace_2', '',True)  # nopep8
         last_actives = api.get_last_active()
         assert len(last_actives) == 9
         # workspace_2 content
             session=self.session,
             config=self.app_config,
         )
-        main_folder = api.create(ContentType.Folder, workspace, None, 'this is randomized folder', '', True)  # nopep8
+        main_folder = api.create(CONTENT_TYPES.Folder.slug, workspace, None, 'this is randomized folder', '', True)  # nopep8
         # creation order test
-        firstly_created = api.create(ContentType.Page, workspace, main_folder, 'creation_order_test', '', True)  # nopep8
-        secondly_created = api.create(ContentType.Page, workspace, main_folder, 'another creation_order_test', '', True)  # nopep8
+        firstly_created = api.create(CONTENT_TYPES.Page.slug, workspace, main_folder, 'creation_order_test', '', True)  # nopep8
+        secondly_created = api.create(CONTENT_TYPES.Page.slug, workspace, main_folder, 'another creation_order_test', '', True)  # nopep8
         # update order test
-        firstly_created_but_recently_updated = api.create(ContentType.Page, workspace, main_folder, 'update_order_test', '', True)  # nopep8
-        secondly_created_but_not_updated = api.create(ContentType.Page, workspace, main_folder, 'another update_order_test', '', True)  # nopep8
+        firstly_created_but_recently_updated = api.create(CONTENT_TYPES.Page.slug, workspace, main_folder, 'update_order_test', '', True)  # nopep8
+        secondly_created_but_not_updated = api.create(CONTENT_TYPES.Page.slug, workspace, main_folder, 'another update_order_test', '', True)  # nopep8
         with new_revision(
             session=self.session,
             tm=transaction.manager,
             firstly_created_but_recently_updated.description = 'Just an update'
         api.save(firstly_created_but_recently_updated)
         # comment change order
-        firstly_created_but_recently_commented = api.create(ContentType.Page, workspace, main_folder, 'this is randomized label content', '', True)  # nopep8
-        secondly_created_but_not_commented = api.create(ContentType.Page, workspace, main_folder, 'this is another randomized label content', '', True)  # nopep8
+        firstly_created_but_recently_commented = api.create(CONTENT_TYPES.Page.slug, workspace, main_folder, 'this is randomized label content', '', True)  # nopep8
+        secondly_created_but_not_commented = api.create(CONTENT_TYPES.Page.slug, workspace, main_folder, 'this is another randomized label content', '', True)  # nopep8
         comments = api.create_comment(workspace, firstly_created_but_recently_commented, 'juste a super comment', True)  # nopep8
 
         last_actives = api.get_last_active(workspace=workspace)
             session=self.session,
             config=self.app_config,
         )
-        main_folder = api.create(ContentType.Folder, workspace, None, 'this is randomized folder', '', True)  # nopep8
+        main_folder = api.create(CONTENT_TYPES.Folder.slug, workspace, None, 'this is randomized folder', '', True)  # nopep8
         # creation order test
-        firstly_created = api.create(ContentType.Page, workspace, main_folder, 'creation_order_test', '', True)  # nopep8
-        secondly_created = api.create(ContentType.Page, workspace, main_folder, 'another creation_order_test', '', True)  # nopep8
+        firstly_created = api.create(CONTENT_TYPES.Page.slug, workspace, main_folder, 'creation_order_test', '', True)  # nopep8
+        secondly_created = api.create(CONTENT_TYPES.Page.slug, workspace, main_folder, 'another creation_order_test', '', True)  # nopep8
         # update order test
-        firstly_created_but_recently_updated = api.create(ContentType.Page, workspace, main_folder, 'update_order_test', '', True)  # nopep8
-        secondly_created_but_not_updated = api.create(ContentType.Page, workspace, main_folder, 'another update_order_test', '', True)  # nopep8
+        firstly_created_but_recently_updated = api.create(CONTENT_TYPES.Page.slug, workspace, main_folder, 'update_order_test', '', True)  # nopep8
+        secondly_created_but_not_updated = api.create(CONTENT_TYPES.Page.slug, workspace, main_folder, 'another update_order_test', '', True)  # nopep8
         with new_revision(
             session=self.session,
             tm=transaction.manager,
             firstly_created_but_recently_updated.description = 'Just an update'
         api.save(firstly_created_but_recently_updated)
         # comment change order
-        firstly_created_but_recently_commented = api.create(ContentType.Page, workspace, main_folder, 'this is randomized label content', '', True)  # nopep8
-        secondly_created_but_not_commented = api.create(ContentType.Page, workspace, main_folder, 'this is another randomized label content', '', True)  # nopep8
+        firstly_created_but_recently_commented = api.create(CONTENT_TYPES.Page.slug, workspace, main_folder, 'this is randomized label content', '', True)  # nopep8
+        secondly_created_but_not_commented = api.create(CONTENT_TYPES.Page.slug, workspace, main_folder, 'this is another randomized label content', '', True)  # nopep8
         comments = api.create_comment(workspace, firstly_created_but_recently_commented, 'juste a super comment', True)  # nopep8
 
         selected_contents = [
             session=self.session,
             config=self.app_config,
         )
-        main_folder = api.create(ContentType.Folder, workspace, None, 'this is randomized folder', '', True)  # nopep8
+        main_folder = api.create(CONTENT_TYPES.Folder.slug, workspace, None, 'this is randomized folder', '', True)  # nopep8
         # creation order test
-        firstly_created = api.create(ContentType.Page, workspace, main_folder, 'creation_order_test', '', True)  # nopep8
-        secondly_created = api.create(ContentType.Page, workspace, main_folder, 'another creation_order_test', '', True)  # nopep8
+        firstly_created = api.create(CONTENT_TYPES.Page.slug, workspace, main_folder, 'creation_order_test', '', True)  # nopep8
+        secondly_created = api.create(CONTENT_TYPES.Page.slug, workspace, main_folder, 'another creation_order_test', '', True)  # nopep8
         # update order test
-        firstly_created_but_recently_updated = api.create(ContentType.Page, workspace, main_folder, 'update_order_test', '', True)  # nopep8
-        secondly_created_but_not_updated = api.create(ContentType.Page, workspace, main_folder, 'another update_order_test', '', True)  # nopep8
+        firstly_created_but_recently_updated = api.create(CONTENT_TYPES.Page.slug, workspace, main_folder, 'update_order_test', '', True)  # nopep8
+        secondly_created_but_not_updated = api.create(CONTENT_TYPES.Page.slug, workspace, main_folder, 'another update_order_test', '', True)  # nopep8
         with new_revision(
             session=self.session,
             tm=transaction.manager,
             firstly_created_but_recently_updated.description = 'Just an update'
         api.save(firstly_created_but_recently_updated)
         # comment change order
-        firstly_created_but_recently_commented = api.create(ContentType.Page, workspace, main_folder, 'this is randomized label content', '', True)  # nopep8
-        secondly_created_but_not_commented = api.create(ContentType.Page, workspace, main_folder, 'this is another randomized label content', '', True)  # nopep8
+        firstly_created_but_recently_commented = api.create(CONTENT_TYPES.Page.slug, workspace, main_folder, 'this is randomized label content', '', True)  # nopep8
+        secondly_created_but_not_commented = api.create(CONTENT_TYPES.Page.slug, workspace, main_folder, 'this is another randomized label content', '', True)  # nopep8
         comments = api.create_comment(workspace, firstly_created_but_recently_commented, 'juste a super comment', True)  # nopep8
 
         last_actives = api.get_last_active(workspace=workspace, limit=2)  # nopep8
             session=self.session,
             config=self.app_config,
         )
-        main_folder = api.create(ContentType.Folder, workspace, None, 'this is randomized folder', '', True)  # nopep8
+        main_folder = api.create(CONTENT_TYPES.Folder.slug, workspace, None, 'this is randomized folder', '', True)  # nopep8
         # creation order test
-        firstly_created = api.create(ContentType.Page, workspace, main_folder, 'creation_order_test', '', True)  # nopep8
-        secondly_created = api.create(ContentType.Page, workspace, main_folder, 'another creation_order_test', '', True)  # nopep8
+        firstly_created = api.create(CONTENT_TYPES.Page.slug, workspace, main_folder, 'creation_order_test', '', True)  # nopep8
+        secondly_created = api.create(CONTENT_TYPES.Page.slug, workspace, main_folder, 'another creation_order_test', '', True)  # nopep8
         # update order test
-        firstly_created_but_recently_updated = api.create(ContentType.Page, workspace, main_folder, 'update_order_test', '', True)  # nopep8
-        secondly_created_but_not_updated = api.create(ContentType.Page, workspace, main_folder, 'another update_order_test', '', True)  # nopep8
+        firstly_created_but_recently_updated = api.create(CONTENT_TYPES.Page.slug, workspace, main_folder, 'update_order_test', '', True)  # nopep8
+        secondly_created_but_not_updated = api.create(CONTENT_TYPES.Page.slug, workspace, main_folder, 'another update_order_test', '', True)  # nopep8
         with new_revision(
             session=self.session,
             tm=transaction.manager,
             firstly_created_but_recently_updated.description = 'Just an update'
         api.save(firstly_created_but_recently_updated)
         # comment change order
-        firstly_created_but_recently_commented = api.create(ContentType.Page, workspace, main_folder, 'this is randomized label content', '', True)  # nopep8
-        secondly_created_but_not_commented = api.create(ContentType.Page, workspace, main_folder, 'this is another randomized label content', '', True)  # nopep8
+        firstly_created_but_recently_commented = api.create(CONTENT_TYPES.Page.slug, workspace, main_folder, 'this is randomized label content', '', True)  # nopep8
+        secondly_created_but_not_commented = api.create(CONTENT_TYPES.Page.slug, workspace, main_folder, 'this is another randomized label content', '', True)  # nopep8
         comments = api.create_comment(workspace, firstly_created_but_recently_commented, 'juste a super comment', True)  # nopep8
 
         last_actives = api.get_last_active(workspace=workspace2)
             session=self.session,
             config=self.app_config,
         )
-        a = api.create(ContentType.Folder, workspace, None,
+        a = api.create(CONTENT_TYPES.Folder.slug, workspace, None,
                        'this is randomized folder', '', True)
-        p = api.create(ContentType.Page, workspace, a,
+        p = api.create(CONTENT_TYPES.Page.slug, workspace, a,
                        'this is randomized label content', '', True)
 
         with new_revision(
             session=self.session,
             config=self.app_config,
         )
-        a = api.create(ContentType.Folder, workspace, None,
+        a = api.create(CONTENT_TYPES.Folder.slug, workspace, None,
                        'this is randomized folder', '', True)
-        p = api.create(ContentType.Page, workspace, a,
+        p = api.create(CONTENT_TYPES.Page.slug, workspace, a,
                        'this is dummy label content', '', True)
 
         with new_revision(
             config=self.app_config,
         )
         a = api.create(
-            content_type=ContentType.Folder,
+            content_type_slug=CONTENT_TYPES.Folder.slug,
             workspace=workspace,
             parent=None,
             label='this is randomized folder',
             do_save=True
         )
         p1 = api.create(
-            content_type=ContentType.Page,
+            content_type_slug=CONTENT_TYPES.Page.slug,
             workspace=workspace,
             parent=a,
             label='this is dummy label content',
             do_save=True
         )
         p2 = api.create(
-            content_type=ContentType.Page,
+            content_type_slug=CONTENT_TYPES.Page.slug,
             workspace=workspace,
             parent=a,
             label='Hey ! Jon !',
         folder_1 = self._create_content_and_test(
             'folder_1',
             workspace=workspace,
-            type=ContentType.Folder
+            type=CONTENT_TYPES.Folder.slug
         )
         folder_2 = self._create_content_and_test(
             'folder_2',
             workspace=workspace,
-            type=ContentType.Folder
+            type=CONTENT_TYPES.Folder.slug
         )
         page_1 = self._create_content_and_test(
             'foo', workspace=workspace,
-            type=ContentType.Page,
+            type=CONTENT_TYPES.Page.slug,
             parent=folder_1
         )
         page_2 = self._create_content_and_test(
             'bar',
             workspace=workspace,
-            type=ContentType.Page,
+            type=CONTENT_TYPES.Page.slug,
             parent=folder_2
         )
 
             session=self.session,
             config=self.app_config,
         ).create(
-            content_type=ContentType.Page,
+            content_type_slug=CONTENT_TYPES.Page.slug,
             workspace=bob_workspace,
             label='bob_page',
             do_save=True,
             session=self.session,
             config=self.app_config,
         ).create(
-            content_type=ContentType.Page,
+            content_type_slug=CONTENT_TYPES.Page.slug,
             workspace=admin_workspace,
             label='admin_page',
             do_save=True,

backend/tracim_backend/tests/models/test_content.py

 from tracim_backend.models import User
 from tracim_backend.models.data import ActionDescription
 from tracim_backend.models.data import ContentRevisionRO
-from tracim_backend.models.data import ContentType
+from tracim_backend.models.contents import CONTENT_TYPES
 from tracim_backend.models.data import Workspace
 from tracim_backend.tests import StandardTest
 
 
         content1_from_api = api.get_one(
             content1.id,
-            ContentType.Page,
+            CONTENT_TYPES.Page.slug,
             workspace1
         )
 
         first_content = self._create_content(
             owner=user_admin,
             workspace=workspace,
-            type=ContentType.Page,
+            type=CONTENT_TYPES.Page.slug,
             label='TEST_CONTENT_1',
             description='TEST_CONTENT_DESCRIPTION_1',
             revision_type=ActionDescription.CREATION,
         second_content = self._create_content(
             owner=user_admin,
             workspace=workspace,
-            type=ContentType.Page,
+            type=CONTENT_TYPES.Page.slug,
             label='TEST_CONTENT_2',
             description='TEST_CONTENT_DESCRIPTION_2',
             revision_type=ActionDescription.CREATION
         created_content = self._create_content(
             owner=user_admin,
             workspace=workspace,
-            type=ContentType.Page,
+            type=CONTENT_TYPES.Page.slug,
             label='TEST_CONTENT_%s' % key,
             description='TEST_CONTENT_DESCRIPTION_%s' % key,
             revision_type=ActionDescription.CREATION
         content = self._create_content(
             owner=user_admin,
             workspace=workspace,
-            type=ContentType.File,
+            type=CONTENT_TYPES.File.slug,
             label='TEST_CONTENT_1',
             description='TEST_CONTENT_DESCRIPTION_1',
             revision_type=ActionDescription.CREATION,

backend/tracim_backend/tests/models/test_content_revision.py

 
 from tracim_backend.models import ContentRevisionRO
 from tracim_backend.models import User
-from tracim_backend.models.data import ContentType
+from tracim_backend.models.contents import CONTENT_TYPES
 from tracim_backend.tests import DefaultTest
 from tracim_backend.tests import eq_
 
+
 class TestContentRevision(DefaultTest):
 
     def _new_from(self, revision):
         folder = self._create_content_and_test(
             name='folder_1',
             workspace=workspace,
-            type=ContentType.Folder
+            type=CONTENT_TYPES.Folder.slug
         )
         page = self._create_content_and_test(
             workspace=workspace,
             parent=folder,
             name='file_1',
             description='content of file_1',
-            type=ContentType.Page,
+            type=CONTENT_TYPES.Page.slug,
             owner=admin
         )
 

backend/tracim_backend/views/contents_api/comment_controller.py

 from tracim_backend.views.core_api.schemas import WorkspaceAndContentIdPathSchema
 from tracim_backend.views.core_api.schemas import NoContentSchema
 from tracim_backend.exceptions import EmptyCommentContentNotAllowed
-from tracim_backend.models.contents import ContentTypeLegacy as ContentType
+from tracim_backend.models.contents import CONTENT_TYPES
 from tracim_backend.models.revision_protection import new_revision
 from tracim_backend.models.data import UserRoleInWorkspace
 
         )
         content = api.get_one(
             hapic_data.path.content_id,
-            content_type=ContentType.Any
+            content_type=CONTENT_TYPES.Any_SLUG
         )
         comments = content.get_comments()
         comments.sort(key=lambda comment: comment.created)
         )
         content = api.get_one(
             hapic_data.path.content_id,
-            content_type=ContentType.Any
+            content_type=CONTENT_TYPES.Any_SLUG
         )
         comment = api.create_comment(
             content.workspace,
         workspace = wapi.get_one(hapic_data.path.workspace_id)
         parent = api.get_one(
             hapic_data.path.content_id,
-            content_type=ContentType.Any,
+            content_type=CONTENT_TYPES.Any_SLUG,
             workspace=workspace
         )
         comment = api.get_one(
             hapic_data.path.comment_id,
-            content_type=ContentType.Comment,
+            content_type=CONTENT_TYPES.Comment.slug,
             workspace=workspace,
             parent=parent,
         )

backend/tracim_backend/views/contents_api/file_controller.py

 from tracim_backend.models.data import UserRoleInWorkspace
 from tracim_backend.models.context_models import ContentInContext
 from tracim_backend.models.context_models import RevisionInContext
-from tracim_backend.models.contents import ContentTypeLegacy as ContentType
+from tracim_backend.models.contents import CONTENT_TYPES
 from tracim_backend.models.contents import file_type
 from tracim_backend.models.revision_protection import new_revision
 from tracim_backend.exceptions import EmptyLabelNotAllowed
         )
         content = api.get_one(
             hapic_data.path.content_id,
-            content_type=ContentType.Any
+            content_type=CONTENT_TYPES.Any_SLUG
         )
         file = request.POST['files']
         with new_revision(
         )
         content = api.get_one(
             hapic_data.path.content_id,
-            content_type=ContentType.Any
+            content_type=CONTENT_TYPES.Any_SLUG
         )
         file = DepotManager.get().get(content.depot_file)
         response = request.response
         )
         content = api.get_one(
             hapic_data.path.content_id,
-            content_type=ContentType.Any
+            content_type=CONTENT_TYPES.Any_SLUG
         )
         revision = api.get_one_revision(
             revision_id=hapic_data.path.revision_id,
         )
         content = api.get_one(
             hapic_data.path.content_id,
-            content_type=ContentType.Any
+            content_type=CONTENT_TYPES.Any_SLUG
         )
         pdf_preview_path = api.get_pdf_preview_path(
             content.content_id,
         )
         content = api.get_one(
             hapic_data.path.content_id,
-            content_type=ContentType.Any
+            content_type=CONTENT_TYPES.Any_SLUG
         )
         pdf_preview_path = api.get_full_pdf_preview_path(content.revision_id)
         return FileResponse(pdf_preview_path)
         )
         content = api.get_one(
             hapic_data.path.content_id,
-            content_type=ContentType.Any
+            content_type=CONTENT_TYPES.Any_SLUG
         )
         revision = api.get_one_revision(
             revision_id=hapic_data.path.revision_id,
         )
         content = api.get_one(
             hapic_data.path.content_id,
-            content_type=ContentType.Any
+            content_type=CONTENT_TYPES.Any_SLUG
         )
         allowed_dim = api.get_jpg_preview_allowed_dim()
         jpg_preview_path = api.get_jpg_preview_path(
         )
         content = api.get_one(
             hapic_data.path.content_id,
-            content_type=ContentType.Any
+            content_type=CONTENT_TYPES.Any_SLUG
         )
         jpg_preview_path = api.get_jpg_preview_path(
             content_id=content.content_id,
         )
         content = api.get_one(
             hapic_data.path.content_id,
-            content_type=ContentType.Any
+            content_type=CONTENT_TYPES.Any_SLUG
         )
         revision = api.get_one_revision(
             revision_id=hapic_data.path.revision_id,
         )
         content = api.get_one(
             hapic_data.path.content_id,
-            content_type=ContentType.Any
+            content_type=CONTENT_TYPES.Any_SLUG
         )
         return api.get_content_in_context(content)
 
         )
         content = api.get_one(
             hapic_data.path.content_id,
-            content_type=ContentType.Any
+            content_type=CONTENT_TYPES.Any_SLUG
         )
         with new_revision(
                 session=request.dbsession,
         )
         content = api.get_one(
             hapic_data.path.content_id,
-            content_type=ContentType.Any
+            content_type=CONTENT_TYPES.Any_SLUG
         )
         revisions = content.revisions
         return [
         )
         content = api.get_one(
             hapic_data.path.content_id,
-            content_type=ContentType.Any
+            content_type=CONTENT_TYPES.Any_SLUG
         )
         with new_revision(
                 session=request.dbsession,

backend/tracim_backend/views/contents_api/html_document_controller.py

 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 ContentTypeLegacy as ContentType
+from tracim_backend.models.contents import CONTENT_TYPES
 from tracim_backend.models.contents import html_documents_type
 from tracim_backend.models.revision_protection import new_revision
 
         )
         content = api.get_one(
             hapic_data.path.content_id,
-            content_type=ContentType.Any
+            content_type=CONTENT_TYPES.Any_SLUG
         )
         return api.get_content_in_context(content)
 
         )
         content = api.get_one(
             hapic_data.path.content_id,
-            content_type=ContentType.Any
+            content_type=CONTENT_TYPES.Any_SLUG
         )
         with new_revision(
                 session=request.dbsession,
         )
         content = api.get_one(
             hapic_data.path.content_id,
-            content_type=ContentType.Any
+            content_type=CONTENT_TYPES.Any_SLUG
         )
         revisions = content.revisions
         return [
         )
         content = api.get_one(
             hapic_data.path.content_id,
-            content_type=ContentType.Any
+            content_type=CONTENT_TYPES.Any_SLUG
         )
         with new_revision(
                 session=request.dbsession,

backend/tracim_backend/views/contents_api/threads_controller.py

 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 ContentTypeLegacy as ContentType
+from tracim_backend.models.contents import CONTENT_TYPES
 from tracim_backend.models.contents import thread_type
 from tracim_backend.models.revision_protection import new_revision
 
         )
         content = api.get_one(
             hapic_data.path.content_id,
-            content_type=ContentType.Any
+            content_type=CONTENT_TYPES.Any_SLUG
         )
         return api.get_content_in_context(content)
 
         )
         content = api.get_one(
             hapic_data.path.content_id,
-            content_type=ContentType.Any
+            content_type=CONTENT_TYPES.Any_SLUG
         )
         with new_revision(
                 session=request.dbsession,
         )
         content = api.get_one(
             hapic_data.path.content_id,
-            content_type=ContentType.Any
+            content_type=CONTENT_TYPES.Any_SLUG
         )
         revisions = content.revisions
         return [
         )
         content = api.get_one(
             hapic_data.path.content_id,
-            content_type=ContentType.Any
+            content_type=CONTENT_TYPES.Any_SLUG
         )
         with new_revision(
                 session=request.dbsession,

backend/tracim_backend/views/core_api/schemas.py

 from tracim_backend.lib.utils.utils import DATETIME_FORMAT
 from tracim_backend.models.auth import Profile
 from tracim_backend.models.contents import GlobalStatus
+from tracim_backend.models.contents import CONTENT_STATUS
+from tracim_backend.models.contents import CONTENT_TYPES
 from tracim_backend.models.contents import open_status
-from tracim_backend.models.contents import ContentTypeLegacy as ContentType
-from tracim_backend.models.contents import ContentStatusLegacy as ContentStatus
 from tracim_backend.models.context_models import ActiveContentFilter
 from tracim_backend.models.context_models import ContentIdsQuery
 from tracim_backend.models.context_models import UserWorkspaceAndContentPath
         validate=Range(min=0, max=1, error="Value must be 0 or 1"),
     )
     content_type = marshmallow.fields.String(
-        example=ContentType.Any,
-        default=ContentType.Any,
-        validate=OneOf(ContentType.allowed_type_values())
+        example=CONTENT_TYPES.Any_SLUG,
+        default=CONTENT_TYPES.Any_SLUG,
+        validate=OneOf(CONTENT_TYPES.endpoint_allowed_types_slug())
     )
 
     @post_load
 class ContentTypeSchema(marshmallow.Schema):
     slug = marshmallow.fields.String(
         example='pagehtml',
-        validate=OneOf(ContentType.allowed_types()),
+        validate=OneOf(CONTENT_TYPES.endpoint_allowed_types_slug()),
     )
     fa_icon = marshmallow.fields.String(
         example='fa-file-text-o',
     )
     content_type = marshmallow.fields.String(
         example='html-document',
-        validate=OneOf(ContentType.allowed_types_for_folding()),  # nopep8
+        validate=OneOf(CONTENT_TYPES.endpoint_allowed_types_slug()),
     )
     parent_id = marshmallow.fields.Integer(
         example=35,
     label = marshmallow.fields.Str(example='Intervention Report 12')
     content_type = marshmallow.fields.Str(
         example='html-document',
-        validate=OneOf(ContentType.allowed_types()),
+        validate=OneOf(CONTENT_TYPES.endpoint_allowed_types_slug()),
     )
     sub_content_types = marshmallow.fields.List(
         marshmallow.fields.String(
             example='html-content',
-            validate=OneOf(ContentType.allowed_types())
+            validate=OneOf(CONTENT_TYPES.endpoint_allowed_types_slug())
         ),
         description='list of content types allowed as sub contents. '
                     'This field is required for folder contents, '
     )
     status = marshmallow.fields.Str(
         example='closed-deprecated',
-        validate=OneOf(ContentStatus.allowed_values()),
+        validate=OneOf(CONTENT_STATUS.get_all_slugs_values()),
         description='this slug is found in content_type available statuses',
         default=open_status
     )
 # Content
 #####
 
+
 class ContentSchema(ContentDigestSchema):
     current_revision_id = marshmallow.fields.Int(example=12)
     created = marshmallow.fields.DateTime(
 class SetContentStatusSchema(marshmallow.Schema):
     status = marshmallow.fields.Str(
         example='closed-deprecated',
-        validate=OneOf(ContentStatus.allowed_values()),
+        validate=OneOf(CONTENT_STATUS.get_all_slugs_values()),
         description='this slug is found in content_type available statuses',
         default=open_status,
         required=True,

backend/tracim_backend/views/core_api/system_controller.py

 from tracim_backend.lib.utils.authorization import require_profile
 from tracim_backend.models import Group
 from tracim_backend.models.applications import applications
-from tracim_backend.models.contents import ContentTypeLegacy as ContentType
+from tracim_backend.models.contents import CONTENT_TYPES
 
 try:  # Python 3.5+
     from http import HTTPStatus
         """
         Get list of alls content types availables in this tracim instance.
         """
-        content_types_slugs = ContentType.allowed_types_for_folding()
-        content_types = [ContentType(slug) for slug in content_types_slugs]
+        content_types_slugs = CONTENT_TYPES.endpoint_allowed_types_slug()
+        content_types = [CONTENT_TYPES.get_one_by_slug(slug) for slug in content_types_slugs]
         return content_types
 
     def bind(self, configurator: Configurator) -> None:

backend/tracim_backend/views/core_api/user_controller.py

 from pyramid.config import Configurator
+
 try:  # Python 3.5+
     from http import HTTPStatus
 except ImportError:
 from tracim_backend.lib.core.user import UserApi
 from tracim_backend.lib.core.workspace import WorkspaceApi
 from tracim_backend.lib.core.content import ContentApi
-from tracim_backend.models.contents import ContentTypeLegacy as ContentType
 from tracim_backend.views.controllers import Controller
 from tracim_backend.lib.utils.authorization import require_same_user_or_profile
 from tracim_backend.lib.utils.authorization import require_profile
 from tracim_backend.views.core_api.schemas import ContentDigestSchema
 from tracim_backend.views.core_api.schemas import ActiveContentFilterQuerySchema
 from tracim_backend.views.core_api.schemas import WorkspaceDigestSchema
+from tracim_backend.models.contents import CONTENT_TYPES
 
 SWAGGER_TAG__USER_ENDPOINTS = 'Users'
 
             before_content = api.get_one(
                 content_id=content_filter.before_content_id,
                 workspace=workspace,
-                content_type=ContentType.Any
+                content_type=CONTENT_TYPES.Any_SLUG
             )
         last_actives = api.get_last_active(
             workspace=workspace,

backend/tracim_backend/views/core_api/workspace_controller.py

 from tracim_backend.views.core_api.schemas import WorkspaceSchema
 from tracim_backend.views.core_api.schemas import WorkspaceIdPathSchema
 from tracim_backend.views.core_api.schemas import WorkspaceMemberSchema
-from tracim_backend.models.contents import ContentTypeLegacy as ContentType
+from tracim_backend.models.contents import CONTENT_TYPES
 from tracim_backend.models.revision_protection import new_revision
 
 SWAGGER_TAG_WORKSPACE_ENDPOINTS = 'Workspaces'
         contents = api.get_all(
             parent_id=content_filter.parent_id,
             workspace=request.current_workspace,
-            content_type=content_filter.content_type or ContentType.Any,
+            content_type=content_filter.content_type or CONTENT_TYPES.Any_SLUG,
         )
         contents = [
             api.get_content_in_context(content) for content in contents
         parent = None
         if creation_data.parent_id:
             try:
-                parent = api.get_one(content_id=creation_data.parent_id, content_type=ContentType.Any)  # nopep8
+                parent = api.get_one(content_id=creation_data.parent_id, content_type=CONTENT_TYPES.Any_SLUG)  # 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,
+            content_type_slug=creation_data.content_type,
             workspace=request.current_workspace,
             parent=parent,
         )
         )
         content = api.get_one(
             path_data.content_id,
-            content_type=ContentType.Any
+            content_type=CONTENT_TYPES.Any_SLUG
         )
         new_parent = api.get_one(
-            move_data.new_parent_id, content_type=ContentType.Any
+            move_data.new_parent_id, content_type=CONTENT_TYPES.Any_SLUG
         )
 
         new_workspace = request.candidate_workspace
             )
         updated_content = api.get_one(
             path_data.content_id,
-            content_type=ContentType.Any
+            content_type=CONTENT_TYPES.Any_SLUG
         )
         return api.get_content_in_context(updated_content)
 
         )
         content = api.get_one(
             path_data.content_id,
-            content_type=ContentType.Any
+            content_type=CONTENT_TYPES.Any_SLUG
         )
         with new_revision(
                 session=request.dbsession,
         )
         content = api.get_one(
             path_data.content_id,
-            content_type=ContentType.Any
+            content_type=CONTENT_TYPES.Any_SLUG
         )
         with new_revision(
                 session=request.dbsession,
             session=request.dbsession,
             config=app_config,
         )
-        content = api.get_one(path_data.content_id, content_type=ContentType.Any)  # nopep8
+        content = api.get_one(path_data.content_id, content_type=CONTENT_TYPES.Any_SLUG)  # nopep8
         with new_revision(
                 session=request.dbsession,
                 tm=transaction.manager,
         )
         content = api.get_one(
             path_data.content_id,
-            content_type=ContentType.Any
+            content_type=CONTENT_TYPES.Any_SLUG
         )
         with new_revision(
                 session=request.dbsession,