Comment Créer une Application Web avec Laravel : Guide Complet pour Débutants

Laravel est l'un des frameworks PHP les plus populaires, réputé pour sa simplicité, sa puissance, et ses fonctionnalités riches qui facilitent le développement d'applications web modernes. Si vous débutez avec Laravel et que vous souhaitez apprendre tout en créant une application concrète, ce guide est fait pour vous !

Dans cet article, nous vous accompagnons étape par étape pour développer une application web de gestion de recettes. Vous découvrirez les bases de Laravel, de son architecture MVC à la gestion des bases de données avec Eloquent, en passant par la création d'interfaces dynamiques avec Blade. À la fin de ce tutoriel, vous aurez non seulement une application fonctionnelle, mais aussi une compréhension solide des concepts clés de Laravel.

Préparez votre environnement de développement, et plongeons ensemble dans l’univers de Laravel ! 🚀

Introduction

Qu'est-ce que Laravel ?

Laravel est un framework PHP open-source, populaire et robuste, conçu pour simplifier le développement d'applications web modernes. Il repose sur une architecture MVC (Modèle-Vue-Contrôleur) qui permet de structurer proprement le code et de séparer la logique métier de l’interface utilisateur. Laravel offre une multitude de fonctionnalités prêtes à l’emploi, telles que le routage, l’authentification, la gestion des bases de données, et bien plus, ce qui en fait un outil incontournable pour les développeurs PHP.

En plus de sa simplicité et de sa richesse fonctionnelle, Laravel bénéficie d’une communauté active et de ressources abondantes (documentation officielle, tutoriels, packages), rendant l’apprentissage et l’utilisation de ce framework accessibles même aux débutants.

Pourquoi choisir Laravel pour le développement web ?

Laravel se distingue par ses nombreux avantages qui facilitent et accélèrent le processus de développement :

Facilité d’utilisation : Sa syntaxe élégante et intuitive réduit la courbe d’apprentissage pour les développeurs.
Riche écosystème : Des outils intégrés comme Eloquent ORM, Blade (le moteur de template), et Artisan (l’interface en ligne de commande) permettent de gérer efficacement les bases de données, les vues, et les tâches courantes.
Sécurité intégrée : Laravel offre des fonctionnalités natives pour la protection des données, telles que la gestion des mots de passe hachés, la prévention des attaques CSRF et SQL injection.
Scalabilité et performance : Laravel est conçu pour des applications de toutes tailles, et sa compatibilité avec des outils comme Redis, Memcached ou Horizon facilite le traitement de tâches complexes.
Communauté et extensions : Avec une communauté massive, Laravel propose une multitude de packages pour étendre les fonctionnalités de votre application.
Approche moderne : Laravel suit les meilleures pratiques du développement web, telles que les tests automatisés et les API REST.

En somme, Laravel est idéal pour construire rapidement des applications robustes et évolutives.

Objectifs du tutoriel

Ce tutoriel est conçu pour être 100% pratique et accessible aux débutants souhaitant apprendre les bases de Laravel. Voici les objectifs principaux :

Apprendre les bases de Laravel : Découvrir les concepts fondamentaux du framework en créant une application de gestion de recettes.
Comprendre les concepts clés :
MVC (Modèle-Vue-Contrôleur) : Appréhender la structure logique de Laravel.
Routage : Apprendre à gérer les URL et les contrôleurs associés.
Migrations : Savoir créer et gérer les bases de données avec des migrations.
Eloquent ORM : Comprendre comment interagir avec les bases de données de manière intuitive.
Blade : Créer des interfaces utilisateur dynamiques avec le moteur de template Blade.

À la fin du tutoriel, vous aurez non seulement une application de recettes fonctionnelle, mais aussi une compréhension solide des concepts de base de Laravel.

Prérequis

Pour suivre ce tutoriel dans les meilleures conditions, assurez-vous de remplir les prérequis suivants :

Connaissances de base en PHP :

Vous devez savoir manipuler des variables, des fonctions, et avoir une compréhension de base de la programmation orientée objet (POO).

Un environnement de développement configuré :

PHP (version 8.0 ou supérieure) : Assurez-vous que PHP est installé sur votre machine.
Composer : L'outil de gestion des dépendances pour PHP.
MySQL : Une base de données relationnelle pour stocker les recettes.
Serveur local : Utilisez un outil comme XAMPP ou Laragon pour simuler un environnement serveur.

Un éditeur de code :

Visual Studio Code est recommandé pour sa simplicité et ses extensions utiles pour Laravel.

1. Configuration de l’environnement

Dans cette section, nous allons configurer l’environnement de développement et installer Laravel afin de commencer la création de notre application de gestion de recettes.

Installer Laravel

Installation via Composer

Vérifiez que Composer est installé :
Laravel nécessite Composer pour gérer ses dépendances. Si Composer n’est pas encore installé, téléchargez-le depuis le site officiel : https://getcomposer.org/.

Pour vérifier son installation, exécutez la commande suivante dans votre terminal :

composer --version

Cela affichera la version installée si Composer est bien configuré.

Créer une nouvelle application Laravel :

Utilisez la commande suivante pour installer une nouvelle application Laravel appelée recette-app :

composer create-project laravel/laravel recette-app

Cette commande va :

Télécharger la dernière version de Laravel.
Installer toutes les dépendances nécessaires.
Configurer un projet Laravel prêt à l’emploi dans un dossier nommé recette-app.

Naviguez dans le répertoire du projet :
Une fois l’installation terminée, déplacez-vous dans le dossier du projet :

cd recette-app

Configurer l’application

Paramétrer le fichier `.env`

Le fichier .env de Laravel contient les configurations sensibles de l'application, telles que les paramètres de connexion à la base de données. Voici comment configurer ce fichier :

Ouvrez le fichier .env à la racine de votre projet dans votre éditeur de code.

Trouvez la section relative à la base de données, et modifiez-la pour correspondre à votre configuration MySQL locale. Par exemple :

DB_CONNECTION=mysql
DB_HOST=127.0.0.1
DB_PORT=3306
DB_DATABASE=recette_app
DB_USERNAME=root
DB_PASSWORD=your_password

Remplacez recette_app par le nom de votre base de données.
Mettez à jour DB_USERNAME et DB_PASSWORD en fonction de vos identifiants MySQL.

Créer la base de données :
Connectez-vous à votre serveur MySQL et créez une base de données appelée recette_app :

CREATE DATABASE recette_app;

Générer la clé d’application :
Laravel nécessite une clé unique pour sécuriser les données de l’application. Générez cette clé en exécutant la commande suivante :

php artisan key:generate

Cela mettra automatiquement à jour la valeur APP_KEY dans le fichier .env.

Lancer le serveur local

Une fois Laravel configuré, vous pouvez lancer un serveur local pour voir l’application en action.

Exécutez la commande suivante dans le terminal :

php artisan serve

Cela démarrera un serveur local, généralement accessible à l’adresse suivante :
http://127.0.0.1:8000.

Ouvrez cette URL dans votre navigateur. Si tout a été configuré correctement, vous verrez la page d’accueil par défaut de Laravel.

2. Structure du projet Laravel

Avant de plonger dans le développement de notre application, il est essentiel de comprendre la structure d’un projet Laravel et son fonctionnement. Cette section présente les dossiers principaux de Laravel et offre une explication rapide du cycle de vie d’une requête.

1. Présentation des dossiers principaux

Laravel suit une structure bien organisée pour rendre le développement clair et efficace. Voici un aperçu des dossiers principaux que vous utiliserez fréquemment dans ce tutoriel :

