def create_user(self, claims):
"""
Create a user account for the given claims.
This method is overridden to ensure we create a user account
which will work in the DUA world.
"""
username = claims.get("preferred_username", default_username_algo(claims["email"]))
user = self.UserModel(username=username, email=claims["email"])
user._disable_account_creation = True
user.set_unusable_password()
user.save()
extra = {}
if claims.get("zoneinfo"):
extra["timezone"] = claims["zoneinfo"]
if claims.get("locale"):
extra["language"] = claims["locale"]
Account.create(**{
"request": self.request,
"user": user,
"create_email": False,
**extra,
})
if claims.get("email_verified", False):
EmailAddress.objects.create(
email=user.email,
verified=True,
primary=True,
)
else:
EmailAddress.objects.add_email(user, user.email, confirm=True)
return user
def create_user(backend,
details,
response,
uid,
username,
user=None,
*args,
**kwargs):
"""Create user. Depends on get_username pipeline."""
if user:
return {'user': user}
if not username:
return None
warn_setting('SOCIAL_AUTH_CREATE_USERS', 'create_user')
if not setting('SOCIAL_AUTH_CREATE_USERS', True):
# Send signal for cases where tracking failed registering is useful.
socialauth_not_registered.send(sender=backend.__class__,
uid=uid,
response=response,
details=details)
return None
email = details.get('email')
request = kwargs["request"]
user = User.objects.create_user(username=username, email=email)
Account.create(request=request, user=user)
EmailAddress.objects.add_email(user, user.email, primary=True)
return {'user': user, 'is_new': True}
def create_user(backend, details, response, uid, username, user=None, *args, **kwargs):
"""Create user. Depends on get_username pipeline."""
if user:
return {'user': user}
if not username:
return None
warn_setting('SOCIAL_AUTH_CREATE_USERS', 'create_user')
if not setting('SOCIAL_AUTH_CREATE_USERS', True):
# Send signal for cases where tracking failed registering is useful.
socialauth_not_registered.send(sender=backend.__class__, uid=uid, response=response, details=details)
return None
email = details.get('email')
request = kwargs["request"]
user = User.objects.create_user(username=username, email=email)
Account.create(request=request, user=user)
EmailAddress.objects.add_email(user, user.email, primary=True)
return {
'user': user,
'is_new': True
}
def setUp(self):
Account.create(**{
'username': '******',
'email': '*****@*****.**',
'password': '******'
}).save()
response = self.client.post('/api/v1/login', data={
'username': '******',
'password': '******'
})
self.header = {'HTTP_AUTHORIZATION': 'Token {}'.format(response.json().get('key'))}
def setUp(self):
account = Account.create(
**{
'username': '******',
'email': '*****@*****.**',
'password': '******'
})
account.save()
response = self.client.post('/api/v1/login',
data={
'username': '******',
'password': '******'
})
self.auth_token_header = {
'HTTP_AUTHORIZATION': 'Token {}'.format(response.json().get('key'))
}
account_1 = Account.create(
**{
'username': '******',
'email': '*****@*****.**',
'password': '******'
})
account_1.save()
backup = Backup(
**{
'account': account,
'digest': 'somedigest',
'timestamp': self.timestamp,
'backup': 'encoded backup data'
})
backup.save()
backup_1 = Backup(
**{
'account': account,
'digest': 'somedigest_1',
'timestamp': self.timestamp,
'backup': 'encoded backup data 1'
})
backup_1.save()
Backup(
**{
'account': account_1,
'digest': 'somedigest_2',
'timestamp': self.timestamp,
'backup': 'encoded backup data 2'
}).save()
self.expected_list = [{
'digest': backup_1.digest,
'timestamp': backup_1.timestamp
}, {
'digest': backup.digest,
'timestamp': backup.timestamp
}]
def user_post_save(sender, **kwargs):
"""
After User.save is called we check to see if it was a created user. If so,
we check if the User object wants account creation. If all passes we
create an Account object.
We only run on user creation to avoid having to check for existence on
each call to User.save.
"""
user, created = kwargs["instance"], kwargs["created"]
disabled = getattr(user, "_disable_account_creation", not settings.ACCOUNT_CREATE_ON_SAVE)
if created and not disabled:
from account.models import Account
Account.create(user=user)
def test_create_failed_incorrect_password(self):
account = Account.create(
**{
'username': '******',
'email': '*****@*****.**',
'password': None
})
self.assertIsNone(account)
account = Account.create(
**{
'username': '******',
'email': '*****@*****.**',
'password': ''
})
self.assertIsNone(account)
def setUp(self):
account = Account.create(
**{
'username': '******',
'email': '*****@*****.**',
'password': '******'
})
account.save()
response = self.client.post('/api/v1/login',
data={
'username': '******',
'password': '******'
})
self.auth_token_header = {
'HTTP_AUTHORIZATION': 'Token {}'.format(response.json().get('key'))
}
self.backup = Backup(
**{
'account': account,
'digest':
'somedigestsomedigestsomedigestsomedigestsomedigestsomedigestsomedigestsomedigestsomedigestsomedigestsomedigestsomedigestmedigest',
'timestamp': self.timestamp,
'backup': 'encoded backup data'
})
self.backup.save()
def create_account(self, form):
account = Account.create(request=self.request, user=self.created_user, create_email=False)
fields = {}
if "street" in form.cleaned_data:
fields["street"] = form.cleaned_data["street"]
if "plz_city" in form.cleaned_data:
fields["plz_city"] = form.cleaned_data["plz_city"]
if "phone" in form.cleaned_data:
fields["phone"] = form.cleaned_data["phone"]
for k, v in fields.items():
setattr(account, k, v)
account.save()
return account
def create_account(self, form):
account = Account.create(request=self.request,
user=self.created_user,
create_email=False)
fields = {}
if "street" in form.cleaned_data:
fields["street"] = form.cleaned_data["street"]
if "plz_city" in form.cleaned_data:
fields["plz_city"] = form.cleaned_data["plz_city"]
if "phone" in form.cleaned_data:
fields["phone"] = form.cleaned_data["phone"]
for k, v in fields.items():
setattr(account, k, v)
account.save()
return account
def test_create(self):
actual_account = Account.create(
**{
'username': '******',
'email': '*****@*****.**',
'password': '******',
'max_backups': 8,
})
actual_account.save()
expected_account = Account.objects.get(pk='test_username_1')
self.assertEqual(actual_account.username, expected_account.username)
self.assertEqual(actual_account.email, expected_account.email)
self.assertEqual(actual_account.password, expected_account.password)
self.assertEqual(actual_account.max_backups,
expected_account.max_backups)
def setUp(self):
self.account = Account.create(
**{
'username': '******',
'email': '*****@*****.**',
'password': '******'
})
self.account.save()
response = self.client.post('/api/v1/login',
data={
'username': '******',
'password': '******'
})
self.auth_token_header = {
'HTTP_AUTHORIZATION': 'Token {}'.format(response.json().get('key'))
}
for i in range(4):
Backup(
**{
'account': self.account,
'digest': 'some_digest_{}'.format(i),
'timestamp': now(),
'backup': 'encoded backup data {}'.format(i)
}).save()
def create_account(self, form):
return Account.create(request=self.request, user=self.created_user, create_email=False)
def create_account(self, new_user, form):
return Account.create(request=self.request, user=new_user)
def create_account(self, form):
return Account.create(request=self.request, user=self.created_user, create_email=False,
subscribe_to_newsletter=form.cleaned_data["subscribe_to_newsletter"])
def create_account(self, form):
return Account.create(request=self.request,
user=self.created_user,
create_email=False,
timezone=form.cleaned_data["timezone"])
def post(self, request, *args, **kwargs):
try:
data = json.loads(request.body)
except:
return HttpResponseBadRequest(self.format_error)
# Data should be a list of registration info in dictionary format.
if not (isinstance(data, list) and all([isinstance(d, dict) for d in data])):
return HttpResponseBadRequest(self.format_error)
all_valid = True
seen_emails = []
user_data = []
for registration in data:
form = GroupRegistrationForm(data=registration)
if form.is_valid():
# Check if this is a duplicate of an email provided in this request.
email = User.objects.normalize_email(form.cleaned_data['email'])
if email in seen_emails:
all_valid = False
user_data.append({
'valid': False,
'error_message': 'This email is a duplicate of one above.',
'user': None,
})
else:
seen_emails.append(email)
created, user = form.save(commit=False)
if created:
# Delay account creation until the transaction is
# committed.
user._disable_account_creation = True
user.save()
user_data.append({
'valid': True,
'created': created,
'user': {
'pycon_id': user.pk,
'email': form.cleaned_data.get('email'),
'first_name': form.cleaned_data.get('first_name', ''),
'last_name': form.cleaned_data.get('last_name', ''),
}
})
else:
all_valid = False
user_data.append({
'valid': False,
'errors': [e for errors in form.errors.values() for e in errors],
'user': None,
})
# The request is atomic - all users are created (or found), or none
# are.
if all_valid:
for d in user_data:
if d['created']:
# Now that the transaction has been committed,
# create an Account for the user so that they can log in.
user = User.objects.get(pk=d['user']['pycon_id'])
Account.create(user=user)
else:
for d in user_data:
d['user'] = None
d.pop('created', None)
transaction.set_rollback(True)
return_data = {'success': all_valid, 'users': user_data}
return HttpResponse(json.dumps(return_data))
def setUp(self):
Account.create(**{
'username': '******',
'email': '*****@*****.**',
'password': '******'
}).save()
content = urllib2.urlopen(url)
# Facebook default image check
if sender.name == 'facebook' and 'image/gif' in str(content.info()):
return
filename = user.username + "_profile" + '.' + content.headers.subtype
profile.photo.save(filename, ContentFile(content.read()))
except IOError, e:
logger.debug(e)
try:
profile.language = response.get('locale').split("_")[0]
profile.full_clean()
except Exception:
pass
profile.time_zone = response.get('timezone')
profile.save()
account = user.account_set.all()[0] or Account.create(user=user, create_email=False)
try:
account.language = response.get('locale').split("_")[0]
tz_offset = int(response.get('timezone'))
tz_joiner = "" if tz_offset < 0 else "+"
account.timezone = coerce_timezone_value(tz_joiner.join(("Etc/GMT", str(tz_offset))))
account.full_clean()
except Exception:
pass
account.save()
email, created = EmailAddress.objects.get_or_create(user=user, email=user.email)
email.verified = True
email.save()
return True
if sender.name == 'facebook' and 'image/gif' in str(
content.info()):
return
filename = user.username + "_profile" + '.' + content.headers.subtype
profile.photo.save(filename, ContentFile(content.read()))
except IOError, e:
logger.debug(e)
try:
profile.language = response.get('locale').split("_")[0]
profile.full_clean()
except Exception:
pass
profile.time_zone = response.get('timezone')
profile.save()
account = user.account_set.all()[0] or Account.create(user=user,
create_email=False)
try:
account.language = response.get('locale').split("_")[0]
tz_offset = int(response.get('timezone'))
tz_joiner = "" if tz_offset < 0 else "+"
account.timezone = coerce_timezone_value(
tz_joiner.join(("Etc/GMT", str(tz_offset))))
account.full_clean()
except Exception:
pass
account.save()
email, created = EmailAddress.objects.get_or_create(user=user,
email=user.email)
email.verified = True
email.save()
return True
def create_account(self, form):
return Account.create(request=self.request,
user=self.created_user,
create_email=False)
def post(self, request, *args, **kwargs):
try:
data = json.loads(request.body)
except:
return HttpResponseBadRequest(self.format_error)
# Data should be a list of registration info in dictionary format.
if not (isinstance(data, list)
and all([isinstance(d, dict) for d in data])):
return HttpResponseBadRequest(self.format_error)
all_valid = True
seen_emails = []
user_data = []
for registration in data:
form = GroupRegistrationForm(data=registration)
if form.is_valid():
# Check if this is a duplicate of an email provided in this request.
email = User.objects.normalize_email(
form.cleaned_data['email'])
if email in seen_emails:
all_valid = False
user_data.append({
'valid': False,
'error_message':
'This email is a duplicate of one above.',
'user': None,
})
else:
seen_emails.append(email)
created, user = form.save(commit=False)
if created:
# Delay account creation until the transaction is
# committed.
user._disable_account_creation = True
user.save()
user_data.append({
'valid': True,
'created': created,
'user': {
'pycon_id': user.pk,
'email': form.cleaned_data.get('email'),
'first_name':
form.cleaned_data.get('first_name', ''),
'last_name':
form.cleaned_data.get('last_name', ''),
}
})
else:
all_valid = False
user_data.append({
'valid':
False,
'errors':
[e for errors in form.errors.values() for e in errors],
'user':
None,
})
# The request is atomic - all users are created (or found), or none
# are.
if all_valid:
for d in user_data:
if d['created']:
# Now that the transaction has been committed,
# create an Account for the user so that they can log in.
user = User.objects.get(pk=d['user']['pycon_id'])
Account.create(user=user)
else:
for d in user_data:
d['user'] = None
d.pop('created', None)
transaction.set_rollback(True)
return_data = {'success': all_valid, 'users': user_data}
return HttpResponse(json.dumps(return_data))
def create(self, validated_data):
account = Account.create(**validated_data)
account.save()
return account
