use config as param in every internal api + with_context method in API

tracim/command/user.py

         self._group_api = GroupApi(
             current_user=None,
             session=self._session,
+            config=self._app_config,
         )
         user = self._proceed_user(parsed_args)
         self._proceed_groups(user, parsed_args)

tracim/fixtures/content.py

         admin_workspace_api = WorkspaceApi(
             current_user=admin,
             session=self._session,
+            config=self._config,
         )
         bob_workspace_api = WorkspaceApi(
             current_user=bob,
             session=self._session,
+            config=self._config
         )
         content_api = ContentApi(
             current_user=admin,
         role_api = RoleApi(
             current_user=admin,
             session=self._session,
+            config=self._config,
         )
 
         # Workspaces

tracim/lib/core/group.py

 # -*- coding: utf-8 -*-
 import typing
 
+from tracim import CFG
+
 __author__ = 'damien'
 
 from tracim.models.auth import Group, User
             self,
             session: Session,
             current_user: typing.Optional[User],
+            config: CFG
+
     ):
         self._user = current_user
         self._session = session
+        self._config = config
 
     def _base_query(self) -> Query:
         return self._session.query(Group)

tracim/lib/core/userworkspace.py

 # -*- coding: utf-8 -*-
 import typing
 
+from tracim import CFG
+from tracim.models.context_models import UserRoleWorkspaceInContext
+
 __author__ = 'damien'
 
 from sqlalchemy.orm import Session
         ],
     }
 
+    def get_user_role_workspace_with_context(
+            self,
+            user_role: UserRoleInWorkspace
+    ) -> UserRoleWorkspaceInContext:
+        """
+        Return WorkspaceInContext object from Workspace
+        """
+        workspace = UserRoleWorkspaceInContext(
+            user_role=user_role,
+            dbsession=self._session,
+            config=self._config,
+        )
+        return workspace
+
     @classmethod
     def role_can_read_member_role(cls, reader_role: int, tested_role: int) \
             -> bool:
 
         return role
 
-    def __init__(self, session: Session, current_user: typing.Optional[User]):
+    def __init__(self,
+                 session: Session,
+                 current_user: typing.Optional[User],
+                 config: CFG):
         self._session = session
         self._user = current_user
