Jaki jest najlepszy sposób rozszerzenia modelu użytkownika (w pakiecie z aplikacją uwierzytelniającą Django) o pola niestandardowe? Chciałbym również użyć adresu e-mail jako nazwy użytkownika (do celów uwierzytelnienia).

Widziałem już kilka sposobów, aby to zrobić, ale nie mogę zdecydować, który z nich jest najlepszy.

Najmniej bolesnym i rzeczywiście polecanym przez Django sposobem na zrobienie tego jest OneToOneField(User)własność.

Rozszerzenie istniejącego modelu użytkownika

…

Jeśli chcesz przechowywać związane z tym informacje User, możesz użyć relacji jeden do jednego z modelem zawierającym pola, aby uzyskać dodatkowe informacje. Ten model jeden do jednego jest często nazywany modelem profilu, ponieważ może przechowywać informacje niezwiązane z uwierzytelnianiem na temat użytkownika witryny.

To powiedziawszy, rozszerzenie django.contrib.auth.models.Useri zastąpienie działa również ...

Zastępowanie niestandardowego modelu użytkownika

Niektóre rodzaje projektów mogą mieć wymagania uwierzytelniania, dla których wbudowany Usermodel Django nie zawsze jest odpowiedni. Na przykład w niektórych witrynach sensowniej jest używać adresu e-mail jako tokena identyfikacyjnego zamiast nazwy użytkownika.

[Ed: Dwa ostrzeżenia i powiadomienie , że jest to dość drastyczne .]

Na pewno trzymałbym się z daleka od zmiany faktycznej klasy User w twoim drzewie źródłowym Django i / lub kopiowania i modyfikowania modułu auth.

Uwaga: ta odpowiedź jest nieaktualna. zobacz inne odpowiedzi, jeśli używasz Django 1.7 lub nowszego.

Tak to robię.

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

Spowoduje to utworzenie profilu użytkownika za każdym razem, gdy użytkownik zostanie zapisany, jeśli został utworzony. Następnie możesz użyć

  user.get_profile().whatever

Oto więcej informacji z dokumentów

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

Aktualizacja: należy pamiętać, że AUTH_PROFILE_MODULEjest przestarzała od wersji 1.5: https://docs.djangoproject.com/en/1.5/ref/settings/#auth-profile-module

Minęło trochę czasu od 2008 roku i czas na świeżą odpowiedź. Od wersji Django 1.5 będziesz mógł tworzyć niestandardowe klasy użytkowników. Właściwie w chwili, gdy to piszę, jest on już scalony w master, więc możesz go wypróbować.

Jest trochę informacji na ten temat w dokumentach lub jeśli chcesz zagłębić się w to, w tym zatwierdzeniu .

Wszystko, co musisz zrobić, to dodać AUTH_USER_MODELustawienia ze ścieżką do niestandardowej klasy użytkownika, która rozszerza albo AbstractBaseUser(bardziej konfigurowalną wersję), albo AbstractUser(mniej lub bardziej starą klasę użytkownika, którą możesz rozszerzyć).

Dla osób, które leniwie klikają, oto przykładowy kod (zaczerpnięty z dokumentów ):

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

Od wersji Django 1.5 możesz łatwo rozszerzyć model użytkownika i zachować jedną tabelę w bazie danych.

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

Musisz również skonfigurować go jako bieżącą klasę użytkownika w pliku ustawień

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

Jeśli chcesz dodać wiele preferencji użytkowników, lepszym wyborem może być opcja OneToOneField.

Uwaga dla osób tworzących biblioteki stron trzecich: jeśli potrzebujesz dostępu do klasy użytkownika, pamiętaj, że ludzie mogą to zmienić. Skorzystaj z oficjalnego pomocnika, aby uzyskać odpowiednią klasę

from django.contrib.auth import get_user_model

User = get_user_model()

Istnieje oficjalne zalecenie dotyczące przechowywania dodatkowych informacji o użytkownikach . Książka Django omawia ten problem również w sekcji Profile .

Poniżej znajduje się inne podejście do rozszerzenia użytkownika. Wydaje mi się, że jest to bardziej jasne, łatwe, czytelne niż w przypadku dwóch podejść.

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

Stosując powyższe podejście:

1. nie musisz używać user.get_profile (). newattribute, aby uzyskać dostęp do dodatkowych informacji związanych z użytkownikiem
2. możesz bezpośrednio uzyskać dostęp do dodatkowych nowych atrybutów za pośrednictwem user.newattribute

Możesz po prostu rozszerzyć profil użytkownika, tworząc nowy wpis za każdym razem, gdy użytkownik jest tworzony przy użyciu sygnałów zapisu postu 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)

Spowoduje to automatyczne utworzenie instancji pracownika po utworzeniu nowego użytkownika.

Jeśli chcesz rozszerzyć model użytkownika i chcesz dodać dodatkowe informacje podczas tworzenia użytkownika, możesz użyć django-betterforms ( http://django-betterforms.readthedocs.io/en/latest/multiform.html ). Spowoduje to utworzenie formularza dodawania użytkownika ze wszystkimi polami zdefiniowanymi w modelu 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'),
]

Rozszerzanie modelu użytkownika Django (UserProfile) jak profesjonalista

Znalazłem to bardzo przydatne: link

Ekstrakt:

z importu django.contrib.auth.models Użytkownik

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

Nowość w Django 1.5, teraz możesz stworzyć swój własny model użytkownika (co wydaje się być dobrym rozwiązaniem w powyższym przypadku). Zobacz „Dostosowywanie uwierzytelniania w Django”

Prawdopodobnie najfajniejsza nowa funkcja w wersji 1.5.

To właśnie robię i moim zdaniem jest to najprostszy sposób, aby to zrobić. zdefiniuj menedżera obiektów dla nowego dostosowanego modelu, a następnie zdefiniuj model.

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

Nie zapomnij dodać tej linii kodu do settings.py:

AUTH_USER_MODEL = 'YourApp.User'

To właśnie robię i zawsze działa.

Obecnie, począwszy od Django 2.2, zalecanym sposobem na rozpoczęcie nowego projektu jest utworzenie niestandardowego modelu użytkownika, który dziedziczy po AbstractUser, a następnie wskazanie modelu AUTH_USER_MODEL.

Źródło: https://docs.djangoproject.com/en/2.2/topics/auth/customizing/#using-a-custom-user-model-when-starting-a-project

Proste i skuteczne podejście to models.py

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