2023

Introduction Au Développement Web Et Api

Avec Laravel

TOUALY REGIS
Yere.toualy@produitbat.ci
11/06/2023
 Contenu
Séance 1 :......................................................................................................................... 2
Module 1 : Introduction à Laravel .................................................................................. 2
Module 2 : Structure d'un projet Laravel......................................................................... 5
Séance 2 :......................................................................................................................... 9
Module 3 : Les contrôleurs ............................................................................................ 9
Module 4 : Bases de données et Eloquent ORM............................................................ 12
Séance 3 :....................................................................................................................... 16
Module 5 : Relations avec Eloquent ............................................................................. 16
Module 6 : Validation des données ............................................................................... 21
Séance 4 :....................................................................................................................... 22
Module 7 : Authentification et autorisation ................................................................... 22
Module 8 : Gestion des fichiers et des images ............................................................... 23
Séance 5 :....................................................................................................................... 24
Module 9 : API et développement d'applications mobiles............................................... 24
Module 10 : Sécurité ................................................................................................... 25
Séance 6 :....................................................................................................................... 25
Exercice d’application ................................................................................................. 25
Evaluation .................................................................................................................. 25
Séance 1 :
Module 1 : Introduction à Laravel
1. Qu'est-ce que Laravel ?
Laravel est un framework de développement web et api open-source écrit en PHP. Il a
été créé par Taylor Otwell en 2011et est devenu l'un des frameworks PHP les plus populaires et
les plus appréciés par la communauté des développeurs.
Laravel adopte une approche élégante et expressive du développement, en mettant
l'accent sur la simplicité, la clarté du code et la productivité. Il offre de nombreuses
fonctionnalités avancées qui simplifient le développement d'applications web robustes et
évolutives.

2. Avantages de l'utilisation de Laravel

Voici quelques points clés à connaître sur Laravel :

• Architecture MVC : Laravel suit le modèle de conception MVC (Modèle-Vue-

Contrôleur), qui permet de séparer les préoccupations et de maintenir une structure
organisée de l'application.
• Routage convivial : Laravel propose un système de routage simple et intuitif. Vous
pouvez définir facilement des routes pour gérer les requêtes HTTP entrantes et définir
les actions correspondantes.
• Gestion des vues : Avec Laravel, vous pouvez créer des vues conviviales à l'aide de
son moteur de template 1 appelé Blade. Blade offre une syntaxe expressive et vous
permet d'organiser vos vues de manière claire et réutilisable.
• Base de données et ORM : Laravel fournit une couche d'abstraction de base de
données appelée Eloquent ORM. Eloquent simplifie l'interaction avec la base de
données en vous permettant de travailler avec des objets plutôt qu'avec du SQL brut.
• Système d'authentification : Laravel inclut un système d'authentification prêt à
l'emploi qui vous permet de gérer facilement l'inscription des utilisateurs, la connexion,
la réinitialisation des mots de passe, etc.
• Sécurité : Laravel intègre des fonctionnalités de sécurité telles que le hachage de mots
de passe, la protection CSRF (Cross-Site Request Forgery), le chiffrement, la validation
des données, etc.
• Services et files d'attente : Le framework offre une intégration fluide avec les services
tiers et propose un système de files d'attente pour gérer les tâches longues ou intensives.
• Communauté active : Laravel bénéficie d'une communauté de développeurs très
active et engagée. Il existe de nombreuses ressources, tutoriels, extensions et packages
disponibles pour vous aider à développer rapidement avec Laravel. Par
exemple Laravel.io, Packagist, Laracasts, GitHub, laravel-France.

3. Environnement de développement requis

Pour développer avec Laravel, vous avez besoin de configurer un environnement de
développement comprenant les éléments suivants :

1 Un moteur de template est un outil de modèle structurel qui simplifie la syntaxe pour assurer une bonne maintenabilité de son
projet web. Il permet de dissocier la partie présentation (HTML) de la partie programmation
 • PHP : Laravel nécessite PHP dans une version spécifique. Actuellement, Laravel 8.x
