Laravel
Models Migration Relation
Introduction,istallation Strucutre,model,migration Migration,Models,Relation
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 CRUD: Etudiant CRUD: Car CRUD,Recherche: Book
Validation
Exemple :Projets
Eloquent
Eloquent Lecture : all, find, first, get where, orWhere, whereIn, orderBy, etc Les joinutres DB::
Routing
Views,Blade Templates
  • Création de Vues
  • Passage de Données aux Vues
  • Variables de Vues
  • Conditions dans les Templates
  • Boucles dans les Templates
  • Inclusion de Vues Partielles
  • Directives Blade
  • Extensions Blade
  • Création de Layouts
  • Sections et Yield
  • Échappement de Contenu
  • Composer de Vue
  • Service de Vues
  • Partage de Données entre Vues
  • Localisation et Traduction
Forms,Validation
  • Création de Formulaires
  • Validation de Formulaires
  • Messages de Validation
  • Redirection après Validation
  • Anciennes Données de Formulaire
  • Création de Formulaires Collectifs
  • Validation Personnalisée
  • Création de Règles de Validation
  • Extension des Règles de Validation
  • Validation de Requêtes Ajax
  • Validation de Fichiers
  • Préservation des Données de Formulaire
  • Validation de Requêtes API
  • Validation de Formulaires Vue.js
  • Validation avec Form Requests
Seeder
  • Création de Seeders
  • Exécution de Seeders
  • Seeders pour les Données de Base
  • Utilisation de Factories dans les Seeders
  • Seeders de Relations
  • Seeders Personnalisés
  • Utilisation des Commandes Artisan pour les Seeders
  • Reproduction (Rollback) des Seeders
  • Seeders avec Faker pour les Données Fausse
  • Seeders en Production
  • Utilisation des Seeders avec les Tests
  • Seeders pour les Tables Pivot
  • Seeders pour les Données Temporaires
  • Seeders pour les Données de Configuration
  • Utilisation des Seeders dans les Environnements Spécifiques
  • Seeders pour les Tables Interactives (Interactive Tables)
  • Seeder de Données en Masse
  • Seeders pour les Données de Développement
  • Seeder avec Relations Complexes
  • Seeders pour les Données d'Application
Middleware
  • Middleware Global
  • Middleware Assigné à des Routes
  • Création de Middleware Personnalisé
  • Middleware Prioritaire
  • Middleware Terminable
  • Middleware de Groupe
  • Middleware de Terminaison (Terminable Middleware)
  • Exclusion de Middleware par Route
  • Middleware Basé sur un Prédicat (Closure Middleware)
  • Middleware de Routage
  • Middleware d'Authentification
  • Middleware CSRF
  • Middleware de Vérification d'État du Cache
  • Middleware de Vérification du Jeton API
  • Middleware de Maintenance
Cookie
  • Création de Cookies
  • Lecture de Cookies
  • Modification de Cookies
  • Suppression de Cookies
  • Cookies Chiffrés et Signés
  • Cookie Flash
  • Cookies Cryptés
  • Cookie sans Préfixe
  • Global Middleware des Cookies
  • Configuration des Cookies
  • Cookie Guard
  • Expiration des Cookies
  • Cookies HTTP-Only
  • Cookie Samesite
  • Cookie dans les Réponses de Fichiers
Session
  • Configuration de Session
  • Utilisation de Session
  • Stockage de Données en Session
  • Lecture de Données en Session
  • Suppression de Données en Session
  • Session Flash
  • Session avec Base de Données
  • Session dans les Vues
  • Redirection avec Anciennes Données de Session
  • Session Guard
  • Manipulation des ID de Session
  • Personnalisation du Nom du Cookie de Session
  • Expiration de Session
  • Forçage de l'Expiration de Session
  • Événements de Session
  • Protection contre la Régénération de Session
