장고 - 이메일로 로그인

장고 - 이메일로 로그인

나는 장고가 사용자 이름이 아닌 이메일로 사용자 인증을 하기를 원합니다.한 가지 방법은 이메일 값을 사용자 이름 값으로 제공하는 것일 수 있지만, 저는 그것을 원하지 않습니다., URL을 가지고 있습니다./profile/<username>/ 저는 을 가질 수 없습니다./profile/abcd@gmail.com/.

다른 이유는 모든 전자 메일이 고유하지만 사용자 이름이 이미 사용되고 있기 때문입니다. 사용자 을 따서사용자이름다같음생자성다니합동이과라로 자동 fullName_ID.

장고가 이메일로 인증하도록 어떻게 변경할 수 있습니까?

이렇게 사용자를 생성합니다.

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

이렇게 로그인합니다.

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)

먼저 사용자 이름을 얻는 것 외에 로그인 방법이 있습니까?

사용자 지정 인증 백엔드를 작성해야 합니다.다음과 같은 방법으로 작동합니다.

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

그런 다음 설정에서 해당 백엔드를 인증 백엔드로 설정합니다.

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

업데이트됨.상속 대상ModelBackend같은 방법을 시행하고 있기 때문에get_user()이미.

여기에서 문서 참조: https://docs.djangoproject.com/en/3.0/topics/auth/customizing/ #인증 확인 문서 작성

