Laravel
Models Migration Relation
Introduction Installation Projet:Structure Strucutre,model,migration Migration,Models,Relation Artisan CLI Migrations:Exemples Models:Exemples Relations:Exemples 1 Relations:Exemples 2
Les Relations
BelongsTo HasOne HasMany BelongsToMany HasManyThrough
Exemples des Relations
Relations:oneToMany,ManyToMany... Relations:Exemples
Exercices
Exercice 1 Exercice 2
Controllers Views Routes
Routes,Controller,Model,view
Les Routes
Définir:Routes Routes avec Paramètres Routes nommées Groupes de routes
Les Controllers
Les Controllers Les Contrôleurs de Ressources
Les Vues
Vues et Blade Templates Blade Layouts et Sections Sous-vues Composants et Slots Contrôles de flux
MVC :CRUD
CRUD: Produit CRUD: Etudiant CRUD: Car CRUD,Recherche: Book
Validation
Exemple :Projets
ORM:Eloquent
Exemple :Transport
Api:Laravel +React
Middleware

Seeders & Factories
Exemples :EFM

Authenfication
TP:Schools Management
Authenfication:React
Layouts
Exercices





Eloquent ORM : Jointures

1. Jointure simple (INNER JOIN) :
Supposons que vous ayez deux modèles Produit et Categorie, et que chaque produit appartienne à une catégorie. Vous pouvez utiliser belongsTo dans le modèle Produit pour définir la relation :

// Produit.php
class Produit extends Model {
    public function categorie() {
        return $this->belongsTo(Categorie::class, 'idcategorie', 'idcategorie');
    }
}

// Categorie.php
class Categorie extends Model {
    // ...
}
Maintenant, pour effectuer une jointure et récupérer tous les produits avec les informations de la catégorie, vous pouvez faire quelque chose comme ceci :

$produits = Produit::join('categories', 'produits.idcategorie', '=', 'categories.idcategorie')
                   ->select('produits.*', 'categories.nom as categorie_nom')
                   ->get();
Cependant, grâce à la relation Eloquent, vous pouvez simplifier cela :

$produits = Produit::with('categorie')->get();
2. Jointure avec conditions :
Supposons que vous ayez un modèle Client et un modèle Vente, et que chaque vente soit associée à un client. Vous pouvez utiliser belongsTo dans le modèle Vente :

// Vente.php
class Vente extends Model {
    public function client() {
        return $this->belongsTo(Client::class, 'idclient', 'idclient');
    }
}

// Client.php
class Client extends Model {
    // ...
}
Pour récupérer toutes les ventes avec les informations du client, vous pouvez faire :

$ventes = Vente::with('client')->get();
3. Jointure avec des conditions avancées :
Supposons que vous ayez un modèle Vente et un modèle Produit, et que chaque vente soit associée à un produit. Vous pouvez utiliser belongsTo dans le modèle Vente :

// Vente.php
class Vente extends Model {
    public function produit() {
        return $this->belongsTo(Produit::class, 'idproduit', 'idproduit');
    }
}

// Produit.php
class Produit extends Model {
    // ...
}
Pour récupérer toutes les ventes avec les informations du produit, en filtrant par une condition spécifique sur le produit, vous pouvez faire :

$ventes = Vente::with(['produit' => function ($query) {
                $query->where('prix', '>', 50);
           }])
           ->get();
4. Jointure avec plusieurs conditions :
Supposons que vous ayez un modèle Commande et un modèle Produit, et chaque commande est associée à plusieurs produits via une table pivot commande_produit. Vous pouvez utiliser belongsToMany pour définir cette relation :

// Commande.php
class Commande extends Model {
    public function produits() {
        return $this->belongsToMany(Produit::class, 'commande_produit', 'idcommande', 'idproduit');
    }
}

// Produit.php
class Produit extends Model {
    // ...
}
Pour récupérer toutes les commandes avec les informations détaillées des produits, vous pouvez faire :

$commandes = Commande::with('produits')->get();
5. Jointure polymorphique :
Supposons que vous ayez un modèle Commentaire qui peut être associé à un modèle Article ou à un modèle Photo. Vous pouvez utiliser une relation polymorphique :

