Aller au contenu

2. Gestion des catégories⚓︎

Dans ce TP nous allons réaliser une application web, « TODO » ou aussi appelé liste de tâches.
Une TODO List est un procédé qui se veut simple et efficace pour gérer les tâches d'un projet. Ces tâches peuvent être indépendantes ou devoir, au contraire, être accomplies dans un certain ordre. Ces tâches pourront également être catégorisées (pro, perso, famille, ...).

Voilà la liste des fonctionnalités de l’application que l'on va ajouter :

  • attribuer une ou plusieurs catégories pour chaque Todo
  • Création d'une page de recherche

2.1 Gestion de la catégorie⚓︎

2.1.1 Relation Many To Many⚓︎

On va avoir besoin de déclarer qu'un todo peut appartenir à plusieurs catégories et une catégorie classifie plusieurs todos. La relation est symétrique.

On ajoute l'espace de noms nécessaire à la gestion de cette relation dans les 2 models.

🐘 PHP
use Illuminate\Database\Eloquent\Relations\BelongsToMany;

Puis à l'intérieur de la classe, on ajoute les méthodes d'association.

Dans Todos.php

🐘 PHP
    public function categories(): BelongsToMany
        {
            return $this->belongsToMany(Categories::class);
        }
code complet de Todos.php
🐘 PHP
<?php
namespace App\Models;

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

class Todos extends Model
{
    use HasFactory;

    protected $fillable = ['texte', 'termine', 'important'];

    public function categories(): BelongsToMany
    {
        return $this->belongsToMany(Categories::class);
    }
}

Dans Categories.php

🐘 PHP
    public function todos(): BelongsToMany
        {
            return $this->belongsToMany(Todos::class);
        }
code complet de catégories.php
🐘 PHP
<?php

namespace App\Models;


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

class Categories extends Model
{
    use HasFactory;

    public function todos(): BelongsToMany
    {
        return $this->belongsToMany(Todos::class);
    }
}

On déclare ici avec la méthode todos (au pluriel) qu’une catégorie appartient à plusieurs (belongsToMany) todos (Todos). On aura ainsi une méthode pratique pour récupérer les todos d’une catégorie. Idem pour les catégories.

2.1.2 Le seeder⚓︎

On fait le choix de ne pas créer d'interface pour ajouter les catégories (Mais vous pouvez le faire ).
On va donc faire une saisie directement en Base de données. Mais en phase de mise au ppoint d'application, vous vous êtes rendu compte que l'on peut avoir besoin de flasher sa base. Ce qui peut être facheux lorsque l'on souhaite conserver quleques données. On va donc passer par de seeders, intégré à la Laravel, ce sont des scripts qui permettront des injections de données en Base, comme pour les tables de paramétrages ou des jeux de données.

Chat GPT

Il peut être tres pratique d'utiliser une IA pour générer ses seeders. Vous trouverez ci dessous la question poser à chatGPT pour générer le CategoriesTableSeeder.

Je travaille dans le contexte Laravel 10 pour créer une application de gestion de taches.
Une tache peut être affecter à une catégorie : pro, famille, sport, associatif par exemple.
Ci dessous le code de la migration de la table :

hp public function up(): void { Schema::create('categories', function (Blueprint $table) { $table->integer('idcat'); $table->string('libelle'); $table->primary('idcat'); $table->timestamps(); }); } Peux tu me donner le seeder correspondant ?

On va créer un nouveau fichier dans le répertoire database\seeders, qui contiendra les données à injecter en table. On pourra l'exécuter directement en utilisant la commande suivante :

📋 Texte
php artisan db:seed --class=CategoriesSeeder
Code de CategoriesSeeder
🐘 PHP
<?php
namespace Database\Seeders;

use Illuminate\Database\Seeder;
use Illuminate\Support\Facades\DB;
use Illuminate\Support\Facades\Hash;
use Illuminate\Support\Str;

class CategoriesSeeder extends Seeder
{
    /**
     * Run the database seeds.
     *
     * @return void
     */
    public function run()
    {
        $categories = [
            ['idcat' => 1, 'libelle' => 'Pro'],
            ['idcat' => 2, 'libelle' => 'Famille'],
            ['idcat' => 3, 'libelle' => 'Sport'],
            ['idcat' => 4, 'libelle' => 'Associatif'],
            // Ajoutez d'autres catégories au besoin
        ];

        // Insertion des données dans la table 'categories'
        DB::table('categories')->insert($categories);
    }
}
?>

On va également ajouter un seeder à la propriété $seeders du fichier DatabaseSeeder.php afin qu'il soit exécuté lors de la commande php artisan db:seed.