+        self._config = config
 
     def _get_one_rsc(self, user_id, workspace_id):
         """

tracim/lib/core/workspace.py

 
 from sqlalchemy.orm import Query
 from sqlalchemy.orm import Session
+
+from tracim import CFG
 from tracim.lib.utils.translation import fake_translator as _
 
 from tracim.lib.core.userworkspace import RoleApi
 from tracim.models.auth import Group
 from tracim.models.auth import User
+from tracim.models.context_models import WorkspaceInContext
 from tracim.models.data import UserRoleInWorkspace
 from tracim.models.data import Workspace
 
             self,
             session: Session,
             current_user: User,
+            config: CFG,
             force_role: bool=False
     ):
         """
         """
         self._session = session
         self._user = current_user
+        self._config = config
         self._force_role = force_role
 
     def _base_query_without_roles(self):
             filter(UserRoleInWorkspace.user_id == self._user.user_id).\
             filter(Workspace.is_deleted == False)
 
+    def get_workspace_with_context(
+            self,
+            workspace: Workspace
+    ) -> WorkspaceInContext:
+        """
+        Return WorkspaceInContext object from Workspace
+        """
+        workspace = WorkspaceInContext(
+            workspace=workspace,
+            dbsession=self._session,
+            config=self._config,
+        )
+        return workspace
+
     def create_workspace(
             self,
             label: str='',
         role_api = RoleApi(
             session=self._session,
             current_user=self._user,
+            config=self._config
         )
 
         role = role_api.create_one(

tracim/lib/utils/request.py

         if 'workspace_id' not in request.json_body:
             raise WorkspaceNotFound('No workspace_id param in json body')
         workspace_id = request.json_body['workspace_id']
-        wapi = WorkspaceApi(current_user=user, session=request.dbsession)
+        wapi = WorkspaceApi(
+            current_user=user,
+            session=request.dbsession,
+            config=request.registry.settings['CFG']
+        )
         workspace = wapi.get_one(workspace_id)
     except JSONDecodeError:
         raise WorkspaceNotFound('Bad json body')

tracim/lib/webdav/dav_provider.py

         if path == root_path:
             return resources.RootResource(path, environ, user=user, session=session)
 
-        workspace_api = WorkspaceApi(current_user=user, session=session)
+        workspace_api = WorkspaceApi(
+            current_user=user,
+            session=session,
+            config=self.app_config,
+        )
         workspace = self.get_workspace_from_path(path, workspace_api)
 
         # If the request path is in the form root/name, then we return a WorkspaceResource resource
 
         workspace = self.get_workspace_from_path(
             path,
-            WorkspaceApi(current_user=user, session=session)
+            WorkspaceApi(
+                current_user=user,
+                session=session,
+                config=self.app_config,
+            )
         )
 
         if parent_path == root_path or workspace is None:

tracim/lib/webdav/resources.py

         self.workspace_api = WorkspaceApi(
             current_user=self.user,
             session=session,
-            force_role=True
+            force_role=True,
+            config=self.provider.app_config
         )
 
     def __repr__(self) -> str:
             workspace_api = WorkspaceApi(
                 current_user=self.user,
                 session=self.session,
+                config=self.provider.app_config,
                 )
             content_api = ContentApi(
                 current_user=self.user,

tracim/tests/__init__.py

         WorkspaceApi(
             current_user=user,
             session=self.session,
+            config=self.app_config,
         ).create_workspace(name, save_now=True)
 
         eq_(

tracim/tests/library/test_content_api.py

             config=self.app_config,
             current_user=None,
         )
-        group_api = GroupApi(current_user=None,session=self.session)
+        group_api = GroupApi(
+            current_user=None,
+            session=self.session,
+            config=self.app_config,
+        )
         groups = [group_api.get_one(Group.TIM_USER),
                   group_api.get_one(Group.TIM_MANAGER),
                   group_api.get_one(Group.TIM_ADMIN)]
                                 groups=groups, save_now=True)
         workspace = WorkspaceApi(
             current_user=user,
-            session=self.session
+            session=self.session,
+            config=self.app_config,
         ).create_workspace('test workspace', save_now=True)
         api = ContentApi(
             current_user=user,
 
         # Refresh instances after commit
         user = uapi.get_one(uid)
-        workspace_api = WorkspaceApi(current_user=user, session=self.session)
+        workspace_api = WorkspaceApi(
+            current_user=user,
+            session=self.session,
+            config=self.app_config
+        )
         workspace = workspace_api.get_one(wid)
         api = ContentApi(
             current_user=user,
 
         # Refresh instances after commit
         user = uapi.get_one(uid)
-        workspace_api = WorkspaceApi(current_user=user, session=self.session)
+        workspace_api = WorkspaceApi(
+            current_user=user,
+            session=self.session,
+            config=self.app_config
+        )
         workspace = workspace_api.get_one(wid)
         api = ContentApi(
             current_user=user, 
         # Test that the item is still available if "show deleted" is activated
         # Refresh instances after commit
         user = uapi.get_one(uid)
-        workspace_api = WorkspaceApi(current_user=user, session=self.session)
+        workspace_api = WorkspaceApi(
+            current_user=user,
+            session=self.session,
+            config=self.app_config,
+        )
         api = ContentApi(
             current_user=user,
             session=self.session,
             config=self.app_config,
             current_user=None,
         )
-        group_api = GroupApi(current_user=None, session=self.session)
+        group_api = GroupApi(
+            current_user=None,
+            session=self.session,
+            config=self.app_config,
+        )
         groups = [group_api.get_one(Group.TIM_USER),
                   group_api.get_one(Group.TIM_MANAGER),
                   group_api.get_one(Group.TIM_ADMIN)]
 
         user = uapi.create_user(email='this.is@user',
                                 groups=groups, save_now=True)
-        workspace_api = WorkspaceApi(current_user=user, session=self.session)
+        workspace_api = WorkspaceApi(
+            current_user=user,
+            session=self.session,
+            config=self.app_config,
+        )
         workspace = workspace_api.create_workspace(
             'test workspace',
             save_now=True
         transaction.commit()
         # Refresh instances after commit
         user = uapi.get_one(uid)
-        workspace_api = WorkspaceApi(current_user=user, session=self.session)
+        workspace_api = WorkspaceApi(
+            current_user=user,
+            session=self.session,
+            config=self.app_config,
+        )
         api = ContentApi(
             session=self.session,
             current_user=user,
 
         # Refresh instances after commit
         user = uapi.get_one(uid)
-        workspace_api = WorkspaceApi(current_user=user, session=self.session)
+        workspace_api = WorkspaceApi(
+            current_user=user,
+            session=self.session,
+            config=self.app_config,
+        )
         workspace = workspace_api.get_one(wid)
         api = ContentApi(
             current_user=user, 
 
         # Refresh instances after commit
         user = uapi.get_one(uid)
-        workspace_api = WorkspaceApi(current_user=user, session=self.session)
+        workspace_api = WorkspaceApi(
+            current_user=user,
+            session=self.session,
+            config=self.app_config,
+        )
         workspace = workspace_api.get_one(wid)
         api = ContentApi(
             current_user=user,
             config=self.app_config,
             current_user=None,
         )
-        group_api = GroupApi(current_user=None, session=self.session)
+        group_api = GroupApi(
+            current_user=None,
+            session=self.session,
+            config=self.app_config,
+        )
         groups = [group_api.get_one(Group.TIM_USER),
                   group_api.get_one(Group.TIM_MANAGER),
                   group_api.get_one(Group.TIM_ADMIN)]
         )
         workspace = WorkspaceApi(
             current_user=user,
-            session=self.session
+            session=self.session,
+            config=self.app_config,
         ).create_workspace(
             'test workspace',
             save_now=True
 
         # Refresh instances after commit
         user = uapi.get_one(uid)
-        workspace_api = WorkspaceApi(current_user=user, session=self.session)
+        workspace_api = WorkspaceApi(
+            current_user=user,
+            session=self.session,
+            config=self.app_config,
+        )
         workspace = workspace_api.get_one(wid)
         api = ContentApi(
             current_user=user, 
             config=self.app_config,
             current_user=None,
         )
-        group_api = GroupApi(current_user=None, session=self.session)
+        group_api = GroupApi(
+            current_user=None,
+            session=self.session,
+            config=self.app_config
+        )
         groups = [group_api.get_one(Group.TIM_USER),
                   group_api.get_one(Group.TIM_MANAGER),
                   group_api.get_one(Group.TIM_ADMIN)]
                                 groups=groups, save_now=True)
         workspace = WorkspaceApi(
             current_user=user,
-            session=self.session
+            session=self.session,
+            config=self.app_config
         ).create_workspace('test workspace', save_now=True)
         api = ContentApi(
             current_user=user, 
 
         # Refresh instances after commit
         user = uapi.get_one(uid)
-        workspace_api = WorkspaceApi(current_user=user, session=self.session)
+        workspace_api = WorkspaceApi(
+            current_user=user,
+            session=self.session,
+            config=self.app_config,
+        )
         workspace = workspace_api.get_one(wid)
         api = ContentApi(
             current_user=user,
         )
         group_api = GroupApi(
             current_user=None,
-            session=self.session
+            session=self.session,
+            config=self.app_config,
         )
         groups = [group_api.get_one(Group.TIM_USER),
                   group_api.get_one(Group.TIM_MANAGER),
 
         workspace = WorkspaceApi(
             current_user=user,
-            session=self.session
+            session=self.session,
+            config=self.app_config,
         ).create_workspace(
             'test workspace',
             save_now=True
         )
         group_api = GroupApi(
             current_user=None,
-            session=self.session
+            session=self.session,
+            config=self.app_config,
         )
         groups = [group_api.get_one(Group.TIM_USER),
                   group_api.get_one(Group.TIM_MANAGER),
 
         workspace = WorkspaceApi(
             current_user=user,
-            session=self.session
+            session=self.session,
+            config=self.app_config,
         ).create_workspace(
             'test workspace',
             save_now=True
         )
         group_api = GroupApi(
             current_user=None,
-            session=self.session
+            session=self.session,
+            config=self.config,
         )
         groups = [group_api.get_one(Group.TIM_USER),
                   group_api.get_one(Group.TIM_MANAGER),
 
         workspace = WorkspaceApi(
             current_user=user,
-            session=self.session
+            session=self.session,
+            config=self.app_config,
         ).create_workspace(
             'test workspace',
             save_now=True
         )
         group_api = GroupApi(
             current_user=None,
-            session=self.session
+            session=self.session,
+            config=self.app_config
         )
         groups = [group_api.get_one(Group.TIM_USER),
                   group_api.get_one(Group.TIM_MANAGER),
         )
         workspace = WorkspaceApi(
             current_user=user,
-            session=self.session
+            session=self.session,
+            config=self.app_config,
         ).create_workspace(
             'test workspace',
             save_now=True
         )
-        RoleApi(current_user=user, session=self.session).create_one(
+        RoleApi(
+            current_user=user,
+            session=self.session,
+            config=self.app_config,
+        ).create_one(
             user2,
             workspace,
             UserRoleInWorkspace.WORKSPACE_MANAGER,
         workspace2 = WorkspaceApi(
             current_user=user2,
             session=self.session,
+            config=self.app_config,
         ).create_workspace(
             'test workspace2',
             save_now=True
         )
         group_api = GroupApi(
             current_user=None,
-            session=self.session
+            session=self.session,
+            config=self.app_config,
         )
         groups = [group_api.get_one(Group.TIM_USER),
                   group_api.get_one(Group.TIM_MANAGER),
         )
         workspace = WorkspaceApi(
             current_user=user,
-            session=self.session
+            session=self.session,
+            config=self.app_config,
         ).create_workspace(
             'test workspace',
             save_now=True
         )
-        RoleApi(current_user=user, session=self.session).create_one(
+        RoleApi(
+            current_user=user,
+            session=self.session,
+            config=self.app_config,
+        ).create_one(
             user2,
             workspace,
             UserRoleInWorkspace.WORKSPACE_MANAGER,
         )
         workspace2 = WorkspaceApi(
             current_user=user2,
-            session=self.session
+            session=self.session,
+            config=self.app_config,
         ).create_workspace(
             'test workspace2',
             save_now=True
         )
         group_api = GroupApi(
             current_user=None,
-            session=self.session
+            session=self.session,
+            config=self.app_config,
         )
         groups = [group_api.get_one(Group.TIM_USER),
                   group_api.get_one(Group.TIM_MANAGER),
         )
         workspace = WorkspaceApi(
             current_user=user,
-            session=self.session
+            session=self.session,
+            config=self.app_config,
         ).create_workspace(
             'test workspace',
             save_now=True
         )
-        RoleApi(current_user=user, session=self.session).create_one(
+        RoleApi(
+            current_user=user,
+            session=self.session,
+            config=self.app_config,
+        ).create_one(
             user2, workspace,
             UserRoleInWorkspace.WORKSPACE_MANAGER,
             with_notif=False
         )
         group_api = GroupApi(
             current_user=None,
-            session=self.session
+            session=self.session,
+            config=self.app_config,
         )
         groups = [group_api.get_one(Group.TIM_USER),
                   group_api.get_one(Group.TIM_MANAGER),
         wapi = WorkspaceApi(
             current_user=user_a,
             session=self.session,
+            config=self.app_config,
         )
         workspace1 = wapi.create_workspace(
             'test workspace n°1',
         role_api1 = RoleApi(
             current_user=user_a,
             session=self.session,
+            config=self.app_config,
         )
         role_api1.create_one(
             user_b,
         role_api2 = RoleApi(
             current_user=user_b,
             session=self.session,
+            config=self.app_config,
         )
         role_api2.create_one(user_b, workspace2, UserRoleInWorkspace.READER,
                              False)
         )
         group_api = GroupApi(
             current_user=None,
-            session=self.session
+            session=self.session,
+            config = self.app_config,
         )
         groups = [group_api.get_one(Group.TIM_USER),
                   group_api.get_one(Group.TIM_MANAGER),
             save_now=True
         )
 
-        wapi = WorkspaceApi(current_user=user_a, session=self.session)
+        wapi = WorkspaceApi(
+            current_user=user_a,
+            session=self.session,
+            config=self.app_config,
+        )
         workspace_api = WorkspaceApi(
             current_user=user_a,
-            session=self.session
+            session=self.session,
+            config=self.app_config,
         )
         workspace = wapi.create_workspace(
             'test workspace',
         role_api = RoleApi(
             current_user=user_a,
             session=self.session,
+            config=self.app_config,
         )
         role_api.create_one(
             user_b,
             config=self.app_config,
             current_user=None,
         )
-        group_api = GroupApi(current_user=None, session=self.session)
+        group_api = GroupApi(
+            current_user=None,
+            session=self.session,
+            config=self.app_config,
+        )
         groups = [group_api.get_one(Group.TIM_USER),
                   group_api.get_one(Group.TIM_MANAGER),
                   group_api.get_one(Group.TIM_ADMIN)]
         wapi = WorkspaceApi(
             current_user=user_a,
             session=self.session,
+            config=self.app_config,
         )
         workspace = wapi.create_workspace(
             'test workspace',
         role_api = RoleApi(
             current_user=user_a,
             session=self.session,
+            config=self.app_config,
         )
         role_api.create_one(
             user_b,
             config=self.app_config,
             current_user=None,
         )
-        group_api = GroupApi(current_user=None, session=self.session)
+        group_api = GroupApi(
+            current_user=None,
+            session=self.session,
+            config=self.app_config,
+        )
         groups = [group_api.get_one(Group.TIM_USER),
                   group_api.get_one(Group.TIM_MANAGER),
                   group_api.get_one(Group.TIM_ADMIN)]
             save_now=True
         )
 
-        workspace_api = WorkspaceApi(current_user=user1, session=self.session)
+        workspace_api = WorkspaceApi(
+            current_user=user1,
+            session=self.session,
+            config=self.app_config,
+        )
         workspace = workspace_api.create_workspace(
             'test workspace',
             save_now=True
 
         RoleApi(
             current_user=user1,
-            session=self.session
+            session=self.session,
+            config=self.app_config,
         ).create_one(
             user2,
             workspace,
         user1 = uapi.get_one(u1id)
         workspace = WorkspaceApi(
             current_user=user1,
-            session=self.session
+            session=self.session,
+            config=self.app_config,
         ).get_one(wid)
         api = ContentApi(
             current_user=user1,
         workspace = WorkspaceApi(
             current_user=user1,
             session=self.session,
+            config=self.app_config,
         ).get_one(wid)
         api = ContentApi(
             current_user=user1,
         )
         group_api = GroupApi(
             current_user=None,
-            session=self.session
+            session=self.session,
+            config = self.app_config,
         )
         groups = [group_api.get_one(Group.TIM_USER),
                   group_api.get_one(Group.TIM_MANAGER),
         workspace = WorkspaceApi(
             current_user=user1,
             session=self.session,
+            config=self.app_config,
         ).create_workspace(
             'test workspace',
             save_now=True
 
         RoleApi(
             current_user=user1,
-            session=self.session
+            session=self.session,
+            config=self.app_config,
         ).create_one(
             user2,
             workspace,
         )
         group_api = GroupApi(
             current_user=None,
-            session=self.session
+            session=self.session,
+            config=self.app_config,
         )
         groups = [group_api.get_one(Group.TIM_USER),
                   group_api.get_one(Group.TIM_MANAGER),
             save_now=True
         )
 
-        workspace_api = WorkspaceApi(current_user=user1, session=self.session)
+        workspace_api = WorkspaceApi(
+            current_user=user1,
+            session=self.session,
+            config=self.app_config,
+        )
         workspace = workspace_api.create_workspace(
             'test workspace',
             save_now=True
         RoleApi(
             current_user=user1,
             session=self.session,
+            config=self.app_config,
         ).create_one(
             user2,
             workspace,
 
         # Refresh instances after commit
         user1 = uapi.get_one(u1id)
-        workspace_api2 = WorkspaceApi(current_user=user1, session=self.session)
+        workspace_api2 = WorkspaceApi(
+            current_user=user1,
+            session=self.session,
+            config=self.app_config,
+        )
         workspace = workspace_api2.get_one(wid)
         api = ContentApi(
             current_user=user1,
         workspace = WorkspaceApi(
             current_user=user1,
             session=self.session,
+            config=self.app_config,
         ).get_one(wid)
 
         updated = api.get_one(pcid, ContentType.Any, workspace)
         group_api = GroupApi(
             current_user=None,
             session=self.session,
+            config=self.app_config,
         )
         groups = [group_api.get_one(Group.TIM_USER),
                   group_api.get_one(Group.TIM_MANAGER),
             save_now=True,
         )
 
-        workspace_api = WorkspaceApi(current_user=user1, session=self.session)
+        workspace_api = WorkspaceApi(
+            current_user=user1,
+            session=self.session,
+            config=self.app_config,
+        )
         workspace = workspace_api.create_workspace(
             'test workspace',
             save_now=True
         RoleApi(
             current_user=user1,
             session=self.session,
+            config=self.app_config,
         ).create_one(
             user2,
             workspace,
             config=self.app_config,
             current_user=None,
         )
-        group_api = GroupApi(current_user=None, session=self.session)
+        group_api = GroupApi(
+            current_user=None,
+            session=self.session,
+            config=self.app_config,
+        )
         groups = [group_api.get_one(Group.TIM_USER),
                   group_api.get_one(Group.TIM_MANAGER),
                   group_api.get_one(Group.TIM_ADMIN)]
         )
         u1id = user1.user_id
 
-        workspace_api = WorkspaceApi(current_user=user1, session=self.session)
+        workspace_api = WorkspaceApi(
+            current_user=user1,
+            session=self.session,
+            config=self.app_config,
+        )
         workspace = workspace_api.create_workspace(
             'test workspace',
             save_now=True
 
         RoleApi(
             current_user=user1,
-            session=self.session
+            session=self.session,
+            config=self.app_config,
         ).create_one(
             user2,
             workspace,
         ).get_one(u1id)
         workspace = WorkspaceApi(
             current_user=user1,
-            session=self.session
+            session=self.session,
+            config=self.app_config,
         ).get_one(wid)
 
         content = api.get_one(pcid, ContentType.Any, workspace)
         workspace = WorkspaceApi(
             current_user=user1,
             session=self.session,
+            config=self.app_config,
         ).get_one(wid)
         u2 = UserApi(
             current_user=None,
         )
         group_api = GroupApi(
             current_user=None,
-            session=self.session
+            session=self.session,
+            config=self.app_config,
         )
         groups = [group_api.get_one(Group.TIM_USER),
                   group_api.get_one(Group.TIM_MANAGER),
         )
         u1id = user1.user_id
 
-        workspace_api = WorkspaceApi(current_user=user1, session=self.session)
+        workspace_api = WorkspaceApi(
+            current_user=user1,
+            session=self.session,
+            config=self.app_config,
+        )
         workspace = workspace_api.create_workspace(
             'test workspace',
             save_now=True
 
         RoleApi(
             current_user=user1,
-            session=self.session
+            session=self.session,
+            config=self.app_config,
         ).create_one(
             user2,
             workspace,
         workspace = WorkspaceApi(
             current_user=user1,
             session=self.session,
+            config=self.app_config,
         ).get_one(wid)
 
         content = api.get_one(pcid, ContentType.Any, workspace)
         workspace = WorkspaceApi(
             current_user=user1,
             session=self.session,
+            config=self.app_config,
         ).get_one(wid)
         # show archived is used at the top end of the test
         api = ContentApi(
         group_api = GroupApi(
             current_user=None,
             session=self.session,
+            config=self.app_config,
         )
         groups = [group_api.get_one(Group.TIM_USER),
                   group_api.get_one(Group.TIM_MANAGER),
 
         workspace = WorkspaceApi(
             current_user=user,
-            session=self.session
+            session=self.session,
+            config=self.app_config,
         ).create_workspace(
             'test workspace',
             save_now=True
             current_user=user, 
             session=self.session,
             config=self.app_config,
-
         )
         a = api.create(ContentType.Folder, workspace, None,
                        'this is randomized folder', True)
         group_api = GroupApi(
             current_user=None,
             session=self.session,
+            config=self.app_config,
         )
         groups = [group_api.get_one(Group.TIM_USER),
                   group_api.get_one(Group.TIM_MANAGER),
 
         workspace = WorkspaceApi(
             current_user=user,
-            session=self.session
+            session=self.session,
+            config=self.app_config,
         ).create_workspace(
             'test workspace',
             save_now=True,
             config=self.app_config,
             current_user=None,
         )
-        group_api = GroupApi(current_user=None, session=self.session)
+        group_api = GroupApi(
+            current_user=None,
+            session=self.session,
+            config=self.app_config,
+        )
         groups = [group_api.get_one(Group.TIM_USER),
                   group_api.get_one(Group.TIM_MANAGER),
                   group_api.get_one(Group.TIM_ADMIN)]
 
         workspace = WorkspaceApi(
             current_user=user,
-            session=self.session
+            session=self.session,
+            config=self.app_config,
         ).create_workspace('test workspace', save_now=True)
 
         api = ContentApi(
         bob_workspace = WorkspaceApi(
             current_user=bob,
             session=self.session,
+            config=self.app_config,
         ).create_workspace(
             'bob_workspace',
             save_now=True,
         admin_workspace = WorkspaceApi(
             current_user=admin,
             session=self.session,
+            config=self.app_config,
         ).create_workspace(
             'admin_workspace',
             save_now=True,

tracim/tests/library/test_workspace.py

             .filter(User.email == 'admin@admin.admin').one()
         wapi = WorkspaceApi(
             session=self.session,
+            config=self.app_config,
             current_user=admin,
         )
         w = wapi.create_workspace(label='workspace w', save_now=True)
         rapi = RoleApi(
             session=self.session,
             current_user=admin,
+            config=self.app_config,
         )
         r = rapi.create_one(u, w, UserRoleInWorkspace.READER, with_notif=True)
         eq_([r, ], wapi.get_notifiable_roles(workspace=w))
         wapi = WorkspaceApi(
             session=self.session,
             current_user=admin,
+            config=self.app_config,
         )
         eq_([], wapi.get_all_manageable())
         # Checks an admin gets all workspaces.
         gapi = GroupApi(
             session=self.session,
             current_user=None,
+            config=self.app_config,
         )
         u = uapi.create_user('u.s@e.r', [gapi.get_one(Group.TIM_USER)], True)
         wapi = WorkspaceApi(
             session=self.session,
-            current_user=u
+            current_user=u,
+            config=self.app_config,
         )
         rapi = RoleApi(
             session=self.session,
-            current_user=u
+            current_user=u,
+            config=self.app_config,
         )
         rapi.create_one(u, w4, UserRoleInWorkspace.READER, False)
         rapi.create_one(u, w3, UserRoleInWorkspace.CONTRIBUTOR, False)

tracim/views/core_api/user_controller.py

         wapi = WorkspaceApi(
             current_user=request.current_user,  # User
             session=request.dbsession,
+            config=app_config,
         )
         # TODO - G.M - 22-05-2018 - Refactor this in a more lib way( avoid
         # try/catch and complex code here).

tracim/views/core_api/workspace_controller.py

+import typing
+
 from pyramid.config import Configurator
 from sqlalchemy.orm.exc import NoResultFound
 
     @hapic.output_body(WorkspaceSchema())
     def workspace(self, context, request: TracimRequest, hapic_data=None):
         """
