Ce document contient :

- les connaissances minimums pour réaliser un site avec Laravel

-Résumé des fonctionnalités Laravel qui peuvent vous être utiles

• Model: La base de données (ORM: Éloquent).

• Vue: Gestion du HTML (Moteur de Template : Blade).
• Controller: Gestion des requêtes et génère le contenu.

C’est du MVC avec un ORM (Object–Relational Mapping) pour accéder aux

objets.

L’idée d’un ORM, c’est de remplacer l’écriture des requêtes SQL par
de la manipulation d’objet.

#Créer un projet
Il ya plusieurs façons de créer un projet. Je vous conseille de passer
par « Composer » qui fonctionnera, quelle que soit la plateforme.

composer create-project laravel/laravel le-nom-de-votre-projet

#Les projets
// Nouveau projet
composer create-project laravel/laravel projectName

// Lancement du serveur/projet
php artisan serve

// Liste de commandes
php artisan list
// Aide sur les commandes
php artisan help migrate
// console Laravel
php artisan tinker

// Liste des routes

php artisan route:list

#Réinstaller un projet
Si vous changez de machine ou si vous récupérez le code source depuis
Git il sera nécessaire de réinstaller les dépendances. Pour ça :

1. composer install
2. npm install
3. php artisan key :generate
4. configurer base de données .env
5. php artisan migrate
6. php artisan db :seed
7. php artisan serv

#Lancer votre site

Pour visualiser votre site, Laravel intègre une commande permettant
de lancer « un serveur web » intégré le temps du développement. Il
suffit de :

php artisan serve

Ou depuis n'importe où sur le réseau :

php artisan serve --host=0.0.0.0

Host ?

0.0.0.0 est l'adresse IP de la machine locale. Cela signifie que le

serveur sera accessible depuis n'importe quelle adresse IP de la
machine locale.
#Les routes
L’ensemble des routes sont dans 3 fichiers :

• routes/web.php: Gestion des urls pour les clients (web)

• routes/api.php: Gestion des urls pour les échanges « technique» API.
• routes/console.php: Gestion des commandes pour la console Laravel.

#Définir une route simple

Dans le fichier web.php il suffira par exemple de :

Route::get('/', function () { return "Bonjour Monde"; } );

