A felhasználói hitelesítés kezelése a Python Django alkalmazásban

Ebben az oktatóanyagban megmutatom, hogyan kell elvégezni a felhasználói bejelentkezést, a kijelentkezést és a regisztrációt a Django-ban. Az összes kód, amelyet itt leírok, ebben a GitHub-tárban található. Ez az oktatóprogram a Python 2.7 és a Django 1.9 verziókat használja.

A projekt telepítése és felépítése

A kezdéshez futtassa a következő parancsokat a terminálról:

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

Dióhéjban ez a négy parancs létrehoz egy új src nevű Django projektet, belép a projektbe, létrehoz egy új alkalmazást, a mysite-t az src projekt belsejében, majd létrehoz egy SQLite adatbázist a db.sqlite3 nevű projekthez. Ne felejtse el feltüntetni a mysite alkalmazást az src / settings.py fájlban is.

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

Hozzon létre egy sablon nevű könyvtárat a mysite alkalmazáson belül. Ezután hozzon létre két másik könyvtárat a mysite / sablonok belsejében, a „register” és a „mysite” néven.

Utalni fogok a két könyvtárban tárolt sablonokra is, a registration / {template_name} és a mysite / {template_name} használatával.

A projekt felépítésének végül így kell kinéznie:

. |-- 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

Már lehet, hogy kitalálja, hogy a mysite sablonjai mire használhatók (például a mysite-ben definiált nézetek). Hamarosan eljutunk a regisztráció fontosságához.

Szükségünk lesz arra is, hogy a felhasználók teszteljék webhelyünket. Ezt megteheti egy superuser ( python manage.py createsuperuser) létrehozásával . De ne aggódjon - mindaz, amit ez az oktatóanyag leír, a normál felhasználók számára is alkalmazható, minden változtatás nélkül. Normál felhasználókat hozhat létre az oktatóanyag céljaira egy superuser létrehozásával, a fejlesztői kiszolgáló ( python manage.py runserver) futtatásával , a localhost: 8000 / admin navigálásával, a Users (Felhasználók) navigációval, majd egy új felhasználó létrehozásával.

Bejelentkezés kezelése

A dokumentáció szerint a Django nézeteket kínál a felhasználói hitelesítési módszerek kezeléséhez, például a bejelentkezéshez, a kijelentkezéshez és a jelszó helyreállításához. Ez megspórol bennünket abban a gondban, hogy át kell gondolnunk saját nézeteinket a dolgok kezeléséhez. Ezenkívül ezek a nézetek meglehetősen konfigurálhatóak, és szerepelnek a django.contrib.auth.views fájlban, amelyeket az alábbiak szerint importálunk:

from django.contrib.auth import views as auth_views

Azt akarjuk, hogy a bejelentkezési oldal megnyíljon, amikor a felhasználó belép a / login oldalra. A bejelentkezési nézet használatához csatolja a következőket az src / urls.py fájlba

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

A nézet alapértelmezés szerint egy sablont jelenít meg, amely a register / login.html fájlban található.

A register / login.html a következő egyszerű HTML-űrlapot tartalmazza:

   Login    {% csrf_token %} 

Username

Password

Login

Nem akarja használni a registration / login.html fájlt? Megadhatja, hogy milyen sablonokat használjon, ha egy Python szótárat ad meg harmadik paraméterként az urlpatternben, kulcsként a 'template_name' kulcsot, értékként pedig a sablon helyét. Ha a mysite / login_user.html fájlt szeretné használni sablonként:

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

Ezenkívül a nézet más argumentumait is felhasználhatja, nagyjából ugyanúgy. Az argumentumok teljes listáját a docs dokumentumban találja meg.

Amikor a felhasználó az elküldés gombra kattint, a bejelentkezési nézet kezeli a bejelentkezést számunkra. Miután a felhasználó bejelentkezett, meghatározhatjuk, hova kell átirányítani az oldalt, megadva a LOGIN_REDIRECT_URL fájlt az src / settings.py fájlban. Alapértelmezés szerint átirányítjuk a / login címre, ha a bejelentkezés sikertelen.

LOGIN_REDIRECT_URL = '/'

Most futtassa a fejlesztõszervert ( python manage.py runserver), és keresse meg a localhost: 8000 / login / címet. Adja meg a példahasználó felhasználói hitelesítő adatait. Ha a bejelentkezés sikeres volt, a rendszer átirányítja Önt. Ellenkező esetben a / login címre irányít át.

Még akkor is, ha a bejelentkezése sikeres volt, a rendszer átirányít a / helyre, és hibaüzenetet lát. Ez azért fog bekövetkezni, mert nem definiáltunk rá egy urlpattern.

A kijelentkezés kezelése

Ezután azt akarjuk, hogy a felhasználók kijelentkezzenek, amikor a / kijelentkezéshez navigálnak. Kiterjeszthetjük a bejelentkezéshez hasonló analógiát a kijelentkezéshez, és elérhetjük a kijelentkezéshez tartozó nézetet az alábbi URL-minta csatolásával az src / settings.py fájlba.

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

A kijelentkezési nézet alapértelmezés szerint megjeleníti a registration / logged_out.html sablont. Itt van egy egyszerű kijelentkezési sablon:

      You have successfully logged out. Home  

As with login, you can change the template location by including an object with a ‘template_name’ key and the template’s location as the value.

Signup

We want our users to register for our website by navigating to /register. Before doing that, let’s clean up the project a bit. First of all, we want a urlpattern for our home page /. We are going to use mysite app for this purpose, so append the following in src/urls.py

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

Now we need to include the urlpattern for / in mysite/urls.py, so include the following urlpattern in it (after importing the relevant libraries)

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

Here, home refers to the view for /, and register refers to the view for handling registration. For creating a user registration form, we will use Django’s in built forms. To do this, create a mysite/forms.py file and include the following:

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

First, we import the forms library, we create UserRegistrationForm, which inherits from forms.Form. We want our forms to have 3 fields: username, email, password and the variable assignments do just that. forms.CharField represents a field composed of characters. The arguments — required, max_length and label— specify whether a field is required, it’s maximum length, and the field’s label. The widget parameter in password says that password is an input of type “password.”

We want users to be able to view the form if they go to /register, as well as fill it in and submit it. These correspond to GET and POST requests on /register. Thus, we include the following in 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('/') 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})

The home view is defined to render the src/home.html template, which is as follows:

   Home   {% if user.is_authenticated %} 

hello

welcome {{ user.username }}

Logout

{% else %}

Login

Register

{% endif %}

We check whether the user is logged in, using user.is_authenticated, and display our welcome text along with the username (using user.username) along with a link for logging out. If not, we will display links for logging in and registering.

For the register view, we check whether the request method is POST or not. If it isn’t, then we specify the form to be UserRegistrationForm and render, it by passing it as a parameter to mysite/register.html template:

       {% csrf_token %} {{ form.as_p }} Submit   

The form that is passed as input to the register view is then rendered using form.as_p. When the user clicks the submit button, a POST request is sent. We take the form data using the form variable.

Next we check if the form data is valid (through is_valid()). If it is, we create a userObj dictionary which we get by applying cleaned_data to the form and extract username, email and password from it.

The if condition checks whether it’s the case that a user with the same username and email exists in our database. If it is so, we create a new user, login using the same user and redirect to /. Otherwise, we raise an error saying that such a user already exists.

Here’s some relevant documentation in case you get stuck, or want to learn more:

  • User Authentication
  • Forms

If you would like to give me feedback about this tutorial, contact me.

If you liked this post, please ♡ it and share it :)