1.1. `routes/`

Ce dossier contient les fichiers de définition des routes, qui permettent de relier les URL aux contrôleurs ou aux fonctions spécifiques.

Fichier important :

web.php : Fichier utilisé pour définir les routes web (celles accessibles via un navigateur). Par exemple :

Route::get('/recipes', [RecipeController::class, 'index']);

api.php : Fichier pour les routes des API (destinées à une application externe ou mobile).

1.2. `app/Models/`

Ce dossier contient les modèles, qui représentent les entités de votre application et permettent d’interagir avec la base de données.

Exemple :
Si vous avez une table recipes dans votre base de données, vous créerez un modèle Recipe.php dans ce dossier. Ce modèle contient la logique liée à la gestion des données, comme les relations avec d'autres modèles.

namespace App\Models;

use Illuminate\Database\Eloquent\Factories\HasFactory;
use Illuminate\Database\Eloquent\Model;

class Recipe extends Model
{
    use HasFactory;

    protected $fillable = ['title', 'description', 'ingredients', 'steps'];
}

1.3. `app/Http/Controllers/`

Les contrôleurs se trouvent dans ce dossier. Ils contiennent la logique métier qui relie les modèles aux vues.

Exemple :
Si vous avez une route qui affiche toutes les recettes, vous utiliserez un contrôleur pour récupérer les données et les envoyer à la vue.

namespace App\Http\Controllers;

use App\Models\Recipe;
use Illuminate\Http\Request;

class RecipeController extends Controller
{
    public function index()
    {
        $recipes = Recipe::all();
        return view('recipes.index', compact('recipes'));
    }
}

1.4. `resources/views/`

Ce dossier contient les vues de l’application. Les vues sont les fichiers Blade qui génèrent l’interface utilisateur (HTML dynamique).

Exemple de fichier Blade :
resources/views/recipes/index.blade.php peut contenir le code suivant pour afficher une liste de recettes :

<!DOCTYPE html>
<html>
<head>
    <title>Liste des recettes</title>
</head>
<body>
    <h1>Recettes</h1>
    <ul>
        @foreach ($recipes as $recipe)
            <li>{{ $recipe->title }}</li>
        @endforeach
    </ul>
</body>
</html>

2. Explication rapide du cycle de vie d’une requête

Le cycle de vie d'une requête dans Laravel suit une séquence bien définie pour transformer une demande utilisateur en une réponse.

La requête arrive au point d’entrée (public/index.php)
Ce fichier est le point de départ de toute requête. Il charge les fichiers nécessaires et initialise l’application Laravel.

Le routage (routes/web.php)
Une fois que l’application est initialisée, Laravel analyse l’URL demandée et trouve une correspondance dans les routes définies (par exemple, /recipes).

Appel au contrôleur
Si une route correspond à l’URL, elle appelle la méthode d’un contrôleur spécifié. Par exemple, la route suivante appelle la méthode index de RecipeController :

Route::get('/recipes', [RecipeController::class, 'index']);

Interaction avec le modèle
Dans le contrôleur, si des données doivent être récupérées ou enregistrées, le modèle est utilisé pour interagir avec la base de données. Par exemple :

$recipes = Recipe::all();

Retour d’une vue
Une fois les données récupérées, le contrôleur retourne une vue, souvent avec les données nécessaires :

return view('recipes.index', compact('recipes'));

Rendu HTML
Laravel génère du HTML dynamique en combinant la vue (fichier Blade) et les données passées par le contrôleur, puis retourne ce HTML comme réponse à l’utilisateur.

3. Création de la base de données

Dans cette section, nous allons configurer une base de données MySQL pour notre application Laravel et utiliser les migrations pour créer la table des recettes. Les migrations permettent de gérer la structure de la base de données directement depuis le code, ce qui rend les modifications plus faciles à suivre et à partager.

1. Configurer la base de données MySQL

Créer une base de données nommée `recette_app`

Connectez-vous à votre serveur MySQL via un outil comme phpMyAdmin, HeidiSQL, ou en utilisant le terminal avec la commande suivante :

mysql -u root -p

(Remplacez root par votre nom d’utilisateur MySQL et entrez votre mot de passe si nécessaire.)

Une fois connecté, créez une base de données pour l’application avec la commande SQL suivante :

CREATE DATABASE recette_app;

Vérifiez que la base de données a été créée :

SHOW DATABASES;

Configurez Laravel pour utiliser cette base de données :

Ouvrez le fichier .env à la racine du projet Laravel.

Modifiez les valeurs suivantes pour correspondre à votre configuration MySQL :

DB_CONNECTION=mysql
DB_HOST=127.0.0.1
DB_PORT=3306
DB_DATABASE=recette_app
DB_USERNAME=root
DB_PASSWORD=your_password

2. Utiliser les migrations pour créer les tables

Les migrations dans Laravel permettent de définir et modifier la structure des tables de votre base de données à l’aide de code. Voici comment créer la table des recettes :

Générer une migration pour les recettes

Dans votre terminal, exécutez la commande suivante pour créer une migration :

php artisan make:migration create_recipes_table

Cette commande génère un fichier de migration dans le dossier database/migrations avec un nom comme 2025_01_23_000000_create_recipes_table.php.

Ajouter les colonnes nécessaires

Ouvrez le fichier de migration généré dans l’éditeur de code.

Ajoutez les colonnes nécessaires pour la table des recettes dans la méthode up() :

public function up()
{
    Schema::create('recipes', function (Blueprint $table) {
        $table->id(); // Colonne pour l'identifiant unique
        $table->string('title'); // Titre de la recette
        $table->text('description')->nullable(); // Description de la recette
        $table->text('ingredients'); // Liste des ingrédients
        $table->text('steps'); // Étapes de préparation
        $table->timestamps(); // Colonnes created_at et updated_at
    });
}

La méthode down() est utilisée pour supprimer la table si vous annulez la migration. Cela est automatiquement généré par Laravel et peut être laissé tel quel :

public function down()
{
    Schema::dropIfExists('recipes');
}

3. Exécuter les migrations

Une fois la migration définie, vous pouvez exécuter la commande suivante pour appliquer les modifications à la base de données :

php artisan migrate

Cette commande :

Lit toutes les migrations non exécutées dans le dossier database/migrations.
Crée les tables correspondantes dans la base de données.

Vérifier les résultats

Ouvrez votre outil de gestion MySQL (phpMyAdmin, etc.) ou utilisez la ligne de commande pour vérifier que la table recipes a été créée :

SHOW TABLES;

Pour afficher la structure de la table :

DESCRIBE recipes;

4. Création des modèles et relations

Dans cette étape, nous allons créer un modèle Recipe pour interagir avec la table recipes, définir des relations (si nécessaire), et générer des données fictives à l'aide de factories et seeders. Ces outils permettent de peupler rapidement la base de données pour tester l'application.

1. Créer le modèle Recipe

1.1. Générer le modèle

Laravel propose une commande simple pour créer un modèle et une migration en même temps. Exécutez la commande suivante dans votre terminal :

php artisan make:model Recipe -m

Cette commande crée deux fichiers :

Le modèle : app/Models/Recipe.php
Ce fichier représente la table recipes et contient la logique pour interagir avec les données.
La migration : database/migrations/YYYY_MM_DD_HHMMSS_create_recipes_table.php
Ce fichier vous permet de définir ou de modifier la structure de la table associée.

1.2. Définir les colonnes dans la migration

Si ce n’est pas encore fait, ouvrez le fichier de migration et ajoutez les colonnes nécessaires (comme vu précédemment) :

