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.
use Illuminate\Database\Eloquent\Relations\BelongsToMany;
Puis à l'intérieur de la classe, on ajoute les méthodes d'association.
Dans Todos.php
public function categories(): BelongsToMany
{
return $this->belongsToMany(Categories::class);
}
code complet de Todos.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
public function todos(): BelongsToMany
{
return $this->belongsToMany(Todos::class);
}
code complet de catégories.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 :
php artisan db:seed --class=CategoriesSeeder
Code de CategoriesSeeder
<?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
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
php artisan migrate:fresh --seed
php artisan migrate:fresh --seed --seeder=CategoriesSeeder
2.1.3 Le controller Catégorie⚓︎
Générer le controller de Catégorie en ligne de commande.
solution au cas où
php artisan make:controller CategoriesController
Ajouter le code pour récupérer la liste des catégorie
code de categoriesController
/**
* 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
//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
<!-- 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
<!-- 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`.
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();
});
}
catégories
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
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
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.
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⚓︎
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
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
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().
$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 :
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
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 :
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.
php artisan route:list
On peut filtrer l'affichage, par exemple pour n'afficher que les routes dont le nom commence par todo :
php artisan route:list --name=todo
2.3.4 A faire⚓︎
A faire : réorganiser votre fichier
web.php :
- regrouper toutes les routes de
TodosController, y compris celle de la liste (todo.liste), dans un seul groupecontroller(); - pour les routes d'action, utiliser en plus
prefix('action'); - vérifier avec
php artisan route:listque 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
LIKEet 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 :
- ajouter une nouvelle route dans le groupe de routes de
TodosController; - ajouter une nouvelle fonction
viewCompteur()dansTodosController; - créer une nouvelle vue
compteur.blade.php; - 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.
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.
/**
* 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.
<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.
<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 attributtodos_countà chaque catégorie ; - afficher la progression
terminés / totalen pourcentage, en prenant garde au cas où il n'y a aucun Todo (division par zéro).