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




Laravel:Relations OneToMany,ManyToMany,OneToOne....

1. Relation "Un à Un" (One to One) - User et Profile

php artisan make:migration create_Utilisateurs_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('Utilisateurs', function (Blueprint $table) {
            $table->id();//id int primary key
            $table->string('name');
            $table->string('email')->unique();
            $table->string('password');
            $table->timestamps();
        });
    }

    public function down()
    {
        Schema::dropIfExists('Utilisateurs');
    }
};
php artisan make:model Models\Utilisateur
<?php

namespace App\Models;

use Illuminate\Database\Eloquent\Model;

class Utilisateur extends Model
{
    protected $table = 'Utilisateurs';
    protected $primaryKey = 'id';
    public $timestamps = true;

    protected $fillable = [
        'name', 'email', 'password'
    ];

    // Relation Un à Un : Un utilisateur a un seul profil
    public function profile()
    {
        return $this->hasOne('App\Models\Profile'); 
		//lorsque le model profile a primaryKey=id ,on n'as pas besoin de spécifier idProfile dans la relation has.. ,belongsTo...
    }
}
php artisan make:migration create_profiles_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('profiles', function (Blueprint $table) {
            $table->id();
            $table->foreignId('Utilisateur_id')->constrained();//permet de créer la foreign key Utilisateur_id qui references Utlisateur(id)
			//constraint foreign key('Utilisateur_id') references Utilisateur(id)
			//lorsque Utilisateur a primarykey=id  ,pour déclarer une foreign key  on appell Model_id dans ce cas Utilisateur_id
            $table->text('bio')->nullable();
            $table->string('avatar')->nullable();
            $table->timestamps();
        });
    }

    public function down()
    {
        Schema::dropIfExists('profiles');
    }
};
php artisan make:model Models\Profile
<?php

namespace App\Models;

use Illuminate\Database\Eloquent\Model;

class Profile extends Model
{
    protected $table = 'profiles';
    protected $primaryKey = 'id';
    public $timestamps = true;

    protected $fillable = [
        'Utilisateur_id', 'bio', 'avatar'
    ];

    // Relation Un à Un inverse : Un profil appartient à un utilisateur
    public function Utilisateur()
    {
        return $this->belongsTo('App\Models\Utilisateur');
    }
}

2. Relation "Un à Plusieurs" (One to Many) - Author et Book

php artisan make:migration create_authors_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('authors', function (Blueprint $table) {
            $table->id();
            $table->string('name');
            $table->string('email')->unique();
            $table->timestamps();
        });
    }

    public function down()
    {
        Schema::dropIfExists('authors');
    }
};
php artisan make:model Models\Author
<?php

namespace App\Models;

use Illuminate\Database\Eloquent\Model;

class Author extends Model
{
    protected $table = 'authors';
    protected $primaryKey = 'id';
    public $timestamps = true;

    protected $fillable = [
        'name', 'email'
    ];

    // Relation Un à Plusieurs : Un auteur peut avoir plusieurs livres
    public function books()
    {
        return $this->hasMany('App\Models\Book');
    }
}
php artisan make:migration create_books_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('books', function (Blueprint $table) {
            $table->id();
            $table->foreignId('author_id')->constrained();
            $table->string('title');
            $table->text('description');
            $table->timestamps();
        });
    }

    public function down()
    {
        Schema::dropIfExists('books');
    }
};
php artisan make:model Models\Book
<?php

namespace App\Models;

use Illuminate\Database\Eloquent\Model;

class Book extends Model
{
    protected $table = 'books';
    protected $primaryKey = 'id';
    public $timestamps = true;

    protected $fillable = [
        'author_id', 'title', 'description'
    ];

    // Relation Un à Plusieurs inverse : Un livre appartient à un auteur
    public function author()
    {
        return $this->belongsTo('App\Models\Author');
    }
}

3. Relation "Plusieurs à Plusieurs" (Many to Many) - Student et Course

php artisan make:migration create_students_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('students', function (Blueprint $table) {
            $table->id();
            $table->string('name');
            $table->string('email')->unique();
            $table->timestamps();
        });
    }

    public function down()
    {
        Schema::dropIfExists('students');
    }
};
php artisan make:model Models\Student
<?php

namespace App\Models;

use Illuminate\Database\Eloquent\Model;

class Student extends Model
{
    protected $table = 'students';
    protected $primaryKey = 'id';
    public $timestamps = true;

    protected $fillable = [
        'name', 'email'
    ];

    // Relation Plusieurs à Plusieurs : Un étudiant peut être inscrit à plusieurs cours
    public function courses()
    {
        return $this->belongsToMany('App\Models\Course');
    }
}
php artisan make:migration create_courses_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('courses', function (Blueprint $table) {
            $table->id();
            $table->string('title');
            $table->text('description');
            $table->timestamps();
        });
    }

    public function down()
    {
        Schema::dropIfExists('courses');
    }
};
php artisan make:model Models\Course
<?php

namespace App\Models;