Authentication,Authorization
  • Configuration de l'Authentification
  • Création de Systèmes d'Authentification
  • Les Vues d'Authentification
  • Le Trait d'Authentification
  • Protection de Routes et de Contrôleurs
  • Middleware d'Authentification
  • Redirection après Connexion/Déconnexion
  • Confirmation par Email
  • Réinitialisation de Mot de Passe
  • Authentification à Deux Facteurs
  • Authentification API
  • Personnalisation des Erreurs d'Authentification
  • Personnalisation du Nom du Champ d'Authentification
  • Déconnexion des Sessions
  • Enregistrement d'Utilisateur
  • Middleware d'Authorization
  • Gate et Policies
  • Authorization dans les Contrôleurs
  • Blade et Authorization
  • Blade et Directives Authorization
File Uploading
  • Configuration de l'Upload de Fichiers
  • Upload de Fichiers dans les Formulaires
  • Validation des Fichiers
  • Stockage des Fichiers
  • Modification des Fichiers
  • Suppression des Fichiers
  • Upload de Multiples Fichiers
  • Filesystem Disk Configuration
  • Upload de Fichiers avec Intervention Image
  • Upload de Fichiers avec Spatie Media Library
  • Upload de Fichiers en API
  • Personnalisation des Noms de Fichiers
  • Personnalisation des Directories de Stockage
  • Gestion des Erreurs d'Upload de Fichiers
  • Upload de Fichiers Vue.js
  • File Upload avec Livewire
  • Upload de Gros Fichiers
  • File Upload et Middleware
  • File Upload et File Validation
Email
  • Configuration de l'Envoyeur (Mailer)
  • Envoi de Emails
  • Vues pour les Emails
  • Attachments dans les Emails
  • Emails HTML et Texte Brut
  • Personnalisation des Entêtes d'Email
  • Personnalisation des Messages Swift
  • Files d'Attente d'Emails
  • Mail Notifications
  • Markdown Emails
  • Personnalisation des Vues de Notifications
  • Notifications en Base de Données
  • Mail avec Mailables
  • File d'Attente pour les Mailables
  • Envoyer des Emails à Plusieurs Destinataires
  • Mail et Locale
  • Mail de Notification Personnalisée
  • Email de Réinitialisation de Mot de Passe
  • Emails avec Files d'Attente et Jobs
  • Logging des Emails
Ajax
  • Configuration de la Protection CSRF pour les Requêtes Ajax
  • Requêtes Ajax avec jQuery
  • Requêtes Ajax avec Axios
  • Utilisation des Routes pour les Requêtes Ajax
  • Passage de Données aux Requêtes Ajax
  • Recevoir et Traiter les Requêtes Ajax dans les Contrôleurs
  • Retourner des Réponses JSON
  • Validation de Requêtes Ajax
  • Utilisation d'Ajax avec Livewire
  • Intégration d'Ajax dans les Formulaires
  • Gestion des Erreurs dans les Requêtes Ajax
  • File Upload avec Ajax
  • Utilisation d'Ajax avec Vue.js
  • Requêtes Ajax dans les Tests
  • Personnalisation des Réponses JSON
  • Préchargement de Données avec Ajax
  • Manipulation du DOM avec Ajax
Views
  • Création de Vues
  • Passage de Données aux Vues
  • Variables de Vues
  • Conditions dans les Templates
  • Boucles dans les Templates
  • Inclusion de Vues Partielles
  • Directives Blade
  • Extensions Blade
  • Création de Layouts
  • Sections et Yield
  • Échappement de Contenu
  • Composer de Vue
  • Service de Vues
  • Partage de Données entre Vues
  • Localisation et Traduction
  • Vue d'Ensemble des Vues
  • Méthodes Magiques de Vue
  • Vues Composants
  • Composants de Vue dans les Formulaires
  • Composants Dynamiques
Rest API
  • Configuration de Routes pour une API
  • Utilisation des Contrôleurs pour les Ressources
  • Routes de Ressources API
  • Middleware pour l'Authentification API
  • Validation de Requêtes API
  • Transformation de Ressources
  • API Resources
  • API Resource Collections
  • Pagination dans les Ressources API
  • API Resource Customization
  • API Resource Relationships
  • Envoi de Réponses JSON
  • Middleware de Traitement des Réponses API
  • Versionnement de l'API
  • Rate Limiting pour l'API
  • Gestion des Erreurs API
  • File Upload avec une API
  • Authentification API avec Jetstream
  • Authentification API avec Sanctum
  • Authentification API avec Passport
  • Testing de l'API
