Principales fonctionnalités des formulaires Django

Les composants Form de Django fournissent une abstraction puissante pour gérer les données utilisateur. Ils offrent plusieurs avantages essentiels :

• Génération automatique du balisage HTML pour les champs de saisie.
• Validation des données soumises par l'utilisateur, avec gestion des messages d'erreur.
• Conservation des données précédemment soumises lors d'une nouvelle requête.
• Initialisation des champs avec des valeurs par défaut provenant de sources externes.

Définition d'une classe de formulaire

Pour créer un formulaire, on définit une classe héritant de django.forms.Form. Chaque attribut de classe correspond à un champ du formulaire, où l'on spécifie son type (CharField, ChoiceField) et son widget (TextInput, Select).

from django import forms

class FormulaireInscription(forms.Form):
    identifiant = forms.CharField(
        widget=forms.TextInput(attrs={'id': 'champ_id', 'class': 'style_css'})
    )
    choix_genre = forms.ChoiceField(
        choices=(('H', 'Homme'), ('F', 'Femme'),),
        initial='F',
        widget=forms.RadioSelect
    )
    ville = forms.CharField(
        initial='Paris',
        widget=forms.Select(choices=[('Paris', 'Paris'), ('Lyon', 'Lyon'),])
    )
    mot_de_passe = forms.CharField(
        widget=forms.PasswordInput(attrs={'class': 'style_css'}, render_value=True)
    )

Traitement dans la vue

Dans la vue, on instancie le formulaire. Pour une requête GET, on l'envoie vide au template. Pour une requête POST, on le lie aux données de la requête via request.POST et on appelle la méthode is_valid() pour déclencher la validation.

from django.shortcuts import render, redirect
from .forms import FormulaireInscription

def vue_inscription(request):
    if request.method == 'GET':
        formulaire = FormulaireInscription()
        return render(request, 'inscription.html', {'form': formulaire})
    elif request.method == 'POST':
        formulaire = FormulaireInscription(request.POST)
        if formulaire.is_valid():
            donnees_propres = formulaire.cleaned_data
            # Traiter les données validées
        else:
            erreurs = formulaire.errors
            # Gérer les erreurs
        return render(request, 'inscription.html', {'form': formulaire})
    return redirect('/')

Rendu HTML du formulaire

Le template affiche les champs du formulaire en utilisant la syntaxe {{ form.champ }}. Les erreurs associées à chaque champ sont accessibles via {{ form.champ.errors }}.

<form method="POST">
    {% csrf_token %}
    <p>{{ form.identifiant }} {{ form.identifiant.errors }}</p>
    <p>{{ form.choix_genre }} {{ form.choix_genre.errors }}</p>
    <p>{{ form.ville }} {{ form.ville.errors }}</p>
    <p>{{ form.mot_de_passe }} {{ form.mot_de_passe.errors }}</p>
    <input type="submit"/>
</form>

Personnalisation et options des champs

Django propose un large éventail de types de champs natifs adaptés à différents besoins de validation.

• CharField : Pour les chaînes de caractères. Options : max_length, min_length.
• IntegerField / FloatField / DecimalField : Pour les données numériques avec validation de plages.
• DateField / DateTimeField : Pour les dates et heures, avec spécification des formats d'entrée.
• EmailField : Valide automatiquement le format d'une adresse e-mail.
• FileField : Gère l'envoi de fichiers (nécessite enctype="multipart/form-data" dans le formulaire).
• ChoiceField : Fournit une liste de choix prédéfinie, utilisable avec un widget Select ou RadioSelect.

La plupart des champs acceptent les arguments communs required, widget, label, initial et error_messages.

Stratégies de validation personnalisée

Au-delà des validations intégrées, plusieurs mécanismes permettent d'ajouter des règles spécifiques.

Avec des validateurs explicites

from django.core.validators import RegexValidator

class FormulaireContact(forms.Form):
    telephone = forms.CharField(
        validators=[RegexValidator(r'^\+?[0-9]{10,15}$', 'Numéro de téléphone invalide.')]

Avec une méthode de nettoyage de champ

class FormulaireCommande(forms.Form):
    code_promo = forms.CharField(required=False)

    def clean_code_promo(self):
        code = self.cleaned_data.get('code_promo')
        if code and not code.startswith('PROMO'):
            raise forms.ValidationError('Le code promotionnel doit commencer par PROMO.')
        return code

Initialisation avec des données existentes

Pour pré-remplir un formulaire avec des données (par exemple, depuis une base de données), il suffit de passer un dictionnaire en premier argument au constructeur.

def editer_profil(request, user_id):
    utilisateur = get_object_or_404(Utilisateur, pk=user_id)
    if request.method == 'GET':
        # Initialisation avec les données de l'objet
        donnees_initiales = {'nom': utilisateur.nom, 'email': utilisateur.email}
        formulaire = FormulaireProfil(initial=donnees_initiales)
        return render(request, 'editer_profil.html', {'form': formulaire})
    # ...

Les options des ChoiceField peuvent être chargées dynamiquement en surchargeant la méthode __init__ du formulaire ou en utilisant les champs spéciaux ModelChoiceField liés directement à un queryset Django.