Gestion des formulaires — Flask-WTF
Dans ce chapitre, vous apprendrez à utiliser Flask-WTF pour standardiser la gestion des formulaires : définition de classes de formulaire, protection CSRF automatique, validation des champs et messages d'erreur.
Pourquoi utiliser Flask-WTF ?
Les formulaires d'inscription et de connexion du chapitre précédent étaient écrits à la main : manuellement à partir derequest.form.get()Récupération des valeurs, validation manuelle, affichage manuel des erreurs.
Flask-WTFUne surcouche de WTForms pour Flask, offrant :
- Définition de classes de formulaire, gestion centralisée des champs + règles de validation.
- Protection CSRF automatique
- Rendu des champs et des messages d'erreur dans les templates
form.validate_on_submit()Gestion unifiée de la détermination et de la validation GET/POST.
Installation et configuration
(venv) $ pip install flask-wtf
Configurer SECRET_KEY dans app.py (le jeton CSRF dépend de cette clé) :
Exemple
app.config['SECRET_KEY'] = 'your-secret-key' # Utiliser des variables d'environnement pour l'environnement de production
app.config['WTF_CSRF_ENABLED'] = True # Activé par défaut, le déclarer explicitement
Définir la classe de formulaire
Exemple
from flask_wtf import FlaskForm
from wtforms import StringField, PasswordField, EmailField, BooleanField
from wtforms.validators import DataRequired, Length, Email, EqualTo, ValidationError
from app.models import User
class RegisterForm(FlaskForm):
Formulaire d'inscription
username = StringField(Nom d'utilisateur, validators=[
DataRequired(message=Le nom d'utilisateur ne peut pas être vide),
Length(min=3, max=50, message=Le nom d'utilisateur doit comporter entre 3 et 50 caractères)
])
email = EmailField(E-mail, validators=[
DataRequired(message=L'adresse e-mail ne peut pas être vide),
Email(message=Veuillez saisir une adresse e-mail valide)
])
password = PasswordField(Mot de passe, validators=[
DataRequired(message=Le mot de passe ne peut pas être vide),
Length(min=6, message=Le mot de passe doit comporter au moins 6 caractères)
])
confirm_password = PasswordField(Confirmer le mot de passe, validators=[
DataRequired(message=Veuillez saisir à nouveau le mot de passe),
EqualTo('password', message=Les deux mots de passe ne correspondent pas)
])
# Validateur personnalisé : vérifier si le nom d'utilisateur est déjà enregistré
def validate_username(self, field):
if User.query.filter_by(username=field.data).first():
raise ValidationError(Ce nom d'utilisateur est déjà pris.)
def validate_email(self, field):
if User.query.filter_by(email=field.data).first():
raise ValidationError(Cet e-mail est déjà enregistré.)
class LoginForm(FlaskForm):
"""Formulaire de connexion"""
username = StringField(Nom d'utilisateur, validators=[
DataRequired(message=Le nom d'utilisateur ne peut pas être vide)
])
password = PasswordField(Mot de passe, validators=[
DataRequired(message=Le mot de passe ne peut pas être vide)
])
remember = BooleanField(Se souvenir de moi)
Types de champs courants
| Classe Field | Balise HTML | Description |
|---|---|---|
| StringField | <input type="text"> | Texte sur une seule ligne |
| PasswordField | <input type="password"> | Champ de mot de passe |
| EmailField | <input type="email"> | Champ de saisie e-mail |
| TextAreaField | <textarea> | Texte multiligne |
| BooleanField | <input type="checkbox"> | Case à cocher |
| SelectField | <select> | Sélection dans une liste déroulante |
Validateurs courants
| Validateur | Fonction |
|---|---|
| DataRequired() | Le champ ne peut pas être vide |
| Length(min=, max=) | Limite de longueur des caractères |
| Email() | Validation du format d'e-mail |
| EqualTo('field_name') | Correspond à la valeur d'un autre champ |
| Optional() | Autoriser le champ à être vide (ignorer les validateurs suivants). |
Utilisation des formulaires dans les fonctions de vue
Exemple
from flask import Blueprint, render_template, redirect, url_for, flash
from flask_login import login_user, logout_user, login_required, current_user
from app.forms import RegisterForm, LoginForm
from app.models import User, db
auth_bp = Blueprint('auth', __name__)
@auth_bp.route("/register", methods=['GET', 'POST'])
def register():
if current_user.is_authenticated:
return redirect(url_for('main.index'))
formulaire = RegisterForm()
# form.validate_on_submit() valide le formulaire lors des requêtes POST
# Renvoie False sur les requêtes GET ou lorsque la validation échoue
if form.validate_on_submit():
user = User(username=form.username.data, email=form.email.data)
user.set_password(form.password.data)
db.session.add(user)
db.session.commit()
login_user(user)
flash(fInscription réussie, bienvenue, {user.username} !, 'success')
return redirect(url_for('main.index'))
# En cas de requêtes GET ou d'échec de validation, rendre le modèle avec le formulaire
return render_template('register.html', form=form)
@auth_bp.route("/login", methods=['GET', 'POST'])
def login():
if current_user.is_authenticated:
return redirect(url_for('main.index'))
form = LoginForm()
if form.validate_on_submit():
user = User.query.filter_by(username=form.username.data).first()
if user is None or not user.check_password(form.password.data):
flash(Nom d'utilisateur ou mot de passe incorrect., 'error')
return render_template('login.html', form=form)
login_user(user, remember=form.remember.data)
flash(fBon retour, {user.username} !, 'success')
next_page = request.args.get('next')
return redirect(next_page or url_for('main.index'))
return render_template('login.html', form=form)
Rendu des formulaires dans les templates
Exemple
{% extends 'base.html' %}
{% block title %}Inscription - EXAMPLE Blog{% endblock %}
{% block content %}
<div class="auth-form">
<h2>Registre</h2>
<form method="post">
<!-- form.hidden_tag() génère automatiquement le champ caché du jeton CSRF -->
{{ form.hidden_tag() }}
<div class="form-group">
{{ form.username.label }}
{{ form.username(class="form-input") }}
{% if form.username.errors %}
{% for error in form.username.errors %}
<span class="field-error">{{ error }}</span>
{% endfor %}
{% endif %}
</div>
<div class="form-group">
{{ form.email.label }}
{{ form.email(class="form-input") }}
{% for error in form.email.errors %}
<span class="field-error">{{ error }}</span>
{% endfor %}
</div>
<div class="form-group">
{{ form.password.label }}
{{ form.password(class="form-input") }}
{% for error in form.password.errors %}
<span class="field-error">{{ error }}</span>
{% endfor %}
</div>
<div class="form-group">
{{ form.confirm_password.label }}
{{ form.confirm_password(class="form-input") }}
{% for error in form.confirm_password.errors %}
<span class="field-error">{{ error }}</span>
{% endfor %}
</div>
{{ form.submit(class="btn-submit") }}
</forme>
<p class="form-footer">
Vous avez déjà un compte ?<a href="{{ url_for('auth.login') }}">Connectez-vous maintenant</a>
</p>
</div>
{% endblock %}
La protection CSRF de Flask-WTF est automatique :
form.hidden_tag()Générera un champ caché<input>Contient un jeton aléatoire ; le serveur valide ce jeton avant d'accepter la requête POST. Tout formulaire soumis depuis un site externe est rejeté car il ne contient pas le bon jeton.
Comparaison entre request.form manuel et Flask-WTF
| Aspect | request.form manuel | Flask-WTF |
|---|---|---|
| Lignes de code | Pour chaque champ, répétez les trois étapes : récupérer/valider/signaler | Définir la classe de formulaire une fois |
| Protection CSRF | Implémentation manuelle requise | Automatique |
| Validation personnalisée | if/else manuel | méthode validate_xxx |
| Affichage des erreurs | Concaténation manuelle | collecte automatique de form.field.errors |
| Scénarios applicables | Formulaires simples (par ex. champ de recherche) | Formulaires complexes (inscription, connexion, modification du profil) |
Résumé du chapitre
Dans ce chapitre, vous avez refactorisé le formulaire d'authentification à l'aide de Flask-WTF : FlaskForm définit les champs et les validateurs, validate_xxx pour la validation personnalisée, form.validate_on_submit() gère uniformément la validation POST, form.hidden_tag() assure une protection CSRF automatique, et les messages d'erreur sont affichés dans les templates.
La gestion des formulaires est désormais plus standardisée et sécurisée.
autres extensions