Wie kann das Benutzermodell (zusammen mit der Authentifizierungs-App von Django) am besten um benutzerdefinierte Felder erweitert werden? Möglicherweise möchte ich auch die E-Mail als Benutzernamen verwenden (zur Authentifizierung).

Ich habe bereits einige Möglichkeiten gesehen , kann mich aber nicht entscheiden, welche die beste ist.

Der am wenigsten schmerzhafte und in der Tat von Django empfohlene Weg, dies zu tun, ist durch eine OneToOneField(User)Eigenschaft.

Erweitern des vorhandenen Benutzermodells

…

Wenn Sie Informationen zu speichern möchten User, können Sie eine Eins-zu-Eins-Beziehung zu einem Modell verwenden, das die Felder für zusätzliche Informationen enthält. Dieses Eins-zu-Eins-Modell wird häufig als Profilmodell bezeichnet, da es möglicherweise nicht authentifizierungsbezogene Informationen über einen Site-Benutzer speichert.

Das heißt, es zu erweitern django.contrib.auth.models.Userund zu ersetzen funktioniert auch ...

Ersetzen eines benutzerdefinierten Benutzermodells

Für einige Arten von Projekten gelten möglicherweise Authentifizierungsanforderungen, für die das integrierte UserModell von Django nicht immer geeignet ist. Auf einigen Websites ist es beispielsweise sinnvoller, anstelle eines Benutzernamens eine E-Mail-Adresse als Identifikations-Token zu verwenden.

[Ed: Es folgen zwei Warnungen und eine Benachrichtigung , in der erwähnt wird, dass dies ziemlich drastisch ist .]

Ich würde mich definitiv davon fernhalten, die tatsächliche Benutzerklasse in Ihrem Django-Quellbaum zu ändern und / oder das Auth-Modul zu kopieren und zu ändern.

Hinweis: Diese Antwort ist veraltet. Weitere Antworten finden Sie, wenn Sie Django 1.7 oder höher verwenden.

So mache ich es.

#in models.py
from django.contrib.auth.models import User
from django.db.models.signals import post_save

class UserProfile(models.Model):  
    user = models.OneToOneField(User)  
    #other fields here

    def __str__(self):  
          return "%s's profile" % self.user  

def create_user_profile(sender, instance, created, **kwargs):  
    if created:  
       profile, created = UserProfile.objects.get_or_create(user=instance)  

post_save.connect(create_user_profile, sender=User) 

#in settings.py
AUTH_PROFILE_MODULE = 'YOURAPP.UserProfile'

Dadurch wird jedes Mal ein Benutzerprofil erstellt, wenn ein Benutzer gespeichert wird, wenn er erstellt wird. Sie können dann verwenden

  user.get_profile().whatever

Hier finden Sie weitere Informationen aus den Dokumenten

http://docs.djangoproject.com/de/dev/topics/auth/#storing-additional-information-about-users

Update: Bitte beachten Sie, dass dies AUTH_PROFILE_MODULEseit Version 1.5 veraltet ist: https://docs.djangoproject.com/de/1.5/ref/settings/#auth-profile-module

Nun, seit 2008 ist einige Zeit vergangen und es ist Zeit für eine neue Antwort. Seit Django 1.5 können Sie benutzerdefinierte Benutzerklassen erstellen. Zum Zeitpunkt, an dem ich dies schreibe, ist es bereits in master zusammengeführt, sodass Sie es ausprobieren können.

In diesem Commit finden Sie einige Informationen dazu in Dokumenten oder wenn Sie sich eingehender damit befassen möchten .

Alles, was Sie tun müssen, ist AUTH_USER_MODEL, Einstellungen mit dem Pfad zur benutzerdefinierten Benutzerklasse hinzuzufügen , der entweder erweitert AbstractBaseUser(anpassbarere Version) oderAbstractUser (mehr oder weniger alte Benutzerklasse, die Sie erweitern können).

Für Leute, die faul sind zu klicken, hier das Codebeispiel (aus Dokumenten entnommen ):

from django.db import models
from django.contrib.auth.models import (
    BaseUserManager, AbstractBaseUser
)


class MyUserManager(BaseUserManager):
    def create_user(self, email, date_of_birth, password=None):
        """
        Creates and saves a User with the given email, date of
        birth and password.
        """
        if not email:
            raise ValueError('Users must have an email address')

        user = self.model(
            email=MyUserManager.normalize_email(email),
            date_of_birth=date_of_birth,
        )

        user.set_password(password)
        user.save(using=self._db)
        return user

    def create_superuser(self, username, date_of_birth, password):
        """
        Creates and saves a superuser with the given email, date of
        birth and password.
        """
        u = self.create_user(username,
                        password=password,
                        date_of_birth=date_of_birth
                    )
        u.is_admin = True
        u.save(using=self._db)
        return u