Nous déclarons ici une route, accessible sur le / (c’est-à-

dire http://localhost:8000/), elle affichera Bonjour Monde.

// Fermeture de la route de base

Route::get('/greeting', function () {
return 'Hello World';
});

// Raccourci de la vue directe de la route

Route::view('/welcome', 'welcome');

// Route vers la classe du contrôleur

utiliser App\Http\Controllers\UserController;
Route::get('/user', [UserController::class, 'index']);

// Route uniquement pour des verbes HTTP spécifiques

Route::match(['get', 'post'], '/', function () {
//
});

// Route pour tous les verbes (GET, POST, PUT, DELETE, ...)
Route::any('/', function () {
//
});

// Route Redirect
Route::redirect('/clients', '/customers');

// Paramètres de la route
Route::get('/user/{id}', function ($id) {
return 'Utilisateur '.$id;
});
// Paramètre optionnel
Route::get('/user/{name?}', function ($name = 'John') {
return $name;
});
// Route nommée
Route::get(
'/utilisateur/profil',
[UserProfileController::class, 'show']
)->name('profile');

// Ressource
Route::resource('photos', PhotoController::class);

GET /photos index photos.index

GET /photos/create create photos.create
POST /photos store photos.store
GET /photos/{photo} show photos.show
GET /photos/{photo}/edit edit photos.edit
PUT/PATCH /photos/{photo} mettre à jour les photos.update
DELETE /photos/{photo} destroy photos.destroy

// Ressource partielle
Route::resource('photos', PhotoController::class)->only(['index',
'show']);

Route::resource('photos', PhotoController::class)->except(['create',
'save', 'update', 'destroy']);

// Génération de redirections...
return redirect()->route('profile');

// Groupe de préfixes de route

Route::prefix('admin')->group(function () {
Route::get('/users', function () {
// Correspond à l'URL "/admin/users".
});
});

// Liaison du modèle de route

utiliser App\Models\User;
Route::get('/users/{user}', function (User $user) {
return $user->email;
});

// Liaison du modèle de route (autre que l'identifiant)

utiliser App\Models\User;
Route::get('/posts/{post:slug}', function (Post $post) {
return view('post', ['post' => $post]);
});

// Route fallback
Route::fallback(function () {
//
});
#Les contrôleurs
Le contrôleur va contenir la logique « métier » pour traiter les
demandes des clients.

php artisan make:controller DemoController

Cette action va créer le squelette d’un contrôleur à l’emplacement

suivant app/Http/Controllers/DemoController.php. Le contenu est
minimaliste :

Use namespace App\Http\Controllers;

use Illuminate\Http\Request;

class DemoController extends Controller

{
public function voir($id): string
{
// Pour l’instant pas de vue, nous verrons ça plus tard.
return "Vous avez demandé l’id : " . $id;
}
}

Il suffit donc de créer une méthode, les paramètres seront

automatiquement remplis lors de l’appel du client $id contiendra la
valeur présente à la place de {id}.

Exemple d’utilisation des controleurs

// Définir les règles de validation
protected $rules = [
title' => 'required|unique:posts|max:255',
name' => 'required|min:6',
'email' => 'required|email',
'publish_at' => 'nullable|date',
];

// Valider
$validatedData = $request->validate($rules)

// Affiche la page d'erreur 404

abort(404, 'Sorry, Post not found')
// Exemple de contrôleur CRUD
Classe ProductsController
{

public function index()

{
$produits = Product::all();

// app/resources/views/produits/index.blade.php
return view('products.index', ['products', $products]);
}

public function create()

{
return view('produits.create');
}

public function store()

{
Product::create(request()->validate([
name' => 'required',
price' => 'required',
note' => 'nullable
]));

return redirect(route('products.index'));
}

//méthode avec injection de modèle

public function show(Produit $produit)
{
return view('produits.show', ['produit', $produit]);
}

public function edit(Product $product)

{
return view('produits.edit', ['produit', $produit]);
}

public function update(Product $product)

{
Product::update(request()->validate([
name' => 'required',
price' => 'required',
note' => 'nullable
]));

return redirect(route($product->path()));
}
 public function delete(Product $product)
{
$produit->supprimer();
return redirect("/contacts");
}
}

// Paramètres de requête www.demo.html?name=mike

request()->nom //mike

// Données du formulaire (ou valeur par défaut)

request()->input('email', 'no@email.com')

#Éloquent « l’ORM »
#La migration________________________________________
Une migration c’est ce qui va nous permettre d’initialiser la base de
données directement depuis Laravel. Bien que cette partie est
optionnelle je vous conseille vivement de l’utiliser (c’est un
standard en entreprise.)

Une migration, est juste une classe qui va contenir la définition de

votre table, les champs, les types, la structure. Le contenu de base
sera le suivant :

<?php

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

class LeNomDeVotreMigration extends Migration

{
/**
* Run the migrations.
*
* @return void
*/
public function up()
{
Schema::create('leNomDeVotreTableEnBase', function
(Blueprint $table) {
$table->id();
$table->timestamps();
});
}
 /**
* Reverse the migrations.
*
* @return void
*/
public function down()
{
Schema::dropIfExists('leNomDeVotreTableEnBase');
}
}

Par exemple, si vous souhaitez ajouter dans votre table deux champs
(un texte et un booléen), il faudra ajouter dans la méthode up :

$table->string('texte');
$table->boolean('termine');

Lancer la migration, c’est-à-dire appliquer l’ensemble des

modifications en attente en BDD :

php artisan migrate

// Créer une table de données

$ php artisan make:migration create_products_table

// Création d'une table (exemple de migration)

Schema::create('products', function (Blueprint $table) {

// Clé primaire auto-incrémentée
$table->id(); //$table ->id(‘refernce’);
// created_at et updated_at
$table->timestamps();
// Contrainte d'unicité
$table->chaîne('modelNo')->unique();
// Non requis
$table->text('description')->nullable();

// Valeur par défaut

$table->boolean('isActive')->default(true);

// Relation de clé étrangère

$table->foreignId('user_id')->constrained('users')
->onDelete('cascade');
});

// Mise à jour de la table (exemple de migration)

$ php artisan make:migration add_comment_to_products_table

// up()
Schema::table('users', function (Blueprint $table) {
 $table->text('comment');
});

// down()
Schema::table('users', function (Blueprint $table) {
$table->dropColumn('comment');
});

#Le modèle
Le modèle est l’objet qui nous permettra de faire « nos requêtes SQL
», l’accès à nos données.

Laravel intègre une commande pour créer un modèle vide :

php artisan make:model LeNomDeVotreTableEnBase

Cette action va créer un squelette de modèle à l’emplacement suivant

: app/Models/LeNomDeVotreTableEnBase.php. Le contenu sera le minimum :

<?php

namespace App\Models;

use Illuminate\Database\Eloquent\Factories\HasFactory;
use Illuminate\Database\Eloquent\Model;

class LeNomDeVotreTableEnBase extends Model

{
use HasFactory;
}

Remarque :De base le nome de la classe sera le nom de votre table. Si

vous souhaitez changer le comportement, il vous suffit de :

<?php

namespace App\Models;

use Illuminate\Database\Eloquent\Factories\HasFactory;
use Illuminate\Database\Eloquent\Model;

class LeNomDeVotreTableEnBase extends Model

{
protected $table = "NOM_DE_MA_TABLE";

use HasFactory;
}
 # Interagir avec la base de données
// Créer un enregistrement en base de données
$Stagiaire = new Stagiaire;
$Stagiaire->name = $request->name;
$Stagiaire->save();

// Mettre à jour un enregistrement en base de données

$Stagiaire = Stagiaire::find(1);
$Stagiaire->name = 'New stagiaire Name';
$Stagiaire->save();

// Créer un enregistrement en base de données à partir d'un tableau

(mass assignment). Le tableau peut être rempli avec des données de
formulaire
$user = User::create(['nom' => 'Taylor',prenom => 'Otwell']);
// ou $user = User::create($request->all());

// Mettre à jour un enregistrement en base de données à partir d'un

tableau (mass assignment). Le tableau peut être rempli avec des
données de formulaire
Stagiaire::where('active', 1)->update(['delayed' => 1]);

// Supprimer un enregistrement en base de données

$current_user = User::Find(1); // On récupère l'utilisateur
$current_user->delete(); // On le supprime

// Supprimer un enregistrement en base de données à partir de son id

User::destroy(1);

// Supprimer plusieurs enregistrements en base de données

$deletedRows = Stagiaire::where('active', 0)->delete();

// Obtenir tous les enregistrements d'une table équivaut à SELECT *

FROM table
$items = Item::all().

// Trouver un enregistrement en base de données à partir de son id

(équivaut à SELECT * FROM table WHERE id = $id). La colonne id est
définit dans votre modèle (protected $primaryKey = 'id';)
$Stagiaire = Stagiaire::find(1);

// Obtiens l'enregistrement avec l'id 1 ou lève une exception

$model = Stagiaire::findOrFail(1);

// Obtient le dernier enregistrement de la table

$items = Item::latest()->get()
// Réaliser une requête personnalisée. Trouve tous les enregistrements
actifs et les trie par nom dans l'ordre décroissant. Limite le nombre
de résultats à 10
$Stagiaires = App\Stagiaire::where('active', 1)->orderBy('name',
'desc')->take(10)->get();

// Cherche un enregistrement en base de données à partir de son id.

Si l'enregistrement n'existe pas la requête renvoi une exception
Todo::where('id', $id)->firstOrFail()

// Réaliser un where de type LIKE

Todos::where('name', 'like', '%' . $my . '%')->get()

// Réalise une requête avec plusieurs conditions de type OR

Todos::where('name', 'mike')->orWhere('title', '=', 'Admin')->get();

// Réalise une requête avec plusieurs conditions de type AND

Todos::where('name', 'mike')->where('title', '=', 'Admin')->get();

// Compter le nombre d'enregistrements

$count = Stagiaire::where('active', 1)->count();

// Somme des valeurs de la colonne price

$sum = Stagiaire::where('active', 1)->sum('price');

// Est-ce que l'enregistrement existe en base de données ?

if ($project->$users->contains('mike')) {}

// Choisir les colonnes à récupérer

$users = User::select('name', 'email as user_email')->get();

// Choisir les colonnes à récupérer avec une condition

$users = User::select('name', 'email as user_email')->where('name',
'John')->get();

L'ORM (Relations)
Les jointures sont à définir directement dans le modèle. Elles seront
des méthodes accessibles via l’objet de votre modèle.

#One To One
class Todo extends Model {
// Dans le modèle
public function categorie()
{
return $this->hasOne(Categorie::class);
}
}
#One To Many
class Post extends Model {
// Dans le modèle
public function comments()
{
return $this->hasMany(Comment::class);
}

#L’inverse du One To Many : le « Belong To »

class Comment extends Model
{
public function post()
{
return $this->belongsTo(Post::class);
}
}

Interagir avec les données de L'ORM (Relations)

// Obtenir les commentaires d'un article
$commentairesArticle = App\Models\Article::find($id)->comments()->get();

// Obtenir les articles d'un utilisateur

$articlesUtilisateur = App\Models\User::find($id)->articles()->get();

// Obtenir les Utilisateurs avec leurs articles

$users = App\Models\User::with('articles')->get();

// Obtenir les Utilisateurs avec leurs articles et leurs

commentaires
$users = App\Models\User::with('articles.comments')->get();
// Réaliser la jointure à la main entre les tables (en dernier
recours, si vous ne pouvez pas utiliser les relations)
$users = App\Models\User::join('articles', 'users.id', '=',
'articles.user_id')->get();

// Obtenir les articles d'un utilisateur avec une condition

$articlesUtilisateur = App\Models\User::find($id)->articles()-
>where('title', 'like', '%test%')->get();

// Plusieurs with, récupère les articles et les commentaires de

chaque utilisateur
$users = App\Models\User::with('articles', 'comments')->get();

Rappel : Les relations sont définies dans le modèle (belongsTo,

hasMany, ...).
`with()` : Le with() permet de récupérer les données d'une autre
table. Vous pouvez également déclarer le with() dans le modèle.

Exemple, dans le modèle Commande :

$with = ['produit'];

En indiquant le $with dans le modèle, votre jointure sera

automatiquement effectuée. Vous n'aurez plus besoin de passer par
le with() dans le contrôleur. Pratique pour automatiser les jointures.

#Commande de base
// Migration de la base de données
$ php artisan migrate

// Ensemencement des données

$ php artisan db:seed

// Migration de la table de création

$ php artisan make:migration create_products_table

// Créer à partir du modèle avec des options :

// -m (migration), -c (contrôleur), -r (contrôleurs de ressources),
-f (factory), -s (seeder)
$ php artisan make:model Product -mcf

// Créez un contrôleur
$ php artisan make:controller ProductsController

// Mise à jour de la migration des tables

$ php artisan make:migration add_date_to_blogposts_table

// Retour à la dernière migration

php artisan migrate:rollback

// Annule toutes les migrations

php artisan migrate:reset

// Annule tout et refait la migration

php artisan migrate:refresh

// Annuler toutes les migrations, migrer à nouveau et ensemencer

php artisan migrate:refresh --seed

#Remplir une base de données (données fictives)

#Factory

Comment nous allons remplir. (définition)

// ex: database/factories/ProductFactory.php
public function definition() {
return [
'name' => $this->faker->text(20),
'price' => $this->faker->numberBetween(10, 10000),
categorie => $this->faker->randomElement([‘Legumes’,’Fruits’,’Boissons’]),

];
}

#Seeder
Ce que nous allons remplir réellement.

// ex: database/seeders/DatabaseSeeder.php
public function run() {
Product::factory(10)->create();
}

$ php artisan db:seed

// or with migration
$ php artisan migrate --seed

#Blade (les templates, la vue)

<!-- Nom de la route -->
<a href="{{ route('routeName.show', $id) }}">

<!-- Héritage du modèle -->

@yield('content') <!-- layout.blade.php -->
@extends('layout')
@section('content') ... @endsection

<!-- Template include -->

@include('view.name', ['name' => 'John'])

<!-- Modèle de variable -->

{{ var_name }}

<!-- Variable html raw safe -->

{ ! ! var_name ! ! }

<!-- Interation -->

@foreach ($items as $item)
{{ $item.name }}
 @if($loop->last)
$loop->index
@endif
@endforeach

<!-- Conditionnel -->

@if ($post->id === 1)
'Post one'
@elseif ($post->id === 2)
'Publier deux !'
@else
Autre
@endif

<!-- Formulaire -->

<form method="POST" action="{{ route('posts.store') }}">
@csrf

<!-- Correspondance du chemin de la requête -->

{{ request()->is('posts*') ? 'current page' : 'not current page' }}

<!-- Route exist? -->

@if (Route::has('login'))

<!-- Auth blade variable -->

@auth
@endauth
@guest

<!-- Current user -->

{{ Auth::user()->name }}

<!-- Validations errors -->

@if ($errors->any())
<div class="alert alert-danger">
<ul>
@foreach ($errors->all() as $error)
<li>{{ $error }}</li>
@endforeach
</ul>
</div>
@endif

<!-- Check a specific attributes -->

<input id="title" type="text" class="@error('title') is-invalid
@enderror">

<!-- Repopulate form with data from previous request -->

{{ old('name') }}
#La session
// Flash (uniquement pour la prochaine demande)
$request->session()->flash('status', 'Task was successful!');

// Flash avec redirection

return redirect('/home')->with('success' => 'email sent!');

// Définir la session
$request->session()->put('key', 'value');

// Récupération de la session
$value = session('key');
Si session : if ($request->session()->has('users'))

// Suppression de la session
$request->session()->forget('key');

// Afficher le flash dans le modèle

@if (session('message')) {{ session('message') }} @endif