public function up()
{
    Schema::create('recipes', function (Blueprint $table) {
        $table->id();
        $table->string('title');
        $table->text('description')->nullable();
        $table->text('ingredients');
        $table->text('steps');
        $table->timestamps();
    });
}

Appliquez les modifications à la base de données en exécutant la commande :

php artisan migrate

1.3. Ajouter les relations dans le modèle

Si votre application utilise d'autres entités comme des catégories ou des utilisateurs, vous pouvez définir des relations dans le modèle Recipe. Par exemple :

Une recette appartient à une catégorie :

public function category()
{
    return $this->belongsTo(Category::class);
}

Une recette est créée par un utilisateur :

public function user()
{
    return $this->belongsTo(User::class);
}

Ces relations permettront de récupérer facilement les catégories ou les utilisateurs associés à une recette.

2. Ajouter des données avec des seeders et factories

2.1. Créer une factory pour générer des recettes

Les factories permettent de générer des données fictives pour tester l'application. Utilisez la commande suivante pour créer une factory pour le modèle Recipe :

php artisan make:factory RecipeFactory

Cette commande crée un fichier dans le dossier database/factories. Ouvrez le fichier généré, par exemple database/factories/RecipeFactory.php, et définissez les données fictives pour les recettes :

namespace Database\Factories;

use Illuminate\Database\Eloquent\Factories\Factory;

class RecipeFactory extends Factory
{
    public function definition()
    {
        return [
            'title' => $this->faker->sentence(3), // Génère un titre aléatoire
            'description' => $this->faker->paragraph(), // Génère une description aléatoire
            'ingredients' => $this->faker->paragraph(2), // Génère une liste d'ingrédients fictive
            'steps' => $this->faker->paragraph(3), // Génère des étapes fictives
        ];
    }
}

2.2. Créer un seeder pour remplir la base de données

Les seeders permettent de remplir automatiquement la base de données avec des données générées par les factories.

Créez un seeder pour les recettes :

php artisan make:seeder RecipeSeeder

Ouvrez le fichier généré dans le dossier database/seeders/RecipeSeeder.php et utilisez la factory pour créer plusieurs recettes :

namespace Database\Seeders;

use Illuminate\Database\Seeder;
use App\Models\Recipe;

class RecipeSeeder extends Seeder
{
    public function run()
    {
        Recipe::factory(10)->create(); // Génère 10 recettes fictives
    }
}

Ajoutez ce seeder au fichier DatabaseSeeder.php pour qu’il soit exécuté avec les autres seeders :

public function run()
{
    $this->call(RecipeSeeder::class);
}

2.3. Exécuter les seeders

Pour remplir la base de données avec les données fictives, utilisez la commande suivante :

php artisan db:seed

Si vous souhaitez recréer toute la base de données (en supprimant les données existantes), utilisez :

php artisan migrate:fresh --seed

5. Gestion des routes

Les routes jouent un rôle essentiel dans une application Laravel, car elles relient les URL aux actions spécifiques définies dans les contrôleurs. Dans cette section, nous allons définir des routes pour gérer les différentes fonctionnalités de notre application de recettes : afficher toutes les recettes, afficher une recette spécifique, et gérer les opérations de création, mise à jour et suppression.

1. Introduction aux routes Laravel

Les routes dans Laravel sont définies dans le fichier routes/web.php. Chaque route associe une URL à une action spécifique (souvent une méthode dans un contrôleur). Voici comment ajouter les routes nécessaires pour notre application.

1.1. Créer une route pour afficher toutes les recettes

Ajoutez la route suivante dans le fichier routes/web.php pour afficher toutes les recettes :

use App\Http\Controllers\RecipeController;

Route::get('/recipes', [RecipeController::class, 'index'])->name('recipes.index');

URL : /recipes
Méthode HTTP : GET
Action associée : La méthode index du RecipeController.

1.2. Créer une route pour afficher une recette spécifique

Ajoutez une route pour afficher les détails d’une recette spécifique :

Route::get('/recipes/{id}', [RecipeController::class, 'show'])->name('recipes.show');

URL : /recipes/{id} (où {id} est un paramètre dynamique représentant l’identifiant de la recette).
Méthode HTTP : GET
Action associée : La méthode show du RecipeController.

1.3. Ajouter des routes pour créer, mettre à jour et supprimer des recettes

Voici les routes pour gérer la création, la mise à jour et la suppression des recettes :

Route pour afficher le formulaire de création d’une recette :

Route::get('/recipes/create', [RecipeController::class, 'create'])->name('recipes.create');

URL : /recipes/create
Méthode HTTP : GET
Action associée : La méthode create du contrôleur (affiche le formulaire).

Route pour enregistrer une nouvelle recette :

Route::post('/recipes', [RecipeController::class, 'store'])->name('recipes.store');

URL : /recipes
Méthode HTTP : POST
Action associée : La méthode store du contrôleur (enregistre la recette dans la base de données).

Route pour afficher le formulaire d’édition d’une recette :

Route::get('/recipes/{id}/edit', [RecipeController::class, 'edit'])->name('recipes.edit');

URL : /recipes/{id}/edit
Méthode HTTP : GET
Action associée : La méthode edit du contrôleur (affiche le formulaire de modification).

Route pour mettre à jour une recette existante :

Route::put('/recipes/{id}', [RecipeController::class, 'update'])->name('recipes.update');

URL : /recipes/{id}
Méthode HTTP : PUT
Action associée : La méthode update du contrôleur (met à jour les données de la recette).

Route pour supprimer une recette :

Route::delete('/recipes/{id}', [RecipeController::class, 'destroy'])->name('recipes.destroy');

URL : /recipes/{id}
Méthode HTTP : DELETE
Action associée : La méthode destroy du contrôleur (supprime la recette).

2. Regrouper les routes dans un contrôleur

Au lieu de définir toutes les actions directement dans les routes, nous allons regrouper la logique dans un contrôleur dédié, appelé RecipeController.

2.1. Générer un contrôleur

Utilisez la commande suivante pour générer un contrôleur nommé RecipeController :

php artisan make:controller RecipeController

Cela crée un fichier RecipeController.php dans le dossier app/Http/Controllers/.

2.2. Ajouter les méthodes au contrôleur

Ouvrez le fichier app/Http/Controllers/RecipeController.php et ajoutez les méthodes nécessaires pour chaque route définie :

Afficher toutes les recettes :

public function index()
{
    $recipes = \App\Models\Recipe::all();
    return view('recipes.index', compact('recipes'));
}

Afficher une recette spécifique :

public function show($id)
{
    $recipe = \App\Models\Recipe::findOrFail($id);
    return view('recipes.show', compact('recipe'));
}

Afficher le formulaire de création :

public function create()
{
    return view('recipes.create');
}

Enregistrer une nouvelle recette :

public function store(Request $request)
{
    $validated = $request->validate([
        'title' => 'required|string|max:255',
        'description' => 'nullable|string',
        'ingredients' => 'required|string',
        'steps' => 'required|string',
    ]);

    \App\Models\Recipe::create($validated);

    return redirect()->route('recipes.index')->with('success', 'Recette créée avec succès !');
}

Afficher le formulaire d’édition :

public function edit($id)
{
    $recipe = \App\Models\Recipe::findOrFail($id);
    return view('recipes.edit', compact('recipe'));
}

Mettre à jour une recette existante :

public function update(Request $request, $id)
{
    $validated = $request->validate([
        'title' => 'required|string|max:255',
        'description' => 'nullable|string',
        'ingredients' => 'required|string',
        'steps' => 'required|string',
    ]);

    $recipe = \App\Models\Recipe::findOrFail($id);
    $recipe->update($validated);

    return redirect()->route('recipes.index')->with('success', 'Recette mise à jour avec succès !');
}

