ramon
/
skillbox
1
0
Fork 0
Code Issues 1 Pull Requests 1 Packages Projects 1 Releases 1 Wiki Activity

Remove user token, use confirmation key

This commit is contained in:
Christian Cueni 2020-02-03 08:56:08 +01:00
parent 773547c883
commit cd7f79072e
5 changed files with 94 additions and 115 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

9
server/core/hep_client.py
View File

@ -108,6 +108,15 @@ class HepClient:
}) })
return response.json() 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): def _customer_orders(self, admin_token, customer_id):
url = ("/rest/V1/orders/?searchCriteria[filterGroups][0][filters][0][" url = ("/rest/V1/orders/?searchCriteria[filterGroups][0][filters][0]["
"field]=customer_id&searchCriteria[filterGroups][0][filters][0][value]={}".format(customer_id)) "field]=customer_id&searchCriteria[filterGroups][0][filters][0][value]={}".format(customer_id))

62
server/registration/mutations_public.py
View File

@ -12,33 +12,27 @@ from django.conf import settings
from graphene import relay from graphene import relay
from core.hep_client import HepClient, HepClientException, HepClientUnauthorizedException from core.hep_client import HepClient, HepClientException, HepClientUnauthorizedException
from core.views import SetPasswordView from users.user_signup_login_handler import handle_user_and_verify_products
from registration.models import License
from users.models import User, Role, UserRole, SchoolClass
class PublicFieldError(graphene.ObjectType): class PublicFieldError(graphene.ObjectType):
code = graphene.String() code = graphene.String()
class MutationError(graphene.ObjectType): class RegistrationError(graphene.ObjectType):
field = graphene.String() field = graphene.String()
errors = graphene.List(PublicFieldError)
class Registration(relay.ClientIDMutation): class Registration(relay.ClientIDMutation):
class Input: class Input:
firstname_input = graphene.String() confirmation_key = graphene.String()
lastname_input = graphene.String()
email_input = graphene.String()
license_key_input = graphene.String()
success = graphene.Boolean() success = graphene.Boolean()
errors = graphene.List(MutationError) # todo: change for consistency errors = graphene.List(RegistrationError) # todo: change for consistency
@classmethod @classmethod
def mutate_and_get_payload(cls, root, info, **kwargs): def mutate_and_get_payload(cls, root, info, **kwargs):
confirmation_key = kwargs.get('confirmationKey') confirmation_key = kwargs.get('confirmation_key')
hep_client = HepClient() hep_client = HepClient()
@ -49,50 +43,18 @@ class Registration(relay.ClientIDMutation):
except HepClientException: except HepClientException:
return cls.return_login_error('unknown_error') return cls.return_login_error('unknown_error')
try: user, error_msg = handle_user_and_verify_products(user_data)
user = User.objects.get(hep_id=user_data['id'])
except User.DoesNotExist:
user = User.objects.create_user_from_hep(user_data)
# show verfiy page if error_msg:
return cls.return_login_error(error_msg)
# errors = [] return cls(success=False, 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)
@classmethod @classmethod
def create_local_user(cls, serializer, info): def return_login_error(cls, message):
user = User.objects.create_user_with_random_password(serializer.data['first_name'], error = RegistrationError(field=message)
serializer.data['last_name'], return cls(success=False, errors=[error])
serializer.data['email'])
sb_license = License.objects.create(licensee=user, license_type=serializer.context['license_type'])
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: class RegistrationMutations:
registration = Registration.Field() registration = Registration.Field()

129
server/registration/tests/test_registration.py
View File

