Laravel

ROYAUME DU MAROC
‫مكتب التكوين المهني وإنعاش الشغل‬

office de la formation professionnelle et de la promotion du travail
ISMONTIC TANGER
MODULE 205 : Développer en back-end
DÉVELOPPER EN BACK-END
OUAFIQ Majda
2022-2023
Découvrir les notions fondamentales
des Frameworks PHP
Présentation des Frameworks PHP
Un Framework est une boite à outils pour aider les développeurs dans la réalisation
de leurs tâches. Frame (cadre ) et work (travail).
Un Framework contient des composants autonomes qui permettent de résoudre les
problèmes souvent rencontrés par les développeurs (CRUD, arborescence, normes,
sécurités, etc.).
Les Frameworks PHP les plus populaires
des Frameworks PHP
Le framework Laravel
Lancé en 2011, Laravel se trouve en tête des classements grâce à ses fonctionnalités:
Offre une solution MVC complète.
a son propre ORM « Eloquent ORM » .
Utilise le moteur de templating Blade.
Packalyst, une collection de paquets Laravel, compte plus de 15 000 paquets
utilisable .
Dispose de l’outil de ligne de commande Artisan Console qui permet d’automatiser
les tâches répétitives et de générer rapidement du code squelette.
Dispose de plusieurs outils utiles tels que Mix pour la compilation des actifs CSS et
JS, et Socialite pour l’authentification OAuth.
Bénéficie d’une large communauté de développeurs
des Frameworks PHP
L’architecture MVC
Les frameworks PHP suivent généralement le plus célèbres design patterns qui
s'appelle MVC, qui signifie Modèle - Vue - Contrôleur.
Le but du pattern MVC est de séparer la logique du code en trois parties que l'on
retrouve dans des fichiers distincts.
Modèle : cette partie gère la logique métier. Le modèle communique avec la BDD.
C’est lui qui s’occupe de récupérer un article en base par exemple. On y trouve des
algorithmes complexes et des requêtes SQL.
Vue : cette partie se concentre sur l'affichage. Elle affiche à l’utilisateur des données
contenues dans des variables. On y trouve essentiellement du code HTML mais aussi
quelques boucles et conditions PHP très simples.
des Frameworks PHP
Contrôleur : cette partie gère les échanges avec l'utilisateur. C'est en quelque sorte
l'intermédiaire entre l'utilisateur, le modèle et la vue. Le modèle lui transmet les
données récupérées en base de données, puis il transmet ces données à la vue.
Préparer l’environnement de Laravel
Installation des outils pour Laravel
Pour travailler avec Laravel, vous avez besoin de :
1. PHP (PHP 8.X pour Laravel 9, PHP 7.4 pour Laravel 8).
2. un serveur Local (Apache ou Nginx), permettant l’exécution du PHP
3. un serveur de base de données pour gérer vos bases de données.
4. Composer, un gestionnaire de dépendances pour PHP
5. IDE et Editeurs de code ( Visual Studio Code, Atom, PHPStorm …)
6. Navigateurs Web : Laravel est compatible sur tout les navigateurs récents
(Chrome, Firefox ou Safari)
Composer
Composer est un logiciel gestionnaire de dépendances libre
écrit en PHP. Il permet à ses utilisateurs de déclarer et d'installer
les bibliothèques dont le projet principal a besoin. Il permet de
télécharger et de mettre à jour des bibliothèques externes.
Les bibliothèques externes permettent de réutiliser le code écrit
par d'autres personnes pour simplifier le développement.
Composer permet également de créer des projets Laravel et de télécharger le
framework.
Installation de Composer
Pour installer Composer, il suffit de télécharger un installeur
https://getcomposer.org/download/ et téléchargez Composer-Setup.exe.
Vérifications
Pour vérifier que tout fonctionne exécuter composer sur la ligne de commande
comme suit:
Créer un nouveau projet Laravel
Méthode 1 : Utiliser l’installeur de Laravel
Installer Laravel dans notre ordinateur : Ouvrez votre terminal (invite de commande)
et tapez la ligne suivante:
Créer notre premier projet laravel (project_laravel) :

