diff --git a/server/core/hep_client.py b/server/core/hep_client.py index 72e98d49..b5546a43 100644 --- a/server/core/hep_client.py +++ b/server/core/hep_client.py @@ -108,6 +108,15 @@ class HepClient: }) return response.json() + def customers_search(self, email): + response = self._call("/rest/V1/customers/search?searchCriteria[filterGroups][0][filters][0][field]" + "=email&searchCriteria[filterGroups][0][filters][0][value]={}".format(email)) + + json_data = response.json() + if len(json_data) > 0: + return json_data[0] + return None + def _customer_orders(self, admin_token, customer_id): url = ("/rest/V1/orders/?searchCriteria[filterGroups][0][filters][0][" "field]=customer_id&searchCriteria[filterGroups][0][filters][0][value]={}".format(customer_id)) diff --git a/server/registration/mutations_public.py b/server/registration/mutations_public.py index 0cdc7066..32e600fb 100644 --- a/server/registration/mutations_public.py +++ b/server/registration/mutations_public.py @@ -12,33 +12,27 @@ from django.conf import settings from graphene import relay from core.hep_client import HepClient, HepClientException, HepClientUnauthorizedException -from core.views import SetPasswordView -from registration.models import License -from users.models import User, Role, UserRole, SchoolClass +from users.user_signup_login_handler import handle_user_and_verify_products class PublicFieldError(graphene.ObjectType): code = graphene.String() -class MutationError(graphene.ObjectType): +class RegistrationError(graphene.ObjectType): field = graphene.String() - errors = graphene.List(PublicFieldError) class Registration(relay.ClientIDMutation): class Input: - firstname_input = graphene.String() - lastname_input = graphene.String() - email_input = graphene.String() - license_key_input = graphene.String() + confirmation_key = graphene.String() success = graphene.Boolean() - errors = graphene.List(MutationError) # todo: change for consistency + errors = graphene.List(RegistrationError) # todo: change for consistency @classmethod def mutate_and_get_payload(cls, root, info, **kwargs): - confirmation_key = kwargs.get('confirmationKey') + confirmation_key = kwargs.get('confirmation_key') hep_client = HepClient() @@ -49,50 +43,18 @@ class Registration(relay.ClientIDMutation): except HepClientException: return cls.return_login_error('unknown_error') - try: - user = User.objects.get(hep_id=user_data['id']) - except User.DoesNotExist: - user = User.objects.create_user_from_hep(user_data) + user, error_msg = handle_user_and_verify_products(user_data) - # show verfiy page + if error_msg: + return cls.return_login_error(error_msg) - # errors = [] - # for key, value in serializer.errors.items(): - # error = MutationError(field=key, errors=[]) - # for field_error in serializer.errors[key]: - # error.errors.append(PublicFieldError(code=field_error.code)) - - errors.append(error) - - return cls(success=False, errors=errors) + return cls(success=False, errors=[]) @classmethod - def create_local_user(cls, serializer, info): - user = User.objects.create_user_with_random_password(serializer.data['first_name'], - serializer.data['last_name'], - serializer.data['email']) - sb_license = License.objects.create(licensee=user, license_type=serializer.context['license_type']) + def return_login_error(cls, message): + error = RegistrationError(field=message) + return cls(success=False, errors=[error]) - if sb_license.license_type.is_teacher_license(): - teacher_role = Role.objects.get(key=Role.objects.TEACHER_KEY) - UserRole.objects.get_or_create(user=user, role=teacher_role) - default_class_name = SchoolClass.generate_default_group_name() - default_class = SchoolClass.objects.create(name=default_class_name) - user.school_classes.add(default_class) - else: - student_role = Role.objects.get(key=Role.objects.STUDENT_KEY) - UserRole.objects.get_or_create(user=user, role=student_role) - - password_reset_view = SetPasswordView() - password_reset_view.request = info.context - form = password_reset_view.form_class({'email': user.email}) - - if not form.is_valid(): - return cls(success=False, errors=form.errors) - - password_reset_view.form_valid(form) - - return cls(success=True) class RegistrationMutations: registration = Registration.Field() diff --git a/server/registration/tests/test_registration.py b/server/registration/tests/test_registration.py index 15779a98..77a5be5c 100644 --- a/server/registration/tests/test_registration.py +++ b/server/registration/tests/test_registration.py @@ -13,6 +13,7 @@ from django.test import TestCase, RequestFactory from graphene.test import Client from api.schema import schema +from core.hep_client import HepClient from registration.factories import LicenseTypeFactory, LicenseFactory from registration.models import License from users.managers import RoleManager @@ -43,7 +44,7 @@ class RegistrationTests(TestCase): request.session.save() self.client = Client(schema=schema, context_value=request) - def make_register_mutation(self, first_name, last_name, email, license_key): + def make_register_mutation(self, confirmation_key): mutation = ''' mutation Registration($input: RegistrationInput!){ registration(input: $input) { @@ -57,64 +58,76 @@ class RegistrationTests(TestCase): return self.client.execute(mutation, variables={ 'input': { - 'firstnameInput': first_name, - 'lastnameInput': last_name, - 'emailInput': email, - 'licenseKeyInput': license_key, + 'confirmationKeyInput': confirmation_key } }) - def _assert_user_registration(self, count, email, role_key): - users = User.objects.filter(username=self.email) - self.assertEqual(len(users), count) - user_roles = UserRole.objects.filter(user__email=email, role__key=role_key) - self.assertEqual(len(user_roles), count) - licenses = License.objects.filter(licensee__email=email, license_type__for_role__key=role_key) - self.assertEqual(len(licenses), count) + # @patch.object(HepClient, 'customer_me', return_value=ME_DATA) + # def test_user_can_register_with_valid_confirmation_key(self, me_mock): + # + # self.user.hep_id = ME_DATA['id'] + # self.user.save() + # + # now = timezone.now() + # expiry_date = now + timedelta(365) + # LicenseFactory(expire_date=expiry_date, licensee=self.user, for_role=self.teacher_role).save() + # + # result = self.make_login_mutation(self.user.email, TOKEN) + # + # self.assertTrue(result.get('data').get('login').get('success')) + # self.assertTrue(self.user.is_authenticated) - def test_user_can_register_as_teacher(self): - self._assert_user_registration(0, self.email, RoleManager.TEACHER_KEY) - school_classes = SchoolClass.objects.filter(name__startswith='Meine Klasse') - self.assertEqual(len(school_classes), 0) - result = self.make_register_mutation(self.first_name, self.last_name, self.email, self.teacher_license_type.key) - self.assertTrue(result.get('data').get('registration').get('success')) - self._assert_user_registration(1, self.email, RoleManager.TEACHER_KEY) - school_classes = SchoolClass.objects.filter(name__startswith='Meine Klasse') - self.assertEqual(len(school_classes), 1) - user = User.objects.get(email=self.email) - self.assertTrue(school_classes[0].is_user_in_schoolclass(user)) - self.assertEqual(len(mail.outbox), 1) - self.assertEqual(mail.outbox[0].subject, 'Myskillbox: E-Mail bestätigen und Passwort setzen') - - def test_user_can_register_as_student(self): - self._assert_user_registration(0, self.email, RoleManager.STUDENT_KEY) - result = self.make_register_mutation(self.first_name, self.last_name, self.email, self.student_license_type.key) - self.assertTrue(result.get('data').get('registration').get('success')) - self._assert_user_registration(1, self.email, RoleManager.STUDENT_KEY) - - def test_existing_user_cannot_register(self): - self._assert_user_registration(0, self.email, RoleManager.STUDENT_KEY) - self.make_register_mutation(self.first_name, self.last_name, self.email, self.student_license_type.key) - result = self.make_register_mutation(self.first_name, self.last_name, self.email, self.student_license_type.key) - self.assertEqual(result.get('data').get('registration').get('errors')[0].get('field'), 'email') - - def test_existing_user_cannot_register_with_uppercase_email(self): - self._assert_user_registration(0, self.email, RoleManager.STUDENT_KEY) - self.make_register_mutation(self.first_name, self.last_name, self.email.upper(), self.student_license_type.key) - result = self.make_register_mutation(self.first_name, self.last_name, self.email, self.student_license_type.key) - self.assertEqual(result.get('data').get('registration').get('errors')[0].get('field'), 'email') - - def test_user_cannot_register_if_firstname_is_missing(self): - result = self.make_register_mutation('', self.last_name, self.email, self.teacher_license_type.key) - self.assertEqual(result.get('data').get('registration').get('errors')[0].get('field'), 'first_name') - self.assertFalse(result.get('data').get('registration').get('success')) - - def test_user_cannot_register_if_lastname_is_missing(self): - result = self.make_register_mutation(self.first_name, '', self.email, self.teacher_license_type.key) - self.assertEqual(result.get('data').get('registration').get('errors')[0].get('field'), 'last_name') - self.assertFalse(result.get('data').get('registration').get('success')) - - def test_user_cannot_register_if_email_is_missing(self): - result = self.make_register_mutation(self.first_name, self.last_name, '', self.teacher_license_type.key) - self.assertEqual(result.get('data').get('registration').get('errors')[0].get('field'), 'email') - self.assertFalse(result.get('data').get('registration').get('success')) + # def _assert_user_registration(self, count, email, role_key): + # users = User.objects.filter(username=self.email) + # self.assertEqual(len(users), count) + # user_roles = UserRole.objects.filter(user__email=email, role__key=role_key) + # self.assertEqual(len(user_roles), count) + # licenses = License.objects.filter(licensee__email=email, license_type__for_role__key=role_key) + # self.assertEqual(len(licenses), count) + # + # def test_user_can_register_as_teacher(self): + # self._assert_user_registration(0, self.email, RoleManager.TEACHER_KEY) + # school_classes = SchoolClass.objects.filter(name__startswith='Meine Klasse') + # self.assertEqual(len(school_classes), 0) + # result = self.make_register_mutation(self.first_name, self.last_name, self.email, self.teacher_license_type.key) + # self.assertTrue(result.get('data').get('registration').get('success')) + # self._assert_user_registration(1, self.email, RoleManager.TEACHER_KEY) + # school_classes = SchoolClass.objects.filter(name__startswith='Meine Klasse') + # self.assertEqual(len(school_classes), 1) + # user = User.objects.get(email=self.email) + # self.assertTrue(school_classes[0].is_user_in_schoolclass(user)) + # self.assertEqual(len(mail.outbox), 1) + # self.assertEqual(mail.outbox[0].subject, 'Myskillbox: E-Mail bestätigen und Passwort setzen') + # + # def test_user_can_register_as_student(self): + # self._assert_user_registration(0, self.email, RoleManager.STUDENT_KEY) + # result = self.make_register_mutation(self.first_name, self.last_name, self.email, self.student_license_type.key) + # self.assertTrue(result.get('data').get('registration').get('success')) + # self._assert_user_registration(1, self.email, RoleManager.STUDENT_KEY) + # + # def test_existing_user_cannot_register(self): + # self._assert_user_registration(0, self.email, RoleManager.STUDENT_KEY) + # self.make_register_mutation(self.first_name, self.last_name, self.email, self.student_license_type.key) + # result = self.make_register_mutation(self.first_name, self.last_name, self.email, self.student_license_type.key) + # self.assertEqual(result.get('data').get('registration').get('errors')[0].get('field'), 'email') + # + # def test_existing_user_cannot_register_with_uppercase_email(self): + # self._assert_user_registration(0, self.email, RoleManager.STUDENT_KEY) + # self.make_register_mutation(self.first_name, self.last_name, self.email.upper(), self.student_license_type.key) + # result = self.make_register_mutation(self.first_name, self.last_name, self.email, self.student_license_type.key) + # self.assertEqual(result.get('data').get('registration').get('errors')[0].get('field'), 'email') + # + # def test_user_cannot_register_if_firstname_is_missing(self): + # result = self.make_register_mutation('', self.last_name, self.email, self.teacher_license_type.key) + # self.assertEqual(result.get('data').get('registration').get('errors')[0].get('field'), 'first_name') + # self.assertFalse(result.get('data').get('registration').get('success')) + # + # def test_user_cannot_register_if_lastname_is_missing(self): + # result = self.make_register_mutation(self.first_name, '', self.email, self.teacher_license_type.key) + # self.assertEqual(result.get('data').get('registration').get('errors')[0].get('field'), 'last_name') + # self.assertFalse(result.get('data').get('registration').get('success')) + # + # def test_user_cannot_register_if_email_is_missing(self): + # result = self.make_register_mutation(self.first_name, self.last_name, '', self.teacher_license_type.key) + # self.assertEqual(result.get('data').get('registration').get('errors')[0].get('field'), 'email') + # self.assertFalse(result.get('data').get('registration').get('success')) diff --git a/server/users/mutations_public.py b/server/users/mutations_public.py index c51a452e..811ae089 100644 --- a/server/users/mutations_public.py +++ b/server/users/mutations_public.py @@ -51,7 +51,7 @@ class Login(relay.ClientIDMutation): except HepClientException: return cls.return_login_error('unknown_error') - user, error_msg = handle_user_and_verify_products(user_data, token) + user, error_msg = handle_user_and_verify_products(user_data) if error_msg: return cls.return_login_error(error_msg) diff --git a/server/users/user_signup_login_handler.py b/server/users/user_signup_login_handler.py index e276c276..f085d8c5 100644 --- a/server/users/user_signup_login_handler.py +++ b/server/users/user_signup_login_handler.py @@ -14,7 +14,7 @@ from registration.models import License from users.models import User, MagentoToken, UserRole, Role, SchoolClass -def handle_user_and_verify_products(user_data, token): +def handle_user_and_verify_products(user_data): hep_client = HepClient() @@ -25,11 +25,6 @@ def handle_user_and_verify_products(user_data, token): # todo check if email has changed - # todo is this needed? - magento_token, created = MagentoToken.objects.get_or_create(user=user) - magento_token.token = token - magento_token.save() - try: if not hep_client.is_email_verified(user_data): return user, 'email_not_verified'