@ -13,6 +13,7 @@ from django.test import TestCase, RequestFactory
from graphene.test import Client from graphene.test import Client
from api.schema import schema from api.schema import schema
from core.hep_client import HepClient
from registration.factories import LicenseTypeFactory, LicenseFactory from registration.factories import LicenseTypeFactory, LicenseFactory
from registration.models import License from registration.models import License
from users.managers import RoleManager from users.managers import RoleManager
@ -43,7 +44,7 @@ class RegistrationTests(TestCase):
request.session.save() request.session.save()
self.client = Client(schema=schema, context_value=request) 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 = '''
mutation Registration($input: RegistrationInput!){ mutation Registration($input: RegistrationInput!){
registration(input: $input) { registration(input: $input) {
@ -57,64 +58,76 @@ class RegistrationTests(TestCase):
return self.client.execute(mutation, variables={ return self.client.execute(mutation, variables={
'input': { 'input': {
'firstnameInput': first_name, 'confirmationKeyInput': confirmation_key
'lastnameInput': last_name,
'emailInput': email,
'licenseKeyInput': license_key,
} }
}) })
def _assert_user_registration(self, count, email, role_key): # @patch.object(HepClient, 'customer_me', return_value=ME_DATA)
users = User.objects.filter(username=self.email) # def test_user_can_register_with_valid_confirmation_key(self, me_mock):
self.assertEqual(len(users), count) #
user_roles = UserRole.objects.filter(user__email=email, role__key=role_key) # self.user.hep_id = ME_DATA['id']
self.assertEqual(len(user_roles), count) # self.user.save()
licenses = License.objects.filter(licensee__email=email, license_type__for_role__key=role_key) #
self.assertEqual(len(licenses), count) # 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): # def _assert_user_registration(self, count, email, role_key):
self._assert_user_registration(0, self.email, RoleManager.TEACHER_KEY) # users = User.objects.filter(username=self.email)
school_classes = SchoolClass.objects.filter(name__startswith='Meine Klasse') # self.assertEqual(len(users), count)
self.assertEqual(len(school_classes), 0) # user_roles = UserRole.objects.filter(user__email=email, role__key=role_key)
result = self.make_register_mutation(self.first_name, self.last_name, self.email, self.teacher_license_type.key) # self.assertEqual(len(user_roles), count)
self.assertTrue(result.get('data').get('registration').get('success')) # licenses = License.objects.filter(licensee__email=email, license_type__for_role__key=role_key)
self._assert_user_registration(1, self.email, RoleManager.TEACHER_KEY) # self.assertEqual(len(licenses), count)
school_classes = SchoolClass.objects.filter(name__startswith='Meine Klasse') #
self.assertEqual(len(school_classes), 1) # def test_user_can_register_as_teacher(self):
user = User.objects.get(email=self.email) # self._assert_user_registration(0, self.email, RoleManager.TEACHER_KEY)
self.assertTrue(school_classes[0].is_user_in_schoolclass(user)) # school_classes = SchoolClass.objects.filter(name__startswith='Meine Klasse')
self.assertEqual(len(mail.outbox), 1) # self.assertEqual(len(school_classes), 0)
self.assertEqual(mail.outbox[0].subject, 'Myskillbox: E-Mail bestätigen und Passwort setzen') # 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'))
def test_user_can_register_as_student(self): # self._assert_user_registration(1, self.email, RoleManager.TEACHER_KEY)
self._assert_user_registration(0, self.email, RoleManager.STUDENT_KEY) # school_classes = SchoolClass.objects.filter(name__startswith='Meine Klasse')
result = self.make_register_mutation(self.first_name, self.last_name, self.email, self.student_license_type.key) # self.assertEqual(len(school_classes), 1)
self.assertTrue(result.get('data').get('registration').get('success')) # user = User.objects.get(email=self.email)
self._assert_user_registration(1, self.email, RoleManager.STUDENT_KEY) # self.assertTrue(school_classes[0].is_user_in_schoolclass(user))
# self.assertEqual(len(mail.outbox), 1)
def test_existing_user_cannot_register(self): # self.assertEqual(mail.outbox[0].subject, 'Myskillbox: E-Mail bestätigen und Passwort setzen')
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) # def test_user_can_register_as_student(self):
result = self.make_register_mutation(self.first_name, self.last_name, self.email, self.student_license_type.key) # self._assert_user_registration(0, self.email, RoleManager.STUDENT_KEY)
self.assertEqual(result.get('data').get('registration').get('errors')[0].get('field'), 'email') # 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'))
def test_existing_user_cannot_register_with_uppercase_email(self): # self._assert_user_registration(1, self.email, RoleManager.STUDENT_KEY)
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) # def test_existing_user_cannot_register(self):
result = self.make_register_mutation(self.first_name, self.last_name, self.email, self.student_license_type.key) # self._assert_user_registration(0, self.email, RoleManager.STUDENT_KEY)
self.assertEqual(result.get('data').get('registration').get('errors')[0].get('field'), 'email') # 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)
def test_user_cannot_register_if_firstname_is_missing(self): # self.assertEqual(result.get('data').get('registration').get('errors')[0].get('field'), 'email')
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') # def test_existing_user_cannot_register_with_uppercase_email(self):
self.assertFalse(result.get('data').get('registration').get('success')) # 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)
def test_user_cannot_register_if_lastname_is_missing(self): # result = 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.email, self.teacher_license_type.key) # self.assertEqual(result.get('data').get('registration').get('errors')[0].get('field'), 'email')
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_firstname_is_missing(self):
# result = self.make_register_mutation('', self.last_name, self.email, self.teacher_license_type.key)
def test_user_cannot_register_if_email_is_missing(self): # self.assertEqual(result.get('data').get('registration').get('errors')[0].get('field'), 'first_name')
result = self.make_register_mutation(self.first_name, self.last_name, '', self.teacher_license_type.key) # self.assertFalse(result.get('data').get('registration').get('success'))
self.assertEqual(result.get('data').get('registration').get('errors')[0].get('field'), 'email') #
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'))

2
server/users/mutations_public.py
View File

@ -51,7 +51,7 @@ class Login(relay.ClientIDMutation):
except HepClientException: except HepClientException:
return cls.return_login_error('unknown_error') 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: if error_msg:
return cls.return_login_error(error_msg) return cls.return_login_error(error_msg)

7
server/users/user_signup_login_handler.py
View File

@ -14,7 +14,7 @@ from registration.models import License
from users.models import User, MagentoToken, UserRole, Role, SchoolClass 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() hep_client = HepClient()
@ -25,11 +25,6 @@ def handle_user_and_verify_products(user_data, token):
# todo check if email has changed # 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: try:
if not hep_client.is_email_verified(user_data): if not hep_client.is_email_verified(user_data):
return user, 'email_not_verified' return user, 'email_not_verified'