Système d'authentification des utilisateurs Django (2) Authentification dans les requêtes Web

Fournissez un attribut request.user dans chaque requête Web pour représenter l'utilisateur actuel. Si l'utilisateur actuel n'est pas connecté, cet attribut est une instance d'AnonymousUser, sinon, il s'agit d'une instance d'utilisateur.

Vous pouvez le distinguer par is_authenticated(), par exemple :

if request.user.is_authenticated():
# Faire quelque chose pour les utilisateurs authentifiés.
else :
# Faire quelque chose pour les utilisateurs anonymes.

Connexion login

login()

La fonction de connexion nécessite un objet HttPRequest et un objet User comme paramètres. login() utilise le framework de session de Django pour stocker l'identifiant de l'utilisateur dans la session.

Utilisez Authenticate() et login() en même temps :

depuis django.contrib.auth import Authenticate, login

def my_view(request):
username = request .POST['username']
passWord = request.POST['password']
user = Authenticate(username=username, password=password)
si l'utilisateur n'est pas Aucun :
if user. is_active:
          login(request, user)
              # Redirection vers une page de réussite. # Renvoie un message d'erreur « connexion invalide ».


Déconnexion, déconnexion

logout()

Utilise l'objet HttpRequest comme paramètre et n'a aucune valeur de retour. Par exemple :

from django.contrib.auth import logout

def logout_view(request):

logout(request)

# Redirection vers une page de réussite.


Restreindre l'accès

La méthode brute

Utiliser request.user.is_authenticated()

Redirection :

depuis la redirection d'importation de django.shortcuts

def my_view(request):

if not request.user.is_authenticated():

return redirect('/login/?next=%s' % request.path)
# ...


ou :

from django.shortcuts import render

def my_view(request):

if not request.user.is_authenticated() :

return render(request, 'myapp/login_error.html')
# ...


Utilisez le décorateur login_required