Supprimer une recette :

public function destroy($id)
{
    $recipe = \App\Models\Recipe::findOrFail($id);
    $recipe->delete();

    return redirect()->route('recipes.index')->with('success', 'Recette supprimée avec succès !');
}

6. Création des vues avec Blade

Laravel utilise Blade, un moteur de templates puissant et flexible, pour créer des vues. Blade permet de combiner HTML et PHP facilement, tout en offrant des fonctionnalités avancées comme l’héritage de layouts et des directives simples. Dans cette section, nous allons introduire la syntaxe de Blade et créer les vues nécessaires pour notre application de recettes.

1. Introduction à Blade

Blade est le moteur de templates intégré de Laravel. Voici quelques directives de base que nous utiliserons dans ce tutoriel :

1.1. Héritage de layout

Blade permet d’hériter d’un layout principal en utilisant les directives @extends et @section. Exemple :

@extends('layouts.main')

@section('content')
    <h1>Bienvenue sur notre application de recettes !</h1>
@endsection

1.2. Affichage de variables

Les variables peuvent être affichées avec des accolades doubles :

<h1>{{ $recipe->title }}</h1>

1.3. Boucles et conditions

Blade fournit des directives simples pour les boucles et les conditions :

Boucle @foreach :

@foreach ($recipes as $recipe)
    <li>{{ $recipe->title }}</li>
@endforeach

Condition @if :

@if ($recipes->isEmpty())
    <p>Aucune recette disponible.</p>
@else
    <p>Il y a des recettes disponibles !</p>
@endif

2. Créer une interface utilisateur

2.1. Créer un layout principal avec Bootstrap

Créez un fichier de layout principal dans resources/views/layouts/main.blade.php :

<!DOCTYPE html>
<html lang="en">
<head>
    <meta charset="UTF-8">
    <meta name="viewport" content="width=device-width, initial-scale=1.0">
    <title>@yield('title', 'Application de recettes')</title>
    <!-- Lien Bootstrap -->
    <link href="https://cdn.jsdelivr.net/npm/bootstrap@5.3.0/dist/css/bootstrap.min.css" rel="stylesheet">
</head>
<body>
    <nav class="navbar navbar-expand-lg navbar-light bg-light">
        <div class="container">
            <a class="navbar-brand" href="{{ route('recipes.index') }}">Recettes</a>
            <button class="navbar-toggler" type="button" data-bs-toggle="collapse" data-bs-target="#navbarNav">
                <span class="navbar-toggler-icon"></span>
            </button>
        </div>
    </nav>

    <div class="container mt-4">
        @yield('content')
    </div>

    <!-- Script Bootstrap -->
    <script src="https://cdn.jsdelivr.net/npm/bootstrap@5.3.0/dist/js/bootstrap.bundle.min.js"></script>
</body>
</html>

Explication des directives utilisées :

@yield('title') : Permet de définir un titre personnalisé pour chaque page.
@yield('content') : Marqueur pour insérer le contenu spécifique à chaque page.

2.2. Ajouter des pages

2.2.1. La liste des recettes

Créez un fichier resources/views/recipes/index.blade.php pour afficher toutes les recettes :

@extends('layouts.main')

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

@section('content')
    <h1 class="mb-4">Liste des recettes</h1>
    <a href="{{ route('recipes.create') }}" class="btn btn-primary mb-3">Ajouter une nouvelle recette</a>
    @if ($recipes->isEmpty())
        <p>Aucune recette disponible.</p>
    @else
        <ul class="list-group">
            @foreach ($recipes as $recipe)
                <li class="list-group-item">
                    <a href="{{ route('recipes.show', $recipe->id) }}">{{ $recipe->title }}</a>
                </li>
            @endforeach
        </ul>
    @endif
@endsection

2.2.2. Le détail d'une recette

Créez un fichier resources/views/recipes/show.blade.php pour afficher les détails d’une recette :

@extends('layouts.main')

@section('title', $recipe->title)

@section('content')
    <h1>{{ $recipe->title }}</h1>
    <p><strong>Description :</strong> {{ $recipe->description }}</p>
    <p><strong>Ingrédients :</strong></p>
    <p>{{ $recipe->ingredients }}</p>
    <p><strong>Étapes :</strong></p>
    <p>{{ $recipe->steps }}</p>

    <a href="{{ route('recipes.edit', $recipe->id) }}" class="btn btn-warning">Modifier</a>

    <form action="{{ route('recipes.destroy', $recipe->id) }}" method="POST" class="d-inline">
        @csrf
        @method('DELETE')
        <button type="submit" class="btn btn-danger">Supprimer</button>
    </form>
    <a href="{{ route('recipes.index') }}" class="btn btn-secondary">Retour à la liste</a>
@endsection

2.2.3. Le formulaire d’ajout/modification d’une recette

Créez un fichier resources/views/recipes/form.blade.php qui sera utilisé pour les deux actions :

@extends('layouts.main')

@section('title', isset($recipe) ? 'Modifier la recette' : 'Ajouter une recette')

@section('content')
    <h1>{{ isset($recipe) ? 'Modifier la recette' : 'Ajouter une recette' }}</h1>

    <form action="{{ isset($recipe) ? route('recipes.update', $recipe->id) : route('recipes.store') }}" method="POST">
        @csrf
        @if (isset($recipe))
            @method('PUT')
        @endif

        <div class="mb-3">
            <label for="title" class="form-label">Titre</label>
            <input type="text" id="title" name="title" class="form-control" value="{{ old('title', $recipe->title ?? '') }}" required>
        </div>

        <div class="mb-3">
            <label for="description" class="form-label">Description</label>
            <textarea id="description" name="description" class="form-control">{{ old('description', $recipe->description ?? '') }}</textarea>
        </div>

        <div class="mb-3">
            <label for="ingredients" class="form-label">Ingrédients</label>
            <textarea id="ingredients" name="ingredients" class="form-control" required>{{ old('ingredients', $recipe->ingredients ?? '') }}</textarea>
        </div>

        <div class="mb-3">
            <label for="steps" class="form-label">Étapes</label>
            <textarea id="steps" name="steps" class="form-control" required>{{ old('steps', $recipe->steps ?? '') }}</textarea>
        </div>

        <button type="submit" class="btn btn-success">Enregistrer</button>
        <a href="{{ route('recipes.index') }}" class="btn btn-secondary">Annuler</a>
    </form>
@endsection

7. Gestion des formulaires et validation

Dans cette section, nous allons créer un formulaire pour ajouter une nouvelle recette et apprendre à valider les données soumises avant de les enregistrer dans la base de données. Laravel simplifie la gestion des formulaires et des validations grâce à ses helpers et ses méthodes intégrées.

1. Créer un formulaire pour ajouter une nouvelle recette

Pour simplifier la création du formulaire, nous utiliserons les helpers Blade et les routes que nous avons configurées précédemment.

1.1. La route associée

Assurez-vous d’avoir une route définie pour afficher le formulaire et une autre pour enregistrer les données :

Route::get('/recipes/create', [RecipeController::class, 'create'])->name('recipes.create');
Route::post('/recipes', [RecipeController::class, 'store'])->name('recipes.store');

1.2. La méthode `create` dans le contrôleur

Dans le RecipeController, ajoutez la méthode suivante pour afficher le formulaire de création :

public function create()
{
    return view('recipes.create');
}

1.3. Créer le fichier Blade pour le formulaire

