Contactez-nous

Gérer la soumission de formulaire et la persistance des données

Apprenez à traiter les données de formulaire dans Laravel, valider les entrées utilisateur, sauvegarder les informations en base avec Eloquent et gérer les redirections.

Le cycle de vie de la soumission d'un formulaire dans Laravel

Nous avons créé un formulaire de saisie pour nos notes, mais pour l'instant, sa soumission ne fait rien de concret. Cette section se concentre sur ce qui se passe après qu'un utilisateur a rempli le formulaire et cliqué sur le bouton "Enregistrer". Il s'agit d'une étape cruciale dans toute application web : récupérer les données envoyées, s'assurer qu'elles sont valides et conformes à nos attentes, puis les sauvegarder de manière permanente, généralement dans une base de données. Laravel fournit des outils élégants et robustes pour gérer chacune de ces phases.

Le processus typique est le suivant :

  1. L'utilisateur soumet le formulaire. Le navigateur envoie une requête HTTP (généralement POST) à l'URL spécifiée dans l'attribut action du formulaire.
  2. Notre route Laravel (Route::post('/notes', ...) dans notre cas) intercepte cette requête et la dirige vers la méthode appropriée du contrôleur (la méthode store de NoteController).
  3. Dans le contrôleur, nous accédons aux données soumises.
  4. Nous validons ces données pour nous assurer qu'elles respectent certaines règles (par exemple, le titre ne doit pas être vide).
  5. Si la validation échoue, Laravel redirige automatiquement l'utilisateur vers la page précédente (le formulaire) en y joignant les messages d'erreur et les données précédemment saisies (pour ne pas avoir à tout retaper).
  6. Si la validation réussit, nous utilisons notre modèle Eloquent pour créer une nouvelle entrée dans la base de données.
  7. Enfin, nous redirigeons l'utilisateur vers une page appropriée (par exemple, la liste des notes ou la page de la note nouvellement créée) avec un message de succès (message flash).

Nous allons maintenant détailler chaque étape au sein de notre méthode store du NoteController.

Traitement des données du formulaire dans le contrôleur

La première étape dans notre méthode store du NoteController est d'accéder aux données envoyées par le formulaire. Laravel rend cela très simple grâce à l'injection de dépendance de l'objet Illuminate\Http\Request. Cet objet contient toutes les informations sur la requête HTTP entrante, y compris les données du formulaire.

Modifions la méthode store dans app/Http/Controllers/NoteController.php :

use Illuminate\Http\Request;
use App\Models\Note;
// ... autres use si nécessaire

class NoteController extends Controller
{
    // ... autres méthodes (index, create, show)

    /**
     * Stocke une nouvelle note dans la base de données.
     */
    public function store(Request $request)
    {
        // Accéder aux données du formulaire :
        // $title = $request->input('title');
        // $content = $request->input('content');

        // Pour l'instant, affichons les données pour vérifier
        // dd($request->all()); // "dd" signifie "dump and die", très utile pour le débogage

        // La suite (validation, sauvegarde, redirection) viendra ici
        return "Données reçues (temporaire)";
    }
}

L'objet $request possède plusieurs méthodes pour récupérer les données :

  • $request->all() : Retourne un tableau associatif de toutes les données de la requête (provenant du formulaire).
  • $request->input('nom_du_champ') : Récupère la valeur d'un champ spécifique. Par exemple, $request->input('title').
  • $request->title : Vous pouvez aussi accéder aux champs comme des propriétés dynamiques de l'objet $request.

Si vous soumettez le formulaire de création maintenant (après avoir rempli les champs titre et contenu), et si vous décommentez la ligne dd($request->all());, vous verrez un affichage de toutes les données envoyées par le formulaire, y compris le token CSRF (_token). Cela confirme que notre contrôleur reçoit bien les données.

Validation des données saisies