Code de DatabaseSeeder
🐘 PHP
class DatabaseSeeder extends Seeder
{
    /**
     * Seed the application's database.
     */
    public function run(): void
    {
        //Ajout de la classe CategoriesSeeder
        $this->call([
            CategoriesSeeder::class,
        ]);
    }
}

Lorsque est lancé la commande de (re)création de la base, on peut ajouter l'option --seed pour alimenter les tables avec un jeu de test

📋 Texte
php artisan migrate:fresh --seed

php artisan migrate:fresh --seed --seeder=CategoriesSeeder
▶️ A faire : Ajouter un seeder pour Todo

2.1.3 Le controller Catégorie⚓︎

▶️ Générer le controller de Catégorie en ligne de commande.

solution au cas où
🐘 PHP
php artisan make:controller CategoriesController

▶️ Ajouter le code pour récupérer la liste des catégorie

code de categoriesController
🐘 PHP
/**
 * Affiche la liste des catégories.
 *
 * @return \Illuminate\Http\Response
 */
public function listeCatégories()
{
    return view("home", ["categories" => Categories::all()]);
}

▶️ Pour afficher la liste des Todos, on utilise le controller Todo. On va donc ajouter à l'appel de la liste des Todos, la liste des catégories. ‼️ Ne pas oublier de faire les import de librairies nécessaires.

code liste() dans todocontroller
🐘 PHP
//Liste
public function liste()
{
    return view("home", ["todos" => Todos::all(), "categories" => Categories::all()]);
}

▶️ Conclusion : ici on ne se sert pas du controller Categories.

2.1.4 La vue home pour ajouter les catégories⚓︎

On va d'abord ajouter dans la liste des Todos, l'affichage des catégories.

Dans la liste des Todos

Code dans home pour la liste des catégorie
🐘 PHP
<!-- Affichage du texte -->
<span>{{ $todo->texte }}</span>
    <!-- Affichage de la catégorie -->
    <p>Catégories :</p>
        <ul>
            @foreach($todo->categories as $category)
                <li>{{ $category->libelle }}</li>
             @endforeach
            </ul>
    </p>

Puis dans le formulaire de saisie d'un Todo

Code dans home pour les boites à cocher
🐘 PHP
 <!-- boites à cocher pour les catégories -->
<div class="form-group">
<label>Catégories</label>
    @foreach($categories as $categorie)
        <div class="form-check">
            <input class="form-check-input" type="checkbox" name="categories[]" value="{{ $categorie->id }}">
            <label class="form-check-label">{{ $categorie->libelle }}</label>
        </div>
    @endforeach
</div>

Remarquez que le nom du select est accompagné de crochets (categories[]) pour signifier qu’on va envoyer un tableau de valeurs dans la requête HTTP.

👀 Ne pas tester encore à cette étape, le travail n'est pas fini.

2.1.5 Afficher les catégories d'un Todo⚓︎

On est dans une relation n:n, il faudrait donc gérer en théorie des requêtes de jointures entre les tables pour afficher le libellé de chaque catégorie pour un Todo. On va utiliser de la ✨ magie de Laravel pour lui laisser cette tâche.

💥 Le souci est que cette méthode va nous obliger à revoir le nom des champs des noms pour laisser à Laravel le soin de faire ses jointures. Et donc normaliser les noms des clés primaires, qui devront impérativement être de id et normaliser également le nom des tables nom_table=nom_Controller


💢 Je vous invite à debugger par vous même votre application. Il va falloir supprimer la migration categories pour recréer une nouvelle migration "propre".

Solutions

▶️ Créer la migration de la table d'association create_categories_todos_table. et supprimer celle decategorise`.

🐘 PHP
public function up(): void
{
    Schema::create('categories_todos', function (Blueprint $table) {
        $table->integer('categories_id');
        $table->integer('todos_id');
        //Clé primaire composée
        $table->primary(['categories_id', 'todos_id']);
        //Clés étrangères
        $table->foreign('categories_id')->references('id')->on('categories');
        $table->foreign('todos_id')->references('id')->on('todos')->onDelete('cascade');

        $table->timestamps();
    });
}
▶️ Reprendre la migration de la table catégories

🐘 PHP
 public function up(): void
{
    Schema::create('categories', function (Blueprint $table) {
        $table->integer('id');
        $table->string('libelle');
        //Clé primaire
        $table->primary('id');
        $table->timestamps();
    });
}

▶️ Reprendre la migration de la table Todos

