def sync_user(user, userdata):
"""Overwrite user details with data from the remote auth server"""
for k in ['email', 'first_name', 'last_name']:
if getattr(user, k) != userdata[k]:
setattr(user, k, userdata[k])
user.save()
try:
from allauth.account.models import EmailAddress
except ImportError:
return
# Sync email address list
for e in user.emailaddress_set.all():
if e.email not in userdata['email_addresses']:
e.delete()
for e in userdata['email_addresses']:
if user.emailaddress_set.filter(email=e).exists():
continue
emailaddress = EmailAddress(email=e)
emailaddress.save()
user.emailaddress_set.add(emailaddress)
def _add_fake_data_to_courses(self, num):
# create a pool of instructors
instructor_data = [
{'first_name': 'first', 'last_name': 'user', 'username': '******', 'email': '*****@*****.**'},
{'first_name': 'second', 'last_name': 'user', 'username': '******', 'email': '*****@*****.**'},
{'first_name': 'third', 'last_name': 'user', 'username': '******', 'email': '*****@*****.**'},
{'first_name': 'fourth', 'last_name': 'user', 'username': '******', 'email': '*****@*****.**'},
{'first_name': 'fifth', 'last_name': 'user', 'username': '******', 'email': '*****@*****.**'},
]
instructors = []
for instructor_datum in instructor_data:
user = User.objects.create_user(instructor_datum['username'], email=instructor_datum['email'], password="******")
email_address = EmailAddress(user=user, email=instructor_datum['email'], verified=True, primary=True)
user.first_name = instructor_datum['first_name']
user.last_name = instructor_datum['last_name']
user.save()
email_address.save()
instructors.append(user)
for idx in xrange(num):
course = Course(
instructor=instructors[idx % len(instructor_data)],
title='sample title ' + str(idx),
slug='sample-title-' + str(idx),
description=('sample description ' + str(idx) + '\t') * 25,
is_public = True if idx % 2 == 0 else False,
popularity=0
)
course.save()
self._generate_course_pages(course)
def _add_user(self, userdata):
email = userdata['Email']
username = userdata['Username']
user_exists = User.objects.filter(
models.Q(email=email)
| models.Q(username=username))
email_exists = EmailAddress.objects.filter(email=email)
if user_exists or email_exists:
print('Skipping user {} <{}>'.format(username, email))
else:
user = User(
username=username,
email=email,
date_joined=userdata['Creation date'],
password="******" + userdata['Password hash'],
)
user.save()
email = EmailAddress(
user=user,
email=userdata['Email'],
verified=True,
primary=True,
)
email.save()
def email(save=False, **kwargs):
if "user" not in kwargs:
kwargs["user"] = user(save=True)
if "email" not in kwargs:
kwargs["email"] = "%s@%s.com" % (get_random_string(), get_random_string())
email = EmailAddress(**kwargs)
if save:
email.save()
return email
def email(save=False, **kwargs):
if 'user' not in kwargs:
kwargs['user'] = user(save=True)
if 'email' not in kwargs:
kwargs['email'] = '%s@%s.com' % (random_str(), random_str())
email = EmailAddress(**kwargs)
if save:
email.save()
return email
def test_valid_form(self):
email = EmailAddress(user=self.user, email=self.user.email,
verified=True, primary=True)
email.save()
form = {
'login': self.user.email,
'password': '******',
}
response = self.client.post(
reverse('account_login'),
form, follow=True
)
self.assertRedirects(response, reverse('dashboard'))
def test_form_with_valid_username(self):
# Should error as we only accept email addresses now
email = EmailAddress(user=self.user, email=self.user.email,
verified=True, primary=True)
email.save()
form = {
'login': self.user.username,
'password': '******',
}
response = self.client.post(
reverse('account_login'), form, follow=True
)
self.assertEqual(response.status_code, 200)
self.assertIn('Enter a valid email address', response.content)
def extract_email_addresses(self, data):
ret = []
email = data.get('email')
if email and data.get('verified_email'):
ret.append(EmailAddress(email=email,
verified=True,
primary=True))
return ret
def extract_email_addresses(self, data):
email_addresses = []
email = data.get("email")
if email and data.get("email_verified"):
email_addresses.append(
EmailAddress(email=email, verified=True, primary=True))
return email_addresses
def extract_email_addresses(self, data):
# a salesforce user must have an email, but it might not be verified
email = EmailAddress(
email=data.get("email"),
primary=True,
verified=data.get("email_verified"),
)
return [email]
def handle(self, *args, **options):
john = get_user_model().objects.create_user(
username='******',
email='*****@*****.**',
first_name='john',
last_name='wick',
fiscal_code='1111111111111111',
registration_number='111111',
password='******')
john.save()
EmailAddress(verified=True,
primary=True,
user_id=john.id,
email=john.email).save()
tony = get_user_model().objects.create_user(
username='******',
email='*****@*****.**',
first_name='tony',
last_name='stark',
fiscal_code='2222222222222222',
registration_number='222222',
password='******')
tony.save()
EmailAddress(verified=True,
primary=True,
user_id=tony.id,
email=tony.email).save()
luke = get_user_model().objects.create_user(
username='******',
email='*****@*****.**',
first_name='luke',
last_name='skywalker',
fiscal_code='3333333333333333',
registration_number='333333',
password='******')
luke.save()
EmailAddress(verified=True,
primary=True,
user_id=luke.id,
email=luke.email).save()
self.stdout.write(
self.style.SUCCESS('College students accounts created'))
def handle(self, *args, **options):
EmailAddress.objects.all().delete()
users = get_user_model().objects.exclude(email__isnull=True, emailaddress__isnull=False)
emails = []
for user in users:
emails.append(EmailAddress(user=user, email=user.email, verified=True, primary=True))
EmailAddress.objects.bulk_create(emails, batch_size=200)
self.stdout.write("Verified %i email addresses.\n" % len(emails))
def create_user_profile(sender, instance, created, **kwargs):
if created:
Perfil.objects.create(user=instance)
if not EmailAddress.objects.filter(email=instance.email):
address = EmailAddress(user=instance,
email=instance.email,
verified=True,
primary=True)
def extract_email_addresses(self, data):
ret = []
email = data.get('email')
if email:
# If there's an email address, facebook has verified it.
# https://stackoverflow.com/questions/14280535/is-it-possible-to-check-if-an-email-is-confirmed-on-facebook
ret.append(EmailAddress(email=email, verified=True, primary=True))
return ret
def extract_email_addresses(self, data):
ret = []
email = data.get('email')
if email:
# data['verified'] does not imply the email address is
# verified.
ret.append(EmailAddress(email=email, verified=False, primary=True))
return ret
def extract_email_addresses(self, data):
ret = []
email = data.get("kaccount_email")
verified = data.get("kaccount_email_verified")
# data["kaccount_email_verified"] imply the email address is
# verified
ret.append(EmailAddress(email=email, verified=verified, primary=True))
return ret
def extract_email_addresses(self, data):
ret = [
EmailAddress(
email=data['response']['user']['settings']['email_address'],
verified=True,
primary=True)
]
return ret
def verify_user(self):
"""Verify instance user account using django-allauth constructs"""
account_emailaddresse = EmailAddress()
account_emailaddresse.email = '*****@*****.**'
account_emailaddresse.verified = True
account_emailaddresse.user_id = self.user.id
account_emailaddresse.save()
def new_user(email, username=''):
User = get_user_model()
if username:
assert is_username_unique(username)
else:
basename = email.split('@')[0]
username = make_unique_username(basename)
if User.objects.filter(email=email):
raise ValueError('Email "{}" not unique.'.format(email))
user = User(username=username, email=email)
user.save()
# Set up email for allauth.
ea = EmailAddress(user=user, email=email, primary=True, verified=False)
ea.user = user
ea.save()
return user
def update_user_email(sender: Type[EmailAddress], request: HttpRequest,
email_address: EmailAddress, **kwargs):
"""
Receive a signal when an email address is updated and confirmed.
When the signal is received, the new ``email_address``
is made primary and the old email addresses are deleted.
:param sender: The model class that sent the signal.
:param request: The original request.
:param email_address: The new email address.
"""
email_address.user.is_active = True
# Make new email_address primary
email_address.set_as_primary()
# Get rid of old email addresses
EmailAddress.objects.filter(user=email_address.user,
primary=False).delete()
def extract_email_addresses(self, data):
ret = [
EmailAddress(
email=data["response"]["user"]["settings"]["email_address"],
verified=True,
primary=True,
)
]
return ret
def extract_email_addresses(self, data):
addresses = []
for email in data.get("emails", []):
addresses.append(
EmailAddress(email=email.get("email"),
verified=email.get("verfified"),
primary=email.get("primary")))
return addresses
def test_same_email_unverified_2(self):
# A social login with an unverified email matching an existing
# verified email does nothing (no auto-signup is allowed).
self._create_user(email="*****@*****.**", verified=True)
emails = [
EmailAddress(email="*****@*****.**", verified=False, primary=True)
]
self._create_social_user(emails, "google", "10001")
self.assertEqual(SocialAccount.objects.count(), 0)
self.assertEqual(User.objects.count(), 1)
def extract_email_addresses(self, data, user=None):
# Force verification of email addresses because SurfConext will only transmit verified emails
if data.get('email'):
return [
EmailAddress(email=data['email'].strip().lower(),
verified=True,
primary=True)
]
else:
return []
def extract_email_addresses(self, data):
ret = []
email = data.get('email')
if email:
settings = self.get_settings()
verified_email = settings.get('VERIFIED_EMAIL')
verified = bool(data.get('verified') and verified_email)
ret.append(
EmailAddress(email=email, verified=verified, primary=True))
return ret
def extract_email_addresses(self, data):
"""Extract only the verified emails from GitHub."""
email_addresses = []
for email_address in data.get('email_addresses', []):
if email_address.get('verified', False):
email_addresses.append(EmailAddress(email=email_address['email'],
verified=True,
primary=email_address['primary'],
user=User()))
return email_addresses
def cleanup_email_addresses(self, email, addresses):
# Move user.email over to EmailAddress
if email and email.lower() not in [a.email.lower() for a in addresses]:
addresses.append(EmailAddress(email=email, verified=False, primary=True))
# Force verified emails
settings = self.get_settings()
verified_email = settings.get("VERIFIED_EMAIL", False)
if verified_email:
for address in addresses:
address.verified = True
def test_email_changed(user_factory, mocker, mailoutbox):
mocked_cache_inv = mocker.patch(
"squarelet.users.signals.send_cache_invalidations")
mocked_customer = mocker.patch(
"squarelet.organizations.models.Organization.customer",
new_callable=PropertyMock,
)
user = user_factory(email_failed=True)
user.individual_organization.customer = mocked_customer
old_email = EmailAddress(email="*****@*****.**")
new_email = EmailAddress(email="*****@*****.**", user=user)
signals.email_changed(None, user, old_email, new_email)
assert mocked_customer().email == new_email.email
mocked_customer().save.assert_called_once()
assert not user.email_failed
mocked_cache_inv.assert_called_with("user", user.uuid)
mail = mailoutbox[0]
assert mail.subject == "Changed email address"
assert mail.to == [old_email.email]
def extract_email_addresses(self, data):
ret = []
email = data.get("Email")
if email:
ret.append(
EmailAddress(
email=email,
verified=False,
primary=True,
))
return ret
def test_different_email(self):
# Base case: social login with an unknown email creates a new
# user
user = self._create_user(email="*****@*****.**", verified=True)
emails = [
EmailAddress(email="*****@*****.**", verified=True, primary=True)
]
self._create_social_user(emails, "google", "10001")
self.assertEqual(User.objects.count(), 2)
socialaccount = SocialAccount.objects.get(uid="10001")
self.assertTrue(socialaccount.user.id != user.id)
def extract_email_addresses(self, data):
result = []
for email_address in data.get("email_addresses", ()):
# Ignore all email addresses that have not been verified by GitHub.
email = email_address.get("email", "").strip()
if email and email_address.get("verified"):
result.append(
EmailAddress(email=email,
verified=True,
primary=email_address["primary"]))
return result
def extract_email_addresses(self, data: dict) -> List[EmailAddress]:
emails = [email for email in data.get('emails', []) if 'handle' in email]
emails.sort(key=lambda e: e.get('primary', False), reverse=True)
return [
EmailAddress(
email=email['handle'],
verified=True,
primary=True
) for email in emails if email.get('primary', False)
]
def test_download_email_verification_links(settings, superuser_client):
user = UserFactory.create()
EmailAddress(user=user, email=user.email).save()
data = {
'action': 'download_email_verification_links',
'_selected_action': User.objects.all().values_list('pk', flat=True),
}
response = superuser_client.post(reverse('admin:user_user_changelist'), data, follow=True)
assert '/accounts/confirm-email/' in str(response.content)
def test_github_unverified_match(self, mock_get):
# A github login with an unverified email should match an
# existing user with the same verified email.
user = self._create_user(email="*****@*****.**", verified=True)
emails = [
EmailAddress(email="*****@*****.**", verified=False, primary=True)
]
self._create_social_user(emails, "github", "10001", "(bad token)")
self.assertEqual(User.objects.count(), 1)
socialaccount = SocialAccount.objects.get(uid="10001")
self.assertEqual(socialaccount.user.id, user.id)
def extract_email_addresses(self, data):
email = data.get("email")
verified = convert_to_python_bool_if_value_is_json_string_bool(
data.get("email_verified", False)
)
return (
[EmailAddress(email=email, verified=verified, primary=True)]
if email
else []
)
def extract_email_addresses(self, data):
result = []
for email_address in data.get('email_addresses', ()):
# Ignore all email addresses that have not been verified by GitHub.
email = email_address.get('email', '').strip()
if email and email_address.get('verified'):
result.append(
EmailAddress(email=email,
verified=True,
primary=email_address['primary']))
return result
def test_same_email_verified(self):
# A social login matching an existing verified email attaches
# to the existing user
user = self._create_user(email="*****@*****.**", verified=True)
emails = [
EmailAddress(email="*****@*****.**", verified=True, primary=True)
]
self._create_social_user(emails, "google", "10001")
self.assertEqual(User.objects.count(), 1)
socialaccount = SocialAccount.objects.get(uid="10001")
self.assertEqual(socialaccount.user.id, user.id)
def test_expired_email_verify_link(self):
verified_count = EmailAddress.objects.filter(verified=True).count()
# create a user
user = self.create_user('username', '*****@*****.**', 'password')
# create an unverified email address
email = EmailAddress(user=user, email=user.email,
verified=False, primary=True)
email.save()
# create and email confirmation object
confirmation = self._create_confirmation(
email, datetime.now(tz) - timedelta(days=10)
)
response = self.client.post(reverse('account_confirm_email',
args=(confirmation.key,)))
self.assertEqual(response.status_code, 404)
new_verified_count = EmailAddress.objects.filter(verified=True).count()
self.assertEqual(verified_count, new_verified_count)
def extract_email_addresses(self, data):
ret = []
email = data.get('email')
if email:
settings = self.get_settings()
# data['verified'] does not imply the email address is
# verified.
verified_email = settings.get('VERIFIED_EMAIL', False)
ret.append(EmailAddress(email=email,
verified=verified_email,
primary=True))
return ret
def verify_user(self):
"""Verify instance user account using django-allauth constructs"""
account_emailaddresse = EmailAddress()
account_emailaddresse.email = '*****@*****.**'
account_emailaddresse.verified = True
account_emailaddresse.user_id = self.user.id
account_emailaddresse.save()
def handle(self, *args, **options):
passwd = getpass.getpass("Enter password:"******"User with such email/username already exists.")
u = user_model.objects.create_superuser(
options['name'], options['email'], passwd
)
u.save()
email_entity = EmailAddress(
email=options['email'], verified=True,
primary=True, user=u
)
email_entity.save()
email_confirmation_entity = EmailConfirmation(
email_address=email_entity,
created=timezone.now() - datetime.timedelta(days=1),
sent=timezone.now() - datetime.timedelta(hours=12),
key=str(uuid.uuid4()).replace('-', '')
)
email_confirmation_entity.save()
self.stdout.write(
'Successfully created superuser {0} with confirmed email address {1}'.format(
options['name'], options['email']
)
)
def obj_create(self, bundle, request = None, **kwargs):
password = bundle.data['password']
email = bundle.data['email']
try:
username = email
bundle.obj = User.objects.create_user(username, email, password)
email_address = EmailAddress(user = bundle.obj, email = email, verified = True, primary = True)
email_address.save()
#print "Success"
#student = Student(user = bundle.obj)
#print student
#student.save()
#try:
# student.gpa = bundle.data['gpa']
# student.save()
#except ValueError:
# pass
#try:
# student.zip_code = bundle.data['zip_code']
# student.save()
#except ValueError:
# pass
#bundle.obj = User(username = username, email = email, password = password)
#bundle.obj.save()
except IntegrityError:
raise BadRequest('That username already exists')
return bundle
def _save_email_addresses(self, request):
adapter = get_adapter()
# user.email may not be listed as an EmailAddress ...
user = self.account.user
try:
primary_email_address = EmailAddress.objects.get(user=user,
primary=True)
except EmailAddress.DoesNotExist:
primary_email_address = None
if (user.email
and (user.email.lower() not in [e.email.lower()
for e in self.email_addresses])):
# ... so let's append it
email_address \
= EmailAddress(user=user,
email=user.email,
verified=adapter.is_email_verified(request,
user.email),
primary=(not primary_email_address))
if not primary_email_address:
primary_email_address = email_address
self.email_addresses.append(email_address)
for email_address in self.email_addresses:
# Pick up only valid ones...
email = valid_email_or_none(email_address.email)
if not email:
continue
# ... and non-conflicting ones...
if (account_settings.UNIQUE_EMAIL
and EmailAddress.objects.filter(email__iexact=email).exists()):
continue
if email_address.primary:
if not primary_email_address:
primary_email_address = email_address
else:
email_address.primary = False
email_address.user = user
email_address.verified \
= (email_address.verified
or adapter.is_email_verified(request,
email_address.email))
email_address.save()
if primary_email_address and (not user.email or primary_email_address.email.lower() != user.email.lower()):
user.email = primary_email_address.email
user.save()
adapter.stash_email_verified(request, None)
import os
import sys
#SCRIPT TO CREATE PROFILES, AFTER CREATING USERS
#FOR CREATING USERS UNCOMMENT THE CODE COMMENTRD AND VICEVERSA
os.environ['DJANGO_SETTINGS_MODULE'] = 'pichrr.settings'
import django
from django.contrib.auth.models import User
from allauth.account.models import EmailAddress
if __name__ == '__main__':
django.setup()
usernames = ['theHulk', 'tonyStark', 'capt_America', 'Thor', 'blackWidow', 'hawkEye', 'loki', 'deadPool']
passwords = ['theHulk', 'tonyStark', 'capt_America', 'Thor', 'blackWidow', 'hawkEye', 'loki', 'deadPool']
for i in range(len(usernames)):
email = usernames[i]+'@gmail.com'
user = User.objects.create_user(username = usernames[i], password = passwords[i], email = email)
user.save()
email_address = EmailAddress(user=user,email=email, verified=True, primary=True)
email_address.save()
