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




La relation "BelongsTo" dans Laravel

La relation "BelongsTo" dans Laravel est utilisée pour définir une relation où une table appartient à une autre table. Elle est souvent utilisée pour définir une relation "many-to-one" entre deux tables, où plusieurs enregistrements de la table enfant appartiennent à un seul enregistrement de la table parente. La clé étrangère est généralement stockée dans la table enfant, faisant référence à la clé primaire de la table parente.
Supposons que nous avons deux tables : articles et categories.
Chaque article appartient à une catégorie.

Migration pour la table articles :

// database/migrations/YYYY_MM_DD_create_articles_table.php

use Illuminate\Database\Migrations\Migration;
use Illuminate\Database\Schema\Blueprint;
use Illuminate\Support\Facades\Schema;

return new class extends Migration
{
    public function up()
    {
        Schema::create('articles', function (Blueprint $table) {
            $table->id('idArticle'); // Nommer la clé primaire avec idTable
            $table->string('title');
            $table->text('content');
            $table->unsignedBigInteger('category_id'); // Clé étrangère

            $table->foreign('category_id')->references('idCategory')->on('categories');
            
            $table->timestamps();
        });
    }

    public function down()
    {
        Schema::dropIfExists('articles');
    }
}

Migration pour la table categories :

// database/migrations/YYYY_MM_DD_create_categories_table.php

use Illuminate\Database\Migrations\Migration;
use Illuminate\Database\Schema\Blueprint;
use Illuminate\Support\Facades\Schema;

return new class extends Migration
{
    public function up()
    {
        Schema::create('categories', function (Blueprint $table) {
            $table->id('idCategory'); // Nommer la clé primaire avec idTable
            $table->string('name');
            // Ajoutez d'autres colonnes au besoin

            $table->timestamps();
        });
    }

    public function down()
    {
        Schema::dropIfExists('categories');
    }
}

Modèle pour la table Article :

// app/Models/Article.php

namespace App\Models;

use Illuminate\Database\Eloquent\Model;

class Article extends Model
{
    protected $table = 'articles';
    protected $primaryKey = 'idArticle'; // Nommer la clé primaire avec idTable
    protected $fillable = ['title', 'content', 'category_id'];

    public function category()
    {
        return $this->belongsTo(Category::class, 'category_id', 'idCategory');
		//$table->foreign('category_id')->references('idCategory')->on('categories');

    }
}

Modèle pour la table Category :

// app/Models/Category.php

namespace App\Models;

use Illuminate\Database\Eloquent\Model;

class Category extends Model
{
    protected $table = 'categories';
    protected $primaryKey = 'idCategory'; // Nommer la clé primaire avec idTable
    protected $fillable = ['name'];

    public function articles()
    {
        return $this->hasMany(Article::class, 'category_id', 'idArticle');

    /*
	class Article extends Model
	...
	$table->id('idArticle'); 
     ...
    $table->unsignedBigInteger('category_id'); // Clé étrangère
    $table->foreign('category_id')->references('idCategory')->on('categories');
		*/


    }
}

Exemple 2

une application de gestion de tâches où une tâche appartient à un utilisateur. Nous aurons donc deux tables : tasks et users.

Migration pour la table tasks :

// database/migrations/YYYY_MM_DD_create_tasks_table.php

use Illuminate\Database\Migrations\Migration;
use Illuminate\Database\Schema\Blueprint;
use Illuminate\Support\Facades\Schema;

return new class extends Migration
{
    public function up()
    {
        Schema::create('tasks', function (Blueprint $table) {
            $table->id('idTask'); // Nommer la clé primaire avec idTable
            $table->string('title');
            $table->text('description');
            $table->unsignedBigInteger('user_id'); // Clé étrangère

            $table->foreign('user_id')->references('idUser')->on('users');
            
            $table->timestamps();
        });
    }

    public function down()
    {
        Schema::dropIfExists('tasks');
    }
}

Migration pour la table users :

// database/migrations/YYYY_MM_DD_create_users_table.php

use Illuminate\Database\Migrations\Migration;
use Illuminate\Database\Schema\Blueprint;
use Illuminate\Support\Facades\Schema;

return new class extends Migration
{
    public function up()
    {
        Schema::create('users', function (Blueprint $table) {
            $table->id('idUser'); // Nommer la clé primaire avec idTable
            $table->string('name');
            $table->string('email')->unique();
            $table->string('password');
            
            $table->timestamps();
        });
    }

    public function down()
    {
        Schema::dropIfExists('users');
    }
}

Modèle pour la table Task :

// app/Models/Task.php

namespace App\Models;

use Illuminate\Database\Eloquent\Model;

class Task extends Model
{
    protected $table = 'tasks';
    protected $primaryKey = 'idTask'; // Nommer la clé primaire avec idTable
    protected $fillable = ['title', 'description', 'user_id'];

    public function user()
    {
        return $this->belongsTo(User::class, 'user_id', 'idUser');
    }
}

Modèle pour la table User :

// app/Models/User.php

namespace App\Models;

use Illuminate\Database\Eloquent\Model;