-        Get workspace information
+        Get workspace informations
         """
         wid = hapic_data.path['workspace_id']
         app_config = request.registry.settings['CFG']
         wapi = WorkspaceApi(
             current_user=request.current_user,  # User
             session=request.dbsession,
+            config=app_config,
         )
         # TODO - G.M - 22-05-2018 - Refactor this in a more lib way( avoid
         # try/catch and complex code here).
             workspace = wapi.get_one(wid)
         except NoResultFound:
             raise WorkspaceNotFound()
-        return WorkspaceInContext(workspace, request.dbsession, app_config)
+        return wapi.get_workspace_with_context(workspace)
 
     @hapic.with_api_doc()
     @hapic.input_path(WorkspaceIdPathSchema())
             context,
             request: TracimRequest,
             hapic_data=None
-    ) -> None:
+    ) -> typing.List[UserRoleWorkspaceInContext]:
+        """
+        Get Members of this workspace
+        """
         wid = hapic_data.path['workspace_id']
         app_config = request.registry.settings['CFG']
         rapi = RoleApi(
             current_user=request.current_user,
             session=request.dbsession,
+            config=app_config,
         )
         wapi = WorkspaceApi(
             current_user=request.current_user,
             session=request.dbsession,
+            config=app_config,
         )
         try:
             wapi.get_one(wid)
         except NoResultFound:
             raise WorkspaceNotFound()
         return [
-            UserRoleWorkspaceInContext(
-                user_role,
-                request.dbsession,
-                app_config
-            )
+            rapi.get_user_role_workspace_with_context(user_role)
             for user_role in rapi.get_all_for_workspace(wid)
         ]
 
         configurator.add_route('workspace', '/workspaces/{workspace_id}', request_method='GET')  # nopep8
         configurator.add_view(self.workspace, route_name='workspace')
         configurator.add_route('workspace_members', '/workspaces/{workspace_id}/members', request_method='GET')  # nopep8
-        configurator.add_view(self.workspaces_members, route_name='workspace_members')
+        configurator.add_view(self.workspaces_members, route_name='workspace_members')  # nopep8