Résumé Laravel

Module 1 : Installation et Préparation du Projet

Commandes :
1. Installer Composer :
Composer est un gestionnaire de dépendances PHP qui permet de gérer et d’installer des bibliothèques et des
frameworks, comme Laravel. Avant de commencer, il est essentiel d’avoir Composer installé sur le système.
php -r "copy('[Link] '[Link]');"
php [Link]
php -r "unlink('[Link]');"
sudo mv [Link] /usr/local/bin/composer
2. Installer Laravel globalement :
composer global require laravel/installer
3. Créer un projet Laravel :
laravel new gestion-factures
OU avec Composer :
composer create-project laravel/laravel gestion-factures
4. Lancer le serveur de développement :
Laravel inclut un serveur de développement intégré pour tester rapidement une application localement. Ce serveur
est accessible via une URL locale.
php artisan serve
Accès à l'application : [Link]
5. Vérifier la version de PHP :
php -v
Configuration avec MySQL :
1. Modifier le fichier .env pour MySQL :
Le fichier .env est utilisé pour configurer la connexion à la base de données MySQL, notamment en précisant le nom
de la base, l'utilisateur, et le mot de passe.
DB_CONNECTION=mysql
DB_HOST=[Link]
DB_PORT=3306
DB_DATABASE=gestion_factures
DB_USERNAME=root
DB_PASSWORD=root
2. Créer une base de données MySQL :
mysql -u root -p
Puis, dans l’interface MySQL :
CREATE DATABASE gestion_factures;
EXIT;

Module 2 : Création d'une API RESTful

Commandes :
1. Créer un modèle avec une migration :
Un modèle représente une table de base de données, et une migration permet de définir la structure de cette table.
php artisan make:model Invoice -m
Crée un modèle Invoice et une migration associée.

Page 1 sur 7
Les migrations permettent de créer des tables dans la base de données. Une fois définies, elles sont appliquées pour
générer les tables dans MySQL.
2. Modifier la migration (Exemple : table invoices) :
public function up()
{
Schema::create('invoices', function (Blueprint $table) {
$table->id();
$table->string('number')->unique();
$table->string('customer_name');
$table->decimal('amount', 10, 2);
$table->boolean('is_paid')->default(false);
$table->timestamp('payment_date')->nullable();
$table->timestamps();
});
}
3. Appliquer les migrations :
php artisan migrate
4. Créer un contrôleur API :
php artisan make:controller InvoiceController
5. Créer des Modèles
Les modèles Eloquent interagissent avec la base de données. Créez-les avec
php artisan make:model.
6. Ajouter des routes API dans routes/[Link] :
Les routes définissent les points d’entrée (endpoints) de l’API, permettant de mapper des URL à des méthodes
spécifiques des contrôleurs.
Modifiez les fichiers de routes (routes/[Link] ou routes/[Link]) pour définir les points d’accès de votre
application.
use App\Http\Controllers\InvoiceController;

Route::get('/invoices', [InvoiceController::class, 'index']);

Route::post('/invoices', [InvoiceController::class, 'store']);
Route::get('/invoices/{id}', [InvoiceController::class, 'show']);
Route::put('/invoices/{id}', [InvoiceController::class, 'update']);
Route::delete('/invoices/{id}', [InvoiceController::class, 'destroy']);
7. Tester l’API avec cURL :
cURL est un outil en ligne de commande qui permet d’envoyer des requêtes HTTP. Il est utilisé pour tester les
différents endpoints de l’API.
Ajouter une facture :
curl -X POST [Link] \
-H "Content-Type: application/json" \
-d '{"number":"INV001","customer_name":"Ali","amount":1500.00}'
Module 3 : Gestion des Formulaires avec Laravel
Commandes :
1. Créer un modèle avec migration et contrôleur :
Cette commande génère simultanément un modèle pour la base de données, une migration pour définir la structure
des tables, et un contrôleur pour gérer les formulaires.

