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 Exercices

Soit le Schéma Relationnel 1. Système de Gestion d'Étudiants :

Étudiant(ID_Etudiant, Nom, Prénom, Adresse)
Cours(ID_Cours, NomCours, CodeCours)
Enseignant(ID_Enseignant, Nom, Prénom, Titre)
Inscription(ID_Inscription, ID_Etudiant, ID_Cours, Annee)
Migration pour la table Étudiant (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('ID_Etudiant');
            $table->string('Nom');
            $table->string('Prénom');
            $table->string('Adresse');
            $table->timestamps();
        });
    }

    public function down()
    {
        Schema::dropIfExists('students');
    }
};
Migration pour la table Cours (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('ID_Cours');
            $table->string('NomCours');
            $table->string('CodeCours');
            $table->timestamps();
        });
    }

    public function down()
    {
        Schema::dropIfExists('courses');
    }
};
Migration pour la table Enseignant (create_teachers_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('teachers', function (Blueprint $table) {
            $table->id('ID_Enseignant');
            $table->string('Nom');
            $table->string('Prénom');
            $table->string('Titre');
            $table->timestamps();
        });
    }

    public function down()
    {
        Schema::dropIfExists('teachers');
    }
};
Migration pour la table Inscription (create_inscriptions_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('inscriptions', function (Blueprint $table) {
            $table->id('ID_Inscription');
            $table->unsignedBigInteger('ID_Etudiant');
            $table->unsignedBigInteger('ID_Cours');
            $table->string('Annee');
            $table->timestamps();

            $table->foreign('ID_Etudiant')->references('ID_Etudiant')->on('students');
            $table->foreign('ID_Cours')->references('ID_Cours')->on('courses');
        });
    }

    public function down()
    {
        Schema::dropIfExists('inscriptions');
    }
};
Modèle pour la table Étudiant (Student.php) :
use Illuminate\Database\Eloquent\Model;

class Student extends Model
{
    protected $table = 'students';
    protected $primaryKey = 'ID_Etudiant';
    protected $fillable = ['Nom', 'Prénom', 'Adresse'];

    public function inscriptions()
    {
        return $this->hasMany(Inscription::class, 'ID_Etudiant',          'ID_Etudiant');
		                             //Inscription (foreign key)       primary key
    }
}
Modèle pour la table Cours (Course.php) :
use Illuminate\Database\Eloquent\Model;

class Course extends Model
{
    protected $table = 'courses';
    protected $primaryKey = 'ID_Cours';
    protected $fillable = ['NomCours', 'CodeCours'];

    public function inscriptions()
    {
        return $this->hasMany(Inscription::class, 'ID_Cours', 'ID_Cours');
    }
}
Modèle pour la table Enseignant (Teacher.php) :
use Illuminate\Database\Eloquent\Model;

class Teacher extends Model
{
    protected $table = 'teachers';
    protected $primaryKey = 'ID_Enseignant';
    protected $fillable = ['Nom', 'Prénom', 'Titre'];

    public function inscriptions()
    {
        return $this->hasMany(Inscription::class, 'ID_Enseignant', 'ID_Enseignant');
    }
}
Modèle pour la table Inscription (Inscription.php) :
use Illuminate\Database\Eloquent\Model;

class Inscription extends Model
{
    protected $table = 'inscriptions';
    protected $primaryKey = 'ID_Inscription';
    protected $fillable = ['ID_Etudiant', 'ID_Cours', 'Annee'];

    public function student()
    {
        return $this->belongsTo(Student::class, 'ID_Etudiant', 'ID_Etudiant');
	
    }

    public function course()
    {
        return $this->belongsTo(Course::class, 'ID_Cours', 'ID_Cours');
    }
}

2. Système de Commandes en Ligne :
Client(ID_Client, Nom, Prénom, Adresse)
Produit(ID_Produit, NomProduit, Prix, Stock)
Commande(ID_Commande, ID_Client, DateCommande)
Fournisseur(ID_Fournisseur, Nom, Adresse)
3. Système Hospitalier :
Patient(ID_Patient, Nom, Prénom, DateNaissance, Adresse)
Médecin(ID_Medecin, Nom, Prénom, Spécialité)
Service(ID_Service, NomService, Description)
Prescription(ID_Prescription, ID_Medecin, ID_Patient, Medicament, Posologie)
4. Système de Réservation d'Hôtel :
Client(ID_Client, Nom, Prénom, Adresse)
Chambre(ID_Chambre, NumChambre, TypeChambre, Prix)
Réservation(ID_Reservation, ID_Client, ID_Chambre, DateDebut, DateFin)
Employé(ID_Employe, Nom, Prénom, Poste)
1. Compagnie d'Assurance :
Client(ID_Client, Nom, Prénom, Adresse)
PoliceAssurance(ID_Police, TypePolice, MontantPrime)
Sinistre(ID_Sinistre, DateSinistre, MontantDommage)
AgentAssurance(ID_Agent, Nom, Prénom, Agence)
Relations :
Un client peut souscrire à plusieurs polices d'assurance (relation un-à-plusieurs entre Client et PoliceAssurance).
Un sinistre est associé à une police d'assurance et à un client (relation un-à-un entre Sinistre, PoliceAssurance et Client). Un agent d'assurance gère plusieurs clients et polices (relation un-à-plusieurs entre AgentAssurance, Client et PoliceAssurance).
Créer les migrations et les modèles