Chấp nhận địa chỉ email làm tên người dùng trong Django

Có cách nào tốt để thực hiện việc này trong django mà không cần sử dụng hệ thống xác thực của riêng tôi không? Tôi muốn tên người dùng là địa chỉ email của người dùng thay vì họ tạo tên người dùng.

Xin hãy cho tôi lời khuyên. Cảm ơn.

Đối với bất kỳ ai khác muốn làm điều này, tôi khuyên bạn nên xem qua django-email-as-username , đây là một giải pháp khá toàn diện, bao gồm vá lỗi quản trị và các createsuperuserlệnh quản lý, cùng với các bit và mảnh khác.

Chỉnh sửa : Kể từ Django 1.5 trở đi, bạn nên cân nhắc sử dụng mô hình người dùng tùy chỉnh thay vì django-email-as-username .

Đây là những gì chúng tôi làm. Nó không phải là một giải pháp "hoàn chỉnh", nhưng nó làm được nhiều điều bạn đang tìm kiếm.

from django import forms
from django.contrib import admin
from django.contrib.auth.admin import UserAdmin
from django.contrib.auth.models import User

class UserForm(forms.ModelForm):
    class Meta:
        model = User
        exclude = ('email',)
    username = forms.EmailField(max_length=64,
                                help_text="The person's email address.")
    def clean_email(self):
        email = self.cleaned_data['username']
        return email

class UserAdmin(UserAdmin):
    form = UserForm
    list_display = ('email', 'first_name', 'last_name', 'is_staff')
    list_filter = ('is_staff',)
    search_fields = ('email',)

admin.site.unregister(User)
admin.site.register(User, UserAdmin)

Đây là một cách để làm điều đó để cả tên người dùng và email đều được chấp nhận:

from django.contrib.auth.forms import AuthenticationForm
from django.contrib.auth.models import User
from django.core.exceptions import ObjectDoesNotExist
from django.forms import ValidationError

class EmailAuthenticationForm(AuthenticationForm):
    def clean_username(self):
        username = self.data['username']
        if '@' in username:
            try:
                username = User.objects.get(email=username).username
            except ObjectDoesNotExist:
                raise ValidationError(
                    self.error_messages['invalid_login'],
                    code='invalid_login',
                    params={'username':self.username_field.verbose_name},
                )
        return username

Không biết có cài đặt nào đó để đặt biểu mẫu Xác thực mặc định hay không nhưng bạn cũng có thể ghi đè url trong urls.py

url(r'^accounts/login/$', 'django.contrib.auth.views.login', { 'authentication_form': EmailAuthenticationForm }, name='login'),

Việc nâng ValidationError sẽ tránh được 500 lỗi khi gửi một email không hợp lệ. Việc sử dụng định nghĩa của cấp cao cho "invalid_login" khiến thông báo lỗi không rõ ràng (so với một thông báo lỗi cụ thể "không tìm thấy người dùng theo email đó") sẽ được yêu cầu để ngăn rò rỉ cho dù địa chỉ email có được đăng ký tài khoản trên dịch vụ của bạn hay không. Nếu thông tin đó không an toàn trong kiến ​​trúc của bạn, thì thông báo lỗi có nhiều thông tin hơn có thể hữu ích hơn.

Django hiện cung cấp một ví dụ đầy đủ về hệ thống xác thực mở rộng với quản trị viên và biểu mẫu: https://docs.djangoproject.com/en/stable/topics/auth/customizing/#a-full-example

Về cơ bản, bạn có thể sao chép / dán nó và điều chỉnh (tôi không cần date_of_birthtrong trường hợp của mình).

Nó thực sự có sẵn kể từ Django 1.5 và vẫn có sẵn cho đến nay (django 1.7).

Nếu bạn định mở rộng mô hình người dùng, bạn sẽ phải triển khai mô hình người dùng tùy chỉnh.

Đây là một ví dụ cho Django 1.8. Django 1.7 sẽ yêu cầu nhiều công việc hơn một chút, chủ yếu là thay đổi các biểu mẫu mặc định (chỉ cần xem UserChangeForm& UserCreationFormin django.contrib.auth.forms- đó là những gì bạn cần trong 1.7).

user_manager.py:

from django.contrib.auth.models import BaseUserManager
from django.utils import timezone