login_required([redirect_field_name=REDIRECT_FIELD_NAME, login_url=None]

de django.contrib.auth.decorators import login_required

@login_required

def my_view(request):

...


Si l'utilisateur n'est pas connecté, redirigez vers settings.LOGIN_URL et ajoutez le chemin relatif de l'URL actuelle pour former une paire de caractères de requête ensuite comme clé et ajoutez-le à settings.LOGIN_URL :

/accounts /login/ ?next=/polls/3/.

La clé de la paire de caractères de requête est par défaut suivante, vous pouvez également la nommer vous-même :

de django.contrib.auth .decorators import login_required

@login_required(redirect_field_name='my_redirect_field')

def my_view(request):

...


Vous pouvez également définir vous-même login_url :

de django.contrib.auth.decorators import login_required

@login_required(login_url='/accounts/login/')

def my_view(request):

...


Définitions requises dans urls.py :

(r'^accounts/login/$', 'django.contrib.auth.views.login'),

Test de connexion de l'utilisateur

Par exemple, pour détecter l'e-mail de l'utilisateur :

def my_view(request):

sinon '@example.com' dans request.user .email :

return HttpResponse ("Vous ne pouvez pas voter dans ce sondage.")

# ...

Vous pouvez utiliser des décorateurs :

de django .contrib.auth.decorators import user_passes_test

def email_check(user):

renvoie '@example.com' dans user.email

@user_passes_test(email_check)
def my_view (demande) :
...


Vues d'authentification

Bien sûr, nous pouvons définir nous-mêmes certaines fonctions d'affichage pour la connexion, la déconnexion et la gestion des mots de passe, et c'est le cas. plus pratique.

Mais vous pouvez également en apprendre davantage sur les vues intégrées de Django.

Django ne fournit pas de modèle par défaut pour les vues d'authentification, mais le contexte du modèle est documenté pour chaque vue ci-dessous.

Toutes les vues intégrées renvoient une instance TemplateResponse, vous permettant de personnaliser facilement le données de réponse.

https://github.com/django/django/blob/master/django/contrib/auth/views.py

La plupart des vues d'authentification intégrées fournissent un nom d'URL pour utiliser.

login(request[, template_name, redirect_field_name, ignition_form,current_app,extra_context])

Code source :

def login(request, template_name='registration/login.html',
         redirect_field_name=REDIRECT_FIELD_NAME,
         authentication_form=AuthenticationForm,
         current_app=None, extra_context=None):
   """
   Affiche le formulaire de connexion et gère l'action de connexion.
   """
   redirect_to = request.POST.get(redirect_field_name,
                                  request.GET.get(redirect_field_name, ''))

   if request.method == "POST":
       form = ignition_form(request, data=request.POST)
       if form.is_valid():

           # Assurez-vous que l'utilisateur est d'origine L'URL de redirection est sécurisée.
           sinon is_safe_url(url=redirect_to, host=request.get_host()):
               redirect_to = solve_url(settings.LOGIN_REDIRECT_URL)

           # , contrôle de sécurité terminé. Connectez l'utilisateur.
           auth_login(request, form.get_user())

           return HttpResponseRedirect(redirect_to)
   else:
       form = Authentication_form(request)

   site_actuel = get_current_site(request)

   context = {
       'form': form,
       redirect_field_name: redirect_to,
       'site': current_site,
       'site_name': current_site.name,
   }
   si extra_context n'est pas None :
       context.update(extra_context)
   return TemplateResponse(request, template_name, context,
                           current_app=current_ application)

Nom de l'URL : login

参数：

template_name : 默认的登陆模板.默认为registration/login.html.
redirect_field_name : 重定向的name，默认为next.
Authentification_form : c'est un formulaire. La valeur par défaut est AuthenticationForm.
current_app : un indice indiquant quelle application contient la vue actuelle. Pour plus d'informations, consultez la stratégie de résolution d'URL avec espace de noms. >如果通过GET访问， 将显示登录表单，可以将其内容POST到相同的URL上。
如果通过POST访问，它首先会尝试登录，如果成功，view就重定向到suivant指定的的链接。 Dans la section suivante, vous trouverez settings.LOGIN_REDIRECT_URL（一般缺省值为accounts/profile/）.表单。

需要用户自己来提供login的html模板，缺省是registration/login.html 。Formulaire : 一个表单对象AuthenticationForm.

suivant : Chaîne de requête中。

site : 当前网站，根据 SITE_ID 设置。如果你并没有安装site框架，这个变量将设定为一个 RequestSite实例，它从
site_name : est le site. name的一个别名。如果你没有安装site框架，它将会被设为 request.META['SERVER_NAME']的值。

如果你不想调用registration/login.html Il s'agit d'une URLconf中设定特定的view参数来传递template_name参数。

(r'^accounts/login/$', 'django.contrib.auth.views.login', {'template_name': 'myapp/login .html'}),


你也可以自己指定重定向链接字段名，通过redirect_field_name 参数。默认的字段名为next.

下面是registration/login.html模板的原始状态，它假定你有一个base.html模板（其中有bloc de contenu的定义。

{% extends "base.html" %}

{% block content %}

{% if form.errors %}

Votre nom d'utilisateur et votre mot de passe ne correspond pas. Veuillez réessayer.

{% endif %}

{% csrf_token %}

{{ form.username.label_tag }}	{{ form.username }}
{{ form.password.label_tag } }	{{ form.password }}

{% endblock %}

Si vous personnalisez le système d'authentification, vous pouvez transmettre le formulaire d'authentification personnalisé à la vue de connexion via le paramètre authentification_form. La méthode __init__ du formulaire doit avoir un paramètre de requête et fournir une méthode get_user pour renvoyer l'objet User authentifié.

logout(request[, next_page, template_name, redirect_field_name, current_app,extra_context])

Déconnexion de l'utilisateur.

Nom de l'URL : logout

Paramètres facultatifs :

next_page : Lien de redirection après la déconnexion.

logout_then_login(request[, login_url, current_app, extra_context])

Déconnectez l'utilisateur, puis redirigez-le vers le lien de connexion.

Paramètres facultatifs :

login_url : lien de redirection vers la page de connexion, la valeur par défaut est settings.LOGIN_URL.

password_change(request[, template_name, post_change_redirect,password_change_form,current_app, extra_context])

Permet aux utilisateurs de modifier leurs mots de passe.

Nom de l'URL : password_change

Oui Arguments facultatifs :

template_name : nom du modèle, la valeur par défaut est Registration/password_change_form.html.
post_change_redirect : Lien de redirection.
password_change_form : formulaire de changement de mot de passe personnalisé, comprenant un paramètre utilisateur. La valeur par défaut est PasswordChangeForm.

password_change_done(request[, template_name,current_app, extra_context])

La page après que l'utilisateur a modifié le mot de passe.

Nom de l'URL : password_change_done

Arguments facultatifs :

template_name : nom du modèle, la valeur par défaut est Registration/password_change_done.html.

password_reset(request[, is_admin_site, template_name, email_template_name, password_reset_form, token_generator, post_reset_redirect, from_email, current_app, extra_context, html_email_template_name])

Envoyer un e-mail à l'utilisateur, contenant un lien à usage unique pour permettre à l'utilisateur de réinitialiser son mot de passe.

Si l'adresse email fournie n'existe pas, elle ne sera pas envoyée.

Nom de l'URL : password_reset

Arguments facultatifs Arguments facultatifs :

template_name : Nom du modèle, la valeur par défaut est Registration/password_reset_form.html.
email_template_name : Le nom du modèle utilisé pour générer des e-mails avec des liens de recharge. La valeur par défaut est Registration/password_reset_email.html.
subject_template_name : Le nom du modèle utilisé pour générer les sujets des e-mails. La valeur par défaut est Registration/password_reset_subject.txt.
password_reset_form : formulaire de réinitialisation de mot de passe, la valeur par défaut est PasswordResetForm.

token_generator : vérifiez l'instance de classe du lien à usage unique, la valeur par défaut est default_token_generator, sa classe est django.contrib.auth.tokens. PasswordResetTokenGenerator.

post_reset_redirect : lien de redirection après la réinitialisation du mot de passe.

from_email : adresse e-mail, la valeur par défaut est DEFAULT_FROM_EMAIL.

current_app : un indice indiquant quelle application contient la vue actuelle. Consultez la stratégie de résolution d'URL avec espace de noms pour plus d'informations.
extra_context : un dictionnaire de données contextuelles qui seront ajoutées aux données contextuelles par défaut transmises au modèle.
html_email_template_name : le nom complet d'un modèle auquel à utiliser pour générer un e-mail texte/html en plusieurs parties avec le lien de réinitialisation du mot de passe. Par défaut, l'e-mail HTML n'est pas envoyé.

Exemple : inscription/password_reset_email.html (modèle de contenu d'e-mail) :

Quelqu'un. demandé la réinitialisation du mot de passe pour l'e-mail {{ email }} Suivez le lien ci-dessous :
{{ protocol}}://{{ domain }}{% url 'password_reset_confirm' uidb64=uid token=token %}

password_reset_done(request[, template_name])

Affichez la page une fois que l'utilisateur a choisi d'envoyer un e-mail de réinitialisation de mot de passe. Si le lien post_reset_redirect n'est pas explicitement spécifié dans la vue password_reset(), cette vue sera appelée directement.

password_reset_confirm(request[, uidb36, token, template_name, token_generator,set_password_form, post_reset_redirect,current_app, extra_context])

Affichez le formulaire de saisie du nouveau mot de passe.

password_reset_complete (request [, template_name, current_app, extra_context])

Le formulaire après une réinitialisation réussie du mot de passe.

Fonctions d'assistance

redirect_to_login(next[, login_url, redirect_field_name])

Redirection vers la page de connexion. Après une connexion réussie, redirigez vers un autre lien. .

Paramètres :

suivant : lien après une connexion réussie.

login_url : lien de la page de connexion, valeur par défaut : settings.LOGIN_URL.

redirect_field_name : nom du champ de redirection, la valeur par défaut est next.

Formulaires intégrés

classe AdminPasswordChangeForm

formulaire de changement de mot de passe de l'utilisateur en arrière-plan

class AuthenticationForm

formulaire de connexion.

Méthode confirm_login_allowed(user)

Par exemple, autorisez tous les utilisateurs à se connecter, quel que soit l'attribut is_active :

from django.contrib.auth.forms import AuthenticationForm

class AuthenticationFormWithInactiveUsersOkay(AuthenticationForm):
def confirm_login_allowed(self, user):
pass

ou autoriser uniquement les utilisateurs actifs à se connecter :

class PickyAuthenticationForm(AuthenticationForm):
def confirm_login_allowed(self, user):
if not user.is_active:
raise form.ValidationError(
) _("Ce compte est inactif."),
code='inactive' ,
          )
          if user.username.startswith('b'):
                                                                                                ' s                     via         ‐ off   ‐ ‐ ‐ ‐ (« Désolé, les comptes commençant par « b » ne sont pas "Je ne suis pas le bienvenu ici.")
🎜>Formulaire de réinitialisation du mot de passe.

class SetPasswordForm

Formulaire de configuration du mot de passe.

class UserChangeForm

arrière-plan administrateur informations utilisateur et formulaire de modification des autorisations.

class UserCreationForm

Formulaire de création d'utilisateur.

Informations d'authentification dans les modèles

L'utilisateur actuellement connecté et ses autorisations peuvent être obtenu dans les variables du modèle, en utilisant RequestContext.

Users

Lors du rendu du modèle RequestContext, l'utilisateur actuellement connecté, qu'il s'agisse d'une instance User ou d'une instance AnonymousUser, est enregistré dans le modèle variable {{ user }} :

{% if user .is_authenticated %}

Bienvenue, {{ user.username }} Merci de vous être connecté.

{% else %}

Bienvenue, nouvel utilisateur. Veuillez vous connecter.

{% endif %}

Cette variable n'existe pas si RequestContext n’est pas utilisé.

Utiliser RequestContext :

from django.shortcuts import render_to_response

from django.template import RequestContext

def some_view(request):
# ...
return render_to_response('my_template.html',
                                                                                                                                                                                                                                     )

　

Ce qui précède est le système d'authentification des utilisateurs de Django (2) Contenu d'authentification dans les requêtes Web Pour plus d'informations. contenu, veuillez faire attention au site Web PHP chinois (www.php.cn) !