Benutzerdefiniertes Benutzermodell mit E-Mail als primäres Anmeldefeld.

from __future__ import unicode_literals
from django.db import models
from django.contrib.auth.models import (
        AbstractBaseUser, BaseUserManager, PermissionsMixin)
from django.utils import timezone
from django.utils.translation import ugettext_lazy as _

class UserManager(BaseUserManager):
    def _create_user(self, email,password, is_staff, is_superuser, **extra_fields):
        now =
        if not email:
            raise ValueError('users must have an email address')
        email = self.normalize_email(email)
        user = self.model(email = email,
                            is_staff = is_staff,
                            is_superuser = is_superuser,
                            last_login = now,
                            date_joined = now,
        user.set_password(password) = self._db)
        return user

    def create_user(self, email, password=None, **extra_fields):
        user = self._create_user(email, password, False, False, **extra_fields)
        return user

    def create_superuser(self, email, password, **extra_fields):
        user = self._create_user(email, password, True, True, **extra_fields)
        return user

class User(AbstractBaseUser,PermissionsMixin):
    """My own custom user class"""

    email = models.EmailField(max_length=255, unique=True, db_index=True, verbose_name=_('email address'))
    date_joined = models.DateTimeField(auto_now_add=True)
    is_active = models.BooleanField(default=True)
    is_staff = models.BooleanField(default=False)

    objects = UserManager()

    USERNAME_FIELD = 'email'

    class Meta:
        verbose_name = _('user')
        verbose_name_plural = _('users')

    def get_full_name(self):
    """Return the email."""

    def get_short_name(self):
    """Return the email."""

from django import forms
from django.contrib.auth.forms import UserCreationForm
from .models import User

