de Mohammed Subhan Khan

Cum să gestionați autentificarea utilizatorului în Python Django

Cum sa gestionati autentificarea utilizatorului in Python Django

În acest tutorial, vă voi arăta cum să faceți conectarea, deconectarea și înregistrarea utilizatorului în Django. Tot codul pe care îl descriu aici se află în acest GitHub repertoriu. Acest tutorial va folosi Python 2.7 și Django 1.9.

Instalarea și structura proiectului

Pentru a începe, rulați următoarele comenzi de la terminal:

django-admin startproject src
cd src
python manage.py startapp mysite
python manage.py migrate

Pe scurt, aceste patru comenzi creează un nou proiect Django numit src, intră în proiect, creează o nouă aplicație, site-ul meu, în interiorul proiectului src, apoi creează o bază de date SQLite pentru proiectul numit db.sqlite3. De asemenea, asigurați-vă că includeți aplicația MySite în src / settings.py.

INSTALLED_APPS = [
    'src',
    'django.contrib.admin',
    'django.contrib.auth',
    ...
]

Creați un director numit șabloane în aplicația MySite. Apoi creați alte două directoare în interiorul site-ului meu / șabloane numite „înregistrare” și „site-ul meu”.

De asemenea, mă voi referi la șabloanele stocate în aceste două directoare, folosind înregistrarea / {template_name} și mysite / {template_name}.

Structura proiectului dvs. ar trebui să arate în cele din urmă astfel:

