create user when creating role to an unexisting user

tracim/exceptions.py

 
 class RoleDoesNotExist(TracimException):
     pass
+
+
+class EmailValidationFailed(TracimException):
+    pass
+
+
+class UserCreationFailed(TracimException):
+    pass

tracim/lib/core/user.py

 import transaction
 import typing as typing
 
-from tracim.exceptions import NotificationNotSend
+from tracim.exceptions import NotificationNotSend, EmailValidationFailed
 from tracim.lib.mail_notifier.notifier import get_email_manager
 from sqlalchemy.orm import Session
 
 from tracim.exceptions import WrongUserPassword
 from tracim.exceptions import AuthenticationFailed
 from tracim.models.context_models import UserInContext
+from tracim.models.context_models import TypeUser
 
 
 class UserApi(object):
     def get_all(self) -> typing.Iterable[User]:
         return self._session.query(User).order_by(User.display_name).all()
 
-    def find_one(self, user_email_or_public_name: str) -> User:
+    def find(
+            self,
+            user_id: int=None,
+            email: str=None,
+            public_name: str=None
+    ) -> typing.Tuple[TypeUser, User]:
+        """
+        Find existing user from all theses params.
+        Check is made in this order: user_id, email, public_name
+        If no user found raise UserDoesNotExist exception
+        """
         user = None
-        try:
-            user = self.get_one_by_email(email=user_email_or_public_name)
-        except UserDoesNotExist:
-            # INFO - G.M - 2018-07-183 - we discard this exception in order
-            # allow secondary check (public_name)
-            pass
 
-        if not user:
-            user = self.get_one_by_public_name(user_email_or_public_name)
+        if user_id:
+            try:
+                user = self.get_one(user_id)
+                return TypeUser.USER_ID, user
+            except UserDoesNotExist:
+                pass
+        if email:
+            try:
+                user = self.get_one_by_email(email)
+                return TypeUser.EMAIL, user
+            except UserDoesNotExist:
+                pass
+        if public_name:
+            try:
+                user = self.get_one_by_public_name(public_name)
+                return TypeUser.PUBLIC_NAME, user
+            except UserDoesNotExist:
+                pass
+
+        raise UserDoesNotExist('User not found with any of given params.')
 
-        return user
     # Check methods
 
     def user_with_email_exists(self, email: str) -> bool:
 
     # Actions
 
+    def _check_email(self, email: str) -> bool:
+        # TODO - G.M - 2018-07-05 - find a better way to check email
+        if not email:
+            return False
+        email = email.split('@')
+        if len(email) != 2:
+            return False
+        return True
+
     def update(
             self,
             user: User,
             user.display_name = name
 
         if email is not None:
+            email_exist = self._check_email(email)
+            if not email_exist:
+                raise EmailValidationFailed('Email given form {} is uncorrect'.format(email))  # nopep8
             user.email = email
 
         if password is not None:
         """Previous create_user method"""
         user = User()
 
+        email_exist = self._check_email(email)
+        if not email_exist:
+            raise EmailValidationFailed('Email given form {} is uncorrect'.format(email))  # nopep8
         user.email = email
+        user.display_name = email.split('@')[0]
 
         for group in groups:
             user.groups.append(group)

tracim/models/context_models.py

 # coding=utf-8
 import typing
 from datetime import datetime
+from enum import Enum
 
 from slugify import slugify
 from sqlalchemy.orm import Session
         self.raw_content = raw_content
 
 
+class TypeUser(Enum):
+    """Params used to find user"""
+    USER_ID = 'found_id'
+    EMAIL = 'found_email'
+    PUBLIC_NAME = 'found_public_name'
+
+
 class UserInContext(object):
     """
     Interface to get User data and User data related to context.

tracim/tests/__init__.py

             'depot_storage_dir': '/tmp/test/depot',
             'depot_storage_name': 'test',
             'preview_cache_dir': '/tmp/test/preview_cache',
+            'email.notification.activated': 'false',
 
         }
         hapic.reset_context()

tracim/tests/functional/test_workspaces.py

             params=params,
         )
 
-    def test_api__create_workspace_member_role__err_400__wrong_user_email_or_public_name(self):  # nopep8
+    def test_api__create_workspace_member_role__ok_200__new_user(self):  # nopep8
         """
         Create workspace member role
         :return:
         }
         res = self.testapp.post_json(
             '/api/v2/workspaces/1/members',
-            status=400,
+            status=200,
             params=params,
         )
 

tracim/tests/library/test_user_api.py

         )
         u = api.create_minimal_user('bob@bob')
         assert u.email == 'bob@bob'
-        assert u.display_name is None
+        assert u.display_name == 'bob'
 
     def test_unit__create_minimal_user_and_update__ok__nominal_case(self):
         api = UserApi(

tracim/views/core_api/workspace_controller.py

 from tracim.models.context_models import UserRoleWorkspaceInContext
 from tracim.models.context_models import ContentInContext
 from tracim.exceptions import EmptyLabelNotAllowed
+from tracim.exceptions import EmailValidationFailed
+from tracim.exceptions import UserCreationFailed
 from tracim.exceptions import UserDoesNotExist
 from tracim.exceptions import WorkspacesDoNotMatch
 from tracim.views.controllers import Controller
         return rapi.get_user_role_workspace_with_context(role)
 
     @hapic.with_api_doc(tags=[WORKSPACE_ENDPOINTS_TAG])
+    @hapic.handle_exception(UserCreationFailed, HTTPStatus.BAD_REQUEST)
     @require_workspace_role(UserRoleInWorkspace.WORKSPACE_MANAGER)
     @hapic.input_path(WorkspaceIdPathSchema())
     @hapic.input_body(WorkspaceMemberInviteSchema())
             session=request.dbsession,
             config=app_config,
         )
-        if hapic_data.body.user_id is not None:
-            user = uapi.get_one(user_id=hapic_data.body.user_id)
-        elif hapic_data.body.user_email_or_public_name:
-            user = uapi.find_one(
-                user_email_or_public_name=hapic_data.body.user_email_or_public_name  # nopep8
-            )
-        else:
-            raise UserDoesNotExist(
-                'user_id or user_email_or_public_name should have '
-                'valid value.'
+        try:
+            _, user = uapi.find(
+                user_id=hapic_data.body.user_id,
+                email=hapic_data.body.user_email_or_public_name,
+                public_name=hapic_data.body.user_email_or_public_name
             )
+        except UserDoesNotExist:
+            try:
+                # TODO - G.M - 2018-07-05 - [UserCreation] Reenable email
+                # notification for creation
+                user = uapi.create_user(
+                    hapic_data.body.user_email_or_public_name,
+                    do_notify=False
+                )  # nopep8
+            except EmailValidationFailed:
+                raise UserCreationFailed('no valid mail given')
         role = rapi.create_one(
             user=user,
             workspace=request.current_workspace,