|  | @@ -1,11 +1,7 @@
 | 
	
		
			
			| 1 | 1 |  # -*- coding: utf-8 -*-
 | 
	
		
			
			| 2 |  | -"""
 | 
	
		
			
			| 3 |  | -TracimRequest and related functions
 | 
	
		
			
			| 4 |  | -"""
 | 
	
		
			
			| 5 | 2 |  from pyramid.request import Request
 | 
	
		
			
			| 6 | 3 |  from sqlalchemy.orm.exc import NoResultFound
 | 
	
		
			
			| 7 | 4 |  
 | 
	
		
			
			| 8 |  | -
 | 
	
		
			
			| 9 | 5 |  from tracim.exceptions import NotAuthenticated
 | 
	
		
			
			| 10 | 6 |  from tracim.exceptions import UserNotFoundInTracimRequest
 | 
	
		
			
			| 11 | 7 |  from tracim.exceptions import UserDoesNotExist
 | 
	
	
		
			
			|  | @@ -46,7 +42,7 @@ class TracimRequest(Request):
 | 
	
		
			
			| 46 | 42 |  
 | 
	
		
			
			| 47 | 43 |          # User found from request headers, content, distinct from authenticated
 | 
	
		
			
			| 48 | 44 |          # user
 | 
	
		
			
			| 49 |  | -        self._user_candidate = None  # type: User
 | 
	
		
			
			|  | 45 | +        self._candidate_user = None  # type: User
 | 
	
		
			
			| 50 | 46 |  
 | 
	
		
			
			| 51 | 47 |          # INFO - G.M - 18-05-2018 - Close db at the end of the request
 | 
	
		
			
			| 52 | 48 |          self.add_finished_callback(self._cleanup)
 | 
	
	
		
			
			|  | @@ -60,7 +56,7 @@ class TracimRequest(Request):
 | 
	
		
			
			| 60 | 56 |          :return: Workspace of the request
 | 
	
		
			
			| 61 | 57 |          """
 | 
	
		
			
			| 62 | 58 |          if self._current_workspace is None:
 | 
	
		
			
			| 63 |  | -            self.current_workspace = get_workspace(self.current_user, self)
 | 
	
		
			
			|  | 59 | +            self.current_workspace = self._get_workspace(self.current_user, self)
 | 
	
		
			
			| 64 | 60 |          return self._current_workspace
 | 
	
		
			
			| 65 | 61 |  
 | 
	
		
			
			| 66 | 62 |      @current_workspace.setter
 | 
	
	
		
			
			|  | @@ -82,7 +78,7 @@ class TracimRequest(Request):
 | 
	
		
			
			| 82 | 78 |          Get user from authentication mecanism.
 | 
	
		
			
			| 83 | 79 |          """
 | 
	
		
			
			| 84 | 80 |          if self._current_user is None:
 | 
	
		
			
			| 85 |  | -            self.current_user = get_auth_safe_user(self)
 | 
	
		
			
			|  | 81 | +            self.current_user = self._get_auth_safe_user(self)
 | 
	
		
			
			| 86 | 82 |          return self._current_user
 | 
	
		
			
			| 87 | 83 |  
 | 
	
		
			
			| 88 | 84 |      @current_user.setter
 | 
	
	
		
			
			|  | @@ -102,9 +98,9 @@ class TracimRequest(Request):
 | 
	
		
			
			| 102 | 98 |          can help user to know about who one page is about in
 | 
	
		
			
			| 103 | 99 |          a similar way as current_workspace.
 | 
	
		
			
			| 104 | 100 |          """
 | 
	
		
			
			| 105 |  | -        if self._user_candidate is None:
 | 
	
		
			
			| 106 |  | -            self.candidate_user = get_candidate_user(self)
 | 
	
		
			
			| 107 |  | -        return self._user_candidate
 | 
	
		
			
			|  | 101 | +        if self._candidate_user is None:
 | 
	
		
			
			|  | 102 | +            self.candidate_user = self._get_candidate_user(self)
 | 
	
		
			
			|  | 103 | +        return self._candidate_user
 | 
	
		
			
			| 108 | 104 |  
 | 
	
		
			
			| 109 | 105 |      def _cleanup(self, request: 'TracimRequest') -> None:
 | 
	
		
			
			| 110 | 106 |          """
 | 
	
	
		
			
			|  | @@ -122,86 +118,87 @@ class TracimRequest(Request):
 | 
	
		
			
			| 122 | 118 |  
 | 
	
		
			
			| 123 | 119 |      @candidate_user.setter
 | 
	
		
			
			| 124 | 120 |      def candidate_user(self, user: User) -> None:
 | 
	
		
			
			| 125 |  | -        if self._user_candidate is not None:
 | 
	
		
			
			|  | 121 | +        if self._candidate_user is not None:
 | 
	
		
			
			| 126 | 122 |              raise ImmutableAttribute(
 | 
	
		
			
			| 127 | 123 |                  "Can't modify already setted candidate_user"
 | 
	
		
			
			| 128 | 124 |              )
 | 
	
		
			
			| 129 |  | -        self._user_candidate = user
 | 
	
		
			
			| 130 |  | -###
 | 
	
		
			
			| 131 |  | -# Utils for TracimRequest
 | 
	
		
			
			| 132 |  | -###
 | 
	
		
			
			|  | 125 | +        self._candidate_user = user
 | 
	
		
			
			| 133 | 126 |  
 | 
	
		
			
			|  | 127 | +    ###
 | 
	
		
			
			|  | 128 | +    # Utils for TracimRequest
 | 
	
		
			
			|  | 129 | +    ###
 | 
	
		
			
			| 134 | 130 |  
 | 
	
		
			
			| 135 |  | -def get_candidate_user(
 | 
	
		
			
			| 136 |  | -        request: TracimRequest
 | 
	
		
			
			| 137 |  | -) -> User:
 | 
	
		
			
			| 138 |  | -    """
 | 
	
		
			
			| 139 |  | -    Get candidate user
 | 
	
		
			
			| 140 |  | -    :param request: pyramid request
 | 
	
		
			
			| 141 |  | -    :return: user found from header/body
 | 
	
		
			
			| 142 |  | -    """
 | 
	
		
			
			| 143 |  | -    app_config = request.registry.settings['CFG']
 | 
	
		
			
			| 144 |  | -    uapi = UserApi(None, session=request.dbsession, config=app_config)
 | 
	
		
			
			| 145 |  | -
 | 
	
		
			
			| 146 |  | -    try:
 | 
	
		
			
			| 147 |  | -        login = None
 | 
	
		
			
			| 148 |  | -        if 'user_id' in request.matchdict:
 | 
	
		
			
			| 149 |  | -            login = request.matchdict['user_id']
 | 
	
		
			
			| 150 |  | -        if not login:
 | 
	
		
			
			| 151 |  | -            raise UserNotFoundInTracimRequest('You request a candidate user but the context not permit to found one')  # nopep8
 | 
	
		
			
			| 152 |  | -        user = uapi.get_one(login)
 | 
	
		
			
			| 153 |  | -    except UserNotFoundInTracimRequest as exc:
 | 
	
		
			
			| 154 |  | -        raise UserDoesNotExist('User {} not found'.format(login)) from exc
 | 
	
		
			
			| 155 |  | -    return user
 | 
	
		
			
			| 156 |  | -
 | 
	
		
			
			| 157 |  | -
 | 
	
		
			
			| 158 |  | -def get_auth_safe_user(
 | 
	
		
			
			| 159 |  | -        request: TracimRequest,
 | 
	
		
			
			| 160 |  | -) -> User:
 | 
	
		
			
			| 161 |  | -    """
 | 
	
		
			
			| 162 |  | -    Get current pyramid authenticated user from request
 | 
	
		
			
			| 163 |  | -    :param request: pyramid request
 | 
	
		
			
			| 164 |  | -    :return: current authenticated user
 | 
	
		
			
			| 165 |  | -    """
 | 
	
		
			
			| 166 |  | -    app_config = request.registry.settings['CFG']
 | 
	
		
			
			| 167 |  | -    uapi = UserApi(None, session=request.dbsession, config=app_config)
 | 
	
		
			
			| 168 |  | -    try:
 | 
	
		
			
			| 169 |  | -        login = request.authenticated_userid
 | 
	
		
			
			| 170 |  | -        if not login:
 | 
	
		
			
			| 171 |  | -            raise UserNotFoundInTracimRequest('You request a current user but the context not permit to found one')  # nopep8
 | 
	
		
			
			| 172 |  | -        user = uapi.get_one_by_email(login)
 | 
	
		
			
			| 173 |  | -    except (UserDoesNotExist, UserNotFoundInTracimRequest) as exc:
 | 
	
		
			
			| 174 |  | -        raise NotAuthenticated('User {} not found'.format(login)) from exc
 | 
	
		
			
			| 175 |  | -    return user
 | 
	
		
			
			| 176 |  | -
 | 
	
		
			
			| 177 |  | -
 | 
	
		
			
			| 178 |  | -def get_workspace(
 | 
	
		
			
			| 179 |  | -        user: User,
 | 
	
		
			
			| 180 |  | -        request: TracimRequest
 | 
	
		
			
			| 181 |  | -) -> Workspace:
 | 
	
		
			
			| 182 |  | -    """
 | 
	
		
			
			| 183 |  | -    Get current workspace from request
 | 
	
		
			
			| 184 |  | -    :param user: User who want to check the workspace
 | 
	
		
			
			| 185 |  | -    :param request: pyramid request
 | 
	
		
			
			| 186 |  | -    :return: current workspace
 | 
	
		
			
			| 187 |  | -    """
 | 
	
		
			
			| 188 |  | -    workspace_id = ''
 | 
	
		
			
			| 189 |  | -    try:
 | 
	
		
			
			| 190 |  | -        if 'workspace_id' in request.matchdict:
 | 
	
		
			
			| 191 |  | -            workspace_id = request.matchdict['workspace_id']
 | 
	
		
			
			| 192 |  | -        if not workspace_id:
 | 
	
		
			
			| 193 |  | -            raise WorkspaceNotFound('No workspace_id property found in request')
 | 
	
		
			
			| 194 |  | -        wapi = WorkspaceApi(
 | 
	
		
			
			| 195 |  | -            current_user=user,
 | 
	
		
			
			| 196 |  | -            session=request.dbsession,
 | 
	
		
			
			| 197 |  | -            config=request.registry.settings['CFG']
 | 
	
		
			
			| 198 |  | -        )
 | 
	
		
			
			| 199 |  | -        workspace = wapi.get_one(workspace_id)
 | 
	
		
			
			| 200 |  | -    except JSONDecodeError:
 | 
	
		
			
			| 201 |  | -        raise WorkspaceNotFound('Bad json body')
 | 
	
		
			
			| 202 |  | -    except NoResultFound:
 | 
	
		
			
			| 203 |  | -        raise WorkspaceNotFound(
 | 
	
		
			
			| 204 |  | -            'Workspace {} does not exist '
 | 
	
		
			
			| 205 |  | -            'or is not visible for this user'.format(workspace_id)
 | 
	
		
			
			| 206 |  | -        )
 | 
	
		
			
			| 207 |  | -    return workspace
 | 
	
		
			
			|  | 131 | +    def _get_candidate_user(
 | 
	
		
			
			|  | 132 | +            self,
 | 
	
		
			
			|  | 133 | +            request: 'TracimRequest',
 | 
	
		
			
			|  | 134 | +    ) -> User:
 | 
	
		
			
			|  | 135 | +        """
 | 
	
		
			
			|  | 136 | +        Get candidate user
 | 
	
		
			
			|  | 137 | +        :param request: pyramid request
 | 
	
		
			
			|  | 138 | +        :return: user found from header/body
 | 
	
		
			
			|  | 139 | +        """
 | 
	
		
			
			|  | 140 | +        app_config = request.registry.settings['CFG']
 | 
	
		
			
			|  | 141 | +        uapi = UserApi(None, session=request.dbsession, config=app_config)
 | 
	
		
			
			|  | 142 | +
 | 
	
		
			
			|  | 143 | +        try:
 | 
	
		
			
			|  | 144 | +            login = None
 | 
	
		
			
			|  | 145 | +            if 'user_id' in request.matchdict:
 | 
	
		
			
			|  | 146 | +                login = request.matchdict['user_id']
 | 
	
		
			
			|  | 147 | +            if not login:
 | 
	
		
			
			|  | 148 | +                raise UserNotFoundInTracimRequest('You request a candidate user but the context not permit to found one')  # nopep8
 | 
	
		
			
			|  | 149 | +            user = uapi.get_one(login)
 | 
	
		
			
			|  | 150 | +        except UserNotFoundInTracimRequest as exc:
 | 
	
		
			
			|  | 151 | +            raise UserDoesNotExist('User {} not found'.format(login)) from exc
 | 
	
		
			
			|  | 152 | +        return user
 | 
	
		
			
			|  | 153 | +
 | 
	
		
			
			|  | 154 | +    def _get_auth_safe_user(
 | 
	
		
			
			|  | 155 | +            self,
 | 
	
		
			
			|  | 156 | +            request: 'TracimRequest',
 | 
	
		
			
			|  | 157 | +    ) -> User:
 | 
	
		
			
			|  | 158 | +        """
 | 
	
		
			
			|  | 159 | +        Get current pyramid authenticated user from request
 | 
	
		
			
			|  | 160 | +        :param request: pyramid request
 | 
	
		
			
			|  | 161 | +        :return: current authenticated user
 | 
	
		
			
			|  | 162 | +        """
 | 
	
		
			
			|  | 163 | +        app_config = request.registry.settings['CFG']
 | 
	
		
			
			|  | 164 | +        uapi = UserApi(None, session=request.dbsession, config=app_config)
 | 
	
		
			
			|  | 165 | +        try:
 | 
	
		
			
			|  | 166 | +            login = request.authenticated_userid
 | 
	
		
			
			|  | 167 | +            if not login:
 | 
	
		
			
			|  | 168 | +                raise UserNotFoundInTracimRequest('You request a current user but the context not permit to found one')  # nopep8
 | 
	
		
			
			|  | 169 | +            user = uapi.get_one_by_email(login)
 | 
	
		
			
			|  | 170 | +        except (UserDoesNotExist, UserNotFoundInTracimRequest) as exc:
 | 
	
		
			
			|  | 171 | +            raise NotAuthenticated('User {} not found'.format(login)) from exc
 | 
	
		
			
			|  | 172 | +        return user
 | 
	
		
			
			|  | 173 | +
 | 
	
		
			
			|  | 174 | +    def _get_workspace(
 | 
	
		
			
			|  | 175 | +            self,
 | 
	
		
			
			|  | 176 | +            user: User,
 | 
	
		
			
			|  | 177 | +            request: 'TracimRequest'
 | 
	
		
			
			|  | 178 | +    ) -> Workspace:
 | 
	
		
			
			|  | 179 | +        """
 | 
	
		
			
			|  | 180 | +        Get current workspace from request
 | 
	
		
			
			|  | 181 | +        :param user: User who want to check the workspace
 | 
	
		
			
			|  | 182 | +        :param request: pyramid request
 | 
	
		
			
			|  | 183 | +        :return: current workspace
 | 
	
		
			
			|  | 184 | +        """
 | 
	
		
			
			|  | 185 | +        workspace_id = ''
 | 
	
		
			
			|  | 186 | +        try:
 | 
	
		
			
			|  | 187 | +            if 'workspace_id' in request.matchdict:
 | 
	
		
			
			|  | 188 | +                workspace_id = request.matchdict['workspace_id']
 | 
	
		
			
			|  | 189 | +            if not workspace_id:
 | 
	
		
			
			|  | 190 | +                raise WorkspaceNotFound('No workspace_id property found in request')
 | 
	
		
			
			|  | 191 | +            wapi = WorkspaceApi(
 | 
	
		
			
			|  | 192 | +                current_user=user,
 | 
	
		
			
			|  | 193 | +                session=request.dbsession,
 | 
	
		
			
			|  | 194 | +                config=request.registry.settings['CFG']
 | 
	
		
			
			|  | 195 | +            )
 | 
	
		
			
			|  | 196 | +            workspace = wapi.get_one(workspace_id)
 | 
	
		
			
			|  | 197 | +        except JSONDecodeError:
 | 
	
		
			
			|  | 198 | +            raise WorkspaceNotFound('Bad json body')
 | 
	
		
			
			|  | 199 | +        except NoResultFound:
 | 
	
		
			
			|  | 200 | +            raise WorkspaceNotFound(
 | 
	
		
			
			|  | 201 | +                'Workspace {} does not exist '
 | 
	
		
			
			|  | 202 | +                'or is not visible for this user'.format(workspace_id)
 | 
	
		
			
			|  | 203 | +            )
 | 
	
		
			
			|  | 204 | +        return workspace
 |