Django - ईमेल के साथ लॉगिन

Question 1

मैं django को उपयोगकर्ताओं को ईमेल के माध्यम से प्रमाणित करना चाहता हूं, उपयोगकर्ता नाम के माध्यम से नहीं। एक तरीका उपयोगकर्ता नाम मान के रूप में ईमेल मूल्य प्रदान कर सकता है, लेकिन मैं ऐसा नहीं चाहता। कारण, मैं एक url हूँ /profile/<username>/, इसलिए मेरे पास एक url नहीं हो सकता है /profile/abcd@gmail.com/।

एक और कारण यह है कि सभी ईमेल अद्वितीय हैं, लेकिन ऐसा कभी-कभी होता है कि उपयोगकर्ता नाम पहले से ही लिया जा रहा है। इसलिए मैं उपयोक्तानाम बनानेवाला हूं fullName_ID।

मैं सिर्फ Django को ईमेल से प्रमाणित कैसे कर सकता हूं?

यह है कि मैं एक उपयोगकर्ता कैसे बनाऊं।

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)

क्या पहले उपयोगकर्ता नाम प्राप्त करने के अलावा कोई अन्य लॉगिन है?

Question 2

आपको एक कस्टम प्रमाणीकरण बैकएंड लिखना चाहिए। कुछ इस तरह काम करेगा:

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/#writing-an-authentication-backend

Question 3

यदि आप एक नई परियोजना शुरू कर रहे हैं, तो django ने आपको एक कस्टम उपयोगकर्ता मॉडल सेट करने के लिए अत्यधिक अनुशंसा की है। (देखें https://docs.djangoproject.com/en/dev/topics/auth/customizing/#use-a-custom-user-model-when-starting-a-project )

और यदि आपने ऐसा किया है, तो अपने उपयोगकर्ता मॉडल में तीन लाइनें जोड़ें:

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)काम करना बंद कर देता है।

Question 4

Django 3.x के लिए ईमेल प्रमाणीकरण

डिफ़ॉल्ट उपयोगकर्ता नाम और पासवर्ड प्रमाणीकरण के बजाय प्रमाणीकरण के लिए ईमेल / उपयोगकर्ता नाम और पासवर्ड का उपयोग करने के लिए, हमें ModelBackend वर्ग के दो तरीकों को ओवरराइड करने की आवश्यकता है: प्रमाणीकृत () और get_user ():

Get_user विधि एक user_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

डिफ़ॉल्ट रूप से, AUTHENTICATION_BACKENDS इसके लिए सेट है:

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

सेटिंग्स थिंकपैड फ़ाइल में, डिफ़ॉल्ट को ओवरराइड करने के लिए नीचे में निम्नलिखित जोड़ें:

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

Question 5

मेरी भी ऐसी ही आवश्यकता थी जहाँ उपयोगकर्ता नाम / ईमेल को उपयोगकर्ता नाम फ़ील्ड के लिए काम करना चाहिए। यदि कोई व्यक्ति ऐसा करने के प्रमाणीकरण बैकएंड के लिए देख रहा है, तो निम्नलिखित कार्य कोड देखें। यदि आप केवल ईमेल की इच्छा रखते हैं तो आप क्वेरी को बदल सकते हैं।

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

इसके अलावा सेटिंग्स में AUTHENTICATION_BACKENDS = ('path.to.CustomBackend') जोड़ें

Question 6

Django 2.x

जैसा कि django 2.x के लिए ऊपर गणेश द्वारा उल्लेख किया गया है, अब प्रामाणिक विधि के लिए अनुरोध परम की आवश्यकता है।

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

अपनी बैकेंड को अपनी प्रोजेक्ट सेटिंग में जोड़ें

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

आपके कस्टम उपयोगकर्ता मॉडल को सक्रिय और मान्य उपयोगकर्ताओं के लिए ईमेल को विशिष्ट बनाने की आवश्यकता होगी जिसे आप बस कुछ इस तरह से कर सकते हैं:

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'

लेकिन किसी और को उनके ईमेल का उपयोग करने से रोकने के लिए, आपको इसके बजाय ईमेल सत्यापन को जोड़ना चाहिए और आपकी पंजीकरण और लॉगिन प्रक्रिया को ध्यान में रखना चाहिए कि ईमेल अद्वितीय नहीं हो सकते हैं (और शायद नए उपयोगकर्ताओं को मौजूदा और मान्य ईमेल पते का उपयोग करने से रोकें)।