Page 2 sur 7
php artisan make:model Invoice -mc
2. Ajouter les routes pour les formulaires CRUD dans routes/[Link] :
Les routes permettent de définir les chemins pour afficher les formulaires, ajouter, modifier ou supprimer des
données via le navigateur.
Route::resource('invoices', InvoiceController::class);
3. Créer des vues avec Blade :
Blade est le moteur de templates intégré de Laravel. Il permet de créer des pages dynamiques avec des données
provenant de la base.
Placez les fichiers Blade dans le dossier resources/views.
Exemple : resources/views/invoices/[Link]
<form action="{{ route('[Link]') }}" method="POST">
@csrf
<input type="text" name="customer_name" required>
<input type="number" name="amount" required>
<button type="submit">Créer</button>
</form>
4. Valider les données dans le contrôleur :
Laravel offre une fonctionnalité de validation intégrée pour vérifier que les données saisies dans les formulaires
respectent certaines règles avant d'être enregistrées.
$validated = $request->validate([
'customer_name' => 'required|max:255',
'amount' => 'required|numeric|min:0',
]);
Module 4 : Téléversement de Fichiers
Commandes :
Téléversement de fichiers dans le contrôleur :
Laravel permet de gérer les fichiers téléchargés via les formulaires, en les stockant dans des répertoires définis et en
vérifiant leur type ou taille.
if ($request->hasFile('file')) {
$validated['file_path'] = $request->file('file')->store('invoices');
}
Module 5 : Relations Eloquent et Requêtes Avancées
Commandes :
1. Exemple de relation One-to-Many :
Dans le modèle [Link] :
public function invoices()
{
return $this->hasMany(Invoice::class);
}
2. Tester les relations avec Tinker :
Tinker est une console interactive pour exécuter des commandes PHP directement dans l’environnement Laravel,
utile pour tester les relations et manipuler les données.
php artisan tinker
Exemple de création d’une facture associée à un client :
$client = App\Models\Client::find(1);
$client->invoices()->create(['number' => 'INV001', 'amount' => 1500]);

Page 3 sur 7
 3. Requêtes avancées avec Eloquent :
Récupérer toutes les factures supérieures à 1000 MAD :
$invoices = \App\Models\Invoice::where('amount', '>', 1000)->get();
4. Requêtes avec Query Builder :
Jointure entre factures et clients :
DB::table('invoices')
->join('clients', 'invoices.client_id', '=', '[Link]')
->select('invoices.*', '[Link] as client_name')
->get();

Module 6 : Notifications et Emailing

Commandes :
1. Créer une classe Mailable :
php artisan make:mail InvoiceCreated
2. Configurer l’emailing dans .env :
Laravel utilise des services SMTP comme Mailtrap pour envoyer des emails. Le fichier .env est configuré pour définir
le serveur d’envoi, le port, et les identifiants.
MAIL_MAILER=smtp
MAIL_HOST=[Link]
MAIL_PORT=2525
MAIL_USERNAME=your_mailtrap_username
MAIL_PASSWORD=your_mailtrap_password
MAIL_FROM_ADDRESS=noreply@[Link]
MAIL_FROM_NAME="Gestion Factures"
3. Envoyer un email après la création d’une facture :
Exemple dans InvoiceController@store :
Mail::to('admin@[Link]')->send(new InvoiceCreated($invoice));

Module 7 : Interface Utilisateur avec Blade

Commandes :
1. Créer un layout global avec Blade :
Exemple : resources/views/layouts/[Link]
<!DOCTYPE html>
<html lang="en">
<head>
<title>Facturation</title>
</head>
<body>
<main>@yield('content')</main>
</body>
</html>
2. Pagination dans Blade :
{{ $invoices->links() }}
3. Afficher les données :
Exemple dans une vue [Link] :
@foreach ($invoices as $invoice)

Page 4 sur 7
 <tr>
<td>{{ $invoice->number }}</td>
<td>{{ $invoice->customer_name }}</td>
</tr>
@endforeach
Exercices :
1 Gestion d'un Système Bancaire avec Laravel
Objectif : Créer une application Laravel pour gérer un système bancaire simple comprenant trois entités principales :
Client, Compte et Transaction. L'application permettra d'ajouter des clients, de leur attribuer des comptes
bancaires, et d'enregistrer des transactions (dépôts et retraits) tout en mettant à jour les soldes des comptes.
Contexte :
Une banque souhaite développer une application pour suivre ses clients, leurs comptes bancaires, et les transactions
associées. Voici les besoins spécifiques :
1. Chaque client peut avoir plusieurs comptes bancaires.
2. Chaque compte bancaire a un numéro unique et un solde.
3. Les transactions (dépôts ou retraits) doivent être enregistrées, avec mise à jour du solde.
Consignes :
1. Création du Projet
1. Créez un nouveau projet Laravel nommé bank-management.
2. Configurez le fichier .env pour connecter votre application à une base MySQL appelée bank_management.
3. Créez la base de données correspondante.

2. Modélisation des Données

Créez les modèles et leurs migrations pour représenter les entités suivantes :
1. Client :
id : Identifiant unique.
name : Nom du client.
email : Adresse email unique.
phone : Téléphone (facultatif).
2. Compte (Account) :
id : Identifiant unique.
client_id : Référence au client (clé étrangère).
account_number : Numéro unique du compte.
balance : Solde actuel du compte.
3. Transaction :
id : Identifiant unique.
account_id : Référence au compte (clé étrangère).
amount : Montant de la transaction.
type : Type de transaction (deposit ou withdrawal).
Ajoutez les relations entre les modèles :
• Un client peut avoir plusieurs comptes.
• Un compte peut avoir plusieurs transactions.
3. Implémentation des Fonctions
Développez les fonctionnalités suivantes:
1. Clients :
Lister tous les clients.
Ajouter un nouveau client (nom, email, téléphone).
Page 5 sur 7
 Afficher les détails d'un client (y compris ses comptes).