만약 당신이 새로운 프로젝트를 시작한다면, 장고는 당신에게 맞춤형 사용자 모델을 설정할 것을 강력히 추천합니다.(프로젝트를 시작할 때 https://docs.djangoproject.com/en/dev/topics/auth/customizing/ #사용자 정의 사용자 모델 사용 참조)

사용자 모델에 세 줄을 추가합니다.

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

그리고나서authenticate(email=email, password=password)있는 반면에authenticate(username=username, password=password)작동을 중지합니다.

Django 3.x에 대한 이메일 인증

기본 사용자 이름 및 암호 인증 대신 전자 메일/사용자 이름 및 암호를 인증에 사용하려면 ModelBackend 클래스의 두 가지 방법인 authenticate()와 get_user()를 재정의해야 합니다.

get_user 메서드는 user_id(사용자 이름, 데이터베이스 ID 등일 수 있지만 사용자 개체에 고유해야 함)를 사용하고 사용자 개체 또는 없음을 반환합니다.이메일을 고유 키로 보관하지 않은 경우 query_set에 대해 반환된 여러 결과를 처리해야 합니다.아래 코드에서는 반환된 목록에서 첫 번째 사용자를 반환하여 이 문제를 해결했습니다.

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

기본적으로 AUTHICATION_BACKENS는 다음과 같이 설정됩니다.

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

settings.py 파일의 맨 아래에 다음을 추가하여 기본값을 재정의합니다.

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

장고 4.0

전자 메일 인증을 구현할 수 있는 두 가지 주요 방법은 다음과 같습니다.

• 전자 메일은 잘못된 철자와 악의적인 사용을 완화하기 위해 사용자 모델에서 고유하지 않아야 합니다.
• 전자 메일은 확인된 경우에만 인증에 사용해야 합니다(예: 확인 전자 메일을 보내고 확인 링크를 클릭했습니다).
• 우리는 확인된 이메일 주소로만 이메일을 보내야 합니다.

사용자 지정 사용자 모델

프로젝트 중간 변경이 까다로울 수 있으므로 새 프로젝트를 시작할 때는 사용자 지정 사용자 모델을 사용하는 것이 좋습니다.

하겠습니다.email_verified확인된 전자 메일 주소를 가진 사용자에 대한 전자 메일 인증을 제한하는 필드입니다.

# app.models.py
from django.db import models
from django.contrib.auth.models import AbstractUser


class User(AbstractUser):
    email_verified = models.BooleanField(default=False)

그런 다음 지정된 전자 메일 주소를 사용자 이름으로 대체하는 사용자 지정 인증 백엔드를 만듭니다.

는 백드는다명시로설인정양함작증께다동니합식과이하는으엔적음을을 명시적으로 설정하는 과 함께 작동합니다.email및 정하는및필을 username밭.밭.

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

UserModel = get_user_model()


class CustomUserModelBackend(ModelBackend):
    def authenticate(self, request, username=None, password=None, **kwargs):
        if username is None:
            username = kwargs.get(UserModel.USERNAME_FIELD, kwargs.get(UserModel.EMAIL_FIELD))
        if username is None or password is None:
            return
        try:
            user = UserModel._default_manager.get(
                Q(username__exact=username) | (Q(email__iexact=username) & Q(email_verified=True))
            )
        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

를 수정합니다.settings.py사용자 지정 사용자 모델 및 인증 백엔드를 사용합니다.

# project.settings.py

AUTH_USER_MODEL = "app.User"
AUTHENTICATION_BACKENDS = ["app.backends.CustomUserModelBackend"]

해야합다니를 실행해야 .manage.py makemigrations 앞에서migrate첫 번째 마이그레이션에 이러한 설정이 포함되어 있는지 확인합니다.

확장 사용자 모델

User모델(2차 쿼리 포함), 기존을 확장하는 것이 더 나을 수 있습니다.User로그인 흐름 및 확인 프로세스에 따라 선호될 수 있습니다.

우리는 다음과 같은 일대일 관계를 만듭니다.EmailVerification 쪽이든User하고 있는 ▁the▁our입니다.AUTH_USER_MODEL설정

# app.models.py
from django.conf import settings
from django.db import models


class EmailVerification(models.Model):
    user = models.OneToOneField(
        settings.AUTH_USER_MODEL,
        on_delete=models.CASCADE,
        related_query_name="verification"
    )
    verified = models.BooleanField(default=False)

또한 인라인 확장을 포함하는 사용자 지정 관리자를 생성할 수 있습니다.

# app.admin.py
from django.contrib import admin
from django.contrib.auth import get_user_model
from django.contrib.auth.admin import UserAdmin as BaseUserAdmin

from .models import EmailVerification

UserModel = get_user_model()


class VerificationInline(admin.StackedInline):
    model = EmailVerification
    can_delete = False
    verbose_name_plural = 'verification'


class UserAdmin(BaseUserAdmin):
    inlines = (VerificationInline,)


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

음 델 백 를 유 드 엔 만 듭 니 한 사 백 의 위 는verified밭.밭.

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

UserModel = get_user_model()


class ExtendedUserModelBackend(ModelBackend):
    def authenticate(self, request, username=None, password=None, **kwargs):
        if username is None:
            username = kwargs.get(UserModel.USERNAME_FIELD, kwargs.get(UserModel.EMAIL_FIELD))
        if username is None or password is None:
            return
        try:
            user = UserModel._default_manager.get(
                Q(username__exact=username) | (Q(email__iexact=username) & Q(verification__verified=True))
            )
        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

를 수정합니다.settings.py인증 백엔드를 사용할 수 있습니다.

# project.settings.py

AUTHENTICATION_BACKENDS = ["app.backends.ExtendedUserModelBackend"]

그러면 됩니다.makemigrations그리고.migrate기존 프로젝트에 기능을 추가합니다.

메모들

• 하지 않는 변경인 경우 변경 내용은 다음과 같습니다.Q(username__exact=username)Q(username__iexact=username).
• 프로덕션에서 새 사용자가 확인된 기존 전자 메일 주소로 등록하지 못하도록 합니다.

사용자 이름 필드에 대해 사용자 이름/이메일 중 하나가 작동해야 하는 유사한 요구사항이 있었습니다.인증 백엔드 방법을 찾는 경우 다음 작업 코드를 확인하십시오.전자 메일만 원하는 경우 쿼리 집합을 변경할 수 있습니다.

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

AUTHICATION_BACKENS =( 'path.to 도 추가합니다.사용자 지정 백엔드', )가 설정되어 있습니다.파이의

장고 2에 대한 이메일 및 사용자 이름 인증.x

이것이 일반적인 질문이라는 것을 염두에 두고, 여기 장고 소스 코드를 모방하지만 대소문자를 구분하지 않고 사용자 이름이나 이메일로 사용자를 인증하는 사용자 정의 구현이 있습니다. 타이밍 공격 보호를 유지하고 비활성 사용자를 인증하지 않습니다.

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

항상 설정을 추가해야 합니다.올바른 인증 백엔드에 연결합니다.

이를 위한 방법은 장고 3.0으로 업데이트된 것 같습니다.

저의 작업 방법은 다음과 같습니다.

인증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

그리고 나서 이것을 settings.py 파일에 추가했습니다.

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

는 그것을: function 나는위도만들를: 기능니.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)