Créez un fichier resources/views/recipes/create.blade.php :

@extends('layouts.main')

@section('title', 'Ajouter une recette')

@section('content')
    <h1>Ajouter une nouvelle recette</h1>

    <form action="{{ route('recipes.store') }}" method="POST">
        @csrf <!-- Protection contre les attaques CSRF -->

        <div class="mb-3">
            <label for="title" class="form-label">Titre</label>
            <input type="text" id="title" name="title" class="form-control" value="{{ old('title') }}" required>
        </div>

        <div class="mb-3">
            <label for="description" class="form-label">Description</label>
            <textarea id="description" name="description" class="form-control">{{ old('description') }}</textarea>
        </div>

        <div class="mb-3">
            <label for="ingredients" class="form-label">Ingrédients</label>
            <textarea id="ingredients" name="ingredients" class="form-control" required>{{ old('ingredients') }}</textarea>
        </div>

        <div class="mb-3">
            <label for="steps" class="form-label">Étapes</label>
            <textarea id="steps" name="steps" class="form-control" required>{{ old('steps') }}</textarea>
        </div>

        <button type="submit" class="btn btn-success">Enregistrer</button>
        <a href="{{ route('recipes.index') }}" class="btn btn-secondary">Annuler</a>
    </form>
@endsection

Explication des helpers Blade utilisés :

@csrf : Ajoute un token CSRF pour protéger le formulaire contre les attaques CSRF.
old('field_name') : Permet de conserver les données précédemment saisies en cas d’erreur de validation.

2. Valider les données avant de les enregistrer

Laravel propose une gestion facile des validations via la méthode validate() dans les contrôleurs.

2.1. Ajouter des règles de validation dans le contrôleur

Dans le RecipeController, ajoutez la méthode store pour gérer la soumission du formulaire et valider les données :

public function store(Request $request)
{
    // Valider les données du formulaire
    $validated = $request->validate([
        'title' => 'required|string|max:255',
        'description' => 'nullable|string',
        'ingredients' => 'required|string',
        'steps' => 'required|string',
    ]);

    // Créer une nouvelle recette avec les données validées
    \App\Models\Recipe::create($validated);

    // Rediriger vers la liste des recettes avec un message de succès
    return redirect()->route('recipes.index')->with('success', 'Recette ajoutée avec succès !');
}

Règles de validation utilisées :

required : Le champ est obligatoire.
string : Le champ doit être une chaîne de caractères.
max:255 : La longueur maximale du champ est de 255 caractères.
nullable : Le champ peut être laissé vide.

2.2. Afficher les erreurs de validation dans la vue

Laravel fournit une manière simple d’afficher les erreurs de validation directement dans la vue.

Modifiez le fichier resources/views/recipes/create.blade.php pour inclure les messages d’erreur :

@extends('layouts.main')

@section('title', 'Ajouter une recette')

@section('content')
    <h1>Ajouter une nouvelle recette</h1>

    <!-- Affichage des erreurs -->
    @if ($errors->any())
        <div class="alert alert-danger">
            <ul>
                @foreach ($errors->all() as $error)
                    <li>{{ $error }}</li>
                @endforeach
            </ul>
        </div>
    @endif

    <form action="{{ route('recipes.store') }}" method="POST">
        @csrf <!-- Protection contre les attaques CSRF -->

        <div class="mb-3">
            <label for="title" class="form-label">Titre</label>
            <input type="text" id="title" name="title" class="form-control" value="{{ old('title') }}" required>
        </div>

        <div class="mb-3">
            <label for="description" class="form-label">Description</label>
            <textarea id="description" name="description" class="form-control">{{ old('description') }}</textarea>
        </div>

        <div class="mb-3">
            <label for="ingredients" class="form-label">Ingrédients</label>
            <textarea id="ingredients" name="ingredients" class="form-control" required>{{ old('ingredients') }}</textarea>
        </div>

        <div class="mb-3">
            <label for="steps" class="form-label">Étapes</label>
            <textarea id="steps" name="steps" class="form-control" required>{{ old('steps') }}</textarea>
        </div>

        <button type="submit" class="btn btn-success">Enregistrer</button>
        <a href="{{ route('recipes.index') }}" class="btn btn-secondary">Annuler</a>
    </form>
@endsection

2.3. Tester le formulaire

Essayez de soumettre le formulaire sans remplir les champs obligatoires.
Vérifiez que les erreurs de validation sont affichées sous forme de liste rouge.

8. Intégration avec Eloquent

Eloquent est l'ORM (Object-Relational Mapping) intégré de Laravel. Il simplifie les interactions avec la base de données en transformant les tables en classes et les lignes en objets. Dans cette section, nous allons explorer comment lire, ajouter, mettre à jour et supprimer des données en utilisant Eloquent.

1. Introduction à Eloquent

Eloquent permet de manipuler les données d’une base de données comme des objets PHP. Chaque table de votre base de données est représentée par un modèle (par exemple, le modèle Recipe correspond à la table recipes).

1.1. Lire toutes les données avec `Recipe::all()`

La méthode all() récupère toutes les lignes d’une table sous forme de collection d’objets.

Exemple : Lire toutes les recettes
Ajoutez la méthode index dans le RecipeController pour afficher toutes les recettes :

public function index()
{
    $recipes = \App\Models\Recipe::all(); // Récupère toutes les recettes
    return view('recipes.index', compact('recipes')); // Passe les données à la vue
}

Dans la vue recipes/index.blade.php :

@foreach ($recipes as $recipe)
    <li>{{ $recipe->title }}</li>
@endforeach

1.2. Lire une recette spécifique avec `Recipe::find()`

La méthode find($id) permet de récupérer une ligne spécifique en fonction de son identifiant.

Exemple : Lire une recette spécifique
Ajoutez la méthode show dans le RecipeController :

public function show($id)
{
    $recipe = \App\Models\Recipe::find($id); // Récupère une recette par son ID
    if (!$recipe) {
        abort(404, 'Recette non trouvée');
    }
    return view('recipes.show', compact('recipe'));
}

Dans la vue recipes/show.blade.php :

<h1>{{ $recipe->title }}</h1>
<p>{{ $recipe->description }}</p>
<p>{{ $recipe->ingredients }}</p>
<p>{{ $recipe->steps }}</p>

2. Ajouter, mettre à jour et supprimer des recettes

2.1. Ajouter une nouvelle recette avec `create()`

La méthode create() permet de créer une nouvelle entrée dans la base de données. Assurez-vous que le modèle Recipe contient l’attribut $fillable pour les colonnes que vous voulez autoriser à remplir :

namespace App\Models;

use Illuminate\Database\Eloquent\Factories\HasFactory;
use Illuminate\Database\Eloquent\Model;

class Recipe extends Model
{
    use HasFactory;

    protected $fillable = ['title', 'description', 'ingredients', 'steps'];
}

Dans le contrôleur :
Ajoutez la méthode store pour créer une nouvelle recette :

public function store(Request $request)
{
    $validated = $request->validate([
        'title' => 'required|string|max:255',
        'description' => 'nullable|string',
        'ingredients' => 'required|string',
        'steps' => 'required|string',
    ]);

    \App\Models\Recipe::create($validated); // Création de la recette

    return redirect()->route('recipes.index')->with('success', 'Recette ajoutée avec succès !');
}

2.2. Mettre à jour une recette avec `update()`

La méthode update() permet de modifier une ligne existante.

Dans le contrôleur :
Ajoutez la méthode update pour modifier une recette :