use Illuminate\Database\Eloquent\Model;

class Course extends Model
{
    protected $table = 'courses';
    protected $primaryKey = 'id';
    public $timestamps = true;

    protected $fillable = [
        'title', 'description'
    ];

    // Relation Plusieurs à Plusieurs inverse : Un cours peut avoir plusieurs étudiants
    public function students()
    {
        return $this->belongsToMany('App\Models\Student');
    }
}

4. Relation Polymorphe - Comment et Post

php artisan make:migration 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();//id int primary key
            $table->text('content');
            $table->unsignedBigInteger('commentable_id');
            $table->string('commentable_type');
            $table->timestamps();
        });
    }

    public function down()
    {
        Schema::dropIfExists('comments');
    }
}
php artisan make:model Models\Comment
<?php

namespace App\Models;

use Illuminate\Database\Eloquent\Model;

class Comment extends Model
{
    protected $table = 'comments';
    protected $primaryKey = 'id';
    public $timestamps = true;

    protected $fillable = [
        'content', 'commentable_id', 'commentable_type'
    ];

    // Relation Polymorphe : Un commentaire peut appartenir à un post ou à une vidéo
    public function commentable()
    {
        return $this->morphTo();
    }
};
php artisan make:migration create_posts_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('posts', function (Blueprint $table) {
            $table->id();
            $table->string('title');
            $table->text('content');
            $table->timestamps();
        });
    }

    public function down()
    {
        Schema::dropIfExists('posts');
    }
};
php artisan make:model Models\Post
<?php

namespace App\Models;

use Illuminate\Database\Eloquent\Model;

class Post extends Model
{
    protected $table = 'posts';
    protected $primaryKey = 'id';
    public $timestamps = true;

    protected $fillable = [
        'title', 'content'
    ];

    // Relation Polymorphe inverse : Un post peut avoir plusieurs commentaires
    public function comments()
    {
        return $this->morphMany('App\Models\Comment', 'commentable');
    }
}

la Relation Polymorphe - Video

php artisan make:migration create_videos_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('videos', function (Blueprint $table) {
            $table->id();
            $table->string('title');
            $table->text('description');
            $table->timestamps();
        });
    }

    public function down()
    {
        Schema::dropIfExists('videos');
    }
};
php artisan make:model Models\Video
<?php

namespace App\Models;

use Illuminate\Database\Eloquent\Model;

class Video extends Model
{
    protected $table = 'videos';
    protected $primaryKey = 'id';
    public $timestamps = true;

    protected $fillable = [
        'title', 'description'
    ];

    // Relation Polymorphe inverse : Une vidéo peut avoir plusieurs commentaires
    public function comments()
    {
        return $this->morphMany('App\Models\Comment', 'commentable');
    }
}

Utilisation des Relations

<?
// Création d'un utilisateur
$Utilisateur = Utilisateur::create([
    'name' => 'John Doe',
    'email' => 'john@example.com',
    'password' => bcrypt('secret'),
]);

// Création d'un profil pour l'utilisateur
$profile = $Utilisateur->profile()->create([
    'bio' => 'A passionate Laravel developer.',
    'avatar' => 'avatar.jpg',
]);
Exemple d'Utilisation de la Relation Un à Plusieurs
php
Copy code
// Création d'un auteur
$author = Author::create([
    'name' => 'Jane Author',
    'email' => 'jane@example.com',
]);

// Ajout de plusieurs livres pour l'auteur
$book1 = $author->books()->create([
    'title' => 'Book 1',
    'description' => 'Description for Book 1',
]);

$book2 = $author->books()->create([
    'title' => 'Book 2',
    'description' => 'Description for Book 2',
]);
Exemple d'Utilisation de la Relation Plusieurs à Plusieurs
php
Copy code
// Création d'un étudiant
$student = Student::create([
    'name' => 'Alice Student',
    'email' => 'alice@example.com',
]);

// Inscrit l'étudiant à plusieurs cours
$course1 = Course::create([
    'title' => 'Course 1',
    'description' => 'Description for Course 1',
]);

$course2 = Course::create([
    'title' => 'Course 2',
    'description' => 'Description for Course 2',
]);

$student->courses()->attach([$course1->id, $course2->id]);
Exemple d'Utilisation de la Relation Polymorphe
php
Copy code
// Création d'un post
$post = Post::create([
    'title' => 'My First Post',
    'content' => 'This is the content of my first post.',
]);

// Ajout de commentaires au post
$comment1 = $post->comments()->create([
    'content' => 'Great post!',
]);

$comment2 = $post->comments()->create([
    'content' => 'I enjoyed reading this.',
]);

// Création d'une vidéo
$video = Video::create([
    'title' => 'Laravel Tutorial',
    'description' => 'A tutorial on Laravel basics.',
]);

// Ajout de commentaires à la vidéo
$comment3 = $video->comments()->create([
    'content' => 'Very helpful tutorial.',
]);

$comment4 = $video->comments()->create([
    'content' => 'Thanks for sharing!',
]);