장고 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

settings.py 에서 다음 행을 추가합니다.

AUTHENTICATION_BACKENDS = ['appname.filename.EmailorUsernameModelBackend']

ModelBackend 클래스를 사용자 지정해야 합니다.내 간단한 코드:

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

settings.py 파일에 다음을 추가합니다.

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

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

에 그음에다.settings.py:

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

는 나의 앱, 기가내장앱인곳에서,backends.py앱 안에 이고 내 앱 안 파 이 일 파 있 고 썬 이 에,EmailAuthenticate의▁my▁inside▁theication에 있는 인증 클래스입니다.backends.py

2022년 5월 업데이트:

이 지침은 "username"과 "password"가 아닌 "email"과 "password"로 인증을 설정하는 방법을 보여주며, 이 지침에서는 "username"이 제거되어 기본 Django 설정을 최대한 변경하지 않으려고 했습니다.

먼저 아래 명령을 실행하여 "계정" 응용 프로그램을 만듭니다.

python manage.py startapp account

그런 다음 "account" 응용 프로그램을 "INSTALLED_APPS"로 설정하고 AUTH_USER_MODEL = 'account'를 설정합니다.아래와 같이 "settings.py "에서 CustomUser'를 사용합니다.

# "settings.py"

INSTALLED_APPS = [
    # ...
    "account", # Here
]

AUTH_USER_MODEL = 'account.CustomUser' # Here

그런 다음 "account" 폴더 바로 아래에 "managers.py "을 만들고 "managers.py "에서 "UserManager" 클래스를 확장하는 "CustomUserManager" 클래스를 만듭니다.*아래의 코드를 "managers.py "에 복사하여 붙여넣기만 하면 "managers.py " 명령어를 "message manage"로 만들 수 있습니다.py create superuser"는 오류 없이 올바르게 작동합니다.

# "account/managers.py"

from django.contrib.auth.models import UserManager
from django.contrib.auth.hashers import make_password

class CustomUserManager(UserManager): # Here
   
    def _create_user(self, email, password, **extra_fields):
        
        if not email:
            raise ValueError("The given email must be set")
        email = self.normalize_email(email)
        user = self.model(email=email, **extra_fields)
        user.password = make_password(password)
        user.save(using=self._db)
        return user

    def create_user(self, email=None, password=None, **extra_fields):
        extra_fields.setdefault("is_staff", False)
        extra_fields.setdefault("is_superuser", False)
        return self._create_user(email, password, **extra_fields)

    def create_superuser(self, email=None, password=None, **extra_fields):
        extra_fields.setdefault("is_staff", True)
        extra_fields.setdefault("is_superuser", True)

        if extra_fields.get("is_staff") is not True:
            raise ValueError("Superuser must have is_staff=True.")
        if extra_fields.get("is_superuser") is not True:
            raise ValueError("Superuser must have is_superuser=True.")

        return self._create_user(email, password, **extra_fields)

그런 다음 아래와 같이 "AbstractUser" 클래스를 확장하는 "CustomUser" 클래스를 만들고 "없음"으로 설정하고 "email"을 "unique=True"로 설정하고 "email"을 "USERNAME_FIELD"로 설정하고 "CustomUserManager" 클래스를 "account/models.py "로 설정합니다.*아래 코드를 복사하여 "account/models.py "에 붙여넣기만 하면 됩니다.

