refactoring UserRoleinWorkspaceModel

tracim/exceptions.py

 
 class EmptyRawContentNotAllowed(EmptyValueNotAllowed):
     pass
+
+
+class RoleDoesNotExist(TracimException):
+    pass

tracim/lib/core/userworkspace.py

 from tracim.models.auth import User
 from tracim.models.data import Workspace
 from tracim.models.data import UserRoleInWorkspace
-from tracim.models.data import RoleType
 
 
 class RoleApi(object):
 
-    ALL_ROLE_VALUES = UserRoleInWorkspace.get_all_role_values()
+    # TODO - G.M - 29-06-2018 - [Cleanup] Drop this
+    # ALL_ROLE_VALUES = UserRoleInWorkspace.get_all_role_values()
     # Dict containing readable members roles for given role
-    members_read_rights = {
-        UserRoleInWorkspace.NOT_APPLICABLE: [],
-        UserRoleInWorkspace.READER: [
-            UserRoleInWorkspace.WORKSPACE_MANAGER,
-        ],
-        UserRoleInWorkspace.CONTRIBUTOR: [
-            UserRoleInWorkspace.WORKSPACE_MANAGER,
-            UserRoleInWorkspace.CONTENT_MANAGER,
-            UserRoleInWorkspace.CONTRIBUTOR,
-        ],
-        UserRoleInWorkspace.CONTENT_MANAGER: [
-            UserRoleInWorkspace.WORKSPACE_MANAGER,
-            UserRoleInWorkspace.CONTENT_MANAGER,
-            UserRoleInWorkspace.CONTRIBUTOR,
-            UserRoleInWorkspace.READER,
-        ],
-        UserRoleInWorkspace.WORKSPACE_MANAGER: [
-            UserRoleInWorkspace.WORKSPACE_MANAGER,
-            UserRoleInWorkspace.CONTENT_MANAGER,
-            UserRoleInWorkspace.CONTRIBUTOR,
-            UserRoleInWorkspace.READER,
-        ],
-    }
+    # members_read_rights = {
+    #     UserRoleInWorkspace.NOT_APPLICABLE: [],
+    #     UserRoleInWorkspace.READER: [
+    #         UserRoleInWorkspace.WORKSPACE_MANAGER,
+    #     ],
+    #     UserRoleInWorkspace.CONTRIBUTOR: [
+    #         UserRoleInWorkspace.WORKSPACE_MANAGER,
+    #         UserRoleInWorkspace.CONTENT_MANAGER,
+    #         UserRoleInWorkspace.CONTRIBUTOR,
+    #     ],
+    #     UserRoleInWorkspace.CONTENT_MANAGER: [
+    #         UserRoleInWorkspace.WORKSPACE_MANAGER,
+    #         UserRoleInWorkspace.CONTENT_MANAGER,
+    #         UserRoleInWorkspace.CONTRIBUTOR,
+    #         UserRoleInWorkspace.READER,
+    #     ],
+    #     UserRoleInWorkspace.WORKSPACE_MANAGER: [
+    #         UserRoleInWorkspace.WORKSPACE_MANAGER,
+    #         UserRoleInWorkspace.CONTENT_MANAGER,
+    #         UserRoleInWorkspace.CONTRIBUTOR,
+    #         UserRoleInWorkspace.READER,
+    #     ],
+    # }
+
+    # TODO - G.M - 29-06-2018 - [Cleanup] Drop this
+    # @classmethod
+    # def role_can_read_member_role(cls, reader_role: int, tested_role: int) \
+    #         -> bool:
+    #     """
+    #     :param reader_role: role as viewer
+    #     :param tested_role: role as viwed
+    #     :return: True if given role can view member role in workspace.
+    #     """
+    #     if reader_role in cls.members_read_rights:
+    #         return tested_role in cls.members_read_rights[reader_role]
+    #     return False
 
     def get_user_role_workspace_with_context(
             self,
         return workspace
 
     @classmethod
-    def role_can_read_member_role(cls, reader_role: int, tested_role: int) \
-            -> bool:
-        """
-        :param reader_role: role as viewer
-        :param tested_role: role as viwed
-        :return: True if given role can view member role in workspace.
-        """
-        if reader_role in cls.members_read_rights:
-            return tested_role in cls.members_read_rights[reader_role]
-        return False
-
-    @classmethod
     def create_role(cls) -> UserRoleInWorkspace:
         role = UserRoleInWorkspace()
 
         if flush:
             self._session.flush()
 
-    def _get_all_for_user(self, user_id) -> typing.List[UserRoleInWorkspace]:
-        return self._session.query(UserRoleInWorkspace)\
-            .filter(UserRoleInWorkspace.user_id == user_id)
-
-    def get_all_for_user(self, user: User) -> typing.List[UserRoleInWorkspace]:
-        return self._get_all_for_user(user.user_id).all()
-
-    def get_all_for_user_order_by_workspace(
-        self,
-        user_id: int
-    ) -> typing.List[UserRoleInWorkspace]:
-        return self._get_all_for_user(user_id)\
-            .join(UserRoleInWorkspace.workspace).order_by(Workspace.label).all()
-
     def get_all_for_workspace(
         self,
         workspace:Workspace
     def save(self, role: UserRoleInWorkspace) -> None:
         self._session.flush()
 
-    # TODO - G.M - 07-06-2018 - [Cleanup] Check if this method is already needed
-    @classmethod
-    def get_roles_for_select_field(cls) -> typing.List[RoleType]:
-        """
-
-        :return: list of DictLikeClass instances representing available Roles
-        (to be used in select fields)
-        """
-        result = list()
 
-        for role_id in UserRoleInWorkspace.get_all_role_values():
-            role = RoleType(role_id)
-            result.append(role)
+    # TODO - G.M - 29-06-2018 - [Cleanup] Drop this
+    # @classmethod
+    # def role_can_read_member_role(cls, reader_role: int, tested_role: int) \
+    #         -> bool:
+    #     """
+    #     :param reader_role: role as viewer
+    #     :param tested_role: role as viwed
+    #     :return: True if given role can view member role in workspace.
+    #     """
+    #     if reader_role in cls.members_read_rights:
+    #         return tested_role in cls.members_read_rights[reader_role]
+    #     return False
+    # def _get_all_for_user(self, user_id) -> typing.List[UserRoleInWorkspace]:
+    #     return self._session.query(UserRoleInWorkspace)\
+    #         .filter(UserRoleInWorkspace.user_id == user_id)
+    #
+    # def get_all_for_user(self, user: User) -> typing.List[UserRoleInWorkspace]:
+    #     return self._get_all_for_user(user.user_id).all()
+    #
+    # def get_all_for_user_order_by_workspace(
+    #     self,
+    #     user_id: int
+    # ) -> typing.List[UserRoleInWorkspace]:
+    #     return self._get_all_for_user(user_id)\
+    #         .join(UserRoleInWorkspace.workspace).order_by(Workspace.label).all()
 
-        return result
+    # TODO - G.M - 07-06-2018 - [Cleanup] Check if this method is already needed
+    # @classmethod
+    # def get_roles_for_select_field(cls) -> typing.List[RoleType]:
+    #     """
+    #
+    #     :return: list of DictLikeClass instances representing available Roles
+    #     (to be used in select fields)
+    #     """
+    #     result = list()
+    #
+    #     for role_id in UserRoleInWorkspace.get_all_role_values():
+    #         role = RoleType(role_id)
+    #         result.append(role)
+    #
+    #     return result

tracim/models/context_models.py

 from tracim.models.data import Content
 from tracim.models.data import ContentRevisionRO
 from tracim.models.data import Workspace, UserRoleInWorkspace
+from tracim.models.roles import WorkspaceRoles
 from tracim.models.workspace_menu_entries import default_workspace_menu_entry
 from tracim.models.workspace_menu_entries import WorkspaceMenuEntry
 from tracim.models.contents import ContentTypeLegacy as ContentType
         'contributor', 'content-manager', 'workspace-manager'
         :return: user workspace role as slug.
         """
-        return UserRoleInWorkspace.SLUG[self.user_role.role]
+        return WorkspaceRoles.get_role_from_level(self.user_role.role).slug
 
     @property
     def user(self) -> UserInContext:

tracim/models/data.py

 from tracim.exceptions import ContentRevisionUpdateError
 from tracim.models.meta import DeclarativeBase
 from tracim.models.auth import User
+from tracim.models.roles import WorkspaceRoles
 
 DEFAULT_PROPERTIES = dict(
     allowed_content=dict(
     workspace = relationship('Workspace', remote_side=[Workspace.workspace_id], backref='roles', lazy='joined')
     user = relationship('User', remote_side=[User.user_id], backref='roles')
 
-    NOT_APPLICABLE = 0
-    READER = 1
-    CONTRIBUTOR = 2
-    CONTENT_MANAGER = 4
-    WORKSPACE_MANAGER = 8
-
-    SLUG = {
-        NOT_APPLICABLE: 'not-applicable',
-        READER: 'reader',
-        CONTRIBUTOR: 'contributor',
-        CONTENT_MANAGER: 'content-manager',
-        WORKSPACE_MANAGER: 'workspace-manager',
-    }
+    NOT_APPLICABLE = WorkspaceRoles.NOT_APPLICABLE.level
+    READER = WorkspaceRoles.READER.level
+    CONTRIBUTOR = WorkspaceRoles.CONTRIBUTOR.level
+    CONTENT_MANAGER = WorkspaceRoles.CONTENT_MANAGER.level
+    WORKSPACE_MANAGER = WorkspaceRoles.WORKSPACE_MANAGER.level
+
+    # TODO - G.M - 10-04-2018 - [Cleanup] Drop this
+    # SLUG = {
+    #     NOT_APPLICABLE: 'not-applicable',
+    #     READER: 'reader',
+    #     CONTRIBUTOR: 'contributor',
+    #     CONTENT_MANAGER: 'content-manager',
+    #     WORKSPACE_MANAGER: 'workspace-manager',
+    # }
 
-    LABEL = dict()
-    LABEL[0] = l_('N/A')
-    LABEL[1] = l_('Reader')
-    LABEL[2] = l_('Contributor')
-    LABEL[4] = l_('Content Manager')
-    LABEL[8] = l_('Workspace Manager')
+    # LABEL = dict()
+    # LABEL[0] = l_('N/A')
+    # LABEL[1] = l_('Reader')
+    # LABEL[2] = l_('Contributor')
+    # LABEL[4] = l_('Content Manager')
+    # LABEL[8] = l_('Workspace Manager')
     # TODO - G.M - 10-04-2018 - [Cleanup] Drop this
     #
     # STYLE = dict()
     #     return UserRoleInWorkspace.STYLE[self.role]
     #
 
+    def role_object(self):
+        return WorkspaceRoles.get_role_from_level(level=self.role)
+
     def role_as_label(self):
-        return UserRoleInWorkspace.LABEL[self.role]
+        return self.role_object().label
 
     @classmethod
     def get_all_role_values(cls) -> typing.List[int]:
         """
         Return all valid role value
         """
-        return [
-            UserRoleInWorkspace.READER,
-            UserRoleInWorkspace.CONTRIBUTOR,
-            UserRoleInWorkspace.CONTENT_MANAGER,
-            UserRoleInWorkspace.WORKSPACE_MANAGER
-        ]
+        return [role.level for role in WorkspaceRoles.get_all_valid_role()]
 
     @classmethod
     def get_all_role_slug(cls) -> typing.List[str]:
         # INFO - G.M - 25-05-2018 - Be carefull, as long as this method
         # and get_all_role_values are both used for API, this method should
         # return item in the same order as get_all_role_values
-        return [cls.SLUG[value] for value in cls.get_all_role_values()]
-
+        return [role.slug for role in WorkspaceRoles.get_all_valid_role()]
 
-class RoleType(object):
-    def __init__(self, role_id):
-        self.role_type_id = role_id
-        # TODO - G.M - 10-04-2018 - [Cleanup] Drop this
+# TODO - G.M - 10-04-2018 - [Cleanup] Drop this
+# class RoleType(object):
+#     def __init__(self, role_id):
+#         self.role_type_id = role_id
         # self.fa_icon = UserRoleInWorkspace.ICON[role_id]
         # self.role_label = UserRoleInWorkspace.LABEL[role_id]
         # self.css_style = UserRoleInWorkspace.STYLE[role_id]

tracim/models/roles.py

+import typing
+from enum import Enum
+
+from tracim.exceptions import RoleDoesNotExist
+
+
+class WorkspaceRoles(Enum):
+    """
+    Available role for workspace.
+    All roles should have a unique level and unique slug.
+    level is role value store in database and is also use for
+    permission check.
+    slug is for http endpoints and other place where readability is
+    needed.
+    """
+    NOT_APPLICABLE = (0, 'not-applicable')
+    READER = (1, 'reader')
+    CONTRIBUTOR = (2, 'contributor')
+    CONTENT_MANAGER = (4, 'content-manager')
+    WORKSPACE_MANAGER = (8, 'workspace-manager')
+
+    def __init__(self, level, slug):
+        self.level = level
+        self.slug = slug
+    
+    @property
+    def label(self):
+        """ Return valid label associated to role"""
+        # TODO - G.M - 2018-06-180 - Make this work correctly
+        return self.slug
+    
+    @classmethod
+    def get_all_valid_role(cls) -> typing.List['WorkspaceRoles']:
+        """
+        Return all valid role value
+        """
+        return [item for item in list(WorkspaceRoles) if item.level > 0]
+
+    @classmethod
+    def get_role_from_level(cls, level: int) -> 'WorkspaceRoles':
+        """
+        Obtain Workspace role from a level value
+        :param level: level value as int
+        :return: correct workspace role related
+        """
+        roles = [item for item in list(WorkspaceRoles) if item.level == level]
+        if len(roles) != 1:
+            raise RoleDoesNotExist()
+        return roles[0]
+
+    @classmethod
+    def get_role_from_slug(cls, slug: str) -> 'WorkspaceRoles':
+        """
+        Obtain Workspace role from a slug value
+        :param slug: slug value as str
+        :return: correct workspace role related
+        """
+        roles = [item for item in list(WorkspaceRoles) if item.slug == slug]
+        if len(roles) != 1:
+            raise RoleDoesNotExist()
+        return roles[0]

tracim/tests/models/tests_roles.py

+# coding=utf-8
+import unittest
+import pytest
+from tracim.exceptions import RoleDoesNotExist
+from tracim.models.roles import WorkspaceRoles
+
+
+class TestWorkspacesRoles(unittest.TestCase):
+    """
+    Test for WorkspaceRoles Enum Object
+    """
+    def test_workspace_roles__ok__all_list(self):
+        roles = list(WorkspaceRoles)
+        assert len(roles) == 5
+        for role in roles:
+            assert role
+            assert role.slug
+            assert isinstance(role.slug, str)
+            assert role.level or role.level == 0
+            assert isinstance(role.level, int)
+            assert role.label
+            assert isinstance(role.slug, str)
+        assert WorkspaceRoles['READER']
+        assert WorkspaceRoles['NOT_APPLICABLE']
+        assert WorkspaceRoles['CONTRIBUTOR']
+        assert WorkspaceRoles['WORKSPACE_MANAGER']
+        assert WorkspaceRoles['CONTENT_MANAGER']
+
+    def test__workspace_roles__ok__check_model(self):
+        role = WorkspaceRoles.WORKSPACE_MANAGER
+        assert role
+        assert role.slug
+        assert isinstance(role.slug, str)
+        assert role.level
+        assert isinstance(role.level, int)
+        assert role.label
+        assert isinstance(role.slug, str)
+
+    def test_workspace_roles__ok__get_all_valid_roles(self):
+        roles = WorkspaceRoles.get_all_valid_role()
+        assert len(roles) == 4
+        for role in roles:
+            assert role
+            assert role.slug
+            assert isinstance(role.slug, str)
+            assert role.level or role.level == 0
+            assert isinstance(role.level, int)
+            assert role.level > 0
+            assert role.label
+            assert isinstance(role.slug, str)
+
+    def test_workspace_roles__ok__get_role__from_level__ok__nominal_case(self):
+        role = WorkspaceRoles.get_role_from_level(0)
+
+        assert role
+        assert role.slug
+        assert isinstance(role.slug, str)
+        assert role.level == 0
+        assert isinstance(role.level, int)
+        assert role.label
+        assert isinstance(role.slug, str)
+
+    def test_workspace_roles__ok__get_role__from_slug__ok__nominal_case(self):
+        role = WorkspaceRoles.get_role_from_slug('reader')
+
+        assert role
+        assert role.slug
+        assert isinstance(role.slug, str)
+        assert role.level > 0
+        assert isinstance(role.level, int)
+        assert role.label
+        assert isinstance(role.slug, str)
+
+    def test_workspace_roles__ok__get_role__from_level__err__role_does_not_exist(self):  # nopep8
+        with pytest.raises(RoleDoesNotExist):
+            WorkspaceRoles.get_role_from_level(-1000)
+
+    def test_workspace_roles__ok__get_role__from_slug__err__role_does_not_exist(self):  # nopep8
+        with pytest.raises(RoleDoesNotExist):
+            WorkspaceRoles.get_role_from_slug('this slug does not exist')