├── .bandit
├── .editorconfig
├── .github
    ├── FUNDING.yml
    ├── dependabot.yml
    └── workflows
    │   ├── ci.yml
    │   └── release.yml
├── .gitignore
├── .readthedocs.yaml
├── CONTRIBUTING.rst
├── LICENSE
├── MANIFEST.in
├── README.rst
├── SECURITY.md
├── docs
    ├── conf.py
    ├── contributing.rst
    ├── customizing.rst
    ├── index.rst
    ├── privacy.rst
    ├── sample.png
    ├── settings.rst
    ├── spelling_wordlist.txt
    ├── templates.rst
    └── usage.rst
├── mailauth
    ├── __init__.py
    ├── backends.py
    ├── contrib
    │   ├── __init__.py
    │   ├── admin
    │   │   ├── __init__.py
    │   │   ├── admin.py
    │   │   ├── apps.py
    │   │   ├── locale
    │   │   │   └── de
    │   │   │   │   └── LC_MESSAGES
    │   │   │   │       └── django.po
    │   │   ├── static
    │   │   │   └── mailauth_admin
    │   │   │   │   └── css
    │   │   │   │       └── login.css
    │   │   ├── templates
    │   │   │   ├── mailauth_admin
    │   │   │   │   └── login.html
    │   │   │   └── registration
    │   │   │   │   └── login_requested.html
    │   │   └── views.py
    │   ├── user
    │   │   ├── __init__.py
    │   │   ├── admin.py
    │   │   ├── apps.py
    │   │   ├── locale
    │   │   │   └── de
    │   │   │   │   └── LC_MESSAGES
    │   │   │   │       └── django.po
    │   │   ├── migrations
    │   │   │   ├── 0001_initial.py
    │   │   │   ├── 0002_emailuser_session_salt.py
    │   │   │   ├── 0003_ci_unique_index.py
    │   │   │   ├── 0004_auto_20200812_0722.py
    │   │   │   ├── 0005_emailuser_email_hash_alter_emailuser_email.py
    │   │   │   └── __init__.py
    │   │   ├── models.py
    │   │   └── signals.py
    │   └── wagtail
    │   │   ├── __init__.py
    │   │   ├── apps.py
    │   │   ├── templates
    │   │       └── wagtailadmin
    │   │       │   └── login.html
    │   │   ├── urls.py
    │   │   └── views.py
    ├── forms.py
    ├── signing.py
    ├── templates
    │   └── registration
    │   │   ├── login_email.txt
    │   │   └── login_subject.txt
    ├── urls.py
    └── views.py
├── pyproject.toml
├── sample.png
├── setup.cfg
└── tests
    ├── __init__.py
    ├── conftest.py
    ├── contrib
        ├── __init__.py
        ├── admin
        │   ├── __init__.py
        │   ├── test_admin.py
        │   └── test_views.py
        ├── auth
        │   ├── __init__.py
        │   ├── test_admin.py
        │   ├── test_models.py
        │   └── test_signals.py
        └── wagtail
        │   ├── __init__.py
        │   └── test_views.py
    ├── test_backends.py
    ├── test_forms.py
    ├── test_models.py
    ├── test_signing.py
    ├── test_views.py
    └── testapp
        ├── __init__.py
        ├── manage.py
        ├── settings.py
        ├── urls.py
        └── wsgi.py


/.bandit:
--------------------------------------------------------------------------------
1 | [bandit]
2 | exclude: tests
3 | 


--------------------------------------------------------------------------------
/.editorconfig:
--------------------------------------------------------------------------------
 1 | # http://editorconfig.org
 2 | 
 3 | root = true
 4 | 
 5 | [*]
 6 | indent_style = space
 7 | indent_size = 4
 8 | trim_trailing_whitespace = true
 9 | insert_final_newline = true
10 | charset = utf-8
11 | end_of_line = lf
12 | 
13 | [*.{json,yml,yaml,js,jsx,toml}]
14 | indent_size = 2
15 | 
16 | [*.{html,htm}]
17 | indent_size = 2
18 | 
19 | [LICENSE]
20 | insert_final_newline = false
21 | 
22 | [Makefile]
23 | indent_style = tab
24 | 


--------------------------------------------------------------------------------
/.github/FUNDING.yml:
--------------------------------------------------------------------------------
1 | github: codingjoe
2 | custom: https://www.paypal.me/codingjoe
3 | 


--------------------------------------------------------------------------------
/.github/dependabot.yml:
--------------------------------------------------------------------------------
 1 | version: 2
 2 | updates:
 3 | - package-ecosystem: pip
 4 |   directory: "/"
 5 |   schedule:
 6 |     interval: daily
 7 | - package-ecosystem: github-actions
 8 |   directory: "/"
 9 |   schedule:
10 |     interval: daily
11 | 


