Django - Đăng nhập bằng Email

Tôi muốn django xác thực người dùng qua email, không phải qua tên người dùng. Một cách có thể là cung cấp giá trị email dưới dạng giá trị tên người dùng, nhưng tôi không muốn điều đó. Lý do là, tôi có một url /profile/<username>/, do đó tôi không thể có một url /profile/abcd@gmail.com/.

Một lý do khác là tất cả các email là duy nhất, nhưng đôi khi vẫn xảy ra trường hợp tên người dùng đã được sử dụng. Do đó tôi đang tự động tạo tên người dùng là fullName_ID.

Làm cách nào tôi có thể thay đổi để Django xác thực bằng email?

Đây là cách tôi tạo một người dùng.

username = `abcd28`
user_email = `abcd@gmail.com`
user = User.objects.create_user(username, user_email, user_pass)

Đây là cách tôi đăng nhập.

email = request.POST['email']
password = request.POST['password']
username = User.objects.get(email=email.lower()).username
user = authenticate(username=username, password=password)
login(request, user)

Có cách đăng nhập nào khác ngoài việc lấy tên người dùng trước không?

Bạn nên viết một chương trình phụ trợ xác thực tùy chỉnh. Một cái gì đó như thế này sẽ hoạt động:

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

class EmailBackend(ModelBackend):
    def authenticate(self, request, username=None, password=None, **kwargs):
        UserModel = get_user_model()
        try:
            user = UserModel.objects.get(email=username)
        except UserModel.DoesNotExist:
            return None
        else:
            if user.check_password(password):
                return user
        return None

Sau đó, đặt chương trình phụ trợ đó làm chương trình phụ trợ xác thực trong cài đặt của bạn:

AUTHENTICATION_BACKENDS = ['path.to.auth.module.EmailBackend']

Đã cập nhật . Kế thừa từ ModelBackendkhi nó triển khai các phương thức như get_user()đã có.

Xem tài liệu tại đây: https://docs.djangoproject.com/en/3.0/topics/auth/customizing/#writing-an-authentication-backend

