15 | {% blocktrans count counter=form.errors.items|length %}Please correct the error below.{% plural %}Please correct the errors below.{% endblocktrans %}
16 |
17 | {% endif %}
18 |
19 | {% if form.non_field_errors or form.this_is_the_login_form.errors %}
20 | {% for error in form.non_field_errors|add:form.this_is_the_login_form.errors %}
21 |
54 | {% endblock %}
55 |
--------------------------------------------------------------------------------
/emailusernames/tests.py:
--------------------------------------------------------------------------------
1 | from django.contrib.auth import authenticate
2 | from django.contrib.auth.models import User
3 | from django.db import IntegrityError
4 | from django.test import TestCase
5 | from emailusernames.utils import create_user
6 |
7 |
8 | class CreateUserTests(TestCase):
9 | """
10 | Tests which create users.
11 | """
12 | def setUp(self):
13 | self.email = 'user@example.com'
14 | self.password = 'password'
15 |
16 | def test_can_create_user(self):
17 | user = create_user(self.email, self.password)
18 | self.assertEquals(list(User.objects.all()), [user])
19 |
20 | def test_can_create_user_with_long_email(self):
21 | padding = 'a' * 30
22 | create_user(padding + self.email, self.password)
23 |
24 | def test_created_user_has_correct_details(self):
25 | user = create_user(self.email, self.password)
26 | self.assertEquals(user.email, self.email)
27 |
28 | def test_can_create_user_with_explicit_id(self):
29 | """Regression test for
30 | https://github.com/dabapps/django-email-as-username/issues/52
31 |
32 | """
33 | User.objects.create(email=self.email, id=1)
34 |
35 |
36 |
37 | class ExistingUserTests(TestCase):
38 | """
39 | Tests which require an existing user.
40 | """
41 |
42 | def setUp(self):
43 | self.email = 'user@example.com'
44 | self.password = 'password'
45 | self.user = create_user(self.email, self.password)
46 |
47 | def test_user_can_authenticate(self):
48 | auth = authenticate(email=self.email, password=self.password)
49 | self.assertEquals(self.user, auth)
50 |
51 | def test_user_can_authenticate_with_case_insensitive_match(self):
52 | auth = authenticate(email=self.email.upper(), password=self.password)
53 | self.assertEquals(self.user, auth)
54 |
55 | def test_user_can_authenticate_with_username_parameter(self):
56 | auth = authenticate(username=self.email, password=self.password)
57 | self.assertEquals(self.user, auth)
58 | # Invalid username should be ignored
59 | auth = authenticate(email=self.email, password=self.password,
60 | username='invalid')
61 | self.assertEquals(self.user, auth)
62 |
63 | def test_user_emails_are_unique(self):
64 | with self.assertRaises(IntegrityError) as ctx:
65 | create_user(self.email, self.password)
66 | if hasattr(ctx.exception, 'message'):
67 | self.assertEquals(ctx.exception.message, 'user email is not unique')
68 | else:
69 | self.assertEquals(str(ctx.exception), 'user email is not unique')
70 |
71 | def test_user_emails_are_case_insensitive_unique(self):
72 | with self.assertRaises(IntegrityError) as ctx:
73 | create_user(self.email.upper(), self.password)
74 | if hasattr(ctx.exception, 'message'):
75 | self.assertEquals(ctx.exception.message, 'user email is not unique')
76 | else:
77 | self.assertEquals(str(ctx.exception), 'user email is not unique')
78 |
79 | def test_user_unicode(self):
80 | if isinstance(self.email, str):
81 | self.assertEquals(str(self.user), self.email)
82 | else:
83 | self.assertEquals(unicode(self.user), self.email)
84 |
--------------------------------------------------------------------------------
/emailusernames/utils.py:
--------------------------------------------------------------------------------
1 | import base64
2 | import hashlib
3 | import os
4 | import re
5 | import sys
6 |
7 | from django.contrib.auth.models import User
8 | from django.db import IntegrityError
9 |
10 |
11 | # We need to convert emails to hashed versions when we store them in the
12 | # username field. We can't just store them directly, or we'd be limited
13 | # to Django's username <= 30 chars limit, which is really too small for
14 | # arbitrary emails.
15 | def _email_to_username(email):
16 | # Emails should be case-insensitive unique
17 | email = email.lower()
18 | # Deal with internationalized email addresses
19 | converted = email.encode('utf8', 'ignore')
20 | return base64.urlsafe_b64encode(hashlib.sha256(converted).digest())[:30]
21 |
22 |
23 | def get_user(email, queryset=None):
24 | """
25 | Return the user with given email address.
26 | Note that email address matches are case-insensitive.
27 | """
28 | if queryset is None:
29 | queryset = User.objects
30 | return queryset.get(username=_email_to_username(email))
31 |
32 |
33 | def user_exists(email, queryset=None):
34 | """
35 | Return True if a user with given email address exists.
36 | Note that email address matches are case-insensitive.
37 | """
38 | try:
39 | get_user(email, queryset)
40 | except User.DoesNotExist:
41 | return False
42 | return True
43 |
44 |
45 | _DUPLICATE_USERNAME_ERRORS = (
46 | 'column username is not unique',
47 | 'UNIQUE constraint failed: auth_user.username',
48 | 'duplicate key value violates unique constraint "auth_user_username_key"\n'
49 | )
50 |
51 |
52 | def create_user(email, password=None, is_staff=None, is_active=None):
53 | """
54 | Create a new user with the given email.
55 | Use this instead of `User.objects.create_user`.
56 | """
57 | try:
58 | user = User.objects.create_user(email, email, password)
59 | except IntegrityError as err:
60 | regexp = '|'.join(re.escape(e) for e in _DUPLICATE_USERNAME_ERRORS)
61 | if re.match(regexp, str(err)):
62 | raise IntegrityError('user email is not unique')
63 | raise
64 |
65 | if is_active is not None or is_staff is not None:
66 | if is_active is not None:
67 | user.is_active = is_active
68 | if is_staff is not None:
69 | user.is_staff = is_staff
70 | user.save()
71 | return user
72 |
73 |
74 | def create_superuser(email, password):
75 | """
76 | Create a new superuser with the given email.
77 | Use this instead of `User.objects.create_superuser`.
78 | """
79 | return User.objects.create_superuser(email, email, password)
80 |
81 |
82 | def migrate_usernames(stream=None, quiet=False):
83 | """
84 | Migrate all existing users to django-email-as-username hashed usernames.
85 | If any users cannot be migrated an exception will be raised and the
86 | migration will not run.
87 | """
88 | stream = stream or (quiet and open(os.devnull, 'w') or sys.stdout)
89 |
90 | # Check all users can be migrated before applying migration
91 | emails = set()
92 | errors = []
93 | for user in User.objects.all():
94 | if not user.email:
95 | errors.append("Cannot convert user '%s' because email is not "
96 | "set." % (user._username, ))
97 | elif user.email.lower() in emails:
98 | errors.append("Cannot convert user '%s' because email '%s' "
99 | "already exists." % (user._username, user.email))
100 | else:
101 | emails.add(user.email.lower())
102 |
103 | # Cannot migrate.
104 | if errors:
105 | [stream.write(error + '\n') for error in errors]
106 | raise Exception('django-email-as-username migration failed.')
107 |
108 | # Can migrate just fine.
109 | total = User.objects.count()
110 | for user in User.objects.all():
111 | user.username = _email_to_username(user.email)
112 | user.save()
113 |
114 | stream.write("Successfully migrated usernames for all %d users\n"
115 | % (total, ))
116 |
--------------------------------------------------------------------------------
/manage.py:
--------------------------------------------------------------------------------
1 | #!/usr/bin/env python
2 | import os
3 | import sys
4 |
5 | if __name__ == "__main__":
6 | os.environ.setdefault("DJANGO_SETTINGS_MODULE", "testsettings")
7 |
8 | from django.core.management import execute_from_command_line
9 |
10 | args = sys.argv
11 | if len(args) == 2 and args[1] == 'test':
12 | args.append('emailusernames')
13 |
14 | execute_from_command_line(args)
15 |
--------------------------------------------------------------------------------
/setup.py:
--------------------------------------------------------------------------------
1 | #!/usr/bin/env python
2 | # -*- coding: utf-8 -*-
3 |
4 | import os
5 | import sys
6 | from distutils.core import setup
7 | import emailusernames
8 |
9 | version = emailusernames.__version__
10 |
11 | if sys.argv[-1] == 'publish':
12 | os.system("python setup.py sdist upload")
13 | print("You probably want to also tag the version now:")
14 | print(" git tag -a %s -m 'version %s'" % (version, version))
15 | print(" git push --tags")
16 | sys.exit()
17 |
18 |
19 | def get_packages(root):
20 | """
21 | Return root package and all sub-packages.
22 | """
23 | return [x[0] for x in os.walk(root)
24 | if os.path.exists(os.path.join(x[0], '__init__.py'))]
25 |
26 |
27 | def get_package_data(root):
28 | """
29 | Return all files under the root package, that are not in a
30 | package themselves.
31 | """
32 | walk = [(x[0].replace(root + os.sep, '', 1), x[2])
33 | for x in os.walk(root)
34 | if not os.path.exists(os.path.join(x[0], '__init__.py'))]
35 |
36 | file_list = []
37 | for base, files in walk:
38 | file_list.extend([os.path.join(base, file) for file in files])
39 | return {root: file_list}
40 |
41 |
42 | setup(
43 | name='py2-py3-django-email-as-username',
44 | version=version,
45 | description='User authentication with email addresses instead of usernames.',
46 | author='Tom Christie',
47 | author_email='',
48 | maintainer='Harmo',
49 | maintainer_email='dtharmo@gmail.com',
50 | url='https://github.com/harmo/django-email-as-username',
51 | packages=get_packages('emailusernames'),
52 | package_data=get_package_data('emailusernames'),
53 | license='BSD',
54 | )
55 |
--------------------------------------------------------------------------------
/testsettings.py:
--------------------------------------------------------------------------------
1 | import os
2 |
3 | DATABASES = {
4 | 'default': {
5 | 'ENGINE': 'django.db.backends.sqlite3',
6 | 'NAME': ':memory:',
7 | },
8 | }
9 |
10 | SECRET_KEY = os.environ.get('SECRET_KEY', 'SeCrEt!')
11 |
12 | INSTALLED_APPS = (
13 | 'django.contrib.auth',
14 | 'django.contrib.contenttypes',
15 | 'emailusernames',
16 | )
17 |
18 | AUTHENTICATION_BACKENDS = (
19 | 'emailusernames.backends.EmailAuthBackend',
20 | )
21 |
--------------------------------------------------------------------------------