// Commentaire.php
class Commentaire extends Model {
    public function commentable() {
        return $this->morphTo();
    }
}

// Article.php
class Article extends Model {
    // ...
}

// Photo.php
class Photo extends Model {
    // ...
}
Pour récupérer tous les commentaires avec les informations détaillées des articles ou des photos, vous pouvez faire :

$commentaires = Commentaire::with('commentable')->get();
6. Jointure conditionnelle :
Supposons que vous ayez un modèle Client avec une colonne type qui peut être "individuel" ou "entreprise", et un modèle Commande associé. Vous pouvez utiliser une jointure conditionnelle pour récupérer les commandes en fonction du type de client :

$commandes = Commande::join('clients', function ($join) {
                $join->on('commandes.idclient', '=', 'clients.idclient')
                     ->where('clients.type', '=', 'individuel');
            })
            ->get();
Exemple 1: Récupérer tous les clients avec leurs ventes associées

// Récupérer tous les clients avec leurs ventes associées
$clients = Client::with('ventes')->get();

// Afficher les informations
foreach ($clients as $client) {
    echo "Nom du client: {$client->nom}\n";
    
    // Afficher les ventes associées
    foreach ($client->ventes as $vente) {
        echo "   Vente ID: {$vente->idvente}, Quantité: {$vente->quantite}\n";
    }
    echo "\n";
}
Exemple 2: Créer un nouveau produit pour une catégorie spécifique

// Créer un nouveau produit
$produit = new Produit();
$produit->nom = "Nouveau produit";
$produit->prix = 50.99;
$produit->marque = "Marque XYZ";
$produit->quantiteStock = 100;

// Associer le produit à une catégorie spécifique
$categorie = Categorie::find(1);
$produit->categorie()->associate($categorie);

// Sauvegarder le produit
$produit->save();
Exemple 3: Mettre à jour le prix de tous les produits d'une catégorie

// Mettre à jour le prix de tous les produits d'une catégorie
Produit::where('idcategorie', 1)
        ->update(['prix' => 55.99]);
Exemple 4: Supprimer une vente spécifique et mettre à jour la quantité en stock du produit associé

// Supprimer une vente spécifique (ID de la vente à supprimer)
$idVenteASupprimer = 1;
$vente = Vente::find($idVenteASupprimer);

if ($vente) {
    // Mettre à jour la quantité en stock du produit associé
    $produit = $vente->produit;
    $produit->quantiteStock += $vente->quantite;
    $produit->save();

    // Supprimer la vente
    $vente->delete();
} else {
    echo "La vente avec l'ID {$idVenteASupprimer} n'a pas été trouvée.\n";
}
Exemple 5: Récupérer tous les produits avec les informations sur la catégorie

// Récupérer tous les produits avec les informations sur la catégorie préchargées
$produits = Produit::with('categorie')->get();

// Afficher les informations
foreach ($produits as $produit) {
    echo "Nom du produit: {$produit->nom}, Prix: {$produit->prix}\n";
    echo "   Catégorie: {$produit->categorie->nom}\n\n";
}
Exemple 6: Créer une nouvelle catégorie et y associer un produit

// Créer une nouvelle catégorie
$nouvelleCategorie = new Categorie();
$nouvelleCategorie->nom = "Nouvelle Catégorie";
$nouvelleCategorie->description = "Description de la nouvelle catégorie";
$nouvelleCategorie->save();

// Associer un produit à la nouvelle catégorie
$produit = Produit::find(1);
$produit->categorie()->associate($nouvelleCategorie);
$produit->save();
Exemple 7: Récupérer tous les clients qui ont effectué une vente avec un produit de la catégorie 2

// Récupérer les clients qui ont effectué une vente avec un produit de la catégorie 2
$clients = Client::whereHas('ventes.produit', function ($query) {
                $query->where('idcategorie', 2);
             })
             ->get();

// Afficher les informations
foreach ($clients as $client) {
    echo "Nom du client: {$client->nom}, Prénom: {$client->prenom}\n";
}
Exemple 8: Récupérer les produits avec un prix supérieur à 50 et une quantité en stock supérieure à 10

// Récupérer les produits avec un prix supérieur à 50 et une quantité en stock supérieure à 10
$produits = Produit::where('prix', '>', 50)
                    ->where('quantiteStock', '>', 10)
                    ->get();