public function update(Request $request, $id)
{
    $validated = $request->validate([
        'title' => 'required|string|max:255',
        'description' => 'nullable|string',
        'ingredients' => 'required|string',
        'steps' => 'required|string',
    ]);

    $recipe = \App\Models\Recipe::findOrFail($id); // Récupère la recette
    $recipe->update($validated); // Met à jour avec les nouvelles données

    return redirect()->route('recipes.index')->with('success', 'Recette mise à jour avec succès !');
}

Formulaire d’édition dans recipes/edit.blade.php :

<form action="{{ route('recipes.update', $recipe->id) }}" method="POST">
    @csrf
    @method('PUT') <!-- Méthode HTTP PUT -->
    <input type="text" name="title" value="{{ old('title', $recipe->title) }}" required>
    <textarea name="description">{{ old('description', $recipe->description) }}</textarea>
    <textarea name="ingredients">{{ old('ingredients', $recipe->ingredients) }}</textarea>
    <textarea name="steps">{{ old('steps', $recipe->steps) }}</textarea>
    <button type="submit">Mettre à jour</button>
</form>

2.3. Supprimer une recette avec `delete()`

La méthode delete() permet de supprimer une ligne de la base de données.

Dans le contrôleur :
Ajoutez la méthode destroy pour supprimer une recette :

public function destroy($id)
{
    $recipe = \App\Models\Recipe::findOrFail($id); // Récupère la recette
    $recipe->delete(); // Supprime la recette

    return redirect()->route('recipes.index')->with('success', 'Recette supprimée avec succès !');
}

Formulaire de suppression dans recipes/show.blade.php :

<form action="{{ route('recipes.destroy', $recipe->id) }}" method="POST">
    @csrf
    @method('DELETE') <!-- Méthode HTTP DELETE -->
    <button type="submit" class="btn btn-danger">Supprimer</button>
</form>

9. Pagination et recherche

Dans cette section, nous allons ajouter la pagination pour afficher les recettes par page et implémenter une fonctionnalité de recherche pour permettre aux utilisateurs de trouver des recettes par leur titre ou leur description.

1. Ajouter la pagination aux recettes

La méthode paginate() d’Eloquent permet de diviser les résultats en pages. Laravel génère également les liens de pagination automatiquement.

1.1. Mettre en place la pagination dans le contrôleur

Modifiez la méthode index dans le RecipeController pour utiliser la pagination :

public function index()
{
    $recipes = \App\Models\Recipe::paginate(5); // Récupère 5 recettes par page
    return view('recipes.index', compact('recipes'));
}

1.2. Afficher les liens de pagination dans la vue

Dans le fichier resources/views/recipes/index.blade.php, ajoutez les liens de pagination :

@extends('layouts.main')

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

@section('content')
    <h1 class="mb-4">Liste des recettes</h1>

    <a href="{{ route('recipes.create') }}" class="btn btn-primary mb-3">Ajouter une nouvelle recette</a>

    @if ($recipes->isEmpty())
        <p>Aucune recette disponible.</p>
    @else
        <ul class="list-group mb-3">
            @foreach ($recipes as $recipe)
                <li class="list-group-item">
                    <a href="{{ route('recipes.show', $recipe->id) }}">{{ $recipe->title }}</a>
                </li>
            @endforeach
        </ul>

        <!-- Afficher les liens de pagination -->
        {{ $recipes->links() }}
    @endif
@endsection

Résultat attendu :

Les recettes sont affichées par pages de 5.
Des liens de navigation pour changer de page (précédent, suivant) apparaissent automatiquement en bas de la liste.

2. Implémenter une fonctionnalité de recherche

Nous allons ajouter une barre de recherche pour permettre aux utilisateurs de trouver des recettes par leur titre ou leur description.

Modifiez le fichier resources/views/layouts/main.blade.php pour inclure une barre de recherche dans la navigation :

<nav class="navbar navbar-expand-lg navbar-light bg-light">
    <div class="container">
        <a class="navbar-brand" href="{{ route('recipes.index') }}">Recettes</a>
        <button class="navbar-toggler" type="button" data-bs-toggle="collapse" data-bs-target="#navbarNav">
            <span class="navbar-toggler-icon"></span>
        </button>
        <div class="collapse navbar-collapse" id="navbarNav">
            <form class="d-flex ms-auto" method="GET" action="{{ route('recipes.index') }}">
                <input class="form-control me-2" type="search" name="search" placeholder="Rechercher..." value="{{ request('search') }}">
                <button class="btn btn-outline-success" type="submit">Rechercher</button>
            </form>
        </div>
    </div>
</nav>

2.2. Modifier la méthode `index` pour gérer la recherche

Ajoutez une condition pour filtrer les recettes en fonction du terme de recherche soumis :

public function index(Request $request)
{
    $query = \App\Models\Recipe::query();

    // Filtrer par recherche si un terme est fourni
    if ($request->has('search') && $request->search != '') {
        $query->where('title', 'like', '%' . $request->search . '%')
              ->orWhere('description', 'like', '%' . $request->search . '%');
    }

    // Ajouter la pagination
    $recipes = $query->paginate(5);

    return view('recipes.index', compact('recipes'));
}

2.3. Afficher un message si aucun résultat n’est trouvé

Dans le fichier resources/views/recipes/index.blade.php, ajoutez un message pour les résultats de recherche vides :

@if ($recipes->isEmpty())
    <p>Aucune recette trouvée pour "{{ request('search') }}"</p>
@else
    <ul class="list-group mb-3">
        @foreach ($recipes as $recipe)
            <li class="list-group-item">
                <a href="{{ route('recipes.show', $recipe->id) }}">{{ $recipe->title }}</a>
            </li>
        @endforeach
    </ul>

    {{ $recipes->links() }}
@endif

Résultat attendu

Pagination :

Les recettes sont affichées par pages (5 par page).
Les liens de navigation pour changer de page sont disponibles.

Recherche :

Un champ de recherche permet de soumettre un terme (titre ou description).
Les résultats filtrés s’affichent, ou un message indique qu’aucune recette ne correspond au terme de recherche.

10. Gestion des fichiers (images des recettes)

Dans cette section, nous allons ajouter une fonctionnalité pour permettre le téléchargement et l’affichage des images des recettes. Laravel simplifie la gestion des fichiers avec des outils intégrés pour le stockage local et cloud.

1. Ajouter un champ pour télécharger une image

1.1. Ajouter une colonne pour l’image dans la table `recipes`

Pour stocker le chemin des images dans la base de données, nous devons ajouter une colonne image dans la table recipes.

Créer une migration pour ajouter la colonne image :

php artisan make:migration add_image_to_recipes_table --table=recipes

Modifier la migration générée : Ouvrez le fichier de migration dans le dossier database/migrations et ajoutez la colonne :

public function up()
{
    Schema::table('recipes', function (Blueprint $table) {
        $table->string('image')->nullable(); // Colonne pour le chemin de l'image
    });
}

public function down()
{
    Schema::table('recipes', function (Blueprint $table) {
        $table->dropColumn('image');
    });
}

Exécuter la migration :

php artisan migrate

1.2. Modifier le formulaire pour inclure le téléchargement d’images

Ajoutez un champ pour télécharger une image dans le fichier resources/views/recipes/form.blade.php :

Modifier le formulaire pour inclure l’attribut enctype :

<form action="{{ isset($recipe) ? route('recipes.update', $recipe->id) : route('recipes.store') }}" method="POST" enctype="multipart/form-data">
    @csrf
    @if (isset($recipe))
        @method('PUT')
    @endif

    <!-- Autres champs... -->

    <div class="mb-3">
        <label for="image" class="form-label">Image de la recette</label>
        <input type="file" id="image" name="image" class="form-control">
    </div>

    <button type="submit" class="btn btn-success">Enregistrer</button>
    <a href="{{ route('recipes.index') }}" class="btn btn-secondary">Annuler</a>
