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

# Chemin du fichier : app.py
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

# Chemin du fichier : app/forms.py (nouveau fichier)
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 FieldBalise HTMLDescription
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

ValidateurFonction
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

# Chemin du fichier : app/blueprints/auth.py (register et login refactorisés)
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

<!-- Chemin du fichier : app/templates/register.html -->
{% 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

Aspectrequest.form manuelFlask-WTF
Lignes de codePour chaque champ, répétez les trois étapes : récupérer/valider/signalerDéfinir la classe de formulaire une fois
Protection CSRFImplémentation manuelle requiseAutomatique
Validation personnaliséeif/else manuelméthode validate_xxx
Affichage des erreursConcaténation manuellecollecte automatique de form.field.errors
Scénarios applicablesFormulaires 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