class MyUser(AbstractBaseUser):
    email = models.EmailField(
                        verbose_name='email address',
                        max_length=255,
                        unique=True,
                    )
    date_of_birth = models.DateField()
    is_active = models.BooleanField(default=True)
    is_admin = models.BooleanField(default=False)

    objects = MyUserManager()

    USERNAME_FIELD = 'email'
    REQUIRED_FIELDS = ['date_of_birth']

    def get_full_name(self):
        # The user is identified by their email address
        return self.email

    def get_short_name(self):
        # The user is identified by their email address
        return self.email

    def __unicode__(self):
        return self.email

    def has_perm(self, perm, obj=None):
        "Does the user have a specific permission?"
        # Simplest possible answer: Yes, always
        return True

    def has_module_perms(self, app_label):
        "Does the user have permissions to view the app `app_label`?"
        # Simplest possible answer: Yes, always
        return True

    @property
    def is_staff(self):
        "Is the user a member of staff?"
        # Simplest possible answer: All admins are staff
        return self.is_admin

Seit Django 1.5 können Sie das Benutzermodell problemlos erweitern und eine einzelne Tabelle in der Datenbank behalten.

from django.contrib.auth.models import AbstractUser
from django.db import models
from django.utils.translation import ugettext_lazy as _

class UserProfile(AbstractUser):
    age = models.PositiveIntegerField(_("age"))

Sie müssen es auch als aktuelle Benutzerklasse in Ihrer Einstellungsdatei konfigurieren

# supposing you put it in apps/profiles/models.py
AUTH_USER_MODEL = "profiles.UserProfile"

Wenn Sie viele Benutzereinstellungen hinzufügen möchten, ist die OneToOneField-Option möglicherweise die bessere Wahl.

Ein Hinweis für Benutzer, die Bibliotheken von Drittanbietern entwickeln: Wenn Sie auf die Benutzerklasse zugreifen müssen, denken Sie daran, dass Benutzer diese ändern können. Verwenden Sie den offiziellen Helfer, um die richtige Klasse zu finden

from django.contrib.auth import get_user_model

User = get_user_model()

Es gibt eine offizielle Empfehlung zum Speichern zusätzlicher Informationen über Benutzer . Das Django-Buch behandelt dieses Problem auch im Abschnitt Profile .

Das Folgende ist ein weiterer Ansatz zum Erweitern eines Benutzers. Ich denke, es ist klarer, einfacher und lesbarer als über zwei Ansätzen.

http://scottbarnham.com/blog/2008/08/21/extending-the-django-user-model-with-inheritance/

Verwenden Sie den obigen Ansatz:

1. Sie müssen user.get_profile (). newattribute nicht verwenden, um auf die zusätzlichen Informationen zuzugreifen, die sich auf den Benutzer beziehen
2. Sie können einfach direkt über user.newattribute auf zusätzliche neue Attribute zugreifen

Sie können das Benutzerprofil einfach erweitern, indem Sie jedes Mal, wenn ein Benutzer mithilfe von Django-Post-Save-Signalen erstellt wird, einen neuen Eintrag erstellen

models.py

from django.db.models.signals import *
from __future__ import unicode_literals

class UserProfile(models.Model):

    user_name = models.OneToOneField(User, related_name='profile')
    city = models.CharField(max_length=100, null=True)

    def __unicode__(self):  # __str__
        return unicode(self.user_name)

def create_user_profile(sender, instance, created, **kwargs):
    if created:
        userProfile.objects.create(user_name=instance)

post_save.connect(create_user_profile, sender=User)

Dadurch wird automatisch eine Mitarbeiterinstanz erstellt, wenn ein neuer Benutzer erstellt wird.

