Laravel 9: Base de donnée & ORM

UP Web

AU: 2024/2025

1
 Plan

• Introduction
• Configuration et création de la base de données
• La Migration
• Factory
• La population (Seeding)
• L’ORM Eloquent
• Les relations

2
Introduction

3
 Introduction

❑ La programmation Orientée Objet, utilisant une base de données relationnelle,

nécessite de convertir les données relationnelles en objets et vice-versa.

❑ Persistance d’objets métiers : les objets modélisés dans les applications sont
associées à des données stockées dans les SGBDR

4
Configuration de la base des
données

5
Configuration de la base de données

Laravel permet de gérer la base des données de type:

 Postgres

 SQLite

 SQL Server

 MySQL

6
Configuration de la base de données

La configuration de la base de données de l’application s’effectue

dans le fichier .env

Il faut définir surtout le nom de la base, le nom de l’utilisateur

et le mot de passe. 7
Création de la base des
données

8
Création de la base de données

Il existe deux méthodes pour créer une base de données :

1. Méthode manuelle: à travers le gestionnaire de base de
données MySQL «phpMyAdmin»

2. Méthode en utilisant «artisan»:

❑ Créer une nouvelle commande Artisan «dbcreate»:
php artisan make:command dbcreate

 Cette commande permet de créer un fichier dbcreate.php sous

app/console/commands

9
Création de la base de données

Remplacer le contenu du fichier dbcreate.php par le code

suivant:
<?php
namespace App\Console\Commands;
use Illuminate\Console\Command;
use Illuminate\Support\Facades\DB;
class dbcreate extends Command
{
/**
* The name and signature of the console command.
*
* @var string
*/
protected $signature = 'db:create {name?}';
/**
* The console command description.
*
* @var string
*/
protected $description = 'Create a new MySQL database based on the database config file or the provide
d name';
/** 10
* Create a new command instance.
 Création de la base de données
/**
* Execute the console command.
*
* @return int
*/
public function handle()
{
$schemaName = $this->argument('name') ?: config("database.connections.mysql.database");
$charset = config("database.connections.mysql.charset",'utf8mb4');
$collation = config("database.connections.mysql.collation",'utf8mb4_unicode_ci');
config(["database.connections.mysql.database" => null]);
$query = "CREATE DATABASE IF NOT EXISTS $schemaName CHARACTER SET $charset COLLATE $collation;";
DB::statement($query);
config(["database.connections.mysql.database" => $schemaName]);
}}

 Il suffit, maintenant, de lancer la commande Artisan suivante:

php artisan db:create
 Pour vérifier si vous avez bien créer cette commande , il suffit de taper la
commande suivante:
php artisan list
11
La Migration

12
 La migration
 La migration permet de créer et de mettre à jour le schéma de base de données.
 Elle permet de tracker les différents changements et évolutions de votre base
 Lors de la création d’un projet laravel, 4 migrations sont présentes par défaut:

• users : c’est une migration de base pour créer une table des utilisateurs,
• password_resets : c’est une migration liée à la précédente qui permet de gérer
le renouvellement des mots de passe en toute sécurité,
• failed_jobs : une migration qui concerne les queues,
• personal_access_tokens : concerne les api
13
 La migration
Constitution d’une migration
Une classe de migration contient 2 méthodes :

✔ Up : utilisée pour créer la table et de ses colonnes dans la base de données.

Méthode de la façade Schema fonction qui utilise l’objet « Blueprint »
utilisée pour créer une table Nom de la table pour définir le tableau

14
La migration
Constitution d’une migration
✔ Down : utilisée pour la suppression de la table de la base de données.

Fonction utilisée pour supprimer un tableau

15
La migration
Pour lancer les migrations on utilise la commande suivante:
php artisan migrate
Les 4 migrations sont exécutées et 5 tables seront créés dans la base de données

16
La migration
Lien entre migration et création de la table « users » associée

17
 La migration
La migration dispose de 6 commandes:

 fresh : supprime toutes les tables et relance la migration.

 install : crée le dossier de migration.
 refresh : réinitialise et relance les migrations.
 status : donne des informations sur les migrations.
 rollback : annule la dernière migration.
18
La migration - Rollback

• Annuler ou rafraichir une migration

• Pour annuler une migration on utilise la commande rollback:

 Php artisan migrate:rollback : annuler la dernière migration

 Php artisan migrate:rollback --step=5 : annuler les 5 dernières migrations

 Php artisant migrate:reset : pour annuler toutes les migrations

19
La migration – Créer une migration