Taper la commande laravel new project_laravel en plaçant le terminal dans le
répertoire de travail (ex. www):
Méthode 2 : Créer un nouveau projet Laravel avec Composer
Créer un deuxième projet à la racine du serveur nommé project_laravel2 :avec la
commande suivante:
Dirigez-vous vers votre dossier à la racine de votre serveur www ou htdocs et
exécuter la commande : composer create-project laravel/laravel project_laravel2
Architecture d’un projet Laravel
Ouvrez le dossier project_laravel avec l’éditeur Visual Code, vous devez avoir ceci
comme résultat :
app/ : Ce dossier contient le code principal de votre application Laravel. Il est
subdivisé en plusieurs sous-dossiers pour les modèles, les contrôleurs, les vues, les
middlewares, etc. Ces dossiers sont :
app/Http/Controllers : Contient les contrôleurs de l'application
app/Http/Middleware : Contient les middlewares de l'application
app/Http/Requests : Contient les classes de validation de requêtes
app/Models : Contient les modèles de données de l'application
app/Providers : Contient les fournisseurs de services de l'application
bootstrap/ : Ce dossier contient les fichiers nécessaires pour démarrer l'application.
Cela inclut notamment les fichiers d'autoloading et les fichiers de configuration.
config/ : Ce dossier contient les fichiers de configuration de l'application, y compris
les fichiers pour les bases de données, le cache, le service de messagerie, etc.
database/ : Ce dossier contient les migrations et les seeders de la base de données.
public/ : Ce dossier contient les fichiers accessibles publiquement de votre
application, y compris les fichiers CSS, JS, les images, les fichiers d'entrée de
l'application, etc.
resources/ : Ce dossier contient les ressources de l'application telles que les fichiers
de vue, les fichiers de traduction, les fichiers de langues, etc. Il contient les sous-
dossiers suivants :
resources/views : Contient les fichiers de vue Blade de l'application
resources/lang : Contient les fichiers de traduction de l'application
routes/ : Ce dossier contient les fichiers de définition de routes de l'application.
Vous pouvez y définir les routes pour les contrôleurs, les middlewares, les
fichiers d'entrée, etc.
storage/ : Ce dossier contient les fichiers générés par l'application, tels que les
fichiers journaux, les fichiers de cache, les fichiers de session, etc.
tests/ : Ce dossier contient les fichiers de test de l'application.
vendor/ : Ce dossier contient les fichiers de dépendances de l'application, y compris
le code source de Laravel lui-même et les packages tiers installés via Composer
Qu'est ce que Laravel Artisan?
Laravel Artisan est une Interface en Ligne de Commande (CLI) qui va vous
permettre de gérer votre application en lançant des commandes via le terminal
(effacer le cache de l’application, gérer des modèles, des contrôleurs, des routes…)
Laravel Artisan: commandes utiles
Lancer le projet Laravel
Placez le terminal dans le dossier racine de votre projet et taper les commandes:
php artisan key:generate
Ensuite
php artisan serve
Ouvrez le navigateur et allez sur http://localhost/:8000, et vous obtiendrez le résultat
suivant :
Gestion du routage
Lorsque la requête atteint le fichier public/index.php l’application Laravel est créée et
configurée et l’environnement est détecté. Ensuite le fichier routes/web.php est
chargé. Voici l’emplacement de ce fichier :
Les autres fichiers concernent des routes plus spécifiques comme pour les API avec
le fichier api.php ou les routes pour les actions en ligne de commande avec le fichier
console.php.
C’est avec ce fichier que la requête va être analysée et dirigée. Regardons ce qu’on y
trouve au départ : Route::get('/', function () {
return view('welcome');
});
Gestion du routage
Comme Laravel est explicite vous pouvez déjà deviner à quoi sert ce code :
Route : on utilise le routeur,
get : on regarde si la requête a la méthode « get »,
‘/’ : on regarde si l’url comporte uniquement le nom de domaine,
dans la fonction anonyme on retourne (return) une vue (view) à partir du fichier
« welcome ».
Ce fichier « welcome » se trouve bien rangé dans le dossier des vues :
C’est ce fichier comportant du code Html qui génère le texte d’accueil que vous
obtenez au démarrage initial de Laravel.
Gestion du routage
Visualisons le cycle de la requête :
Gestion du routage
Méthodes de routeur disponibles
Laravel accepte les verbes suivants : get, post, put, patch, delete, options, match
(pour prévoir plusieurs verbes) et any (on accepte tous les verbes).
Il est indispensable de connaître les principales méthodes du HTTP :
GET : pour récupérer des données
POST : pour envoyer des données
PUT : pour mettre à jour des données
PATCH : pour mettre à jour partiellement des données
DELETE : pour supprimer des données
OPTIONS : pour obtenir les options de communication avec une ressource
MATCH : pour prévoir plusieurs verbes (GET, POST, PUT, PATCH, DELETE)
ANY : pour accepter tous les verbes HTTP.
Gestion du routage
Méthodes de routeur disponibles
Route::get($uri, $callback);
Route::post($uri, $callback);
Route::put($uri, $callback);
Route::patch($uri, $callback);
Route::delete($uri, $callback);
Route::options($uri, $callback);
Parfois, vous devrez peut-être enregistrer une route qui répond à plusieurs verbes
HTTP. Vous pouvez le faire en utilisant la méthode match. Ou, vous pouvez même
enregistrer une route qui répond à tous les verbes HTTP en utilisant la méthode any :
Route::match(['get', 'post'], '/', function () {//…});
Route::any('/', function () {//… });
Gestion du routage
Plusieurs routes et paramètre de route:
A l’installation Laravel a une seule route qui correspond à l’url de base composée
uniquement du nom de domaine. Voyons maintenant comment créer d’autres routes.
Imaginons que nous ayons 3 pages qui doivent être affichées avec ces urls :
1. http://monsite.fr/page/1
Il est facile de réaliser cela avec ce code :
Route::get(‘page/1', function() { return 'Je suis la page 1 !'; });
Route::get('page/2', function() { return 'Je suis la page 2 !'; });
Route::get('page/3', function() { return 'Je suis la page 3 !'; });
Gestion du routage
Cette fois je n’ai pas créé de vue parce que ce qui nous intéresse est uniquement une
mise en évidence du routage, je retourne donc directement la réponse au client.
Visualisons cela pour la page 1 :
On peut maintenant se poser une question : est-il vraiment indispensable de créer 3

routes alors que la seule différence tient à peu de chose : une valeur qui change ?
On peut utiliser un paramètre pour une route qui accepte des éléments variables en
utilisant des accolades. Regardez ce code :
Gestion du routage
Route::get(‘page/{n}', function($n) {
return 'Je suis la page ' . $n . ' !';
});
Et une visualisation du fonctionnement :
On dit que la route est paramétrée parce qu’elle possède un paramètre qui peut
prendre n’importe quelle valeur.
On peut rendre un paramètre optionnel en lui ajoutant un point d’interrogation. Dans
ce cas pour éviter une erreur d’exécution il faut prévoir une valeur par défaut pour le
paramètre, par exemple : Route::get('{n?}', function($n = 1) {
Gestion du routage
Redirection
Si vous définissez une route qui redirige vers un autre URI, vous pouvez utiliser la
méthode Route::redirect. Cette méthode fournit un raccourci pratique pour que vous
n'ayez pas à définir une route ou un contrôleur complet pour effectuer une simple
redirection :
Route::redirect('/ici', '/là-bas');
Par défaut, Route::redirect renvoie un code d'état 302. Vous pouvez personnaliser le
code d'état à l'aide du troisième paramètre facultatif :
Route::redirect('/ici', '/là-bas', 301);
Ou, vous pouvez utiliser la méthode Route::permanentRedirect pour renvoyer un
code d'état 301:
Route::permanentRedirect ('/ici', '/là-bas ');
Gestion du routage
Afficher les routes
Si votre itinéraire ne doit renvoyer qu'une vue , vous pouvez utiliser la méthode
Route::view. Comme la méthode redirect, cette méthode fournit un raccourci simple
pour que vous n'ayez pas à définir une route ou un contrôleur complet. La méthode
view accepte un URI comme premier argument et un nom de vue comme second
argument. De plus, vous pouvez fournir un tableau de données à transmettre à la vue
en tant que troisième argument facultatif :
Route::view('/welcome', 'welcome');
Route::view('/welcome', 'welcome', ['name' => 'Ahmed']);
Gestion du routage
La liste des routes
La commande Artisan route:list peut facilement fournir une vue d'ensemble de toutes
les routes définies par votre application :
php artisan route:list
Par défaut, le middleware de route affecté à chaque route ne sera pas affiché dans la
sortie route:list ; cependant, vous pouvez demander à Laravel d'afficher le
middleware de route en ajoutant l' option -v à la commande :
php artisan route:list -v
Vous pouvez également demander à Laravel de n'afficher que les routes commençant
par un URI donné :
php artisan route:list --path=api
Gestion du routage
De plus, vous pouvez demander à Laravel de masquer toutes les routes définies par
des packages tiers en fournissant l'option --except-vendor lors de l'exécution de la
commande route:list :
php artisan route:list --except-vendor
De même, vous pouvez également demander à Laravel de n'afficher que les routes
définies par des packages tiers en fournissant l'option --only-vendor lors de
l'exécution de la commande route:list :
php artisan route:list --only-vendor
Gestion du routage
Les routes nommées
Le nommage des routes est une fonctionnalité de Laravel qui permet d'attribuer un
nom à une route spécifique. Cela peut être très utile dans de nombreuses situations,
notamment lors de la création de liens ou de redirections dans votre application.
Par exemple, si vous avez une route qui affiche les détails d'un produit, vous pouvez
lui donner un nom comme suit :
Route::get('/product/{id}', function ($id) {
// Afficher les détails du produit avec l'ID $id
})->name('product.show');
Ici, la méthode name() est utilisée pour attribuer un nom à la route, qui est
'product.show'. Vous pouvez ensuite utiliser ce nom pour générer des URL dans votre
application.
Gestion du routage
Génération d'URL vers des routes nommées
Une fois que vous avez attribué un nom à une route donnée, vous pouvez utiliser le
nom de la route lors de la génération d'URL ou de redirections via les fonctions de
Laravel route et d'assistance redirect :
<a href="{{ route('product.show', ['id' => $product->id]) }}">Voir les détails</a>
Si la route nommée définit des paramètres, vous pouvez passer les paramètres
comme deuxième argument à la fonction route. Les paramètres donnés seront
automatiquement insérés dans l'URL générée dans leurs positions correctes :
Route::get('/user/{id}/profile', function ($id) {//…})->name('profile');
route('profile', ['id' => 1]);
Gestion du routage
Si vous transmettez des paramètres supplémentaires dans le tableau, ces paires
clé/valeur seront automatiquement ajoutées à la chaîne de requête de l'URL générée :
Route::get('/user/{id}/profile', function ($id) {//…})->name('profile');

route('profile', ['id' => 1, 'photos' => 'yes']);
// /user/1/profile?photos=yes
Gestion du routage
Groupes de routage
Les groupes de routage sont une fonctionnalité du système de routage de Laravel qui
permettent de regrouper des routes liées ensembles sous une même URL ou préfixe
de nommage. Les groupes de routage peuvent être utilisés pour organiser les routes
de votre application et pour appliquer des filtres de routage à un ensemble de routes.
Pour définir un groupe de routage dans Laravel, vous pouvez utiliser la méthode
Route::group() et spécifier les propriétés du groupe de routage, telles que l'URL ou
le préfixe de nommage du groupe et les filtres de routage à appliquer. Ensuite, vous
pouvez définir les routes pour le groupe de la même manière que vous le feriez pour
une route individuelle.
Par exemple, si vous souhaitez regrouper toutes les routes pour l'administration de
votre application sous le préfixe admin, vous pouvez utiliser un groupe de routage
Gestion du routage
comme ceci: Route::group(['prefix' => 'admin'], function () {
Route::get('/', function () {
// Retourne la page d'accueil de l'administration
});
Route::get('users', function () {
// Retourne la liste des utilisateurs de l'administration
});
// Autres routes pour l'administration
});
Dans cet exemple, toutes les routes du groupe de routage auront un préfixe d'URL
'admin/', ce qui signifie que la route pour la page d'accueil de l'administration sera
accessible à l'URL 'admin/' et la route pour la liste des utilisateurs sera accessible à
l'URL 'admin/users'.
De plus, les groupes de routage permettent également d'appliquer des filtres de
routage à un ensemble de routes. Par exemple, vous pouvez utiliser un middleware
Gestion du routage
pour protéger l'accès aux routes du groupe d'administration, comme ceci :
Route::group(['prefix' => 'admin', 'middleware' => 'auth'], function () {
// Routes protégées par le middleware d'authentification
});
Dans cet exemple, le middleware auth sera appliqué à toutes les routes du groupe
d'administration, ce qui signifie que seuls les utilisateurs authentifiés auront accès à
ces routes
Gestion du routage
En Laravel, une route peut avoir des paramètres qui permettent de capturer des
segments variables de l'URL. Par exemple, pour définir une route avec un paramètre
"id", vous pouvez utiliser le code suivant :
Route::get('/utilisateur/{id}', function ($id) {
return 'Utilisateur avec l\'identifiant : ' . $id;
});
D'un autre côté, lorsqu'une requête est envoyée à une route, elle peut inclure des
paramètres dans le corps de la requête ou dans l'en-tête de la requête. Ces paramètres
peuvent être récupérés dans la fonction associée à la route en utilisant l'objet Request.
Par exemple : use Illuminate\Http\Request;
Route::get('/connexion', function (Request $request) {
$identifiant = $request['identifiant'];
$mot_de_passe = $request['mot_de_passe'];
// Vérifier les identifiants et renvoyer une réponse });
Gestion du routage
Dans cet exemple, la route répondra aux requêtes HTTP GET envoyées à l'URL
/connexion. La fonction anonyme associée reçoit l'objet Request comme paramètre,
qui peut être utilisé pour récupérer les paramètres inclus dans le corps de la requête.
Dans cet exemple, les paramètres "identifiant" et "mot_de_passe" sont récupérés en
utilisant l'objet Request.
Manipulation des contrôleurs
Un contrôleur Laravel est une classe PHP qui gère la logique de traitement des
requêtes HTTP dans une application Laravel. Les contrôleurs sont souvent utilisés
pour organiser la logique de l'application en séparant la logique métier du code de
routage.
Les contrôleurs sont généralement stockés dans le répertoire app/Http/Controllers
de votre application Laravel. Vous pouvez créer un nouveau contrôleur en utilisant la
commande artisan make:controller. Par exemple, pour créer un contrôleur
UserController, vous pouvez utiliser la commande suivante :
php artisan make:controller UserController
Lorsqu'une requête est envoyée à votre application, Laravel utilise le routage pour
déterminer quelle méthode de contrôleur doit être exécutée. Le contrôleur est
responsable de récupérer les données nécessaires à partir des modèles de votre
application, puis de les passer à la vue appropriée pour être affichées.
Voici un exemple de route qui appelle la méthode index() du contrôleur
UserController : Route::get('/users', 'UserController@index');
Dans cet exemple, la route est définie avec la méthode get() qui indique que la route
doit répondre à une requête GET. Le premier argument est l'URI de la route (dans cet
exemple, /users) et le deuxième argument est une chaîne de caractères qui spécifie le
nom du contrôleur (UserController) suivi d'un @ et du nom de la méthode à appeler
(index).
Lorsqu'un utilisateur accède à l'URI /users, Laravel va automatiquement appeler la
méthode index() du contrôleur UserController
Si votre contrôleur est dans un sous-namespace, vous pouvez spécifier le chemin
complet du contrôleur.
<?php
namespace App\Http\Controllers;
use Illuminate\Http\Request;
class UserController extends Controller
{
public function index()
{
// Récupérer la liste des utilisateurs depuis la base de données
$users = User::all();
// Afficher la vue index.blade.php et passer la liste des utilisateurs
return view('users.index', ['users' => $users]);
}
public function show($id)
{
// Récupérer l'utilisateur correspondant à l'ID depuis la base de données
$user = User::find($id);
// Afficher la vue show.blade.php et passer l'utilisateur
return view('users.show', ['user' => $user]);
}
}
Dans cet exemple, nous avons un contrôleur UserController qui gère les actions liées
aux utilisateurs. Le contrôleur contient deux méthodes :
index() qui récupère la liste des utilisateurs à partir de la base de données et affiche la
vue users.index qui affiche la liste des utilisateurs.
show($id) qui récupère l'utilisateur correspondant à l'ID fourni dans l'URL à partir de
la base de données et affiche la vue users.show qui affiche les détails de l'utilisateur.
Exercice :
1. Créer un contrôleur CalculeController, puis ajouter deux méthodes :
a. une méthode somme : qui a deux nombres en paramètres et qui calcule la
somme et retourne : la somme est …
b. une méthode produit : qui a deux nombres en paramètres et qui calcule le
produit et retourne : le produit est ...
2. Dans le fichier ‘web.php’ . ajouter deux routes . chacune vers une méthode du
contrôleur. Attention. les routes doivent avoir deux paramètres.
3. Tester le bon fonctionnement.
Manipulation des vues
Les vues sont un élément clé de la création d'applications web dans Laravel. Une vue
dans Laravel est simplement un fichier qui contient du HTML, des balises PHP et
éventuellement des éléments de contrôle de modèle tels que des boucles et des
conditions. Les vues sont utilisées pour afficher les données dynamiques à
l'utilisateur final.
Dans Laravel, les vues sont stockées dans le répertoire resources/views de votre
application. Les noms de fichier de vue sont généralement en minuscules avec des
tirets pour séparer les mots. Par exemple, si vous avez une vue pour afficher la liste
des utilisateurs, vous pouvez l'appeler users-list.blade.php.
Laravel utilise le moteur de templates Blade pour créer des vues. Blade est un moteur
de template simple et facile à utiliser qui permet l'ajout de conditions, boucles,
héritage, etc. dans les vues.
Répertoires de vue imbriqués
Les vues peuvent également être imbriquées dans des sous-répertoires du répertoire
resources/views. La notation "Point" peut être utilisée pour référencer des vues
imbriquées.
Par exemple, si votre vue est stockée dans resources/views/admin/profile.blade.php,
vous pouvez la renvoyer depuis l'une des routes/contrôleurs de votre application
comme suit : return view('admin.profile', $data);
Blade
Laravel possède un moteur de template élégant nommé Blade qui nous permet de
faire pas mal de choses. La première est de nous simplifier la syntaxe. Par exemple
au lieu de la ligne suivante :
<p>C'est l'article n° <?php echo $numero ?></p>
On peut utiliser cette syntaxe avec Blade :
<p>C'est l'article n° {{ $numero }}</p>
Tout ce qui se trouve entre les doubles accolades est interprété comme du code PHP.
Mais pour que ça fonctionne il faut indiquer à Laravel qu’on veut utiliser Blade pour
cette vue. Il suffit d’ajouter « blade » avant l’extension « php ».
Il y a aussi la version avec la syntaxe {!! … !!}. La différence entre les deux versions
est que le texte entre les doubles accolades est échappé ou purifié
Affichage des données
Vous pouvez afficher les données transmises à vos vues Blade en enveloppant la
variable entre accolades.
Hello, {{ $name }}.
Vous n'êtes pas limité à l'affichage du contenu des variables passées à la vue. Vous
pouvez également afficher les résultats de n'importe quelle fonction PHP. En fait,
vous pouvez mettre n'importe quel code PHP que vous souhaitez echo dans une
instruction Blade : The current UNIX timestamp is {{ time() }}.
Les Directives
Outre l'héritage des modèles et l'affichage des données, Blade fournit également des
raccourcis pratiques pour les structures de contrôle PHP courantes, telles que les
instructions conditionnelles et les boucles. Ces raccourcis offrent une manière très
propre et concise de travailler avec les structures de contrôle PHP tout en restant
familiers à leurs homologues PHP.
Vous pouvez construire des instructions if à l'aide des directives @if, @elseif, @else
et @endif. Ces directives fonctionnent de la même manière que leurs homologues
PHP :
@if (count($records) === 1)
I have one record!
@elseif (count($records) > 1)
I have multiple records!
@else
I don't have any records!
@endif
En plus des directives conditionnelles déjà discutées, les directives @isset @empty
peuvent être utilisées comme raccourcis pratiques pour leurs fonctions PHP
respectives : @isset($records)
// $records is defined and is not null...
@endisset
@empty($records)
// $records is "empty"...
@endempty
Les instructions switch peuvent être construites à l'aide
des directives @switch, @case, @break et @default @endswitch
@switch($i)
@case(1)
First case...
@break
@default
Default case...
@endswitch
En plus des instructions conditionnelles, Blade fournit des directives simples pour
travailler avec les structures de boucle de PHP. Encore une fois, chacune de ces
directives fonctionne de manière identique à leurs homologues PHP :
@for ($i = 0; $i < 10; $i++)

The current value is {{ $i }}
@endfor
@foreach ($users as $user)

<p>This is user {{ $user->id }}</p>
@endforeach
@while (true)
<p>I'm looping forever.</p>
@endwhile
Lorsque vous utilisez des boucles, vous pouvez également ignorer l'itération en cours
ou terminer la boucle à l'aide des directives @continue et @break :

@if ($user->type == 1)
@continue
@endif
<li>{{ $user->name }}</li>
@if ($user->number == 5)
@break
@endif
@endforeach
Transmission des données aux vues
Vous pouvez passer un tableau de données aux vues pour rendre ces données
disponibles à la vue :
// in a Laravel controller
return view('greeting', ['name' => 'Alex']);
// in routes/greeting.php
Route::get('/greeting', function () { return view('greeting', ['name' => 'Alex']); });
Lors de la transmission d'informations de cette manière, les données doivent être un

tableau avec des paires clé/valeur.
Après avoir fourni des données à une vue, vous pouvez ensuite accéder à chaque
valeur de votre vue à l'aide des clés de données, telles que {{ $name; }}.
Il existe une autre méthode pour transmettre un paramètre, par exemple pour
transmettre la variable $numero.
Voici une schématisation du fonctionnement :
Exercice 1 :
1. Modifier la méthode somme du contrôleur ( de l’exercice précédent) pour qu’elle
retournera la somme directement au lieu de toute une phrase contenant la somme.
2. Créer une vue affichage.blade.php qui contient div où on affichera la somme.
3. tester le bon fonctionnement
Exercice 2 :
1. créer une vue qui contient une liste déroulante(select) remplie par les nombres de 0
à9
2. Remplir une deuxième liste par les nombres impairs de 1 à 1000. Proposer deux
solutions
a. Solution 1 : avec une boucle
b. Solution 2 : avec une boucle et une condition
Créer un layout et organiser les vues:
En termes d'héritage des vues dans Laravel, cela fait référence à la capacité de créer
une vue parente qui peut être héritée par d'autres vues enfants. Cela signifie qu'une
vue parente peut contenir du code HTML et des éléments qui sont communs à toutes
les vues enfants, ce qui évite la duplication de code et facilite la maintenance du
code.
Par exemple, si vous avez plusieurs pages dans votre application web qui ont la
même mise en page de base, vous pouvez créer une vue parente contenant la
structure de base de la page et hériter cette vue dans les pages enfants. Les pages
enfants n'auront alors besoin que de contenir le code spécifique à chaque page.
Pour utiliser l'héritage des vues dans Laravel, vous pouvez utiliser la directive
@extends dans les vues enfants pour indiquer quelle vue parente utiliser. Vous
dans la vue parente qui peuvent être remplacées par du contenu spécifique dans les
vues enfants.
@extends est utilisé pour créer une vue parente qui peut être étendue par d'autres
vues. Il est utile lorsque vous avez besoin d'afficher des éléments communs à
plusieurs pages, tels que l'en-tête et le pied de page.
Supposons que vous avez une vue parente appelée "layout.blade.php" qui contient la
structure de base de votre site web. Cette vue contient une barre de navigation, un en-
tête et un pied de page, qui sont communs à toutes les pages de votre site.
layout.blade.php :
<body>
<header>
<h1>Mon site web</h1>
<nav>
<ul>
<li><a href="/">Accueil</a></li>
<li><a href="/contact">Contact</a></li>
</ul>
</nav>
</header>
<main>
@yield('content')
</main>
<footer>
© 2023 Mon site web
</footer>
</body>
Dans cette vue, la section principale est définie à l'aide de la directive @yield. Cette
directive permet de définir une section que les vues enfants peuvent remplir avec du
contenu spécifique.
Maintenant, supposons que vous ayez une page "contact" sur votre site web que vous
souhaitez afficher à l'aide de cette structure de base. Vous pouvez créer une vue
enfant appelée "contact.blade.php" et hériter de la vue parente en utilisant la directive
@extends :
contact.blade.php :
@extends('layout')
@section('content')
<h2>Contactez-nous</h2>
<p>Remplissez le formulaire ci-dessous pour nous contacter :</p>
<form action="/contact" method="post">

</form>
@endsection
Dans cette vue, la directive @extends('layout') indique que la vue parente à utiliser
est "layout.blade.php". La directive @section('content') remplit la section principale
de la vue parente avec du contenu spécifique à la page de contact.
Ainsi, lorsque vous affichez la page "contact" sur votre site web, Laravel combinera
automatiquement le contenu de la vue parente et de la vue enfant pour produire la
page finale avec la structure de base et le contenu spécifique à la page de contact.
Les vues partielles
@include est utilisé pour inclure une vue dans une autre vue. Il est utile lorsque vous
avez besoin d'afficher le contenu d'une vue dans plusieurs autres vues. Vous pouvez
inclure une vue en utilisant la syntaxe suivante :
<!DOCTYPE html>
<html>
<head>
<title>Mon site web</title>
</head>
<body>
@include('header')
<div class="content">
<h1>Bienvenue sur mon site web</h1>
<p>Lorem ipsum dolor sit amet, consectetur adipiscing elit.</p>
</div>
</body>
</html>
Dans cet exemple, la vue header est incluse en utilisant la directive
@include('header'). La vue header doit être stockée dans le dossier resources/views et
avoir l'extension .blade.php.
Pour passer des paramètres à une vue partielle incluse avec la directive @include
dans Laravel, vous pouvez utiliser la syntaxe suivante :
@include('header', ['title' => 'Page d\'accueil'])
Dans la vue incluse, vous pouvez accéder aux paramètres passés en utilisant la
variable correspondante. Par exemple, si vous passez un paramètre nommé titre à la
vue incluse, vous pouvez l'afficher en utilisant la syntaxe suivante :
<h1>{{ $titre }}</h1>
Exercice :
1. Créer une page nommée layout.blade.php qui contient une structure générale de
vos page.
2. Ensuite, créer deux page nommée page1.blade.php et page2.blade.php qui héritent
depuis la page layout en ajoutant un contenu spécifique à chaque page.
Utilisation des Middleware
Le middleware fournit un mécanisme pratique pour inspecter et filtrer les requêtes
HTTP entrant dans votre application. Par exemple, Laravel inclut un middleware qui
vérifie que l'utilisateur de votre application est authentifié. Si l’ utilisateur n'est pas
authentifié, le middleware redirigera l'utilisateur vers l'écran de connexion de votre
application. Cependant, si l'utilisateur est authentifié, le middleware permettra à la
demande de continuer plus loin dans l'application.
Créer middleware
La façon la plus simple de créer un middleware est d'utiliser Artisan. Appeler la
commande make:middleware a pour effet de créer une structure de base de
middleware dans le dossier réservé a cet usage: app/Http/Middleware
php artisan make:middleware NomMiddleware
Cette commande placera une nouvelle classe NomMiddleware dans le répertoire
app/Http/Middleware.
Le middleware c'est une classe qui contient deux méthodes handle et terminate. Sauf
que terminate n'est pas généré automatiquement il faut l’ajouter manuellement.
public function handle(Request Srequest, Closure Snext){}
public function terminate(Request $request, Response $response{}
Enregistrement d'un middleware
Après la création du middleware, nous devons informer l'application que le
middleware existe. Si vous souhaitez qu'un middleware s'exécute à chaque demande,
accédez à app/Http/kernel.php et ajouter le middleware au Kernel.
Types Middleware
Pour utiliser le middleware dans Laravel, vous devez le définir soit dans le tableau
$routeMiddleware ou $middlewareGroups ou $middleware dans le fichier
app/Http/Kernel.php. Ensuite, vous pouvez appliquer le middleware aux routes
individuelles ou aux groupes de routes à l'aide de la méthode middleware dans votre
fichier de routes.
Voici un exemple d'application du middleware à une route dans Laravel:
Route::get('/dashboard', function () {//… })->middleware('auth');
Dans cet exemple, le middleware auth est appliqué à la route /dashboard. Cela
signifie que la requête sera d'abord filtrée par le middleware auth avant d'être
transmise à la fonction de fermeture pour être traitée.
class CheckAge
{
public function handle(Request $request, Closure $next)
{
$age = 15;
if ($age < 18) {
return redirect('/')->with('error', 'Vous devez être majeur pour accéder.');
//ou abort(404)
}
return $next($request);
}}
Lier un middleware à un controller
Un middleware peut être affecté aux routes du contrôleur dans vos fichiers de routes :
Route::get('profile', [UserController::class, 'show'])->middleware('auth');
Ou, vous trouverez peut-être pratique de spécifier un middleware dans le
constructeur de votre contrôleur. En utilisant la méthode middleware dans le
constructeur de votre contrôleur, vous pouvez affecter un middleware aux actions du
contrôleur : class UserController extends Controller
{
public function __construct()
{
$this->middleware('auth');
$this->middleware('log')->only('index');
$this->middleware('subscribed')->except('store');
}
}
Lier un middleware à un controller
$this->middleware('auth') : cela applique le middleware auth à toutes les méthodes
de ce contrôleur. Le middleware auth est responsable de vérifier si l'utilisateur est
authentifié avant de lui permettre d'accéder à une ressource.
$this->middleware('log')->only('index') : cela applique le middleware log
uniquement à la méthode index de ce contrôleur. Le middleware log est responsable
de journaliser les demandes entrantes.
$this->middleware('subscribed')->except('store') : cela applique le middleware
subscribed à toutes les méthodes de ce contrôleur, sauf à la méthode store. Le
middleware subscribed vérifie si l'utilisateur est abonné avant de lui permettre
d'accéder à une ressource.
contrôleur de ressources
Dans Laravel, un contrôleur de ressources (ou resource controller en anglais) est un
contrôleur qui implémente des méthodes pré-définies pour gérer les différentes
actions CRUD (Create, Read, Update, Delete) d'une ressource.
Pour créer un contrôleur de ressources, vous pouvez utiliser la commande
make:controller de Laravel avec l'option --resource :
php artisan make:controller MyResourceController --resource
Cela va créer un contrôleur de ressources nommé MyResourceController avec des

méthodes pré-définies pour gérer les actions CRUD.
Voici les méthodes pré-définies que vous obtiendrez avec un contrôleur de
ressources:
index() : affiche une liste de la ressource
create() : affiche un formulaire pour créer une nouvelle ressource
show($id) : affiche une ressource spécifique
edit($id) : affiche un formulaire pour éditer une ressource existante
update(Request $request, $id) : met à jour une ressource existante
destroy($id) : supprime une ressource existante
Ensuite, vous pouvez enregistrer une route de ressources qui pointe vers le
contrôleur: use App\Http\Controllers\PhotoController;
Route::resource('photos', PhotoController::class);
GET /photos : appelle la méthode index() du contrôleur
GET /photos/create : appelle la méthode create() du contrôleur pour afficher un formulaire de
création
POST /photos : appelle la méthode store(Request $request) du contrôleur pour enregistrer une
nouvelle ressource
GET /photos/{photo} : appelle la méthode show($id) du contrôleur pour afficher une ressource
spécifique
GET /photos/{photo}/edit : appelle la méthode edit($id) du contrôleur pour afficher un
formulaire d'édition
PUT/PATCH /photos/{photo} : appelle la méthode update(Request $request, $id) du contrôleur
pour mettre à jour une ressource existante
DELETE /photos/{photo} : appelle la méthode destroy($id) du contrôleur pour supprimer une
ressource existante
Protection CSRF(Cross-Site Request
Forgery)
Falsification de requêtes intersites
Les falsifications de requêtes inter-sites sont un type d'exploit malveillant par lequel
des commandes non autorisées sont exécutées au nom d'un utilisateur authentifié.
L’impact de cette attaque dépend des privilèges de la victime sur le système.
Laravel fournit une protection contre les attaques CSRF en générant un jeton CSRF.
Ce jeton CSRF est généré automatiquement pour chaque utilisateur. Ce jeton n'est
rien d'autre qu'une chaîne aléatoire gérée par l'application Laravel pour vérifier les
demandes des utilisateurs.
Cette protection de jeton CSRF peut être appliquée à n'importe quel formulaire
HTML dans l’application Laravel en spécifiant un champ de formulaire caché du
jeton CSRF,
Forgery)
Une des manières efficaces de se prémunir contre les attaques CSRF est
d'accompagner chaque formulaire a protéger d'un jeton (en anglais "token")
d'identification de session. Pour ce faire:
lorsqu'un visiteur se connecte sur votre site, vous enregistrez en session une chaine
de caractère aléatoire.
Cette même chaine est récupérée en session et passée au formulaire, sous la forme
d'un champ de type "hidden",
Lorsque le formulaire est posté, votre système de validation doit vérifier que le
champ caché contient la même valeur que celle enregistrée en session.
Si ce n'est pas le cas, ça signifie que quelqu'un a essayé de soumettre le formulaire
depuis un autre endroit que votre site. Il faut alors annuler le traitement de ce
formulaire.
Forgery)
Laravel inclut un plug-in CSRF intégré, qui génère des jetons pour chaque
session utilisateur active. Ces jetons vérifient que les opérations ou requêtes sont
envoyées par l’utilisateur authentifié concerné.
Empêcher les requêtes CSRF
CSRF est implémenté dans les formulaires HTML déclarés dans les applications
Web. Vous devez inclure un jeton CSRF validé masqué dans le formulaire, afin que
le middleware de protection CSRF de Laravel puisse valider la demande.
La protection CSRF peut être implémentée dans Laravel à l’aide de n'importe quel
formulaire HTMIL avec une forme cachée de jeton CSRF et la demande de
l’utilisateur est validée à l’aide du middleware CSRF VerifyCsrfToken.
Forgery)
L'une des options suivantes peut être utilisée pour générer un jeton CSRF
1. Empêcher les requêtes CSRF via @csrf
@csrf est une directive de Blade pour générer un champ de jeton qui sera utilisé pour
la vérification. Il génère un champ de saisie masqué.
Lorsque la directive blade @csrf est utilisée, une balise input de type="hidden est
ajoutée au formulaire. La valeur sera le jeton CSRF qui sera envoyé dans le cadre des
données du formulaire lorsque le formulaire est soumis.
Syntaxe
<form action="{{ url/..)}" method="post">
@csrf
…
</form>
Forgery)
Exercice:
Créer une vue qui contient un formulaire comme suit:
dans l'attribut action on a : /accueil (penser à créer une page accueil)

Tester le bon fonctionnement sans et avec l’utilisation du: @csrf
Forgery)
2. Empēcher les requêtes CSRF via csrf_token()
csrf token() :Cette fonction peut être utilisée dans la balise meta et le champ de saisie
masqué du formulaire HTML. Il génère une chaîne aléatoire en tant que jeton
CSRF.
Syntaxe :
<form method = "POST">
<input type = "hidden" name = "_token" value = "{{csrf_token()}}">
….
</form>
Exercice :
Créez une vue Laravel nommé form-csrf_token.blade.php où la fonction csrf_token()
est utilisée pour générer le jeton CSRF.
Forgery)
3. Empêcher les requêtes CSRF via csrf_field()
csrf_field() : Cette fonction crée un champ masqué pour le formulaire HTML où il
est utilisé et génère un jeton CSRF.
Syntaxe:
<form method = "POST" action="/profile">
{{ csrf_field() }}
….
< /form>
Exercice:
Créez une vue Laravel nommé form-csrf_field.blade-php où la fonction csrf_field()
est utilisée pour générer le jeton CSRE.
Forgery)
Remarque : Exclure les URI de la protection CSRF
Laravel a la protection CSRF activé par défaut pour toutes les demandes qui
transitent par votre application (à chaque formulaire créé avec la méthode
Form::open). Parfois, vous souhaiterez peut-être exclure un ensemble d’URI de la
protection CSRF Surtout lorsqu’on utilise des services externes dont on n'a pas droit
de définir un jeton.
1. Ouvrez le fichier App\Http\Middleware\VerifyCsrfToken.php.
2. Ajoutez le nom de la route que vous souhaitez exclure de la protection CSRF à la
propriété $except. Par exemple, si vous souhaitez exclure la route api/webhooks de
la protection CSRF, ajoutez
protected cette ligne
$except = [ de code :
'api/webhooks',
];
Validation des formulaires
La validation des formulaires est une étape importante pour s'assurer que les données
soumises par les utilisateurs sont correctes et conformes aux règles de l'application.
Dans Laravel 9, la validation des formulaires est facilitée grâce à la méthode
validate.
Voici un exemple de validation d'un formulaire de création de compte avec les règles
suivantes :
Le nom d'utilisateur est requis et doit avoir une longueur maximale de 50
caractères
L'adresse email est requise et doit être une adresse email valide
Le mot de passe est requis et doit avoir une longueur minimale de 8 caractères
use App\Models\User;
use Illuminate\Http\Request;
class UserController extends Controller

{
public function store(Request $request)
{
$request->validate([
'username' => 'required|max:50',
'email' => 'required|email',
'password' => 'required|min:8',
]);
…
// Rediriger l'utilisateur vers une autre page
return redirect('/')->with('success', 'Votre compte a été créé avec succès !');
}
}
Dans cet exemple, la méthode validate() est appelée avec un tableau de règles de
validation. Si les données ne respectent pas les règles de validation, Laravel génère
automatiquement une exception Illuminate\Validation\ValidationException. Dans ce
cas, il est possible d'accéder aux erreurs de validation en utilisant la méthode
getMessage() de l'exception.
Les messages d'erreur sont en anglais. On peut cependant personnaliser les messages
en modifiant le fichier \lang\validation.php
Notez que la méthode validate() peut également prendre en charge des messages
d'erreur personnalisés en passant un tableau de messages à la méthode validate().
Cela permet de personnaliser les messages d'erreur pour chaque règle de validation.
$validatedData = $request->validate([
'username' => 'required|max:50',
'email' => 'required|email|unique:users,email',
'password' => 'required|min:8',
], [
'username.required' => 'Le champ nom d\'utilisateur est obligatoire.',
'username.max' => 'Le champ nom d\'utilisateur ne doit pas dépasser :max
caractères.',
'email.required' => 'Le champ adresse email est obligatoire.',
'email.email' => 'Le champ adresse email doit être une adresse email
valide.',
'email.unique' => 'L\'adresse email est déjà utilisée par un autre
utilisateur.',
'password.required' => 'Le champ mot de passe est obligatoire.',
'password.min' => 'Le champ mot de passe doit avoir au moins :min
caractères.',
]);
Une fois que la validation a échoué, Laravel renvoie automatiquement l'utilisateur à
la page précédente avec les erreurs de validation. Les erreurs sont stockées dans la
variable $errors, qui peut être affichée dans la vue pour informer l'utilisateur des
erreurs qu'il doit corriger.
Voici un exemple de code pour afficher les erreurs de validation dans la vue :
@if ($errors->any())
<div class="alert alert-danger">
<ul>
@foreach ($errors->all() as $error)
<li>{{ $error }}</li>
@endforeach
</ul>
</div>
@endif
Laravel offre également une directive Blade @error qui permet d'afficher les erreurs
de validation directement à côté de chaque champ de formulaire sans avoir à utiliser
une condition @if pour chaque champ.
Voici un exemple de code pour afficher les erreurs de validation à côté de chaque
champ de formulaire en utilisant la directive Blade @error :
<form method="POST" action="/users">
<div class="form-group">
<label for="username">Nom d'utilisateur :</label>
<input type="text" id="username" name="username" class="form-control
@error('username')
<span class="invalid-feedback" role="alert">{{ $message }}</span>
@enderror
</div>
<button type="submit" class="btn btn-primary">Créer un compte</button>
</form>
utiliser une base de données MySQL
Pour utiliser une base de données MySQL en Laravel 9 et créer des requêtes SQL
CRUD, vous devez tout d'abord configurer votre application pour qu'elle se connecte
à votre base de données. Voici les étapes à suivre:
Créez une nouvelle base de données MySQL en utilisant l'outil de votre choix.
Ouvrez le fichier .env à la racine de votre projet Laravel et configurez les paramètres
de base de données comme suit:
DB_CONNECTION=mysql
DB_HOST=127.0.0.1
DB_PORT=3306
DB_DATABASE=nom_de_votre_base_de_donnees
DB_USERNAME=votre_nom_d_utilisateur
DB_PASSWORD=votre_mot_de_passe
Remplacez "nom_de_votre_base_de_donnees", "votre_nom_d_utilisateur" et

"votre_mot_de_passe" par les informations de votre propre base de données.
En utilisant la façade DB de Laravel, vous pouvez effectuer des opérations CRUD en
utilisant des requêtes SQL sur une base de données MySQL. Voici comment
procéder:
use
Importez la façade DB en Illuminate\Support\Facades\DB;
haut de votre fichier de contrôleur ou de modèle:
Utilisez la méthode DB::select() pour exécuter une requête de sélection et récupérer

$results
les résultats. Par = DB::select('SELECT
exemple, * FROM
pour récupérer tous les table_name');
enregistrements d'une table:
Utilisez la méthode DB::insert() pour insérer des données dans une table. Par
exemple, pour insérer un nouvel enregistrement:
DB::insert('INSERT INTO table_name (column1, column2) VALUES (?, ?)',
['value1', 'value2']);
Utilisez la méthode DB::update() pour mettre à jour des données dans une table. Par
exemple, pour mettre à jour un enregistrement existant:
DB::update('UPDATE table_name SET column1 = ?, column2 = ? WHERE id = ?',
['new_value1', 'new_value2', $id]);
Utilisez la méthode DB::delete() pour supprimer des données d'une table. Par
exemple, pour supprimer un enregistrement:
DB::delete('DELETE FROM table_name WHERE id = ?', [$id]);
Bien que l'utilisation de requêtes SQL directement dans Laravel puisse être utile dans
certaines situations, il est généralement recommandé d'utiliser les outils de haut
niveau fournis par Laravel, tels que le Query Builder ou les modèles Eloquent, pour
une meilleure maintenabilité et une meilleure sécurité de l'application.
Manipulation des requêtes HTTP pour
les fichiers
La manipulation des requêtes HTTP pour les fichiers dans une application Laravel
peut être effectuée via l'utilisation de la classe Illuminate\Http\Request. Cette classe
fournit des méthodes pour récupérer et manipuler les fichiers envoyés dans une
requête HTTP.
Voici un exemple de code pour la manipulation d'un fichier image envoyé via une
requête HTTP en utilisant la classe Illuminate\Http\Request :
<form action="/upload" method="POST"

enctype="multipart/form-data">
@csrf
<input type="file" name="image">
<button type="submit">Télécharger</button>
</form>
les fichiers
public function uploadImage(Request $request) {
// Vérifie que le fichier a été envoyé dans la requête
if ($request->hasFile('image')) {
// Récupère le fichier image à partir de la requête
$image = $request->file('image');
// Définit le nom du fichier

$name = time().'_'.$image->getClientOriginalName();
// Stocke le fichier dans le dossier storage/app/public/images de votre application

$path = $image->storeAs('public/images',$name);
DB::insert('insert into stagaires Values

(?,?,?,?)',[$request['code'],$name,$request[‘nom'],$request[‘prenom']]);
}}
les fichiers
Ce code :
1. Vérifie si la requête contient un fichier avec le nom de l’input en utilisant la
méthode hasFile.
2. Récupère le fichier image à partir de la requête en utilisant la méthode file.
3. Définit un nom pour le fichier en combinant la valeur de time() avec le nom
original du fichier en utilisant la méthode getClientOriginalName pour rendre le
nom unique.
4. Stocke le fichier dans le dossier storage/app/public/images de l'application en
utilisant la méthode storeAs.
5. Insère le nom du fichier téléchargé dans la table de la base de données en utilisant
la méthode DB::insert.
les fichiers
Notez que pour que ce processus fonctionne correctement, vous devez vous assurer
que votre formulaire contient l'attribut enctype="multipart/form-data". De plus, vous
devez créer un lien symbolique pour le dossier storage/app/public vers public/storage
en utilisant la commande php artisan storage:link pour accéder aux fichiers stockés
dans storage/app/public à partir de l'URL http://votreapp.com/storage.
Et vous pouvez finalement afficher votre image en utilisant :
<img width="100" src="{{ asset('storage/images/'.$Stagiare->image) }}">

Les transactions
En Laravel, les transactions sont utilisées pour effectuer des opérations sur plusieurs
tables de la base de données de manière atomique, c'est-à-dire qu'elles sont toutes
exécutées en une seule fois ou annulées si l'une d'elles échoue.
Vous pouvez utiliser la méthode transaction() pour effectuer une transaction :
DB::transaction(function () {
// exécutez ici vos requêtes SQL qui modifient les données dans la base de
données
});
Cette méthode commence une transaction, exécute le code dans la fonction anonyme
et valide la transaction automatiquement si tout se passe bien, ou annule la
transaction si une exception est levée.
Vous pouvez utiliser d’autre méthode, voici un exemple de code pour effectuer une
transaction en Laravel :
Les transactions
DB::beginTransaction();
try {
// exécutez ici vos requêtes SQL qui modifient les données
dans la base de données
DB::commit();
} catch (\Exception $e) {
DB::rollback();
}
Dans cet exemple, la méthode DB::beginTransaction() commence une transaction,

DB::commit() valide toutes les modifications effectuées dans la transaction, et
DB::rollback() annule toutes les modifications effectuées si une exception est levée.
Query Builder /générateur de requêtes
Introduction
Le générateur de requêtes de base de données de Laravel fournit une interface
pratique et fluide pour créer et exécuter des requêtes de base de données. Il peut être
utilisé pour effectuer la plupart des opérations de base de données dans votre
application et fonctionne parfaitement avec tous les systèmes de base de données pris
en charge par Laravel.
La configuration de la base de données

Indiquer le nom de la base de données dans le fichier de configuration .env
Les opérations CRUD
le Query Builder est accessible via la façade DB et permet de sélectionner une table
puis utiliser des méthodes pour récupérer les données.
La méthode get en Laravel est utilisée pour exécuter une requête de sélection de
données et retourner les résultats sous forme de collection.
$users = DB::table('users')->get();
1. Sélection de données :
Vous pouvez sélectionner des données d'une table en utilisant la méthode select. Par
exemple, pour sélectionner tous les enregistrements de la table "users" :
$users = DB::table('users')->select('*')->get();
Vous pouvez également sélectionner des colonnes spécifiques en les passant en
argument à la méthode select :
$users = DB::table('users')->select('name', 'email')->get();
La méthode raw en Laravel permet d'insérer une expression SQL brute dans une
requête. Cela peut être utile pour des situations où le générateur de requêtes de
Laravel ne permet pas de construire la requête souhaitée ou si vous avez besoin
d'utiliser des expressions SQL plus avancées.
Voici un exemple d'utilisation de la méthode raw pour insérer une expression SQL
brute dans une requête de sélection de données :
$users = DB::table('users')
->select(DB::raw('count(*) as user_count, status'))
->groupBy('status')
->get();
2. Recherche de données :
Vous pouvez utiliser la méthode where pour filtrer les données en fonction d'une
condition. Par exemple, pour sélectionner tous les enregistrements de la table "users"
où le nom est "John" :
$users = DB::table('users')->where('name', 'John')->get();
en utilisant la méthode where en Laravel, il est possible d'utiliser d'autres opérateurs

de comparaison tels que >, <, >=, <=, !=, <> et LIKE pour filtrer les résultats.
Voici un exemple d'utilisation de la méthode where avec l'opérateur > pour récupérer
tous les enregistrements de la table "orders" dont le montant total est supérieur à
1000 $orders = DB::table('orders')
->where('total_amount', '>', 1000)
->get();
Vous pouvez combiner plusieurs conditions de filtrage en utilisant les méthodes
where et orWhere. Par exemple, pour récupérer tous les enregistrements de la table
"orders" dont le montant total est supérieur à 1000 et dont la date de commande est
antérieure au 1er janvier 2022 :
$orders = DB::table('orders')
->where('total_amount', '>', 1000)
->where('order_date', '<', '2022-01-01')
->get();
->where('name', 'John')
->orWhere('email', '[email protected]')
->get();
Il est tout à fait possible de combiner des conditions de filtrage avec des opérateurs
logiques "ET" et "OU" dans une même requête de sélection de données en utilisant
les méthodes where, orWhere de Laravel.
Par exemple, si nous voulons récupérer tous les enregistrements de la table "users"
dont le nom est "John" et dont l'adresse e-mail est "[email protected]" ou
"[email protected]", nous pouvons utiliser les méthodes where, whereRaw,
orWhere et orWhereRaw comme suit :
->where('name', 'John')
->where(function($query) {
$query->where('email', '[email protected]')
->orWhere('email', '[email protected]');
})
->get();
La méthode whereBetween de Laravel permet de spécifier une condition de filtrage
pour récupérer les enregistrements d'une table dont une colonne se situe dans un
certain intervalle de valeurs.
Par exemple, si nous voulons récupérer tous les enregistrements de la table "orders"
dont la date se situe entre le 1er janvier 2022 et le 31 décembre 2022, nous pouvons
utiliser la méthode whereBetween comme suit :
->whereBetween('date', ['2022-01-01', '2022-12-31'])
->get();
De plus, il est également possible d'utiliser les méthodes whereNotBetween et

orWhereBetween pour spécifier des conditions de filtrage inversées ou combinées
avec l'opérateur "OU".
3. Joindre des tables :
Vous pouvez joindre deux ou plusieurs tables en utilisant la méthode join. Par
exemple, pour joindre la table "users" avec la table "posts" sur la colonne "user_id" :
->join('posts', 'users.id', '=', 'posts.user_id')
->select('users.name', 'posts.title')
->get();
4. Agréger des données :

Vous pouvez agréger des données en utilisant des méthodes telles que count, sum,
avg, min et max. Par exemple, pour obtenir le nombre total d'utilisateurs :
$totalUsers = DB::table('users')->count();
5. Trier les données :
Vous pouvez trier les données en utilisant la méthode orderBy. Par exemple, pour
trier la table "users" par la colonne "name" dans l'ordre croissant :
$users = DB::table('users')->orderBy('name', 'asc')->get();
6. Regroupement
Les méthodes groupBy et having de Laravel permettent de regrouper les
enregistrements d'une table en fonction de certaines colonnes et de filtrer les résultats
regroupés en utilisant des conditions de filtrage sur des colonnes agrégées.
$ordersByCustomer = DB::table('orders')
->select('customer_id', DB::raw('count(*) as total_orders'))
->groupBy('customer_id')
->having('total_orders', '>', 10)
->get();
7. Limiter le nombre de lignes retourné :
La méthode limit de Laravel est utilisée pour limiter le nombre d'enregistrements
renvoyés par une requête de sélection. Elle prend en paramètre le nombre maximum
d'enregistrements à renvoyer.
->limit(1)
->get();
8. Insérer des données :
Vous pouvez insérer des données dans une table en utilisant la méthode insert. Par
exemple, pour insérer un nouvel utilisateur :
DB::table('users')->insert([
'name' => 'John Doe',
'email' => '[email protected]',
'password' => 'password123'
]);
9. Mettre à jour des données :
Vous pouvez mettre à jour des données dans une table en utilisant la méthode update.
Par exemple, pour mettre à jour le nom de l'utilisateur dont l'ID est 1 :
DB::table('users')
->where('id', 1)
->update(['name' => 'Jane Doe']);
10. Supprimer des données :

Vous pouvez supprimer des données d'une table en utilisant la méthode delete :
DB::table('users')
->where('id', '>', 100)
->delete();
Query Builder : La pagination
Il existe plusieurs façons de paginer les éléments. Le plus simple consiste à utiliser la
méthode paginate sur le générateur de requêtes ou une requête Eloquent . La méthode
paginate prend automatiquement en charge la définition de la "limite" et du
"décalage" de la requête en fonction de la page actuelle consultée par l'utilisateur. Par
défaut, la page en cours est détectée par la valeur de l'argument page de chaîne de
requête sur la requête HTTP. Cette valeur est automatiquement détectée par Laravel,
et est également automatiquement insérée dans les liens générés par le paginateur.
Dans cet exemple, le seul argument passé à la méthode paginate est le nombre
d'éléments que vous souhaitez afficher "par page". Dans ce cas précisons que nous
souhaitons afficher 10 éléments par page :
$users = DB::table('users')->paginate(10);
Mise en page simple
La méthode paginate compte le nombre total d'enregistrements correspondant à la
requête avant de récupérer les enregistrements de la base de données. Ceci est fait
pour que le paginateur sache combien de pages d'enregistrements il y a au total.
Toutefois, si vous ne prévoyez pas d'afficher le nombre total de pages dans l'interface
utilisateur de votre application, la requête de nombre d'enregistrements n'est pas
nécessaire.
Par conséquent, si vous n'avez besoin d'afficher que de simples liens "Suivant" et
"Précédent" dans l'interface utilisateur de votre application, vous pouvez utiliser la
simplePaginateméthode pour effectuer une seule requête efficace :
// Méthode simplePaginate
$users = DB::table('users')->simplePaginate(10);
Affichage des résultats de pagination
Lors de l'appel de la méthode paginate, vous recevrez une instance de Illuminate\
Pagination\LengthAwarePaginator, tandis que l'appel de la simplePaginateméthode
renvoie une instance de Illuminate\Pagination\Paginator.
Ces objets fournissent plusieurs méthodes qui décrivent le jeu de résultats. En plus de
ces méthodes d'assistance, les instances de paginateur sont des itérateurs et peuvent
être bouclées sous forme de tableau. Ainsi, une fois que vous avez récupéré les
résultats, vous pouvez afficher les résultats et rendre les liens de page en utilisant
<div class="container">
Blade :
{{ $user->name }}
@endforeach
</div>
{{ $users->links() }}
La méthode links rendra les liens vers le reste des pages dans le jeu de
résultats. Chacun de ces liens contiendra déjà la variable page de chaîne de requête
appropriée.
Utiliser Bootstrap
Laravel inclut des vues de pagination construites à l'aide de Bootstrap CSS . Pour
utiliser ces vues au lieu des vues par défaut de Tailwind, vous pouvez appeler les
méthodes useBootstrapFour ou useBootstrapFive dans la méthode boot de votre App\
Providers\AppServiceProviderclasse :
use Illuminate\Pagination\Paginator;
public function boot(): void
{
Paginator::useBootstrapFive();
//ou Paginator::useBootstrapFour();
}
Migration
La migration en Laravel est un outil puissant qui permet de gérer facilement la
structure de la base de données de votre application. Les migrations permettent de
définir et de gérer les schémas de table de base de données à l'aide de fichiers de
migration.
Pour créer une migration en Laravel, vous pouvez utiliser la commande artisan
make:migration en passant le nom de la migration que vous souhaitez créer. Par
exemple, pour créer une migration nommée create_users_table, vous pouvez exécuter
la commande suivante :
php artisan make:migration create_users_table
Cela créera un nouveau fichier de migration dans le répertoire database/migrations.

Chaque nom de fichier de migration contient un horodatage qui permet à Laravel de
déterminer l'ordre d’exécution des migrations.
Migration
Vous pouvez maintenant ouvrir ce fichier et définir la structure de la table que vous
souhaitez créer en utilisant les méthodes fournies par Laravel, telles que up et down.
Par exemple, voici comment vous pouvez définir la structure de la table users en
utilisant les migrations :
public function up()
{
Schema::create('users', function (Blueprint $table) {
$table->id();
$table->string('name');
$table->string('email')->unique();
$table->string('password');
$table->timestamps();
});
} public function down()
{
Schema::dropIfExists('users');
}
Migration
Dans cet exemple, la méthode up définit la structure de la table users avec plusieurs
colonnes, y compris une clé primaire, des champs pour le nom, l'email, le mot de
passe, etc. La méthode down supprime simplement la table users si vous voulez
annuler la migration.
Une fois que vous avez défini votre migration, vous pouvez utiliser la commande
migrate pour exécuter toutes les migrations qui n'ont pas encore été exécutées sur la
base de données. Cette commande crée toutes les tables de base de données et les
colonnes nécessaires en utilisant les fichiers de migration.
php artisan migrate
La commande migrate:refresh supprime toutes les tables de la base de données et

réapplique toutes les migrations.
php artisan migrate:refresh
Migration
Voici quelques types de colonnes courants que vous pouvez utiliser avec $table:
$table->id() : la méthode créera une colonne id ; cependant, vous pouvez passer un
nom de colonne en paramètre si vous souhaitez attribuer un nom différent à la
colonne.
$table->string('name') : utilise une colonne de chaîne de caractères pouvant contenir
jusqu'à 255 caractères.
$table->integer('age') : utilise une colonne d'entier pouvant stocker des valeurs
entières signées allant de -2147483648 à 2147483647.
$table->boolean('is_admin') : utilise une colonne booléenne qui peut être soit true,
soit false.
$table->timestamp('created_at') : utilise une colonne de type timestamp qui stocke à
la fois la date et l'heure de création d'une ligne.
Migration
$table->float('price') : utilise une colonne de type flottant pour stocker des nombres
décimaux.
$table->date('birthdate') : utilise une colonne de type date pour stocker des dates.
Contraintes sur les colonnes :
Il est possible d'ajouter des contraintes lors de la création de la table dans une
migration Laravel en utilisant les méthodes associées telles que :
La méthode unique() peut être utilisée pour spécifier qu'une colonne doit avoir une
valeur unique pour chaque enregistrement dans la table.
$table->string('email')->unique();
La méthode primary() peut être utilisée pour définir une clé primaire sur une colonne
ou un ensemble de colonnes.
$table->string(code')->primary();
Migration
Mettre à jour une table:
Lorsque vous voulez mettre à jour une table dans Laravel, vous pouvez nommer
votre migration avec un nom descriptif de votre migration.
Par exemple, si vous souhaitez ajouter une colonne age à votre table users, vous
pouvez nommer votre migration : add_age_to_users_table
Voici comment créer une migration pour ajouter une colonne age à votre table users :
php artisan make:migration add_age_to_users_table --table=users
Ensuite, dans la méthode up() de votre migration, vous pouvez ajouter la colonne
age: public function up(){
Schema::table('users', function (Blueprint $table) {
$table->integer('age');
});
}
Migration
Voici un exemple pour ajouter une colonne phone_number à la table users existante :
{
$table->string('phone_number');
});
}
Vous pouvez également modifier une colonne existante en utilisant la méthode

change. Par exemple, pour modifier la colonne email pour qu'elle soit unique dans la
table users, vous pouvez utiliser le code suivant :
public function up() {

$table->unique('email')->change();
});
}
Migration
Les modificateurs de colonnes :
Ils sont utilisés dans les migrations de base de données pour définir les propriétés
supplémentaires des colonnes. Voici quelques exemples:
nullable() : permet à la colonne d'être nulle.

default($value) : définit une valeur par défaut pour la colonne.
unsigned() : pour les types de colonnes numériques, force la colonne à stocker
uniquement des valeurs positives.
unique() : définit la colonne comme étant unique pour chaque enregistrement dans la
table.
after($column) : spécifie que la colonne doit être placée après une autre colonne.
Migration
Voici un exemple de migration qui utilise des modificateurs de colonnes :
{
Schema::table('my_table', function (Blueprint $table) {
$table->string('email')->nullable()->unique() ->change();
$table->integer('age')->unsigned()->default(18);
$table->text('description')->after('name');
});
}
Dans cet exemple, la migration modifie la colonne email de la table my_table. La
méthode nullable() permet à la colonne d'être nulle, la méthode unique() définit la
colonne comme étant unique. La migration ajoute également une colonne age avec
une valeur par défaut de 18 et une contrainte de non-négativité. La méthode text()
crée une colonne de type texte. La méthode after('name') spécifie que la colonne
description doit être placée après la colonne name.
Migration
Contraintes de clé étrangère
Laravel prend également en charge la création de contraintes de clé étrangère, qui
sont utilisées pour forcer l'intégrité référentielle au niveau de la base de données. Par
exemple, définissons une colonne user_id sur la table posts qui fait référence à la
colonne id sur une table users :
Schema::table('posts', function (Blueprint $table) {
$table->unsignedBigInteger('user_id');
$table->foreign('user_id')->references('id')->on('users');
});
Vous pouvez également utiliser la méthode foreignId en combinaison avec
constrained() pour ajouter une clé étrangère dans Laravel. La méthode foreignId crée
une colonne de type unsignedBigInteger avec un nom qui suit la convention
nom_de_la_table_id. La méthode constrained permet de définir les détails de la
Migration
contrainte de clé étrangère.
Voici un exemple de code qui ajoute une clé étrangère user_id à la table posts en
référençant la colonne id de la table users :
Schema::table('posts', function (Blueprint $table) {
$table->foreignId('user_id')->constrained();
});
Dans cet exemple, la méthode foreignId crée automatiquement une colonne user_id
de type unsignedBigInteger. La méthode constrained prend en argument le nom de
la table cible pour la clé étrangère (dans ce cas, users). La méthode constrained utilise
les conventions de Laravel pour définir les noms des colonnes référencées et la
suppression en cascade, mais vous pouvez également spécifier ces détails
manuellement si nécessaire.
Migration
Par exemple :
$table->foreignId('user_id')
->constrained()
->onUpdate('cascade|restrict|null')
->onDelete('cascade|restrict|null');
Tout modificateur de colonne supplémentaire doit être appelé avant la

méthode constrained :
$table->foreignId('user_id')->nullable()->constrained();
Seeders
Les seeders sont utilisés pour ajouter des données initiales à votre base de données,
afin que vous n'ayez pas à le faire manuellement. Cela est particulièrement utile pour
les tests ou pour créer des données de démonstration. Nous allons apprendre
comment utiliser les seeders en Laravel pour peupler notre base de données avec des
données initiales.
Création d'un seeder
Pour créer un seeder, vous devez exécuter la commande suivante dans votre
terminal : php artisan make:seeder <nom-du-seeder>
Cette commande générera un fichier de seeder dans le dossier database/seeds. Ouvrez

le fichier de seeder généré et ajoutez les données initiales que vous souhaitez ajouter
Seeders
Par exemple, supposons que vous ayez une table "users" avec les colonnes "name",
"email" et "password". Vous pouvez ajouter des données initiales pour cette table en
utilisant le code suivant dans votre fichier de seeder :
public function run(){ use Illuminate\Support\Facades\DB;

DB::table('users')->insert([ use Illuminate\Support\Facades\Hash;
'name' => 'John Doe', use Illuminate\Support\Str;
'email' => '[email protected]',
'password' =>123 public function run(): void
]); } } {
DB::table('users')->insert([
'name' => Str::random(10),
'email' => Str::random(10).'@gmail.com',
'password' => Hash::make('password'),
]); } }
Seeders
Exécution des seeders
L'exécution des Seeders en Laravel est très simple et peut être faite en utilisant la
commande artisan db:seed. Cette commande exécute toutes les Seeders dans l'ordre
dans lequel elles ont été définies dans le fichier DatabaseSeeder.
Avant tout, vous devez définir les Seeders à exécuter : Ouvrez le fichier
DatabaseSeeder qui se trouve dans le dossier database/seeds et ajoutez les Seeders
que vous souhaitez exécuter dans la méthode run.
public function run(): void{
$this->call([
UserSeeder::class,
PostSeeder::class,
CommentSeeder::class,
]);
}
Seeders
Ensuite, ouvrez votre terminal et exécutez la commande php artisan db:seed. Laravel
exécutera toutes les Seeders dans l'ordre dans lequel elles ont été définies dans le
fichier DatabaseSeeder.
Vous pouvez également exécuter une Seeder spécifique en utilisant la commande
artisan db:seed --class=NomDeLaClasseSeeder.
php artisan db:seed --class=UsersTableSeeder
Cela exécutera uniquement la Seeder UsersTableSeeder.

Factory
Les Factory en Laravel sont un outil puissant pour générer des données de test
aléatoires et réalistes pour votre application. Elles vous permettent de créer des
modèles Eloquent avec des données de test de manière facile et rapide.
Les Factory sont des classes PHP qui vous permettent de générer des données
aléatoires pour vos modèles Eloquent. Laravel dispose d'un puissant système de
Factory qui facilite grandement cette tâche.
Création d'une Factory
Ouvrir votre terminal et exécuter la commande artisan make:model en spécifiant le
nom de votre modèle. Par exemple, si vous voulez créer un modèle User, vous
pouvez exécuter la commande suivante :
php artisan make:model User
Cela créera un nouveau fichier User.php dans le dossier app/Models.

Factory
Ouvrez le fichier User.php et ajoutez les attributs que vous souhaitez définir pour
votre modèle. Par exemple, vous pouvez ajouter les attributs suivants :
class User extends Model
{
use HasFactory;
protected $fillable = [ 'name', 'email','password', ];
}
Dans cet exemple, nous avons ajouté les attributs name, email et password à notre
modèle User.
Ouvrir votre terminal et exécuter la commande artisan make:factory en spécifiant le
nom de votre Factory et le modèle associé. Par exemple, si vous voulez créer une
Factory pour le modèle User, vous pouvez exécuter la commande suivante :
php artisan make:factory UserFactory --model=User
Cela créera un nouveau fichier UserFactory.php dans le dossier database/factories.

Factory
Sinon vous pouvez en une seule commande créer le modèle et le factorie lié a ce
modèle en utilisant la commande artisan make:model en spécifiant le nom de votre
modèle. Par exemple, si vous voulez créer un modèle User qui génère une Factory,
vous pouvez exécuter la commande suivante : php artisan make:model User -mf
Ouvrez le fichier UserFactory.php et dans la méthode definition, vous pouvez
configurer les attributs de votre modèle. Les attributs peuvent être des valeurs
aléatoires ou des valeurs spécifiques que vous souhaitez définir.
use Illuminate\Support\Facades\Faker;
public function definition(){
return [
'name' => $this->faker->name(),
'email => $this->faker->unique()->safeEmail(),
'email_verified_at' => now(),
'password' => '$2y$10$92IXU', ]; } }
Factory
Ensuite dans le seeder lié à ce factory : vous pouvez utiliser les factories pour générer
des données de test pour vos tables de base de données. Par exemple, dans un seeder
de base de données, vous pouvez utiliser le code suivant pour créer 10 utilisateurs
avec le factory UserFactory : use App\Models\User;
class UserSeeder extends Seeder

{
public function run()
{
User::factory()->count(10)->create();
}
}
Dans ce code, la méthode factory est appelée sur le modèle User, et la méthode count
est utilisée pour spécifier le nombre d'utilisateurs à générer. La méthode create est
ensuite appelée pour enregistrer les données générées dans la base de données.
ORM Eloquent
Introduction
L'application Web Laravel pourrait communiquer directement avec les tables de la
base de données. Cependant, il sera plus intéressant d’utiliser des modèles, c'est-à-
dire une représentation objet de chacune des tables
Lorsqu'on utilise une telle couche, placée entre le controlleur et la base de données,
on dira qu'on fait du mapping objet-relationnel, souvent référé comme ORM (object-
relational mapping). LORM livré avec Laravel s'appelle Eloquent.
Génération du modèle
Nous avons vu que Laravel utilise une architecture en MVC (Model View Controller)
Dans cette architecture l’intermédiaire entre le Contrôleur et la base de données est le
Model.
ORM Eloquent
ORM Eloquent
Une fois la base de données est modélisée, On doit créer des modèles pour nos tables.
Chaque table dans la BD doit correspondre à un Model qui sera utilisé pour
interagir avec la table. Le fichier dans lequel le modèle est défini sera généré à laide
de la commande
php artisan make:model Nom_Model
N.B :Pour suivre les standards de Laravel, le nom du modèle doit débuter par une
majuscule et être au singulier.
Exemple :
php artisan make:model Stagiaire
La commande précédente créera un fichier nommé Stagiaire.php placé directement

dans le dossier app/models.
ORM Eloquent
Le modèle Stagiaire est automatiquement lié à la table stagiaires. Laravel fait ce
lien si le nom de la table est exactement le nom du modèle, tout en lettre minuscules
avec en plus un s final.
Les conventions d'Eloquent pour les Models
Nom de la table : Par convention le nom du Model est le singulier du nom de la table
qui lui correspond dans la BD. Si le nom de la table est différent, il faut le spécifier
dans le model : protected $table = nom_table;
Clé primaire : Eloquent suppose également que chaque table possède une colonne de
clé primaire appelée id. Vous pouvez définir une propriété $primaryKey pour
remplacer cette convention: protected $primaryKey = "code" ;
Eloquent suppose que la clé primaire est une valeur entière incrémentée, ce qui
signifie que, par défaut, la clé primaire sera automatiquement convertie en int.
ORM Eloquent
Si vous souhaitez utiliser une clé primaire non incrémentée ou non numérique, vous
devez définir les propriétés publique $incrementing et $keyType sur votre modèle
comme suit :
public $incrementing = false;
protected $keyType= 'string;
Timestamps
Si vous ne souhaitez pas que les colonnes created_ at et updated_at soient gérées
automatiquement par Eloquent, définissez la propriété $timestamps sur votre modèle
sur false: public $timestamps = false;
ORM Eloquent
Opérations CRUD
Lorsqu'un modèle est créé et associé à une table de base de données, vous êtes prêt à
commencer à récupérer les données de la base de données. Chaque modèle Eloquent
peut être considéré comme un puissant générateur de requêtes qui vous permet
d'interroger de manière fluide la table de base de données associé au modèle.
Pour commencer, on génère une migration et un contrôleur de type ressource avec le
modèle : php artisan make:model Stagiaire -cr
Création de la route : on utilise une route resource
Route::resource('stagiaires', 'StagiaireController::class');
Cette déclaration de route unique crée plusieurs routes pour gérer diverses actions
sur la ressource( comme déjà vu dans la partie du cours contrôleur de ressource)
ORM Eloquent
Read (Lire) : Pour lire un ou plusieurs modèles à partir de la base de données, vous
pouvez utiliser la méthode all() pour récupérer tous les modèles ou la méthode find()
pour récupérer un modèle spécifique en fonction de son identifiant.
La méthode "index" récupère tous les utilisateurs de la base de données à l'aide de la
méthode "all" de l'ORM Eloquent et les stocke dans une variable appelée "users".
Elle renvoie ensuite la vue "users.index" avec les données "users".
//Affiche une liste de tous les utilisateurs.

{
$users = User::all();
return view('index', ['users' => $users]);
}
ORM Eloquent
La méthode "show" récupère un utilisateur spécifique à partir de la base de données à
l'aide de la méthode "find" de l'ORM Eloquent, en utilisant l'ID de l'utilisateur qui est
passé en paramètre. Elle renvoie ensuite la vue "users.show" avec les données de
l'utilisateur.
//Affiche les détails d'un utilisateur spécifique.
public function show($id)
{
return view('users.show', ['user' => $user]);
}
ORM Eloquent
La méthode "edit" récupère un utilisateur spécifique à partir de la base de données à
l'aide de la méthode "find" de l'ORM Eloquent, en utilisant l'ID de l'utilisateur qui est
passé en paramètre
//Affiche le formulaire de modification d'un utilisateur spécifique.

public function edit($id)
{
return view('users.edit', ['user' => $user]);
}
ORM Eloquent
Create (Créer) : Pour créer un nouveau modèle, vous pouvez instancier une
nouvelle classe User et remplir les propriétés avec les données de l'utilisateur, puis
appeler la méthode save() pour l'enregistrer dans la base de données.
La méthode "store" enregistre un nouvel utilisateur dans la base de données. Elle crée
une nouvelle instance du modèle "User", affecte les valeurs du nom, de l'e-mail et du
mot de passe à partir de la demande, hache le mot de passe à l'aide de la méthode
"make" de la classe "Hash" de Laravel, puis enregistre l'utilisateur dans la base de
données à l'aide de la méthode "save" de l'instance du modèle. Enfin, elle redirige
l'utilisateur vers la liste des utilisateurs en utilisant la méthode "redirect" de Laravel.
ORM Eloquent
//Enregistre un nouvel utilisateur dans la base de données.

{
$user = new User;
$user->name = $request[‘name’];
$user->email = $request->email;
$user->password = Hash::make($request->password);
$user->save();
return redirect()->route('users.index');
}
ORM Eloquent
Update (Mettre à jour) : Pour mettre à jour un modèle existant, vous pouvez le
récupérer à partir de la base de données en utilisant la méthode find() ou first(),
modifier ses propriétés, puis appeler la méthode save() pour enregistrer les
modifications dans la base de données.
La méthode "update" met à jour les informations d'un utilisateur spécifique dans la
base de données. Elle récupère l'utilisateur à partir de la base de données en utilisant
la méthode statique "find" de l'ORM Eloquent. Elle affecte ensuite les nouvelles
valeurs des champs "name", "email" et "password" à partir de la requête HTTP, et
utilise la fonction "Hash::make" pour hasher le nouveau mot de passe avant de
l'enregistrer dans la base de données. Enfin, elle redirige l'utilisateur vers la méthode
"index" du contrôleur.
ORM Eloquent
// Mise à jour les informations d'un utilisateur spécifique dans la base de données.
public function update(Request $request, $id)
{
$user->name = $request->name;
$user->email = $request->email;
$user->password = Hash::make($request->password);
$user->save();
}
ORM Eloquent
Delete (Supprimer) : Pour supprimer un modèle existant de la base de données,
vous pouvez le récupérer en utilisant la méthode find() ou first(), puis appeler la
méthode delete() pour le supprimer de la base de données.
La méthode "destroy" supprime un utilisateur spécifique de la base de données. Elle
récupère l'utilisateur à partir de la base de données en utilisant la méthode statique
"find" de l'ORM Eloquent, puis appelle la méthode "delete" sur l'instance du modèle
pour supprimer l'enregistrement correspondant de la base de données. Enfin, elle
redirige l'utilisateur vers la méthode "index" du contrôleur.
ORM Eloquent
/**
* Supprime un utilisateur spécifique de la base de données.
*
* @param int $id
* @return \Illuminate\Http\Response
*/
public function destroy($id)
{
$user->delete();
}
les relations de modèle dans Laravel
Eloquent
Définition
Une relation signifie que vous avez deux tables ou plus avec des enregistrements qui
sont liés les uns aux autres .
Les relations Eloquent sont définies comme des méthodes sur vos classes de modèle
Eloquent.
Étant donné que les relations servent également de puissants générateurs de requêtes ,
la définition de relations en tant que méthodes offre de puissantes capacités de
chaînage de méthodes et d'interrogation.
Eloquent
Relation (One To One)
La plus simple relation mais la moins utile. Une relation de type « Has One » ou «
One-To-One ». Cela signifie effectivement qu’un certain enregistrement est lié à un
autre enregistrement (mais pas à plusieurs autres enregistrements !).
Eloquent
la relation directe : hasOne
personnes adresses
Id Id
nom hasOne rue
prenom numero
ville
Personne_id
l’inverse de la relation : belongsTo
personnes adresses
Id
Id rue
nom belongsTo numero
prenom ville
Personne_id
Eloquent
Pour établir une relation "one to one" en Eloquent, vous devez définir la méthode
hasOne dans le modèle parent et la méthode belongsTo dans le modèle enfant.
Dans le modèle Personne:
class Personne extends Model{
public function adresse()
{
return $this->hasOne('App\Models\Adresse', ‘peronne_id');
}
}
Eloquent détermine la clé étrangère de la relation en fonction du nom du modèle

parent. Dans ce cas, le modèle Adresse est automatiquement supposé avoir une clé
étrangère personne_id. Si vous souhaitez remplacer cette convention, vous pouvez
passer un deuxième argument à la méthode hasOne.
Eloquent
Dans le modèle Adresse:
class Adresse extends Model
{
public function personne()
{
return $this->belongsTo('App\Models\Personne', ‘personne_id
');
}
}
Ici, la méthode personne() définit la relation inverse entre Adresse et Personne. Cela
signifie qu'une adresse appartient à une seule personne, et que chaque personne a
exactement une adresse.
Eloquent
Vous pouvez maintenant utiliser ces relations pour accéder aux enregistrements
associés dans les deux tables. Par exemple :
// Obtenez l'adresse d'une personne spécifique

$personne = Personne::find(1);
$adresse = $personne->adresse;
// Obtenez la personne associée à une adresse spécifique

$adresse = Adresse::find(1);
$personne = $adresse->personne;
Eloquent
Read (Lire) :
Dans le code ci-dessus, la méthode "index()" récupère toutes les personnes et les
passe à une vue pour les afficher.

{
$personnes = Personne::all();
return view('personnes.index', $personnes);
}
Eloquent
Create (Créer) : public function store(Request $request) {
$personne = new Personne;
$personne->nom = $request->nom;
$personne->prenom = $request->prenom;
$personne->save();
$adresse = new Adresse;

$adresse->rue = $request->rue;
$adresse->ville = $request->ville;
$personne->adresse()->save($adresse);
return redirect()->route('personnes.index');
}
Eloquent
Update (Modifier) :
public function update(Request $request, Personne $personne)

{
$personne->nom = $request->nom;
$personne->prenom = $request->prenom;
$personne->adresse->rue = $request->rue;
$personne->adresse->ville = $request->ville;
$personne->save();
}
Eloquent
Destroy (Supprimer) :
public function destroy(Personne $personne)

{
$personne->adresse->delete();
$personne->delete();
}
Eloquent
Relation (One To Many)
Une relation "one to many" (un-à-plusieurs) existe entre la table "filiere" et la table
"stagiaire", une filière peut avoir plusieurs stagiaires, mais chaque stagiaire ne peut
appartenir qu'à une seule filière.
Dans ce cas, la table "filiere" agirait comme l'entité parente, tandis que la table
"stagiaire" serait l'entité enfant. La clé primaire de la table "filiere" serait utilisée
comme clé étrangère dans la table "stagiaire" pour établir la relation.
Par exemple, la table "filiere" pourrait contenir les informations suivantes :
Eloquent
Et la table "stagiaire" pourrait ressembler à ceci :
Dans cet exemple, les stagiaires Alice et Bob appartiennent à la filière Informatique
(id_filiere = 1), tandis que Claire appartient à la filière Marketing (id_filiere = 2). La
colonne "id_filiere" dans la table "stagiaire" est une clé étrangère qui fait référence à
la clé primaire "id_filiere" de la table "filiere".
Eloquent
la relation directe : hasOne
filieres stagaiares
Id
Id nom
Nom_filiere hasMany
prenom
filiere_id
l’inverse de la relation : belongsTo

filieres stagaiares
Id
Id nom
Nom_filiere belongsTo prenom
filiere_id
Eloquent
Dans le modèle "Filiere", vous pouvez définir une méthode qui récupère tous les
stagiaires de la filière en utilisant la méthode "hasMany" :
Dans le modèle Filiere:
class Filiere extends Model
{
public function stagiaires()

{
return $this->hasMany(Stagiaire::class);
}
}
Eloquent
Dans le modèle "Stagiaire", vous pouvez définir une méthode qui récupère la filière à
laquelle appartient le stagiaire en utilisant la méthode "belongsTo" :
class Stagiaire extends Model

{
public function filiere()

{
return $this->belongsTo(Filiere::class);
}
}
Eloquent
Vous pouvez maintenant utiliser ces relations pour récupérer les données de la base
de données dans votre application Laravel. Par exemple, pour récupérer tous les
stagiaires d'une filière spécifique, vous pouvez utiliser la méthode "stagiaires" sur
l'objet "Filiere" :
$filiere = Filiere::find(1);
$stagiaires = $filiere->stagiaires;
Cela renverra une collection de tous les stagiaires de la filière avec l'id 1.
De même, pour récupérer la filière à laquelle appartient un stagiaire spécifique, vous
pouvez utiliser la méthode "filiere" sur l'objet "Stagiaire" :
$stagiaire = Stagiaire::find(1);
$filiere = $stagiaire->filiere;
Eloquent
Read (Lire) :
Dans le code ci-dessus, la méthode "index()" récupère toutes les stagiaires et les
passe à une vue pour les afficher.

{
$stagiaires = Stagiaire::all();
return view('stagiaires.index', $stagiaires);
}
Eloquent
Create (Créer) :

{
$filiere = Filiere:: find($request->input('filiere_id'));
$stagiaire = new Stagiaire;
$stagiaire->nom_stagiaire = $request->input('nom_stagiaire');
$stagiaire->prenom_stagiaire = $request->input('prenom_stagiaire');
$filiere->stagiaires()->save ($stagiaire);
return redirect()->route('stagiaires.index');
}
Eloquent
Update (Modifier) :
public function update(Request $request, $id){
$stagiaire = Stagiaire::find($id);
$stagiaire->nom_stagiaire = $request->input('nom_stagiaire');
$stagiaire->prenom_stagiaire = $request->input('prenom_stagiaire');
//récupérer la nouvelle filière en utilisant son ID
$nv_filiere = Filiere::find($request->input('filiere_id'));
if (!$nv_filiere->is($stagiaire->filiere)) {
// La nouvelle filière est différente de la filière déjà liée, mettez à jour la relation du
stagiaire avec la nouvelle filière en utilisant la méthode associate
$stagiaire->filiere()->associate($nv_filiere); }
$stagiaire->save();
return redirect()->route('stagiaires.index'); }
Eloquent
Destroy (Supprimer) :
public function destroy($id)

{
$stagiaire = Stagiaire::find($id);
//pour supprimer la relation du stagiaire avec sa filière, utiliser
la méthode dissociate avant la suppression du stagiaire :
$stagiaire->filiere()->dissociate();
$stagiaire->delete();
}
Eloquent
Relation (ManyTo Many)
La relation Many-To-Many en Laravel avec Eloquent ORM permet de relier deux
tables entre elles de manière à ce qu'un enregistrement d'une table puisse être associé
à plusieurs enregistrements d'une autre table, et vice versa.
supposons que les tables stagiaires et modules sont lié avec une relation many to
many et qui génère une troisième table notes qui contient la note d'un stagiaire pour
un module donné.
Ces tables sont liées par une relation Many-to-Many, où chaque "Stagiaire" peut
avoir plusieurs "Modules", et chaque "Module" peut être associé à plusieurs
"Stagiaires". La table pivot "notes" contient les notes des stagiaires pour chaque
module
Voici un exemple de données pour les trois tables que nous avons définies
ORM Eloquent
La table "stagiaires" :
La table "modules" :
La table "notes" :
ORM Eloquent
Remarque : Il faut donc au préalable créer également une migration pour la table
d’association. le nom de la table est construit en joignant les noms des tables (tous
deux au singulier) dans L'ordre alphabétique. Cela permet à Laravel de faire
directement le lien entre les tables sans avoir à préciser le nom de la table de relation.
Si le nom de la table de relation many-to-many entre les deux tables ne correspond
pas à la convention de nommage de Laravel, vous pouvez le spécifier en utilisant le
deuxième argument de la méthode belongsToMany().
Par défaut, Eloquent va chercher une table de liaison qui combine les noms de
modèle en ordre alphabétique et en utilisant le singulier de chaque nom. Par exemple,
si nous avons un modèle User et un modèle Role, Eloquent va chercher une table de
liaison nommée role_user.
ORM Eloquent
Si le nom de votre table de liaison ne suit pas cette convention de nommage, vous
pouvez spécifier le nom de la table de liaison en utilisant le deuxième argument de la
méthode belongsToMany(). Par exemple, si la table de liaison est nommée
user_roles, vous pouvez le spécifier comme suit :

{
public function roles()
{
return $this->belongsToMany(Role::class, 'user_role');
}
}
ORM Eloquent
La convention recommandée pour les clés étrangères dans Laravel est de nommer la
clé étrangère en utilisant le nom de la table parente auquel il fait référence, suivi de
l'underscore (_) et de la clé primaire de la table parente. Par exemple, si vous avez
une table "users" avec une clé primaire "id" qui est référencée par une table "posts",
la clé étrangère dans la table "posts" devrait être nommée "user_id".
Si ce n’est pas le cas, vous pouvez spécifier les noms des clés étrangères en utilisant
la méthode belongsToMany() dans votre modèle Laravel.
{
public function roles()
{
return $this->belongsToMany(Role::class, 'role_user', 'user_id', 'role_id');
}
}
ORM Eloquent
Dans cet exemple, la méthode belongsToMany() prend quatre arguments :
Le premier argument est le nom de la classe de modèle à laquelle vous voulez vous
connecter (Role::class).
Le deuxième argument est le nom de la table de relation (user_role).
Le troisième argument est le nom de la clé étrangère de la table de relation qui fait
référence à la table de modèle actuelle (user_id pour le modèle "User").
Le quatrième argument est le nom de la clé étrangère de la table de relation qui fait
référence à la table de modèle cible (role_id pour le modèle "Role").
ORM Eloquent
Dans cette migration, vous pouvez ajouter les colonnes que vous souhaitez dans la
table "modules", par exemple :
Schema::create('modules', function (Blueprint $table) {
$table->id();
$table->string('nom');
$table->text('description');
});
table "stagiaires", par exemple :
Schema::create('stagiaires', function (Blueprint $table) {
$table->id();
$table->string('nom');
$table->string('prenom');
});
ORM Eloquent
table "notes", par exemple :
Schema::create('notes', function (Blueprint $table) {

$table->id();
$table->unsignedBigInteger('module_id');
$table->unsignedBigInteger('stagiaire_id');
$table->integer('note');
$table->foreign('module_id')->references('id')->on('modules');
$table->foreign('stagiaire_id')->references('id')->on('stagiaires');
});
Eloquent
Créez les modèles "Module", "Stagiaire":
class Module extends Model
{
public function stagiaires()
{
return $this->belongsToMany(Stagiaire::class, 'notes')->withPivot('note');
}
}
class Stagiaire extends Model

{
public function modules()
{
return $this->belongsToMany(Module::class, 'notes')->withPivot('note');
}
}
Eloquent
Dans la relation many-to-many entre les modèles "Module" et "Stagiaire" avec une
table de relation nommée "notes", il n'est pas obligatoire de créer un modèle pour la
table de relation "notes".
Laravel gère automatiquement cette table de relation lors de la récupération et de la
sauvegarde des relations many-to-many entre les modèles "Module" et "Stagiaire".
Cependant, si vous avez ajouté des colonnes supplémentaires dans la table de relation
"notes" que vous souhaitez utiliser dans votre application, vous pouvez créer un
modèle pour cette table et utiliser la méthode withPivot() pour spécifier les colonnes
pivot supplémentaires que vous avez ajoutées.
Eloquent
class Note extends Model
{
protected $table = 'notes';
protected $fillable = ['module_id', 'stagiaire_id', 'note'];
public function module()

{
return $this->belongsTo(Module::class);
}
public function stagiaire()

{
return $this->belongsTo(Stagiaire::class);
}
}
Eloquent
Dans cet exemple, nous avons récupéré un module à l'aide de Module::find(1) et
avons accédé à la relation many-to-many avec module->stagiaires. Nous avons
ensuite parcouru les stagiaires pour ce module et avons accédé aux colonnes pivot
"note" et "date" à l'aide de la méthode pivot->note et pivot->date.
$module = Module::find(1);
$stagiaires = $module->stagiaires;
foreach ($stagiaires as $stagiaire) {

$note = $stagiaire->pivot->note;
$date = $stagiaire->pivot->date;
echo "Stagiaire : {$stagiaire->nom}, Note : {$note}, Date : {$date} <br>";
}
ORM Eloquent
Create (Créer) : Voici un exemple d'utilisation de la méthode attach() pour attacher
un nouveau stagiaire à un nouveau module avec une nouvelle note :
// On crée un nouveau stagiaire
$stagiaire = new Stagiaire();
$stagiaire->nom = 'Durand';
$stagiaire->prenom = 'Sophie';
$stagiaire->save();
// On crée un nouveau module
$module = new Module();
$module->nom = 'JavaScript';
$module->save();
// On attache le stagiaire au module avec une note
$module->stagiaires()->attach($stagiaire, ['note' => 18, 'date' => '2023-04-20']);
ORM Eloquent
Dans cet exemple, nous créons un nouveau stagiaire avec le nom "Durand" et le
prénom "Sophie", et un nouveau module avec le nom "JavaScript". Ensuite, nous
utilisons la méthode attach() pour attacher le stagiaire au module avec une note de 18
et une date de '2023-04-20'. Cette méthode va créer une nouvelle ligne dans la table
"Stagiaire", une nouvelle ligne dans la table "Module", et une nouvelle ligne dans la
table de liaison "notes", qui lie le stagiaire et le module.
ORM Eloquent
Update (Modifier) : Voici un exemple d'utilisation de la méthode
updateExistingPivot() pour modifier la note d'un stagiaire pour un module existant :
// On récupère le stagiaire et le module existants

// On met à jour la note du stagiaire pour ce module

$module->stagiaires()->updateExistingPivot($stagiaire->id, ['note' => 14, 'date' =>
'2023-04-21']);
ORM Eloquent
Dans cet exemple, nous récupérons un stagiaire existant avec l'identifiant 1 et un
module existant avec l'identifiant 2. Ensuite, nous utilisons la méthode
updateExistingPivot() pour mettre à jour la note du stagiaire pour ce module avec une
note de 14 et une date de '2023-04-21'. Cette méthode va modifier la ligne
correspondante dans la table de liaison "notes".
Notez que cette méthode doit être utilisée uniquement si le lien existe déjà dans la
table de liaison "notes". Si le lien n'existe pas encore, vous devez utiliser la méthode
attach() comme expliqué précédemment.
ORM Eloquent
Destroy (Supprimer) : Voici un exemple d'utilisation de la méthode detach() pour
supprimer le lien entre un stagiaire et un module :
// On récupère le stagiaire et le module existants

// On détache le stagiaire du module

$module->stagiaires()->detach($stagiaire->id);
ORM Eloquent
Dans cet exemple, nous récupérons un stagiaire existant avec l'identifiant 1 et un
module existant avec l'identifiant 2. Ensuite, nous utilisons la méthode detach() pour
supprimer le lien entre le stagiaire et le module. Cette méthode va supprimer la ligne
correspondante dans la table de liaison "notes". Si vous voulez supprimer
complètement le stagiaire ou le module, vous devez utiliser la méthode delete() sur
l'objet correspondant.
Authentification
Pour définir l'authentification dans un projet Laravel sans utiliser l'authentification
par défaut fournie par Laravel, voici les étapes à suivre :
Créer une table pour stocker les informations des utilisateurs : Vous pouvez utiliser
Laravel's migration system pour créer la table avec les colonnes nécessaires comme
l'email et le mot de passe.
Créer un formulaire de connexion : Créez un formulaire de connexion qui demande
l'email et le mot de passe de l'utilisateur.
Valider les informations d'identification de l'utilisateur : Lorsque le formulaire est
soumis, validez les informations d'identification de l'utilisateur en vérifiant si l'email
et le mot de passe correspondent à un utilisateur dans la base de données.
Créer une session pour l'utilisateur : Si les informations d'identification de
l'utilisateur sont valides, créez une session pour l'utilisateur pour qu'il puisse rester
Authentification
connecté.
Protéger les routes : Pour vous assurer que seuls les utilisateurs authentifiés peuvent
accéder à certaines pages, utilisez Laravel's middleware pour protéger ces routes.
Ajouter une fonctionnalité de déconnexion : Enfin, ajoutez une fonctionnalité de
déconnexion pour permettre aux utilisateurs de se déconnecter de l'application.
Authentification
Voici un exemple de code pour mettre en place une authentification personnalisée :
1. Créez une migration pour la table des utilisateurs :
php artisan make:migration create_users_table
2. Créez un formulaire de connexion avec les champs nécessaires :

<form action="{{route('login')}}" method="post">
@csrf
<input type="email" name="email" id="">
<input type="password" name="password" id="">
<input type="submit" value="Se Connecter">
</form>
3. Apres soumission du formulaire de connexion, la fonction login est appelée

Authentification
public function login(Request $request)
{
$credentials = $request->only('email', 'password');
if (Auth::attempt($credentials)) {
// Authentication passed...
// Auth::login($user);
return redirect()->intended('accueil');
}
return redirect()->back()->withErrors(['email' => 'Invalid
credentials']);
}
Authentification
Tout d'abord, la fonction récupère les informations d'identification soumises par
l'utilisateur via la requête $request->only('email', 'password').
Ensuite, elle appelle la fonction Auth::attempt($credentials) pour tenter d'authentifier
l'utilisateur en utilisant ces informations d'identification.
Si l'authentification réussit, Laravel crée automatiquement une session pour
l'utilisateur authentifié via la méthode Auth::attempt(). Cette session contient l'ID de
l'utilisateur, qui est utilisé pour identifier l'utilisateur dans les requêtes suivantes.
Ensuite l'utilisateur est redirigé vers la page d'accueil de l'application avec la fonction
redirect()->intended('accueil').
Si l'authentification échoue, l'utilisateur est redirigé vers la page de connexion avec
un message d'erreur en utilisant la fonction redirect()->back()->withErrors(['email'
=> 'Invalid credentials']).
Authentification
Pour afficher cette erreur dans la vue, vous pouvez utiliser la syntaxe Blade suivante :
{{ $errors->first('email') }}
Il est important de noter que la fonction Auth::attempt($credentials) utilise le modèle

User de Laravel pour trouver l'utilisateur correspondant aux informations
d'identification soumises. Si vous utilisez une table de base de données différente
pour stocker les informations d'utilisateur, vous devrez modifier la configuration
d'authentification de Laravel pour qu'elle utilise votre table au lieu de la table users
par défaut.
4. Vous pouvez ensuite accéder aux propriétés de l'utilisateur, telles que son nom, son
adresse e-mail, etc.
vous êtes authentifier {{ Auth::user()->name}}
<a href="{{url('logout')}}">se déconnecter</a>
Authentification
5. Ajouter une fonctionnalité de déconnexion :
Vous pouvez ajouter une fonctionnalité de déconnexion pour permettre aux
utilisateurs de se déconnecter de l'application. Laravel fournit une méthode de
déconnexion pratique :
public function logout(){
Auth::logout();
return redirect('/login');
}
6. Protéger les routes :

Vous pouvez protéger les routes nécessitant une authentification en utilisant Laravel's
middleware. Par exemple :
Route::get('/accueil', function () {
return view('accueil');
})->middleware('auth');
Authentification
Route::get('/login', function () {
if (Auth::check()) {
return redirect('/accueil');
}
return view('login');
});
Ce code définit une route pour afficher le formulaire de connexion (/login). Si
l'utilisateur est déjà connecté, il sera redirigé vers la page d'accueil (/accueil). Sinon,
la vue login sera affichée.
Le code utilise la méthode Auth::check() pour vérifier si l'utilisateur est connecté. Si
c'est le cas, la méthode renvoie true, sinon elle renvoie false.
La méthode Auth::check() utilise la session pour déterminer si l'utilisateur est
connecté ou non. Si la session contient des informations d'identification valides, la
méthode renvoie true. Sinon, elle renvoie false.
Authentification de laravel
L’authentification constitue une tâche fréquente. En effet, il y a souvent des parties
d’un site qui ne doivent être accessibles qu’à certains utilisateurs, ne serait-ce que
l’administration. La solution proposée par Laravel est d’une grande simplicité parce
que tout est déjà préparé comme nous allons le voir.
En résumé, pour l’authentification on a la possibilités d’utiliser laravel/breeze qui
utilise Tailwind
La base de données
Par défaut la partie persistance de l’authentification (c’est à dire la manière de
retrouver les renseignements des utilisateurs) avec Laravel se fait en base de données
avec Eloquent et part du principe qu’il y a un modèle App\Models\User (dans le
dossier app).
Lors de l’installation, il existe déjà des migrations :
Repartez d’une installation vierge et faites la migration avec Artisan :
Vous devriez normalement obtenir ces tables :

Les middlewares
Les middlewares servent à effectuer un traitement à l’arrivée (ou au départ) des
requêtes HTTP. Dans ce chapitre on va voir deux autres middlewares qui vont nous
permettre de savoir si un utilisateur est authentifié ou pas pour agir en conséquence.
Middleware auth
Le middleware auth permet de n’autoriser l’accès qu’aux utilisateurs authentifiés,
donc de protéger des routes. Ce middleware est déjà présent et déclaré dans app\Http\
Kernel.php.
On peut utiliser ce middleware directement sur une route :
Route::get('comptes', function() {
// Réservé aux utilisateurs authentifiés
})->middleware('auth');
Que ce passe-t-il quand un utilisateur n’arrive pas à s’authentifier ? Par défaut il est
renvoyer vers la route nommée login, ce qui paraît logique.
Les routes de l’authentification
Dans l’installation de base vous ne trouvez aucune route pour l’authentification. Pour
les créer (et ça ne créera pas seulement les routes) il faut déjà installer un package :
composer require laravel/breeze --dev
Une fois que le package est installé vous pouvez lancer cette commande :
php artisan breeze:install
C’est avec cette commande que vont être créés les routes, vues, controlleurs…Là on
nous pose une question :
On va choisir la première option blade. Répondez aussi non aux deux questions
suivantes.
Regardez ce qui a été ajouté dans le fichier routes/web.php :
Route::get('/dashboard', function () {
return view('dashboard');
})->middleware(['auth', 'verified'])->name('dashboard');
Route::middleware('auth')->group(function () {
Route::get('/profile', [ProfileController::class, 'edit'])->name('profile.edit');
Route::patch('/profile', [ProfileController::class, 'update'])->name('profile.update');
Route::delete('/profile', [ProfileController::class, 'destroy'])->name('profile.destroy');
});
require __DIR__.'/auth.php';
Les vues de l’authentification
Il y a également eu la génération de nombreuses vues :
La création de l’utilisateur
La création de l’utilisateur se fait aussi dans le contrôleur :
public function store(Request $request): RedirectResponse
{
$user = User::create([
'name' => $request->name,
'email' => $request->email,
'password' => Hash::make($request->password),
]);
}
Une fois que l’utilisateur est créé dans la base il est automatiquement connecté et est
redirigé sur le dashboard :
La connexion d’un utilisateur
Pour se connecter, il faut utiliser l’url …/login.
Si vous venez juste d’enregistrer un utilisateur il faudra le déconnecter avant d’avoir
accès au formulaire de login.
On voit qu’on utilise le contrôleur AuthenticatedSessionController avec sa
méthode create qui se contente de renvoyer une vue :
public function create(): View
{
return view('auth.login');
}
La déconnexion d’un utilisateur
L’utilisateur dispose d’un lien pour se déconnecter :
Si on clique sur Logout on utilise l’url …/logout et cette route ::

Notification
Laravel dispose d’un système complet de notifications, par exemple par emails.
Classiquement, une notification est un court message pour informer un utilisateur
qu’il s’est passé quelque chose qui le concerne dans l’application.
Par exemple, une donnée sensible a été mise à jour, on envoie un email en informant
l’utilisateur de ce changement et, si ce n’est pas lui qui l’a effectué, il peut alors
intervenir.
Organisation du code
Il y a une commande d’artisan pour créer une notification :
php artisan make:notification MaNotification
Les notifications se trouvent dans le dossier app/Notifications, Ce dossier n’existe

pas dans l’installation de base de Laravel, il est ajouté lorsqu’on crée la première
notification avec Artisan.
Notification
Exemple
On va à nouveau partir d’une installation vierge de Laravel avec Breeze. On va
décider d’envoyer un email à un utilisateur qui s’enregistre avec succès. On
commence par créer la notification avec Artisan :
php artisan make:notification RegisteredNotification
On va modifier la fonction toMail pour changer le message :

public function toMail($notifiable)
{
return (new MailMessage)->line('Vous avez bien été enregistré sur notre site !');
}
Notification
Il ne reste plus qu’à envoyer la notification à partir de la méthode store du contrôleur
RegisteredUserController :
use App\Notifications\RegisteredNotification;
...
protected function store(Request $request): RedirectResponse

{
...
$user = User::create([
'name' => $request->name,
'password' => Hash::make($request->password),
]);
$user->notify(new RegisteredNotification());
...
}
Notification
Maintenant quand un utilisateur s’enregistre il reçoit un email :
Notification
Le renouvellement du mot de passe
Laravel, après la demande de renouvellement du mot de passe de l’utilisateur,
expédie ce genre d’email :
Par défaut, la classe de notification se situe dans le framework :
Pour voir plus de détails : https://laravel.sillo.org/cours-laravel-10-les-notifications/

Les événements
Laravel offre de nombreuses fonctionnalités pour la gestion des événements et la
mise en place de systèmes de messagerie basés sur des événements.
Voici quelques éléments clés à connaître sur les événements en Laravel :
Les événements en Laravel permettent de déclencher des actions lorsqu'un certain
événement se produit dans l'application.
Les événements peuvent être définis dans des classes appelées "events" qui sont
généralement stockées dans le dossier "app/Events".
Lorsqu'un événement est déclenché, il peut être écouté par des "listeners" qui sont
des classes qui répondent à l'événement et définies dans le dossier "app/Listeners".
Les listeners peuvent être enregistrés dans le fichier "EventServiceProvider" pour
qu'ils soient automatiquement chargés lors du démarrage de l'application.
Les événements peuvent être utilisés pour créer des notifications en temps réel.
Les événements
Exemple :
Dans la méthode store du contrôleur StagiaireController, ajouter le code pour ajouter
un nouveau stagiaire dans la base de données :
class StagiaireController extends Controller{

{
$stagiaire = Stagiaire::create([
'nom' => $request->nom,
'prenom' => $request->prenom,
]);
event(new StagiaireCreated($stagiaire));
}
}
Les événements
Le contrôleur StagiaireController contient une méthode store qui crée un nouveau
stagiaire en utilisant la méthode create du modèle Stagiaire et déclenche un
événement StagiaireCreated en passant le stagiaire nouvellement créé comme
argument. Enfin, il redirige l'utilisateur vers la liste des stagiaires.
Créer un événement StagiaireCreated dans une classe StagiaireCreated dans le fichier
app/Events/StagiaireCreated.php : php artisan make:event StagiaireCreated
class StagiaireCreated{
use Dispatchable, SerializesModels;
public $stagiaire;
public function __construct(Stagiaire $stagiaire)

{
$this->stagiaire = $stagiaire;
}
}
Les événements
Dans cet exemple, la classe StagiaireCreated est l'événement déclenché lorsqu'un
nouveau stagiaire est créé. Cette classe utilise les traits Dispatchable et
SerializesModels pour permettre la diffusion de l'événement et la sérialisation des
modèles. La classe a une propriété $stagiaire qui contient le stagiaire nouvellement
créé et une méthode __construct qui reçoit ce stagiaire comme argument et l'assigne à
la propriété $stagiaire.
Dans le fichier app/Providers/EventServiceProvider.php, ajouter une liaison entre
l'événement StagiaireCreated et son écouteur :
protected $listen = [
Registered::class => [
SendEmailVerificationNotification::class,],
StagiaireCreated::class => [
SendStagiaireCreatedNotification::class,],
];
Les événements
Créer un écouteur SendStagiaireCreatedNotification pour envoyer une notification
lorsqu'un nouveau stagiaire est créé dans le fichier
app/Listeners/SendStagiaireCreatedNotification.php :
php artisan make:listener SendStagiaireCreatedNotification --event= StagiaireCreated
class SendStagiaireCreatedNotification
{
public function handle(StagiaireCreated $event)
{
$event->stagiaire->notify(new StagiaireCreatedNotification($event->stagiaire));
}
}
Créer une notification StagiaireCreatedNotification pour notifier l'administrateur de
l'ajout d'un nouveau stagiaire dans le fichier
app/Notifications/StagiaireCreatedNotification.php : comme déjà vu précédemment.
Les événements
class StagiaireCreatedNotification extends Notification
{
use Queueable;
public $stagiaire;
public function __construct(Stagiaire $stagiaire)

{
$this->stagiaire = $stagiaire;
}
public function toMail($notifiable)

{
return (new MailMessage)
->subject('Nouveau stagiaire ajouté')
->line('Un nouveau stagiaire a été ajouté : ' . $this->stagiaire->nom . ' ' . $this-
>stagiaire->prenom)
->action('Voir le profil', url('/stagiaires/' . $this->stagiaire->id))
->line('Merci d\'utiliser notre application.');
}
}
Les sessions
Étant donné que les applications pilotées par HTTP sont sans état, les sessions
fournissent un moyen de stocker des informations sur l'utilisateur à travers plusieurs
requêtes. donc il est important de disposer d’un système qui permet de mémoriser des
informations entre deux requêtes. C’est justement l’objet des sessions.
Le fichier de configuration de session de votre application est stocké dans
config/session.php. Par défaut, Laravel est configuré pour utiliser le driver file de
session, qui fonctionnera bien pour de nombreuses applications.
Par défaut c’est un fichier (dans storage/framework/sessions) qui mémorise les
informations des sessions, mais on peut aussi utiliser : les cookies, la base de
données, tableau (utilisé pour les tests), dynamodb, memcached, redis…
L'option driver de configuration de session définit où les données de session seront
stockées pour chaque demande.
Les sessions
Laravel est livré avec plusieurs excellents pilotes prêts à l'emploi :
file- les sessions sont stockées dans storage/framework/sessions.
cookie- les sessions sont stockées dans des cookies sécurisés et cryptés.
database- les sessions sont stockées dans une base de données relationnelle.
memcached/ redis- les sessions sont stockées dans l'un de ces magasins rapides
basés sur le cache.
dynamodb- les sessions sont stockées dans AWS DynamoDB.
array- les sessions sont stockées dans un tableau PHP et ne seront pas
persistantes.
Les sessions
Stocker des données
Pour stocker des données dans la session, vous utiliserez généralement la méthode de
l'instance de requête ou l' assistant global put :session
// Via a request instance...
$request->session()->put('key', 'value');
// Via the global "session" helper...

session(['key' => 'value']);
Pousser vers les valeurs de session du tableau

push peut être utilisé pour pousser une nouvelle valeur sur une valeur de session qui
est un tableau. Par exemple, si la user.teamsclé contient un tableau de noms d'équipe,
vous pouvez insérer une nouvelle valeur dans le tableau comme suit :
$request->session()->push('teams', 'developers');
Les sessions
Récupération des données
Il existe deux manières principales de travailler avec les données de session dans
Laravel : l'assistant global session et via une Request instance. Tout d'abord,
examinons l'accès à la session via une Request instance, qui peut être indiquée sur
une fermeture de route ou une méthode de contrôleur.
$request->session()->get('key');
Vous pouvez également utiliser la fonction PHP globale session pour récupérer et
stocker des données dans la session. Lorsque l'assistant session est appelé avec un
seul argument de chaîne, il renverra la valeur de cette clé de session. Lorsque
l'assistant est appelé avec un tableau de paires clé/valeur, ces valeurs seront stockées
dans la session : session('key');
Les sessions
Récupération de toutes les données de session
Si vous souhaitez récupérer toutes les données de la session, vous pouvez utiliser la
all méthode : $data = $request->session()->all();
Déterminer si un élément existe dans la session

Pour déterminer si un élément est présent dans la session, vous pouvez utiliser la has
méthode.
La méthode has renvoie true si la valeur est présente et null si la valeur n’existe pas.
if ($request->session()->has('users'))
Suppression de données
La forget méthode supprimera une donnée de la session. Si vous souhaitez supprimer
toutes les données de la session, vous pouvez utiliser la flush méthode :
Les sessions
// Forget a single key...
$request->session()->forget('name');
// Forget multiple keys...

$request->session()->forget(['name',
'status']);
$request->session()->flush();
if (session()->has('error')) ...
Ces informations demeurent pour le même client à travers ses requêtes. Laravel
s’occupe de ces informations, on se contente de lui indiquer un couple clé-valeur et il
s’occupe de tout.
Créer un journal de log personnalisé
Lorsque nous développons une nouvelle application avec le framework Laravel,
surtout dans la phase de développement active, nous aimons bien suivre tout ce qu’il
se passe dans les moindres détails.
Nous avons besoin de suivre ce qu’il se passe. Surtout que certaines de nos
commandes dans Laravel traitent de gros volumes de données. Au final, on se
retrouve à faire des millions d’appels vers des services externes, donc des erreurs
arrivent et on a besoin de savoir précisément où ça coince avant que tout soit stable
des deux cotés.
Le fichier de log par défaut de Laravel
Lorsque vous installez le framework Laravel et que vous commencez à l’utiliser, à
moins que vous soyez très fort, des erreurs vont se produire. C’est normal, je ne
compte plus le nombre d’erreurs que je vois par jour.
L’erreur s’affiche alors sur votre navigateur ou dans votre terminal et Laravel va alors
automatiquement remplir le fichier de log de base. Ce fichier se trouve dans le
dossier storage et ensuite dans le sous-dossier logs. Il est par défaut sobrement appelé
laravel.log.
Le chemin exact du fichier de log par défaut dans Laravel est :
/storage/logs/laravel.log
Tout cela, c’est très bien, mais chaque fois qu’une erreur va se produire, peu importe
son origine, elle va remplir ce fichier laravel.log. Ce n’est pas un problème et c’est
très bien d’avoir une trace. Ce fichier laravel.log de base qui est très utile pour
développer son application va malheureusement être un peu trop pollué. C’est pour
cela qu’on va commencé à créer nos propres fichiers journaux d’événements.
Logging dans Laravel : le niveau de gravité des messages
Le système de logging de Laravel dispose de plusieurs niveaux d’alerte pour qualifier
la nature des messages. On va en parlé avant de montrer comment créer
techniquement ce nouveau fichier de log personnalisé, car ce concept est important
pour la suite. Si vous voulez par la suite exploiter ce fichier de log facilement, autant
renseigner correctement ses messages dedans.
Voici les différents niveaux de gravité des logs, du plus important au moins
important:
emergency : les erreurs les plus graves, qui nécessitent une intervention immédiate,
comme un système en panne ou un service indisponible.
alert : une très grosse erreur qui doit être corrigée immédiatement, comme une base
de données indisponible.
critical : représente une erreur critique, comme une défaillance sur une partie de
votre application ou une API indisponible par exemple.
error : une erreur générique mais qui peut avoir des conséquences importantes,
comme une erreur de syntaxe dans une requête SQL.
warning : ce n’est pas une erreur mais ce que vous mettez derrière ce message mérite
une attention particulière, comme une ressource proche de la limite.
notice : une information intéressante pour le suivi du système, comme un utilisateur
qui se connecte ou une opération réussie.
info : des informations générales sur le système, comme les messages d’initialisation
ou les résultats d’opérations.
debug : les informations de débogage, utiles lorsque vous êtes en train de développer
votre application pour suivre ce qu’il se passe.
Bien évidemment, vous pouvez les utiliser comme vous voulez, c’est juste à titre
d’information pour la lecture. Vous pouvez sans souci log une erreur pas grave du
tout dans emergency si vous en avez envie.
Comment ajouter son journal de logs personnalisé dans Laravel
Pour faire fonctionner notre nouveau fichier de log, il faut donc modifier le
fichier : /config/logging.php.
Une fois dans ce fichier, il vous suffit d’ajouter le code suivant dans le tableau
'channels'
général channels : => [
// ...
'custom' => [
'driver' => 'daily',
'path' => storage_path('logs/custom.log'),
'level' => 'debug',
'days' => 7,
],],
Dans cet exemple, le canal de journalisation custom est créé avec le driver daily, ce
qui signifie que les messages sont enregistrés dans un fichier journal quotidien. Le
chemin du fichier journal est spécifié par l'option path, qui utilise la fonction
storage_path() pour obtenir le répertoire de stockage de l'application. Le niveau de
gravité du journal est spécifié par l'option level, qui est réglé sur debug pour
enregistrer tous les messages. Enfin, l'option days spécifie la durée de conservation
des fichiers journaux.
Une fois que vous avez créé un nouveau canal de journalisation, vous pouvez
l'utiliser pour enregistrer des messages dans votre application en utilisant la classe
Log de Laravel. Par exemple, pour enregistrer un message d'erreur dans le canal
custom, vous pouvez utiliser le code suivant :
use Illuminate\Support\Facades\Log;
Log::channel('custom')->error('Une erreur s\'est produite');
Dans cet exemple, la méthode channel est utilisée pour sélectionner le canal custom,
et la méthode error est utilisée pour enregistrer un message d'erreur avec le texte 'Une
erreur s'est produite'. Ce message sera enregistré dans le fichier journal
storage/logs/custom.log.
Cette instruction peut être utilisée n'importe où dans votre code pour enregistrer un
message d'erreur dans le canal de journalisation custom. Cela peut être utile dans des
situations où une erreur se produit et que vous souhaitez enregistrer des informations
sur cette erreur dans le fichier journal pour l'analyser plus tard.

Laravel

Transféré par

Droits d'auteur :

Formats disponibles

Laravel

Transféré par

Informations du document

Copyright

Formats disponibles

Partager ce document

Partager ou intégrer le document

Options de partage

Avez-vous trouvé ce document utile ?

Ce contenu est-il inapproprié ?

Droits d'auteur :

Formats disponibles

Laravel

Transféré par

Droits d'auteur :

Formats disponibles

ROYAUME DU MAROC

‫مكتب التكوين المهني وإنعاش الشغل‬

MODULE 205 : Développer en back-end

Créer notre premier projet laravel (project_laravel) :

On peut maintenant se poser une question : est-il vraiment indispensable de créer 3

<a href="{{ route('product.show', ['id' => $product->id]) }}">Voir les détails</a>

Route::get('/user/{id}/profile', function ($id) {//…})->name('profile');

@for ($i = 0; $i < 10; $i++)

@foreach ($users as $user)

@foreach ($users as $user)

<li>{{ $user->name }}</li>

Lors de la transmission d'informations de cette manière, les données doivent être un

Cela va créer un contrôleur de ressources nommé MyResourceController avec des

dans l'attribut action on a : /accueil (penser à créer une page accueil)

class UserController extends Controller

Remplacez "nom_de_votre_base_de_donnees", "votre_nom_d_utilisateur" et

Utilisez la méthode DB::select() pour exécuter une requête de sélection et récupérer

DB::delete('DELETE FROM table_name WHERE id = ?', [$id]);

<form action="/upload" method="POST"

// Définit le nom du fichier

// Stocke le fichier dans le dossier storage/app/public/images de votre application

DB::insert('insert into stagaires Values

<img width="100" src="{{ asset('storage/images/'.$Stagiare->image) }}">

Dans cet exemple, la méthode DB::beginTransaction() commence une transaction,

La configuration de la base de données

en utilisant la méthode where en Laravel, il est possible d'utiliser d'autres opérateurs

De plus, il est également possible d'utiliser les méthodes whereNotBetween et

4. Agréger des données :

10. Supprimer des données :

Cela créera un nouveau fichier de migration dans le répertoire database/migrations.

La commande migrate:refresh supprime toutes les tables de la base de données et

Vous pouvez également modifier une colonne existante en utilisant la méthode

public function up() {

nullable() : permet à la colonne d'être nulle.

Tout modificateur de colonne supplémentaire doit être appelé avant la

Cette commande générera un fichier de seeder dans le dossier database/seeds. Ouvrez

public function run(){ use Illuminate\Support\Facades\DB;

Cela exécutera uniquement la Seeder UsersTableSeeder.

Cela créera un nouveau fichier User.php dans le dossier app/Models.

Cela créera un nouveau fichier UserFactory.php dans le dossier database/factories.

class UserSeeder extends Seeder

La commande précédente créera un fichier nommé Stagiaire.php placé directement

//Affiche une liste de tous les utilisateurs.

//Affiche le formulaire de modification d'un utilisateur spécifique.

//Enregistre un nouvel utilisateur dans la base de données.

Eloquent détermine la clé étrangère de la relation en fonction du nom du modèle

// Obtenez l'adresse d'une personne spécifique

// Obtenez la personne associée à une adresse spécifique

public function index()

$adresse = new Adresse;

public function update(Request $request, Personne $personne)

public function destroy(Personne $personne)

l’inverse de la relation : belongsTo

public function stagiaires()

class Stagiaire extends Model

public function filiere()

public function index()

public function store(Request $request)

public function destroy($id)

class User extends Model