Internationalisation et Localisation
  • Configuration de la Langue par Défaut
  • Fichiers de Langue
  • Traduction de Textes
  • Variables de Remplacement dans les Traductions
  • Localisation de Formats de Date, Heure et Nombre
  • Localisation des Vues
  • Méthodes Helper pour la Traduction
  • Méthodes de Langue pour les Champs de Formulaire
  • Localisation des Messages d'Erreur de Validation
  • Changement Dynamique de la Langue
  • Localisation des Routes
  • Localisation des Fichiers de Config
  • Localisation des Vues Vue.js
  • Localisation des Emails
  • Localisation des Notifications
  • Localisation des Seeders
  • Langues Prises en Charge
  • Configuration des Fallback Locales
  • Localisation pour les Applications Multi-Domaines
  • Localisation dans les Tests
  • Localisation des URL
  • Localisation des Assets (JavaScript, CSS)
  • Stratégies de Gestion des Langues
Console Artisan et Tâches Planifiées
  • Introduction à Artisan Console
  • Liste des Commandes Artisan
  • Création de Commandes Artisan Personnalisées
  • Paramètres et Options de Commandes Artisan
  • Argument et Option avec Valeurs par Défaut
  • Exécution de Commandes Artisan Programmatically
  • Artisan Tinker - Console Interactive
  • Commandes de Migration Artisan
  • Commandes de Génération de Code Artisan
  • Commandes pour l'Optimisation
  • Commandes pour les Tests
  • Commandes pour l'Environnement de Travail
  • Commandes pour la Configuration
  • Commandes pour les Tâches Planifiées
  • Création de Tâches Planifiées avec Cron
  • Tâches Planifiées avec le Système de Files d'Attente
  • Tâches Planifiées avec Laravel Horizon
  • Exécution de Tâches Planifiées Manuellement
  • Logging des Sorties de Tâches Planifiées
  • Limitation de l'Exécution de Tâches Planifiées
  • Tâches Planifiées en Environnement de Développement
  • Tâches Planifiées en Environnement de Production
Tests dans Laravel
  • Introduction aux Tests dans Laravel
  • Configuration des Environnements de Tests
  • Types de Tests dans Laravel
  • Tests Unitaires
  • Tests Fonctionnels
  • Tests de Navigation
  • Assertions dans les Tests
  • Tests de Validation de Données
  • Tests de Base de Données
  • Utilisation des Factories dans les Tests
  • Tests de Contrôleurs
  • Tests de Middleware
  • Tests d'Authentification
  • Tests d'Autorisation
  • Tests de Traits
  • Tests d'API
  • Tests Vue.js avec Laravel
  • Tests de Notifications
  • Tests d'Événements
  • Tests de Jobs
  • Tests de Console Artisan
  • Tests Dusk pour les Tests de Navigateur
  • Configuration des Environnements pour les Tests Dusk
  • Utilisation des Données de Base dans les Tests Dusk
  • Tests Dusk avec Vue.js
Les Notifications
  • Introduction aux Notifications
  • Configuration des Notifications
  • Envoi de Notifications
  • Création de Notifications
  • Personnalisation des Canaux de Notification
  • Personnalisation des Vues de Notification
  • Notification avec Base de Données
  • Notification avec File d'Attente
  • Notification avec Broadcast
  • Notification avec Mail
  • Notification avec Slack
  • Notification avec SMS (Nexmo, Twilio)
  • Notification avec Base de Données SQLite
  • Notification avec Discord
  • Notification avec Pusher
  • Notification avec Telegram
  • Notification avec WebSockets
  • Notification avec Broadcast sur Canal Privé
  • Personnalisation des Actions de Notification
  • Notifications en Masse
  • Notification avec File d'Attente et Jobs
  • Notification avec File d'Attente et Livewire
  • Notification avec Events
  • Logging des Notifications
