Découverte des notions fondamentales de Laravel à travers un cas concret.

Sommaire

1. Création du modèle
2. Création du contrôleur
3. Création des vues
4. Validation des données
5. Contrôle d’accès
6. Les tests

La génération du contrôleur

Le rôle du contrôleur est de prendre en considération les paramètres d’une requête http, d’appeler les services nécessaires pour répondre au besoin et de transmettre les éléments résultants à la vue.

Une bonne pratique est de limiter les responsabilités du contrôleur afin qu’il serve littéralement de passe-plat.

L’objet de notre contrôleur est la gestion de nos restaurants, c’est important de bien séparer la gestion des ressources nottament car Laravel nous permet de spécifier le modèle qui va être la cible de notre contrôleur lors de la génération de celui-ci via la commande :

1php artisan make:controller --model Restaurant RestaurantController

On obtient le fichier app/Http/Controllers/RestaurantController.php qui contient nos méthodes, il ne reste plus qu’à remplir !

A noter que la validation des données sera détaillée lors du prochain chapitre. Ici le contenu des entrées de l'utilisateur n'est pas vérifié !

La lecture de ressources

Maintenant que notre contrôleur existe, nous allons lui donner la capacité de rendre une ou plusieurs ressources.

Commençons par la méthode index, celle-ci sert à rendre la liste de ressources. Cette liste peut être paginée, filtrée ou ordonnée en fonction du besoin.

Nous allons développer le cas le plus simple, c’est à dire tout rendre :

 1/**
 2 * Display a listing of the resource.
 3 *
 4 * @return \Illuminate\Http\Response
 5 */
 6public function index()
 7{
 8    $restaurants = Restaurant::all();
 9 
10    return view(
11        'restaurants.index',
12        ['restaurants' => $restaurants]
13    );
14}

Donc, on récupère l’ensemble des restaurants et on les transmets à la vue restaurants.index sur laquelle nous reviendrons dans un prochain chapitre.

Autre méthode dédié à la lecture, la méthode show qui a la responsabilité de rendre une unique ressource :

 1/**
 2 * Display the specified resource.
 3 *
 4 * @param  \App\Models\Restaurant  $restaurant
 5 * @return \Illuminate\Http\Response
 6 */
 7public function show(Restaurant $restaurant)
 8{
 9     return view(
10         'restaurants.show',
11         ['restaurant' => $restaurant]
12     );
13}

Ici, la spécificité réside dans le fait que le restaurant cible est disponible en paramètre de la méthode. C’est le binding, notion qu’on abordera un peu plus loin lors de la déclaration des routes.

L’écriture d’une ressource

Comment créer une ressource ? C’est ce qu’on va voir avec le formulaire et l’interprétation de celui-ci.

On commence par la méthode dédiée à l’affichage du formulaire de création d’une ressource, c’est la méthode create :

1/**
2 * Show the form for creating a new resource.
3 *
4 * @return \Illuminate\Http\Response
5 */
6public function create()
7{
8    return view('restaurants.create');
9}

Aucune complexité particulière, on retourne la vue qui contiendra le formulaire.

Viens en retour, la méthode qui doit interpréter les entrées du formulaire pour créer notre ressource, c’est la méthode store :

 1/**
 2 * Store a newly created resource in storage.
 3 *
 4 * @param  \Illuminate\Http\Request  $request
 5 * @return \Illuminate\Http\Response
 6 */
 7public function store(Request $request)
 8{
 9    $restaurant = Restaurant::make(
10        $request->only('name', 'address', 'type')
11    );
12 
13    $request->user()->restaurants()->save(
14        $restaurant
15    );
16 
17    return redirect()->route('restaurants.index');
18}

Le premier bloc d’instruction consiste à instancier notre restaurant avec les entrées du formulaire récupérer dans l’objet $request. Le second vise à associer le restaurant à l’utilisateur connecté disponible via la méthode $request->user().

Enfin, on effectue une redirection vers la page index.

Ce choix de redirection est arbitraire, vous pouvez très bien choisir de rediriger l’utilisateur vers la page show ou la page d’édition du restaurant.

L’édition d’une ressource

Prochaine étape, l’édition d’une ressource existante, tout comme la création on va distinguer la méthode d’affichage du formulaire de celle qui va l’interpréter.

Le formulaire d’édition est délivré par la méthode edit :

 1/**
 2 * Show the form for editing the specified resource.
 3 *
 4 * @param  \App\Models\Restaurant  $restaurant
 5 * @return \Illuminate\Http\Response
 6 */
 7public function edit(Restaurant $restaurant)
 8{
 9    return view(
10        'restaurants.edit',
11        ['restaurant' => $restaurant]
12    );
13}

