Kullanıcı modelini (Django'nun kimlik doğrulama uygulamasıyla birlikte) özel alanlarla genişletmenin en iyi yolu nedir? Ayrıca, e-postayı kullanıcı adı olarak kullanmak istiyorum (kimlik doğrulama amacıyla).

Bunu yapmanın birkaç yolunu gördüm , ancak hangisinin en iyisi olduğuna karar veremiyorum.

Bunu yapmanın en az acı veren ve gerçekten de Django tarafından önerilen yolu bir OneToOneField(User)özelliktir.

Mevcut Kullanıcı modelini genişletme

...

İle ilgili bilgileri saklamak Useristiyorsanız, ek bilgi için alanları içeren bir modelle bire bir ilişki kullanabilirsiniz. Bu bire bir model, genellikle bir site kullanıcısıyla ilgili kimlik doğrulama ile ilgili olmayan bilgileri depolayabileceğinden, profil modeli olarak adlandırılır.

Bununla birlikte, uzatmak django.contrib.auth.models.Userve yerine koymak da işe yarıyor ...

Özel bir Kullanıcı modelini değiştirme

Bazı proje türlerinin Django'nun yerleşik Usermodelinin her zaman uygun olmadığı kimlik doğrulama gereksinimleri olabilir . Örneğin, bazı sitelerde kullanıcı adı yerine kimlik belirteciniz olarak bir e-posta adresi kullanmak daha mantıklıdır.

[Ed: Bunun oldukça sert olduğunu belirten iki uyarı ve bir bildirim geliyor .]

Ben kesinlikle Django kaynak ağacınızdaki gerçek Kullanıcı sınıfını değiştirmek ve / veya kopyalama ve auth modülünü değiştirmek uzak kalmak istiyorum.

Not: bu cevap kullanımdan kaldırıldı. Django 1.7 veya üstünü kullanıyorsanız diğer yanıtlara bakın.

Ben böyle yaparım.

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

Bu, bir kullanıcı her oluşturulduğunda kaydedildiğinde bir kullanıcı profili oluşturur. Sonra kullanabilirsiniz

  user.get_profile().whatever

İşte dokümanlardan biraz daha bilgi

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

Güncelleme: Lütfen AUTH_PROFILE_MODULEv1.5'ten beri kullanımdan kaldırıldığını unutmayın : https://docs.djangoproject.com/en/1.5/ref/settings/#auth-profile-module

2008'den beri biraz zaman geçti ve yeni bir cevap vermenin zamanı geldi. Django 1.5'ten beri özel Kullanıcı sınıfı oluşturabileceksiniz. Aslında, bunu yazdığım sırada, zaten usta ile birleştirildi, böylece deneyebilirsiniz.

Dokümanlarda ya da daha derinlemesine incelemek istiyorsanız, bu taahhütte bazı bilgiler var .

Tek yapmanız gereken AUTH_USER_MODEL, AbstractBaseUser(daha özelleştirilebilir sürüm) veya AbstractUser(genişletebileceğiniz daha fazla veya daha az eski Kullanıcı sınıfı ) özel kullanıcı sınıfına giden yolu içeren ayarlara eklemektir .

Tıklama tembel insanlar için, kod örneği ( dokümanlardan alınmıştır ):

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

Django 1.5'ten beri kullanıcı modelini kolayca genişletebilir ve veritabanında tek bir tablo tutabilirsiniz.

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

Ayrıca, ayarlar dosyanızda geçerli kullanıcı sınıfı olarak yapılandırmanız gerekir

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

Çok sayıda kullanıcı tercihi eklemek istiyorsanız OneToOneField seçeneği daha iyi bir seçim olabilir.

Üçüncü taraf kütüphaneleri geliştiren kişiler için bir not: Kullanıcı sınıfına erişmeniz gerekiyorsa, insanların kütüphaneyi değiştirebileceğini unutmayın. Doğru sınıfı almak için resmi yardımcıyı kullanın

from django.contrib.auth import get_user_model

User = get_user_model()

Kullanıcılar hakkında ek bilgi depolama konusunda resmi bir öneri vardır . Django Kitabı, bu sorunu Profiller bölümünde de tartışmaktadır .

Aşağıda bir Kullanıcı genişletmek için başka bir yaklaşımdır. İki yaklaşımın üzerinde olduğundan daha net, kolay, okunabilir olduğunu düşünüyorum.

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

Yukarıdaki yaklaşımı kullanarak:

1. kullanıcıyla ilgili ek bilgilere erişmek için user.get_profile (). newattribute kullanmanıza gerek yoktur
2. ek yeni özelliklere doğrudan user.newattribute üzerinden erişebilirsiniz.

Bir kullanıcı her oluşturulduğunda Django posta kaydetme sinyallerini kullanarak yeni bir giriş oluşturarak kullanıcı profilini kolayca genişletebilirsiniz.

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)

Bu, yeni bir kullanıcı oluşturulduğunda otomatik olarak bir çalışan örneği oluşturur.

Kullanıcı modelini genişletmek ve kullanıcı oluştururken daha fazla bilgi eklemek istiyorsanız django-betterforms ( http://django-betterforms.readthedocs.io/en/latest/multiform.html ) kullanabilirsiniz. Bu, UserProfile modelinde tanımlanan tüm alanları içeren bir kullanıcı ekleme formu oluşturur.

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

Django Kullanıcı Modelini (UserProfile) bir Uzman gibi genişletme

Bunu çok faydalı buldum: link

Bir özü:

django.contrib.auth.models ithalat Kullanıcıdan

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

Django 1.5'te yeni olan, şimdi kendi Özel Kullanıcı Modelinizi oluşturabilirsiniz (bu, yukarıdaki durumda yapılması iyi bir şey gibi görünüyor). 'Django'da kimlik doğrulamayı özelleştirme' konusuna bakın.

Muhtemelen 1.5 sürümündeki en havalı yeni özellik.

Yaptığım şey bu ve bence bunu yapmanın en basit yolu. yeni özelleştirilmiş modeliniz için bir nesne yöneticisi tanımlayın ve ardından modelinizi tanımlayın.

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

Bu kod satırını aşağıdakilere eklemeyi unutmayın settings.py:

AUTH_USER_MODEL = 'YourApp.User'

Yaptığım şey bu ve her zaman işe yarıyor.

Şu anda Django 2.2'den itibaren, yeni bir projeye başlarken önerilen yol, AbstractUser'dan devralınan özel bir kullanıcı modeli oluşturmak, daha sonra AUTH_USER_MODEL'i modele yönlendirmektir.

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

Basit ve etkili yaklaşım models.py

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