Question 7

Django 2.X के लिए ईमेल और उपयोगकर्ता नाम प्रमाणीकरण

यह ध्यान में रखते हुए कि यह एक सामान्य प्रश्न है, यहाँ एक कस्टम कार्यान्वयन Django स्रोत कोड की नकल करता है, लेकिन उपयोगकर्ता को उपयोगकर्ता नाम या ईमेल, केस-असंवेदनशील रूप से प्रमाणित करता है , समय - समय पर हमले की सुरक्षा और निष्क्रिय उपयोगकर्ताओं को प्रमाणित नहीं करता है ।

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

हमेशा अपनी सेटिंग्स को जोड़ने के लिए याद रखें कि सही प्रमाणीकरण बैकेंड है ।

Question 8

आपको 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

और सेटिंग्स फ़ाइल में, जोड़ें:

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

Question 9

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

Settings.py में, निम्नलिखित पंक्ति जोड़ें,

AUTHENTICATION_BACKENDS = ['appname.filename.EmailorUsernameModelBackend']

Question 10

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

जहां लेख मेरे Django-अनुप्रयोग है, backends.pyमेरे ऐप के अंदर अजगर फ़ाइल है और EmailAuthenticateमेरी अंदर प्रमाणीकरण बैकएंड वर्ग है backends.pyफ़ाइल

Question 11

बहुत साधारण। इसके लिए किसी अतिरिक्त कक्षा की आवश्यकता नहीं है।

जब आप किसी उपयोगकर्ता को ईमेल से बनाते और अपडेट करते हैं, तो बस ईमेल के साथ उपयोगकर्ता नाम फ़ील्ड सेट करें।

इस तरह जब आप उपयोगकर्ता नाम को प्रमाणित करते हैं तो ईमेल का समान मूल्य होगा।

कोड:

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

Question 12

Django 2 के लिए

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

Question 13

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

Question 14

यदि आपने कस्टम डेटाबेस बनाया है, वहाँ से यदि आप अपनी ईमेल आईडी और पासवर्ड को मान्य करना चाहते हैं।

ईमेल आईडी और पासवर्ड प्राप्त करें models.objects.value_list('db_columnname').filter(db_emailname=textbox email)

2. सूची में रखा गया है object_query_list

3. सूची सूची स्ट्रिंग करने के लिए

Ex:

Html Email_idऔर Passwordमान लेंViews.py

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

u_pass = request.POST.get('upass')
डेटाबेस से ईमेल आईडी और पासवर्ड प्राप्त करें

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)
Queryमूल्य सेट से सूची में ईमेल आईडी और पासवर्ड मान लें

Email_Value = Email[0]

Password_Value=Password[0]
सूची को स्ट्रिंग में बदलें

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

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

अंत में आपकी लॉगिन स्थिति

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

Question 15

मैंने उस के लिए एक सहायक बनाया है: फ़ंक्शन 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)

Question 16

ऐसा लगता है कि ऐसा करने का तरीका Django 3.0 के साथ अपडेट किया गया है।

मेरे लिए एक काम करने का तरीका है:

प्रमाणीकरण # # - मैंने इसे एक एप्लिकेशन में रखा (सेटिंग्स के साथ प्रोजेक्ट फ़ोल्डर में काम नहीं किया

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

फिर इसे सेटिंग्स फ़ाइल में जोड़ दिया

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

Question 17

डिफ़ॉल्ट उपयोगकर्ता मॉडल एक सार वर्ग का उत्तराधिकार / विस्तार करता है। ढांचे में परिवर्तन या परिवर्तन की एक निश्चित मात्रा के लिए उत्तरदायी होना चाहिए।

एक सरल हैक निम्नलिखित करना है: यह एक आभासी वातावरण में है

अपने django स्थापना स्थान पर जाएं और Lib फ़ोल्डर ढूंढें
django / contrib / परिस्थिति / पर नेविगेट करें
मॉडल की खोज करें और खोलें। AbstractUser क्लास लाइन 315 खोजें

ईमेल विशेषता पर लाइन 336 अद्वितीय जोड़ें और इसे सही पर सेट करें

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

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

हो गया, makemigrations और पलायन

आप अपने जोखिम पर ऐसा करें,