Nếu bạn đang bắt đầu một dự án mới, django thực sự khuyên bạn nên thiết lập một mô hình người dùng tùy chỉnh. (xem https://docs.djangoproject.com/en/dev/topics/auth/customizing/#using-a-custom-user-model-when-starting-a-project )

và nếu bạn đã làm điều đó, hãy thêm ba dòng vào mô hình người dùng của bạn:

class MyUser(AbstractUser):
    USERNAME_FIELD = 'email'
    email = models.EmailField(_('email address'), unique=True) # changes email to unique and blank to false
    REQUIRED_FIELDS = [] # removes email from REQUIRED_FIELDS

Sau đó authenticate(email=email, password=password)hoạt động, trong khi authenticate(username=username, password=password)ngừng hoạt động.

Xác thực email cho Django 3.x

Để sử dụng email / tên người dùng và mật khẩu để xác thực thay vì xác thực tên người dùng và mật khẩu mặc định, chúng ta cần ghi đè hai phương thức của lớp ModelBackend: authenticate () và get_user ():

Phương thức get_user lấy user_id - có thể là tên người dùng, ID cơ sở dữ liệu hoặc bất cứ thứ gì, nhưng phải là duy nhất cho đối tượng người dùng của bạn - và trả về đối tượng người dùng hoặc Không có. Nếu bạn không giữ email làm khóa duy nhất, bạn sẽ phải quan tâm đến nhiều kết quả trả về cho query_set. Trong đoạn mã dưới đây, điều này đã được giải quyết bằng cách trả về người dùng đầu tiên từ danh sách trả về.

from django.contrib.auth.backends import ModelBackend, UserModel
from django.db.models import Q

class EmailBackend(ModelBackend):
    def authenticate(self, request, username=None, password=None, **kwargs):
        try: #to allow authentication through phone number or any other field, modify the below statement
            user = UserModel.objects.get(Q(username__iexact=username) | Q(email__iexact=username))
        except UserModel.DoesNotExist:
            UserModel().set_password(password)
        except MultipleObjectsReturned:
            return User.objects.filter(email=username).order_by('id').first()
        else:
            if user.check_password(password) and self.user_can_authenticate(user):
                return user

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

        return user if self.user_can_authenticate(user) else None

Theo mặc định, AUTHENTICATION_BACKENDS được đặt thành:

['django.contrib.auth.backends.ModelBackend']

Trong tệp settings.py, thêm phần sau ở dưới cùng để ghi đè mặc định:

AUTHENTICATION_BACKENDS = ('appname.filename.EmailBackend',)

Tôi đã có một yêu cầu tương tự trong đó tên người dùng / email sẽ hoạt động cho trường tên người dùng.

from django.contrib.auth import get_user_model  # gets the user_model django  default or your own custom
from django.contrib.auth.backends import ModelBackend
from django.db.models import Q


# Class to permit the athentication using email or username
class CustomBackend(ModelBackend):  # requires to define two functions authenticate and get_user

    def authenticate(self, username=None, password=None, **kwargs):
        UserModel = get_user_model()

        try:
            # below line gives query set,you can change the queryset as per your requirement
            user = UserModel.objects.filter(
                Q(username__iexact=username) |
                Q(email__iexact=username)
            ).distinct()

        except UserModel.DoesNotExist:
            return None

        if user.exists():
            ''' get the user object from the underlying query set,
            there will only be one object since username and email
            should be unique fields in your models.'''
            user_obj = user.first()
            if user_obj.check_password(password):
                return user_obj
            return None
        else:
            return None

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

Đồng thời thêm AUTHENTICATION_BACKENDS = ('path.to.CustomBackend',) trong settings.py

Django 2.x

Như đã đề cập bởi Ganesh ở trên cho django 2.x, phương thức xác thực bây giờ yêu cầu một tham số yêu cầu.

# backends.py
from django.contrib.auth import backends, get_user_model
from django.db.models import Q
UserModel = get_user_model()


class ModelBackend(backends.ModelBackend):

    def authenticate(self, request, username=None, password=None, **kwargs):
        if username is None:
            username = kwargs.get(UserModel.USERNAME_FIELD)
        try:
            # user = UserModel._default_manager.get_by_natural_key(username)
            # You can customise what the given username is checked against, here I compare to both username and email fields of the User model
            user = UserModel.objects.get(Q(username__iexact=username) | Q(email__iexact=username))
        except UserModel.DoesNotExist:
            # Run the default password hasher once to reduce the timing
            # difference between an existing and a nonexistent user (#20760).
            UserModel().set_password(password)
        else:
            if user.check_password(password) and self.user_can_authenticate(user):
                return user
        return super().authenticate(request, username, password, **kwargs)

thêm phần phụ trợ của bạn vào cài đặt dự án của bạn

# settings.py
AUTHENTICATION_BACKENDS = ['path.to.ModelBackend']

Mô hình Người dùng tùy chỉnh của bạn sẽ cần tạo email duy nhất cho những người dùng đang hoạt động và đã được xác thực, bạn có thể thực hiện việc này đơn giản với những thứ như sau:

from django.contrib.auth.models import AbstractUser


class User(AbstractUser):
    objects = UserManager()
    email = models.EmailField(_('email address'), unique=True)

    class Meta:
        verbose_name = _('user')
        verbose_name_plural = _('users')
        db_table = 'auth_user'
        swappable = 'AUTH_USER_MODEL'

Nhưng để ngăn người khác chặn người khác sử dụng email của họ, thay vào đó, bạn nên thêm xác thực email cũng như quy trình đăng ký và đăng nhập của bạn có tính đến các email có thể không phải là duy nhất (và có thể ngăn người dùng mới sử dụng địa chỉ email hiện có và đã được xác thực).

Xác thực tên người dùng và email cho Django 2.X

Lưu ý rằng đây là một câu hỏi phổ biến, đây là một triển khai tùy chỉnh bắt chước mã nguồn Django nhưng xác thực người dùng bằng tên người dùng hoặc email, phân biệt chữ hoa chữ thường, giữ bảo vệ tấn công định thời và không xác thực người dùng không hoạt động .

from django.contrib.auth.backends import ModelBackend, UserModel
from django.db.models import Q

class CustomBackend(ModelBackend):
    def authenticate(self, request, username=None, password=None, **kwargs):
        try:
            user = UserModel.objects.get(Q(username__iexact=username) | Q(email__iexact=username))
        except UserModel.DoesNotExist:
            UserModel().set_password(password)
        else:
            if user.check_password(password) and self.user_can_authenticate(user):
                return user

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

        return user if self.user_can_authenticate(user) else None

Luôn nhớ thêm nó vào settings của bạn.py một Phần phụ trợ Xác thực chính xác .

Bạn nên tùy chỉnh lớp ModelBackend. Mã đơn giản của tôi:

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

class YourBackend(ModelBackend):

  def authenticate(self, username=None, password=None, **kwargs):
    UserModel = get_user_model()
    if username is None:
        username = kwargs.get(UserModel.USERNAME_FIELD)
    try:
        if '@' in username:
            UserModel.USERNAME_FIELD = 'email'
        else:
            UserModel.USERNAME_FIELD = 'username'

        user = UserModel._default_manager.get_by_natural_key(username)
    except UserModel.DoesNotExist:
        UserModel().set_password(password)
    else:
        if user.check_password(password) and self.user_can_authenticate(user):
            return user

Và trong tệp settings.py , hãy thêm:

AUTHENTICATION_BACKENDS = ['path.to.class.YourBackend']

Xác thực bằng email và tên người dùng cho Django 2.x

from django.contrib.auth import get_user_model
from django.contrib.auth.backends import ModelBackend
from django.db.models import Q

class EmailorUsernameModelBackend(ModelBackend):
    def authenticate(self, request, username=None, password=None, **kwargs):
        UserModel = get_user_model()
        try:
            user = UserModel.objects.get(Q(username__iexact=username) | Q(email__iexact=username))
        except UserModel.DoesNotExist:
            return None
        else:
            if user.check_password(password):
                return user
        return None

Trong settings.py, thêm dòng sau,

AUTHENTICATION_BACKENDS = ['appname.filename.EmailorUsernameModelBackend']

from django.contrib.auth.models import User

from django.db import Q

class EmailAuthenticate(object):

    def authenticate(self, username=None, password=None, **kwargs):
        try:
            user = User.objects.get(Q(email=username) | Q(username=username))
        except User.DoesNotExist:
            return None
        except MultipleObjectsReturned:
            return User.objects.filter(email=username).order_by('id').first()

        if user.check_password(password):
            return user
        return None

    def get_user(self,user_id):
        try:
            return User.objects.get(pk=user_id)
        except User.DoesNotExist:
            return None

Và sau đó trong settings.py:

AUTHENTICATION_BACKENDS = (
  'articles.backends.EmailAuthenticate',
)

trong đó các bài báo là ứng dụng django của tôi, backends.pylà tệp python bên trong ứng dụng của tôi và EmailAuthenticatelà lớp phụ trợ xác thực bên trong backends.pytệp của tôi

Khá đơn giản. Không cần thêm bất kỳ lớp học bổ sung nào.

Khi bạn tạo và cập nhật một người dùng bằng email, chỉ cần đặt trường tên người dùng với email.

Bằng cách đó khi bạn xác thực trường tên người dùng sẽ có cùng giá trị của email.

Mật mã:

# Create
User.objects.create_user(username=post_data['email'] etc...)

# Update
user.username = post_data['email']
user.save()

# When you authenticate
user = authenticate(username=post_data['email'], password=password)

Đối với Django 2

username = get_object_or_404(User, email=data["email"]).username
        user = authenticate(
            request, 
            username = username, 
            password = data["password"]
        )
        login(request, user)

Xác thực bằng email cho Django 2.x

def admin_login(request):
if request.method == "POST":
    email = request.POST.get('email', None)
    password = request.POST.get('password', None)
    try:
        get_user_name = CustomUser.objects.get(email=email)
        user_logged_in =authenticate(username=get_user_name,password=password)
        if user_logged_in is not None:
            login(request, user_logged_in)
            messages.success(request, f"WelcomeBack{user_logged_in.username}")
            return HttpResponseRedirect(reverse('backend'))
        else:
            messages.error(request, 'Invalid Credentials')
            return HttpResponseRedirect(reverse('admin_login'))
    except:
        messages.warning(request, 'Wrong Email')
        return HttpResponseRedirect(reverse('admin_login'))

else:
    if request.user.is_authenticated:
        return HttpResponseRedirect(reverse('backend'))
    return render(request, 'login_panel/login.html')

Nếu Bạn đã tạo Cơ sở dữ liệu tùy chỉnh, từ đó nếu bạn muốn xác thực id email và mật khẩu của mình.

1. Tìm nạp id Email và Mật khẩu bằng models.objects.value_list('db_columnname').filter(db_emailname=textbox email)

2. gán trong danh sách được tìm nạp object_query_list

3. chuyển đổi danh sách thành chuỗi

Ví dụ :

1. Lấy Html Email_idvà PasswordGiá trị trongViews.py

   u_email = request.POST.get('uemail')

   u_pass = request.POST.get('upass')

2. Tìm nạp id Email và mật khẩu từ cơ sở dữ liệu

   Email = B_Reg.objects.values_list('B_Email',flat=True).filter(B_Email=u_email)

   Password = B_Reg.objects.values_list('Password',flat=True).filter(B_Email=u_email)

3. Lấy giá trị id Email và mật khẩu trong danh sách từ bộ Querygiá trị

   Email_Value = Email[0]

   Password_Value=Password[0]

4. Chuyển đổi danh sách thành chuỗi

   string_email = ''.join(map(str, Email_Value))

   string_password = ''.join(map(str, Password_Value))

Cuối cùng là Điều kiện đăng nhập của bạn

if (string_email==u_email and string_password ==u_pass)

Tôi đã tạo một trình trợ giúp cho: chức năng authenticate_user(email, password).

from django.contrib.auth.models import User


def authenticate_user(email, password):
    try:
        user = User.objects.get(email=email)
    except User.DoesNotExist:
        return None
    else:
        if user.check_password(password):
            return user

    return None

class LoginView(View):
    template_name = 'myapp/login.html'

    def get(self, request):
        return render(request, self.template_name)

    def post(self, request):
        email = request.POST['email']
        password = request.POST['password']
        user = authenticate_user(email, password)
        context = {}

        if user is not None:
            if user.is_active:
                login(request, user)

                return redirect(self.request.GET.get('next', '/'))
            else:
                context['error_message'] = "user is not active"
        else:
            context['error_message'] = "email or password not correct"

        return render(request, self.template_name, context)

Có vẻ như phương pháp thực hiện điều này đã được cập nhật với Django 3.0.

Một phương pháp làm việc đối với tôi là:

xác thực.py # <- Tôi đã đặt nó trong một ứng dụng (không hoạt động trong thư mục dự án cùng với settings.py

from django.contrib.auth import get_user_model
from django.contrib.auth.backends import BaseBackend
from django.contrib.auth.hashers import check_password
from django.contrib.auth.models import User

class EmailBackend(BaseBackend):
    def authenticate(self, request, username=None, password=None, **kwargs):
        UserModel = get_user_model()
        try:
            user = UserModel.objects.get(email=username)
        except UserModel.DoesNotExist:
            return None
        else:
            if user.check_password(password):
                return user
        return None

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

Sau đó, thêm nó vào tệp settings.py

AUTHENTICATION_BACKENDS = (
    'appname.authentication.EmailBackend',
)