.
|-- db.sqlite3
|-- manage.py
|-- mysite
|   |-- admin.py
|   |-- apps.py
|   |-- __init__.py
|   |-- migrations
|   |   `-- __init__.py
|   |-- models.py
|   |-- templates
|   |   |-- mysite
|   |   `-- registration
|   |-- tests.py
|   `-- views.py
`-- src
    |-- __init__.py
    |-- settings.py
    |-- urls.py
    `-- wsgi.py

S-ar putea să vă dați deja seama pentru ce pot fi utilizate șabloanele din site-ul meu (vizualizări definite în site-ul meu, de exemplu). Vom ajunge la importanța înregistrării în curând.

De asemenea, vom avea nevoie de utilizatori pentru a testa site-ul nostru. Puteți face acest lucru creând un superutilizator (python manage.py createsuperuser). Dar nu vă faceți griji – tot ceea ce descrie acest tutorial poate fi aplicat și utilizatorilor normali, fără modificări. Puteți crea utilizatori normali în scopul acestui tutorial creând un superutilizator, rulând serverul de dezvoltare (python manage.py runserver), navigând la localhost: 8000 / admin, navigând la Utilizatori, apoi creând un utilizator nou.

Gestionarea autentificării

Conform documentației, Django oferă vederi pentru gestionarea metodelor de autentificare a utilizatorului, cum ar fi autentificarea, deconectarea și recuperarea parolei. Acest lucru ne scutește de necazul de a trece prin definirea propriilor opinii pentru gestionarea acestor lucruri. Mai mult, aceste vizualizări sunt destul de configurabile și sunt incluse în django.contrib.auth.views, pe care le vom importa după cum urmează:

from django.contrib.auth import views as auth_views

Vrem ca pagina de autentificare să se deschidă atunci când utilizatorul merge la / autentificare. Pentru a utiliza Autentificare vizualizați adăugați următoarele în src / urls.py

url(r'^login/$', auth_views.login),

Vizualizarea implicit redă un șablon care se află în înregistrare / autentificare.html.

Înregistrarea / login.html include următorul formular HTML simplu:

<!DOCTYPE html>
<html>

<head>
    <title>Login</title>
</head>
    
<body>
    <form method="POST">
        {% csrf_token %}
        <p>
            <label>Username</label>
            <input type="text" name="username">
        </p>
        <p>
            <label>Password</label>
            <input type="password" name="password">
        </p>
        <button type="submit">Login</button>
    </form>
</body>
    
</html>

Nu doriți să utilizați înregistrarea / login.html? Puteți specifica ce șabloane să utilizați oferind un dicționar python ca al treilea parametru în urlpattern, cu „template_name” ca cheie și locația șablonului ca valoare. Dacă doriți să utilizați mysite / login_user.html ca șablon:

url(r'^login/$', auth_views.login, {'template_name': 'mysite/login_user.html'})

În plus, puteți utiliza și alte argumente ale vederii, cam în același mod. Pentru o listă completă de argumente, consultați documente.

Când utilizatorul face clic pe butonul de trimitere, vizualizarea de conectare gestionează datele de conectare pentru noi. După ce utilizatorul s-a conectat, putem defini unde trebuie redirecționată pagina specificând LOGIN_REDIRECT_URL în src / settings.py. În mod implicit, vom fi redirecționați către / autentificare dacă autentificarea eșuează.

LOGIN_REDIRECT_URL = "https://www.freecodecamp.org/"

Acum rulați serverul de dezvoltare (python manage.py runserver) și navigați la localhost: 8000 / login /. Introduceți acreditările de utilizator pentru superutilizatorul de exemplu. Veți fi redirecționat către / dacă autentificarea a avut succes. În caz contrar, veți fi redirecționat către / login.

Chiar dacă autentificarea dvs. a avut succes, veți fi redirecționat către / și veți vedea o eroare. Acest lucru se va întâmpla pentru că nu am definit un urlpattern pentru aceasta.

Gestionarea deconectării

În continuare, vrem ca utilizatorii să se deconecteze atunci când navighează la / să se deconecteze. Putem extinde aceeași analogie cu conectarea la deconectare, accesând vizualizarea corespunzătoare deconectare adăugând următorul urlpattern la src / settings.py

url(r'^logout/$', auth_views.logout)

Vizualizarea deconectare redă în mod implicit șablonul de înregistrare / logged_out.html. Iată un șablon de deconectare simplu:

<!DOCTYPE html>
<html>
    
<head>
    <title></title>
</head>
    
<body>
    You have successfully logged out.
    <a href="https://www.freecodecamp.org/">Home</a>
</body>
    
</html>

Ca și în cazul conectării, puteți modifica locația șablonului prin includerea unui obiect cu o cheie „template_name” și locația șablonului ca valoare.

Inscrie-te

Vrem ca utilizatorii noștri să se înregistreze pe site-ul nostru navigând la / să se înregistreze. Înainte de a face asta, să curățăm puțin proiectul. În primul rând, vrem un urlpattern pentru pagina noastră de start /. Vom folosi aplicația MySite în acest scop, așa că adăugați următoarele în src / urls.py

url(r'^', include('mysite.urls'))

Acum trebuie să includem urlpattern pentru / în mysite / urls.py, deci includeți următoarele urlpattern în el (după importul bibliotecilor relevante)

from django.conf.urls import url, include
from django.contrib import admin
from .views import home, register

urlpatterns = [
    url(r'^$', home),
    url(r'^register/', register),
]

Aici, home se referă la vizualizarea pentru / și register se referă la vizualizarea pentru gestionarea înregistrării. Pentru crearea unui formular de înregistrare a utilizatorului, vom folosi Django în formulare construite. Pentru aceasta, creați un fișier mysite / forms.py și includeți următoarele:

from django import forms

class UserRegistrationForm(forms.Form):
    username = forms.CharField(
        required = True,
        label="Username",
        max_length = 32
    )
    email = forms.CharField(
        required = True,
        label="Email",
        max_length = 32,
    )
    password = forms.CharField(
        required = True,
        label="Password",
        max_length = 32,
        widget = forms.PasswordInput()
    )

Mai întâi, importăm biblioteca de formulare, creăm UserRegistrationForm, care moștenește din forms.Form. Vrem ca formularele noastre să aibă 3 câmpuri: username, email, password iar atribuțiile variabile fac exact asta. forms.CharField reprezintă un câmp compus din caractere. Argumentele – required, max_length și label– specificați dacă este necesar un câmp, lungimea maximă și eticheta câmpului. Parametrul widget din password spune ca password este o intrare de tip „parolă”.

Dorim ca utilizatorii să poată vizualiza formularul dacă merg la / se înregistrează, precum și să îl completeze și să îl trimită. Acestea corespund solicitărilor GET și POST de pe / înregistrare. Astfel, includem următoarele în mysite / views.py:

from django.shortcuts import render
from django.contrib.auth.models import User
from django.contrib.auth import authenticate, login
from django.http import HttpResponseRedirect
from django import forms
from .forms import UserRegistrationForm

# Create your views here.

def home(request):
    return render(request, 'mysite/home.html')
    
def register(request):
    if request.method == 'POST':
        form = UserRegistrationForm(request.POST)
        if form.is_valid():
            userObj = form.cleaned_data
            username = userObj['username']
            email =  userObj['email']
            password =  userObj['password']
            if not (User.objects.filter(username=username).exists() or User.objects.filter(email=email).exists()):
                User.objects.create_user(username, email, password)
                user = authenticate(username = username, password = password)
                login(request, user)
                return HttpResponseRedirect("https://www.freecodecamp.org/")    
            else:
                raise forms.ValidationError('Looks like a username with that email or password already exists')
                
    else:
        form = UserRegistrationForm()
        
    return render(request, 'mysite/register.html', {'form' : form})

Vizualizarea de pornire este definită pentru a reda șablonul src / home.html, care este după cum urmează:

<!DOCTYPE html>
<html>
    
<head>
    <title>Home</title>
</head>
    
<body>
    {% if user.is_authenticated %}
    <p>hello</p>
    <p>welcome {{ user.username }}</p>
    <p><a href="https://www.freecodecamp.org/logout">Logout</a></p>
    {% else %}
    <p><a href="http://www.freecodecamp.org/login">Login</a></p>
    <p><a href="http://www.freecodecamp.org/register">Register</a></p>
    {% endif %}
</body>
    
</html>

Verificăm dacă utilizatorul este conectat, utilizând user.is_authenticated și afișăm textul nostru de bun venit împreună cu numele de utilizator (folosind user.username) împreună cu un link pentru deconectare. Dacă nu, vom afișa linkuri pentru conectare și înregistrare.

Pentru vizualizarea registru, verificăm dacă metoda de solicitare este sau nu POST. Dacă nu este, atunci specificăm forma care urmează să fie UserRegistrationForm și redați-l, trecându-l ca parametru la șablonul mysite / register.html:

<!DOCTYPE html>
<html>
    
<head>
    <title></title>
</head>
    
<body>
    <form method="POST">
        {% csrf_token %} {{ form.as_p }}
        <button type="submit">Submit</button>
    </form>
</body>
    
</html>

Formularul care este transmis ca intrare în vizualizarea registrului este apoi redat folosind form.as_p. Când utilizatorul face clic pe butonul de trimitere, este trimisă o cerere POST. Luăm datele formularului utilizând variabila formular.

Apoi verificăm dacă datele formularului sunt valide (prin is_valid()). Dacă este, creăm un userObj dicționar pe care îl obținem aplicând cleaned_data la formă și extract username, email și password din ea.

Condiția if verifică dacă este cazul în care există un utilizator cu același nume de utilizator și e-mail în baza noastră de date. Dacă este așa, creăm un utilizator nou, ne conectăm folosind același utilizator și redirecționăm către /. În caz contrar, ridicăm o eroare spunând că un astfel de utilizator există deja.

Iată câteva documente relevante în cazul în care vă blocați sau doriți să aflați mai multe:

Dacă doriți să-mi dați feedback despre acest tutorial, Contacteaza-ma.

Dacă ți-a plăcut această postare, te rog ♡ și distribuie-o 🙂