Avant de sauvegarder quoi que ce soit en base de données, il est impératif de valider les données reçues. La validation garantit que les données sont dans le format attendu et respectent les contraintes métier (par exemple, un champ obligatoire, une longueur minimale/maximale, un format d'email valide, etc.). Laravel offre un système de validation très puissant et flexible.

La validation peut être effectuée directement dans le contrôleur en utilisant la méthode validate disponible sur l'objet $request. Cette méthode prend en premier argument un tableau de règles de validation. Si l'une des règles échoue, Laravel génère automatiquement une réponse de redirection vers l'URL précédente (le formulaire) et flashe les erreurs de validation dans la session, de sorte qu'elles soient disponibles dans la vue via la variable $errors (comme nous l'avons préparé dans create.blade.php).

Ajoutons la validation à notre méthode store :

// Dans NoteController.php, méthode store()
public function store(Request $request)
{
    $validatedData = $request->validate([
        'title' => 'required|string|max:255',
        'content' => 'required|string',
    ]);

    // Si la validation passe, $validatedData contiendra uniquement les champs validés.
    // La suite du code ne sera exécutée que si la validation réussit.

    // Pour l'instant, affichons les données validées
    // dd($validatedData);

    // La sauvegarde et la redirection viendront ici
    return "Validation réussie (temporaire)";
}

Décortiquons les règles de validation :

  • 'title' => 'required|string|max:255' :
    • required : Le champ 'title' doit être présent et non vide.
    • string : La valeur du champ 'title' doit être une chaîne de caractères.
    • max:255 : La chaîne 'title' ne doit pas dépasser 255 caractères.
  • 'content' => 'required|string' :
    • required : Le champ 'content' doit être présent et non vide.
    • string : La valeur du champ 'content' doit être une chaîne de caractères.

Laravel propose une multitude d'autres règles de validation prêtes à l'emploi. Si vous soumettez le formulaire avec un champ vide ou un titre trop long, vous devriez être redirigé vers le formulaire avec les messages d'erreur appropriés affichés (grâce à nos directives @error et $errors->all() dans create.blade.php).

Sauvegarde de la nouvelle note en base de données avec Eloquent

Une fois les données validées, nous pouvons les enregistrer en toute sécurité dans notre base de données. C'est là que notre modèle Eloquent Note entre en jeu. Il existe plusieurs manières de créer une nouvelle entrée avec Eloquent. Une des plus courantes est d'utiliser la méthode statique create() sur le modèle.

Pour que la méthode Note::create() fonctionne correctement et accepte l'assignation de masse (mass assignment), nous devons spécifier quels attributs du modèle peuvent être assignés de cette manière. Cela se fait en définissant une propriété $fillable (ou $guarded) dans notre modèle app/Models/Note.php. C'est une mesure de sécurité pour éviter que des champs non désirés soient modifiés via une requête.

Modifiez app/Models/Note.php :


     */
    protected $fillable = [
        'title',
        'content',
    ];

    // Si vous préférez utiliser $guarded (ceux qui ne sont PAS assignables en masse) :
    // protected $guarded = ['id', 'created_at', 'updated_at'];
    // Ou pour autoriser tous les champs (moins sécurisé si vous ne contrôlez pas les données entrantes) :
    // protected $guarded = [];
}

Avec $fillable configuré, nous pouvons maintenant utiliser Note::create() dans notre méthode store :

// Dans NoteController.php, méthode store()
public function store(Request $request)
{
    $validatedData = $request->validate([
        'title' => 'required|string|max:255',
        'content' => 'required|string',
    ]);

    // Création de la note en utilisant les données validées
    $note = Note::create($validatedData);

    // $note contient maintenant l'instance de la note nouvellement créée, avec son ID.

    // La redirection viendra ici
    return "Note créée avec ID: " . $note->id . " (temporaire)";
}

La méthode Note::create($validatedData) crée une nouvelle instance du modèle Note, lui assigne les attributs présents dans $validatedData (qui correspondent à nos champs title et content), et la sauvegarde immédiatement en base de données. Les champs created_at et updated_at sont automatiquement remplis par Eloquent.

Redirection après succès et affichage de messages flash

Après avoir sauvegardé avec succès la nouvelle note, la dernière étape est de rediriger l'utilisateur. Il est courant de rediriger vers la liste des notes (la page notes.index) ou vers la page de la note nouvellement créée (notes.show). Nous allons également ajouter un "message flash" à la session. Un message flash est un message qui n'est disponible que pour la prochaine requête HTTP, parfait pour afficher des notifications de succès ou d'erreur après une action.

Complétons notre méthode store :

// Dans NoteController.php, méthode store()
public function store(Request $request)
{
    $validatedData = $request->validate([
        'title' => 'required|string|max:255',
        'content' => 'required|string',
    ]);

    $note = Note::create($validatedData);

    // Redirection vers la page de la note créée avec un message de succès
    // return redirect()->route('notes.show', $note->id)
    //                  ->with('success', 'Note créée avec succès !');

    // Ou redirection vers la liste des notes avec un message de succès
    return redirect()->route('notes.index')
                     ->with('success', 'Note \"' . $note->title . '\" créée avec succès !');
}

La fonction redirect() retourne une instance de redirection. Nous utilisons la méthode route('routeName', $parameters) pour spécifier vers quelle route nommée rediriger. La méthode with('key', 'value') ajoute une donnée flash à la session. Ici, nous ajoutons un message sous la clé 'success'.

Pour afficher ce message flash, nous devons modifier notre vue notes/index.blade.php (si nous redirigeons vers l'index) ou notes/show.blade.php (si nous redirigeons vers le détail). Reprenons l'exemple de notes/index.blade.php et assurons-nous qu'il peut afficher le message de succès :

{{-- Dans resources/views/notes/index.blade.php --}}
@extends('layouts.app')

@section('title', 'Liste des Notes')

@section('content')
    <div class="d-flex justify-content-between align-items-center mb-3">
        <h2>Toutes mes notes</h2>
        <a href="{{ route('notes.create') }}" class="btn btn-primary">Ajouter une note</a>
    </div>

    {{-- Affichage du message flash de succès --}}
    @if(session('success'))
        <div class="alert alert-success">
            {{ session('success') }}
        </div>
    @endif

    {{-- ... reste de la vue ... --}}
@endsection

La fonction helper session('key') permet de récupérer une valeur de la session. Si la clé 'success' existe (ce qui sera le cas après une redirection avec ->with('success', ...)), son message sera affiché. Ce message ne sera présent que pour cette unique requête ; si vous actualisez la page, il disparaîtra.

Avec ces étapes, notre fonctionnalité d'ajout de note est complète ! L'utilisateur peut remplir le formulaire, les données sont validées, sauvegardées, et l'utilisateur est redirigé avec une confirmation. C'est un flux de travail fondamental dans le développement web que Laravel rend particulièrement agréable à implémenter.