La Sécurité dans Laravel
  • Protection CSRF
  • Protection XSS
  • Protection des Routes
  • Validation de Données
  • Échappement de Contenu
  • Authentification Multi-Facteurs (2FA)
  • Protection des Sessions
  • Protection des Cookies
  • Protection contre les Attaques SQL Injection
  • Protection contre les Attaques XSS
  • Protection contre les Attaques CSRF
  • Protection contre les Attaques Clickjacking
  • Configuration de la Politique de Mot de Passe
  • Stockage Sécurisé des Mots de Passe
  • Chiffrement des Cookies
  • Protection Contre les Attaques de Force Brute
  • Authentification API et Jetons
  • OAuth et Laravel Passport
  • Protection Contre les Attaques de Fichier Upload
  • Sécurité des Fichiers de Configuration
  • Protection des Routes Sensibles
  • Middleware de Sécurité
  • Reporting des Failles de Sécurité
  • Chiffrement des Données
  • Utilisation Sécurisée d'Ajax
Intégration de Frontend avec React
  • Configuration de l'Environnement de Développement
  • Création de Projets React avec Create React App
  • Création d'une API RESTful avec Laravel
  • Routes API dans Laravel
  • Controllers API dans Laravel
  • Validation des Requêtes API
  • Utilisation de Middlewares pour l'Authentification API
  • Authentification API avec Laravel Passport
  • Création de Modèles Eloquent pour l'API
  • Requêtes AJAX avec Axios
  • Gestion de l'État avec React Hooks
  • Communication entre React et l'API Laravel
  • Passage de Données entre Laravel et React
  • Création de Composants React
  • Utilisation de Routes dans React avec React Router
  • Intégration de Redux avec Laravel et React
  • Tests Frontend avec Jest et React Testing Library
  • Internationalisation dans une Application Laravel-React
  • Utilisation de Mix pour la Compilation des Ressources
  • Utilisation de Livewire avec React (optionnel)
  • Intégration de Tailwind CSS avec React
  • Intégration de Bootstrap avec React
  • Gestion des Erreurs Frontend et Backend
  • Déploiement d'une Application Laravel-React
  • Migration d'une Application Vue.js vers React




Eloquent ORM : where, orWhere, whereIn, orderBy, etc

1. Utilisation de where :
//Récupérer tous les clients avec le nom "Dupont"
$clients = Client::where('nom', 'Dupont')->get();
2. Utilisation de orWhere :
//Récupérer les produits avec un prix inférieur à 50 ou une quantité en stock supérieure à 100
$produits = Produit::where('prix', '<', 50)
                    ->orWhere('quantiteStock', '>', 100)
                    ->get();
3. Utilisation de whereIn :
//Récupérer les produits de la catégorie 1, 3 ou 5
$produits = Produit::whereIn('idcategorie', [1, 3, 5])->get();
4. Utilisation de orderBy :
//Récupérer tous les produits triés par prix de manière ascendante
$produits = Produit::orderBy('prix')->get();
5. Utilisation de where avec des relations :
//Récupérer toutes les ventes pour un client spécifique avec une quantité supérieure à 5
$ventes = Vente::where('idclient', 1)
               ->where('quantite', '>', 5)
               ->get();
6. Utilisation de orWhere avec des relations :
//Récupérer toutes les ventes pour un client spécifique ou un produit spécifique
$ventes = Vente::where('idclient', 1)
               ->orWhere('idproduit', 2)
               ->get();
7. Utilisation de whereIn avec des relations :
//Récupérer toutes les ventes pour les produits de la catégorie 1, 3 ou 5
$ventes = Vente::whereIn('idproduit', Produit::whereIn('idcategorie', [1, 3, 5])->pluck('idproduit'))
               ->get();
8. Utilisation de orderBy avec des relations :
//Récupérer toutes les ventes triées par date de vente de manière descendante
$ventes = Vente::orderBy('datevente', 'desc')->get();
9. Utilisation de where avec des opérateurs logiques :
//Récupérer tous les produits avec un prix supérieur à 50 et une quantité en stock inférieure à 100
$produits = Produit::where('prix', '>', 50)
                    ->where('quantiteStock', '<', 100)
                    ->get();