Pour créer un squelette de migration on utilise la commande suivante:

php artisan make:migration TestMigration
Une migration avec un code de base est créée dans le dossier
database/migrations :

20
La migration – Créer une table

Pour créer une table via la commande , on utilise la commande suivante:

php artisan make:migration create_nom_table --
create=nom_table

Avec:
 l’option --create: signifie que nous voulons créer une table nommée ‘nom_table’ ,
ce qui nous permettra d’avoir un fichier de migration un peu plus entamé et
nous évitera de taper quelques lignes de codes en plus.

21
La migration – Initialisation d’une table

Pour créer une table nous utilisons la méthode « create » de la

façade « Schema ».

Cette méthode accepte 2 paramètres ; le premier c’est le nom de la table, le

deuxième est une fonction qui utilise l’objet « Blueprint » pour définir le tableau.
22
La migration – Initialisation d’une table

Pour créer une table nous utilisons la méthode « create » de la

façade « Schema ».

Cette méthode accepte 2 paramètres ; le premier c’est le nom de la table, le

deuxième est une fonction qui utilise l’objet « Blueprint » pour définir le tableau.
23
 La migration – Créer des colonnes
La méthode « table » de la façade « schema » a la même signature que la méthode
« create » présentée précédemment.
❑ Dans la fonction passé dans le deuxième argument, nous pouvons utilisé l’objet
« Blueprint » pour créer les colonnes de la table :

Schema::table('products', function (Blueprint $table) {

$table->string('name');

});

Bien sûr, le générateur de schéma contient une variété de types de colonnes qu’on peut
utiliser lors de la construction des tables :

24
La migration – Créer des index

• Le générateur de schéma supporte plusieurs types d’index :

• ->primary('id') : pour ajouter une clé primaire
• ->unique('email') : index unique

• On peut les ajouter des façons suivantes :

• $table->string('email')->unique(); //1er façon
• $table->unique('email'); //2eme façon

25
Factory

26
 Factory

 Lors du test de votre application, on peut avoir besoin d'insérer quelques

enregistrements dans votre base de données.

 Au lieu de spécifier manuellement la valeur de chaque colonne, Laravel vous

permet de définir un ensemble d'attributs par défaut pour chacun de vos modèles

Eloquent en utilisant Factory .

27
 Factory: Quelques méthodes

 Dans un projet laravel, le fichier database/factories/UserFactory.php est par défaut.

 Cette factory est incluse dans toutes les nouvelles applications Laravel et contient la définition
de factory suivante :

 unique(): permet de s’assurer que les emails générés seront uniques.

 safeEmail(): permet de définir les emails avec le nom de domaine example.org, example.com ou
example.net.
28
 Name(): permet de générer le nom d’un utilisateur.
 Factory

 À travers the helper fake, factory aura accès Faker PHP library qui permet de générer du faux
texte. Avec cette librairie on peut générer différents types de données aléatoires: des noms, des
numéros de téléphone, des mots de passe, etc.
 Pour créer un factory, il suffit d’exécuter la commande :

php artisan make:factory ModuleFactory

 La classe est crée dans le dossier database/factories.
 On utilise la méthode fournie par Illuminate\Database\Eloquent\Factories\HasFactory afin
d’instancier un factory associé au modèle.
On peut aussi associer un factory à un modèle bien précis : Pour créer une factorie avec le fichier
de modèle associé, on utilise la commande suivante:

php artisan make:factory ModuleFactory –model=Module

29
 Factory

 Factory sont des classes qui étendent la classe factory de base de Laravel Illuminate\
Database\Eloquent\Factories\Factory
 Il implémente la méthode de définition.
 La méthode de définition renvoie l'ensemble par défaut des valeurs d'attributs qui doivent être
appliquées lors de la création d'un modèle à l'aide du factory.
 Il suffit d’implémenter la logique du factory au sein de la fonction definition

30
La population (Seeding)

31
La population (Seeding) (1/4)
 Permet de remplir les tables dans la base de données

 À partir de cette classe, on fait l’appel des autres classes seeder

 Les classes de la population se trouvent dans le dossier databases/seeds:

32
La population (Seeding) (2/4)

Pour générer le fichier seed, on doit utiliser la commande suivante:

php artisan make:seeder ModuleSeeder

 Ce nouveau fichier se trouvera dans le dossier /database/seeds

un seeder spécialement crée pour la table “Module"

33
Liaison Factory & Seeding (3/4)
 Dans le fichier ModuleSeeder, on va utiliser ModuleFactory afin de générer de