Très semblable à la méthode create ci ce n’est qu’on injecte le restaurant dans la vue pour afficher ses propriétés dans le formulaire.

S’en suit la méthode update qui a la responsabilité d’enregistrer les modifications du restaurant énoncées dans le formulaire :

 1/**
 2 * Update the specified resource in storage.
 3 *
 4 * @param  \Illuminate\Http\Request  $request
 5 * @param  \App\Models\Restaurant  $restaurant
 6 * @return \Illuminate\Http\Response
 7 */
 8public function update(Request $request, Restaurant $restaurant)
 9{
10    $restaurant->update(
11        $request->only('name', 'address', 'type')
12    );
13 
14    return redirect()->route('restaurants.index');
15}

On utilise la méthode $restaurant->update() pour prendre en considération les entrées du formulaire et on redirige vers la page index.

La suppression d’une ressource

Enfin, il nous reste la méthode qui exécute la suppression d’une ressource, c’est la méthode destroy :

 1/**
 2 * Remove the specified resource from storage.
 3 *
 4 * @param  \App\Models\Restaurant  $restaurant
 5 * @return \Illuminate\Http\Response
 6 */
 7public function destroy(Restaurant $restaurant)
 8{
 9    $restaurant->delete();
10 
11    return redirect()->route('restaurants.index');
12}

Le restaurant est supprimé de la base avec la méthode delete() puis on redirige vers la page index.

La liaison avec les routes

Dans Laravel, une route permet de diriger une requête http vers une méthode spécifique d’un contrôleur.

Elles sont présentes dans le fichier routes/web.php.

J’ignore volontairement les autres fichiers qui sont liés à des besoins spécifiques.

On va déclarer la route pour la méthode index de nôtre contrôleur qui va nous servir de cobaye :

1use App\Http\Controllers\RestaurantController;
2 
3Route::get('/restaurants', [RestaurantController::class, 'index'])
4    ->name('restaurants.index');

Le premier élément notable est l’appelle à la méthode get qui définit le verbe à utiliser pour appeler cette route. Il existe post, patch, put et delete.

Cette méthode dispose de deux paramètres, le premier désigne l’url cible de la route, elle peut contenir des paramètres on le verra après. Le second est un tableau dont la première entrée est la classe du contrôleur et le la seconde est la méthode cible du contrôleur.

Enfin, l’appel à la méthode name permet de donner un nom à notre route, ce qui facilite son utilisation dans le reste de l’application.

Voilà pour la description d’une route basique, maintenant on complète les routes nécessaires à la gestion de nos restaurants :

 1use App\Http\Controllers\RestaurantController;
 2 
 3Route::get('/restaurants/create', [RestaurantController::class, 'create'])
 4    ->name('restaurants.create');
 5 
 6Route::post('/restaurants', [RestaurantController::class, 'store'])
 7    ->name('restaurants.store');
 8 
 9Route::get('/restaurants/{restaurant}', [RestaurantController::class, 'show'])
10    ->name('restaurants.show');
11 
12Route::get('/restaurants/{restaurant}/edit', [RestaurantController::class, 'edit'])
13    ->name('restaurants.edit');
14 
15Route::put('/restaurants/{restaurant}', [RestaurantController::class, 'update'])
16    ->name('restaurants.update');
17 
18Route::delete('/restaurants/{restaurant}', [RestaurantController::class, 'destroy'])
19    ->name('restaurants.destroy');

A noter ici la déclaration du paramètre {restaurant} dans l’url qui permet de définir l’emplacement attendu de l’id du restaurant. C’est ce paramètre, qui permet le binding vers le modèle Restaurant et donc de retrouver l’instance en paramètre de la méthode cible.

On viens de déclarer les 7 routes liées à chacune des méthodes de notre contrôleur, mais étant donné qu'on a respecté le standard de Laravel relatif à la nomenclature des routes, nous pouvons les remplacer par une seule instruction :

1use App\Http\Controllers\RestaurantController;
2 
3Route::resource('restaurants', RestaurantController::class);

Dans le prochain épisode…

Le squelette de l'application est maintenant en place avec le modèle et son contrôleur.

Lors du chapitre suivant on va s'intéresser à la lettre V de l'architecture MVC, c'est à dire la vue !

Source : https://github.com/laravel-fr/support-les-bases/tree/v2