10. Utilisation de orWhere avec des opérateurs logiques :
//Récupérer les clients avec le nom "Dupont" ou "Durand" qui ont effectué une vente
$clients = Client::where('nom', 'Dupont')
                 ->orWhere('nom', 'Durand')
                 ->whereHas('ventes') // Assure qu'il existe au moins une vente associée
                 ->get();
11. Utilisation de where avec une clause orWhere imbriquée :
//Récupérer tous les produits avec un prix inférieur à 50 ou (une marque spécifique et une quantité en stock supérieure à 50)
$produits = Produit::where('prix', '<', 50)
                    ->orWhere(function ($query) {
                        $query->where('marque', 'Samsung')
                              ->where('quantiteStock', '>', 50);
                    })
                    ->get();
12. Utilisation de where avec like pour la recherche :
//Récupérer tous les clients dont le prénom commence par "A"
$clients = Client::where('prenom', 'like', 'A%')->get();
13. Utilisation de whereNotNull :
//Récupérer tous les clients avec un nom défini
$clients = Client::whereNotNull('nom')->get();
14. Utilisation de whereDate :
//Récupérer toutes les ventes effectuées après une date spécifique
$ventes = Vente::whereDate('datevente', '>', '2023-01-01')->get();
15. Utilisation de whereBetween :
//Récupérer les produits avec un prix compris entre 20 et 50
$produits = Produit::whereBetween('prix', [20, 50])->get();
16. Utilisation de orWhereBetween :
//Récupérer les produits avec un prix compris entre 20 et 50 ou une quantité en stock entre 10 et 30
$produits = Produit::orWhereBetween('prix', [20, 50])
                    ->orWhereBetween('quantiteStock', [10, 30])
                    ->get();
17. Utilisation de orWhere avec des relations multiples :
//Récupérer les ventes pour les produits de la catégorie 1 ou 3, et dont la quantité est supérieure à 5
$ventes = Vente::whereHas('produit', function ($query) {
                $query->whereIn('idcategorie', [1, 3]);
             })
             ->where('quantite', '>', 5)
             ->get();
18. Utilisation de whereHas avec des conditions supplémentaires :
//Récupérer les clients ayant effectué une vente avec un produit de la catégorie 1
$clients = Client::whereHas('ventes', function ($query) {
                $query->whereHas('produit', function ($innerQuery) {
                    $innerQuery->where('idcategorie', 1);
                });
             })
             ->get();
19. Utilisation de with pour charger des relations en même temps :
//Récupérer tous les produits avec les informations sur la catégorie préchargées
$produits = Produit::with('categorie')->get();
20. Utilisation de doesntHave pour trouver des enregistrements sans relation :
//Récupérer les clients sans vente
$clientsSansVente = Client::doesntHave('ventes')->get();
21. Utilisation de withCount pour compter le nombre de relations :
//Récupérer les catégories avec le nombre total de produits
$categories = Categorie::withCount('produits')->get();
22. Utilisation de whereJsonContains pour les colonnes JSON :
//Récupérer les produits avec une description JSON contenant le mot "premium"
$produits = Produit::whereJsonContains('description->tags', 'premium')->get();
23. Utilisation de whereDoesntHave pour exclure certains résultats :
//Récupérer les clients sans vente pour le produit de la catégorie 2
$clientsSansVentePourCategorie2 = Client::whereDoesntHave('ventes', function ($query) {
    $query->whereHas('produit', function ($innerQuery) {
        $innerQuery->where('idcategorie', 2);
    });
})->get();
24. Utilisation de orWhereHas avec des conditions complexes :
//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();
25. Utilisation de with pour charger des relations imbriquées :
//Récupérer tous les clients avec leurs ventes et les détails des produits associés
$clients = Client::with('ventes.produit')->get();
26. Utilisation de whereHas 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
// ET les clients dont le nom est "Dupont" et prénom est "Jean"
$clients = Client::whereHas('ventes.produit', function ($query) {
                $query->where('idcategorie', 1);
             })
             ->where(function ($query) {
                 $query->where('nom', 'Dupont')->where('prenom', 'Jean');
             })
             ->get();