🐘 PHP
public function up(): void
{
    Schema::create('todos', function (Blueprint $table) {
        $table->integer('id')->autoIncrement();
        $table->string('texte');
        $table->boolean('termine')->default(0);
        $table->boolean('important')->default(0);

        #Déclaraction de la clé primaire
        $table->primary('id');

        $table->timestamps();
        /*Utilisation du softDelete*/
        $table->softDeletes();
    });
}

▶️ Relancer la migration et les seeders php artisan migrate:fresh --seed

2.1.6 Adapter le code de SaveTodo pour enregister la catégorie du Todo⚓︎

Pour la gestion de la catégorie, je vous rappelle que nous avons déjà géré les jointures par magie ✨. On va continuer à utiliser cette mécanique pour la sauvegarde.
On envoie par la vue home un tableau de catégories name="categories[]". Lisez un peu de documentation ici et essayer de l'adapter à votre projet.

Solution
🐘 PHP
public function saveTodo(Request $request){
    //....
        $todo->save();
        $todo->categories()->attach($cats); /*A ajouter */
        return redirect()->route('todo.liste');
    } else{
        return redirect()->route('todo.liste')->with('message', "Veuillez saisir une note à ajouter");
    }

}

2.1.7 Delete un ToDo⚓︎

Si vous essayer de supprimer un Todo, à cette étape, cela va provoquer une erreur d'intégrité référentielle.

▶️ A Faire : Trouver la solution pour supprimer l'association catégorie_todo en cascade d'un ToDo.

solution

Il faut modifier la migration de Todo pour ajouter la fonction SQL de deleteOnCascade.

🐘 PHP
public function up(): void
{
    Schema::create('categories_todos', function (Blueprint $table) {
        $table->integer('categories_id');
        $table->integer('todos_id');

        $table->foreign('categories_id')->references('id')->on('categories');
        $table->foreign('todos_id')->references('id')->on('todos')
            ->onDelete('cascade');

        $table->primary(['categories_id', 'todos_id']);
        $table->timestamps();
    });
}

👀 relancer la migration et Tester !

2.2 La notion de softDelete⚓︎

Documentation

les soft deletes permettent de marquer un enregistrement comme "supprimé" sans le supprimer réellement de la base de données. Cela peut être utile dans de nombreux cas, par exemple lorsque vous avez des enregistrements que vous ne voulez pas supprimer définitivement, mais que vous voulez simplement cacher aux utilisateurs.

Pour utiliser les soft deletes sur vos modèles, vous devez d'abord ajouter le trait softDeletes à votre classe Model Todos.php:

code de Todos.php
🐘 PHP
<?php

namespace App\Models;

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

use Illuminate\Database\Eloquent\SoftDeletes;

class Todos extends Model
{
    use HasFactory;
    use SoftDeletes;

    protected $fillable = ['texte', 'termine', 'important'];

    public function categories(): BelongsToMany
    {
        return $this->belongsToMany(Categories::class);
    }


}

Ensuite, vous devez ajouter une colonne de type "deleted_at" à votre table. Vous pouvez le faire en ajoutant simplement la date colonne suivante à votre migration :

migration Todo
🐘 PHP
public function up(): void
{
    Schema::create('todos', function (Blueprint $table) {
        $table->integer('id')->autoIncrement();
        #$table->primary('id');
        $table->string('texte');
        $table->boolean('termine')->default(0);
        $table->boolean('important')->default(0);

        $table->timestamps();
        /*Utilisation du softDelete*/
        $table->softDeletes();
    });
}

Une fois que vous avez ajouté la colonne, vous pouvez commencer à utiliser la fonctionnalité soft deletes. Pour "supprimer" un enregistrement, en appelant la méthode delete(), cela va mettre à jour la colonne deleted_at avec la date et l'heure actuelles, ce qui marquera l'enregistrement comme supprimé. ❗️ Attention, dans notre cas, on ne peut supprimer un ToDo que si il est "terminé". Vous devez donc laisser la structure conditionnelle dans lequel est votre appel de delete().

🐘 PHP
$todo = Todos::find($id);
        if($todo->termine == 1){
            $todo->delete();
        }

2.3 Les groupes de routes⚓︎

Au fil du TP, le fichier routes/web.php s'allonge et les routes se ressemblent : elles appellent le même controller, commencent par le même préfixe d'URL (/action/...) et ont des noms qui commencent tous par todo.. Répéter ces informations sur chaque ligne alourdit le code et multiplie les risques d'erreur (une faute de frappe dans un nom de controller, un préfixe oublié...).

Laravel permet de regrouper les routes qui partagent des informations communes : on déclare ces informations une seule fois, et elles s'appliquent à toutes les routes du groupe. C'est l'application du principe DRY (Don't Repeat Yourself).