Wenn Sie das Benutzermodell erweitern und beim Erstellen eines Benutzers weitere Informationen hinzufügen möchten, können Sie django-betterforms ( http://django-betterforms.readthedocs.io/en/latest/multiform.html) verwenden ). Dadurch wird ein Benutzer-Add-Formular mit allen im UserProfile-Modell definierten Feldern erstellt.

models.py

from django.db.models.signals import *
from __future__ import unicode_literals

class UserProfile(models.Model):

    user_name = models.OneToOneField(User)
    city = models.CharField(max_length=100)

    def __unicode__(self):  # __str__
        return unicode(self.user_name)

forms.py

from django import forms
from django.forms import ModelForm
from betterforms.multiform import MultiModelForm
from django.contrib.auth.forms import UserCreationForm
from .models import *

class ProfileForm(ModelForm):

    class Meta:
        model = Employee
        exclude = ('user_name',)


class addUserMultiForm(MultiModelForm):
    form_classes = {
        'user':UserCreationForm,
        'profile':ProfileForm,
    }

views.py

from django.shortcuts import redirect
from .models import *
from .forms import *
from django.views.generic import CreateView

class AddUser(CreateView):
    form_class = AddUserMultiForm
    template_name = "add-user.html"
    success_url = '/your-url-after-user-created'

    def form_valid(self, form):
        user = form['user'].save()
        profile = form['profile'].save(commit=False)
        profile.user_name = User.objects.get(username= user.username)
        profile.save()
        return redirect(self.success_url)

addUser.html

<!DOCTYPE html>
<html lang="en">
    <head>
        <meta charset="UTF-8">
        <title>Title</title>
    </head>
    <body>
        <form action="." method="post">
            {% csrf_token %}
            {{ form }}     
            <button type="submit">Add</button>
        </form>
     </body>
</html>

urls.py

from django.conf.urls import url, include
from appName.views import *
urlpatterns = [
    url(r'^add-user/$', AddUser.as_view(), name='add-user'),
]

Erweitern des Django-Benutzermodells (UserProfile) wie ein Profi

Ich fand das sehr nützlich: Link

Ein Auszug:

aus django.contrib.auth.models Benutzer importieren

class Employee(models.Model):
    user = models.OneToOneField(User)
    department = models.CharField(max_length=100)

>>> u = User.objects.get(username='fsmith')
>>> freds_department = u.employee.department

Neu in Django 1.5, jetzt können Sie Ihr eigenes benutzerdefiniertes Benutzermodell erstellen (was im obigen Fall eine gute Sache zu sein scheint). Siehe 'Anpassen der Authentifizierung in Django'

Wahrscheinlich die coolste neue Funktion in Version 1.5.

Dies ist, was ich tue und es ist meiner Meinung nach der einfachste Weg, dies zu tun. Definieren Sie einen Objektmanager für Ihr neues benutzerdefiniertes Modell und definieren Sie dann Ihr Modell.

from django.db import models
from django.contrib.auth.models import PermissionsMixin, AbstractBaseUser, BaseUserManager

class User_manager(BaseUserManager):
    def create_user(self, username, email, gender, nickname, password):
        email = self.normalize_email(email)
        user = self.model(username=username, email=email, gender=gender, nickname=nickname)
        user.set_password(password)
        user.save(using=self.db)
        return user

    def create_superuser(self, username, email, gender, password, nickname=None):
        user = self.create_user(username=username, email=email, gender=gender, nickname=nickname, password=password)
        user.is_superuser = True
        user.is_staff = True
        user.save()
        return user



  class User(PermissionsMixin, AbstractBaseUser):
    username = models.CharField(max_length=32, unique=True, )
    email = models.EmailField(max_length=32)
    gender_choices = [("M", "Male"), ("F", "Female"), ("O", "Others")]
    gender = models.CharField(choices=gender_choices, default="M", max_length=1)
    nickname = models.CharField(max_length=32, blank=True, null=True)

    is_active = models.BooleanField(default=True)
    is_staff = models.BooleanField(default=False)
    REQUIRED_FIELDS = ["email", "gender"]
    USERNAME_FIELD = "username"
    objects = User_manager()

    def __str__(self):
        return self.username

Vergessen Sie nicht, diese Codezeile in Ihre settings.py:

AUTH_USER_MODEL = 'YourApp.User'

Das ist was ich tue und es funktioniert immer.

Ab Django 2.2 wird beim Starten eines neuen Projekts empfohlen, ein benutzerdefiniertes Benutzermodell zu erstellen, das von AbstractUser erbt, und dann AUTH_USER_MODEL auf das Modell zu verweisen.

Quelle: https://docs.djangoproject.com/de/2.2/topics/auth/customizing/#using-a-custom-user-model-when-starting-a-project

Einfacher und effektiver Ansatz ist models.py

from django.contrib.auth.models import User
class CustomUser(User):
     profile_pic = models.ImageField(upload_to='...')
     other_field = models.CharField()