27. Utilisation de orWhereHas avec des conditions sur une relation et une colonne :
//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();
28. Utilisation de whereDate avec une relation :
//Récupérer les ventes pour un produit spécifique effectuées après une date spécifique
$ventes = Vente::whereHas('produit', function ($query) {
                $query->whereDate('datevente', '>', '2023-01-01');
            })
            ->get();
29. Utilisation de orWhereHas avec une condition complexe sur une relation :
//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', function ($query) {
                $query->whereHas('produit', function ($innerQuery) {
                    $innerQuery->where('idcategorie', 1);
                });
             })
             ->orWhere(function ($query) {
                 $query->where('nom', 'Dupont')->where('prenom', 'Jean');
             })
             ->get();
30. Utilisation de whereHas pour exclure certains résultats :
//Récupérer les clients qui n'ont pas effectué de vente pour un produit spécifique
$clientsSansVente = Client::whereDoesntHave('ventes', function ($query) {
                        $query->where('idproduit', 1);
                    })
                    ->get();
31. Utilisation de whereNotNull avec une relation :
//Récupérer les clients qui ont effectué une vente (relation non nulle)
$clientsAvecVente = Client::whereHas('ventes')->get();
32. Utilisation de whereNull avec une relation :
//Récupérer les clients qui n'ont pas effectué de vente
$clientsSansVente = Client::whereDoesntHave('ventes')->get();
33. Utilisation de orWhere avec plusieurs conditions imbriquées :
//Récupérer les produits avec un prix inférieur à 50 OU (une marque spécifique ET une quantité en stock supérieure à 50)
$produits = Produit::where('prix', '<', 50)
                    ->orWhere(function ($query) {
                        $query->where('marque', 'Samsung')
                              ->where('quantiteStock', '>', 50);
                    })
                    ->get();
34. Utilisation de whereHas pour filtrer par rapport à une relation :
//Récupérer les clients qui ont effectué une vente avec un produit de la marque "Apple"
$clients = Client::whereHas('ventes.produit', function ($query) {
                $query->where('marque', 'Apple');
            })
            ->get();
35. Utilisation de whereBetween avec une relation :
//Récupérer les ventes avec une quantité entre 5 et 10
$ventes = Vente::whereBetween('quantite', [5, 10])->get();
36. Utilisation de orWhereBetween avec une relation :
//Récupérer les ventes avec une quantité entre 5 et 10 ou une quantité supérieure à 20
$ventes = Vente::orWhereBetween('quantite', [5, 10])
               ->orWhere('quantite', '>', 20)
               ->get();
37. Utilisation de whereNotBetween avec une relation :
//Récupérer les ventes avec une quantité en dehors de la plage de 5 à 10
$ventes = Vente::whereNotBetween('quantite', [5, 10])->get();
38. Utilisation de orWhereNotBetween avec une relation :
//Récupérer les ventes avec une quantité en dehors de la plage de 5 à 10 ou en dehors de la plage de 20 à 30
$ventes = Vente::orWhereNotBetween('quantite', [5, 10])
               ->orWhereNotBetween('quantite', [20, 30])
               ->get();
39. Utilisation de whereHas avec plusieurs conditions complexes sur des relations imbriquées :
//Récupérer les clients qui ont effectué une vente avec un produit de la catégorie 1
// ET les clients dont le nom est "Dupont" et prénom est "Jean"
// ET les ventes dont la quantité est supérieure à 5
$clients = Client::whereHas('ventes.produit', function ($query) {
                $query->where('idcategorie', 1);
             })
             ->where(function ($query) {
                 $query->where('nom', 'Dupont')->where('prenom', 'Jean');
             })
             ->whereHas('ventes', function ($query) {
                 $query->where('quantite', '>', 5);
             })
             ->get();