</form>

1.3. Gérer les téléchargements d’images dans le contrôleur

Modifiez les méthodes store et update dans le RecipeController pour gérer le téléchargement des images.

Modifier la méthode store :

public function store(Request $request)
{
    $validated = $request->validate([
        'title' => 'required|string|max:255',
        'description' => 'nullable|string',
        'ingredients' => 'required|string',
        'steps' => 'required|string',
        'image' => 'nullable|image|mimes:jpg,jpeg,png|max:2048', // Validation pour l'image
    ]);

    if ($request->hasFile('image')) {
        // Stocker l'image dans le répertoire public
        $imagePath = $request->file('image')->store('recipes', 'public');
        $validated['image'] = $imagePath;
    }

    \App\Models\Recipe::create($validated);

    return redirect()->route('recipes.index')->with('success', 'Recette ajoutée avec succès !');
}

Modifier la méthode update :

public function update(Request $request, $id)
{
    $validated = $request->validate([
        'title' => 'required|string|max:255',
        'description' => 'nullable|string',
        'ingredients' => 'required|string',
        'steps' => 'required|string',
        'image' => 'nullable|image|mimes:jpg,jpeg,png|max:2048',
    ]);

    $recipe = \App\Models\Recipe::findOrFail($id);

    if ($request->hasFile('image')) {
        // Supprimer l'ancienne image si elle existe
        if ($recipe->image) {
            \Storage::disk('public')->delete($recipe->image);
        }

        // Stocker la nouvelle image
        $imagePath = $request->file('image')->store('recipes', 'public');
        $validated['image'] = $imagePath;
    }

    $recipe->update($validated);

    return redirect()->route('recipes.index')->with('success', 'Recette mise à jour avec succès !');
}

2. Afficher les images dans les vues

2.1. Afficher les images dans la liste des recettes

Modifiez le fichier resources/views/recipes/index.blade.php pour inclure les images :

<ul class="list-group mb-3">
    @foreach ($recipes as $recipe)
        <li class="list-group-item d-flex align-items-center">
            @if ($recipe->image)
                <img src="{{ asset('storage/' . $recipe->image) }}" alt="{{ $recipe->title }}" class="me-3" style="width: 50px; height: 50px; object-fit: cover;">
            @endif
            <a href="{{ route('recipes.show', $recipe->id) }}">{{ $recipe->title }}</a>
        </li>
    @endforeach
</ul>

2.2. Afficher l’image dans le détail d’une recette

Modifiez le fichier resources/views/recipes/show.blade.php pour afficher l’image de la recette :

@if ($recipe->image)
    <img src="{{ asset('storage/' . $recipe->image) }}" alt="{{ $recipe->title }}" class="img-fluid mb-3" style="max-width: 100%; height: auto;">
@endif

<h1>{{ $recipe->title }}</h1>
<p><strong>Description :</strong> {{ $recipe->description }}</p>
<p><strong>Ingrédients :</strong></p>
<p>{{ $recipe->ingredients }}</p>
<p><strong>Étapes :</strong></p>
<p>{{ $recipe->steps }}</p>

Configuration du stockage

Laravel utilise le système de fichiers configuré dans le fichier config/filesystems.php. Pour ce tutoriel, nous utilisons le stockage local dans le répertoire storage/app/public.

Créer un lien symbolique pour le stockage public :
Exécutez cette commande pour rendre le dossier storage/app/public accessible depuis public/storage :

php artisan storage:link

Les images téléchargées seront désormais accessibles via l’URL storage/recipes.

11. Sécurité de l'application

La sécurité est un aspect fondamental du développement d'applications. Laravel offre plusieurs mécanismes intégrés pour protéger votre application contre les attaques courantes. Dans cette section, nous allons explorer la protection CSRF, l'implémentation d'une authentification utilisateur, et la limitation de l'accès à certaines fonctionnalités.

1. Protéger les formulaires avec CSRF

Laravel protège automatiquement vos formulaires contre les attaques CSRF (Cross-Site Request Forgery) grâce à un token ajouté dans chaque formulaire.

1.1. Ajouter le token CSRF dans les formulaires

Dans tous vos formulaires Blade, assurez-vous d’inclure la directive @csrf pour générer un token unique :

<form action="{{ route('recipes.store') }}" method="POST">
    @csrf <!-- Token CSRF -->
    <input type="text" name="title" placeholder="Titre de la recette">
    <button type="submit">Enregistrer</button>
</form>

1.2. Vérification automatique du token

Laravel valide automatiquement le token CSRF pour chaque requête POST, PUT, PATCH, ou DELETE. Si le token est manquant ou incorrect, Laravel renvoie une erreur 419 Page Expired.

1.3. Exclure certaines routes (optionnel)

Si vous souhaitez exclure une route de la vérification CSRF, vous pouvez le faire dans le middleware VerifyCsrfToken :

protected $except = [
    '/webhook/*', // Exemple : exclure les webhooks
];

2. Implémenter l'authentification utilisateur (bonus)

Laravel fournit plusieurs outils pour gérer l'authentification des utilisateurs de manière rapide et efficace.

2.1. Installer Laravel Breeze

Laravel Breeze est un package léger pour configurer rapidement l'authentification avec des vues et des fonctionnalités de base.

Installez Laravel Breeze avec Composer :

composer require laravel/breeze --dev

Publiez les fichiers de Breeze :

php artisan breeze:install

Installez les dépendances JavaScript si vous utilisez les vues front-end :

npm install && npm run dev

Exécutez les migrations pour créer les tables nécessaires (comme users) :

php artisan migrate

2.2. Enregistrement et connexion des utilisateurs

Laravel Breeze ajoute les routes suivantes pour gérer l'authentification :

/register : Page d'inscription.
/login : Page de connexion.
/logout : Déconnexion de l'utilisateur.

Ces fonctionnalités sont prêtes à l’emploi et sécurisées.

3. Limiter l'accès à certaines fonctionnalités pour les utilisateurs connectés

Avec l'authentification en place, vous pouvez restreindre l'accès à certaines routes ou fonctionnalités aux utilisateurs connectés.

3.1. Protéger les routes avec le middleware `auth`

Ajoutez le middleware auth à vos routes pour limiter l'accès aux utilisateurs connectés.

Exemple : Protéger les routes de gestion des recettes :

Route::middleware(['auth'])->group(function () {
    Route::get('/recipes/create', [RecipeController::class, 'create'])->name('recipes.create');
    Route::post('/recipes', [RecipeController::class, 'store'])->name('recipes.store');
    Route::get('/recipes/{id}/edit', [RecipeController::class, 'edit'])->name('recipes.edit');
    Route::put('/recipes/{id}', [RecipeController::class, 'update'])->name('recipes.update');
    Route::delete('/recipes/{id}', [RecipeController::class, 'destroy'])->name('recipes.destroy');
});

Les utilisateurs non connectés seront redirigés automatiquement vers la page de connexion.

3.2. Vérifier l'utilisateur dans le contrôleur

Dans un contrôleur, vous pouvez également vérifier si l'utilisateur est authentifié :

public function create()
{
    if (!auth()->check()) {
        return redirect()->route('login');
    }

    return view('recipes.create');
}

3.3. Afficher des fonctionnalités conditionnelles dans la vue