class User extends Model
{
    protected $table = 'users';
    protected $primaryKey = 'idUser'; // Nommer la clé primaire avec idTable
    protected $fillable = ['name', 'email', 'password'];

    public function tasks()
    {
        return $this->hasMany(Task::class, 'user_id', 'idTask');
    }
}
Dans cet exemple, une tâche (Task) appartient à un utilisateur (User). La clé étrangère user_id dans la table des tâches fait référence à la clé primaire idUser dans la table des utilisateurs. Les méthodes user() dans le modèle Task et tasks() dans le modèle User définissent la relation "BelongsTo" et "HasMany", respectivement. Vous pouvez ensuite accéder à l'utilisateur associé à une tâche ou aux tâches associées à un utilisateur de la même manière que dans l'exemple précédent.
un blog, où un commentaire appartient à un article. Les deux tables associées seront comments et articles.

Migration pour la table comments :

// database/migrations/YYYY_MM_DD_create_comments_table.php

use Illuminate\Database\Migrations\Migration;
use Illuminate\Database\Schema\Blueprint;
use Illuminate\Support\Facades\Schema;

return new class extends Migration
{
    public function up()
    {
        Schema::create('comments', function (Blueprint $table) {
            $table->id('idComment'); // Nommer la clé primaire avec idTable
            $table->text('content');
            $table->unsignedBigInteger('article_id'); // Clé étrangère

            $table->foreign('article_id')->references('idArticle')->on('articles');
            
            $table->timestamps();
        });
    }

    public function down()
    {
        Schema::dropIfExists('comments');
    }
}

Migration pour la table articles :

// database/migrations/YYYY_MM_DD_create_articles_table.php

use Illuminate\Database\Migrations\Migration;
use Illuminate\Database\Schema\Blueprint;
use Illuminate\Support\Facades\Schema;

return new class extends Migration
{
    public function up()
    {
        Schema::create('articles', function (Blueprint $table) {
            $table->id('idArticle'); // Nommer la clé primaire avec idTable
            $table->string('title');
            $table->text('content');
            
            $table->timestamps();
        });
    }

    public function down()
    {
        Schema::dropIfExists('articles');
    }
}

Modèle pour la table Comment :

// app/Models/Comment.php

namespace App\Models;

use Illuminate\Database\Eloquent\Model;

class Comment extends Model
{
    protected $table = 'comments';
    protected $primaryKey = 'idComment'; // Nommer la clé primaire avec idTable
    protected $fillable = ['content', 'article_id'];

    public function article()
    {
        return $this->belongsTo(Article::class, 'article_id', 'idArticle');
    }
}
Modèle pour la table Article :
// app/Models/Article.php

namespace App\Models;

use Illuminate\Database\Eloquent\Model;

class Article extends Model
{
    protected $table = 'articles';
    protected $primaryKey = 'idArticle'; // Nommer la clé primaire avec idTable
    protected $fillable = ['title', 'content'];

    public function comments()
    {
        return $this->hasMany(Comment::class, 'article_id', 'idComment');
    }
}
Dans cet exemple, un commentaire (Comment) appartient à un article (Article). La clé étrangère article_id dans la table des commentaires fait référence à la clé primaire idArticle dans la table des articles. Les méthodes article() dans le modèle Comment et comments() dans le modèle Article définissent la relation "BelongsTo" et "HasMany", respectivement. Vous pouvez ensuite accéder à l'article associé à un commentaire ou aux commentaires associés à un article de la même manière que dans les exemples précédents.
Exemple 3
une application de commerce électronique, où une commande appartient à un utilisateur. Les deux tables associées seront orders et users.
Migration pour la table orders :
// database/migrations/YYYY_MM_DD_create_orders_table.php

use Illuminate\Database\Migrations\Migration;
use Illuminate\Database\Schema\Blueprint;
use Illuminate\Support\Facades\Schema;

class CreateOrdersTable extends Migration
{
    public function up()
    {
        Schema::create('orders', function (Blueprint $table) {
            $table->id('idOrder'); // Nommer la clé primaire avec idTable
            $table->decimal('total_amount', 10, 2);
            $table->unsignedBigInteger('user_id'); // Clé étrangère

            $table->foreign('user_id')->references('id')->on('users');
            
            $table->timestamps();
        });
    }

    public function down()
    {
        Schema::dropIfExists('orders');
    }
}
Migration pour la table users :
// database/migrations/YYYY_MM_DD_create_users_table.php

use Illuminate\Database\Migrations\Migration;
use Illuminate\Database\Schema\Blueprint;
use Illuminate\Support\Facades\Schema;

return new class extends Migration
{
    public function up()
    {
        Schema::create('users', function (Blueprint $table) {
            $table->id('id'); // Nommer la clé primaire avec idTable
            $table->string('name');
            $table->string('email')->unique();
            $table->string('password');
            
            $table->timestamps();
        });
    }

    public function down()
    {
        Schema::dropIfExists('users');
    }
}
Modèle pour la table Order :
// app/Models/Order.php

namespace App\Models;

use Illuminate\Database\Eloquent\Model;