--------------------------------------------------------------------------------
/.github/workflows/ci.yml:
--------------------------------------------------------------------------------
  1 | name: CI
  2 | 
  3 | on:
  4 |   push:
  5 |     branches:
  6 |       - master
  7 |   pull_request:
  8 | 
  9 | jobs:
 10 | 
 11 |   lint:
 12 |     strategy:
 13 |       fail-fast: false
 14 |       matrix:
 15 |         lint-command:
 16 |           - bandit -r . -x ./tests
 17 |           - black --check --diff .
 18 |           - flake8 .
 19 |           - isort --check-only --diff .
 20 |           - pydocstyle .
 21 |     runs-on: ubuntu-latest
 22 |     steps:
 23 |       - uses: actions/checkout@v4
 24 |       - uses: actions/setup-python@v5
 25 |         with:
 26 |           python-version: "3.x"
 27 |           cache: pip
 28 |           cache-dependency-path: pyproject.toml
 29 |       - run: python -m pip install .[lint]
 30 |       - run: ${{ matrix.lint-command }}
 31 | 
 32 |   dist:
 33 |     runs-on: ubuntu-latest
 34 |     steps:
 35 |       - uses: actions/checkout@v4
 36 |       - uses: actions/setup-python@v5
 37 |         with:
 38 |           python-version: "3.x"
 39 |       - name: Install Python dependencies
 40 |         run: python -m pip install --upgrade pip build wheel twine readme-renderer
 41 |       - run: python -m build --sdist --wheel
 42 |       - run: python -m twine check dist/*
 43 |       - uses: actions/upload-artifact@v4
 44 |         with:
 45 |           path: dist/*
 46 | 
 47 |   docs:
 48 |     runs-on: ubuntu-latest
 49 |     steps:
 50 |       - uses: actions/checkout@v4
 51 |       - uses: actions/setup-python@v5
 52 |         with:
 53 |           python-version: "3.11"
 54 |       - run: sudo apt install -y python3-enchant
 55 |       - run: python -m pip install sphinxcontrib-spelling
 56 |       - run: python -m pip install -e '.[docs]'
 57 |       - run: python -m sphinx -W -b spelling docs docs/_build
 58 | 
 59 |   SQLite:
 60 |     needs: [ lint, dist, docs ]
 61 |     runs-on: ubuntu-latest
 62 |     strategy:
 63 |       matrix:
 64 |         python-version:
 65 |           - "3.10"
 66 |           - "3.11"
 67 |           - "3.12"
 68 |         django-version:
 69 |           - "4.2"
 70 |           - "5.0"
 71 |           - "5.1"
 72 |     steps:
 73 |       - uses: actions/checkout@v4
 74 |       - uses: actions/setup-python@v5
 75 |         with:
 76 |           python-version: ${{ matrix.python-version }}
 77 |       - run: python -m pip install -e '.[test]'
 78 |       - run: python -m pip install Django~=${{ matrix.django-version }}.0
 79 |       - run: python -m pytest
 80 |       - uses: codecov/codecov-action@v5
 81 |         with:
 82 |           token: ${{ secrets.CODECOV_TOKEN }}
 83 |           flags: python-${{ matrix.python-version }}
 84 | 
 85 |   wagtail:
 86 |     needs: [ lint, dist, docs ]
 87 |     runs-on: ubuntu-latest
 88 |     strategy:
 89 |       matrix:
 90 |         python-version: [ "3.x" ]
 91 |         wagtail-version:
 92 |           - "5.2.0"
 93 |           - "6.0.0"
 94 |     steps:
 95 |       - uses: actions/checkout@v4
 96 |       - name: Set up Python ${{ matrix.python-version }}
 97 |         uses: actions/setup-python@v5
 98 |         with:
 99 |           python-version: ${{ matrix.python-version }}
100 |       - run: python -m pip install -e ".[test,wagtail]"
101 |       - run: python -m pip install wagtail~=${{ matrix.wagtail-version }}
102 |       - run: python -m pytest
103 |       - uses: codecov/codecov-action@v5
104 |         with:
105 |           token: ${{ secrets.CODECOV_TOKEN }}
106 |           flags: ${{ matrix.extras }}
107 | 
108 | 
109 |   PostgreSQL:
110 |     needs: [ lint, dist, docs ]
111 |     runs-on: ubuntu-latest
112 |     strategy:
113 |       matrix:
114 |         python-version: [ "3.x" ]
115 |     services:
116 |       postgres:
117 |         image: postgres
118 |         env:
119 |           POSTGRES_USER: django
120 |           POSTGRES_PASSWORD: django
121 |         ports:
122 |           - 5432/tcp
123 |         options: --health-cmd pg_isready --health-interval 10s --health-timeout 5s --health-retries 5
124 |     steps:
125 |       - name: Set up Python ${{ matrix.python-version }}
126 |         uses: actions/setup-python@v5
127 |         with:
128 |           python-version: ${{ matrix.python-version }}
129 |       - uses: actions/checkout@v4
130 |       - run: python -m pip install -e ".[test,postgres]"
131 |       - run: psql template1 -c "CREATE EXTENSION citext;"
132 |         env:
133 |           PGHOST: localhost
134 |           PGPORT: ${{ job.services.postgres.ports[5432] }}
135 |           PGUSER: django
136 |           PGPASSWORD: django
137 |       - run: python -m pytest
138 |         env:
139 |           DB_PORT: ${{ job.services.postgres.ports[5432] }}
140 |           DB: pg
141 |       - uses: codecov/codecov-action@v5
142 |         with:
143 |           token: ${{ secrets.CODECOV_TOKEN }}
144 |           flags: ${{ matrix.extras }}
145 | 
146 |   analyze:
147 |     name: CodeQL
148 |     needs: [ SQLite, wagtail, PostgreSQL ]
149 |     runs-on: ubuntu-latest
150 |     permissions:
151 |       actions: read
152 |       contents: read
153 |       security-events: write
154 |     strategy:
155 |       fail-fast: false
156 |       matrix:
157 |         language: [ python ]
158 |     steps:
159 |       - name: Checkout
160 |         uses: actions/checkout@v4
161 |       - name: Initialize CodeQL
162 |         uses: github/codeql-action/init@v3
163 |         with:
164 |           languages: ${{ matrix.language }}
165 |           queries: +security-and-quality
166 |       - name: Autobuild
167 |         uses: github/codeql-action/autobuild@v3
168 |         if: ${{ matrix.language == 'javascript' || matrix.language == 'python' }}
169 |       - name: Perform CodeQL Analysis
170 |         uses: github/codeql-action/analyze@v3
171 |         with:
172 |           category: "/language:${{ matrix.language }}"
173 | 


--------------------------------------------------------------------------------
/.github/workflows/release.yml:
--------------------------------------------------------------------------------
 1 | name: PyPi Release
 2 | 
 3 | on:
 4 |   release:
 5 |     types: [published]
 6 | 
 7 | jobs:
 8 |   PyPi:
 9 | 
10 |     runs-on: ubuntu-latest
11 |     steps:
12 |     - uses: actions/checkout@v4
13 |     - uses: actions/setup-python@v5
14 |       with:
15 |         python-version: "3.x"
16 |     - run: python -m pip install --upgrade pip build wheel twine
17 |     - run: python -m build --sdist --wheel
18 |     - run: python -m twine upload dist/*
19 |       env:
20 |         TWINE_USERNAME: __token__
21 |         TWINE_PASSWORD: ${{ secrets.PYPI_TOKEN }}
22 | 


--------------------------------------------------------------------------------
/.gitignore:
--------------------------------------------------------------------------------
 1 | # Byte-compiled / optimized / DLL files
 2 | __pycache__/
 3 | *.py[cod]
 4 | 
 5 | # C extensions
 6 | *.so
 7 | 
 8 | # Distribution / packaging
 9 | .Python
10 | env/
11 | build/
12 | develop-eggs/
13 | dist/
14 | downloads/
15 | eggs/
16 | .eggs/
17 | lib/
18 | lib64/
19 | parts/
20 | sdist/
21 | var/
22 | *.egg-info/
23 | .installed.cfg
24 | *.egg
25 | 
26 | # PyInstaller
27 | #  Usually these files are written by a python script from a template
28 | #  before PyInstaller builds the exe, so as to inject date/other infos into it.
29 | *.manifest
30 | *.spec
31 | 
32 | # Installer logs
33 | pip-log.txt
34 | pip-delete-this-directory.txt
35 | 
36 | # Unit test / coverage reports
37 | htmlcov/
38 | .tox/
39 | .coverage
40 | .coverage.*
41 | .cache
42 | nosetests.xml
43 | coverage.xml
44 | *,cover
45 | 
46 | # Translations
47 | *.mo
48 | *.pot
49 | 
50 | # Django stuff:
51 | *.log
52 | db.sqlite3
53 | 
54 | # Sphinx documentation
55 | docs/_build/
56 | 
57 | # PyBuilder
58 | target/
59 | 
60 | 
61 | 
62 | tests/local.py
63 | docs/_build/
64 | venv
65 | .python-version
66 | _version.py
67 | 


--------------------------------------------------------------------------------
/.readthedocs.yaml:
--------------------------------------------------------------------------------
 1 | # .readthedocs.yaml
 2 | # Read the Docs configuration file
 3 | # See https://docs.readthedocs.io/en/stable/config-file/v2.html for details
 4 | 
 5 | version: 2
 6 | 
 7 | build:
 8 |   os: ubuntu-20.04
 9 |   tools:
10 |     python: "3.11"
11 | 
12 | sphinx:
13 |   configuration: docs/conf.py
14 | 
15 | python:
16 |   install:
17 |     - method: pip
18 |       path: .
19 |       extra_requirements:
20 |         - docs
21 | 


--------------------------------------------------------------------------------
/CONTRIBUTING.rst:
--------------------------------------------------------------------------------
 1 | ============
 2 | Contributing
 3 | ============
 4 | 
 5 | To install the development requirements simply run::
 6 | 
 7 |     python -m pip install -e '.[test]'
 8 | 
 9 | To run test suite run::
10 | 
11 |     python -m pytest
12 | 
13 | To build the documentation run::
14 | 
15 |     python -m sphinx -W -b spelling docs docs/_build
16 | 
17 | The sample app
18 | ==============
19 | 
20 | To run a full example — e.g. to debug frontend code – you can run::
21 | 
22 |     python -m pip install -e .
23 |     python tests/testapp/manage.py migrate
24 |     python tests/testapp/manage.py createsuperuser
25 |     # You will be asked for the email address of your new superuser
26 |     python tests/testapp/manage.py runserver
27 | 
28 | Next you can go to https://localhost:8000/admin/ and log in with your newly
29 | created superuser.
30 | 


--------------------------------------------------------------------------------
/LICENSE:
--------------------------------------------------------------------------------
 1 | MIT License
 2 | 
 3 | Copyright (c) 2019 Johannes Hoppe
 4 | 
 5 | Permission is hereby granted, free of charge, to any person obtaining a copy
 6 | of this software and associated documentation files (the "Software"), to deal
 7 | in the Software without restriction, including without limitation the rights
 8 | to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
 9 | copies of the Software, and to permit persons to whom the Software is
10 | furnished to do so, subject to the following conditions:
11 | 
12 | The above copyright notice and this permission notice shall be included in all
13 | copies or substantial portions of the Software.
14 | 
15 | THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
16 | IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
17 | FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
18 | AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
19 | LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
20 | OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
21 | SOFTWARE.
22 | 


--------------------------------------------------------------------------------
/MANIFEST.in:
--------------------------------------------------------------------------------
1 | include *.rst
2 | recursive-include mailauth/templates *
3 | recursive-include mailauth/contrib/admin/templates *
4 | recursive-include mailauth/contrib/admin/static *
5 | recursive-include mailauth/contrib/admin/locale *
6 | recursive-include mailauth/contrib/user/locale *
7 | 


--------------------------------------------------------------------------------
/README.rst:
--------------------------------------------------------------------------------
  1 | ================
  2 | Django Mail Auth
  3 | ================
  4 | 
  5 | |version| |docs| |coverage| |license|
  6 | 
  7 | .. figure:: sample.png
  8 |     :width: 425
  9 |     :alt: screenshot from a login form
 10 | 
 11 | Django Mail Auth is a lightweight authentication backend for Django,
 12 | that does not require users to remember passwords.
 13 | 
 14 | Django Mail Auth features:
 15 | 
 16 | - custom user model support
 17 | - drop in Django admin support
 18 | - drop in Django User replacement
 19 | - drop in Wagtail login replacement
 20 | - extendable SMS support
 21 | 
 22 | This project was inspired by:
 23 | 
 24 | - `Is it time for password-less login?`_ by `Ben Brown`_
 25 | - `LOGIN WITHOUT PASSWORD MOST SECURE | WAIT.. WHAT?`_ by `Joris Snoek`_
 26 | - `django-nopassword`_ by `Rolf Erik Lekang`_
 27 | 
 28 | 
 29 | .. _`Rolf Erik Lekang`: http://rolflekang.com
 30 | .. _`django-nopassword`: https://github.com/relekang/django-nopassword
 31 | .. _`Is it time for password-less login?`: http://notes.xoxco.com/post/27999787765/is-it-time-for-password-less-login
 32 | .. _`LOGIN WITHOUT PASSWORD MOST SECURE | WAIT.. WHAT?`: https://www.lucius.digital/en/blog/login-without-password-most-secure-wait-what
 33 | .. _`Ben Brown`: http://twitter.com/benbrown
 34 | .. _`Joris Snoek`: https://twitter.com/lucius_digital
 35 | 
 36 | Installation
 37 | ------------
 38 | 
 39 | Run this command to install ``django-mail-auth``::
 40 | 
 41 |     python3 -m pip install django-mail-auth[wagtail]
 42 | 
 43 | Setup
 44 | -----
 45 | 
 46 | First add ``mailauth`` to you installed apps:
 47 | 
 48 | .. code-block:: python
 49 | 
 50 |     INSTALLED_APPS = [
 51 |         # Django's builtin apps…
 52 | 
 53 |         'mailauth',
 54 | 
 55 |         'mailauth.contrib.admin',  # optional
 56 |         'mailauth.contrib.user',  # optional
 57 | 
 58 |         # optional, must be included before "wagtail.admin"
 59 |         'mailauth.contrib.wagtail',
 60 | 
 61 | 
 62 |         # other apps…
 63 |     ]
 64 | 
 65 | ``mailauth.contrib.admin`` is optional and will replace the admin's login
 66 | with token based authentication too.
 67 | 
 68 | ``mailauth.contrib.user`` is optional and provides a new Django User model.
 69 | The new User model needs to be enabled via the ``AUTH_USER_MODEL`` setting:
 70 | 
 71 | .. code-block:: python
 72 | 
 73 |     # This setting should be either "EmailUser" or
 74 |     # any custom subclass of "AbstractEmailUser"
 75 |     AUTH_USER_MODEL = 'mailauth_user.EmailUser'
 76 | 
 77 |     # optional, Wagtail only
 78 |     WAGTAILUSERS_PASSWORD_ENABLED = False
 79 | 
 80 | 
 81 | Next you will need to add the new authentication backend:
 82 | 
 83 | .. code-block:: python
 84 | 
 85 |     AUTHENTICATION_BACKENDS = (
 86 |         # default, but now optional
 87 |         # This should be removed if you use mailauth.contrib.user or any other
 88 |         # custom user model that does not have a username/password
 89 |         'django.contrib.auth.backends.ModelBackend',
 90 | 
 91 |         # The new access token based authentication backend
 92 |         'mailauth.backends.MailAuthBackend',
 93 |     )
 94 | 
 95 | Django's ``ModelBackend`` is only needed, if you still want to support
 96 | password based authentication. If you don't, simply remove it from the list.
 97 | 
 98 | Last but not least, go to your URL root configuration ``urls.py`` and add the following:
 99 | 
100 | .. code-block:: python
101 | 
102 |     from django.urls import path
103 | 
104 | 
105 |     urlpatterns = [
106 |         path('accounts/', include('mailauth.urls')),
107 | 
108 |         # optional, must be before "wagtail.admin.urls"
109 |         path('', include('mailauth.contrib.wagtail.urls')),
110 |     ]
111 | 
112 | That's it!
113 | 
114 | .. note:: Don't forget to setup you Email backend!
115 | 
116 | .. |version| image:: https://img.shields.io/pypi/v/django-mail-auth.svg
117 |    :target: https://pypi.python.org/pypi/django-mail-auth/
118 | .. |coverage| image:: https://codecov.io/gh/codingjoe/django-mail-auth/branch/main/graph/badge.svg
119 |    :target: https://codecov.io/gh/codingjoe/django-mail-auth
120 | .. |license| image:: https://img.shields.io/badge/license-MIT-blue.svg
121 |    :target: :target: https://raw.githubusercontent.com/codingjoe/django-mail-auth/main/LICENSE
122 | .. |docs| image:: https://readthedocs.org/projects/django-mail-auth/badge/?version=latest
123 |    :target: https://django-mail-auth.readthedocs.io/en/latest/?badge=latest
124 |    :alt: Documentation Status
125 | 


--------------------------------------------------------------------------------
/SECURITY.md:
--------------------------------------------------------------------------------
1 | # Security Policy
2 | 
3 | ## Security contact information
4 | 
5 | To report a security vulnerability, please use the
6 | [Tidelift security contact](https://tidelift.com/security).
7 | Tidelift will coordinate the fix and disclosure.
8 | 


--------------------------------------------------------------------------------
/docs/conf.py:
--------------------------------------------------------------------------------
 1 | """Sphinx configuration file."""
 2 | 
 3 | import os
 4 | import sys
 5 | 
 6 | import django
 7 | from pkg_resources import get_distribution
 8 | 
 9 | os.environ.setdefault("DJANGO_SETTINGS_MODULE", "tests.testapp.settings")
10 | sys.path.insert(0, os.path.abspath(".."))
11 | django.setup()
12 | 
13 | project = "Django Mail Auth"
14 | copyright = "2022, Johannes Maron"
15 | release = get_distribution("django-mail-auth").version
16 | version = ".".join(release.split(".")[:2])
17 | 
18 | master_doc = "index"
19 | 
20 | extensions = [
21 |     "sphinx.ext.autodoc",
22 |     "sphinx.ext.napoleon",
23 |     "sphinx.ext.intersphinx",
24 |     "sphinx.ext.doctest",
25 | ]
26 | 
27 | intersphinx_mapping = {
28 |     "python": ("https://docs.python.org/3", None),
29 |     "django": (
30 |         "https://docs.djangoproject.com/en/stable/",
31 |         "https://docs.djangoproject.com/en/stable/_objects/",
32 |     ),
33 | }
34 | 
35 | try:
36 |     import sphinxcontrib.spelling  # noqa
37 | except ImportError:
38 |     pass
39 | else:
40 |     extensions.append("sphinxcontrib.spelling")
41 | 
42 |     spelling_word_list_filename = "spelling_wordlist.txt"
43 |     spelling_show_suggestions = True
44 | 
45 | 
46 | autodoc_default_options = {
47 |     "show-inheritance": True,
48 | }
49 | 


--------------------------------------------------------------------------------
/docs/contributing.rst:
--------------------------------------------------------------------------------
1 | .. include:: ../CONTRIBUTING.rst
2 | 


--------------------------------------------------------------------------------
/docs/customizing.rst:
--------------------------------------------------------------------------------
  1 | ===========
  2 | Customizing
  3 | ===========
  4 | 
  5 | Custom login message (like SMS)
  6 | _______________________________
  7 | 
  8 | Django Mail Auth can be easily extended. Besides template adaptations it is
  9 | possible to send different messages like SMS. To make those changes, you
 10 | will need to write a custom login form.
 11 | 
 12 | Custom login form
 13 | -----------------
 14 | 
 15 | Custom login forms need to inherit from :class:`.BaseLoginForm` and override
 16 | the :meth:`save<.BaseLoginForm.save>` method.
 17 | 
 18 | The following example is for a login SMS. This will require a
 19 | custom user model with a unique ``phone_number`` field:
 20 | 
 21 | .. code-block:: python
 22 | 
 23 |     from django import forms
 24 |     from django.contrib.auth import get_user_model
 25 |     from django.template import loader
 26 |     from mailauth.forms import BaseLoginForm
 27 | 
 28 | 
 29 |     class SmsLoginForm(BaseLoginForm):
 30 |         phone_number = forms.CharField()
 31 | 
 32 |         template_name = 'registration/login_sms.txt
 33 |         from_number = None
 34 | 
 35 |         def __init__(self, *args, **kwargs):
 36 |             self.twilio_client = TwilioRestClient(
 37 |                 settings.TWILIO_SID,
 38 |                 settings.TWILIO_AUTH_TOKEN
 39 |             )
 40 |             super().__init__(*args, **kwargs)
 41 | 
 42 |         def save(self):
 43 |             phone_number = self.cleaned_data['phone_number']
 44 |             user = get_user_model().objects.get(
 45 |                 phone_number=phone_number
 46 |             )
 47 |             context = self.get_context(self.request, user)
 48 | 
 49 |             from_number = self.from_number or getattr(
 50 |                 settings, 'DEFAULT_FROM_NUMBER'
 51 |             )
 52 |             sms_content = loader.render_to_string(
 53 |                 self.template_name, context
 54 |             )
 55 | 
 56 |             self.twilio_client.messages.create(
 57 |                 to=user.phone_number,
 58 |                 from_=from_number,
 59 |                 body=sms_content
 60 |             )
 61 | 
 62 | 
 63 | To add the new login form, simply add a new login view to your URL configuration with
 64 | the custom form:
 65 | 
 66 | .. code-block:: python
 67 | 
 68 |     from django.urls import path
 69 |     from mailauth.views import LoginView
 70 | 
 71 |     from .forms import SmsLoginForm
 72 | 
 73 |     urlpatterns = [
 74 |         path(
 75 |             'login/sms/',
 76 |             LoginView.as_view(form_class=SmsLoginForm),
 77 |             name='login-sms'
 78 |         ),
 79 |     ]
 80 | 
 81 | API documentation
 82 | -----------------
 83 | 
 84 | .. autoclass:: mailauth.forms.BaseLoginForm
 85 |     :members:
 86 | 
 87 | Custom User Model
 88 | _________________
 89 | 
 90 | For convenience, Django Mail Auth provides a
 91 | :class:`EmailUser<mailauth.contrib.user.models.EmailUser>` which is almost
 92 | identical to Django's built in :class:`User<django.contrib.auth.models.User>`
 93 | but without the :attr:`password<django.contrib.auth.models.User.password>`
 94 | and :attr:`username<django.contrib.auth.models.User.username>` field.
 95 | The :attr:`email<mailauth.contrib.user.models.AbstractEmailUser.email>`
 96 | field serves as a username and is – different to Django's User –
 97 | unique and case insensitive.
 98 | 
 99 | Implementing a custom User model
100 | --------------------------------
101 | 
102 | .. code-block:: python
103 | 
104 |     from mailauth.contrib.user.models import AbstractEmailUser
105 |     from phonenumber_field.modelfields import PhoneNumberField
106 | 
107 | 
108 |     class SMSUser(AbstractEmailUser):
109 |         phone_number = phone = PhoneNumberField(_("phone number"), unique=True, db_index=True)
110 | 
111 |     class Meta(AbstractEmailUser.Meta):
112 |         verbose_name = _("user")
113 |         verbose_name_plural = _("users")
114 |         swappable = "AUTH_USER_MODEL"
115 | 
116 | .. note:: Do not forget to adjust your ``AUTH_USER_MODEL`` to correct ``app_label.ModelName``.
117 | 
118 | API documentation
119 | -----------------
120 | 
121 | .. autoclass:: mailauth.contrib.user.models.AbstractEmailUser
122 |     :members:
123 | 
124 |     .. autoattribute:: mailauth.contrib.user.models.AbstractEmailUser.email
125 |        :noindex:
126 |     .. autoattribute:: mailauth.contrib.user.models.AbstractEmailUser.session_salt
127 |        :noindex:
128 | 
129 | .. autoclass:: mailauth.contrib.user.models.EmailUser
130 |     :members:
131 | 


--------------------------------------------------------------------------------
/docs/index.rst:
--------------------------------------------------------------------------------
 1 | .. include:: ../README.rst
 2 | 
 3 | All Contents
 4 | ============
 5 | 
 6 | .. toctree::
 7 |     :maxdepth: 2
 8 |     :caption: Contents:
 9 |     :glob:
10 | 
11 |     usage
12 |     templates
13 |     privacy
14 |     customizing
15 |     settings
16 |     contributing
17 | 


--------------------------------------------------------------------------------
/docs/privacy.rst:
--------------------------------------------------------------------------------
 1 | Privacy
 2 | ========
 3 | 
 4 | Anonymization
 5 | -------------
 6 | 
 7 | User privacy is important, not only to meet local regulations, but also to
 8 | protect your users and allow them to exercise their rights. However,
 9 | it's not always practical to delete users, especially if they have dependent
10 | objects, that are relevant for statistical analysis.
11 | 
12 | Anonymization is a process of removing the user's personal data whilst keeping
13 | related data intact. This is done by using the ``anomymize`` method.
14 | 
15 | 
16 | 
17 | .. automethod:: mailauth.contrib.user.models.AbstractEmailUser.anonymize
18 |     :noindex:
19 | 
20 | This method may be overwritten to provide anonymization for you custom user model.
21 | 
22 | Related objects may also listen to the anonymize signal.
23 | 
24 | .. autoclass:: mailauth.contrib.user.signals.anonymize
25 | 
26 | All those methods can be conveniently triggered via the ``anonymize`` admin action.
27 | 
28 | .. autoclass:: mailauth.contrib.user.admin.AnonymizableAdminMixin
29 |     :members:
30 | 
31 | Liability Waiver
32 | ----------------
33 | 
34 | THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
35 | IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
36 | FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
37 | AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
38 | LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
39 | OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
40 | SOFTWARE.
41 | 


--------------------------------------------------------------------------------
/docs/sample.png:
--------------------------------------------------------------------------------
1 | ../sample.png


--------------------------------------------------------------------------------
/docs/settings.rst:
--------------------------------------------------------------------------------
 1 | Settings
 2 | ========
 3 | 
 4 | Mail Auth settings
 5 | ------------------
 6 | 
 7 | .. attribute:: LOGIN_URL_TIMEOUT
 8 | 
 9 |     Default: ``900``
10 | 
11 |     Defines how long a login code is valid in seconds.
12 | 
13 | .. attribute:: LOGIN_REQUESTED_URL
14 | 
15 |     Default: ``accounts/login/success``
16 | 
17 |     Defines the URL the user will be redirected to, after requesting an
18 |     authentication message.
19 | 
20 | .. attribute:: LOGIN_TOKEN_SINGLE_USE
21 | 
22 |     Default: ``True``
23 | 
24 |     Defines if a token can be used more than once.
25 |     If ``True``, the same token can only be used once and will be invalid the next try.
26 |     If ``False``, the same token can be used multiple times and remains valid until expired.
27 | 
28 | Django related settings
29 | -----------------------
30 | 
31 | .. attribute:: DEFAULT_FROM_EMAIL
32 | 
33 |     Default: ``'root@example.com'``
34 | 
35 |     The sender email address for authentication emails send by Django Mail Auth.
36 | 
37 | .. attribute:: SECRET_KEY
38 | 
39 |     .. attention:: *Keep it secret, keep it safe!*
40 | 
41 |         This key is the foundation of all of Django security measures and for
42 |         this package.
43 | 


--------------------------------------------------------------------------------
/docs/spelling_wordlist.txt:
--------------------------------------------------------------------------------
 1 | admin
 2 | anonymize
 3 | anonymized
 4 | anonymization
 5 | Auth
 6 | boolean
 7 | backend
 8 | Django
 9 | frontend
10 | mixin
11 | mixins
12 | namespace
13 | subclasses
14 | tuple
15 | tuples
16 | triple
17 | URL
18 | 


--------------------------------------------------------------------------------
/docs/templates.rst:
--------------------------------------------------------------------------------
 1 | =========
 2 | Templates
 3 | =========
 4 | 
 5 | There are a couple relevant templates, that can be overridden to your needs.
 6 | 
 7 | Mail Auth templates
 8 | -------------------
 9 | 
10 | Login templates
11 | ~~~~~~~~~~~~~~~
12 | 
13 | .. attribute:: registration/login_requested.html
14 | 
15 | This template will be displayed after a user successfully requested a login
16 | URL. This template is not proved by the package and needs to be created.
17 | 
18 | Email templates
19 | ~~~~~~~~~~~~~~~
20 | 
21 | .. attribute:: registration/login_subject.txt
22 | 
23 | This template defines the subject line of the email that will be sent to
24 | the user.
25 | 
26 | This template is provided by the package and can be overridden.
27 | 
28 | .. attribute:: registration/login_email.txt
29 | 
30 | This is the plain text template for the email containing the authentication
31 | URL that will be sent to the user.
32 | 
33 | This template is provided by the package and can be overridden.
34 | 
35 | .. attribute:: registration/login_email.html
36 | 
37 | This is the HTML template for the email containing the authentication URL that
38 | will be sent to the user.
39 | 
40 | 
41 | This template is optional. If not provided, only plain text emails will be
42 | sent.
43 | 
44 | 
45 | Django related templates
46 | ------------------------
47 | 
48 | Mail Auth uses Django's default templates for the login views.
49 | 
50 | Login templates
51 | ~~~~~~~~~~~~~~~
52 | 
53 | .. attribute:: registration/login.html
54 | 
55 | This template displays login form, where a user can request a login URL. This
56 | template is not proved Django or by the package and needs to be created.
57 | 
58 | .. attribute:: registration/logged_out.html
59 | 
60 | This template will be displayed after a successful logout. This template is
61 | not proved Django or by the package and needs to be created.
62 | 


--------------------------------------------------------------------------------
/docs/usage.rst:
--------------------------------------------------------------------------------
1 | .. include:: ../README.rst
2 | 


--------------------------------------------------------------------------------
/mailauth/__init__.py:
--------------------------------------------------------------------------------
1 | """Django authentication via login URLs, no passwords required."""
2 | 
3 | from . import _version
4 | 
5 | __version__ = _version.version
6 | VERSION = _version.version_tuple
7 | 


--------------------------------------------------------------------------------
/mailauth/backends.py:
--------------------------------------------------------------------------------
 1 | import logging
 2 | 
 3 | from django.conf import settings
 4 | from django.contrib.auth.backends import ModelBackend
 5 | from django.core.signing import BadSignature, SignatureExpired
 6 | from django.urls import reverse
 7 | 
 8 | from . import signing
 9 | from .signing import UserDoesNotExist
10 | 
11 | logger = logging.getLogger(__name__)
12 | 
13 | 
14 | class MailAuthBackend(ModelBackend):
15 |     signer = signing.UserSigner()
16 | 
17 |     def authenticate(self, request, token=None):
18 |         max_age = getattr(settings, "LOGIN_URL_TIMEOUT", 60 * 15)
19 |         single_use = getattr(settings, "LOGIN_TOKEN_SINGLE_USE", True)
20 | 
21 |         try:
22 |             user = self.signer.unsign(token, max_age=max_age, single_use=single_use)
23 |         except UserDoesNotExist:
24 |             logger.warning(
25 |                 "Valid token for non-existing user. Maybe the user has been deleted.",
26 |                 exc_info=True,
27 |             )
28 |         except SignatureExpired:
29 |             logger.warning("Token has expired.", exc_info=True)
30 |         except BadSignature:
31 |             logger.exception('Malicious or corrupted login token received: "%s"', token)
32 |         else:
33 |             if self.user_can_authenticate(user):
34 |                 return user
35 |             logger.warning(
36 |                 "User '%s' is not allowed to authenticate.",
37 |                 user,
38 |                 exc_info=True,
39 |             )
40 | 
41 |     @classmethod
42 |     def get_token(cls, user):
43 |         return cls.signer.sign(user)
44 | 
45 |     @staticmethod
46 |     def get_login_url(token):
47 |         return reverse("mailauth:login-token", kwargs={"token": token})
48 | 


--------------------------------------------------------------------------------
/mailauth/contrib/__init__.py:
--------------------------------------------------------------------------------
https://raw.githubusercontent.com/codingjoe/django-mail-auth/f32e1d9fe11f794a41d0b7bf7d3594586ea1c400/mailauth/contrib/__init__.py


--------------------------------------------------------------------------------
/mailauth/contrib/admin/__init__.py:
--------------------------------------------------------------------------------
https://raw.githubusercontent.com/codingjoe/django-mail-auth/f32e1d9fe11f794a41d0b7bf7d3594586ea1c400/mailauth/contrib/admin/__init__.py


--------------------------------------------------------------------------------
/mailauth/contrib/admin/admin.py:
--------------------------------------------------------------------------------
1 | from django.contrib import admin
2 | 
3 | from .views import AdminLoginView
4 | 
5 | admin.site.login = AdminLoginView.as_view(site=admin.site)
6 | 


--------------------------------------------------------------------------------
/mailauth/contrib/admin/apps.py:
--------------------------------------------------------------------------------
1 | from django.apps import AppConfig
2 | 
3 | 
4 | class MailAuthAdmin(AppConfig):
5 |     name = "mailauth.contrib.admin"
6 |     label = "mailauth_admin"
7 | 


--------------------------------------------------------------------------------
/mailauth/contrib/admin/locale/de/LC_MESSAGES/django.po:
--------------------------------------------------------------------------------
 1 | # SOME DESCRIPTIVE TITLE.
 2 | # Copyright (C) YEAR THE PACKAGE'S COPYRIGHT HOLDER
 3 | # This file is distributed under the same license as the PACKAGE package.
 4 | # Johannes Hoppe <info@johanneshoppe.com>, 2019.
 5 | #
 6 | msgid ""
 7 | msgstr ""
 8 | "Project-Id-Version: \n"
 9 | "Report-Msgid-Bugs-To: \n"
10 | "POT-Creation-Date: 2022-04-14 16:57+0200\n"
11 | "PO-Revision-Date: 2019-04-12 18:15+0200\n"
12 | "Last-Translator: Johannes Hoppe <info@johanneshoppe.com>\n"
13 | "Language-Team: \n"
14 | "Language: de\n"
15 | "MIME-Version: 1.0\n"
16 | "Content-Type: text/plain; charset=UTF-8\n"
17 | "Content-Transfer-Encoding: 8bit\n"
18 | "Plural-Forms: nplurals=2; plural=(n != 1);\n"
19 | "X-Generator: Poedit 2.2.1\n"
20 | 
21 | #: templates/mailauth_admin/login.html:10
22 | msgid "Please correct the error below."
23 | msgstr "Bitte korrigieren Sie den untenstehenden Fehler."
24 | 
25 | #: templates/mailauth_admin/login.html:10
26 | msgid "Please correct the errors below."
27 | msgstr "Bitte korrigieren Sie die untenstehenden Fehler."
28 | 
29 | #: templates/mailauth_admin/login.html:26
30 | #, python-format
31 | msgid ""
32 | "You are authenticated as %(username)s, but are not authorized to access this "
33 | "page. Would you like to login to a different account?"
34 | msgstr ""
35 | "Sie sind als %(username)s authentifiziert, aber nicht berechtigt, auf diese "
36 | "Seite zuzugreifen. Möchten Sie sich auf einem anderen Konto anmelden?"
37 | 
38 | #: templates/mailauth_admin/login.html:34
39 | msgid ""
40 | "Enter your email address below, and we'll email you a link and instructions "
41 | "to log into your account."
42 | msgstr ""
43 | "Geben Sie unten Ihre E-Mail-Adresse ein, und wir schicken Ihnen einen Link "
44 | "und Anweisungen, um sich in Ihr Konto einzuloggen."
45 | 
46 | #: templates/mailauth_admin/login.html:46
47 | msgid "Send login email"
48 | msgstr "Sende Login E-Mail"
49 | 
50 | #: templates/registration/login_requested.html:7
51 | msgid "We sent you an email with instructions to log into your account."
52 | msgstr ""
53 | "Wir haben Ihnen eine E-Mail mit Anweisungen geschickt, um sich in Ihr Konto "
54 | "einzuloggen."
55 | 
56 | #: templates/registration/login_requested.html:12
57 | msgid ""
58 | "Should you not receive an email soon, you can request a new login email "
59 | "below."
60 | msgstr ""
61 | "Sollten Sie nicht bald eine E-Mail erhalten, können Sie unten eine neue "
62 | "Login-E-Mail anfordern."
63 | 
64 | #: templates/registration/login_requested.html:17
65 | msgid "Resend login email"
66 | msgstr "Login E-Mail erneut senden"
67 | 
68 | #: views.py:17
69 | msgid "Log in"
70 | msgstr "Anmelden"
71 | 


--------------------------------------------------------------------------------
/mailauth/contrib/admin/static/mailauth_admin/css/login.css:
--------------------------------------------------------------------------------
1 | .login .form-row #id_email {
2 |     clear: both;
3 |     padding: 8px;
4 |     width: 100%;
5 |     -webkit-box-sizing: border-box;
6 |        -moz-box-sizing: border-box;
7 |             box-sizing: border-box;
8 | }
9 | 


--------------------------------------------------------------------------------
/mailauth/contrib/admin/templates/mailauth_admin/login.html:
--------------------------------------------------------------------------------
 1 | {% extends "admin/login.html" %}
 2 | {% load i18n static %}
 3 | 
 4 | {% block extrastyle %}{{ block.super }}<link rel="stylesheet" type="text/css" href="{% static "mailauth_admin/css/login.css" %}">
 5 | {% endblock %}
 6 | 
 7 | {% block content %}
 8 | {% if form.errors and not form.non_field_errors %}
 9 | <p class="errornote">
10 | {% if form.errors.items|length == 1 %}{% trans "Please correct the error below." %}{% else %}{% trans "Please correct the errors below." %}{% endif %}
11 | </p>
12 | {% endif %}
13 | 
14 | {% if form.non_field_errors %}
15 | {% for error in form.non_field_errors %}
16 | <p class="errornote">
17 |     {{ error }}
18 | </p>
19 | {% endfor %}
20 | {% endif %}
21 | 
22 | <div id="content-main">
23 | 
24 | {% if user.is_authenticated %}
25 | <p class="errornote">
26 | {% blocktrans trimmed %}
27 |     You are authenticated as {{ username }}, but are not authorized to
28 |     access this page. Would you like to login to a different account?
29 | {% endblocktrans %}
30 | </p>
31 | {% endif %}
32 | 
33 | <p>
34 | {% blocktrans trimmed %}
35 |     Enter your email address below, and we'll email you a link and instructions to log into your account.
36 | {% endblocktrans %}
37 | </p>
38 | 
39 | <form action="{{ app_path }}" method="post" id="login-form">{% csrf_token %}
40 |   <div class="form-row">
41 |     {{ form.email.errors }}
42 |     {{ form.email.label_tag }} {{ form.email }}
43 |     <input type="hidden" name="next" value="{{ next }}">
44 |   </div>
45 |   <div class="submit-row">
46 |     <label>&nbsp;</label><input type="submit" value="{% trans 'Send login email' %}">
47 |   </div>
48 | </form>
49 | 
50 | </div>
51 | {% endblock %}
52 | 


--------------------------------------------------------------------------------
/mailauth/contrib/admin/templates/registration/login_requested.html:
--------------------------------------------------------------------------------
 1 | {% extends "admin/login.html" %}
 2 | {% load i18n static %}
 3 | 
 4 | {% block content %}
 5 | <div id="content-main">
 6 | <p>
 7 | {% blocktrans trimmed %}
 8 |     We sent you an email with instructions to log into your account.
 9 | {% endblocktrans %}
10 | </p>
11 | <p>
12 | {% blocktrans trimmed %}
13 |     Should you not receive an email soon, you can request a new login email below.
14 | {% endblocktrans %}
15 | </p>
16 | <div class="submit-row">
17 |     <input type="button" onclick="window.history.back();" value="{% trans 'Resend login email' %}">
18 | </div>
19 | </div>
20 | {% endblock %}
21 | 


--------------------------------------------------------------------------------
/mailauth/contrib/admin/views.py:
--------------------------------------------------------------------------------
 1 | from django.contrib.auth import REDIRECT_FIELD_NAME
 2 | from django.urls import reverse
 3 | from django.utils.translation import gettext_lazy as _
 4 | 
 5 | from mailauth.views import LoginView
 6 | 
 7 | 
 8 | class AdminLoginView(LoginView):
 9 |     template_name = "mailauth_admin/login.html"
10 |     site = None
11 | 
12 |     def get_context_data(self, **kwargs):
13 |         context = super().get_context_data(**kwargs)
14 |         context.update(
15 |             {
16 |                 **self.site.each_context(self.request),
17 |                 "title": _("Log in"),
18 |                 "app_path": self.request.get_full_path(),
19 |                 "username": self.request.user.get_username(),
20 |             }
21 |         )
22 |         if (
23 |             REDIRECT_FIELD_NAME not in self.request.GET
24 |             and REDIRECT_FIELD_NAME not in self.request.POST
25 |         ):
26 |             context[REDIRECT_FIELD_NAME] = reverse(
27 |                 "admin:index", current_app=self.site.name
28 |             )
29 |         return context
30 | 


--------------------------------------------------------------------------------
/mailauth/contrib/user/__init__.py:
--------------------------------------------------------------------------------
https://raw.githubusercontent.com/codingjoe/django-mail-auth/f32e1d9fe11f794a41d0b7bf7d3594586ea1c400/mailauth/contrib/user/__init__.py


--------------------------------------------------------------------------------
/mailauth/contrib/user/admin.py:
--------------------------------------------------------------------------------
 1 | from django.contrib import admin
 2 | from django.contrib.auth.models import Group, Permission
 3 | from django.utils.translation import gettext_lazy as _, ngettext
 4 | 
 5 | from . import models
 6 | 
 7 | 
 8 | class AnonymizableAdminMixin:
 9 |     """
10 |     Mixin for admin classes that provides a `anonymize` action.
11 | 
12 |     This mixin calls the `anonymize` method of all user model instances.
13 |     """
14 | 
15 |     actions = ["anonymize"]
16 | 
17 |     @admin.action(
18 |         permissions=["anonymize"],
19 |         description=_("Anonymize selected %(verbose_name_plural)s"),
20 |     )
21 |     def anonymize(self, request, queryset):
22 |         count = queryset.count()
23 |         for user in queryset.iterator():
24 |             user.anonymize()
25 | 
26 |         self.message_user(
27 |             request,
28 |             ngettext(
29 |                 "%(count)s %(obj_name)s has successfully been anonymized.",
30 |                 "%(count)s %(obj_name)s have successfully been anonymized.",
31 |                 count,
32 |             )
33 |             % {
34 |                 "count": count,
35 |                 "obj_name": (
36 |                     self.model._meta.verbose_name_plural
37 |                     if count > 1
38 |                     else self.model._meta.verbose_name
39 |                 ),
40 |             },
41 |             fail_silently=True,
42 |         )
43 | 
44 |     def has_anonymize_permission(self, request, obj=None):
45 |         return request.user.has_perm(f"{self.opts.app_label}.anonymize", obj=obj)
46 | 
47 | 
48 | @admin.register(models.EmailUser)
49 | class EmailUserAdmin(AnonymizableAdminMixin, admin.ModelAdmin):
50 |     list_display = ("email", "first_name", "last_name", "is_staff")
51 |     list_filter = ("is_staff", "is_superuser", "is_active", "groups")
52 |     search_fields = ("first_name", "last_name", "email")
53 |     ordering = ("email",)
54 |     filter_horizontal = (
55 |         "groups",
56 |         "user_permissions",
57 |     )
58 | 
59 |     fieldsets = (
60 |         (None, {"fields": (("email", "is_active"), ("first_name", "last_name"))}),
61 |         (
62 |             Group._meta.verbose_name_plural,
63 |             {
64 |                 "fields": ("groups",),
65 |             },
66 |         ),
67 |         (
68 |             Permission._meta.verbose_name_plural,
69 |             {
70 |                 "classes": ("collapse",),
71 |                 "fields": (("is_staff", "is_superuser"), "user_permissions"),
72 |             },
73 |         ),
74 |     )
75 | 


--------------------------------------------------------------------------------
/mailauth/contrib/user/apps.py:
--------------------------------------------------------------------------------
1 | from django.apps import AppConfig
2 | 
3 | 
4 | class AuthConfig(AppConfig):
5 |     name = "mailauth.contrib.user"
6 |     label = "mailauth_user"
7 | 


--------------------------------------------------------------------------------
/mailauth/contrib/user/locale/de/LC_MESSAGES/django.po:
--------------------------------------------------------------------------------
 1 | # SOME DESCRIPTIVE TITLE.
 2 | # Copyright (C) YEAR THE PACKAGE'S COPYRIGHT HOLDER
 3 | # This file is distributed under the same license as the PACKAGE package.
 4 | # Johannes Hoppe <info@johanneshoppe.com>, 2019.
 5 | #
 6 | msgid ""
 7 | msgstr ""
 8 | "Project-Id-Version: \n"
 9 | "Report-Msgid-Bugs-To: \n"
10 | "POT-Creation-Date: 2022-04-14 16:56+0200\n"
11 | "PO-Revision-Date: 2022-04-14 15:38+0200\n"
12 | "Last-Translator: Johannes Maron <johannes@maron.family>\n"
13 | "Language-Team: \n"
14 | "Language: de\n"
15 | "MIME-Version: 1.0\n"
16 | "Content-Type: text/plain; charset=UTF-8\n"
17 | "Content-Transfer-Encoding: 8bit\n"
18 | "Plural-Forms: nplurals=2; plural=(n != 1);\n"
19 | "X-Generator: Poedit 3.0.1\n"
20 | 
21 | #: admin.py:19
22 | #, python-format
23 | msgid "Anonymize selected %(verbose_name_plural)s"
24 | msgstr "Ausgewählte %(verbose_name_plural)s anonymisieren"
25 | 
26 | #: admin.py:29
27 | #, python-format
28 | msgid "%(count)s %(obj_name)s has successfully been anonymized."
29 | msgid_plural "%(count)s %(obj_name)s have successfully been anonymized."
30 | msgstr[0] "%(count)s %(obj_name)s wurde erfolgreich anonymisiert."
31 | msgstr[1] "%(count)s %(obj_name)s wurden erfolgreich anonymisiert."
32 | 
33 | #: models.py:56
34 | msgid "email address"
35 | msgstr "E-Mail-Adresse"
36 | 


--------------------------------------------------------------------------------
/mailauth/contrib/user/migrations/0001_initial.py:
--------------------------------------------------------------------------------
  1 | # Generated by Django 2.2 on 2019-04-12 15:56
  2 | 
  3 | import django.utils.timezone
  4 | from django.db import migrations, models
  5 | 
  6 | import mailauth.contrib.user.models
  7 | 
  8 | 
  9 | class Migration(migrations.Migration):
 10 |     initial = True
 11 | 
 12 |     dependencies = [
 13 |         ("auth", "0006_require_contenttypes_0002"),
 14 |     ]
 15 | 
 16 |     operations = [
 17 |         migrations.CreateModel(
 18 |             name="EmailUser",
 19 |             fields=[
 20 |                 (
 21 |                     "id",
 22 |                     models.AutoField(
 23 |                         auto_created=True,
 24 |                         primary_key=True,
 25 |                         serialize=False,
 26 |                         verbose_name="ID",
 27 |                     ),
 28 |                 ),
 29 |                 (
 30 |                     "last_login",
 31 |                     models.DateTimeField(
 32 |                         blank=True, null=True, verbose_name="last login"
 33 |                     ),
 34 |                 ),
 35 |                 (
 36 |                     "is_superuser",
 37 |                     models.BooleanField(
 38 |                         default=False,
 39 |                         help_text="Designates that this user has all permissions without explicitly assigning them.",
 40 |                         verbose_name="superuser status",
 41 |                     ),
 42 |                 ),
 43 |                 (
 44 |                     "first_name",
 45 |                     models.CharField(
 46 |                         blank=True, max_length=30, verbose_name="first name"
 47 |                     ),
 48 |                 ),
 49 |                 (
 50 |                     "last_name",
 51 |                     models.CharField(
 52 |                         blank=True, max_length=150, verbose_name="last name"
 53 |                     ),
 54 |                 ),
 55 |                 (
 56 |                     "is_staff",
 57 |                     models.BooleanField(
 58 |                         default=False,
 59 |                         help_text="Designates whether the user can log into this admin site.",
 60 |                         verbose_name="staff status",
 61 |                     ),
 62 |                 ),
 63 |                 (
 64 |                     "is_active",
 65 |                     models.BooleanField(
 66 |                         default=True,
 67 |                         help_text="Designates whether this user should be treated as active. Unselect this instead of deleting accounts.",
 68 |                         verbose_name="active",
 69 |                     ),
 70 |                 ),
 71 |                 (
 72 |                     "date_joined",
 73 |                     models.DateTimeField(
 74 |                         default=django.utils.timezone.now, verbose_name="date joined"
 75 |                     ),
 76 |                 ),
 77 |                 (
 78 |                     "email",
 79 |                     models.EmailField(
 80 |                         db_index=True,
 81 |                         max_length=254,
 82 |                         unique=True,
 83 |                         verbose_name="email address",
 84 |                     ),
 85 |                 ),
 86 |                 (
 87 |                     "groups",
 88 |                     models.ManyToManyField(
 89 |                         blank=True,
 90 |                         help_text="The groups this user belongs to. A user will get all permissions granted to each of their groups.",
 91 |                         related_name="user_set",
 92 |                         related_query_name="user",
 93 |                         to="auth.Group",
 94 |                         verbose_name="groups",
 95 |                     ),
 96 |                 ),
 97 |                 (
 98 |                     "user_permissions",
 99 |                     models.ManyToManyField(
100 |                         blank=True,
101 |                         help_text="Specific permissions for this user.",
102 |                         related_name="user_set",
103 |                         related_query_name="user",
104 |                         to="auth.Permission",
105 |                         verbose_name="user permissions",
106 |                     ),
107 |                 ),
108 |             ],
109 |             options={
110 |                 "verbose_name": "user",
111 |                 "verbose_name_plural": "users",
112 |                 "abstract": False,
113 |                 "swappable": "AUTH_USER_MODEL",
114 |             },
115 |             managers=[
116 |                 ("objects", mailauth.contrib.user.models.EmailUserManager()),
117 |             ],
118 |         ),
119 |     ]
120 | 


--------------------------------------------------------------------------------
/mailauth/contrib/user/migrations/0002_emailuser_session_salt.py:
--------------------------------------------------------------------------------
 1 | # Generated by Django 2.2.1 on 2019-05-27 10:39
 2 | 
 3 | from django.db import migrations, models
 4 | 
 5 | import mailauth
 6 | 
 7 | 
 8 | class Migration(migrations.Migration):
 9 |     dependencies = [
10 |         ("mailauth_user", "0001_initial"),
11 |     ]
12 | 
13 |     operations = [
14 |         migrations.AddField(
15 |             model_name="emailuser",
16 |             name="session_salt",
17 |             field=models.CharField(
18 |                 default=mailauth.contrib.user.models._get_session_salt,
19 |                 editable=False,
20 |                 max_length=12,
21 |             ),
22 |         ),
23 |     ]
24 | 


--------------------------------------------------------------------------------
/mailauth/contrib/user/migrations/0003_ci_unique_index.py:
--------------------------------------------------------------------------------
 1 | from django.db import migrations
 2 | 
 3 | try:
 4 |     from citext import CIEmailField, CITextExtension
 5 | except ImportError:
 6 |     CITextExtension = None
 7 |     CIEmailField = None
 8 | 
 9 | 
10 | def _operations():
11 |     if CITextExtension:
12 |         yield CITextExtension()
13 |         yield migrations.AlterField(
14 |             model_name="emailuser",
15 |             name="email",
16 |             field=CIEmailField(
17 |                 db_index=True, max_length=254, unique=True, verbose_name="email address"
18 |             ),
19 |         )
20 |     else:
21 |         yield migrations.RunSQL(
22 |             sql=(
23 |                 "CREATE UNIQUE INDEX mailauth_user_emailuser_email_upper_idx"
24 |                 ' ON mailauth_user_emailuser (UPPER("email"));',
25 |             ),
26 |             reverse_sql=("DROP INDEX mailauth_user_emailuser_email_upper_idx;",),
27 |         )
28 | 
29 | 
30 | class Migration(migrations.Migration):
31 |     dependencies = [
32 |         ("mailauth_user", "0002_emailuser_session_salt"),
33 |     ]
34 | 
35 |     operations = list(_operations())
36 | 


--------------------------------------------------------------------------------
/mailauth/contrib/user/migrations/0004_auto_20200812_0722.py:
--------------------------------------------------------------------------------
 1 | from django.db import migrations, models
 2 | 
 3 | 
 4 | class Migration(migrations.Migration):
 5 |     dependencies = [
 6 |         ("mailauth_user", "0003_ci_unique_index"),
 7 |     ]
 8 | 
 9 |     operations = [
10 |         migrations.AlterField(
11 |             model_name="emailuser",
12 |             name="first_name",
13 |             field=models.CharField(
14 |                 blank=True, max_length=150, verbose_name="first name"
15 |             ),
16 |         ),
17 |     ]
18 | 


--------------------------------------------------------------------------------
/mailauth/contrib/user/migrations/0005_emailuser_email_hash_alter_emailuser_email.py:
--------------------------------------------------------------------------------
 1 | from django.db import migrations, models
 2 | 
 3 | try:
 4 |     from citext import CIEmailField
 5 | except ImportError:
 6 |     CIEmailField = models.EmailField
 7 | 
 8 | 
 9 | class Migration(migrations.Migration):
10 |     dependencies = [
11 |         ("mailauth_user", "0004_auto_20200812_0722"),
12 |     ]
13 | 
14 |     operations = [
15 |         # add new permissions
16 |         migrations.AlterModelOptions(
17 |             name="emailuser",
18 |             options={
19 |                 "permissions": [("anonymize", "Can anonymize user")],
20 |                 "verbose_name": "user",
21 |                 "verbose_name_plural": "users",
22 |             },
23 |         ),
24 |         # email is now nullable
25 |         migrations.AlterField(
26 |             model_name="emailuser",
27 |             name="email",
28 |             field=CIEmailField(
29 |                 blank=True,
30 |                 db_index=True,
31 |                 max_length=254,
32 |                 null=True,
33 |                 unique=True,
34 |                 verbose_name="email address",
35 |             ),
36 |         ),
37 |     ]
38 | 


--------------------------------------------------------------------------------
/mailauth/contrib/user/migrations/__init__.py:
--------------------------------------------------------------------------------
https://raw.githubusercontent.com/codingjoe/django-mail-auth/f32e1d9fe11f794a41d0b7bf7d3594586ea1c400/mailauth/contrib/user/migrations/__init__.py


--------------------------------------------------------------------------------
/mailauth/contrib/user/models.py:
--------------------------------------------------------------------------------
  1 | from django.contrib.auth.base_user import BaseUserManager
  2 | from django.contrib.auth.models import AbstractUser
  3 | from django.db import models
  4 | from django.utils.crypto import get_random_string, salted_hmac
  5 | from django.utils.translation import gettext_lazy as _
  6 | 
  7 | from . import signals
  8 | 
  9 | try:
 10 |     from citext import CIEmailField
 11 | except ImportError:
 12 |     from django.db.models import EmailField as CIEmailField
 13 | 
 14 | 
 15 | class EmailUserManager(BaseUserManager):
 16 |     use_in_migrations = True
 17 | 
 18 |     def _create_user(self, email, **extra_fields):
 19 |         """Create and save a user with the given email."""
 20 |         email = self.normalize_email(email)
 21 |         user = self.model(email=email, **extra_fields)
 22 |         user.save(using=self._db)
 23 |         return user
 24 | 
 25 |     def create_user(self, email, **extra_fields):
 26 |         extra_fields.setdefault("is_staff", False)
 27 |         extra_fields.setdefault("is_superuser", False)
 28 |         return self._create_user(email, **extra_fields)
 29 | 
 30 |     def create_superuser(self, email, **extra_fields):
 31 |         extra_fields.setdefault("is_staff", True)
 32 |         extra_fields.setdefault("is_superuser", True)
 33 | 
 34 |         if extra_fields.get("is_staff") is not True:
 35 |             raise ValueError("Superuser must have is_staff=True.")
 36 |         if extra_fields.get("is_superuser") is not True:
 37 |             raise ValueError("Superuser must have is_superuser=True.")
 38 | 
 39 |         return self._create_user(email, **extra_fields)
 40 | 
 41 | 
 42 | def _get_session_salt():
 43 |     return get_random_string(12)
 44 | 
 45 | 
 46 | class AbstractEmailUser(AbstractUser):
 47 |     EMAIL_FIELD = "email"
 48 |     USERNAME_FIELD = "email"
 49 |     REQUIRED_FIELDS = []
 50 | 
 51 |     username = None
 52 |     password = None
 53 | 
 54 |     email = CIEmailField(
 55 |         _("email address"), blank=True, null=True, unique=True, db_index=True
 56 |     )
 57 |     """Unique and case insensitive to serve as a better username."""
 58 | 
 59 |     session_salt = models.CharField(
 60 |         max_length=12,
 61 |         editable=False,
 62 |         default=_get_session_salt,
 63 |     )
 64 |     """Salt for the session hash replacing the password in this function."""
 65 | 
 66 |     def has_usable_password(self):
 67 |         return False
 68 | 
 69 |     objects = EmailUserManager()
 70 | 
 71 |     class Meta(AbstractUser.Meta):
 72 |         abstract = True
 73 |         permissions = [
 74 |             ("anonymize", "Can anonymize user"),
 75 |         ]
 76 | 
 77 |     def get_session_auth_hash(self):
 78 |         """Return an HMAC of the :attr:`.session_salt` field."""
 79 |         key_salt = "mailauth.contrib.user.models.EmailUserManager.get_session_auth_hash"
 80 |         if not self.session_salt:
 81 |             raise ValueError("'session_salt' must be set")
 82 |         return salted_hmac(key_salt, self.session_salt, algorithm="sha256").hexdigest()
 83 | 
 84 |     def anonymize(self, commit=True):
 85 |         """
 86 |         Anonymize the user data for privacy purposes.
 87 | 
 88 |         This method will erase the email address, first and last name.
 89 |         You may overwrite this method to add additional fields to anonymize::
 90 | 
 91 |             class MyUser(AbstractEmailUser):
 92 |                 def anonymize(self, commit=True):
 93 |                     super().anonymize(commit=False) # do not commit yet
 94 |                     self.phone_number = None
 95 |                     if commit:
 96 |                         self.save()
 97 |         """
 98 |         signals.anonymize.send(sender=self.__class__, instance=self)
 99 |         self.email = None
100 |         self.first_name = ""
101 |         self.last_name = ""
102 |         update_fields = ["email", "first_name", "last_name"]
103 |         if commit:
104 |             self.save(update_fields=update_fields)
105 |         return update_fields
106 | 
107 | 
108 | delattr(AbstractEmailUser, "password")
109 | 
110 | 
111 | class EmailUser(AbstractEmailUser):
112 |     class Meta(AbstractEmailUser.Meta):
113 |         swappable = "AUTH_USER_MODEL"
114 | 


--------------------------------------------------------------------------------
/mailauth/contrib/user/signals.py:
--------------------------------------------------------------------------------
 1 | from django.dispatch import Signal
 2 | 
 3 | anonymize = Signal()
 4 | """
 5 | Signal that is emitted when a user and all their data should be anonymized.
 6 | 
 7 | The signal is emitted before the private date is delete on the instance,
 8 | thus the receiver can still access the data. The receiver should usually
 9 | not alter the instance, but only later related data. We recommend overriding
10 | the anonymize method to modify the instance.
11 | 
12 | Usage::
13 | 
14 |     from django.dispatch import receiver
15 |     from mailauth.contrib.user.models import EmailUser
16 |     from mailauth.contrib.user.signals import anonymize
17 | 
18 | 
19 |     @receiver(anonymize, sender=EmailUser)
20 |     def anonymize_user(sender, instance, **kwargs):
21 |         # Do something with related user data
22 |         instance.related_model.delete()
23 | 
24 | """
25 | 


--------------------------------------------------------------------------------
/mailauth/contrib/wagtail/__init__.py:
--------------------------------------------------------------------------------
https://raw.githubusercontent.com/codingjoe/django-mail-auth/f32e1d9fe11f794a41d0b7bf7d3594586ea1c400/mailauth/contrib/wagtail/__init__.py


--------------------------------------------------------------------------------
/mailauth/contrib/wagtail/apps.py:
--------------------------------------------------------------------------------
1 | from django.apps import AppConfig
2 | 
3 | 
4 | class MailAuthWagtail(AppConfig):
5 |     name = "mailauth.contrib.wagtail"
6 |     label = "mailauth_wagtail"
7 | 


--------------------------------------------------------------------------------
/mailauth/contrib/wagtail/templates/wagtailadmin/login.html:
--------------------------------------------------------------------------------
 1 | {% extends "wagtailadmin/admin_base.html" %}
 2 | {% load wagtailadmin_tags i18n %}
 3 | {% block titletag %}{% trans "Sign in" %}{% endblock %}
 4 | {% block bodyclass %}login{% endblock %}
 5 | 
 6 | {% block extra_css %}
 7 |     {{ block.super }}
 8 | 
 9 |     <link rel="stylesheet" href="{% versioned_static 'wagtailadmin/css/layouts/login.css' %}" type="text/css" />
10 | {% endblock %}
11 | 
12 | {% block furniture %}
13 |     <main class="content-wrapper" role="main">
14 |         {% if messages or form.errors %}
15 |             <div class="messages">
16 |                 <ul>
17 |                     {% if form.errors %}
18 |                         <li class="error">{{ form.errors.email.0 }}</li>
19 |                     {% endif %}
20 |                     {% for message in messages %}
21 |                         <li class="{{ message.tags }}">{{ message }}</li>
22 |                     {% endfor %}
23 |                 </ul>
24 |             </div>
25 |         {% endif %}
26 | 
27 |         {% block above_login %}{% endblock %}
28 | 
29 |         <form action="{% url 'wagtailadmin_login' %}" method="post" autocomplete="off" novalidate>
30 |             {% block login_form %}
31 |             {% csrf_token %}
32 | 
33 |             {% url 'wagtailadmin_home' as home_url %}
34 |             <input type="hidden" name="next" value="{{ next|default:home_url }}" />
35 | 
36 |             <h1>{% block branding_login %}{% trans "Sign in to Wagtail" %}{% endblock %}</h1>
37 | 
38 |             <ul class="fields">
39 |                 {% block fields %}
40 |                 <li class="full">
41 |                     <div class="field iconfield">
42 |                         {{ form.email.label_tag }}
43 |                         <div class="input icon-mail">
44 |                             {{ form.email }}
45 |                         </div>
46 |                     </div>
47 |                 </li>
48 | 
49 |                 {% block extra_fields %}
50 |                 {% for field_name, field in form.extra_fields %}gs
51 |                 <li class="full">
52 |                     {{ field.label_tag }}
53 |                     <div class="field iconfield">
54 |                         {{ field }}
55 |                     </div>
56 |                 </li>
57 |                 {% endfor %}
58 |                 {% endblock extra_fields %}
59 | 
60 |                 {% comment %}
61 |                     Removed until functionality exists
62 |                     <li class="checkbox">
63 |                         <div class="field">
64 |                             <label><input type="checkbox" />{% trans "Remember me" %}</label>
65 |                         </div>
66 |                     </li>
67 |                 {% endcomment %}
68 |                 {% endblock %}
69 |                 <li class="submit">
70 |                     {% block submit_buttons %}
71 |                     <button type="submit" class="button button-longrunning" data-clicked-text="{% trans 'Signing in…' %}"><span class="icon icon-spinner"></span><em>{% trans 'Sign in' %}</em></button>
72 |                     {% endblock %}
73 |                 </li>
74 |             </ul>
75 |         {% endblock %}
76 |         </form>
77 | 
78 |         {% block below_login %}{% endblock %}
79 | 
80 |     </main>
81 | {% endblock %}
82 | 
83 | {% block extra_js %}
84 | {{ block.super }}
85 | <script>
86 |     $(function(){
87 |         $('form input[name=email]').trigger('focus');
88 |     })
89 | </script>
90 | {% endblock %}
91 | 


--------------------------------------------------------------------------------
/mailauth/contrib/wagtail/urls.py:
--------------------------------------------------------------------------------
 1 | from django.urls import path
 2 | 
 3 | from . import views
 4 | 
 5 | app_name = "mailauth_wagtail"
 6 | 
 7 | urlpatterns = [
 8 |     path("admin/login/", views.LoginView.as_view(), name="wagtailadmin_login"),
 9 | ]
10 | 


--------------------------------------------------------------------------------
/mailauth/contrib/wagtail/views.py:
--------------------------------------------------------------------------------
 1 | from django.contrib import messages
 2 | from django.http import response
 3 | from django.utils.translation import gettext_lazy as _
 4 | from wagtail.admin.views.account import LoginView as WagtailLoginView
 5 | 
 6 | from mailauth.forms import EmailLoginForm
 7 | 
 8 | __all__ = ("LoginView",)
 9 | 
10 | 
11 | class LoginView(WagtailLoginView):
12 |     """Authentication view for Wagtail admin."""
13 | 
14 |     def get_form_class(self):
15 |         return EmailLoginForm
16 | 
17 |     def form_valid(self, form):
18 |         form.save()
19 |         messages.add_message(
20 |             self.request,
21 |             messages.SUCCESS,
22 |             _("We sent you an email with instructions to log into your account."),
23 |         )
24 |         return response.HttpResponseRedirect(self.get_success_url())
25 | 


--------------------------------------------------------------------------------
/mailauth/forms.py:
--------------------------------------------------------------------------------
  1 | import urllib
  2 | 
  3 | from django import forms
  4 | from django.contrib.auth import get_user_model
  5 | from django.contrib.sites.shortcuts import get_current_site
  6 | from django.core.mail import EmailMultiAlternatives
  7 | from django.db import connection
  8 | from django.template import TemplateDoesNotExist, loader
  9 | from django.urls import reverse
 10 | 
 11 | from mailauth.backends import MailAuthBackend
 12 | 
 13 | 
 14 | class BaseLoginForm(forms.Form):
 15 |     next = forms.CharField(widget=forms.HiddenInput, required=False)
 16 | 
 17 |     def get_login_url(self, request, token, next=None):
 18 |         """
 19 |         Return user login URL including the access token.
 20 | 
 21 |         Args:
 22 |             request (django.http.request.HttpRequest): Current request.
 23 |             token (str): The user specific authentication token.
 24 |             next (str): The path the user should be forwarded to after login.
 25 | 
 26 |         Returns:
 27 |             str: User login URL including the access token.
 28 | 
 29 |         """
 30 |         protocol = "https" if request.is_secure() else "http"
 31 |         current_site = get_current_site(request)
 32 |         url = "{protocol}://{domain}{path}".format(
 33 |             protocol=protocol,
 34 |             domain=current_site.domain,
 35 |             path=reverse("mailauth:login-token", kwargs={"token": token}),
 36 |         )
 37 |         if next is not None:
 38 |             url += "?next=%s" % urllib.parse.quote(next)
 39 |         return url
 40 | 
 41 |     def get_token(self, user):
 42 |         """Return the access token."""
 43 |         return MailAuthBackend.get_token(user=user)
 44 | 
 45 |     def get_mail_context(self, request, user):
 46 |         """
 47 |         Return the context for a message template render.
 48 | 
 49 |         Args:
 50 |             request (django.http.request.HttpRequest): Current request.
 51 |             user: The user requesting a login message.
 52 | 
 53 |         Returns:
 54 |             dict:
 55 |                 A context dictionary including:
 56 |                 - ``site``
 57 |                 - ``site_name``
 58 |                 - ``token``
 59 |                 - ``login_url``
 60 |                 - ``user``
 61 | 
 62 |         """
 63 |         token = self.get_token(user)
 64 |         site = get_current_site(request)
 65 |         login_url = self.get_login_url(request, token, self.cleaned_data["next"])
 66 |         return {
 67 |             "site": site,
 68 |             "site_name": site.name,
 69 |             "token": token,
 70 |             "login_url": login_url,
 71 |             "user": user,
 72 |         }
 73 | 
 74 |     def save(self):
 75 |         """
 76 |         Send login URL to users.
 77 | 
 78 |         Called from the login view, if the form is valid.
 79 | 
 80 |         This method must be implemented by subclasses. This method
 81 |         should trigger the login URL to be sent to the user.
 82 |         """
 83 |         raise NotImplementedError
 84 | 
 85 | 
 86 | class EmailLoginForm(BaseLoginForm):
 87 |     """Login form that contains only the Users email field."""
 88 | 
 89 |     subject_template_name = "registration/login_subject.txt"
 90 |     email_template_name = "registration/login_email.txt"
 91 |     html_email_template_name = "registration/login_email.html"
 92 |     from_email = None
 93 |     field_name = None
 94 | 
 95 |     def __init__(self, request, *args, **kwargs):
 96 |         self.request = request
 97 |         super().__init__(*args, **kwargs)
 98 | 
 99 |         self.field_name = self.field_name or get_user_model().get_email_field_name()
100 |         model_field = get_user_model()._meta.get_field(self.field_name)
101 |         field = model_field.formfield()
102 |         field.required = True
103 | 
104 |         self.fields[self.field_name] = field
105 | 
106 |     def get_users(self, email=None):
107 |         if connection.vendor == "postgresql":
108 |             query = {self.field_name: email}
109 |         else:
110 |             query = {"%s__iexact" % self.field_name: email}
111 |         return get_user_model()._default_manager.filter(**query).iterator()
112 | 
113 |     def save(self):
114 |         """
115 |         Generate and send a one-time link for the user to login.
116 | 
117 |         This method will be called from the view and passed the views request.
118 |         """
119 |         email = self.cleaned_data[self.field_name]
120 |         for user in self.get_users(email):
121 |             context = self.get_mail_context(self.request, user)
122 |             self.send_mail(email, context)
123 | 
124 |     def send_mail(self, to_email, context):
125 |         """Send a django.core.mail.EmailMultiAlternatives to `to_email`."""
126 |         subject = loader.render_to_string(self.subject_template_name, context)
127 |         # Email subject *must not* contain newlines
128 |         subject = "".join(subject.splitlines())
129 |         body = loader.render_to_string(self.email_template_name, context)
130 | 
131 |         email_message = EmailMultiAlternatives(
132 |             subject, body, self.from_email, [to_email]
133 |         )
134 |         try:
135 |             template = loader.get_template(self.html_email_template_name)
136 |         except TemplateDoesNotExist:
137 |             pass
138 |         else:
139 |             html_email = template.render(context, self.request)
140 |             email_message.attach_alternative(html_email, "text/html")
141 | 
142 |         email_message.send()
143 | 


--------------------------------------------------------------------------------
/mailauth/signing.py:
--------------------------------------------------------------------------------
  1 | from django.contrib.auth import get_user_model
  2 | from django.core import signing
  3 | 
  4 | __all__ = (
  5 |     "UserDoesNotExist",
  6 |     "UserSigner",
  7 | )
  8 | 
  9 | 
 10 | class UserDoesNotExist(signing.BadSignature):
 11 |     pass
 12 | 
 13 | 
 14 | class UserSigner(signing.TimestampSigner):
 15 |     """Issue and verify URL safe access tokens for users."""
 16 | 
 17 |     @staticmethod
 18 |     def to_timestamp(value):
 19 |         """
 20 |         Return URL safe base62 encoded timestamp of given datetime.
 21 | 
 22 |         Args:
 23 |             value (datetime.datetime): Datetime instance to encode.
 24 | 
 25 |         Returns:
 26 |             str: URL safe base62 encoded timestamp.
 27 | 
 28 |         """
 29 |         if value is None:
 30 |             return ""
 31 |         return signing.b62_encode(int(value.timestamp()))
 32 | 
 33 |     def sign(self, user):
 34 |         """
 35 |         Return access token for given user.
 36 | 
 37 |         The access token will not include a expiration date, but a timestamp
 38 |         when it has been issued.
 39 | 
 40 |         Args:
 41 |             user (django.contrib.auth.base_user.AbstractBaseUser):
 42 |                 User object to issue a token for.
 43 | 
 44 |         Returns:
 45 |             str: URL safe base64 string.
 46 | 
 47 |         """
 48 |         return super().sign(value=self._make_hash_value(user))
 49 | 
 50 |     def _make_hash_value(self, user):
 51 |         last_login = self.to_timestamp(user.last_login)
 52 |         user_pk = signing.b62_encode(user.pk)
 53 |         return self.sep.join((user_pk, last_login))
 54 | 
 55 |     def unsign(self, value, max_age=None, single_use=True):
 56 |         """
 57 |         Verify access token and return user, if the token is valid.
 58 | 
 59 |         Args:
 60 |             value (str): URL safe base64 encoded access token.
 61 |             max_age (datetime.timedelta): Maximum age an access token to be valid.
 62 |             single_use (bool):
 63 |                 If ``True``, the same token can only be used once and will be invalid
 64 |                 the next try.
 65 |                 If ``False``, the same token can be used multiple times and remains
 66 |                 valid until expired.
 67 |                 Default: ``True``
 68 |         Returns:
 69 |             django.contrib.user.models.BaseUser: Return user object for given
 70 |             access token.
 71 | 
 72 |         Raises:
 73 |             UserDoesNotExist:
 74 |                 If user object does not exist in the database. This can happen,
 75 |                 if the user object has been deleted.
 76 |             SignatureExpired:
 77 |                 If the access token has expired or of the user has been logged in
 78 |                 after the token has been created. The latter prevents users
 79 |                 from using tokens multiple times.
 80 |             django.core.signing.BadSignature:
 81 |                 If the signature does not match provided data.
 82 | 
 83 |         """
 84 |         result = super().unsign(value, max_age=max_age)
 85 |         user_pk, last_login = result.rsplit(self.sep, 2)
 86 |         user_pk = signing.b62_decode(user_pk)
 87 |         try:
 88 |             user = get_user_model()._default_manager.get(pk=user_pk)
 89 |         except get_user_model().DoesNotExist as e:
 90 |             raise UserDoesNotExist("User with pk=%s does not exist" % user_pk) from e
 91 |         else:
 92 |             if (
 93 |                 single_use
 94 |                 and last_login != ""
 95 |                 and self.to_timestamp(user.last_login) != last_login
 96 |             ):
 97 |                 raise signing.SignatureExpired(
 98 |                     "The access token for %r seems used" % user
 99 |                 )
100 |             return user
101 | 


--------------------------------------------------------------------------------
/mailauth/templates/registration/login_email.txt:
--------------------------------------------------------------------------------
 1 | {% load i18n %}{% autoescape off %}
 2 | {% blocktrans %}You're receiving this email because you requested a login link for your user account at {{ site_name }}.{% endblocktrans %}
 3 | 
 4 | {% trans "Please go to the following page to log in:" %}
 5 | {{ login_url }}
 6 | 
 7 | {% trans "Thanks for using our site!" %}
 8 | 
 9 | {% blocktrans %}The {{ site_name }} team{% endblocktrans %}
10 | 
11 | {% endautoescape %}
12 | 


--------------------------------------------------------------------------------
/mailauth/templates/registration/login_subject.txt:
--------------------------------------------------------------------------------
1 | {% load i18n %}{% autoescape off %}
2 | {% blocktrans %}Login link for {{ site_name }}{% endblocktrans %}
3 | {% endautoescape %}


--------------------------------------------------------------------------------
/mailauth/urls.py:
--------------------------------------------------------------------------------
 1 | from django.contrib.auth.views import LogoutView
 2 | from django.urls import path, re_path
 3 | 
 4 | from mailauth import views
 5 | 
 6 | app_name = "mailauth"
 7 | 
 8 | urlpatterns = [
 9 |     path("login/", views.LoginView.as_view(), name="login"),
10 |     path("login/success/", views.LoginRequestedView.as_view(), name="login-success"),
11 |     re_path("login/(?P<token>.*)$", views.LoginTokenView.as_view(), name="login-token"),
12 |     path("logout/", LogoutView.as_view(), name="logout"),
13 | ]
14 | 


--------------------------------------------------------------------------------
/mailauth/views.py:
--------------------------------------------------------------------------------
 1 | from django.conf import settings
 2 | from django.contrib.auth import REDIRECT_FIELD_NAME, authenticate, login
 3 | from django.contrib.auth.views import LoginView as DjangoLoginView
 4 | from django.core.exceptions import PermissionDenied
 5 | from django.http import response
 6 | from django.shortcuts import resolve_url
 7 | from django.utils.decorators import method_decorator
 8 | from django.views import generic
 9 | from django.views.decorators.cache import never_cache
10 | 
11 | from mailauth import forms
12 | 
13 | __all__ = (
14 |     "LoginView",
15 |     "LoginTokenView",
16 | )
17 | 
18 | 
19 | class LoginView(DjangoLoginView):
20 |     """
21 |     Send a login code to the user.
22 | 
23 |     It doesn't authenticate a user but it is the entry point for the login
24 |     process (login URL).
25 |     """
26 | 
27 |     form_class = forms.EmailLoginForm
28 |     success_url = getattr(settings, "LOGIN_REQUESTED_URL", "mailauth:login-success")
29 |     template_name = "registration/login.html"
30 |     redirect_field_name = REDIRECT_FIELD_NAME
31 | 
32 |     def form_valid(self, form):
33 |         form.save()
34 |         return response.HttpResponseRedirect(self.get_success_url())
35 | 
36 |     def get_success_url(self):
37 |         return resolve_url(self.success_url)
38 | 
39 |     def get_initial(self):
40 |         return {
41 |             self.redirect_field_name: self.request.GET.get(self.redirect_field_name),
42 |             **super().get_initial(),
43 |         }
44 | 
45 | 
46 | INTERNAL_LOGIN_URL_TOKEN = "login-token"  # nosec
47 | 
48 | 
49 | class LoginTokenView(DjangoLoginView):
50 |     """Authenticate a user via an access token."""
51 | 
52 |     redirect_field_name = REDIRECT_FIELD_NAME
53 | 
54 |     @method_decorator(never_cache)
55 |     def dispatch(self, request, *args, **kwargs):
56 |         return super().dispatch(request, *args, **kwargs)
57 | 
58 |     def get(self, request, *args, **kwargs):
59 |         token = kwargs["token"]
60 | 
61 |         user = authenticate(request, token=token)
62 |         if user is None:
63 |             raise PermissionDenied
64 |         else:
65 |             login(self.request, user=user)
66 |             # Remove token from the HTTP Referer header
67 |             self.request.path.replace(token, INTERNAL_LOGIN_URL_TOKEN)
68 | 
69 |         return response.HttpResponseRedirect(self.get_success_url())
70 | 
71 |     def post(self, request, *args, **kwargs):
72 |         return self.http_method_not_allowed(request, *args, **kwargs)
73 | 
74 | 
75 | class LoginRequestedView(generic.TemplateView):
76 |     template_name = "registration/login_requested.html"
77 | 


--------------------------------------------------------------------------------
/pyproject.toml:
--------------------------------------------------------------------------------
  1 | [build-system]
  2 | requires = ["flit_core>=3.2", "flit_scm", "wheel"]
  3 | build-backend = "flit_scm:buildapi"
  4 | 
  5 | [project]
  6 | name = "django-mail-auth"
  7 | authors = [
  8 |   { name = "Johannes Maron", email = "johannes@maron.family" },
  9 | ]
 10 | readme = "README.rst"
 11 | license = { file = "LICENSE" }
 12 | keywords = [
 13 |   "django",
 14 |   "otp",
 15 |   "email",
 16 |   "authentication",
 17 |   "passwordless",
 18 | ]
 19 | dynamic = ["version", "description"]
 20 | classifiers = [
 21 |   "Development Status :: 5 - Production/Stable",
 22 |   "Environment :: Console",
 23 |   "Intended Audience :: Developers",
 24 |   "License :: OSI Approved :: MIT License",
 25 |   "Operating System :: OS Independent",
 26 |   "Programming Language :: Python :: 3",
 27 |   "Programming Language :: Python :: 3.10",
 28 |   "Programming Language :: Python :: 3.11",
 29 |   "Programming Language :: Python :: 3.12",
 30 |   "Programming Language :: Python :: 3 :: Only",
 31 |   "Framework :: Django",
 32 |   "Framework :: Django :: 4.2",
 33 |   "Framework :: Django :: 5.0",
 34 |   "Framework :: Django :: 5.1",
 35 |   "Framework :: Wagtail",
 36 |   "Framework :: Wagtail :: 5",
 37 |   "Framework :: Wagtail :: 6",
 38 |   "Topic :: Internet",
 39 |   "Topic :: Internet :: WWW/HTTP",
 40 |   "Topic :: Software Development :: Quality Assurance",
 41 |   "Topic :: Software Development :: Testing",
 42 | ]
 43 | requires-python = ">=3.10"
 44 | dependencies = [
 45 |   "django>=4.2"
 46 | ]
 47 | 
 48 | [project.optional-dependencies]
 49 | test = [
 50 |   "pytest",
 51 |   "pytest-cov",
 52 |   "pytest-django",
 53 | ]
 54 | lint = [
 55 |   "bandit==1.8.3",
 56 |   "black==25.1.0",
 57 |   "flake8==7.2.0",
 58 |   "isort==6.0.1",
 59 |   "pydocstyle[toml]==6.3.0",
 60 | ]
 61 | docs = [
 62 |   "sphinx",
 63 | ]
 64 | wagtail = [
 65 |   "wagtail>=2.8",
 66 | ]
 67 | postgres = [
 68 |   "django-citext",
 69 | ]
 70 | 
 71 | [project.urls]
 72 | Project-URL = "https://github.com/codingjoe/django-mail-auth"
 73 | Changelog = "https://github.com/codingjoe/django-mail-auth/releases"
 74 | Source = "https://github.com/codingjoe/django-mail-auth"
 75 | Documentation = "https://django-mail-auth.rtfd.io/"
 76 | Issue-Tracker = "https://github.com/codingjoe/django-mail-auth/issues"
 77 | 
 78 | [tool.flit.module]
 79 | name = "mailauth"
 80 | 
 81 | [tool.setuptools_scm]
 82 | write_to = "mailauth/_version.py"
 83 | 
 84 | [tool.pytest.ini_options]
 85 | minversion = "6.0"
 86 | addopts = "--cov --tb=short -rxs"
 87 | testpaths = ["tests"]
 88 | DJANGO_SETTINGS_MODULE = "tests.testapp.settings"
 89 | 
 90 | [tool.coverage.run]
 91 | source = ["mailauth"]
 92 | 
 93 | [tool.coverage.report]
 94 | show_missing = true
 95 | 
 96 | [tool.isort]
 97 | atomic = true
 98 | line_length = 88
 99 | multi_line_output = 3
100 | force_grid_wrap = 0
101 | known_first_party = "mailauth, tests"
102 | include_trailing_comma = true
103 | use_parentheses = true
104 | default_section = "THIRDPARTY"
105 | combine_as_imports = true
106 | skip = ["mailauth/_version.py"]
107 | 
108 | [tool.pydocstyle]
109 | add_ignore = "D1"
110 | 


--------------------------------------------------------------------------------
/sample.png:
--------------------------------------------------------------------------------
https://raw.githubusercontent.com/codingjoe/django-mail-auth/f32e1d9fe11f794a41d0b7bf7d3594586ea1c400/sample.png


--------------------------------------------------------------------------------
/setup.cfg:
--------------------------------------------------------------------------------
1 | [flake8]
2 | max-line-length=88
3 | select = C,E,F,W,B,B950
4 | ignore = E203, E501, W503, E731
5 | 


--------------------------------------------------------------------------------
/tests/__init__.py:
--------------------------------------------------------------------------------
https://raw.githubusercontent.com/codingjoe/django-mail-auth/f32e1d9fe11f794a41d0b7bf7d3594586ea1c400/tests/__init__.py


--------------------------------------------------------------------------------
/tests/conftest.py:
--------------------------------------------------------------------------------
 1 | import zoneinfo
 2 | 
 3 | import pytest
 4 | from django.contrib.auth import get_user_model
 5 | from django.utils import timezone
 6 | 
 7 | from mailauth import signing
 8 | 
 9 | 
10 | class FrozenUserSigner(signing.UserSigner):
11 |     """Freeze timestamp for test runs."""
12 | 
13 |     def timestamp(self):
14 |         return "1Hjptg"
15 | 
16 | 
17 | @pytest.fixture()
18 | def user(db):
19 |     """Return a user instance."""
20 |     return get_user_model().objects.create_user(
21 |         pk=1337,
22 |         email="spiderman@avengers.com",
23 |         last_login=timezone.datetime(2002, 5, 3, tzinfo=zoneinfo.ZoneInfo("UTC")),
24 |     )
25 | 
26 | 
27 | @pytest.fixture()
28 | def admin_user(db):
29 |     """Return a user instance."""
30 |     return get_user_model().objects.create_user(
31 |         pk=1337,
32 |         email="spiderman@avengers.com",
33 |         last_login=timezone.datetime(2002, 5, 3, tzinfo=zoneinfo.ZoneInfo("UTC")),
34 |         is_superuser=True,
35 |     )
36 | 
37 | 
38 | @pytest.fixture()
39 | def signature():
40 |     """Return a signature matching the user fixture."""
41 |     return "LZ:173QUS:1Hjptg:6oq5DS1NJ7SxJ1o-CpfgaqrImVaRpkcHrzV9yltwcHM"
42 | 
43 | 
44 | @pytest.fixture()
45 | def signer():
46 |     """Return a forzen version of the UserSigner."""
47 |     return FrozenUserSigner()
48 | 


--------------------------------------------------------------------------------
/tests/contrib/__init__.py:
--------------------------------------------------------------------------------
https://raw.githubusercontent.com/codingjoe/django-mail-auth/f32e1d9fe11f794a41d0b7bf7d3594586ea1c400/tests/contrib/__init__.py


--------------------------------------------------------------------------------
/tests/contrib/admin/__init__.py:
--------------------------------------------------------------------------------
https://raw.githubusercontent.com/codingjoe/django-mail-auth/f32e1d9fe11f794a41d0b7bf7d3594586ea1c400/tests/contrib/admin/__init__.py


--------------------------------------------------------------------------------
/tests/contrib/admin/test_admin.py:
--------------------------------------------------------------------------------
1 | def test_login_view():
2 |     from django.contrib.admin import site
3 | 
4 |     assert site.login.__module__ == "mailauth.contrib.admin.views"
5 | 


--------------------------------------------------------------------------------
/tests/contrib/admin/test_views.py:
--------------------------------------------------------------------------------
 1 | from django.core import mail
 2 | 
 3 | 
 4 | class TestAdminLoginView:
 5 |     def test_get(self, client):
 6 |         response = client.get("/django-admin/login/")
 7 |         assert response.status_code == 200
 8 |         assert b'type="email"' in response.content
 9 |         assert b'id="id_email"' in response.content
10 | 
11 |     def test_post(self, client, user, signature):
12 |         response = client.post(
13 |             "/django-admin/login/", data={"email": "spiderman@avengers.com"}
14 |         )
15 |         assert response.status_code == 302, response.content.decode()
16 |         assert mail.outbox
17 | 
18 |     def test_post__user_does_not_exist(self, db, client):
19 |         response = client.post(
20 |             "/django-admin/login/", data={"email": "superman@avengers.com"}
21 |         )
22 |         assert response.status_code == 302, response.content.decode()
23 |         assert not mail.outbox
24 | 


--------------------------------------------------------------------------------
/tests/contrib/auth/__init__.py:
--------------------------------------------------------------------------------
https://raw.githubusercontent.com/codingjoe/django-mail-auth/f32e1d9fe11f794a41d0b7bf7d3594586ea1c400/tests/contrib/auth/__init__.py


--------------------------------------------------------------------------------
/tests/contrib/auth/test_admin.py:
--------------------------------------------------------------------------------
 1 | from unittest.mock import Mock
 2 | 
 3 | import pytest
 4 | from django.contrib import admin
 5 | from django.contrib.auth.models import Permission
 6 | 
 7 | from mailauth.contrib.user.admin import AnonymizableAdminMixin
 8 | from mailauth.contrib.user.models import EmailUser
 9 | 
10 | 
11 | class TestAnonymizableAdminMixin:
12 |     def test_anonymize__none(self, rf):
13 |         class MyUserModel(EmailUser):
14 |             class Meta:
15 |                 app_label = "test"
16 |                 verbose_name = "singular"
17 |                 verbose_name_plural = "plural"
18 | 
19 |         class MyModelAdmin(AnonymizableAdminMixin, admin.ModelAdmin):
20 |             pass
21 | 
22 |         request = rf.get("/")
23 |         MyModelAdmin(MyUserModel, admin.site).anonymize(
24 |             request, MyUserModel.objects.none()
25 |         )
26 | 
27 |     @pytest.mark.django_db
28 |     def test_anonymize__one(self, rf, user, monkeypatch):
29 |         class MyModelAdmin(AnonymizableAdminMixin, admin.ModelAdmin):
30 |             pass
31 | 
32 |         monkeypatch.setattr(EmailUser, "anonymize", Mock())
33 | 
34 |         request = rf.get("/")
35 |         MyModelAdmin(type(user), admin.site).anonymize(
36 |             request, type(user).objects.all()
37 |         )
38 |         assert EmailUser.anonymize.was_called_once_with(user)
39 | 
40 |     @pytest.mark.django_db
41 |     def test_anonymize__many(self, rf, user, monkeypatch):
42 |         class MyModelAdmin(AnonymizableAdminMixin, admin.ModelAdmin):
43 |             pass
44 | 
45 |         monkeypatch.setattr(EmailUser, "anonymize", Mock())
46 | 
47 |         request = rf.get("/")
48 |         MyModelAdmin(type(user), admin.site).anonymize(
49 |             request, type(user).objects.all()
50 |         )
51 |         assert EmailUser.anonymize.was_called_once_with(user)
52 | 
53 |     def test_has_anonymize_permission(self, rf, user):
54 |         class MyModelAdmin(AnonymizableAdminMixin, admin.ModelAdmin):
55 |             pass
56 | 
57 |         user.is_staff = True
58 |         user.save()
59 |         request = rf.get("/")
60 |         request.user = user
61 |         assert not MyModelAdmin(type(user), admin.site).has_anonymize_permission(
62 |             request
63 |         )
64 | 
65 |         permission = Permission.objects.get(
66 |             codename="anonymize",
67 |         )
68 |         user.user_permissions.add(permission)
69 |         del user._perm_cache
70 |         del user._user_perm_cache
71 |         assert MyModelAdmin(type(user), admin.site).has_anonymize_permission(request)
72 | 


--------------------------------------------------------------------------------
/tests/contrib/auth/test_models.py:
--------------------------------------------------------------------------------
 1 | import pytest
 2 | from django.core.exceptions import FieldDoesNotExist
 3 | 
 4 | from mailauth.contrib.user.models import EmailUser
 5 | 
 6 | 
 7 | class TestAbstractEmailUser:
 8 |     def test_has_usable_password(self):
 9 |         assert not EmailUser().has_usable_password()
10 | 
11 |     def test_get_session_auth_hash__default(self, db):
12 |         user = EmailUser(email="spiderman@avengers.com")
13 | 
14 |         assert user.session_salt
15 |         assert user.get_session_auth_hash()
16 | 
17 |     def test_get_session_auth_hash__value_error(self, db):
18 |         user = EmailUser(email="spiderman@avengers.com", session_salt=None)
19 | 
20 |         with pytest.raises(ValueError) as e:
21 |             user.get_session_auth_hash()
22 | 
23 |         assert "'session_salt' must be set" in str(e.value)
24 | 
25 |     def test_get_session_auth_hash__unique(self, db):
26 |         spiderman = EmailUser(email="spiderman@avengers.com")
27 |         ironman = EmailUser(email="ironman@avengers.com")
28 | 
29 |         assert spiderman.get_session_auth_hash() != ironman.get_session_auth_hash()
30 | 
31 |     def test_password_field(self):
32 |         user = EmailUser(email="spiderman@avengers.com")
33 |         with pytest.raises(FieldDoesNotExist):
34 |             assert user.password
35 | 
36 | 
37 | class TestEmailUserManager:
38 |     def test_create_user(self, db):
39 |         user = EmailUser.objects.create_user("spiderman@avengers.com")
40 |         assert user.pk is not None
41 |         assert user.email == "spiderman@avengers.com"
42 |         assert not user.is_superuser
43 | 
44 |     def test_create_superuser(self, db):
45 |         user = EmailUser.objects.create_superuser("spiderman@avengers.com")
46 |         assert user.is_superuser
47 | 
48 |     def test_create_superuser__no_staff(self, db):
49 |         with pytest.raises(ValueError, match="Superuser must have is_staff=True."):
50 |             EmailUser.objects.create_superuser(
51 |                 "spiderman@avengers.com",
52 |                 is_staff=False,
53 |             )
54 | 
55 |     def test_create_superuser__no_superuser(self, db):
56 |         with pytest.raises(ValueError, match="Superuser must have is_superuser=True."):
57 |             EmailUser.objects.create_superuser(
58 |                 "spiderman@avengers.com",
59 |                 is_superuser=False,
60 |             )
61 | 


--------------------------------------------------------------------------------
/tests/contrib/auth/test_signals.py:
--------------------------------------------------------------------------------
 1 | from unittest.mock import Mock
 2 | 
 3 | import pytest
 4 | from django.dispatch import receiver
 5 | 
 6 | from mailauth.contrib.user.signals import anonymize
 7 | 
 8 | 
 9 | @pytest.mark.django_db
10 | def test_anonymize(user):
11 |     handler = Mock()
12 |     receiver(anonymize, sender=user.__class__)(handler)
13 |     handler.assert_not_called()
14 |     user.anonymize()
15 |     handler.assert_called_once_with(
16 |         signal=anonymize,
17 |         sender=user.__class__,
18 |         instance=user,
19 |     )
20 | 


--------------------------------------------------------------------------------
/tests/contrib/wagtail/__init__.py:
--------------------------------------------------------------------------------
https://raw.githubusercontent.com/codingjoe/django-mail-auth/f32e1d9fe11f794a41d0b7bf7d3594586ea1c400/tests/contrib/wagtail/__init__.py


--------------------------------------------------------------------------------
/tests/contrib/wagtail/test_views.py:
--------------------------------------------------------------------------------
 1 | import pytest
 2 | 
 3 | from mailauth.forms import EmailLoginForm
 4 | 
 5 | 
 6 | class TestLoginView:
 7 |     def test_get_from_class(self):
 8 |         pytest.importorskip("wagtail")
 9 |         from mailauth.contrib.wagtail.views import LoginView
10 | 
11 |         assert issubclass(LoginView().get_form_class(), EmailLoginForm)
12 | 
13 |     def test_form_valid(self, rf, db):
14 |         pytest.importorskip("wagtail")
15 |         from mailauth.contrib.wagtail.views import LoginView
16 | 
17 |         view = LoginView()
18 |         request = rf.get("/")
19 | 
20 |         class DummyMessageStorage:
21 |             def __init__(self):
22 |                 self.messages = []
23 | 
24 |             def add(self, *args):
25 |                 self.messages.append(args)
26 | 
27 |         msgs = DummyMessageStorage()
28 | 
29 |         request._messages = msgs
30 |         view.request = request
31 |         form = EmailLoginForm(view.request, data=dict(email="spiderman@avengers.com"))
32 |         assert form.is_valid()
33 |         response = view.form_valid(form)
34 |         assert response.status_code == 302
35 |         assert msgs.messages
36 | 


--------------------------------------------------------------------------------
/tests/test_backends.py:
--------------------------------------------------------------------------------
 1 | import logging
 2 | 
 3 | from mailauth.backends import MailAuthBackend
 4 | 
 5 | 
 6 | class TestMailAuthBackend:
 7 |     def test_authenticate(self, db, user, settings, signer, signature):
 8 |         settings.LOGIN_URL_TIMEOUT = float("inf")
 9 |         backend = MailAuthBackend()
10 |         backend.signer = signer
11 |         user = backend.authenticate(None, token=signature)
12 |         assert user is not None
13 |         assert user.is_authenticated
14 | 
15 |     def test_authenticate__user_is_not_active(
16 |         self, db, caplog, user, settings, signer, signature
17 |     ):
18 |         settings.LOGIN_URL_TIMEOUT = float("inf")
19 |         backend = MailAuthBackend()
20 |         backend.signer = signer
21 |         user.is_active = False
22 |         user.save(update_fields=["is_active"], force_update=True)
23 |         with caplog.at_level(logging.WARNING):
24 |             user = backend.authenticate(None, token=signature)
25 | 
26 |         assert user is None
27 |         assert caplog.records[-1].levelname == "WARNING"
28 |         assert caplog.records[-1].message == (
29 |             "User 'spiderman@avengers.com' is not allowed to authenticate."
30 |         )
31 | 
32 |     def test_authenticate__user_does_not_exist(
33 |         self, db, caplog, settings, signer, signature
34 |     ):
35 |         settings.LOGIN_URL_TIMEOUT = float("inf")
36 |         backend = MailAuthBackend()
37 |         backend.signer = signer
38 |         with caplog.at_level(logging.WARNING):
39 |             user = backend.authenticate(None, token=signature)
40 |         assert user is None
41 |         assert caplog.records[-1].levelname == "WARNING"
42 |         assert caplog.records[-1].message == (
43 |             "Valid token for non-existing user. Maybe the user has been deleted."
44 |         )
45 | 
46 |     def test_authenticate__timeout(self, db, caplog, user, settings, signer, signature):
47 |         settings.LOGIN_URL_TIMEOUT = 0
48 |         backend = MailAuthBackend()
49 |         backend.signer = signer
50 |         with caplog.at_level(logging.WARNING):
51 |             user = backend.authenticate(None, token=signature)
52 |         assert user is None
53 |         assert caplog.records[-1].levelname == "WARNING"
54 |         assert caplog.records[-1].message == "Token has expired."
55 | 
56 |     def test_authenticate__corrupted_token(
57 |         self, db, caplog, user, settings, signer, signature
58 |     ):
59 |         settings.LOGIN_URL_TIMEOUT = 0
60 |         backend = MailAuthBackend()
61 |         backend.signer = signer
62 |         with caplog.at_level(logging.ERROR):
63 |             user = backend.authenticate(None, token="not/a/valid-token")
64 |         assert user is None
65 |         assert caplog.records[-1].levelname == "ERROR"
66 |         assert (
67 |             caplog.records[-1].message
68 |             == 'Malicious or corrupted login token received: "not/a/valid-token"'
69 |         )
70 | 
71 |     def test_get_token(self, signer, signature, user):
72 |         backend = MailAuthBackend()
73 |         MailAuthBackend.signer = signer
74 |         assert backend.get_token(user) == signature
75 | 
76 |     def test_get_login_url(self, signer, signature):
77 |         backend = MailAuthBackend()
78 |         MailAuthBackend.signer = signer
79 |         assert backend.get_login_url(signature) == (f"/accounts/login/{signature}")
80 | 


--------------------------------------------------------------------------------
/tests/test_forms.py:
--------------------------------------------------------------------------------
 1 | import pytest
 2 | from django.core import mail
 3 | 
 4 | from mailauth.forms import BaseLoginForm, EmailLoginForm
 5 | 
 6 | 
 7 | class TestBaseLoginForm:
 8 |     def test_save(self):
 9 |         with pytest.raises(NotImplementedError):
10 |             BaseLoginForm().save()
11 | 
12 | 
13 | class TestEmailLoginForm:
14 |     def test_get_login_url(self, rf):
15 |         request = rf.get("/")
16 |         form = EmailLoginForm(request=request)
17 |         assert (
18 |             form.get_login_url(request, "TOKEN")
19 |             == "http://testserver/accounts/login/TOKEN"
20 |         )
21 |         assert (
22 |             form.get_login_url(
23 |                 request,
24 |                 "TOKEN",
25 |                 next="/path/?utm_source=website&utm_medium=email#some-anchor",
26 |             )
27 |             == "http://testserver/accounts/login/TOKEN?next=/path/%3Futm_source%3Dwebsite%26utm_medium%3Demail%23some-anchor"
28 |         )
29 | 
30 |     def test_send_mail__html_template(self):
31 |         class MyEmailLoginForm(EmailLoginForm):
32 |             html_email_template_name = EmailLoginForm.email_template_name
33 | 
34 |         MyEmailLoginForm(request=None).send_mail("spiderman@avengers.com", {})
35 |         assert mail.outbox[-1].alternatives
36 | 
37 |     def test_get_users(self, db, user):
38 |         assert list(EmailLoginForm(request=None).get_users("spiderman@avengers.com"))
39 |         assert list(EmailLoginForm(request=None).get_users("SpiderMan@Avengers.com"))
40 |         assert not list(EmailLoginForm(request=None).get_users("SpiderMan@dc.com"))
41 | 


--------------------------------------------------------------------------------
/tests/test_models.py:
--------------------------------------------------------------------------------
 1 | import pytest
 2 | from django.db import IntegrityError
 3 | 
 4 | from mailauth.contrib.user import models
 5 | 
 6 | 
 7 | class TestEmailUser:
 8 |     def test_email__ci_unique(self, db):
 9 |         pytest.importorskip("psycopg")
10 |         models.EmailUser.objects.create_user("IronMan@avengers.com")
11 |         with pytest.raises(IntegrityError):
12 |             models.EmailUser.objects.create_user("ironman@avengers.com")
13 | 
14 |     @pytest.mark.django_db
15 |     def test_anonymize(self):
16 |         user = models.EmailUser.objects.create_user(
17 |             email="ironman@avengers.com", first_name="Tony", last_name="Stark"
18 |         )
19 |         assert user.anonymize() == ["email", "first_name", "last_name"]
20 |         assert not user.first_name
21 |         assert not user.last_name
22 |         assert not user.email
23 | 
24 |     def test_anonymize__no_commit(self):
25 |         user = models.EmailUser(
26 |             email="ironman@avengers.com", first_name="Tony", last_name="Stark"
27 |         )
28 |         user.anonymize(commit=False)
29 |         assert not user.first_name
30 |         assert not user.last_name
31 |         assert not user.email
32 | 


--------------------------------------------------------------------------------
/tests/test_signing.py:
--------------------------------------------------------------------------------
 1 | import zoneinfo
 2 | 
 3 | import pytest
 4 | from django.contrib.auth import get_user_model
 5 | from django.core.signing import SignatureExpired
 6 | from django.utils import timezone
 7 | 
 8 | from mailauth import signing
 9 | 
10 | 
11 | class TestUserSigner:
12 |     def test_sign(self, user, signer, signature):
13 |         assert signer.sign(user) == signature
14 | 
15 |     def test_unsign(self, db, signer, signature):
16 |         user = get_user_model().objects.create_user(
17 |             pk=1337,
18 |             email="spiderman@avengers.com",
19 |             last_login=timezone.datetime(2002, 5, 3, tzinfo=zoneinfo.ZoneInfo("UTC")),
20 |         )
21 |         assert user == signer.unsign(signature)
22 | 
23 |     def test_unsign__no_user(self, db, signer, signature):
24 |         with pytest.raises(
25 |             signing.UserDoesNotExist, match="User with pk=1337 does not exist"
26 |         ):
27 |             signer.unsign(signature)
28 | 
29 |     def test_unsign__last_login(self, db, signer, signature):
30 |         get_user_model().objects.create_user(
31 |             pk=1337,
32 |             email="spiderman@avengers.com",
33 |             # later date, that does not match the signature
34 |             last_login=timezone.datetime(2012, 7, 3, tzinfo=zoneinfo.ZoneInfo("UTC")),
35 |         )
36 |         with pytest.raises(
37 |             SignatureExpired,
38 |             match="The access token for <EmailUser: spiderman@avengers.com> seems used",
39 |         ):
40 |             signer.unsign(signature)
41 | 
42 |     def test_unsing__single_use(self, db, signer, signature):
43 |         user = get_user_model().objects.create_user(
44 |             pk=1337,
45 |             email="spiderman@avengers.com",
46 |             # later date, that does not match the signature (token was used)
47 |             last_login=timezone.datetime(2012, 7, 3, tzinfo=zoneinfo.ZoneInfo("UTC")),
48 |         )
49 |         assert user == signer.unsign(signature, single_use=False)
50 |         # test a second time to make sure token can be used more than one time
51 |         assert user == signer.unsign(signature, single_use=False)
52 |         with pytest.raises(
53 |             SignatureExpired,
54 |             match="The access token for <EmailUser: spiderman@avengers.com> seems used",
55 |         ):
56 |             signer.unsign(signature, single_use=True)
57 | 
58 |     def test_to_timestamp(self):
59 |         value = timezone.datetime(2002, 5, 3, tzinfo=zoneinfo.ZoneInfo("UTC"))
60 |         base62_value = signing.UserSigner.to_timestamp(value=value)
61 |         assert base62_value == "173QUS"
62 | 
63 |     def test_to_timestamp__empty(self):
64 |         base62_value = signing.UserSigner.to_timestamp(value=None)
65 |         assert base62_value == ""
66 | 


--------------------------------------------------------------------------------
/tests/test_views.py:
--------------------------------------------------------------------------------
 1 | from django.urls import reverse
 2 | 
 3 | from mailauth.views import LoginView
 4 | 
 5 | 
 6 | class TestLoginView:
 7 |     def test_get_initial(self, rf):
 8 |         view = LoginView()
 9 |         view.request = rf.get("/", data={"next": "foo/bar"})
10 | 
11 |         assert view.get_initial() == {"next": "foo/bar"}
12 | 
13 | 
14 | class TestLoginTokenView:
15 |     def test_get__ok(self, client, user, signature, settings):
16 |         settings.LOGIN_URL_TIMEOUT = float("inf")
17 |         url = reverse("mailauth:login-token", kwargs={"token": signature})
18 |         response = client.get(url)
19 |         assert response.status_code == 302
20 |         assert response.url == "/accounts/profile/"
21 | 
22 |     def test_get__next(self, client, user, signature, settings):
23 |         settings.LOGIN_URL_TIMEOUT = float("inf")
24 |         url = reverse("mailauth:login-token", kwargs={"token": signature})
25 |         response = client.get(url + "?next=/admin/")
26 |         assert response.status_code == 302
27 |         assert response.url == "/admin/"
28 | 
29 |     def test_get__invalid_token(self, client, user, signature, settings):
30 |         settings.LOGIN_URL_TIMEOUT = float("inf")
31 |         url = reverse("mailauth:login-token", kwargs={"token": "invalid_token"})
32 |         response = client.get(url)
33 |         assert response.status_code == 403
34 | 
35 |     def test_get__wrong_signature(self, client, user, signature, settings):
36 |         settings.LOGIN_URL_TIMEOUT = float("inf")
37 |         url = reverse("mailauth:login-token", kwargs={"token": signature + "false"})
38 |         response = client.get(url)
39 |         assert response.status_code == 403
40 | 
41 |     def test_get__no_user(self, client, signature, settings):
42 |         settings.LOGIN_URL_TIMEOUT = float("inf")
43 |         url = reverse("mailauth:login-token", kwargs={"token": signature})
44 |         response = client.post(url)
45 |         assert response.status_code == 405
46 | 


--------------------------------------------------------------------------------
/tests/testapp/__init__.py:
--------------------------------------------------------------------------------
https://raw.githubusercontent.com/codingjoe/django-mail-auth/f32e1d9fe11f794a41d0b7bf7d3594586ea1c400/tests/testapp/__init__.py


--------------------------------------------------------------------------------
/tests/testapp/manage.py:
--------------------------------------------------------------------------------
 1 | #!/usr/bin/env python
 2 | """Django's command-line utility for administrative tasks."""
 3 | import os
 4 | import sys
 5 | 
 6 | 
 7 | def main():
 8 |     os.environ.setdefault("DJANGO_SETTINGS_MODULE", "tests.testapp.settings")
 9 |     sys.path.insert(0, os.path.abspath("."))
10 |     try:
11 |         from django.core.management import execute_from_command_line
12 |     except ImportError as exc:
13 |         raise ImportError(
14 |             "Couldn't import Django. Are you sure it's installed and "
15 |             "available on your PYTHONPATH environment variable? Did you "
16 |             "forget to activate a virtual environment?"
17 |         ) from exc
18 |     execute_from_command_line(sys.argv)
19 | 
20 | 
21 | if __name__ == "__main__":
22 |     main()
23 | 


--------------------------------------------------------------------------------
/tests/testapp/settings.py:
--------------------------------------------------------------------------------
  1 | """
  2 | Django settings for testapp project.
  3 | 
  4 | Generated by 'django-admin startproject' using Django 2.2.
  5 | 
  6 | For more information on this file, see
  7 | https://docs.djangoproject.com/en/2.2/topics/settings/
  8 | 
  9 | For the full list of settings and their values, see
 10 | https://docs.djangoproject.com/en/2.2/ref/settings/
 11 | """
 12 | 
 13 | import os
 14 | 
 15 | # Build paths inside the project like this: os.path.join(BASE_DIR, ...)
 16 | 
 17 | BASE_DIR = os.path.dirname(os.path.dirname(os.path.abspath(__file__)))
 18 | 
 19 | 
 20 | # Quick-start development settings - unsuitable for production
 21 | # See https://docs.djangoproject.com/en/2.2/howto/deployment/checklist/
 22 | 
 23 | # SECURITY WARNING: keep the secret key used in production secret!
 24 | SECRET_KEY = "supersecret"
 25 | 
 26 | # SECURITY WARNING: don't run with debug turned on in production!
 27 | DEBUG = True
 28 | 
 29 | ALLOWED_HOSTS = []
 30 | 
 31 | 
 32 | # Application definition
 33 | 
 34 | INSTALLED_APPS = [
 35 |     "django.contrib.admin",
 36 |     "django.contrib.auth",
 37 |     "django.contrib.contenttypes",
 38 |     "django.contrib.sessions",
 39 |     "django.contrib.messages",
 40 |     "django.contrib.staticfiles",
 41 |     "mailauth",
 42 |     "mailauth.contrib.admin",
 43 |     "mailauth.contrib.user",
 44 | ]
 45 | 
 46 | try:
 47 |     import wagtail  # NoQA
 48 | except ImportError:
 49 |     pass
 50 | else:
 51 |     INSTALLED_APPS += [
 52 |         "mailauth.contrib.wagtail",
 53 |         "wagtail.admin",
 54 |         "wagtail.users",
 55 |         "wagtail",
 56 |     ]
 57 | 
 58 | AUTHENTICATION_BACKENDS = ("mailauth.backends.MailAuthBackend",)
 59 | 
 60 | AUTH_USER_MODEL = "mailauth_user.EmailUser"
 61 | 
 62 | MIDDLEWARE = [
 63 |     "django.middleware.security.SecurityMiddleware",
 64 |     "django.contrib.sessions.middleware.SessionMiddleware",
 65 |     "django.middleware.locale.LocaleMiddleware",
 66 |     "django.middleware.common.CommonMiddleware",
 67 |     "django.middleware.csrf.CsrfViewMiddleware",
 68 |     "django.contrib.auth.middleware.AuthenticationMiddleware",
 69 |     "django.contrib.messages.middleware.MessageMiddleware",
 70 |     "django.middleware.clickjacking.XFrameOptionsMiddleware",
 71 | ]
 72 | 
 73 | ROOT_URLCONF = "tests.testapp.urls"
 74 | 
 75 | TEMPLATES = [
 76 |     {
 77 |         "BACKEND": "django.template.backends.django.DjangoTemplates",
 78 |         "DIRS": [],
 79 |         "APP_DIRS": True,
 80 |         "OPTIONS": {
 81 |             "context_processors": [
 82 |                 "django.template.context_processors.debug",
 83 |                 "django.template.context_processors.request",
 84 |                 "django.contrib.auth.context_processors.auth",
 85 |                 "django.contrib.messages.context_processors.messages",
 86 |             ],
 87 |         },
 88 |     },
 89 | ]
 90 | 
 91 | WSGI_APPLICATION = "tests.testapp.wsgi.application"
 92 | 
 93 | 
 94 | # Database
 95 | # https://docs.djangoproject.com/en/2.2/ref/settings/#databases
 96 | 
 97 | DB = os.getenv("DB", "sqlite")
 98 | if DB == "sqlite":
 99 |     DATABASES = {
100 |         "default": {
101 |             "ENGINE": "django.db.backends.sqlite3",
102 |             "NAME": os.path.join(BASE_DIR, "db.sqlite3"),
103 |         }
104 |     }
105 | elif DB == "pg":
106 |     DATABASES = {
107 |         "default": {
108 |             "ENGINE": "django.db.backends.postgresql",
109 |             "HOST": "127.0.0.1",
110 |             "PORT": int(os.getenv("DB_PORT", 3306)),
111 |             "NAME": "default_django",
112 |             "USER": "django",
113 |             "PASSWORD": "django",
114 |         }
115 |     }
116 | 
117 | 
118 | LANGUAGE_CODE = "en-us"
119 | 
120 | 
121 | # Internationalization
122 | # https://docs.djangoproject.com/en/2.2/topics/i18n/
123 | 
124 | TIME_ZONE = "UTC"
125 | 
126 | USE_I18N = True
127 | USE_TZ = True
128 | 
129 | 
130 | # Static files (CSS, JavaScript, Images)
131 | # https://docs.djangoproject.com/en/2.2/howto/static-files/
132 | 
133 | STATIC_URL = "/static/"
134 | 
135 | EMAIL_BACKEND = "django.core.mail.backends.console.EmailBackend"
136 | 


--------------------------------------------------------------------------------
/tests/testapp/urls.py:
--------------------------------------------------------------------------------
 1 | from django.contrib import admin
 2 | from django.urls import include, path
 3 | 
 4 | urlpatterns = [
 5 |     path("accounts/", include("mailauth.urls")),
 6 |     path("django-admin/", admin.site.urls),
 7 | ]
 8 | 
 9 | try:
10 |     from wagtail.admin import urls as wagtailadmin_urls
11 | except ImportError:
12 |     pass
13 | else:
14 |     urlpatterns += [
15 |         path("", include("mailauth.contrib.wagtail.urls")),
16 |         path("admin/", include(wagtailadmin_urls)),
17 |     ]
18 | 


--------------------------------------------------------------------------------
/tests/testapp/wsgi.py:
--------------------------------------------------------------------------------
 1 | """
 2 | WSGI config for testapp project.
 3 | 
 4 | It exposes the WSGI callable as a module-level variable named ``application``.
 5 | 
 6 | For more information on this file, see
 7 | https://docs.djangoproject.com/en/2.2/howto/deployment/wsgi/
 8 | """
 9 | 
10 | import os
11 | 
12 | from django.core.wsgi import get_wsgi_application
13 | 
14 | os.environ.setdefault("DJANGO_SETTINGS_MODULE", "settings")
15 | 
16 | application = get_wsgi_application()
17 | 


--------------------------------------------------------------------------------