def populate_user(self,request,sociallogin,data):
socialaccount = sociallogin.account
username = data.get('username')
first_name = data.get('first_name')
last_name = data.get('last_name')
email = data.get('email')
name = data.get('name')
user = sociallogin.account.user
user_model = get_user_model()
try:
query = {"username" + '__iexact': username}
user_model.objects.get(**query)
user_username(user,generate_unique_username([first_name,last_name,email,'user']))
except Exception as e:
if username == None:
user_username(user,generate_unique_username([first_name,last_name,email,'user']))
else:
user_username(user,username.replace(".",""))
user_email(user, valid_email_or_none(email) or '')
name_parts = (name or '').partition(' ')
user_field(user, 'first_name', first_name or name_parts[0])
user_field(user, 'last_name', last_name or name_parts[2])
return user
def save_user(self, request, user, form, commit=True):
"""
Saves a new `User` instance using information provided in the
signup form.
"""
from allauth.account.utils import user_username, user_email, user_field
data = form.cleaned_data
first_name = data.get('first_name')
last_name = data.get('last_name')
email = data.get('email')
username = data.get('username')
user_email(user, email)
user_username(user, username)
if first_name:
user_field(user, 'first_name', first_name)
if last_name:
user_field(user, 'last_name', last_name)
if 'password1' in data:
user.set_password(data["password1"])
else:
user.set_unusable_password()
self.populate_username(request, user)
user.is_active = False
if commit:
# Ability not to commit makes it easier to derive from
# this adapter by adding
user.save()
return user
def signup(self, request, user):
assert EmailAddress.objects.filter(user=user).count() == 0
priority_addresses = []
adapter = get_adapter()
stashed_email = adapter.unstash_verified_email(request)
if stashed_email:
priority_addresses.append(EmailAddress(user=user,
email=stashed_email,
primary=True,
verified=True))
email = user_email(user)
if email:
priority_addresses.append(EmailAddress(user=user,
email=email,
primary=True,
verified=False))
addresses, primary = cleanup_email_addresses(request,
priority_addresses
+ addresses)
for a in addresses:
a.user = user
a.save()
EmailAddress.objects.fill_cache_for_user(user, addresses)
if (primary
and email
and email.lower() != primary.email.lower()):
user_email(user, primary.email)
user.save()
return primary
def save_user(self, request, user, form):
data = form.cleaned_data
email = data['email']
first_name = data["first_name"]
last_name = data["last_name"]
username = generate_unique_username([first_name,last_name,email,'user'])
user_email(user, email)
user_username(user, username)
user_field(user, 'first_name', first_name or '')
user_field(user, 'last_name', last_name or '')
password = data.get("password1")
if password:
user.set_password(password)
else:
user.set_unusable_password()
user.save()
avatar = Photo.objects.create(caption=first_name + " " + last_name + " Avatar", \
user_post=user,image=DEFAULT_IMAGE_PATH_MAPPING['default_male_icon'],
unique_id=generate_unique_id("photo"),photo_type='user_profile')
cover_picture = Photo.objects.create(caption=first_name + " " + last_name + " Cover Picture", \
user_post=user,image=DEFAULT_IMAGE_PATH_MAPPING['default_cover_picture'],
unique_id=generate_unique_id("photo"),photo_type='user_profile')
get_location_from_client_ip(request,user)
user.get_profile().avatar = avatar
user.get_profile().cover_picture = cover_picture
user.get_profile().save()
return user
def populate_user(self, request, sociallogin, data):
"""
Hook that can be used to further populate the user instance.
For convenience, we populate several common fields.
Note that the user instance being populated represents a
suggested User instance that represents the social user that is
in the process of being logged in.
The User instance need not be completely valid and conflict
free. For example, verifying whether or not the username
already exists, is not a responsibility.
"""
username = data.get('username')
first_name = data.get('first_name')
last_name = data.get('last_name')
email = data.get('email')
name = data.get('name')
time_zone = data.get('time_zone')
locale = data.get('locale')
gravatar = data.get('profile_image_url')
user = sociallogin.user
user_username(user, username or '')
user_email(user, valid_email_or_none(email) or '')
name_parts = (name or '').partition(' ')
user_field(user, 'first_name', first_name or name_parts[0])
user_field(user, 'last_name', last_name or name_parts[2])
user_field(user, 'time_zone', time_zone)
user_field(user, 'locale', locale)
user_field(user, 'gravatar', gravatar)
return user
def 設定欄位內容(self, 資料內容={}):
"讓allauth的接口使用"
email = valid_email_or_none(資料內容.get('email')) or ''
if email:
user_email(self, email)
try:
self.來源
except:
name = 資料內容.get('name')
username = 資料內容.get('username')
last_name = 資料內容.get('last_name')
first_name = 資料內容.get('first_name')
if name:
來源名 = name
elif username:
來源名 = username
elif last_name and first_name:
來源名 = last_name + first_name
else:
來源名 = email
self.來源 = 來源表. 加來源({ '名':來源名})
if 'password1' in 資料內容:
self.set_password(資料內容["password1"])
else:
self.set_unusable_password()
return
def _process_signup(request, sociallogin):
# If email is specified, check for duplicate and if so, no auto signup.
auto_signup = app_settings.AUTO_SIGNUP
email = user_email(sociallogin.account.user)
if auto_signup:
# Let's check if auto_signup is really possible...
if email:
if account_settings.UNIQUE_EMAIL:
if email_address_exists(email):
# Oops, another user already has this address. We
# cannot simply connect this social account to the
# existing user. Reason is that the email adress may
# not be verified, meaning, the user may be a hacker
# that has added your email address to his account in
# the hope that you fall in his trap. We cannot check
# on 'email_address.verified' either, because
# 'email_address' is not guaranteed to be verified.
auto_signup = False
# FIXME: We redirect to signup form -- user will
# see email address conflict only after posting
# whereas we detected it here already.
elif app_settings.EMAIL_REQUIRED:
# Nope, email is required and we don't have it yet...
auto_signup = False
if not auto_signup:
request.session['socialaccount_sociallogin'] = sociallogin
url = reverse('socialaccount_signup')
ret = HttpResponseRedirect(url)
else:
# FIXME: This part contains a lot of duplication of logic
# ("closed" rendering, create user, send email, in active
# etc..)
try:
if not get_account_adapter().is_open_for_signup(request):
return render(request,
"account/signup_closed.html")
except ImmediateHttpResponse as e:
return e.response
u = sociallogin.account.user
if account_settings.USER_MODEL_USERNAME_FIELD:
user_username(u,
generate_unique_username(user_username(u)
or email
or 'user'))
for field in ['last_name',
'first_name']:
if hasattr(u, field):
truncated_value = (user_field(u, field) or '') \
[0:User._meta.get_field(field).max_length]
user_field(u, field, truncated_value)
user_email(u, email or '')
if u.password:
pass
else:
u.set_unusable_password()
sociallogin.save(request)
ret = complete_social_signup(request, sociallogin)
return ret
def setUp(self):
adapt = get_adapter()
#create a test user
usr = adapt.new_user(None)
usr.set_password('test')
usr.is_active = 'True'
user_email(usr, '*****@*****.**')
user_username(usr, 'test')
usr.save()
# manually confirm address
email = EmailAddress.objects.create(user=usr,email='*****@*****.**')
adapt.confirm_email(None,email)
def send_email_confirmation_for_celery(request, user, signup=False, **kwargs):
"""
Customized send confirmation function that doesn't set (notification) messages and other
things that depend on the request object since we're passing a mock request object to it.
"""
from .models import SmallsEmailAddress, SmallsEmailConfirmation
COOLDOWN_PERIOD = timedelta(minutes=3)
email = user_email(user)
if email:
try:
email_address = SmallsEmailAddress.objects.get(user=user, email__iexact=email)
if not email_address.verified:
send_email = not SmallsEmailConfirmation.objects \
.filter(sent__gt=now() - COOLDOWN_PERIOD,
email_address=email_address) \
.exists()
if send_email:
email_address.send_confirmation(request,
signup=signup, activate_view=kwargs.get('activate_view'))
else:
send_email = False
except SmallsEmailAddress.DoesNotExist:
send_email = True
email_address = SmallsEmailAddress.objects.add_email(request,
user,
email,
signup=signup,
confirm=True)
assert email_address
def complete_login(self, request, app, token, **kwargs):
resp = requests.get(self.profile_url,
params={ 'access_token': token.token,
'alt': 'json' })
extra_data = resp.json()
# extra_data is something of the form:
#
# {u'family_name': u'Penners', u'name': u'Raymond Penners',
# u'picture': u'https://lh5.googleusercontent.com/-GOFYGBVOdBQ/AAAAAAAAAAI/AAAAAAAAAGM/WzRfPkv4xbo/photo.jpg',
# u'locale': u'nl', u'gender': u'male',
# u'email': u'*****@*****.**',
# u'link': u'https://plus.google.com/108204268033311374519',
# u'given_name': u'Raymond', u'id': u'108204268033311374519',
# u'verified_email': True}
#
# TODO: We could use verified_email to bypass allauth email verification
uid = str(extra_data['id'])
account = SocialAccount(extra_data=extra_data,
uid=uid,
provider=self.provider_id)
user = get_adapter() \
.populate_new_user(request,
account,
email=extra_data.get('email'),
last_name=extra_data.get('family_name'),
first_name=extra_data.get('given_name'))
account.user = user
email_addresses = []
email = user_email(user)
if email and extra_data.get('verified_email'):
email_addresses.append(EmailAddress(email=email,
verified=True,
primary=True))
return SocialLogin(account,
email_addresses=email_addresses)
def __init__(self, *args, **kwargs):
self.sociallogin = kwargs.pop('sociallogin')
user = self.sociallogin.account.user
initial = { 'email': user_email(user) or '',
'username': user_username(user) or '',
'first_name': user.first_name or '',
'last_name': user.last_name or '' }
kwargs['initial'] = initial
super(SignupForm, self).__init__(*args, **kwargs)
def __init__(self, *args, **kwargs):
self.sociallogin = kwargs.pop('sociallogin')
user = self.sociallogin.account.user
initial = { 'email': user_email(user) or '',
'username': user_username(user) or '',
'first_name': user.first_name or '',
'last_name': user.last_name or '' }
kwargs['initial'] = initial
kwargs['email_required'] = app_settings.EMAIL_REQUIRED
super(SignupForm, self).__init__(*args, **kwargs)
def pre_social_login(self, request, sociallogin):
# This isn't tested, but should work
try:
email = user_email(sociallogin.account.user)
user = CustomUser.objects.get(email=email)
if user and not sociallogin.is_existing:
sociallogin.connect(request, user)
return user
except CustomUser.DoesNotExist:
pass
def __init__(self, *args, **kwargs):
self.sociallogin = kwargs.pop("sociallogin")
user = self.sociallogin.account.user
initial = {
"email": user_email(user) or "",
"username": user_username(user) or "",
"first_name": user.first_name or "",
"last_name": user.last_name or "",
}
kwargs["initial"] = initial
super(SignupForm, self).__init__(*args, **kwargs)
def __init__(self, *args, **kwargs):
self.sociallogin = kwargs.pop('sociallogin')
user = self.sociallogin.account.user
# TODO: Should become more generic, not listing
# a few fixed properties.
initial = {'email': user_email(user) or '',
'username': user_username(user) or '',
'first_name': user_field(user, 'first_name') or '',
'last_name': user_field(user, 'last_name') or ''}
kwargs['initial'] = initial
kwargs['email_required'] = app_settings.EMAIL_REQUIRED
super(SignupForm, self).__init__(*args, **kwargs)
def __init__(self, *args, **kwargs):
self.sociallogin = kwargs.pop("sociallogin")
user = self.sociallogin.account.user
initial = {
"email": user_email(user) or "",
"username": user_username(user) or "",
"first_name": user_field(user, "first_name") or "",
"last_name": user_field(user, "last_name") or "",
}
kwargs["initial"] = initial
kwargs["email_required"] = app_settings.EMAIL_REQUIRED
super(SignupForm, self).__init__(*args, **kwargs)
def is_open_for_signup(self, request, sociallogin):
"""
Checks whether or not the site is open for signups.
Next to simply returning True/False you can also intervene the
regular flow by raising an ImmediateHttpResponse
"""
email = user_email(sociallogin.user)
try:
queryset = UserEmail.objects.select_related().get(email=email)
return True
except:
return False
def populate_username(self, request, user):
"""
Fills in a valid username, if required and missing. If the
username is already present it is assumed to be valid
(unique).
"""
first_name = user_field(user, "first_name")
last_name = user_field(user, "last_name")
email = user_email(user)
username = user_username(user)
if USER_MODEL_USERNAME_FIELD:
user_username(user, username or generate_unique_username([first_name, last_name, email, "user"]))
def populate_user(self, request, sociallogin, data):
"""
When populating a :class:`~django.contrib.auth.models.User` object
during login, we make sure the username is the user part of the
user's email address, e.g. ``[email protected]`` will mean the username
is ``jdoe``.
"""
user = super().populate_user(request, sociallogin, data)
email = user_email(user)
if email and '@' in email:
username = email.split('@')[0]
user_username(user, username)
return user
def _process_signup(request, sociallogin):
# If email is specified, check for duplicate and if so, no auto signup.
auto_signup = app_settings.AUTO_SIGNUP
email = user_email(sociallogin.account.user)
if auto_signup:
# Let's check if auto_signup is really possible...
if email:
if account_settings.UNIQUE_EMAIL:
if email_address_exists(email):
# Oops, another user already has this address. We
# cannot simply connect this social account to the
# existing user. Reason is that the email adress may
# not be verified, meaning, the user may be a hacker
# that has added your email address to his account in
# the hope that you fall in his trap. We cannot check
# on 'email_address.verified' either, because
# 'email_address' is not guaranteed to be verified.
auto_signup = False
# FIXME: We redirect to signup form -- user will
# see email address conflict only after posting
# whereas we detected it here already.
elif app_settings.EMAIL_REQUIRED:
# Nope, email is required and we don't have it yet...
auto_signup = False
if not auto_signup:
request.session['socialaccount_sociallogin'] = sociallogin.serialize()
url = reverse('socialaccount_signup')
ret = HttpResponseRedirect(url)
else:
# Ok, auto signup it is, at least the e-mail address is ok.
# We still need to check the username though...
if account_settings.USER_MODEL_USERNAME_FIELD:
username = user_username(sociallogin.account.user)
try:
get_account_adapter().clean_username(username)
except ValidationError:
# This username is no good ...
user_username(sociallogin.account.user, '')
# FIXME: This part contains a lot of duplication of logic
# ("closed" rendering, create user, send email, in active
# etc..)
try:
if not get_adapter().is_open_for_signup(request,
sociallogin):
return render(request,
"account/signup_closed.html")
except ImmediateHttpResponse as e:
return e.response
get_adapter().save_user(request, sociallogin, form=None)
ret = complete_social_signup(request, sociallogin)
return ret
def save_user(self, request, user, form, commit=False):
"""
Saves a new `User` instance using information provided in the
signup form.
"""
# user_field(user, 'date_of_birth', date_of_birth)
# when field date_of_birth (datetime.date(1975, 11, 11),)
# is evaluated by user_field, utils.py:80
# v = v[0:User._meta.get_field(field).max_length]
# (or even just v[0] is evaluated on it's own)
# {TypeError}'datetime.date' object has no attribute '__getitem__'
# is thrown
from allauth.account.utils import user_username, user_email, user_field
data = form.cleaned_data
first_name = data.get('first_name')
last_name = data.get('last_name')
email = data.get('email')
username = data.get('username')
date_of_birth = data.get('date_of_birth')
gender = data.get('gender')
user_email(user, email)
user_username(user, username)
user_field(user, 'first_name', first_name or '')
user_field(user, 'last_name', last_name or '')
user_field(user, 'gender', gender or '')
user_field(user, 'date_of_birth', date_of_birth)
if 'password1' in data:
user.set_password(user, data["password1"])
else:
user.set_unusable_password()
self.populate_username(request, user)
if commit:
# Ability not to commit makes it easier to derive from
# this adapter by adding
user.save()
print user
return user
def populate_username(self, request, user):
# validate the already generated username with django validation
# if it passes use that, otherwise use django-allauth's way of
# generating a unique username
try:
user.full_clean()
safe_username = user_username(user)
except ValidationError:
safe_username = self.generate_unique_username([
user_field(user, 'first_name'),
user_field(user, 'last_name'),
user_email(user),
user_username(user)
])
user_username(user, safe_username)
def clean(self):
super(SignupForm, self).clean()
# `password` cannot be of type `SetPasswordField`, as we don't
# have a `User` yet. So, let's populate a dummy user to be used
# for password validaton.
dummy_user = get_user_model()
user_email(dummy_user, self.cleaned_data.get("email"))
password = self.cleaned_data.get('password1')
if password:
try:
get_adapter().clean_password(password, user=dummy_user)
except forms.ValidationError as e:
self.add_error('password1', e)
if "password1" in self.cleaned_data \
and "password2" in self.cleaned_data:
if self.cleaned_data["password1"] \
!= self.cleaned_data["password2"]:
self.add_error(
'password2',
_("The password and confirm password fields do not match.")
)
return self.cleaned_data
def resend_verification(request):
'''Resend the verification email, if no verified email exists.
'''
# success = send_email_confirmation(request, request.user)
email = user_email(request.user)
if email:
email_address = EmailAddress.objects.get_for_user(request.user, email)
if not email_address.verified:
confirmation = email_address.send_confirmation(request,
signup=False)
success = confirmation != None
else:
success = False
else:
success = False
return JsonResponse({'success': success})
def revert_usernames(apps, schema_editor):
User = apps.get_model('auth', 'User')
for user in User.objects.exclude(username='******'):
old_username = user.username
user_username(
user,
generate_unique_username([
user_field(user, 'first_name'),
user_field(user, 'last_name'),
user_email(user),
user_username(user),
])
)
if user_username(user) != old_username:
user.save()
def send_email_confirmation(request, user, signup=False, **kwargs):
"""
E-mail verification mails are sent:
a) Explicitly: when a user signs up
b) Implicitly: when a user attempts to log in using an unverified
e-mail while EMAIL_VERIFICATION is mandatory.
Especially in case of b), we want to limit the number of mails
sent (consider a user retrying a few times), which is why there is
a cooldown period before sending a new mail.
"""
from .models import SmallsEmailAddress, SmallsEmailConfirmation
COOLDOWN_PERIOD = timedelta(minutes=3)
email = user_email(user)
if email:
try:
email_address = SmallsEmailAddress.objects.get(user=user,
email__iexact=email)
if not email_address.verified:
send_email = not SmallsEmailConfirmation.objects \
.filter(sent__gt=now() - COOLDOWN_PERIOD,
email_address=email_address) \
.exists()
if send_email:
email_address.send_confirmation(
request,
signup=signup,
activate_view=kwargs.get('activate_view'))
else:
send_email = False
except SmallsEmailAddress.DoesNotExist:
send_email = True
email_address = SmallsEmailAddress.objects.add_email(request,
user,
email,
signup=signup,
confirm=True)
assert email_address
# At this point, if we were supposed to send an email we have sent it.
if send_email:
get_adapter().add_message(
request, messages.INFO, 'account/messages/'
'email_confirmation_sent.txt', {'email': email})
if signup:
request.session['account_user'] = user.pk
def unprimary_extra_primary_emails(self, user):
primary_email_addresses = EmailAddress.objects.filter(user=user,
primary=True)
for primary_email_address in primary_email_addresses:
if primary_email_address.email == user_email(user):
break
else:
# Didn't find the main email addresses and break the for loop
print("WARNING: Multiple primary without a user.email match for"
"user pk %s; (tried: %s, using: %s)") % (user.pk, ", ".join([
email_address.email
for email_address in primary_email_addresses
]), primary_email_address)
primary_email_addresses.exclude(pk=primary_email_address.pk).update(
primary=False)
def get_signup_form_initial_data(self, sociallogin):
user = sociallogin.user
initial = {
'email':
user_email(user) or '',
'uni_id':
sociallogin.account.extra_data.get('user').get('username') or '',
'nickname':
sociallogin.account.extra_data.get('nickname') or '',
'first_name':
user_field(user, 'first_name') or '',
'last_name':
user_field(user, 'last_name') or ''
}
return initial
def fix_usernames(apps, schema_editor):
User = apps.get_model('auth', 'User')
for user in User.objects.exclude(username='******'):
if user.email and '@' in user.email:
email_username = user.email.split('@')[0]
old_username = user.username
user_username(
user,
generate_unique_username([
email_username,
user_field(user, 'first_name'),
user_field(user, 'last_name'),
user_email(user),
user_username(user),
]))
if user_username(user) != old_username:
user.save()
def resend_verification(request):
'''Resend the verification email, if no verified email exists.
'''
# success = send_email_confirmation(request, request.user)
email = user_email(request.user)
if email:
email_address = EmailAddress.objects.get_for_user(request.user, email)
if not email_address.verified:
confirmation = email_address.send_confirmation(request, signup=False)
success = confirmation != None
else:
success = False
else:
success = False
return JsonResponse({
'success': success
})
def is_auto_signup_allowed(self, request, sociallogin):
# If email is specified, check for duplicate and if so, no auto signup.
auto_signup = app_settings.AUTO_SIGNUP
if auto_signup:
email = user_email(sociallogin.user)
# Let's check if auto_signup is really possible...
if email:
if settings.ACCOUNT_UNIQUE_EMAIL:
# Change: in Badge always check for email
if email_address_exists(email):
# Oops, another user already has this address.
# Otherwise False, because we cannot trust which provider properly verified the emails.
auto_signup = False
elif app_settings.EMAIL_REQUIRED:
# Nope, email is required and we don't have it yet...
auto_signup = False
return auto_signup
def send_email_confirmation(request, user, signup=False, **kwargs):
"""
E-mail verification mails are sent:
a) Explicitly: when a user signs up
b) Implicitly: when a user attempts to log in using an unverified
e-mail while EMAIL_VERIFICATION is mandatory.
Especially in case of b), we want to limit the number of mails
sent (consider a user retrying a few times), which is why there is
a cooldown period before sending a new mail.
"""
from .models import SmallsEmailAddress, SmallsEmailConfirmation
COOLDOWN_PERIOD = timedelta(minutes=3)
email = user_email(user)
if email:
try:
email_address = SmallsEmailAddress.objects.get(user=user, email__iexact=email)
if not email_address.verified:
send_email = not SmallsEmailConfirmation.objects \
.filter(sent__gt=now() - COOLDOWN_PERIOD,
email_address=email_address) \
.exists()
if send_email:
email_address.send_confirmation(request,
signup=signup, activate_view=kwargs.get('activate_view'))
else:
send_email = False
except SmallsEmailAddress.DoesNotExist:
send_email = True
email_address = SmallsEmailAddress.objects.add_email(request,
user,
email,
signup=signup,
confirm=True)
assert email_address
# At this point, if we were supposed to send an email we have sent it.
if send_email:
get_adapter().add_message(request,
messages.INFO,
'account/messages/'
'email_confirmation_sent.txt',
{'email': email})
if signup:
request.session['account_user'] = user.pk
def fix_usernames(apps, schema_editor):
User = apps.get_model('auth', 'User')
for user in User.objects.exclude(username='******'):
if user.email and '@' in user.email:
email_username = user.email.split('@')[0]
old_username = user.username
user_username(
user,
generate_unique_username([
email_username,
user_field(user, 'first_name'),
user_field(user, 'last_name'),
user_email(user),
user_username(user),
])
)
if user_username(user) != old_username:
user.save()
def __init__(self, *args, **kwargs):
self.sociallogin = kwargs.pop('sociallogin')
user = self.sociallogin.account.user
# TODO: Should become more generic, not listing
# a few fixed properties.
initial = {
'email': user_email(user) or '',
'username': user_username(user) or '',
'first_name': user_field(user, 'first_name') or '',
'last_name': user_field(user, 'last_name') or ''
}
kwargs.update({
'initial':
initial,
'email_required':
kwargs.get('email_required', app_settings.EMAIL_REQUIRED)
})
super(SignupForm, self).__init__(*args, **kwargs)
def is_auto_signup_allowed(self, request, sociallogin):
# If email is specified, check for duplicate and if so, no auto signup.
auto_signup = app_settings.AUTO_SIGNUP
if auto_signup:
email = user_email(sociallogin.user)
# Let's check if auto_signup is really possible...
if email:
if account_settings.UNIQUE_EMAIL:
if email_address_exists(email):
auto_signup = False
# FIXME: We redirect to signup form -- user will
# see email address conflict only after posting
# whereas we detected it here already.
elif app_settings.EMAIL_REQUIRED:
# Nope, email is required and we don't have it yet...
auto_signup = False
return auto_signup
def populate_user(self, request, sociallogin, data):
first_name = data.get('first_name')
last_name = data.get('last_name')
email = data.get('email')
name = data.get('name')
username = data.get('username')
user = sociallogin.account.user
print(sociallogin.account.provider)
# TODO: Consider using the super class for the stuff that is not unique to facebook!
if sociallogin.account.provider == 'facebook':
user_email(user, valid_email_or_none(email) or '')
name_parts = (name or '').partition(' ')
user_field(user, 'first_name', first_name or name_parts[0])
user_field(user, 'last_name', last_name or name_parts[2])
# Save a good username
if username:
username_suggestions = [username, first_name, last_name, email, 'user']
else:
username_suggestions = [first_name, last_name, email, 'user']
user_username(user, generate_unique_username(username_suggestions))
return user
elif sociallogin.account.provider == 'twitter':
if "screen_name" in sociallogin.account.extra_data.keys():
username = sociallogin.account.extra_data['screen_name']
user_email(user, valid_email_or_none(email) or '')
name_parts = (name or '').partition(' ')
user_field(user, 'first_name', first_name or name_parts[0])
user_field(user, 'last_name', last_name or name_parts[2])
# Save a good username
if username:
username_suggestions = [username, first_name, last_name, email, 'user']
else:
username_suggestions = [first_name, last_name, email, 'user']
user_username(user, generate_unique_username(username_suggestions))
return user
elif sociallogin.account.provider == 'google':
#if "screen_name" in sociallogin.account.extra_data.keys():
# username = sociallogin.account.extra_data['screen_name']
user_email(user, valid_email_or_none(email) or '')
name_parts = (name or '').partition(' ')
user_field(user, 'first_name', first_name or name_parts[0])
user_field(user, 'last_name', last_name or name_parts[2])
print("sociallogin.account.extra_data:", str(sociallogin.account.extra_data).encode('utf-8'))
if username:
username_suggestions = [username, first_name, last_name, email, 'user']
else:
username_suggestions = [first_name, last_name, email, 'user']
user_username(user, generate_unique_username(username_suggestions))
return user
else:
return super(SocialAccountAdapter, self).populate_user(request, sociallogin, data)
def unprimary_extra_primary_emails(self, user):
primary_email_addresses = EmailAddress.objects.filter(
user=user, primary=True)
for primary_email_address in primary_email_addresses:
if primary_email_address.email == user_email(user):
break
else:
# Didn't find the main email addresses and break the for loop
print ("WARNING: Multiple primary without a user.email match for"
"user pk %s; (tried: %s, using: %s)") % (
user.pk,
", ".join([email_address.email
for email_address
in primary_email_addresses]),
primary_email_address)
primary_email_addresses.exclude(pk=primary_email_address.pk
).update(primary=False)
def populate_user(self, request, sociallogin, data):
first_name = data.get('first_name')
last_name = data.get('last_name')
email = data.get('email')
name = data.get('name')
username = data.get('username')
user = sociallogin.account.user
# TODO: Consider using the super class for the stuff that is not unique to facebook!
if sociallogin.account.provider == 'facebook':
user_email(user, valid_email_or_none(email) or '')
name_parts = (name or '').partition(' ')
user_field(user, 'first_name', first_name or name_parts[0])
user_field(user, 'last_name', last_name or name_parts[2])
# Save a good username
if username:
username_suggestions = [username, first_name, last_name, email, 'user']
else:
username_suggestions = [first_name, last_name, email, 'user']
user_username(user, generate_unique_username(username_suggestions))
return user
elif sociallogin.account.provider == 'twitter':
if "screen_name" in sociallogin.account.extra_data.keys():
username = sociallogin.account.extra_data['screen_name']
user_email(user, valid_email_or_none(email) or '')
name_parts = (name or '').partition(' ')
user_field(user, 'first_name', first_name or name_parts[0])
user_field(user, 'last_name', last_name or name_parts[2])
# Save a good username
if username:
username_suggestions = [username, first_name, last_name, email, 'user']
else:
username_suggestions = [first_name, last_name, email, 'user']
user_username(user, generate_unique_username(username_suggestions))
return user
elif sociallogin.account.provider == 'google':
#if "screen_name" in sociallogin.account.extra_data.keys():
# username = sociallogin.account.extra_data['screen_name']
user_email(user, valid_email_or_none(email) or '')
name_parts = (name or '').partition(' ')
user_field(user, 'first_name', first_name or name_parts[0])
user_field(user, 'last_name', last_name or name_parts[2])
if username:
username_suggestions = [username, first_name, last_name, email, 'user']
else:
username_suggestions = [first_name, last_name, email, 'user']
user_username(user, generate_unique_username(username_suggestions))
return user
else:
return super(SocialAccountAdapter, self).populate_user(request, sociallogin, data)
def populate_username(self, request, user):
"""
Fills in a valid username, if required and missing. If the
username is already present it is assumed to be valid
(unique).
"""
from allauth.account.utils import user_username, user_email, user_field
first_name = user_field(user, 'first_name')
last_name = user_field(user, 'last_name')
# pass it the full name as the first item in 'txts' instead
user_name = first_name + last_name
email = user_email(user)
username = user_username(user)
if app_settings.USER_MODEL_USERNAME_FIELD:
user_username(
user, username or self.generate_unique_username([
user_name, first_name, last_name, email, username, 'user'
]))
def populate_user(self, request, sociallogin, data):
first_name = data.get("first_name")
last_name = data.get("last_name")
email = data.get("email")
name = data.get("name")
username = data.get("username")
user = sociallogin.account.user
# TODO: Consider using the super class for the stuff that is not unique to facebook!
if sociallogin.account.provider == "facebook":
user_email(user, valid_email_or_none(email) or "")
name_parts = (name or "").partition(" ")
user_field(user, "first_name", first_name or name_parts[0])
user_field(user, "last_name", last_name or name_parts[2])
# Save a good username
if username:
username_suggestions = [username, first_name, last_name, email, "user"]
else:
username_suggestions = [first_name, last_name, email, "user"]
user_username(user, generate_unique_username(username_suggestions))
return user
elif sociallogin.account.provider == "twitter":
if "screen_name" in sociallogin.account.extra_data.keys():
username = sociallogin.account.extra_data["screen_name"]
user_email(user, valid_email_or_none(email) or "")
name_parts = (name or "").partition(" ")
user_field(user, "first_name", first_name or name_parts[0])
user_field(user, "last_name", last_name or name_parts[2])
# Save a good username
if username:
username_suggestions = [username, first_name, last_name, email, "user"]
else:
username_suggestions = [first_name, last_name, email, "user"]
user_username(user, generate_unique_username(username_suggestions))
return user
elif sociallogin.account.provider == "google":
# if "screen_name" in sociallogin.account.extra_data.keys():
# username = sociallogin.account.extra_data['screen_name']
user_email(user, valid_email_or_none(email) or "")
name_parts = (name or "").partition(" ")
user_field(user, "first_name", first_name or name_parts[0])
user_field(user, "last_name", last_name or name_parts[2])
if username:
username_suggestions = [username, first_name, last_name, email, "user"]
else:
username_suggestions = [first_name, last_name, email, "user"]
user_username(user, generate_unique_username(username_suggestions))
return user
else:
return super(SocialAccountAdapter, self).populate_user(request, sociallogin, data)
def post(self, request, student):
student = get_object_or_404(
Student,
teacher=request.user,
user__username=student,
)
user = student.user
email = user_email(request.user)
if not email:
messages.error(
request,
"Can not send a password reset link since your account ({}) doesn't have an email address associated with it.".format(request.user.username)
)
return redirect('teachers:teacher')
temp_key = default_token_generator.make_token(user)
path = reverse(
'account_reset_password_from_key',
kwargs={'uidb36': user_pk_to_url_str(user), 'key': temp_key},
)
context = {
'current_site': get_current_site(request),
'user': user,
'password_reset_url': build_absolute_uri(request, path),
'request': request,
'username': user_username(user),
'timeout_days': settings.PASSWORD_RESET_TIMEOUT_DAYS,
}
get_adapter(request).send_mail(
'teachers/email/password_reset_key',
email,
context,
)
messages.success(
request,
"Password reset link for user {user} has been sent to your email address ({email})".format(
user=user, email=email)
)
return redirect('teachers:teacher')
def is_open_for_signup(self, request, sociallogin):
email = user_email(sociallogin.user)
# If we have a user with that email already, we don't allow
# a signup through a new provider. Revisit this in the future.
if email_address_exists(email):
User = get_user_model()
try:
user = User.objects.get(email__iexact=email)
social_set = user.socialaccount_set.all()
# If the account doesn't have any social logins yet,
# allow the signup.
if not social_set:
return True
providers = [a.provider for a in social_set]
request.other_logins = LoginMethod.objects.filter(
provider_id__in=providers)
except User.DoesNotExist:
request.other_logins = []
return False
else:
return True
def user_info(request):
headers = extract_headers(request)
user = request.user
if not user:
out = {'success': False,
'status': 'error',
'errors': {'user': ['User is not authenticated']}
}
return json_response(out, status=401)
if 'Authorization' not in headers and 'Bearer' not in headers["Authorization"]:
out = {'success': False,
'status': 'error',
'errors': {'auth': ['No token provided.']}
}
return json_response(out, status=403)
groups = [group.name for group in user.groups.all()]
if user.is_superuser:
groups.append("admin")
user_info = json.dumps({
"sub": str(user.id),
"name": " ".join([user_field(user, 'first_name'), user_field(user, 'last_name')]),
"given_name": user_field(user, 'first_name'),
"family_name": user_field(user, 'last_name'),
"email": user_email(user),
"preferred_username": user_username(user),
"groups": groups
})
response = HttpResponse(
user_info,
content_type="application/json"
)
response['Cache-Control'] = 'no-store'
response['Pragma'] = 'no-cache'
return response
def save_user(self, request, sociallogin, form=None):
email = user_email(sociallogin.account.user)
try:
u = User.objects.get(email=email)
sociallogin.account.user = u
u = super(CFSocialAccountAdapter,
self).save_user(request, sociallogin, form)
except:
try:
u = super(CFSocialAccountAdapter,
self).save_user(request, sociallogin, form)
except:
u = User.objects.get(email=email)
u.username = email.replace('@neuro.fchampalimaud.org', '').replace(
'@research.fchampalimaud.org', '')
u.set_password(User.objects.make_random_password(length=50))
u.is_staff = True
g = Group.objects.get(name=settings.PROFILE_GUEST)
u.groups.add(g)
u.save()
return u
def pre_social_login(self, _, sociallogin):
"""Invoked after a user successfully auths with a provider, but before
the login is actually processed on our side and before the
pre_social_login signal is emitted.
We use this hook to abort the login if the user is not coming from a
whitelisted domain. Otherwise this hook has no effect and the login
proceeds as normal.
Args:
request: (unused)
sociallogin: an allauth sociallogin instance with user data attached
Raises:
ImmediateHttpResponse if user's email domain is not in the whitelist
"""
social_login_email = user_email(sociallogin.user)
domain = social_login_email.split('@')[1]
if domain not in settings.STAFF_EMAIL_DOMAIN_WHITELIST:
# TODO(matt): log this
login_url = urlresolvers.reverse('endagaweb.views.user.loginview')
raise ImmediateHttpResponse(redirect(login_url))
def user_info(request):
headers = extract_headers(request)
user = request.user
if not user:
out = {'success': False,
'status': 'error',
'errors': {'user': ['User is not authenticated']}
}
return json_response(out, status=401)
if 'Authorization' not in headers and 'Bearer' not in headers["Authorization"]:
out = {'success': False,
'status': 'error',
'errors': {'auth': ['No token provided.']}
}
return json_response(out, status=403)
groups = [group.name for group in user.groups.all()]
if user.is_superuser:
groups.append("admin")
user_info = json.dumps({
"sub": str(user.id),
"name": " ".join([user_field(user, 'first_name'), user_field(user, 'last_name')]),
"given_name": user_field(user, 'first_name'),
"family_name": user_field(user, 'last_name'),
"email": user_email(user),
"preferred_username": user_username(user),
"groups": groups
})
response = HttpResponse(
user_info,
content_type="application/json"
)
response['Cache-Control'] = 'no-store'
response['Pragma'] = 'no-cache'
return response
def test_email_address_created(self):
factory = RequestFactory()
request = factory.get('/accounts/login/callback/')
request.user = AnonymousUser()
SessionMiddleware().process_request(request)
MessageMiddleware().process_request(request)
User = get_user_model()
user = User()
setattr(user, account_settings.USER_MODEL_USERNAME_FIELD, 'test')
setattr(user, account_settings.USER_MODEL_EMAIL_FIELD, '*****@*****.**')
account = SocialAccount(user=user, provider='openid', uid='123')
sociallogin = SocialLogin(account)
complete_social_login(request, sociallogin)
user = User.objects.get(
**{account_settings.USER_MODEL_USERNAME_FIELD: 'test'})
self.assertTrue(
SocialAccount.objects.filter(user=user, uid=account.uid).exists())
self.assertTrue(
EmailAddress.objects.filter(user=user,
email=user_email(user)).exists())
def send_giftorder_mail(self, total_price, user):
# TODO: move bank, beneficiary, account, reply e-mail into preferences.
# TODO: make nicer HTML mail....
messagetext = _(
"Thank you so much for ordering a voucher and helping the couple to make their dream come true!"
) + "\n\n"
messagetext += _(
"The voucher will be issued after payment receipt.") + "\n\n"
messagetext += _("Please send your payment as follows: ") + "\n\n"
messagetext += _("Bank") + ": Zürcher Kantonalbank" + "\n"
messagetext += _("Account") + ": IBAN CH68 0070 0110 0056 1840 3\n"
messagetext += _(
"In favour of") + ": Sibylle Widmer + Marco Zurbriggen\n"
messagetext += _("Amount") + ": " + total_price.__str__() + "\n\n"
try:
send_mail(
subject="The Travelling 2 - Voucher Order",
message=messagetext,
from_email="*****@*****.**",
recipient_list=[user_email(user)],
)
except:
pass
def user_info(request):
is_authenticated = OAuthAuthentication().is_authenticated(request)
if is_authenticated:
user = request.user
groups = [group.name for group in user.groups.all()]
if user.is_superuser:
groups.append("admin")
user_info = json.dumps({
"sub":
str(user.id),
"name":
" ".join([
user_field(user, 'first_name'),
user_field(user, 'last_name')
]),
"given_name":
user_field(user, 'first_name'),
"family_name":
user_field(user, 'last_name'),
"email":
user_email(user),
"preferred_username":
user_username(user),
"groups":
groups
})
response = HttpResponse(user_info, content_type="application/json")
response['Cache-Control'] = 'no-store'
response['Pragma'] = 'no-cache'
return response
else:
return HttpResponse(status=404)
def save_user(self, request, user, serializer, commit=True):
"""
Saves a new `User` instance using information provided in the
signup form.
"""
secure = request.is_secure()
protocol = 'https' if secure == True else 'http'
serializer = registroSerializer(data=request.data)
url = '%s://%s' % (protocol, request.get_host())
if serializer.is_valid():
affiliate = serializer.validated_data.pop('affiliate', None)
data = serializer.validated_data
instance = data.get('instance')
client_type = data.pop('client_type', None)
first_name = data.get('first_name')
last_name = data.get('last_name')
email = data.get('email')
username = data.get('email').replace('@', '')
user_email(user, email)
user_username(user, username)
if first_name:
user_field(user, 'first_name', first_name)
if last_name:
user_field(user, 'last_name', last_name)
if 'password1' in data:
user.set_password(data["password1"])
else:
user.set_unusable_password()
self.populate_username(request, user)
if commit:
user.save()
# Ability not to commit makes it easier to derive from
# this adapter by adding
if client_type:
if client_type == 'condominio':
condominio_data = {
'rif': data.get('rif'),
'pais': data.get('pais'),
'terminos': data.get('terminos'),
'comprobante_rif': data.get('comprobante_rif'),
'user': user
}
instance = Condominio.objects.create(**condominio_data)
if affiliate:
instance.affiliate = affiliate
comission = get_comission(affiliate)
affiliate.comission = comission
affiliate.save()
#send email to affiliate
protocol = 'https' if request.is_secure(
) else 'http'
site_name = get_current_site(request).name
site_url = protocol + '://' + site_name
message_context = {
'affiliate':
affiliate.user.get_full_name(),
'condominio_name':
str(data.get('first_name')) + ' ' +
str(data.get('last_name') or ''),
'site_url':
site_url,
'rif':
data.get('rif'),
'pais':
data.get('pais')
}
subject_context = {
'condominio_name':
str(data.get('first_name')) + ' ' +
str(data.get('last_name') or '')
}
subject = loader.render_to_string(
'account/email/affiliate_condo_subject.txt',
subject_context)
message = loader.render_to_string(
'account/email/affiliate_condo_message.txt',
message_context)
send_email.delay(subject, message,
settings.DEFAULT_FROM_EMAIL,
[affiliate.user.email])
elif client_type == 'afiliado':
afiliado_dada = {
'rif': data.get('rif'),
'terminos': data.get('terminos'),
'comprobante_rif': data.get('comprobante_rif'),
'comission': 0.10,
'user': user
#'url' : url + '/#/registro?affiliate='+ str(user.id)
}
instance = Affiliate.objects.create(**afiliado_dada)
instance.url = url + '/#/registro?affiliate=' + str(
user.pk)
instance.save()
return user
else:
return Response(serializer.errors)
def populate_username(self, request, user):
# override the username population to always use the email
user_field(user, app_settings.USER_MODEL_USERNAME_FIELD, user_email(user))
def _update_session(self, request, sociallogin):
email = user_email(sociallogin.user)
set_session_verification_email(request, email)
def create_default_provider(user) -> chain:
email = user_email(user) # type: str
return guess_configuration.s(email) | _create_email_account_task.s(
user.id) | verify_email_account_task.s(user.id)
def pre_social_login(self, request, sociallogin):
email = user_email(sociallogin.user)
UserModel = get_user_model()
login_provider_id = sociallogin.account.provider
if (
not email or
not email_address_exists(email) or
sociallogin.state.get('process') != AuthProcess.LOGIN
):
# This is a new email address, or we're connecting social accounts
# so we don't need to do anything
return
try:
user = UserModel.objects.get(email=email)
except UserModel.DoesNotExist:
# This case shouldn't really happen, but even if it does, we
# don't do anything and let the default behavior kick in.
return
social_accounts = list(SocialAccount.objects.filter(
user=user
).values_list('provider', flat=True))
if len(social_accounts) == 0:
# This is a hack to associate existing accounts on pulse
# that were added via Google Auth the old way to the new allauth
# system. We only do this for new logins into this system.
request.migrate_user = user
elif login_provider_id in social_accounts:
# In this case, the existing user already has a social account
# and is logging into it using the same provider.
return
else:
# Here the user already has a Pulse social account (e.g. Google)
# but is logging in through a different social network
# (e.g. Github) that uses the same email for the first time.
# We redirect them to the login view where they have to login
# through their existing social account on Pulse before going to
# the Social Account Connections view to connect their secondary
# social account.
url = reverse('account_login')
qs = QueryDict(mutable=True)
next_url = sociallogin.get_redirect_url(request)
if next_url:
# We encode the final destination url in the connection
# view url so that users are correctly rerouted after
# connecting their accounts.
qs['next'] = next_url
next_url = '{url}?{qs}'.format(
url=reverse('socialaccount_connections'),
qs=qs.urlencode()
)
qs = QueryDict(mutable=True)
qs['next'] = next_url
qs['promptconnection'] = True
qs['provider'] = providers.registry.by_id(login_provider_id).name
raise ImmediateHttpResponse(
response=HttpResponseRedirect(f'{url}?{qs.urlencode()}')
)
def _process_signup(request, sociallogin):
# If email is specified, check for duplicate and if so, no auto signup.
auto_signup = app_settings.AUTO_SIGNUP
email = user_email(sociallogin.account.user)
if auto_signup:
# Let's check if auto_signup is really possible...
if email:
if account_settings.UNIQUE_EMAIL:
if email_address_exists(email):
# Oops, another user already has this address. We
# cannot simply connect this social account to the
# existing user. Reason is that the email adress may
# not be verified, meaning, the user may be a hacker
# that has added your email address to his account in
# the hope that you fall in his trap. We cannot check
# on 'email_address.verified' either, because
# 'email_address' is not guaranteed to be verified.
auto_signup = False
# FIXME: We redirect to signup form -- user will
# see email address conflict only after posting
# whereas we detected it here already.
elif app_settings.EMAIL_REQUIRED:
# Nope, email is required and we don't have it yet...
auto_signup = False
# Stop here if invitations are required
if auth_settings.INVITATION_REQUIRED:
# Check for valid invitation key in session
if 'invitation_key' not in request.session \
or not InvitationKey.objects.is_key_valid(request.session['invitation_key']):
return HttpResponseRedirect(auth_settings.NO_INVITATION_REDIRECT)
if not auto_signup:
request.session['socialaccount_sociallogin'] = sociallogin
url = reverse('socialaccount_signup')
ret = HttpResponseRedirect(url)
else:
# If we're still on auto signup, stop if invitations are required
if auth_settings.INVITATION_REQUIRED:
# Check for valid invitation key in session
if 'invitation_key' not in request.session \
or not InvitationKey.objects.is_key_valid(request.session['invitation_key']):
return HttpResponseRedirect(
auth_settings.NO_INVITATION_REDIRECT)
# Continue with auto signup
# FIXME: This part contains a lot of duplication of logic
# ("closed" rendering, create user, send email, in active
# etc..)
try:
if not get_account_adapter().is_open_for_signup(request):
return render(request, "account/signup_closed.html")
except ImmediateHttpResponse as e:
return e.response
u = sociallogin.account.user
if account_settings.USER_MODEL_USERNAME_FIELD:
user_username(
u,
generate_unique_username(user_username(u) or email or 'user'))
for field in ['last_name', 'first_name']:
if hasattr(u, field):
truncated_value = (user_field(u, field) or '') \
[0:User._meta.get_field(field).max_length]
user_field(u, field, truncated_value)
user_email(u, email or '')
u.set_unusable_password()
sociallogin.save(request)
# Make sure the user has a primary email address
if EmailAddress.objects.filter(user=u).count() == 0:
setup_user_email(request, u)
ret = complete_social_signup(request, sociallogin)
return ret
def is_auto_signup_allowed(self, request, sociallogin):
# If email is specified, check for duplicate and if so, no auto signup.
email = user_email(sociallogin.account.user)
return email.endswith('@neuro.fchampalimaud.org') or email.endswith(
'@research.fchampalimaud.org')
def is_open_for_signup(self, request, sociallogin):
email = user_email(sociallogin.account.user)
return email.endswith('@neuro.fchampalimaud.org') or email.endswith(
'@research.fchampalimaud.org')
def custom_signup(self, request, user, commit=True):
"""Sign up for person or company using data provided."""
# user can be either Company or Person object.
from allauth.account.utils import user_email
data = self.cleaned_data
if data.get('full_name'):
try:
first_name, last_name = data.get('full_name').split(' ', 1)
except ValueError:
first_name, last_name = data.get('full_name'), None
user.first_name = first_name
user.last_name = last_name
if data.get('phone'):
user.phone = data.get('phone')
if data.get('gender'):
user.gender = data.get('gender')
username = data.get('username')
pattern = re.compile("^\d{10,13}")
match = pattern.match(username)
if match:
user.phone = username
else:
user_email(user, username)
password_set_by_user = True
password = data.get("password")
if (password == '') or (password is None):
password_set_by_user = False
password = User.objects.make_random_password()
user.set_password(password)
# self.populate_username(request, user)
if commit:
# Ability not to commit makes it easier to derive from
# this adapter by adding
user.save()
referral = create_referral(user)
user.referral = referral
# provide incentive to user who referred this user.
request = self.context.get('request')
if request and 'referral_code' in request.data:
referrer_user = get_referrer_user(request, user=user)
user.save()
# saving user_type and person or company's type depending on user object.
user.user_type = list(data['account_type'].keys())[0]
user_account_type = list(data['account_type'].values())[0]
if user.user_type == User.COMPANY:
typ, created = CompanyType.objects.get_or_create(
company_type=user_account_type)
elif user.user_type == User.PERSON:
typ, created = PersonType.objects.get_or_create(
person_type=user_account_type)
user.typ.add(typ)
# send password to post_save signal so add it in email context
if not password_set_by_user:
user._password = password
return user
def setUp(self):
self.user = get_user_model()()
allauth_utils.user_username(self.user, 'spam')
allauth_utils.user_email(self.user, '*****@*****.**')
self.user.save()
allauth_utils.sync_user_email_addresses(self.user)
def populate_user(self, request: HttpRequest, sociallogin: SocialLogin,
data: dict):
user = super().populate_user(request, sociallogin, data)
if not user_username(user):
user_username(user, user_email(user))
return user