class RegistrationForm(UserCreationForm):
    email = forms.EmailField(widget=forms.TextInput(
        attrs={'class': 'form-control','type':'text','name': 'email'}),
    password1 = forms.CharField(widget=forms.PasswordInput(
        attrs={'class':'form-control','type':'password', 'name':'password1'}),
    password2 = forms.CharField(widget=forms.PasswordInput(
        attrs={'class':'form-control','type':'password', 'name': 'password2'}),
        label="Password (again)")

    '''added attributes so as to customise for styling, like bootstrap'''
    class Meta:
        model = User
        fields = ['email','password1','password2']
        field_order = ['email','password1','password2']

    def clean(self):
    Verifies that the values entered into the password fields match
    NOTE : errors here will appear in 'non_field_errors()'
        cleaned_data = super(RegistrationForm, self).clean()
        if 'password1' in self.cleaned_data and 'password2' in self.cleaned_data:
            if self.cleaned_data['password1'] != self.cleaned_data['password2']:
                raise forms.ValidationError("Passwords don't match. Please try again!")
        return self.cleaned_data

    def save(self, commit=True):
        user = super(RegistrationForm,self).save(commit=False)
        if commit:
        return user

#The save(commit=False) tells Django to save the new record, but dont commit it to the database yet

class AuthenticationForm(forms.Form): # Note: forms.Form NOT forms.ModelForm
    email = forms.EmailField(widget=forms.TextInput(
        attrs={'class': 'form-control','type':'text','name': 'email','placeholder':'Email'}), 
    password = forms.CharField(widget=forms.PasswordInput(
        attrs={'class':'form-control','type':'password', 'name': 'password','placeholder':'Password'}),

    class Meta:
        fields = ['email', 'password']

from django.shortcuts import redirect, render, HttpResponse
from django.contrib.auth import login as django_login, logout as django_logout, authenticate as django_authenticate
#importing as such so that it doesn't create a confusion with our methods and django's default methods

from django.contrib.auth.decorators import login_required
from .forms import AuthenticationForm, RegistrationForm

def login(request):
    if request.method == 'POST':
        form = AuthenticationForm(data = request.POST)
        if form.is_valid():
            email = request.POST['email']
            password = request.POST['password']
            user = django_authenticate(email=email, password=password)
            if user is not None:
                if user.is_active:
                    return redirect('/dashboard') #user is redirected to dashboard
        form = AuthenticationForm()

    return render(request,'login.html',{'form':form,})

def register(request):
    if request.method == 'POST':
        form = RegistrationForm(data = request.POST)
        if form.is_valid():
            user =
            u = django_authenticate( = user, user.password = password)
            return redirect('/dashboard')
        form = RegistrationForm()

    return render(request,'register.html',{'form':form,})

def logout(request):
    return redirect('/')

@login_required(login_url ="/")
def dashboard(request):
    return render(request, 'dashboard.html',{})

AUTH_USER_MODEL = 'myapp.User'

from django.contrib import admin
from django.contrib.auth.admin import UserAdmin as BaseUserAdmin
from django.contrib.auth.models import Group
from .models import User

class UserAdmin(BaseUserAdmin):
    list_display = ('email','is_staff')
    list_filter = ('is_staff',)
    fieldsets = ((None, 
                  {'fields':('email','password')}), ('Permissions',{'fields':('is_staff',)}),)
    add_fieldsets = ((None, {'classes': ('wide',), 'fields': ('email', 'password1', 'password2')}),)
    search_fields =('email',)
    ordering = ('email',)
    filter_horizontal = (), UserAdmin)

Verwenden Sie die "E-Mail" als Benutzernamen und entfernen Sie das Feld "Benutzername"

Wenn Sie das username Feld loswerden und email als eindeutige Benutzer- username verwenden möchten, müssen Sie ein benutzerdefiniertes User erstellen, das AbstractBaseUser anstelle von AbstractUser . username und email sind in AbstractUser definiert und können nicht überschrieben werden. Das bedeutet, dass Sie auch alle Felder neu definieren müssen, die Sie in AbstractUser definieren möchten.

from django.contrib.auth.models import (
    AbstractBaseUser, PermissionsMixin, BaseUserManager,
from django.db import models
from django.utils import timezone
from django.utils.translation import ugettext_lazy as _

class UserManager(BaseUserManager):

    use_in_migrations = True

    def _create_user(self, email, password, **extra_fields):
        if not email:
            raise ValueError('The given email must be set')
        email = self.normalize_email(email)
        user = self.model(email=email, **extra_fields)
        return user

    def create_user(self, email, password=None, **extra_fields):
        extra_fields.setdefault('is_staff', False)
        extra_fields.setdefault('is_superuser', False)
        return self._create_user(email, password, **extra_fields)

    def create_superuser(self, email, password, **extra_fields):
        extra_fields.setdefault('is_staff', True)
        extra_fields.setdefault('is_superuser', True)

        if extra_fields.get('is_staff') is not True:
            raise ValueError('Superuser must have is_staff=True.')
        if extra_fields.get('is_superuser') is not True:
            raise ValueError('Superuser must have is_superuser=True.')

    return self._create_user(email, password, **extra_fields)

class User(AbstractBaseUser, PermissionsMixin):
    """PermissionsMixin contains the following fields:
        - `is_superuser`
        - `groups`
        - `user_permissions`
     You can omit this mix-in if you don't want to use permissions or
     if you want to implement your own permissions logic.

    class Meta:
        verbose_name = _("user")
        verbose_name_plural = _("users")
        db_table = 'auth_user'
        # `db_table` is only needed if you move from the existing default
        # User model to a custom one. This enables to keep the existing data.

    USERNAME_FIELD = 'email'
    """Use the email as unique username."""

    REQUIRED_FIELDS = ['first_name', 'last_name']

        (GENDER_MALE, _("Male")),
        (GENDER_FEMALE, _("Female")),

    email = models.EmailField(
        verbose_name=_("email address"), unique=True,
            'unique': _(
                "A user is already registered with this email address"),
    gender = models.CharField(
        max_length=1, blank=True, choices=GENDER_CHOICES,
    first_name = models.CharField(
        max_length=30, verbose_name=_("first name"),
    last_name = models.CharField(
        max_length=30, verbose_name=_("last name"),
    is_staff = models.BooleanField(
        verbose_name=_("staff status"),
            "Designates whether the user can log into this admin site."
    is_active = models.BooleanField(
            "Designates whether this user should be treated as active. "
            "Unselect this instead of deleting accounts."
    date_joined = models.DateTimeField(
        verbose_name=_("date joined"),,

    objects = UserManager()

Erweitern Sie das Django-Benutzermodell einfach

Unsere UserProfile Klasse

Erstellen Sie ein UserProfile Modellklasse mit der Beziehung von OneToOne zum User

from django.db import models
from django.contrib.auth.models import User
from django.db.models.signals import post_save

class UserProfile(models.Model):
    user = models.OneToOneField(User, related_name='user')
    photo = FileField(verbose_name=_("Profile Picture"),
                      upload_to=upload_to("", "profiles"),
                      format="Image", max_length=255, null=True, blank=True)
    website = models.URLField(default='', blank=True)
    bio = models.TextField(default='', blank=True)
    phone = models.CharField(max_length=20, blank=True, default='')
    city = models.CharField(max_length=100, default='', blank=True)
    country = models.CharField(max_length=100, default='', blank=True)
    organization = models.CharField(max_length=100, default='', blank=True)

Django-Signale bei der Arbeit

Erstellen Sie mit Django-Signalen ein neues UserProfile ein User erstellt wird. Diese Funktion kann unter der UserProfile Modellklasse in derselben Datei gespeichert oder an UserProfile Stelle platziert werden. Es ist mir egal, wie Sie es richtig bezeichnen.

def create_profile(sender, **kwargs):
    user = kwargs["instance"]
    if kwargs["created"]:
        user_profile = UserProfile(user=user)
post_save.connect(create_profile, sender=User)

inlineformset_factory zur Rettung

Nun für Ihre haben Sie vielleicht so etwas:

from django.shortcuts import render, HttpResponseRedirect
from django.contrib.auth.decorators import login_required
from django.contrib.auth.models import User
from .models import UserProfile
from .forms import UserForm
from django.forms.models import inlineformset_factory
from django.core.exceptions import PermissionDenied
@login_required() # only logged in users should access this
def edit_user(request, pk):
    # querying the User object with pk from url
    user = User.objects.get(pk=pk)

    # prepopulate UserProfileForm with retrieved user values from above.
    user_form = UserForm(instance=user)

    # The sorcery begins from here, see explanation
    ProfileInlineFormset = inlineformset_factory(User, UserProfile, fields=('website', 'bio', 'phone', 'city', 'country', 'organization'))
    formset = ProfileInlineFormset(instance=user)

    if request.user.is_authenticated() and ==
        if request.method == "POST":
            user_form = UserForm(request.POST, request.FILES, instance=user)
            formset = ProfileInlineFormset(request.POST, request.FILES, instance=user)

            if user_form.is_valid():
                created_user =
                formset = ProfileInlineFormset(request.POST, request.FILES, instance=created_user)

                if formset.is_valid():
                    return HttpResponseRedirect('/accounts/profile/')

        return render(request, "account/account_update.html", {
            "noodle": pk,
            "noodle_form": user_form,
            "formset": formset,
        raise PermissionDenied

Unsere Vorlage

Dann spucken Sie alles in Ihre Vorlage account_update.html wie account_update.html :

{% load material_form %}
<!-- Material form is just a materialize thing for django forms -->
<div class="col s12 m8 offset-m2">
      <div class="card">
        <div class="card-content">
        <h2 class="flow-text">Update your information</h2>
          <form action="." method="POST" class="padding">
            {% csrf_token %} {{ noodle_form.as_p }}
            <div class="divider"></div>
            {{ formset.management_form }}
                {{ formset.as_p }}
            <button type="submit" class="btn-floating btn-large waves-light waves-effect"><i class="large material-icons">done</i></button>
            <a href="#" onclick="window.history.back(); return false;" title="Cancel" class="btn-floating waves-effect waves-light red"><i class="material-icons">history</i></a>

Das obige Snippet von Extending Django UserProfile wie ein Profi

Angeben eines benutzerdefinierten Benutzermodells

Das eingebaute User Django ist für einige Arten von Projekten nicht immer angemessen. Auf einigen Websites kann es sinnvoller sein, anstelle eines Benutzernamens beispielsweise eine E-Mail-Adresse zu verwenden.

Sie können das Standard- User überschreiben, indem Sie Ihr benutzerdefiniertes User der Einstellung AUTH_USER_MODEL in Ihrer Projekteinstellungsdatei hinzufügen:

AUTH_USER_MODEL = 'myapp.MyUser'

Beachten Sie, dass es sehr adviced ist das schaffen AUTH_USER_MODEL , bevor Sie Migrationen zu schaffen oder Laufen migrate zum ersten Mal. Aufgrund der Einschränkungen der dynamischen Abhängigkeit von Django.

In Ihrem Blog möchten Sie beispielsweise, dass sich andere Autoren mit einer E-Mail-Adresse anstelle des normalen Benutzernamens anmelden können. Daher erstellen wir ein benutzerdefiniertes User mit einer E-Mail-Adresse mit dem Namen USERNAME_FIELD :

from django.contrib.auth.models import AbstractBaseUser

class CustomUser(AbstractBaseUser):
     email = models.EmailField(unique=True)
     USERNAME_FIELD = 'email'

Durch die Übernahme des AbstractBaseUser wir ein kompatibles User erstellen. AbstractBaseUser stellt die Kernimplementierung eines User bereit.

Um die Django zu lassen createsuperuser Befehl wissen , welche anderen Bereichen al erforderlich wir angeben können REQUIRED_FIELDS . Dieser Wert hat keine Auswirkung in anderen Teilen von Django!

class CustomUser(AbstractBaseUser):
    first_name = models.CharField(max_length=254)
    last_name = models.CharField(max_length=254)
    REQUIRED_FIELDS = ['first_name', 'last_name']

Um mit anderen Teilen von Django kompatibel zu sein, müssen wir noch den Wert is_active , die Funktionen get_full_name() und get_short_name() :

class CustomUser(AbstractBaseUser):
    is_active = models.BooleanField(default=False)
    def get_full_name(self):
        full_name = "{0} {1}".format(self.first_name, self.last_name)
        return full_name.strip()

    def get_short_name(self):
        return self.first_name

Sie sollten auch einen benutzerdefinierten UserManager für Ihr User erstellen, der Django die Verwendung der Funktionen create_user() und create_superuser() :

from django.contrib.auth.models import BaseUserManager

class CustomUserManager(BaseUserManager):
    def create_user(self, email, first_name, last_name, password=None):
        if not email:
            raise ValueError('Users must have an email address')

        user = self.model(

        user.first_name = first_name
        user.last_name = last_name
        return user

    def create_superuser(self, email, first_name, last_name, password):
        user = self.create_user(

        user.is_admin = True
        user.is_active = True
        return user

Referenzieren des Benutzermodells

Ihr Code funktioniert nicht in Projekten, in denen Sie direkt auf das User verweisen ( und in denen die Einstellung AUTH_USER_MODEL geändert wurde ).

Beispiel: Wenn Sie ein Post Modell für ein Blog mit einem benutzerdefinierten User erstellen möchten, sollten Sie das benutzerdefinierte User angeben:

from django.conf import settings
from django.db import models

class Post(models.Model):
    author = models.ForeignKey(settings.AUTH_USER_MODEL, on_delete=models.CASCADE)

Modified text is an extract of the original Stack Overflow Documentation
Lizenziert unter CC BY-SA 3.0
Nicht angeschlossen an Stack Overflow