40. Utilisation de orWhere avec des conditions complexes sur plusieurs relations :
//Récupérer les produits avec un prix inférieur à 50 OU (une marque spécifique ET une quantité en stock supérieure à 50)
// OU (une vente avec un client ayant le nom "Dupont" ET une vente avec un client ayant le prénom "Jean")
$produits = Produit::where('prix', '<', 50)
                    ->orWhere(function ($query) {
                        $query->where('marque', 'Samsung')
                              ->where('quantiteStock', '>', 50);
                    })
                    ->orWhere(function ($query) {
                        $query->whereHas('ventes.client', function ($innerQuery) {
                            $innerQuery->where('nom', 'Dupont');
                        })
                        ->orWhereHas('ventes.client', function ($innerQuery) {
                            $innerQuery->where('prenom', 'Jean');
                        });
                    })
                    ->get();
41. Utilisation de whereRaw pour des conditions SQL brutes :
//Récupérer les produits avec un prix inférieur à 50 ET une quantité en stock supérieure à 10
$produits = Produit::whereRaw('prix < 50 AND quantiteStock > 10')->get();
42. Utilisation de orWhereRaw pour des conditions SQL brutes avec orWhere :
//Récupérer les produits avec un prix inférieur à 50 OU une quantité en stock supérieure à 10
$produits = Produit::orWhereRaw('prix < 50')
                    ->orWhereRaw('quantiteStock > 10')
                    ->get();
43. Utilisation de whereYear et orWhereYear pour filtrer par année :
//Récupérer les ventes de l'année 2022 ou dont la date de vente est en 2023
$ventes = Vente::whereYear('datevente', 2022)
               ->orWhereYear('datevente', 2023)
               ->get();
44. Utilisation de whereColumn pour comparer deux colonnes :
//Récupérer les ventes où la quantité est égale à la quantité en stock
$ventes = Vente::whereColumn('quantite', 'produits.quantiteStock')->get();
45. Utilisation de sous-requêtes dans where :
//Récupérer les clients qui ont effectué une vente avec un produit de la catégorie 1
// ET dont la quantité totale de ventes est supérieure à la moyenne globale de toutes les ventes
$clients = Client::whereHas('ventes.produit', function ($query) {
                $query->where('idcategorie', 1);
             })
             ->whereHas('ventes', function ($query) {
                 $query->selectRaw('sum(quantite) as total_ventes')
                       ->groupBy('idclient')
                       ->havingRaw('total_ventes > (select avg(quantite) from ventes)');
             })
             ->get();
46. Utilisation de whereJsonContains dans une relation JSON :
//Récupérer les produits avec une description JSON contenant "premium" ET une étiquette "sale"
$produits = Produit::whereJsonContains('description->tags', 'premium')
                    ->whereJsonContains('description->tags', 'sale')
                    ->get();
47. Utilisation de orWhere avec une sous-requête dans where :
//Récupérer les produits avec un prix inférieur à 50 OU une quantité en stock supérieure à la moyenne globale des stocks
$produits = Produit::where('prix', '<', 50)
                    ->orWhere('quantiteStock', '>', function ($query) {
                        $query->selectRaw('avg(quantiteStock)')->from('produits');
                    })
                    ->get();
48. Utilisation de whereExists pour vérifier l'existence d'une sous-requête :
//Récupérer les clients qui ont effectué une vente avec un produit de la catégorie 1
// ET dont la quantité totale de ventes est supérieure à 5
$clients = Client::whereExists(function ($query) {
                $query->select(DB::raw(1))
                      ->from('ventes')
                      ->whereRaw('clients.idclient = ventes.idclient')
                      ->where('idcategorie', 1)
                      ->groupBy('idclient')
                      ->havingRaw('sum(quantite) > 5');
             })
             ->get();
49. Utilisation de where avec une jointure :
//Récupérer les clients ayant effectué une vente avec un produit de la catégorie 1
$clients = Client::join('ventes', 'clients.idclient', '=', 'ventes.idclient')
                 ->join('produits', 'ventes.idproduit', '=', 'produits.idproduit')
                 ->where('idcategorie', 1)
                 ->select('clients.*')
                 ->distinct()
                 ->get();
50. Utilisation de orderBy avec une fonction agrégée :
//Récupérer les catégories triées par le nombre total de produits en stock de manière descendante
$categories = Categorie::withCount('produits')
                      ->orderByDesc('produits_count')
                      ->get();
<