class Order extends Model
{
    protected $table = 'orders';
    protected $primaryKey = 'idOrder'; // Nommer la clé primaire avec idTable
    protected $fillable = ['total_amount', 'user_id'];

    public function user()
    {
        return $this->belongsTo(User::class, 'user_id', 'id');
    }
}
Modèle pour la table User :
// app/Models/User.php

namespace App\Models;

use Illuminate\Database\Eloquent\Model;

class User extends Model
{
    protected $table = 'users';
    protected $primaryKey = 'id'; // Nommer la clé primaire avec idTable
    protected $fillable = ['name', 'email', 'password'];

    public function orders()
    {
        return $this->hasMany(Order::class, 'user_id', 'idOrder');
    }
}
Dans cet exemple, une commande (Order) appartient à un utilisateur (User). La clé étrangère user_id dans la table des commandes fait référence à la clé primaire id dans la table des utilisateurs. Les méthodes user() dans le modèle Order et orders() dans le modèle User définissent la relation "BelongsTo" et "HasMany", respectivement
Exemple 4
un blog avec un modèle plus avancé, où un commentaire peut appartenir à un utilisateur et à un article en même temps. Les tables associées seront comments, users, et articles.
Migration pour la table comments :
// database/migrations/YYYY_MM_DD_create_comments_table.php

use Illuminate\Database\Migrations\Migration;
use Illuminate\Database\Schema\Blueprint;
use Illuminate\Support\Facades\Schema;

return new class extends Migration
{
    public function up()
    {
        Schema::create('comments', function (Blueprint $table) {
            $table->id('idComment'); // Nommer la clé primaire avec idTable
            $table->text('content');
            $table->unsignedBigInteger('user_id'); // Clé étrangère vers la table des utilisateurs
            $table->unsignedBigInteger('article_id'); // Clé étrangère vers la table des articles

            $table->foreign('user_id')->references('id')->on('users');
            $table->foreign('article_id')->references('idArticle')->on('articles');
            
            $table->timestamps();
        });
    }

    public function down()
    {
        Schema::dropIfExists('comments');
    }
}
Migration pour la table users :
// database/migrations/YYYY_MM_DD_create_users_table.php

use Illuminate\Database\Migrations\Migration;
use Illuminate\Database\Schema\Blueprint;
use Illuminate\Support\Facades\Schema;

return new class extends Migration
{
    public function up()
    {
        Schema::create('users', function (Blueprint $table) {
            $table->id('id'); // Nommer la clé primaire avec idTable
            $table->string('name');
            $table->string('email')->unique();
            $table->string('password');
            
            $table->timestamps();
        });
    }

    public function down()
    {
        Schema::dropIfExists('users');
    }
}
Migration pour la table articles :
// database/migrations/YYYY_MM_DD_create_articles_table.php

use Illuminate\Database\Migrations\Migration;
use Illuminate\Database\Schema\Blueprint;
use Illuminate\Support\Facades\Schema;

return new class extends Migration
{
    public function up()
    {
        Schema::create('articles', function (Blueprint $table) {
            $table->id('idArticle'); // Nommer la clé primaire avec idTable
            $table->string('title');
            $table->text('content');
            
            $table->timestamps();
        });
    }

    public function down()
    {
        Schema::dropIfExists('articles');
    }
}
Modèle pour la table Comment :
// app/Models/Comment.php

namespace App\Models;

use Illuminate\Database\Eloquent\Model;

class Comment extends Model
{
    protected $table = 'comments';
    protected $primaryKey = 'idComment'; // Nommer la clé primaire avec idTable
    protected $fillable = ['content', 'user_id', 'article_id'];

    public function user()
    {
        return $this->belongsTo(User::class, 'user_id', 'id');
    }

    public function article()
    {
        return $this->belongsTo(Article::class, 'article_id', 'idArticle');
    }
}
Modèle pour la table User :
// app/Models/User.php

namespace App\Models;

use Illuminate\Database\Eloquent\Model;

class User extends Model
{
    protected $table = 'users';
    protected $primaryKey = 'id'; // Nommer la clé primaire avec idTable
    protected $fillable = ['name', 'email', 'password'];

    public function comments()
    {
        return $this->hasMany(Comment::class, 'user_id', 'idComment');
    }
}
Modèle pour la table Article :
// app/Models/Article.php

namespace App\Models;

use Illuminate\Database\Eloquent\Model;

class Article extends Model
{
    protected $table = 'articles';
    protected $primaryKey = 'idArticle'; // Nommer la clé primaire avec idTable
    protected $fillable = ['title', 'content'];

    public function comments()
    {
        return $this->hasMany(Comment::class, 'article_id', 'idComment');
    }
}
Dans cet exemple, un commentaire (Comment) peut appartenir à un utilisateur (User) et à un article (Article) simultanément. La table comments contient deux clés étrangères, user_id faisant référence à la clé primaire id dans la table des utilisateurs, et article_id faisant référence à la clé primaire idArticle dans la table des articles. Les méthodes user() et article() dans le modèle Comment définissent les relations "BelongsTo" avec les modèles User et Article respectivement.