# "account/models.py"

from django.db import models
from django.contrib.auth.models import AbstractUser
from .managers import CustomUserManager

class CustomUser(AbstractUser):
    username = None # Here
    email = models.EmailField('email address', unique=True) # Here
    
    USERNAME_FIELD = 'email' # Here
    REQUIRED_FIELDS = []

    objects = CustomUserManager() # Here

    class Meta:
        verbose_name = "custom user"
        verbose_name_plural = "custom users"

또는 아래와 같이 "AbstractBaseUser" 및 "PermissionsMixin" 클래스를 확장하는 "CustomUser" 클래스를 만들 수도 있습니다.*아래 "AbstractBaseUser" 및 "PermissionsMixin" 클래스가 있는 코드는 "AbstractUser" 클래스가 있는 위의 코드와 동일하며, 보시다시피 "AbstractUser" 클래스가 있는 위의 코드는 코드가 훨씬 적습니다.

from django.db import models
from django.contrib.auth.models import AbstractBaseUser, PermissionsMixin
from django.utils import timezone
from .managers import CustomUserManager

class CustomUser(AbstractBaseUser, PermissionsMixin):
    first_name = models.CharField("first name", max_length=150, blank=True)
    last_name = models.CharField("last name", max_length=150, blank=True)
    email = models.EmailField('email address', unique=True)
    is_staff = models.BooleanField(
        "staff status",
        default=False,
        help_text="Designates whether the user can log into this admin site.",
    )
    is_active = models.BooleanField(
        "active",
        default=True,
        help_text=
            "Designates whether this user should be treated as active. "
            "Unselect this instead of deleting accounts."
        ,
    )
    date_joined = models.DateTimeField("date joined", default=timezone.now)

    USERNAME_FIELD = 'email'

    objects = CustomUserManager() # Here

그런 다음 "account" 폴더 바로 아래에 "forms.py "을 만들고 "UserCreationForm" 클래스를 확장하는 "CustomUserCreationForm" 클래스와 "CustomUserChangeForm" 클래스를 확장하는 "CustomUser" 클래스를 만들고 "CustomUserCreationForm" 클래스에서 "Meta" 내부 클래스를 "model"로 설정합니다.아래와 같이 "py".*아래 코드를 복사하여 "forms.py "에 붙여넣기만 하면 됩니다.

# "account/forms.py"

from django.contrib.auth.forms import UserCreationForm, UserChangeForm
from .models import CustomUser

class CustomUserCreationForm(UserCreationForm):

    class Meta:
        model = CustomUser
        fields = ('email',)

class CustomUserChangeForm(UserChangeForm):

    class Meta:
        model = CustomUser
        fields = ('email',)

그런 다음 "UserAdmin" 클래스를 확장하는 "CustomUserAdmin" 클래스를 만들고 "CustomUserCreationForm" 및 "CustomUserChangeForm" 클래스를 각각 "add_form"과 "form"으로 설정하고 "AdminPasswordChangeForm" 클래스를 "change_password_form"으로 설정한 후 "CustomUser" 및 "CustomUserAdmin" 클래스를 "register" 계정/에서 "register"로 설정합니다.아래와 같이 "py".*아래 코드를 복사하여 "account/admin.py "에 붙여넣기만 하면 됩니다.

from django.contrib import admin
from .forms import CustomUserCreationForm, CustomUserChangeForm
from django.contrib.auth.forms import AdminPasswordChangeForm
from django.contrib.auth.admin import UserAdmin
from .models import CustomUser