class SiteUserManager(BaseUserManager):
    def create_user(self, email, password=None, **extra_fields):
        today = timezone.now()

        if not email:
            raise ValueError('The given email address must be set')

        email = SiteUserManager.normalize_email(email)
        user  = self.model(email=email,
                          is_staff=False, is_active=True, **extra_fields)

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

    def create_superuser(self, email, password, **extra_fields):
        u = self.create_user(email, password, **extra_fields)
        u.is_staff = True
        u.is_active = True
        u.is_superuser = True
        u.save(using=self._db)
        return u

models.py:

from mainsite.user_manager import SiteUserManager

from django.contrib.auth.models import AbstractBaseUser
from django.contrib.auth.models import PermissionsMixin

class SiteUser(AbstractBaseUser, PermissionsMixin):
    email    = models.EmailField(unique=True, blank=False)

    is_active   = models.BooleanField(default=True)
    is_admin    = models.BooleanField(default=False)
    is_staff    = models.BooleanField(default=False)

    USERNAME_FIELD = 'email'

    objects = SiteUserManager()

    def get_full_name(self):
        return self.email

    def get_short_name(self):
        return self.email

form.py:

from django.contrib import admin
from django.contrib.auth.admin import UserAdmin
from django.contrib.auth.forms import UserChangeForm, UserCreationForm
from mainsite.models import SiteUser

class MyUserCreationForm(UserCreationForm):
    class Meta(UserCreationForm.Meta):
        model = SiteUser
        fields = ("email",)


class MyUserChangeForm(UserChangeForm):
    class Meta(UserChangeForm.Meta):
        model = SiteUser


class MyUserAdmin(UserAdmin):
    form = MyUserChangeForm
    add_form = MyUserCreationForm

    fieldsets = (
        (None,              {'fields': ('email', 'password',)}),
        ('Permissions',     {'fields': ('is_active', 'is_staff', 'is_superuser',)}),  
        ('Groups',          {'fields': ('groups', 'user_permissions',)}),
    )

    add_fieldsets = (
        (None, {
            'classes': ('wide',),
            'fields': ('email', 'password1', 'password2')}
        ),
    )

    list_display = ('email', )       
    list_filter = ('is_active', )    
    search_fields = ('email',)       
    ordering = ('email',)


admin.site.register(SiteUser, MyUserAdmin)

settings.py:

AUTH_USER_MODEL = 'mainsite.SiteUser'

Các lựa chọn thay thế khác trông quá phức tạp đối với tôi, vì vậy tôi đã viết một đoạn mã cho phép xác thực bằng tên người dùng, email hoặc cả hai và cũng có thể bật hoặc tắt phân biệt chữ hoa chữ thường. Tôi đã tải nó lên pip với tư cách là xác thực kép django .

from django.contrib.auth.backends import ModelBackend
from django.contrib.auth import get_user_model
from django.conf import settings

###################################
"""  DEFAULT SETTINGS + ALIAS   """
###################################


try:
    am = settings.AUTHENTICATION_METHOD
except:
    am = 'both'
try:
    cs = settings.AUTHENTICATION_CASE_SENSITIVE
except:
    cs = 'both'

#####################
"""   EXCEPTIONS  """
#####################


VALID_AM = ['username', 'email', 'both']
VALID_CS = ['username', 'email', 'both', 'none']

if (am not in VALID_AM):
    raise Exception("Invalid value for AUTHENTICATION_METHOD in project "
                    "settings. Use 'username','email', or 'both'.")

if (cs not in VALID_CS):
    raise Exception("Invalid value for AUTHENTICATION_CASE_SENSITIVE in project "
                    "settings. Use 'username','email', 'both' or 'none'.")

############################
"""  OVERRIDDEN METHODS  """
############################


class DualAuthentication(ModelBackend):
    """
    This is a ModelBacked that allows authentication
    with either a username or an email address.
    """

    def authenticate(self, username=None, password=None):
        UserModel = get_user_model()
        try:
            if ((am == 'email') or (am == 'both')):
                if ((cs == 'email') or cs == 'both'):
                    kwargs = {'email': username}
                else:
                    kwargs = {'email__iexact': username}

                user = UserModel.objects.get(**kwargs)
            else:
                raise
        except:
            if ((am == 'username') or (am == 'both')):
                if ((cs == 'username') or cs == 'both'):
                    kwargs = {'username': username}
                else:
                kwargs = {'username__iexact': username}

                user = UserModel.objects.get(**kwargs)
        finally:
            try:
                if user.check_password(password):
                    return user
            except:
                # Run the default password hasher once to reduce the timing
                # difference between an existing and a non-existing user.
                UserModel().set_password(password)
                return None

    def get_user(self, username):
        UserModel = get_user_model()
        try:
            return UserModel.objects.get(pk=username)
        except UserModel.DoesNotExist:
            return None