nombreux enregistrements au niveau de la base de données.
 Par exemple, pour créer 10 modules au sein de la table module, il suffit d’implémenter la
fonction run au sein de ModuleSeeder.

 Modifier le fichier “DatabaseSeeder.php” en écrivant le code suivant:

34
La population (Seeding) (3/4)

 Pour lancer la population de la table « module », on utilise la commande

suivante:
php artisan db:seed

 Il est possible de supprimer toutes les tables puis de réexécuter les

fichiers de migration et de seeds comme suit :
php artisan migrate:refresh --seed

35
L’ORM: Eloquent

36
Object-Relational Mapping (ORM) (1/2)
C’est une couche d’abstraction à la base de donnée.
ORM fait la relation entre les données orientées objet et les données
relationnelles.

37
Object-Relational Mapping (ORM) (2/2)

Avantages:
•Simplifie l’accès aux données
•Facilite le changement de SGBDR
•Une indépendance du code vis-à-vis du SGBDR utilisé

38
Présentation de l’ORM Eloquent

L’ORM de Laravel est Eloquent, qui est un ORM simple,

permettant de définir un « Model » pour chaque table.
Logiciel open source.
En plus la récupération des données de la table, les
modèles Eloquent vous permettent également d'insérer, de
mettre à jour et de supprimer des données de la table.

39
 Créer un modèle en une ligne
Pour créer un modèle avec le fichier de migration associé, on utilise la commande
suivante :
php artisan make:model Cours --migration
Ou simplement: php artisan make:model Cours -m
<?php

namespace App\Models;

use Illuminate\Database\Eloquent\Factories\HasFactory;
use Illuminate\Database\Eloquent\Model;

class Cours extends Model Fichier de migration

{
public function up()
use HasFactory;
{
}
Schema::create('module', function (Blueprint $table) {
$table->id();
Modèle Cours $table->timestamps();
});
}

40
 Enregistrer un modèle en une ligne
Dans la classe de migration, on va ajouter trois colonnes (Nom du module,
description et durée) :

public function up()

{
Schema::create(‘modules', function (Blueprint $table) {
$table->id();
$table->text('Nom_Module');
$table->text('description');
$table->string('duree');
$table->timestamps();
});
}

Pour lancer la migration on utilise la commande suivante:

php artisan migrate
41
 Récupérer un modèle (1/3)

Une fois qu’on a créé le modèle, la table correspondante ainsi que le

contrôleur, on peut afficher la liste des cours dans la base de données
Au début, on définit dans le contrôleur la fonction affiche suivante:

public function affiche()

{
$listmodules = \App\Models\Module::all();
return view(“modules", compact("listmodules"));
renvoie tous les cours dans la base
} de données

42
Récupérer un modèle (3/3)

Pour afficher la liste des cours, il suffit de créer le fichier blade

« cours.blade.php » suivant:
<table border="1">
<thead>
<tr>
<th>Id</th><th>Nom du Module</th><th>Duree</th>
<th>Description</th><th>Action</th>
</tr>
</thead>
<tbody>
@foreach($listmodules as $listmodules)
<tr>
<td>{{ $listmodules->id }}</td><td>{{ $listmodules->nom_module }}</td>
<td>{{ $listmodules->duree }}</td><td>{{ $listmodules->description }}</td>
<td>
<button type="submit" class="btn btn-link">Supprimer</button>
<button type="submit" class="btn btn-link">Modifier</button>
</td>
</tr>
@endforeach
</tbody>
</table>
43
Les requêtes avec Eloquent ORM

all(): une méthode qui est appliquée directement au modèle de données.

Elle permet de retrouver toutes les données de la table associée au
modèle.

Pour obtenir tous les enregistrements triés dans un ordre donné, on n'a
pas besoin de travailler avec all(). On utilisera plutôt la méthode orderBy()
suivie de la méthode get() afin d'obtenir une collection.

Exemple:

44
Les requêtes avec Eloquent ORM

find(): Est une méthode qui permet de rechercher un

enregistrement par son identifiant.
•Exemple
$module = App\Module::find(5); : recherche par id

Retrouver les enregistrements correspondant à une condition :

where() ou orWhere(), suivi de get().

45
Les formulaires (1/3)
Définition

Laravel fournit diverses balises intégrées pour gérer les formulaires HTML.
Pour créer un formulaire avec Laravel , on doit procéder les deux étapes
suivantes:

1) faire appel au méthode qui permet de retourner un formulaire

comme suit:
Route::get ($uri, méthode)

2) Puis faire au méthode qui permet de traiter un formulaire