2.3.1 Grouper par controller⚓︎

Sans groupe, chaque route précise son controller :

🐘 PHP
Route::post('/action/add', [TodosController::class, 'saveTodo'])->name('todo.save');
Route::get('/action/done/{id}', [TodosController::class, 'markAsDone'])->name('todo.done');
Route::get('/action/delete/{id}', [TodosController::class, 'deleteTodo'])->name('todo.delete');
Route::get('/action/lower/{id}', [TodosController::class, 'lowerPriority'])->name('todo.lower');
Route::get('/action/raise/{id}', [TodosController::class, 'raisePriority'])->name('todo.raise');

Avec Route::controller(), le controller est déclaré une seule fois, et chaque route n'indique plus que le nom de la méthode à appeler :

Code de web.php
🐘 PHP
Route::controller(TodosController::class)->group(function () {
    Route::post('/action/add', 'saveTodo')->name('todo.save');
    Route::get('/action/done/{id}' , 'markAsDone')->name('todo.done');
    Route::get('/action/delete/{id}', 'deleteTodo')->name('todo.delete');
    Route::get('/action/lower/{id}',  'lowerPriority')->name('todo.lower');
    Route::get('/action/raise/{id}', 'raisePriority')->name('todo.raise');
});

‼️ Ne pas oublier l'import du controller en haut du fichier : use App\Http\Controllers\TodosController;

2.3.2 Les autres attributs de groupe⚓︎

D'autres informations communes peuvent être mises en facteur, et elles peuvent se combiner entre elles :

Méthode Rôle Exemple
controller() controller commun à toutes les routes Route::controller(TodosController::class)
prefix() début d'URL commun Route::prefix('action') → /action/add
name() début de nom de route commun Route::name('todo.') → todo.save
middleware() traitement appliqué avant chaque route (authentification, par exemple) Route::middleware('auth')

En combinant prefix(), name() et controller(), notre groupe devient :

🐘 PHP
Route::prefix('action')->name('todo.')->controller(TodosController::class)->group(function () {
    Route::post('/add', 'saveTodo')->name('save');            // URL /action/add,        nom todo.save
    Route::get('/done/{id}', 'markAsDone')->name('done');     // URL /action/done/{id},  nom todo.done
    Route::get('/delete/{id}', 'deleteTodo')->name('delete'); // URL /action/delete/{id}, nom todo.delete
    Route::get('/lower/{id}', 'lowerPriority')->name('lower');
    Route::get('/raise/{id}', 'raisePriority')->name('raise');
});

👀 Les URL et les noms de routes obtenus sont exactement les mêmes qu'avant : les vues qui utilisent route('todo.save') n'ont pas besoin d'être modifiées.

❗️ Le . à la fin de name('todo.') est indispensable : sans lui, la route s'appellerait todosave.

2.3.3 Vérifier ses routes⚓︎

La commande suivante affiche toutes les routes de l'application, avec leur méthode HTTP, leur URL, leur nom et la méthode du controller appelée. C'est le premier réflexe à avoir en cas d'erreur Route [...] not defined ou de page 404.

📋 Texte
php artisan route:list

On peut filtrer l'affichage, par exemple pour n'afficher que les routes dont le nom commence par todo :

📋 Texte
php artisan route:list --name=todo

2.3.4 A faire⚓︎

▶️ A faire : réorganiser votre fichier web.php :

  1. regrouper toutes les routes de TodosController, y compris celle de la liste (todo.liste), dans un seul groupe controller() ;
  2. pour les routes d'action, utiliser en plus prefix('action') ;
  3. vérifier avec php artisan route:list que les URL et les noms des routes n'ont pas changé, puis tester l'application.

Les nouvelles routes des user stories (2.4) seront à ajouter dans ce groupe.

2.4 User Story⚓︎

Une user story décrit une fonctionnalité du point de vue de l'utilisateur, sous la forme : En tant que ... je souhaite ... afin de .... Elle est accompagnée de critères d'acceptation qui permettent de vérifier que la fonctionnalité est terminée.

2.4.1 US1 : Une nouvelle page : Recherche⚓︎

User story : On souhaite créer une page de Recherche par mot clé. Cette page disposera d'un champ texte pour saisir un mot-clé. A la validation de ce formulaire, l'application retournera tous les Todos contenant ce mot-clé dans leur texte, y compris dans les ToDos déjà supprimés.