class CustomUserAdmin(UserAdmin):
    fieldsets = (
        (None, {"fields": ("password",)}),
        ("Personal info", {"fields": ("first_name", "last_name", "email")}),
        (
            "Permissions",
            {
                "fields": (
                    "is_active",
                    "is_staff",
                    "is_superuser",
                    "groups",
                    "user_permissions",
                ),
            },
        ),
        ("Important dates", {"fields": ("last_login", "date_joined")}),
    )
    add_fieldsets = (
        (
            None,
            {
                "classes": ("wide",),
                "fields": ("email", "password1", "password2"),
            },
        ),
    )
    add_form = CustomUserCreationForm # Here
    form = CustomUserChangeForm # Here
    change_password_form = AdminPasswordChangeForm # Here
    list_display = ("email", "first_name", "last_name", "is_staff")
    list_filter = ("is_staff", "is_superuser", "is_active", "groups")
    search_fields = ("first_name", "last_name", "email")
    ordering = ("email",)
    filter_horizontal = (
        "groups",
        "user_permissions",
    )

admin.site.register(CustomUser, CustomUserAdmin) # Here

그런 다음 아래 명령을 실행하여 마이그레이션 및 마이그레이션을 수행합니다.

python manage.py makemigrations && python manage.py migrate

그런 다음 아래 명령을 실행하여 슈퍼 사용자를 만듭니다.

python manage.py createsuperuser

그런 다음 아래 명령을 실행하여 서버를 실행합니다.

python manage.py runserver 0.0.0.0:8000

그런 다음 아래 URL을 엽니다.

http://localhost:8000/admin/login/

마지막으로 아래와 같이 "이메일"과 "암호"로 로그인할 수 있습니다.

이 페이지는 아래와 같이 "사용자 정의 사용자 추가" 페이지입니다.

장고 2의 경우

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

장고 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')

사용자 정의 데이터베이스를 만든 경우 전자 메일 ID와 암호를 확인하려는 경우 이 데이터베이스를 사용합니다.

1. 전자 메일 ID 및 암호 가져오기models.objects.value_list('db_columnname').filter(db_emailname=textbox email)

2.목록에 있는 파일을 가져왔습니다.object_query_list

3.목록을 문자열로 변환

예:

1. HTML을 사용합니다.Email_id그리고.Password값Views.py

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

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

2. 데이터베이스에서 전자 메일 ID 및 암호 가져오기

   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. 목록에서 전자 메일 ID 및 암호 값을 가져옵니다.Query값 집합

   Email_Value = Email[0]

   Password_Value=Password[0]

4. 목록을 문자열로 변환

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

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

마지막으로 로그인 조건

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

이 모든 것들은 단순한 문제로 인해 끔찍하게 복잡합니다.

해당 이메일에 사용자가 있는지 확인한 다음 장고의 인수에 대한 해당 사용자의 사용자 이름을 가져옵니다.authenticate()방법.

try:
    user = User.objects.get(email = request_dict['email'])
    user = authenticate(username = user.username, password = request_dict['password'])
except:
    return HttpResponse('User not found.', status = 400)

아주 간단합니다.추가 수업이 필요 없습니다.

전자 메일로 사용자를 만들고 업데이트할 때는 전자 메일로 사용자 이름 필드를 설정하기만 하면 됩니다.

이렇게 하면 사용자 이름 필드가 전자 메일의 동일한 값이 됩니다.

코드:

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

기본 사용자 모델이 추상 클래스를 상속/확장합니다.프레임워크는 일정량의 변경 또는 변경에 대해 관대해야 합니다.

더 간단한 해킹은 다음을 수행하는 것입니다.이것은 가상 환경에 있습니다.

1. django 설치 위치로 이동하여 Lib 폴더 찾기
2. django/message/auth/로 이동합니다.
3. models.py 파일을 찾아서 엽니다.AbstractUser 클래스 줄 315 찾기

이메일 속성의 LINE 336 유니크를 추가하고 true로 설정합니다.

email = models.EmailField(_('email address'), blank=True,unique=True)

USERNAME_FIELD = 'email'
REQUIRED_FIELDS = ['username']

5. 완료, 마이그레이션 및 마이그레이션

당신의 책임 하에 이 일을 하라.

언급URL : https://stackoverflow.com/questions/37332190/django-login-with-email