// Afficher les informations
foreach ($produits as $produit) {
    echo "Nom du produit: {$produit->nom}, Prix: {$produit->prix}, Quantité en stock: {$produit->quantiteStock}\n";
}
Exemple 9: Utilisation de pluck pour récupérer uniquement les noms des produits de la catégorie 3

// Récupérer uniquement les noms des produits de la catégorie 3
$nomsProduits = Produit::where('idcategorie', 3)->pluck('nom');

// Afficher les noms des produits
foreach ($nomsProduits as $nomProduit) {
    echo "Nom du produit: {$nomProduit}\n";
}
Exemple 10: Utilisation de whereDate pour récupérer les ventes effectuées après une date spécifique

// Récupérer les ventes effectuées après le 2023-01-01
$ventes = Vente::whereDate('datevente', '>', '2023-01-01')->get();

// Afficher les informations sur les ventes
foreach ($ventes as $vente) {
    echo "ID de vente: {$vente->idvente}, Date de vente: {$vente->datevente}\n";
}
Exemple 11: Utilisation de orWhereHas avec des conditions complexes sur plusieurs relations

// Récupérer les clients qui ont effectué une vente avec un produit de la catégorie 1
// OU les clients dont le nom est "Dupont" et prénom est "Jean"
$clients = Client::orWhereHas('ventes.produit', function ($query) {
                $query->where('idcategorie', 1);
             })
             ->orWhere(function ($query) {
                 $query->where('nom', 'Dupont')->where('prenom', 'Jean');
             })
             ->get();

// Afficher les informations sur les clients
foreach ($clients as $client) {
    echo "Nom du client: {$client->nom}, Prénom: {$client->prenom}\n";
}
Exemple 12: Utilisation de whereDoesntHave pour récupérer les clients sans vente

// Récupérer les clients sans vente
$clientsSansVente = Client::doesntHave('ventes')->get();

// Afficher les informations sur les clients
foreach ($clientsSansVente as $client) {
    echo "Nom du client: {$client->nom}, Prénom: {$client->prenom}\n";
}
Exemple 13: Utilisation de orderBy pour récupérer les produits triés par prix de manière décroissante

// Récupérer les produits triés par prix de manière décroissante
$produitsTriés = Produit::orderBy('prix', 'desc')->get();

// Afficher les informations sur les produits
foreach ($produitsTriés as $produit) {
    echo "Nom du produit: {$produit->nom}, Prix: {$produit->prix}\n";
}
Exemple 14: Utilisation de chunk pour traiter un grand nombre d'enregistrements par morceaux

// Traiter tous les clients par morceaux de 100 à la fois
Client::chunk(100, function ($clients) {
    foreach ($clients as $client) {
        echo "Nom du client: {$client->nom}, Prénom: {$client->prenom}\n";
    }
});
Exemple 15: Utilisation de withCount pour compter le nombre de ventes associées à chaque client

// Récupérer tous les clients avec le nombre de ventes associées
$clientsAvecNombreVentes = Client::withCount('ventes')->get();

// Afficher les informations sur les clients avec le nombre de ventes
foreach ($clientsAvecNombreVentes as $client) {
    echo "Nom du client: {$client->nom}, Prénom: {$client->prenom}, Nombre de ventes: {$client->ventes_count}\n";
}
Exemple 16: Utilisation de whereIn pour récupérer les produits par ID

// Récupérer les produits par ID spécifiques
$idsProduits = [1, 2, 3];
$produits = Produit::whereIn('idproduit', $idsProduits)->get();

// Afficher les informations sur les produits
foreach ($produits as $produit) {
    echo "Nom du produit: {$produit->nom}, Prix: {$produit->prix}\n";
}
Exemple 17: Utilisation de whereHas pour filtrer les clients ayant effectué une vente récemment

// Récupérer les clients ayant effectué une vente récemment (dans les 30 derniers jours)
$clients = Client::whereHas('ventes', function ($query) {
                $query->where('datevente', '>', now()->subDays(30));
             })
             ->get();

// Afficher les informations sur les clients
foreach ($clients as $client) {
    echo "Nom du client: {$client->nom}, Prénom: {$client->prenom}\n";
}