✅ Critères d'acceptation :

  • un lien depuis la page d'accueil permet d'accéder à la page de recherche ;
  • la page contient un formulaire avec un champ texte et un bouton de validation ;
  • la recherche ne tient pas compte de la position du mot-clé dans le texte (début, milieu ou fin) ;
  • les Todos supprimés (softDelete) apparaissent dans les résultats et sont signalés comme tels ;
  • si aucun Todo ne correspond, un message l'indique ;
  • si le champ est vide, l'application affiche un message plutôt que de lancer la recherche.

▶️ A faire : créer la route (dans le groupe de routes de TodosController), la méthode du controller et la vue recherche.blade.php.

Pistes
  • La recherche partielle se fait en SQL avec l'opérateur LIKE et le joker %.
  • Par défaut, Eloquent exclut les enregistrements supprimés : regardez du côté de la méthode withTrashed().
  • Pour savoir dans la vue si un Todo est supprimé : $todo->trashed().

2.4.2 US2 : Compteur⚓︎

User story : En tant qu'utilisateur, je souhaite disposer d'une page Compteur qui m'indique combien de Todos sont à faire, terminés et supprimés, afin d'avoir une vue d'ensemble de mon avancement.

✅ Critères d'acceptation :

  • un lien depuis la page d'accueil permet d'accéder à la page Compteur, et un lien permet d'en revenir ;
  • la page affiche le nombre de Todos à faire (non terminés) ;
  • elle affiche le nombre de Todos terminés (non supprimés) ;
  • elle affiche le nombre de Todos supprimés (softDelete) ;
  • les compteurs sont à jour après chaque action (ajout, terminer, supprimer).

▶️ A faire :

  1. ajouter une nouvelle route dans le groupe de routes de TodosController ;
  2. ajouter une nouvelle fonction viewCompteur() dans TodosController ;
  3. créer une nouvelle vue compteur.blade.php ;
  4. ajouter un lien vers la page Compteur dans la vue home.

‼️ Les compteurs doivent être calculés par la base de données (requêtes COUNT), et non en récupérant tous les Todos pour les compter en PHP avec une boucle.

Pistes
  • Eloquent propose la méthode count() à la fin d'une requête : Todos::where(...)->count().
  • Par défaut, Eloquent exclut les Todos supprimés. Pour ne compter que les Todos supprimés : onlyTrashed().
  • La fonction PHP compact() permet de transmettre plusieurs variables à la vue en une seule fois.

Éléments de correction 🎓

1. La route : dans routes/web.php, à ajouter dans le groupe de routes de TodosController.

🐘 PHP
Route::controller(TodosController::class)->group(function () {
    // ... routes existantes
    Route::get('/compteur', 'viewCompteur')->name('todo.compteur');
});

2. La fonction du controller : dans app/Http/Controllers/TodosController.php.

🐘 PHP
/**
 * Affiche la page Compteur : nombre de Todos à faire, terminés et supprimés.
 */
public function viewCompteur()
{
    $compteNonTerm = Todos::where('termine', 0)->count();
    $compteTerm    = Todos::where('termine', 1)->count();
    $compteSuppr   = Todos::onlyTrashed()->count();

    return view('compteur', compact('compteNonTerm', 'compteTerm', 'compteSuppr'));
}

Chaque ligne génère une requête SQL SELECT COUNT(*) : c'est la base de données qui compte, aucune donnée n'est chargée en mémoire. La version avec Todos::all() et une boucle foreach donne le même résultat pour les deux premiers compteurs, mais charge tous les Todos en mémoire et ne peut pas compter les Todos supprimés, que all() exclut.

❗️ Todos::all()->count() ne compte pas les Todos supprimés, mais tous les Todos non supprimés. Seul onlyTrashed() permet d'obtenir les Todos marqués par le softDelete.

3. La vue : nouveau fichier resources/views/compteur.blade.php, à intégrer dans votre gabarit.

HTML
<h1>Compteur</h1>

<table class="table">
    <tr>
        <th>Todos à faire</th>
        <td>{{ $compteNonTerm }}</td>
    </tr>
    <tr>
        <th>Todos terminés</th>
        <td>{{ $compteTerm }}</td>
    </tr>
    <tr>
        <th>Todos supprimés</th>
        <td>{{ $compteSuppr }}</td>
    </tr>
</table>

<a href="{{ route('todo.liste') }}">Retour à la liste</a>

4. Le lien : dans la vue home.

HTML
<a href="{{ route('todo.compteur') }}">Compteur</a>

▶️ Pour aller plus loin :

  • afficher le nombre de Todos par catégorie, avec Categories::withCount('todos')->get() : Laravel ajoute un attribut todos_count à chaque catégorie ;
  • afficher la progression terminés / total en pourcentage, en prenant garde au cas où il n'y a aucun Todo (division par zéro).