Dans vos fichiers Blade, utilisez la directive @auth pour afficher certains éléments uniquement aux utilisateurs connectés :

@auth
    <a href="{{ route('recipes.create') }}" class="btn btn-primary">Ajouter une recette</a>
@endauth

Pour les utilisateurs non connectés, utilisez @guest :

@guest
    <a href="{{ route('login') }}" class="btn btn-secondary">Se connecter</a>
@endguest

12. Déploiement

Une fois que votre application Laravel est prête, il est temps de la déployer sur un serveur pour la rendre accessible en ligne. Cette section vous guide étape par étape pour préparer et déployer votre application Laravel.

1. Préparer l'application pour le déploiement

Avant de déployer une application Laravel, il est essentiel de la configurer pour l'environnement de production.

1.1. Configurer `.env` pour l'environnement de production

Ouvrez le fichier .env situé à la racine de votre projet.

Assurez-vous de modifier les valeurs suivantes pour correspondre à votre environnement de production :

APP_ENV=production
APP_DEBUG=false
APP_URL=http://votre-domaine.com

DB_CONNECTION=mysql
DB_HOST=127.0.0.1
DB_PORT=3306
DB_DATABASE=nom_de_la_base_de_donnees
DB_USERNAME=nom_utilisateur
DB_PASSWORD=mot_de_passe

APP_ENV : Définissez l'environnement sur production pour activer les optimisations de production.
APP_DEBUG : Mettez false pour éviter d'afficher des informations sensibles en cas d'erreur.
APP_URL : Remplacez par le domaine de votre application.

1.2. Optimiser l'application pour la production

Exécutez la commande suivante pour optimiser l'application Laravel :

php artisan optimize

Cela génère des fichiers de cache pour la configuration et les routes, ce qui améliore les performances.

1.3. Configurer les permissions

Assurez-vous que les permissions des dossiers suivants permettent l’écriture :

storage/
bootstrap/cache/

Vous pouvez définir les permissions avec les commandes suivantes (selon votre serveur) :

chmod -R 775 storage
chmod -R 775 bootstrap/cache

2. Déployer l'application sur un serveur web

2.1. Déployer avec Laravel Forge

Laravel Forge est une plateforme qui facilite le déploiement et la gestion des serveurs Laravel.

Créer un serveur : Connectez Laravel Forge à votre fournisseur de cloud préféré (par exemple, AWS, DigitalOcean, Linode).

Installer Laravel : Forge configure automatiquement un environnement Laravel optimisé sur le serveur.

Déployer votre projet :

Connectez Forge à votre dépôt Git (par exemple, GitHub ou GitLab).
Configurez le déploiement automatique lorsque vous poussez du code vers votre branche principale.

Gérer l'application :

Utilisez Forge pour gérer les tâches comme la configuration SSL, les sauvegardes de base de données, et le monitoring du serveur.

2.2. Déployer sur Heroku

Heroku est une plateforme cloud conviviale pour déployer des applications web.

Installer l’outil CLI Heroku :

Téléchargez et installez l'interface en ligne de commande Heroku depuis https://devcenter.heroku.com/articles/heroku-cli.

Initialiser votre projet Heroku :

Connectez-vous à Heroku :

heroku login

Créez une application Heroku :

heroku create votre-application

Configurer l’environnement Laravel :

Ajoutez les variables d'environnement nécessaires (comme celles de .env) :

heroku config:set APP_ENV=production APP_DEBUG=false ...

Ajouter un buildpack pour PHP :

Heroku utilise des buildpacks pour déployer les applications PHP. Ajoutez le buildpack Laravel/Composer :

heroku buildpacks:set heroku/php

Déployer votre application :

Poussez votre code vers Heroku :

git push heroku main

Base de données :

Configurez une base de données (par exemple, Heroku Postgres) et mettez à jour vos variables d’environnement.

2.3. Déployer sur un serveur partagé

Si vous utilisez un serveur mutualisé (comme cPanel ou Plesk), voici les étapes générales pour déployer Laravel :

Téléverser votre projet :

Téléversez tous les fichiers de votre projet Laravel sur le serveur via FTP ou SFTP.
Placez les fichiers dans le dossier public_html ou un répertoire similaire.

Déplacer le dossier public/ :

Déplacez le contenu du dossier public/ à la racine du serveur (public_html).

Mettez à jour les chemins dans index.php pour inclure les fichiers du projet :

require __DIR__.'/../vendor/autoload.php';
$app = require_once __DIR__.'/../bootstrap/app.php';

Configurer .env :

Mettez à jour le fichier .env pour refléter la configuration de votre serveur (base de données, URL, etc.).

Installer les dépendances avec Composer :

Accédez à votre projet via SSH et exécutez :

composer install --optimize-autoloader --no-dev

Créer un lien symbolique pour le stockage :

Si nécessaire, créez un lien symbolique pour rendre le dossier storage accessible :

php artisan storage:link

Migrations et cache :

Exécutez les migrations pour configurer la base de données :

php artisan migrate --force

Mettez à jour les caches de configuration et de routes :

php artisan config:cache
php artisan route:cache

Conclusion

1. Récapitulatif des concepts appris

Au cours de ce tutoriel, vous avez construit une application de gestion de recettes avec Laravel tout en apprenant les bases de ce framework puissant. Voici un récapitulatif des concepts abordés :

Architecture MVC :

Comprendre la séparation entre Modèle, Vue et Contrôleur pour structurer proprement une application.

Migrations :

Créer et modifier des tables dans une base de données de manière versionnée et reproductible.

Eloquent ORM :

Manipuler les données de la base de données comme des objets en utilisant des modèles Laravel.

Blade :

Construire des interfaces dynamiques en utilisant le moteur de templates Blade, avec des directives telles que @extends, @section, et @foreach.

Validation et sécurité :

Valider les données des formulaires pour garantir leur intégrité.
Protéger les formulaires contre les attaques CSRF.

Pagination et recherche :

Diviser les résultats en pages et permettre aux utilisateurs de rechercher des recettes.

Gestion des fichiers :

Permettre aux utilisateurs de téléverser et d’afficher des images dans l’application.

Authentification et autorisation :

Implémenter une gestion utilisateur pour limiter l’accès à certaines fonctionnalités.

Déploiement :

Préparer et déployer une application Laravel en production sur un serveur ou une plateforme cloud.

2. Suggestions pour aller plus loin

Vous avez maintenant une application fonctionnelle et une bonne compréhension des bases de Laravel. Voici quelques idées pour enrichir votre application et approfondir vos connaissances :

Ajouter des catégories de recettes :

Permettez aux utilisateurs de classer les recettes par catégories (par exemple, "Desserts", "Plats principaux").
Implémentez une relation hasMany/belongsTo entre les recettes et les catégories.

Implémenter un système de notation ou de commentaires :

Autorisez les utilisateurs à noter une recette (ex. 1 à 5 étoiles).
Ajoutez des commentaires pour permettre aux utilisateurs de partager leur avis.

Créer une API REST :

Exposez votre application via une API REST pour permettre son intégration avec une application mobile ou d'autres systèmes.
Utilisez Laravel Sanctum pour gérer l'authentification API.

Ajouter des notifications :

Implémentez des notifications (par email ou en temps réel) pour informer les utilisateurs, par exemple, lorsqu’une nouvelle recette est ajoutée.

Créer un tableau de bord admin :

Ajoutez un espace administrateur pour gérer les recettes, les utilisateurs, et les catégories.

Optimisation des performances :

Utilisez la mise en cache avec Laravel Cache.
Configurez un système de files d’attente pour les tâches lourdes (ex. traitement d’images).