Modifier les informations d’un client.
Supprimer un client (ainsi que ses comptes et transactions associées).
2. Comptes :
Créer un compte pour un client (client_id, numéro de compte).
Afficher les détails d’un compte (y compris son solde et ses transactions).
3. Transactions :
Ajouter une transaction (type : dépôt ou retrait, montant).
Mettre à jour le solde du compte après chaque transaction.
Refuser une transaction si le solde est insuffisant pour un retrait.
4. Routes
Ajoutez les routes nécessaires dans routes/[Link] :
• Clients : /api/clients (GET, POST, PUT, DELETE).
• Comptes : /api/accounts (POST, GET).
• Transactions : /api/transactions (POST).
5. Validation des Données
Ajoutez des règles de validation dans les contrôleurs :
1. Clients :
Le champ name est requis.
Le champ email est requis et doit être sous forme d’adresse Email.
Le champ phone est facultatif mais limité à 15 caractères.
2. Comptes :
Le champ client_id doit correspondre à un client existant.
Le champ account_number doit être unique.
3. Transactions :
Le champ amount est requis et doit être positif.
Le champ type est requis.
Questions Associées :
1. Modélisation :
Expliquez pourquoi une relation One-to-Many est utilisée entre Client et Account.
Décrivez le rôle des relations entre Account et Transaction.
2. Validation :
Quels sont les cas d'erreur possibles pour les transactions, et comment les gérez-vous ?
3. Optimisation :
Pourquoi est-il important de valider les données côté serveur ?
Quels sont les avantages d’utiliser des migrations pour gérer la structure des tables ?
1. Introduction à Laravel
1. Qu'est-ce que Laravel?
2. Quelle est la commande pour créer un nouveau projet Laravel ?
3. Pourquoi utilise-t-on Composer avec Laravel ?
4. Quelles sont les principales caractéristiques de Laravel ?
5. Quelle version minimale de PHP est requise pour Laravel 10 ?
2. Structure d’un Projet Laravel
1. Quels sont les dossiers principaux dans un projet Laravel et à quoi servent-ils ?
2. À quoi sert le fichier .env dans Laravel ?
3. Où sont définies les routes dans un projet Laravel ?
4. Quelle est la différence entre les fichiers de routes [Link] et [Link] ?
3. Bases de Données et Migrations
Page 6 sur 7
 1. Qu'est-ce qu'une migration dans Laravel ? Pourquoi l'utilise-t-on ?
2. Quelle est la commande pour appliquer les migrations ?
3. Comment créer une nouvelle migration et un modèle associé ?
4. Comment ajouter une clé étrangère à une table avec une migration ?
4. Eloquent ORM
1. Qu'est-ce que Eloquent dans Laravel ?
2. Expliquez les types de relations Eloquent suivants :
o One-to-One
o One-to-Many
o Many-to-Many
3. Comment définir une relation belongsTo dans un modèle ?
4. Quelle est la différence entre find(), first(), et where() dans Eloquent ?
5. Comment utiliser les relations dans les requêtes avec with() ou whereHas() ?
5. Contrôleurs
1. Quelle est la commande pour créer un contrôleur ?
2. Quelle est la différence entre un contrôleur simple et un contrôleur RESTful dans Laravel ?
6. Blade (Moteur de Templates)
1. Qu'est-ce que Blade dans Laravel et quels sont ses avantages ?
2. Comment créer un layout global avec Blade ?
3. Expliquez l'utilisation des directives Blade suivantes :
o @yield
o @section
o @extends
o @include
4. Comment afficher des données dynamiques dans une vue Blade ?
5. Comment gérer les boucles et conditions dans Blade ?
7. Validation des Données
1. Comment valider les données dans un contrôleur Laravel ?
2. Comment valider une requête HTTP avec une classe FormRequest ?
8. API et Routes
1. Quelle est la différence entre les routes définies dans [Link] et [Link] ?
2. Comment retourner des données au format JSON dans une API Laravel ?
3. Quelle est l’utilité de la méthode resource() pour définir des routes ?
9. Sécurité
1. Qu'est-ce que CSRF et comment Laravel le gère-t-il ?
2. Comment protéger un formulaire contre les attaques CSRF ?
3. Qu'est-ce qu'une injection SQL et comment Laravel la prévient-il ?
4. Comment gérer le hachage de mots de passe dans Laravel ?
10. Notifications et Emailing
1. Quelles sont les étapes pour envoyer un email avec Laravel ?
2. Quelles sont les configurations nécessaires pour utiliser un service SMTP (par exemple Mailtrap ou Gmail) ?

Page 7 sur 7