recommande PHP 8.0 ou une version supérieure. Assurez-vous d'installer PHP sur votre
machine et de vérifier la version à l'aide de la commande php -v dans votre terminal.
• Composer : Composer est un gestionnaire de dépendances pour PHP. Laravel utilise
Composer pour gérer ses propres dépendances et faciliter l'installation de nouveaux
packages. Vous devez donc installer Composer sur votre machine. Vous pouvez le
télécharger à partir du site officiel de Composer (https://getcomposer.org/) et suivre les
instructions d'installation spécifiques à votre système d'exploitation.
• Serveur web : Laravel fonctionne sur différents serveurs web tels qu’Apache, Nginx,
etc. Vous pouvez utiliser le serveur de développement intégré de Laravel pour vos
besoins de développement local, ou configurer un serveur web comme Apache ou
Nginx pour une utilisation en production.
• Base de données : Laravel prend en charge plusieurs systèmes de gestion de base de
données tels que MySQL, PostgreSQL, SQLite, etc. Vous devez installer le système de
gestion de base de données de votre choix et configurer les informations de connexion
dans le fichier .env de votre projet Laravel.
• Outil de ligne de commande artisan : Laravel fournit une interface en ligne de
commande appelée artisan, qui facilite le développement en automatisant de
nombreuses tâches courantes. Assurez-vous d'avoir accès à la commande php artisan
dans votre terminal pour exécuter les commandes artisan.
• Éditeur de code : Vous pouvez utiliser n'importe quel éditeur de code de votre choix
pour développer avec Laravel. Certains éditeurs populaires pour le développement
Laravel incluent Visual Studio Code, PhpStorm, Sublime Text, et Atom.

4. Installation et configuration de Laravel

L'installation et la configuration de Laravel peuvent être effectuées en suivant les étapes ci-
dessous :
1. Étape 1 : Prérequis
Assurez-vous d'avoir installé les prérequis suivants sur votre machine :
o PHP (version 8.1 ou supérieure)
o Composer
o Serveur web (Apache, Nginx, ou utilisez le serveur de développement intégré
de Laravel pour le développement local)
o Système de gestion de base de données (MySQL, PostgreSQL, SQLite, etc.)
o Node.js et NPM (pour les dépendances JavaScript et les ressources frontales,
selon vos besoins)
• Étape 2 : Installer Laravel
Ouvrez votre terminal et exécutez la commande suivante pour installer Laravel via
Composer :
composer global require laravel/installer

Assurez-vous que le répertoire d'exécution des binaires Composer est inclus dans votre variable
d'environnement PATH afin que vous puissiez utiliser la commande Laravel à partir de
n'importe quel répertoire.
• Étape 3 : Créer un nouveau projet Laravel
Naviguez vers le répertoire où vous souhaitez créer votre projet Laravel et exécutez la
commande suivante :
laravel new nom-du-projet

Cela va créer un nouveau projet Laravel avec le nom spécifié.

• Étape 4: Configuration de l'environnement

Rendez-vous dans le répertoire du projet Laravel nouvellement créé :
cd nom-du-projet

Dupliquez le fichier .env.example et renommez-le en .env :

cp .env.example .env

Générez la clé de l'application Laravel en utilisant la commande artisan :

php artisan key:generate

• Étape 6: Exécuter le serveur de développement

Si vous n'utilisez pas un serveur web externe, vous pouvez utiliser le serveur de
développement intégré de Laravel.
Exécutez la commande suivante pour démarrer le serveur :
php artisan serve

Cela démarrera le serveur de développement sur http://localhost:8000 par défaut.

Voilà, vous avez maintenant installé et configuré Laravel ! Vous pouvez accéder à votre
application Laravel en utilisant l'URL du serveur de développement ou en configurant votre
serveur web externe selon vos besoins.

5. Exercice d’application 1
Description de l’exercice : Création d'un projet Laravel
EShopper est un site e-commerce multi-vendeur permettant aux utilisateurs de créer
leurs propres boutiques en ligne et de vendre leurs produits.
Dans ce exerce nous allons faire l’installation et la configuration de laravel pour
développer notre projet EShopper. Pour ce faire nous allons installer Laragon comme server
local.
C’est quoi Laragon ?
Laragon est un environnement de développement local léger et puissant spécialement
conçu pour les projets PHP, y compris Laravel. Il fournit une installation rapide et facile de
l'ensemble de la pile (Apache, PHP, MySQL) et offre des fonctionnalités avancées pour la
gestion de vos projets Laravel.
 Rendez-vous sur le site officiel de Laragon (https://laragon.org/) et téléchargez la
dernière version disponible. Assurez-vous de télécharger la version compatible avec votre
système d'exploitation.
En utilisant Laragon, vous pouvez rapidement configurer un environnement de
développement local pour Laravel sans avoir à installer séparément Apache, PHP, COMPOSER
et MySQL. Cela facilite le développement et le test de vos projets Laravel sur votre propre
machine.

Module 2 : Structure d'un projet Laravel

1. Vue d'ensemble de la structure des dossiers et fichiers
• Laravel suit une structure de dossiers bien définie, qui comprend :
o Le dossier "app" qui contient les classes principales de l'application, y compris
les modèles, les contrôleurs et les services.
o Le dossier "config" qui contient les fichiers de configuration de l'application.
o Le dossier "database" qui contient les migrations de base de données, les
seeds et les factories.
o Le dossier "public" qui est le point d'entrée de l'application et contient les
fichiers publics accessibles via le navigateur.
o Le dossier "resources" qui contient les vues, les fichiers de langues, les
fichiers CSS et JavaScript.
o Le dossier "routes" qui contient les fichiers de définition des routes de
l'application.
o Le dossier "storage" qui stocke les fichiers générés par l'application, tels que
les fichiers journaux et les fichiers de session.
o Le dossier "tests" qui contient les tests unitaires et fonctionnels de
l'application.

• Explication des principaux dossiers et fichiers

o Le fichier "routes/web.php" contient les définitions des routes accessibles via
le navigateur.
o Le fichier "routes/api.php" contient les définitions des routes pour une API.
o Le fichier ".env" est le fichier de configuration de l'environnement et contient
les informations sensibles telles que les informations de base de données et les
clés d'API.
o Le fichier "app/Http/Controllers" est le répertoire où vous pouvez créer vos
contrôleurs.
o Le fichier "app/Models" est le répertoire où vous pouvez définir vos modèles
Eloquent.
o Le fichier "resources/views" est le répertoire où vous pouvez créer vos vues
Blade.

2. Introduction à l'architecture MVC de Laravel

L'architecture MVC (Modèle-Vue-Contrôleur) est un concept fondamental dans le
développement d'applications web, et Laravel, en tant que framework PHP, suit également cette
architecture. L'architecture MVC divise une application en trois composants principaux : le
modèle, la vue et le contrôleur. Chaque composant joue un rôle spécifique dans le traitement
des données et la gestion de la logique de l'application.
 ➢ Modèle (Model) : Le modèle représente la couche de données de l'application. Il est
responsable de l'accès aux données, de leur manipulation et de leur persistance. Dans
Laravel, les modèles sont généralement des classes qui représentent les tables de la
base de données ou d'autres sources de données. Les modèles permettent de définir les
règles de validation des données, les relations entre les tables, et fournissent des
méthodes pour effectuer des opérations CRUD (Créer, Lire, Mettre à jour, Supprimer)
sur les données.
➢ Vue (View) : La vue représente la couche de présentation de l'application. Elle est
responsable de l'affichage des données au format souhaité. Dans Laravel, les vues sont
généralement des fichiers Blade, un moteur de template puissant et expressif. Les vues
permettent de structurer et de formater les données à afficher, d'inclure des éléments
réutilisables, et de gérer les interactions utilisateur.
➢ Contrôleur (Controller) : Le contrôleur agit comme l'intermédiaire entre le modèle et
la vue. Il gère les requêtes HTTP, récupère les données du modèle, effectue les
traitements nécessaires et retourne la réponse appropriée à la vue. Dans Laravel, les
contrôleurs sont des classes qui regroupent des méthodes pour gérer les d ifférentes
actions de l'application. Ils peuvent valider les données d'entrée, interagir avec le
modèle, et retourner la réponse sous forme de vue ou de données JSON.
➢
L'architecture MVC de Laravel offre de nombreux avantages. Elle favorise la
séparation des préoccupations (Separation of Concerns), ce qui facilite la gestion du code, la
réutilisation des composants et la collaboration entre les membres de l'équipe de
développement. De plus, elle facilite la maintenance de l'application en rendant les
modifications et les ajouts de fonctionnalités plus simples et plus clairs.
 3. Création de routes et de vues de base
➢ Routes :
Les routes définissent les URL de votre application et les actions qui doivent être
exécutées lorsqu'une URL est accédée. Les routes peuvent être définies dans le fichier
routes/web.php pour les routes accessibles via un navigateur, ou dans le fichier
routes/api.php pour les routes d'API.

Les fonctions Route::get , Route::post , Route::put , Route::delete sont des

méthodes fournies par Laravel pour définir les différentes routes dans votre application web.
Voici une explication de ces fonctions :
➢ Route::get('/url', function () { }) : Cette fonction définit une route qui
correspond à une requête HTTP GET vers l'URL spécifiée. Lorsque cette route est
accédée, la fonction de rappel fournie est exécutée.
➢ Route::post('/url', function () { }) : Cette fonction définit une route qui
correspond à une requête HTTP POST vers l'URL spécifiée. Lorsque cette route est
accédée, la fonction de rappel fournie est exécutée.
➢ Route::put('/url', function () { }) : Cette fonction définit une route qui
correspond à une requête HTTP PUT vers l'URL spécifiée. Lorsque cette route est
accédée, la fonction de rappel fournie est exécutée.
➢ Route::delete('/url', function () { }) : Cette fonction définit une route qui
correspond à une requête HTTP DELETE vers l'URL spécifiée. Lorsque cette route est
accédée, la fonction de rappel fournie est exécutée.
Ces fonctions permettent de mapper les URL de votre application aux actions
correspondantes dans votre code. Lorsqu'une requête est effectuée vers une URL spécifique,
Laravel examine les routes définies et exécute le callback associé à la première route
correspondante.
Exemple :
Route::get('/', function () {
return view('welcome');
});

Cette route définit l'URL de base '/' et indique que la vue welcome doit être renvoyée lorsque
cette URL est accédée via une requête GET.

Route ::get( '/users/{id}' , function ( $id ) {

// Récupérer les données de l'utilisateur avec l'ID donné
return view ('user', ['id' => $id ]);
});

Cette route définit une URL qui accepte un paramètre id dans l'URL et renvoie la vue ‘user’ en
passant l'ID de l'utilisateur comme donnée.
➢ Vues :
Les vues sont utilisées pour afficher les données et le contenu de votre application. Dans
Laravel, les vues sont généralement créées à l'aide du moteur de template Blade.
 • Ouvrez le répertoire ‘resources/views’ dans votre projet Laravel.
• Créez un nouveau fichier de vue avec l’extension .blade.php.
Par exemple, ‘welcome.blade.php’.
Dans ce fichier, vous pouvez utiliser la syntaxe Blade pour afficher des données, inclure d'autres
fichiers de vue, boucler sur des données, etc. Par exemple :
<html>
<head>
<title>Mon application Laravel</title>
</head>
<body>
<h1>Bienvenue sur mon site !</h1>
</body>
</html>

4. Exercice d’application 2
Dans cet exercice nous allons :

• Créer un dossier ‘’product’’, le dossier "resources/views". Ensuite créons les fichiers

suivants :

index.blade.php
create.blade.php
modifier.blade.php
datail.blade.php
boutique.blade.php

• Ajouter du code Html dans chaque fichier créé.

Exemple : index.blade.php
<html>
<head>
<title>Mon application Laravel</title>
</head>
<body>
<h1>Bienvenue sur mon site !</h1>
</body>
</html>

• Créer les routes qui retournent les vues précédentes :

Route::get('/', function () {
return view('product.index');
});

Route::get('/formulaire-inscription-produit', function () {
 return view('product.create');
});

Route::get('/detail-produit/{id}', function ($id) {

return view('product.detail', ['id' => $id]);
});

Route::get('/formulaire-modification-produit/{id}', function ($id) {

return view('product.modifier', ['id' => $id]);
});

Séance 2 :
Module 3 : Les contrôleurs
1. Création de contrôleurs
Les contrôleurs dans Laravel sont responsables de la gestion des requêtes utilisateur et
de la coordination des actions associées.

• Utilisez la commande `php artisan make:controller NomDuController` pour

générer un nouveau contrôleur.
• Le contrôleur sera créé dans le répertoire "app/Http/Controllers".

2. Définition des actions (méthodes) dans les contrôleurs

Les actions (méthodes) dans les contrôleurs de Laravel représentent les différentes
actions ou fonctionnalités de votre application. Chaque action est associée à une route
spécifique et est responsable de traiter la requête HTTP correspondante et de retourner une
réponse appropriée.
Exemple 1 :

Cet exemple 1 retourne page index se trouvant dans le dossier product sans aucunes données.
Exemple 2 :
On souhaite afficher les produits sur notre page index, les données sont passées sous forme de
tableau.

3. Utilisation des middlewares pour la gestion des requêtes http

Les middlewares sont un concept puissant dans Laravel pour la gestion des requêtes
HTTP. Ils permettent d'intercepter les requêtes avant qu'elles n'atteignent les routes et de
prendre des actions spécifiques en fonction de certaines conditions. Les middlewares peuvent
être utilisés pour effectuer des opérations telles que l'authentification, l'autorisation, la
validation des données, la manipulation des en-têtes, la journalisation, etc.

Comment utiliser les middlewares dans Laravel ?

1. Créez un middleware :
Vous pouvez créer votre propre middleware en utilisant la commande artisan
‘make:middleware’. Par exemple, pour créer un middleware appelé
‘CheckStatusMiddleware’, exécutez la commande suivante dans votre terminal :
php artisan make:middleware CheckStatusMiddleware
Cette commande générera un fichier de middleware dans le répertoire app/Http/Middleware.
Voici un exemple de middleware ‘CheckStatusMiddleware’ qui vérifie si l'utilisateur
a validé sont compte email avant de lui permettre d'accéder à une route :
<?php

namespace App\Http\Middleware;

use Closure;

class CheckAgeMiddleware
{
public function handle($request, Closure $next)
{
if ($request->status == 1) {
return redirect('home'); //
}else{
return redirect(login);
}
return $next($request);
 }
}

2. Enregistrez le middleware
Pour utiliser le middleware, vous devez l'enregistrer dans le fichier
app/Http/Kernel.php de votre application. Dans ce fichier, vous trouverez un tableau
$middleware qui répertorie les middlewares globaux qui s'appliquent à toutes les requêtes. Vous
pouvez également trouver un tableau $routeMiddleware qui répertorie les middlewares
spécifiques aux routes.
Ajoutez votre middleware au tableau $routeMiddleware . Par exemple, pour enregistrer
le middleware ‘CheckStatusMiddleware’, ajoutez la ligne suivante dans le tableau
$routeMiddleware :

'check.s tatus => \App\Http\Middleware\CheckStatusMiddleware :: class ,

3. Utilisez le middleware dans vos routes :

Vous pouvez utiliser le middleware dans vos routes en utilisant la méthode
middleware() lors de la définition de la route. Par exemple, pour appliquer le middleware
CheckStatusMiddleware à une route, utilisez la syntaxe suivante :
Route::get('/home', function () {
// Logique de la route
})->middleware('check.s tatus);

4. Exercice d’application 3 :
Dans cet exercice nous allons :
1. Créer un Controller ProductController et les routes associées à chaque méthode.
php artisan make:controller ProductController

2. Créer des fonctions pour nos différentes actions à mener :

<?php

namespace App\Http\Controllers;

use Illuminate\Http\Request;

class ProductController extends Controller

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

public function detail($id)

{
return view('product.detail');
}

public function modifier($id)

{
return view('product.modifier');
}

3. Modifier nos routes pour quelles pointent sur les différentes méthodes que nous avons
créé :

use App\Http\Controllers\ProductController;

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

Route::get('/formulaire-inscription-produit',
[ProductController::class, 'create']
)->name('create');

Route::get('/detail-produit/{id}',
[ProductController ::class, 'detail']
)->name('detail');

Route::get('/formulaire-modification-produit/{id}',
[ProductController::class, 'modifier']
)->name('modifier');

Module 4 : Bases de données et Eloquent ORM

1. Configuration de la base de données dans Laravel
Pour configurer la base de données dans Laravel, suivez les étapes suivantes :
 • Ouvrez le fichier .env à la racine de votre projet Laravel. Ce fichier contient les
variables d'environnement de votre application, y compris les paramètres de
configuration de la base de données.
• Trouvez les variables suivantes et ajustez-les selon votre configuration de base de
données :

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

DB_CONNECTION : spécifie le pilote de base de données à utiliser. Par défaut, Laravel est
configuré pour utiliser MySQL. Si vous utilisez une autre base de données telle que PostgreSQL
ou SQLite, vous pouvez ajuster cette valeur en conséquence.
DB_HOST : spécifie l'adresse IP ou le nom d'hôte du serveur de base de données. Par défaut,
il est configuré sur 127.0.0.1, ce qui correspond à la machine locale.
DB_PORT : spécifie le port sur lequel le serveur de base de données écoute. Par défaut, il est
configuré sur 3306 pour MySQL.
DB_DATABASE : spécifie le nom de votre base de données à laquelle Laravel se connectera.
DB_USERNAME : spécifie le nom d'utilisateur utilisé pour se connecter à la base de données.
DB_PASSWORD : spécifie le mot de passe associé à l'utilisateur de la base de données.

2. Manipulation des données avec Eloquent dans Laravel

La manipulation des données est une partie essentielle du développement d'applications.
Dans Laravel, Eloquent est l'ORM (Object-Relational Mapping) intégré qui facilite la création,
la récupération, la mise à jour et la suppression (CRUD) des données dans votre application.
Dans cet cours, nous allons explorer comment utiliser Eloquent pour effectuer ces opérations
de base.

• Création de données :
Pour créer un nouvel enregistrement dans la base de données, vous pouvez créer une
instance du modèle correspondant et définir les valeurs des attributs, puis appeler la méthode
save(). Par exemple :
$user = new User;
$user->name = 'John Doe';
$user->email = 'john@example.com';
$user->save();

Vous pouvez également utiliser la méthode create() pour créer et sauvegarder un nouvel
enregistrement en une seule ligne :
 $user = User::create([
'name' => 'John Doe',
'email' => 'john@example.com',
]);

• Récupération de données :
Pour récupérer des enregistrements de la base de données, vous pouvez utiliser plusieurs
méthodes mises à disposition par Eloquent. Voici quelques exemples courants :
Récupérer tous les enregistrements :
$users = User::all();
// ou
$users = User:: get ();

Récupérer un enregistrement par son identifiant :

$user = User::find(1);

$user = User::where('email','john@example.com')-> first ();

Récupérer les enregistrements en fonction de critères spécifiques :

$users = User::where('age', '>', 18)->get();

• Mise à jour de données :

Pour mettre à jour un enregistrement existant, vous pouvez récupérer l'instance du modèle,
modifier ses attributs, puis appeler la méthode save(). Par exemple :
$user = User::find(1);
$user->name = 'Jane Doe';
$user->save();

Vous pouvez également utiliser la méthode update() pour mettre à jour plusieurs
enregistrements en une seule ligne, en spécifiant les attributs à mettre à jour et les critères de
sélection :
User::where('age', '>', 18)->update(['status' => 'active']);

Suppression de données :
Pour supprimer un enregistrement, vous pouvez appeler la méthode delete() sur
l'instance du modèle. Par exemple :
$user = User::find(1);
$user->delete();

Vous pouvez également supprimer plusieurs enregistrements en utilisant des critères de

sélection :
User::where('age', '<', 18)->delete();
Eloquent facilite la manipulation des données dans Laravel en fournissant une syntaxe
expressive et des méthodes pratiques pour créer, récupérer, mettre à jour et supprimer des
enregistrements dans la base de données. Utilisez ces techniques pour interagir avec votre base
de données de manière efficace et sécurisée.

Exercice d’application 4
1. Configuration de la base de données dans Laravel.
Ddans le fichier ".env", on va spécifier les informations de configuration de notre base de
données, y compris le type de base de données, l'hôte, le nom de la base de données, le nom
d'utilisateur et le mot de passe.

DB_CONNECTION=mysql
DB_HOST=127.0.0.1
DB_PORT=3306
DB_DATABASE=eshopper
DB_USERNAME=root
DB_PASSWORD=

2. Création des Models et des migrations

Pour créer nos différents models, il faudrait d’abord avoir conçu le diagramme de classes ou
MCD (Modèle conceptuel des données).

Créons nos models :

php artisan make:model Categorie

php artisan make:model Role
php artisan make:model User
php artisan make:model Produit
Séance 3 :
Module 5 : Relations avec Eloquent
1. Définition des relations entre les modèles
• Eloquent permet de définir des relations entre les modèles pour représenter les
associations entre les tables de la base de données.
• Les relations couramment utilisées incluent les relations hasOne, hasMany,
belongsTo, belongsToMany, etc.
• Vous pouvez définir les relations en ajoutant des méthodes dans les modèles et en
utilisant les méthodes fournies par Eloquent.

2. Utilisation des relations hasOne, hasMany, belongsTo, belongsToMany, etc.

• Une relation hasOne indique qu'un modèle possède une seule autre entité associée.
• Une relation hasMany indique qu'un modèle peut avoir plusieurs entités associées.
• Une relation belongsTo indique qu'un modèle appartient à une autre entité.
• Une relation belongsToMany indique qu'un modèle peut appartenir à plusieurs
autres entités et vice versa.

Chargement des relations Eloquent

• Lorsque vous récupérez un modèle, vous pouvez également charger ses relations pour
éviter les requêtes supplémentaires à la base de données.
• Utilisez la méthode `with ()` pour spécifier les relations à charger. Cela permet
d'améliorer les performances en évitant les requêtes supplémentaires.

3. Exercice d’application 5
Dans cet exercice nous allons créer les relations avec Eloquent entre nos différents
models et sectionner notre Template echopper pour les vues.
A. Relations avec Eloquent
1. Relation Eloquent Categorie et Produit.
Dans le modèle Categorie, définissez la relation "One To Many" avec la méthode produits()
:

namespace App \Models;

use Illuminate\Database\Eloquent\Model;

class Categorie extends Model

{
public function produits()
{
return $this ->hasMany (Produit::class );
}
}

Dans le modèle Produit , définissez la relation "Many To One" avec la méthode categorie()
:

namespace App\Models ;
use Illuminate\Database\Eloquent\Model;

class Produit extends Model

{
public function categorie()
{
return $this->belongsTo(Categorie::class);
}
}

2. Relation Eloquent User et Produit.

Dans le modèle User, définissez la relation "One To Many" avec la méthode produits() :

namespace A pp \ Mode ls ;

use Illumin ate \ Dat abase \ El oquent \ Model ;

class User extends Model

{
public functio n produi ts()
{
ret urn $th is -> hasM any ( Pro duit :: cl ass );
}
}

Dans le modèle Produit, définissez la relation "Many To One" avec la méthode user() :

namespace App\Models;

use Illuminate\Database\Eloquent\Model;

class Produit extends Model

{
public function user()
{
return $this->belongsTo(User::class);
}
}
 3. Relation Eloquent Role et User
Dans le modèle Role, définissez la relation "One To Many" avec la méthode users() :
namespace App\Models;

use Illuminate\Database\Eloquent\Model;

class Role extends Model

{
public function users()
{
return $this->hasMany(User::class);
}
}

Dans le modèle User , définissez la relation "Many To One" avec la méthode role() :
namespace App\Models;

use Illuminate\Database\Eloquent\Model;

class User extends Model

{
public function role()
{
return $this->belongsTo(Role::class);
}
}

4. Création des migrations

• Créez une migration pour la table "Role" :

php artisan make:migration create_roles_table --create=roles

C:\laragon\www\shop-inp\database\migrations\

public function up()

{
Schema::create('roles' , function (Blueprint $table) {
$table->bigIncrements ('id' );
$table->string('nom_role' );
$table->timestamps ();
});
}

• Créez une migration pour la table "User" :

php artisan make:migration create_users_table --create=users

C:\laragon\www\shop-inp\database\migrations\
public function up()
{
Schema::create('users' , function (Blueprint $table) {
$table->bigIncrements ('id' );
$table->string('slug' );
$table->string('nom' );
$table->string('prenom' );
$table->string('email' );
$table->integer ('numero' );
 $table->string('password' );
$table->unsignedBigInteger ('role_id' );
$table->foreign('role_id' )->references ('id' )->on('roles' );
$table->timestamps ();
});
}

• Créez une migration pour la table "Categorie" :

php artisan make:migration create_categories_table --create=categories

C:\laragon\www\shop-inp\database\migrations\
public function up()
{
Schema::create('categories' , function (Blueprint $table) {
$table->bigIncrements ('id' );
$table->string('nom_categorie' );
$table->timestamps ();
});
}

• Créez une migration pour la table "Produit" :

php artisan make:migration create_produits_table --create=produits

C:\laragon\www\shop-inp\database\migrations\
public function up()
{
Schema::create('produits' , function (Blueprint $table) {
$table->bigIncrements ('id' );
$table->string('titre' );
$table->integer ('prix' );
$table->text ('descriptions' );
$table->string('image_couverture' );
$table->string('image_details' );
$table->unsignedBigInteger ('categorie_id' );
$table->unsignedBigInteger ('user_id' );
$table->foreign('categorie_id' )->references ('id' )->on('categories' );
$table->foreign('user_id' )->references ('id' )->on('users' );
$table->timestamps ();
});
}

Exécutez les migrations pour créer les tables :

php artisan migrate

B. Découpage du Template
Le découpage du template HTML en Laravel consiste à organiser et structurer le code HTML
de votre application en utilisant le moteur de templates Blade fourni par Laravel. Cela permet
de séparer la logique de présentation de la logique métier de votre application.
 Master.blade.php

header.blade.php

footer.blade.php

Etape du découpage ;
1 : Création du dossier layouts et includes dans le dossier "resources/views".
2 : Création du fichier master.blade.php dans le dossier layouts.
3 : Création des fichier header.blade.php et footer.blade.php dans le dossier includes.
4 : Extraction du fichier eshopper.zip
5 : Déplacer les dossiers css, font, images et js dans le dossier ‘’public/’’ de notre projet.
6 : le fichier master.blade.php est le fichier maitre qui regroupe tous code et liens que tous les
fichiers esclaves ont en commun.

@include('includes.header')

@yield("content")

@include('includes.footer')

5 : Les fichiers se trouvant dans le dossier ‘’ressources/views/product’’ hériterons du fichier

master.blade.php.

@extends("layouts.master")
 @section("content")
<!-- contenu de la section -->
@endsection

Module 6 : Validation des données

1. Introduction à la validation des données dans Laravel
• Laravel fournit une fonctionnalité de validation intégrée pour valider les données
entrantes.
• La validation permet de s'assurer que les données sont conformes aux règles
spécifiées avant de les traiter ou de les enregistrer dans la base de données.
• Les règles de validation courantes incluent la vérification des champs requis, des
formats d'email, des longueurs minimales/maximales, etc.

2. Utilisation des validateurs de Laravel

• Les validateurs de Laravel sont utilisés pour spécifier les règles de validation et
vérifier les données.
• Utilisez la méthode `validate()` dans les contrôleurs pour valider les données à
partir de la requête.
• Les validateurs peuvent être personnalisés en utilisant des règles prédéfinies, des
expressions régulières ou en créant vos propres règles de validation.
Example :
public function store(Request $request)
{
$request->validate([
tritre => 'required',
'description' => 'required',
'prix' => 'required|numeric' ,
'categorie_id' => 'required|exists:categories,id' ,
Image_couverture' => 'required|files,
]);

Product::create($request->all());

return redirect()->route('products.index' )->with('success', 'Product created

successfully');
}

3. Affichage des messages d'erreur de validation

• Si la validation échoue, Laravel génère automatiquement des messages d'erreur
associés à chaque champ.
• Vous pouvez afficher ces messages d'erreur dans les vues en utilisant la syntaxe
Blade, par exemple `@error(' tritre ')`.
Séance 4 :
Module 7 : Authentification et autorisation
1. Configuration de l'authentification dans Laravel
• Laravel fournit un système d'authentification prêt à l'emploi pour gérer
l'inscription, la connexion et la déconnexion des utilisateurs.
• Vous pouvez activer l'authentification en utilisant la commande `php artisan
make:auth`, qui générera les vues, les routes et les contrôleurs nécessaires.

2. Utilisation du système d'authentification de Laravel

• Laravel fournit des méthodes faciles à utiliser pour gérer l'authentification, telles
que `attempt()`, `login()`, `logout()`, etc.
• Vous pouvez protéger les routes en utilisant le middleware `auth`, ce qui nécessite
que l'utilisateur soit authentifié pour y accéder.

3. Personnalisation de l'authentification dans Laravel

• Vous pouvez personnaliser l'authentification en utilisant les modèles de vue, les
contrôleurs et les routes générés par Laravel.
• Par exemple, vous pouvez ajouter des champs personnalisés lors de l'inscription,
personnaliser les messages d'erreur, etc.
• Mise en place de l'autorisation avec les portes et les politiques
• En plus de l'authentification, Laravel propose un système d'autorisation pour
contrôler les accès des utilisateurs aux ressources.
• Vous pouvez définir des portes (Gates) pour effectuer des vérifications
personnalisées sur les autorisations.
• Vous pouvez également définir des politiques (Policies) pour regrouper les
autorisations associées à un modèle spécifique.

4. Exercice d’application 5
Dans Laravel, Breeze est un package qui fournit une configuration préconfigurée pour
l'authentification et l'autorisation dans votre application. Il simplifie grandement la mise en
place de l'authentification utilisateur avec Laravel.
Voici les étapes pour mettre en place l'authentification et l'autorisation avec Breeze :
• Installer Breeze : Tout d'abord, vous devez installer le package Breeze. Ouvrez votre
terminal, accédez au répertoire de votre projet Laravel et exécutez la commande
suivante :
composer require laravel/breeze --dev

• Générer les fichiers d'authentification : Une fois que Breeze est installé, vous pouvez
générer les fichiers d'authentification nécessaires. Utilisez la commande artisan
suivante :
php artisan breeze:install

Cette commande générera les fichiers de routage, de contrôleur et d e vues nécessaires pour
l'authentification.
 • Migrer la base de données : Après avoir généré les fichiers d'authentification, vous
devez migrer la base de données pour créer les tables nécessaires à l'authentification.
Utilisez la commande artisan suivante :
php artisan migrate

• Compiler les assets : Pour utiliser les styles et scripts CSS/JS fournis par Breeze, vous
devez compiler les assets. Utilisez la commande artisan suivante :
npm install && npm run dev

Module 8 : Gestion des fichiers et des images

Dans Laravel, la gestion des fichiers et des images est facilitée grâce à la bibliothèque intégrée
appelée "Filesystem". Cette bibliothèque offre de nombreuses fonctionnalités pour manipuler
les fichiers, les répertoires et les images de manière simple et efficace. Voici quelques
fonctionnalités clés pour la gestion des fichiers et des images dans Laravel :

1. Stockage des fichiers

Laravel fournit une configuration simple pour définir le répertoire de stockage des fichiers.
Vous pouvez spécifier un répertoire local sur le serveur ou utiliser un service de stockage en
nuage tel que Amazon S3, Google Cloud Storage ou Rackspace.

2. Upload de fichiers
Vous pouvez facilement gérer l'upload de fichiers à l'aide de la méthode store() de la classe
Request . Cette méthode permet de stocker un fichier uploadé dans le répertoire de stockage
configuré.
$file = $request->file('file');
$path = $file->store('uploads');

3. Manipulation des fichiers

Laravel fournit une variété de méthodes pour manipuler les fichiers, telles que la
suppression, le renommage, la copie, le déplacement, etc.
use Illuminate\Support\Facades\Storage;

// Supprimer un fichier
Storage::delete('path/to/file.jpg');

// Renommer un fichier
Storage::move('path/to/oldfile.jpg', 'path/to/newfile.jpg');

// Copier un fichier
Storage::copy('path/to/sourcefile.jpg', 'path/to/destination.jpg');

4. Gestion des images

Laravel propose également des fonctionnalités spécifiques pour la gestion des images,
telles que le redimensionnement, la manipulation des formats, la création de miniatures, etc.
Vous pouvez utiliser la bibliothèque "Intervention Image" pour cela, qui est intégrée dans
Laravel.
 use Illuminate\Support\Facades\Storage;

// Supprimer un fichier
Storage::delete('path/to/file.jpg');

// Renommer un fichier
Storage::move('path/to/oldfile.jpg', 'path/to/newfile.jpg');

// Copier un fichier
Storage::copy('path/to/sourcefile.jpg', 'path/to/destination.jpg');

Séance 5 :
Module 9 : API et développement d'applications mobiles
Le développement d'applications mobiles implique souvent la création d'une API
(Application Programming Interface) qui permet à l'application mobile de communiquer avec
le serveur backend. Laravel facilite le développement d'API grâce à son architecture MVC et à
ses fonctionnalités intégrées.
Voici les étapes générales pour développer une API avec Laravel pour une application
mobile :

1. Configuration de l'API :
Dans Laravel, vous pouvez commencer par configurer les routes de votre API dans le
fichier routes/api.php . Vous pouvez définir les endpoints et les actions associées à chaque
endpoint, tels que la création, la lecture, la mise à jour et la suppression des ressources.

2. Contrôleurs de l'API :
Créez des contrôleurs dédiés pour gérer les différentes actions de votre API. Chaque
méthode dans le contrôleur correspondra à une action spécifique, comme la création d'une
ressource, la récupération d'une liste de ressources, la mise à jour d'une ressource, etc. Vous
pouvez retourner des réponses JSON depuis ces méthodes.

3. Validation des données :

Utilisez les fonctionnalités de validation de Laravel pour valider les données reçues de
l'application mobile. Laravel fournit des validateurs prédéfinis et vous permet également de
créer vos propres règles de validation personnalisées.

4. Authentification et autorisation :
Pour sécuriser votre API, vous pouvez utiliser les fonctionnalités d'authentification et
d'autorisation de Laravel. Laravel Breeze, Laravel Sanctum, ou Laravel Passport sont des
packages couramment utilisés pour gérer l'authentification des utilisateurs et la génération de
jetons d'accès (tokens) pour les requêtes API.

5. Réponses JSON :
Laravel facilite le retour de réponses JSON depuis vos contrôleurs. Vous pouvez utiliser
les méthodes response() et json() pour formater vos réponses. Vous pouvez également gérer
les codes de statut HTTP appropriés pour chaque requête.
 6. Documentation de l'API :
Une documentation claire et complète est essentielle pour les développeurs
d'applications mobiles qui utiliseront votre API. Vous pouvez utiliser des outils tels que
Swagger, OpenAPI, ou Laravel API Documentation Generator pour générer automatiquement
la documentation de votre API à partir de vos commentaires de code.

7. Tests de l'API :
Il est recommandé de mettre en place des tests automatisés pour votre API afin de vous
assurer que toutes les fonctionnalités fonctionnent correctement. Laravel propose des
fonctionnalités intégrées pour les tests unitaires et les tests d'intégration.

En développant votre API avec Laravel, vous bénéficiez de l'ensemble des

fonctionnalités du framework, notamment la gestion des requêtes HTTP, la validation des
données, l'authentification, l'autorisation, la gestion des erreurs, etc. Laravel facilite également
l'intégration avec des bibliothèques externes et des services tiers grâce à son écosystème étendu.

Module 10 : Sécurité
Sécurité des applications Laravel
• Laravel offre de nombreuses fonctionnalités de sécurité intégrées pour protéger les
applications contre les attaques courantes.
• Par exemple, Laravel utilise le hachage de mots de passe sécurisé, les requêtes
préparées, la protection CSRF, la désactivation de l'exécution des scripts, etc.

Déploiement de l'application Laravel

• Pour déployer une application Laravel, vous pouvez suivre différentes approches en
fonction de votre environnement de production.
• Vous pouvez utiliser des services d'hébergement partagé, des serveurs dédiés, des
services de cloud, des conteneurs Docker, etc.
• Assurez-vous de configurer correctement les fichiers de configuration, de gérer les
dépendances avec Composer, d'optimiser le code et de configurer le serveur web.

Séance 6 :
Exercice d’application
Evaluation