comme suit:
Route:: post($uri,methode) 46
Les formulaires (2/3)
Principe de fonctionnement

47
 Les formulaires (3/3)
Principe de fonctionnement

(1) Le client envoie la requête de demande du formulaire qui est

transmise au contrôleur par la route (utilisation du GET),
(2) Le contrôleur crée la vue « infos »,
(3) La vue « infos » crée le formulaire,
(4) Le formulaire est envoyé au client,
(5) Le client soumet le formulaire, le contrôleur reçoit la requête de
soumission par l’intermédiaire de la route (Utilisation du POST),
(6) Le contrôleur génère la réponse,
(7) La réponse est envoyée au client.

48
Créer un modèle (1/4)

Création du formulaire:

<table>
<tr>
<td><label>Nom du module:</label></td>
<td><input type="text" name="nom_module" placeholder="nom du module" ></td>
</tr>
<tr>
<td><label>Durée:</label></td>
<td><input type="text" name="duree" id="duree" placeholder="duree" ></td>
</tr>
<tr>
<td><label>Description:</label></td>
<td> <textarea name="description" id="description" placeholder="Votre description" cols=23></textarea></
td>
</tr>
<tr>
<td clospan="2"><button type="submit" class="btn btn-secondary">Ajouter</button></td>
</tr>
</table>
49
Créer un modèle (2/4)
1ère méthode
On définit dans le controlleur la fonction store suivante:
public function $request)
{store(Request
$module = new \App\Models\Module; Créer une nouvelle instance de l’objet Cours
$module>nom_module = $request->nom_module; Récupérer le contenu du champ nom du module
$module>duree = $request->duree; Récupérer le contenu du champ durée
$module->description = $request->description; Récupérer le contenu du champ description
$module->save(); Fonction prédéfinie pour l’insertion dans la base de données
return redirect('/cours'); Redirection vers l’affichage de la liste des cours
}

50 50
Créer un modèle (3/4)
2ème méthode
On définit dans le contrôleur la fonction store suivante:
public function $request)
{store(Request
Module::create(['nom_module'=>$request-> nom_module,'duree'=>$request->duree,
‘description'=>$request->description]);;
return redirect('/cours');}

Pour utiliser cette méthode, nous devons modifier le modèle en ajoutant l’une
de ces 2 lignes pour activer l’affectation de masse :
• protected $fillable = ['nom_module', ‘duree’,’description’]; : pour désigner
les colonnes autorisant l’affectation de masse, les autres bloquent.
• protected $guarded = ['existe']; : pour désigner les colonnes bloquant
l’affectation de masse, les autres autorisent.

51 51
Créer un modèle (4/4)
Create vs Save

• Save() : la fonction qui permet d’ajouter un nouveau enregistrement

dans la base.

• Create() : la fonction qui retourne le formulaire d’ajout.

52
Supprimer un modèle

Dans la vue, nous rajoutons un bouton de suppression qui

envoi l’id du cours à supprimer
<form action="{{ route(‘module.delete', [$listmodules->id]) }}" method="get">
<button type="submit" class="btn btn-link">Supprimer</button>
</form>

Dans le controlleur, nous définissons la fonction destroy:

public function destroy($id)
{
$module = \App\Models\Module::find($id);
$module->delete();
return redirect()->route('module.affiche')
->with('success','Module deleted successfully.');;
}

53
Modifier un modèle (1/3)

Pour afficher un cours donné, il suffit de créer le fichier blade

« edit.blade.php » suivant:
<form action="{{ route('cours.update', $cours->id) }}" method="GET">
<div class="form-group">
<table>
<tr>
<td><label>Nom du module:</label></td>

<td><input type="text" name="nom_module" id="nom_module" value="{{ $module>nom_module }}" ></td>

</tr><tr>
<td><label>Durée:</label></td>
<td><input type="text" name="duree" id="duree" value="{{ $module->duree }}" ></td>
</tr><tr>
<td><label>Description:</label></td>
<td> <textarea name="description" id="description" cols=23>
{{ $module->description }}</textarea></td></tr>
</div>
<tr>
<td clospan="2"><button type="submit" class="btn btn-secondary">Modifier</button></td></tr>
</table></form>
54

54
Modifier un modèle (2/3)

La fonction edit va servir à afficher la vue et à transmettre des

données si nécessaire.
La fonction update, elle, va contenir toute la partie modification
de la donnée

public function edit(Request $request)

{
$module = \App\Models\Module::find($request->id);
return view('edit',compact(module'));
}

55

55
Modifier un modèle (3/3)

public function update(Request $request, $id)

{
Module::where('id', $id)->update($request->all());
return redirect()->route('module.affiche');

56

56
Les relations

57
Les relations (1/9)

• Les tables de base de données sont souvent liées les unes aux autres.
Exemple: une commande peut être liée à un utilisateur,

• Il existe plusieurs types de relations.

Exemples:
✔ One To One
✔ One To Many
✔ Many To Many

58
Les relations (2/9)
La Relation « OneToMany » (L’inverse « ManyToOne »)

Exemple:
✔ Un «Module» contient plusieurs «Chapitres»
✔ Un «Chapitre» n’appartient qu’à un seule «Module»
OneToMany (hasMany())

ManyToOne (belongsTo())

59
Les relations (3/9)
La Relation « OneToMany » (L’inverse « ManyToOne »)

Pour définir la relation « OneToMany », il suffit d’ajouter la fonction «chapitres»

dans le modèle « Module » en appelant la méthode «hasMany()»:
public function chapitres()
{
return $this->hasMany(Chapitre::class);
}

NB: D’après la convention de nommage, le nom de la méthode doit être au pluriel

❑ Pour définir l'inverse d'une relation « ManyToOne », il suffit d’ajouter la fonction

«module» dans le modèle « Chapitre » en appelant la méthode «belongsTo()»:
public function module()
{
return $this->belongsTo(Module::class);
}

NB: D’après la convention de nommage, le nom de la méthode doit être au singulier

60
Les relations (4/9)
La Relation « OneToMany » (L’inverse « ManyToOne »)

Dans le fichier de migration « CreateChapitresTable », on ajoute la

clé étrangère comme suit:
public function up()
{
Schema::create(‘chapitres', function (Blueprint $table) {
$table->id();
$table->text('Nom_Module');
$table->text('description');
$table->string('duree');
$table->timestamps();

$table->foreignId(‘module_id')->constrained();
});
}

NB: Pour faire la mise à jour de la table modules, il suffit de lancer la commande:
php artisan migrate:refresh

61
Les relations (5/9)
La Relation « ManyToMany »

Ce type de relation signifie qu’un modèle A peut être lié à plusieurs modèles B,
et vice versa.
❑ Exemple:
✔ Un «Enseignant» peut enseigner plusieurs «Modules»
✔ Un «Module» peut être enseigné par plusieurs «Enseignants»

Pour ce type de relation, il faut créer une table intermédiaire de jointure qui
permet de relier entre les deux tables.

62
Les relations (6/9)
La Relation « ManyToMany »

Dans notre exemple, On va avoir nos tables « modules » et

« enseignants » mais en plus une table de jointure (appelée aussi
table pivot) intitulée « enseignant_module ».

63
Les relations (7/9)
La Relation « ManyToMany »

• Pour créer le fichier de migration de la table pivot on

utilise la commande suivante:
php artisan make:migration enseignant_module

NB: D’après la convention de nommage, le nom d'une table pivot

doit être composé des noms des deux tables en singulier,
séparés par une barre de soulignement (ex :
enseignant_module) et dans l’ordre alphabétique.

64
Les relations (8/9)
La Relation « ManyToMany »

Dans le fichier de migration enseignant_module, on ajoute les

deux clés étrangères comme suit:
public function up()
{
Schema::create('enseignant_module', function (Blueprint $table) {
$table->id();
$table->unsignedBigInteger('module_id');
$table->unsignedBigInteger('enseignant_id');
$table->timestamps();
$table->foreign('module_id')->references('id')->on('modules')
->onDelete('cascade')->onUpdate('cascade');
$table->foreign('enseignant_id')->references('id')->on('enseignants')
->onDelete('cascade')->onUpdate('cascade');
});

65
Les relations (9/9)
La Relation « ManyToMany »

Ajouter la fonction «enseignants» dans le modèle « Module » en appelant la

méthode « belongsToMany() »:
public function enseignants()
{
return $this->belongsToMany(Enseignant::class);
}

Pour définir la relation « ManyToMany », il suffit d’ajouter la fonction « modules »

dans le modèle « Enseignant » en appelant la méthode « belongsToMany() »

public function modules()

{
return $this->belongsToMany(Module::class);
}

Il suffit de lancer la commande suivante

php artisan migrate:refresh
66
66
Références

 https://laravel.com/docs/master/eloquent
 https://laravel.com/docs/master/collections#method-all

67
Références

 https://laravel.com/docs/master/eloquent
 https://laravel.com/docs/master/collections#method-all

68
Merci de votre attention

69