Qual é a melhor maneira de estender o modelo de usuário (fornecido com o aplicativo de autenticação do Django) com campos personalizados? Também gostaria de usar o email como nome de usuário (para fins de autenticação).

Eu já vi algumas maneiras de fazer isso, mas não consigo decidir qual é a melhor.

A maneira menos dolorosa e realmente recomendada pelo Django de fazer isso é através de uma OneToOneField(User)propriedade.

Estendendo o modelo de usuário existente

...

Se você deseja armazenar informações relacionadas User, pode usar um relacionamento individual para um modelo que contém os campos para obter informações adicionais. Esse modelo individual é geralmente chamado de modelo de perfil, pois pode armazenar informações não relacionadas à autenticação sobre um usuário do site.

Dito isto, estender django.contrib.auth.models.Usere suplantar também funciona ...

Substituindo um Modelo de Usuário Customizado

Alguns tipos de projetos podem ter requisitos de autenticação para os quais o modelo interno do Django Usernem sempre é apropriado. Por exemplo, em alguns sites, faz mais sentido usar um endereço de email como seu token de identificação em vez de um nome de usuário.

[Ed: dois avisos e uma notificação a seguir , mencionando que isso é bastante drástico .]

Eu definitivamente ficaria longe de mudar a classe User real na sua árvore de código-fonte do Django e / ou copiar e alterar o módulo de autenticação.

Nota: esta resposta está obsoleta. Veja outras respostas se você estiver usando o Django 1.7 ou posterior.

É assim que eu faço.

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

Isso criará um perfil de usuário sempre que um usuário for salvo, se ele for criado. Você pode então usar

  user.get_profile().whatever

Aqui estão mais algumas informações dos documentos

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

Atualização: observe que AUTH_PROFILE_MODULEestá obsoleta desde a v1.5: https://docs.djangoproject.com/en/1.5/ref/settings/#auth-profile-module

Bem, já passou algum tempo desde 2008 e é hora de receber uma nova resposta. Desde o Django 1.5, você poderá criar uma classe de usuário personalizada. Na verdade, no momento em que escrevo isso, ele já está mesclado no master, para que você possa experimentar.

Há algumas informações sobre isso nos documentos ou, se você quiser aprofundar, neste commit .

Tudo o que você precisa fazer é adicionar AUTH_USER_MODELàs configurações o caminho para a classe de usuário personalizada, que se estende AbstractBaseUser(versão mais personalizável) ou AbstractUser(classe de usuário mais ou menos antiga que você pode estender).

Para as pessoas com preguiça de clicar, aqui está um exemplo de código (extraído de documentos ):

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

Desde o Django 1.5, você pode facilmente estender o modelo do usuário e manter uma única tabela no banco de dados.

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

Você também deve configurá-lo como classe de usuário atual no seu arquivo de configurações

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

Se você deseja adicionar muitas preferências dos usuários, a opção OneToOneField pode ser uma opção melhor.

Uma observação para as pessoas que desenvolvem bibliotecas de terceiros: se você precisar acessar a classe de usuário, lembre-se de que as pessoas podem alterá-la. Use o ajudante oficial para obter a classe certa

from django.contrib.auth import get_user_model

User = get_user_model()

Há uma recomendação oficial sobre o armazenamento de informações adicionais sobre os usuários . O Django Book também discute esse problema na seção Profiles .

O abaixo é outra abordagem para estender um usuário. Eu sinto que é mais claro, fácil, legível do que acima de duas abordagens.

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

Usando a abordagem acima:

1. você não precisa usar user.get_profile (). newattribute para acessar as informações adicionais relacionadas ao usuário
2. você pode acessar diretamente novos atributos adicionais diretamente por meio do usuário.newattribute

Você pode simplesmente estender o perfil do usuário criando uma nova entrada sempre que um usuário for criado usando os sinais de pós-gravação do 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)

Isso criará automaticamente uma instância de funcionário quando um novo usuário for criado.

Se você deseja estender o modelo do usuário e deseja adicionar mais informações ao criar um usuário, pode usar o django-betterforms ( http://django-betterforms.readthedocs.io/en/latest/multiform.html ). Isso criará um formulário de adição do usuário com todos os campos definidos no modelo 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'),
]

Estendendo o Django User Model (UserProfile) como um Pro

Achei isso muito útil: link

Um extrato:

de 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

Novo no Django 1.5, agora você pode criar seu próprio modelo de usuário personalizado (o que parece ser uma boa coisa a se fazer no caso acima). Consulte 'Personalizando a autenticação no Django'

Provavelmente, o novo recurso mais interessante da versão 1.5.

Isto é o que eu faço e, na minha opinião, é a maneira mais simples de fazer isso. defina um gerenciador de objetos para seu novo modelo customizado e defina seu modelo.

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ão se esqueça de adicionar esta linha de código no seu settings.py:

AUTH_USER_MODEL = 'YourApp.User'

É isso que eu faço e sempre funciona.

Atualmente, no Django 2.2, a maneira recomendada ao iniciar um novo projeto é criar um modelo de usuário personalizado que herda de AbstractUser e, em seguida, aponte AUTH_USER_MODEL para o modelo.

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

Uma abordagem simples e eficaz é models.py

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