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:Migration ,Models,Relations

Soit le schéma de la base de données relationelle suivante:
clients(idclient ,nom,prenom) 
categories(idcategorie,nom,description)  
produits(idproduit,#idcategorie,nom ,prix,quantiteStock,marque)  
vente(idvente,#idclient,#idproduit,quantite,datevente)

Créer les migrations

create_clients_table.php

php artisan make:migration create_clients_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('clients', function (Blueprint $table) {
            $table->id('idclient');
            $table->string('nom');
            $table->string('prenom');
            $table->timestamps();
        });
    }

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

create_categories_table.php

php artisan make:migration 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('idcategorie');
            $table->string('nom');
			//description text null
            $table->text('description')->nullable();
            $table->timestamps();
        });
    }

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

create_produits_table.php

php artisan make:migration create_produits_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(): void
    {
		//create table produits
        Schema::create('produits', function (Blueprint $table) {
			//idproduit int primary key
            $table->id('idproduit');
			//idcategorie int 
            $table->bigInteger('idcategorie')->unsigned(); //idcategorie int
            $table->foreign('idcategorie')->references('idcategorie')->on('categories');
            //alter table add foreign key(idcategorie) references categories(idcategorie)
			//nom varchar(25)
            $table->string('nom');
			//prix decimal(8,2)
            $table->decimal('prix', 8, 2);
            $table->integer('quantiteStock');
			//marque varchar(25) null
            $table->string('marque')->nullable();
            $table->timestamps();
        });
    }
    public function down()
    {
        Schema::dropIfExists('produits');
    }
};

create_ventes_table.php

php artisan make:migration create_ventes_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(): void
    {
        Schema::create('ventes', function (Blueprint $table) {
			//idvente int primary key
            $table->id('idvente');
			//idclient int
            $table->bigInteger("idclient")->unsigned();
			//idproduit int
            $table->bigInteger("idproduit")->unsigned();
			//constraint foreign key(idclient) references client(idclient)
            $table->foreign('idclient')->references('idclient')->on('clients'); //#idcient
			//constraint foreign key(idproduit) references produit(idproduit)
            $table->foreign('idproduit')->references('idproduit')->on('produits');//#idproduit
            $table->integer('quantite');
            $table->date('datevente');
            $table->timestamps();
        });
    }


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

Lancer la Migrations

php artisan migrate

Créer les Modèles

app/Models/Client.php

php artisan make:model Client
<?php

namespace App\Models;

use Illuminate\Database\Eloquent\Model;

class Client extends Model
{
    // Nom de la table dans la base de données
    protected $table = 'clients';

    // Clé primaire de la table
    protected $primaryKey = 'idclient';

    // Indique si les horodatages sont utilisés (created_at et updated_at)
    public $timestamps = true;

    // Les attributs qui peuvent être remplis de manière massive
    protected $fillable = [
        'nom', 'prenom'
    ];

    // Relation : Un client peut avoir plusieurs ventes
    public function ventes()
    {
        return $this->hasMany('App\Models\Vente', 'idclient'); 
//l'attribut idclient se trouve dans le Model Vente comme un foreign key pour $primaryKey = 'idclient' dans le Model Client
    }
}

app/Models/Categorie.php

php artisan make:model Categorie
<?php

namespace App\Models;

use Illuminate\Database\Eloquent\Model;

class Categorie extends Model
{
    protected $table = 'categories';
    protected $primaryKey = 'idcategorie';
    public $timestamps = true;

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

    // Relation : Une catégorie peut avoir plusieurs produits
    public function produits()
    {
        return $this->hasMany('App\Models\Produit', 'idcategorie');
//Model produit contient l'attribut  'idcategorie' (foreign key) qui $primaryKey = 'idcategorie' dans le Model Categorie
    }
}

app/Models/Produit.php

php artisan make:model Produit
<?php

namespace App\Models;

use Illuminate\Database\Eloquent\Model;

class Produit extends Model
{
    protected $table = 'produits';
    protected $primaryKey = 'idproduit';
    public $timestamps = true;

    protected $fillable = [
        'idcategorie', 'nom', 'prix', 'quantiteStock', 'marque'
    ];

    // Relation : Un produit appartient à une catégorie
    public function categorie()
    {
        return $this->belongsTo('App\Models\Categorie', 'idcategorie'); 
//'attribut idcategorie  dans  $fillable est un foreign key du Model Categorie
    }

    // Relation : Un produit peut avoir plusieurs ventes
    public function ventes()
    {
        return $this->hasMany('App\Models\Vente', 'idproduit');
// l'attribut $primaryKey = 'idproduit' se trouve comme un foreign key dans le Model Vente
    }
}

app/Models/Vente.php

php artisan make:model Vente
<?php

namespace App\Models;

use Illuminate\Database\Eloquent\Model;

class Vente extends Model
{
    protected $table = 'ventes';
    protected $primaryKey = 'idvente';
    public $timestamps = true;

    protected $fillable = [
        'idclient', 'idproduit', 'quantite', 'datevente'
    ];

    // Relation : Une vente appartient à un client
    public function client()
    {
        return $this->belongsTo('App\Models\Client', 'idclient');
//l'attribut idclient dans $fillable représente un foreign key du Model Client
    }

    // Relation : Une vente concerne un produit
    public function produit()
    {
        return $this->belongsTo('App\Models\Produit', 'idproduit'); 
//l'attribut idproduit dans $fillable représente un foreign key du Model Produit
    }
}