Quelle est la meilleure façon d'étendre le modèle utilisateur (fourni avec l'application d'authentification de Django) avec des champs personnalisés? Je voudrais également éventuellement utiliser l'e-mail comme nom d'utilisateur (à des fins d'authentification).

J'ai déjà vu quelques façons de le faire, mais je ne peux pas décider laquelle est la meilleure.

La façon la moins pénible et même recommandée par Django de le faire est d'utiliser une OneToOneField(User)propriété.

Extension du modèle utilisateur existant

…

Si vous souhaitez stocker des informations liées à User, vous pouvez utiliser une relation un à un avec un modèle contenant les champs pour des informations supplémentaires. Ce modèle un-à-un est souvent appelé modèle de profil, car il peut stocker des informations non liées à l'authentification sur un utilisateur du site.

Cela dit, l'étendre django.contrib.auth.models.Useret le supplanter fonctionne aussi ...

Substitution d'un modèle utilisateur personnalisé

Certains types de projets peuvent avoir des exigences d'authentification pour lesquelles le Usermodèle intégré de Django n'est pas toujours approprié. Par exemple, sur certains sites, il est plus logique d'utiliser une adresse e-mail comme jeton d'identification au lieu d'un nom d'utilisateur.

[Ed: Deux avertissements et une notification suivent , mentionnant que c'est assez drastique .]

Je resterais certainement à l'écart de changer la classe utilisateur réelle dans votre arborescence source Django et / ou de copier et de modifier le module d'authentification.

Remarque: cette réponse est déconseillée. voir d'autres réponses si vous utilisez Django 1.7 ou une version ultérieure.

Voilà comment je le fais.

#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'

Cela créera un profil utilisateur chaque fois qu'un utilisateur est enregistré s'il est créé. Vous pouvez ensuite utiliser

  user.get_profile().whatever

Voici quelques informations supplémentaires de la documentation

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

Mise à jour: veuillez noter qu'elle AUTH_PROFILE_MODULEest obsolète depuis la version 1.5: https://docs.djangoproject.com/en/1.5/ref/settings/#auth-profile-module

Eh bien, un certain temps s'est écoulé depuis 2008 et il est temps pour une nouvelle réponse. Depuis Django 1.5, vous pourrez créer une classe d'utilisateurs personnalisée. En fait, au moment où j'écris ceci, il a déjà été fusionné dans master, vous pouvez donc l'essayer.

Il y a des informations à ce sujet dans les documents ou si vous souhaitez approfondir, dans ce commit .

Tout ce que vous avez à faire est d'ajouter AUTH_USER_MODELaux paramètres avec le chemin vers la classe d'utilisateurs personnalisée, qui s'étend soit AbstractBaseUser(version plus personnalisable) ou AbstractUser(plus ou moins ancienne classe d'utilisateurs que vous pouvez étendre).

Pour les personnes qui sont paresseuses à cliquer, voici un exemple de code (tiré de documents ):

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

Depuis Django 1.5, vous pouvez facilement étendre le modèle utilisateur et conserver une seule table dans la base de données.

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"))

Vous devez également le configurer en tant que classe d'utilisateurs actuelle dans votre fichier de paramètres

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

Si vous souhaitez ajouter un grand nombre de préférences des utilisateurs, l'option OneToOneField peut être un meilleur choix.

Une note pour les personnes développant des bibliothèques tierces: si vous avez besoin d'accéder à la classe d'utilisateurs, n'oubliez pas que les gens peuvent la changer. Utilisez l'aide officielle pour obtenir la bonne classe

from django.contrib.auth import get_user_model

User = get_user_model()

Il existe une recommandation officielle sur le stockage d'informations supplémentaires sur les utilisateurs . Le livre Django traite également de ce problème dans la section Profils .

Celui ci-dessous est une autre approche pour étendre un utilisateur. Je pense que c'est plus clair, facile, lisible puis au-dessus de deux approches.

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

En utilisant l'approche ci-dessus:

1. vous n'avez pas besoin d'utiliser user.get_profile (). newattribute pour accéder aux informations supplémentaires relatives à l'utilisateur
2. vous pouvez simplement accéder directement à de nouveaux attributs supplémentaires via user.newattribute

Vous pouvez simplement étendre le profil de l'utilisateur en créant une nouvelle entrée à chaque fois qu'un utilisateur est créé à l'aide des signaux de sauvegarde de Django

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)

Cela créera automatiquement une instance d'employé lorsqu'un nouvel utilisateur est créé.

Si vous souhaitez étendre le modèle utilisateur et souhaitez ajouter des informations supplémentaires lors de la création d'un utilisateur, vous pouvez utiliser django-betterforms ( http://django-betterforms.readthedocs.io/en/latest/multiform.html ). Cela créera un formulaire d'ajout d'utilisateur avec tous les champs définis dans le modèle UserProfile.

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'),
]

Extension du modèle utilisateur Django (UserProfile) comme un pro

J'ai trouvé cela très utile: lien

Un extrait:

depuis django.contrib.auth.models import User

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

Nouveau dans Django 1.5, vous pouvez maintenant créer votre propre modèle d'utilisateur personnalisé (ce qui semble être une bonne chose à faire dans le cas ci-dessus). Voir 'Personnalisation de l'authentification dans Django'

Probablement la nouvelle fonctionnalité la plus cool de la version 1.5.

C'est ce que je fais et c'est à mon avis le moyen le plus simple de le faire. définir un gestionnaire d'objets pour votre nouveau modèle personnalisé puis définir votre modèle.

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

N'oubliez pas d'ajouter cette ligne de code dans votre settings.py:

AUTH_USER_MODEL = 'YourApp.User'

C'est ce que je fais et ça marche toujours.

Actuellement à partir de Django 2.2, la méthode recommandée lors du démarrage d'un nouveau projet consiste à créer un modèle utilisateur personnalisé qui hérite de AbstractUser, puis à pointer AUTH_USER_MODEL vers le modèle.

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

Une approche simple et efficace est models.py

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