Phiên bản mới nhất của django-register cho phép một số tùy chỉnh tốt và có thể thực hiện công việc - tài liệu tại đây https://bitbucket.org/ubernostrum/django-registration/src/fad7080fe769/docs/backend-api.rst

     if user_form.is_valid():
        # Save the user's form data to a user object without committing.
        user = user_form.save(commit=False)
        user.set_password(user.password)
        #Set username of user as the email
        user.username = user.email
        #commit
        user.save()

hoạt động hoàn hảo ... cho django 1.11.4

bạn cũng có thể tìm thấy một cuộc thảo luận thú vị về chủ đề này tại liên kết dưới đây:

http://groups.google.com/group/django-users/browse_thread/thread/c943ede66e6807c/2fbf2afeade397eb#2fbf2afeade397eb

Cách dễ nhất là tra cứu tên người dùng dựa trên email trong giao diện đăng nhập. Bằng cách đó, bạn có thể để mọi thứ khác yên:

from django.contrib.auth import authenticate, login as auth_login

def _is_valid_email(email):
    from django.core.validators import validate_email
    from django.core.exceptions import ValidationError
    try:
        validate_email(email)
        return True
    except ValidationError:
        return False

def login(request):

    next = request.GET.get('next', '/')

    if request.method == 'POST':
        username = request.POST['username'].lower()  # case insensitivity
        password = request.POST['password']

    if _is_valid_email(username):
        try:
            username = User.objects.filter(email=username).values_list('username', flat=True)
        except User.DoesNotExist:
            username = None
    kwargs = {'username': username, 'password': password}
    user = authenticate(**kwargs)

        if user is not None:
            if user.is_active:
                auth_login(request, user)
                return redirect(next or '/')
            else:
                messages.info(request, "<stvrong>Error</strong> User account has not been activated..")
        else:
            messages.info(request, "<strong>Error</strong> Username or password was incorrect.")

    return render_to_response('accounts/login.html', {}, context_instance=RequestContext(request))

Trong mẫu của bạn, hãy đặt biến tiếp theo cho phù hợp, tức là

<form method="post" class="form-login" action="{% url 'login' %}?next={{ request.GET.next }}" accept-charset="UTF-8">

Và nhập tên người dùng / mật khẩu của bạn đúng tên, tức là tên người dùng, mật khẩu.

CẬP NHẬT :

Ngoài ra, lệnh if _is_valid_email (email): có thể được thay thế bằng if '@' trong tên người dùng. Bằng cách đó, bạn có thể bỏ hàm _is_valid_email. Điều này thực sự phụ thuộc vào cách bạn xác định tên người dùng của mình. Nó sẽ không hoạt động nếu bạn cho phép ký tự '@' trong tên người dùng của mình.

Tôi nghĩ cách nhanh nhất là tạo một biểu mẫu kế thừa từ UserCreateForm, sau đó ghi đè usernametrường với forms.EmailField. Sau đó, đối với mỗi người dùng đăng ký mới, họ cần đăng nhập bằng địa chỉ email của họ.

Ví dụ:

urls.py

...
urlpatterns += url(r'^signon/$', SignonView.as_view(), name="signon")

views.py

from django.contrib.auth.models import User
from django.contrib.auth.forms import UserCreationForm
from django import forms

class UserSignonForm(UserCreationForm):
    username = forms.EmailField()


class SignonView(CreateView):
    template_name = "registration/signon.html"
    model = User
    form_class = UserSignonForm

signon.html

...
<form action="#" method="post">
    ...
    <input type="email" name="username" />
    ...
</form>
...

Không chắc liệu mọi người có đang cố gắng thực hiện điều này hay không, nhưng tôi thấy một cách hay (và rõ ràng) là chỉ yêu cầu email và sau đó đặt tên người dùng làm email trong chế độ xem trước khi lưu.

UserForm của tôi chỉ yêu cầu email và mật khẩu:

class UserForm(forms.ModelForm):
    password = forms.CharField(widget=forms.PasswordInput())

    class Meta:
        model = User
        fields = ('email', 'password')

Sau đó, theo quan điểm của tôi, tôi thêm logic sau:

if user_form.is_valid():
            # Save the user's form data to a user object without committing.
            user = user_form.save(commit=False)

            user.set_password(user.password)
            #Set username of user as the email
            user.username = user.email
            #commit
            user.save()