Laravel

Installation
Pour installer Laravel on a besoin de composer qui est un gestionnaire de package .En
plus on besoin de node.js et docker puis on suit les étapes dans la documentation.

Remarque :
Pour savoir si l’installation a été achevé il suffit de taper Laravel dans l’invite de
commande on devrait avoir une version et des indications des différentes commandes si
ce n’est pas le cas alors on doit ajouter composer au path.

Créer un projet Laravel

On tape la commande suivante : laravel new nom_du_projet

Dans le projet créé on a plusieurs fichiers et dossiers dont le fichier composer.json ,ce
fichier contient les informations sur nos assets(JavaScript , CSS et nos images) .

Artisan
C’est un outil de ligne de commandes qui vient avec laravel .En tapant php artisan on
aura plusieurs commandes qu’on peut utiliser .
Pour écrire les commandes on tape php artisan commande.

Démarrage du serveur
On tape : php artisan serve
On obtiendra alors un lien qui nous mènera vers le projet via le navigateur.
On doit laisser le cmd ouvert tant qu’on utilise laravel donc si on veut faire autre chose
avec un invite de commande il faut en ouvrir un nouveau.

Le fichier welcome.blade.php (dans resources/views) contient le fichier pour tous ce qui

concerne HTML.
blade est un modèle de rendu (rendering template) qui permet de insérer des extraits
(snippets) de nos vues sans avoir a mettre dedans des du code pour les traitement avec la
base de données.. c’est le rôle des controleurs .

Authentication
Cette partie du projet laravel permet la gestion des sessions et des
utilisateurs(connexion...).

Breeze
c’est une implémentation simple et minimal de tous les services d’authentification de
laravel.
pour la lancer on utilise la commande.C’est le dernier moyen de gérer les authentification
de laravel 8.x.

Pour commencer on tape : composer require laravel/breeze –dev pour télécharger

puis php artisan breeze:install pour l’installer puis pour construire nos assets npm install
(màj) et npm run dev
Pour exécuter les assets statique on utilise les deux dernières commandes.

Ajouter un framework frontend

php artisan breeze:install vue (pour vue.js)
ou bien php artisan breeze:install react

puis on compile de nouveau

npm install && npm run dev
npm run dev va prendre tous ce qui vient avec laravel et le compile dans un fichier.

Le fichier compilé se trouve dans le répertoire public /js/app.js

on a aussi un autre fichier dans resources/js/app.js qui sera celui sur lequel on va
travailler.

Le fichier resources/sass/app.scss est celui ou on va travailler notre css .

On peut importer d’autres fichiers css comme montrés dans app.scss

Lancer la section Js de laravel

npm install pour commencer a mettre a jour les packages.

Les vues
Dans un projet laravel on a des vues déjà prêtes qui se trouvent dans le dossier
resources/views/
le fichier home indique la vue quand un utilisateur sera connecté.

Migration de fichiers(BD)
Ce concept permet de gérer la base de données en utilisant des fichiers contenant toutes
les instruction qu’aura besoin la base de données puis on utilisera le cmd pour les charger
avec
php artisan migrate :….

si on tape seulement php artisan migrate alors on créera les tables nécessaire à
l’opération d’authentifiactaion
Création du ficher de db
vim database/database.mysql
puis pour sortir on tape echap puis :wq

Remarque :
A chaque fois qu’on modifie le fichier .env on doit redémarrer laravel
 Laravel 8/9
Avantages par rapport à php :
authentification
mail services
rapidité
sécurité

Que peut on faire sur laravel ?

• ToDoList
• login system
• blog
• Bookmarker Manager
• Time Sheet
• OrderApp
• Portfolio
• cms
• Social Network
• Ecommerce

Comment créer un projet avec composer :

on tape dans le cmd :
composer create-project –prefer-dist laravel/laravel nom du projet .

Démarrage du serveur
On tape : php artisan serve
On obtiendra alors un lien qui nous mènera vers le projet via le navigateur.
On doit laisser le cmd ouvert tant qu’on utilise laravel donc si on veut faire autre chose
avec un invite de commande il faut en ouvrir un nouveau.
• php artisan .. ne peut être utilise que dans un projet laravel
• php prend par défaut le port 8000 mais si ce dernier est occupé alors on peut
utiliser(le lancer dans un autre port) un autre port avec la commande php artisan
serve –port=8081

Changer L’URL (enlever localhost )

On doit d’abord revenir dans le répertoire principal en tapant cd
ensuite on tape nano /etc/hosts
puis on change devant 127,0,0,1 avec l’adresse qu’on souhaite au lieu de localhost

Model
Le dossier de Models est dans App/Models et dans ce dernier on a le fichier user.php
créé par défaut. Ce fichier va être utilisé par nos contrôleurs pour interagir avec notre base
de données.
Les contrôleurs quant a eux se trouvent dans le dossier App/http/controllers plus
exactement dans le fichier controller.php les contrôleurs sont ceux qui organisent le
comportement de notre application.
Vues
les vues se trouvent dans ressources/views

Le dossier routes
Ce dossier contient plusieurs fichiers:
api.php c’est la ou enregistre les retours de l’API.
Channels.php on y enregistre tous les événements des ‘broadcasting channels’
console.php ou en définit les commandes de console
web.php ou on enregistre nos routes(vers des vues …)

Remarque quand on veut enregistrer des chose pour le projet on les met dans le dossier
storage qui contient aussi les log.

Le fichier .env
env veut dire environnement donc ce fichier contient tous les réglages de l’environnement
Si on va dans le fichier web.php précédent et si on retourne dans l’une des fonctionne (à
la place de l’accueil par ex) on tape
return env(nom d’une variable de .env) ;
si on rentre dans notre accueil on aura la valeur de la variable

on peut aussi ajouter notre propre variable on lui donne un nom et une valeur et si on
l’affiche on aura notre valeur

.env.example est un exemple de notre env de base avant changement comme ça si on

modifie .env on pourra toujours revenir à l’ancienne valeur.

composer.json et composer.lock
composer.json est le fichier qui gère les dépendances du projet
dans la partie require les éléments indiqué sont des chemins de répertoires et les numéros
représentent la version avec par exemple : ^7,0,1 le 7 c’est le patch ,le 0 l’alpha et le 1
la bêta.
Le chapeau veut dire a peut prés donc si on a la version 4.3 alors les versions qui seront
compatibles sont celles supérieur ou égal à 4,3 et inférieur à 5.
require-dev n’est pas aussi important que les premiers on en a pas vraiment besoin.

Config et extra ne sont pas vraiment nécessaire.

autoload est important car certaines de nos librairies en ont besoin

le reste n’est pas très important

dans le fichier .lock on a v au lieu du chapeau ce la veut dire qu’on a besoin de la version
exacte

Remarque
la commande composer install va vérifier si on a des fichiers manquants dans notre
projet si c’est le cas elle cherchera la dernière version et la mettra à jour (l’installera)
aussi si aucun fichier ne manque elle fera seulement la mise à jour
Composer et packagist
Comment ajouter des librairies ou API à notre fichier log composer?
C’est à travers composer au lieu de faire ceci manuellement à travers l’invite de
commandes
Packagist.org : est le répertoire principal de packages pour composer
pour utiliser ce site on cherche le package voulu puis il nous donne une commande qu’on
tape dans le cmd exemple mollie composer require mollie/mollie-api-php
Après l’exécution de la commande on trouve un dossier mollie dans vendor et si on
vérifie le fichier composer.lock on trouvera qu’un package avec le nom de mollie a
été ajouté.

Remarque
Parfois il se peut que la librairie ne soit pas importé immédiatement et il faut donc taper
dans le cmd composer update.
Si on supprime le dossier mollie on peut le récupérer facilement avec composer update
puisque il est enregistre dans le fichier composer.json

Le dossier vendor
C’est ce dossier qui contient le fichier autoload.php
sans ce fichier notre application ne peut se lancer
Ce dossier contient les dossiers de différentes options ou dépendances inclus avec
laravel.

la commande composer dump-autoload permet de régénérer toutes les classes

qui doivent être dans autoload sans téléchargement.

Routing de base
Dans routes/app.php on a un appel de la classe route ou en utilise une requête get le ‘/’ veut
dire le répertoire principal(équivalent a 127,0,0,1:8000/) du projet donc c’est le chemin si on ne met
pas / c’est la même chose comme c’est par défaut

Ce que ce code veut dire c’est que à chaque fois qu’on a une requête get sur le répertoire principal
alors on aura la vue welcome.

Il existe d’autres types de requêtes.

GET : request a resource
POST create a new row
PUT to udpate a resource (changes the entire row)
PATCH modify a resource( only changed columns)
DELETE to destroy
OPTIONS Ask the server which verb is allowed.

La vue welcome se trouve dans le dossier resources.

Exemple de routes
//Route to users-String
Route::get('/users',function () {
return 'welcome to the users' ;
});

//Route to users-Arrays(JSon)
Route::get('/users',function () {
return ['PHP', 'HTML' ,'Laravel'] ;
});
//Route to users-JSON objects
Route::get('/users',function () {
return response()->json([
'name' => 'Amine',
'course' => 'Laravel'
]) ;
});

//Route to users-function
Route::get('/users',function () {
return redirect('/') ;//nous ramene vers la page home
});

Route::get(‘/blog’,[controler::class, ‘index’]) ;
Route::get(‘/blog/1’,[controler::class, ‘show’]) ;//afficher un elt.

//creation d’un elet.

Route::get(‘/blog/create’,[controler::class, ‘create’]) ;//appelle le formulaire
Route::post(‘/blog’,[controler::class, ‘store’]) ;//sauvegarder

//mise à jour
Route::get(‘/blog/edit/1’,[controler::class, ‘edit’]) ;//appelle l’elt a modifier
Route::patch(‘/blog’,[controler::class, ‘update’]) ;//mettre à jour

//supprimer
Route::delete(‘/blog/id’,[controler::class, ‘destroy’]) ;

Multiple méthodes http dans un seul route:

Route::match([‘GET’,’POST’],‘/blog’,[controler::class, ‘index’]) ;
Route::any(‘/blog’,[controler::class, ‘index’]) ;

Retourner une vue :

Route::view(‘/blog’,’blog.index’,[key => value]) ; [] est optionnel

Paramètres des routes :

Quand on a besoin de paramètres comme pour la suppression on ne met pas a valeur mais un
paramètre comme suit :
Route::delete(‘/blog/{id}’,[controler::class, ‘destroy’]) ;
il est préférable de nommer selon le paramètre attendu ici comme on identifie l’élément a
supprimer par son id on a id mas il peut être nom ...

Le paramètre peut être mis optionnel comme suit :

Route::get(‘/blog/{id?}’,[controler::class, ‘show’]) ;
Mais on aura une erreur car show a besoin d’un id donc en params de show $id = 1 par defaut par
exemple.

Routes avec expressions :

On peut ajouter à notre route une expression reguliere pour savoir quelle type de paramétre il peut
accepter pour ce faire :
Route::get(‘/blog/{id}’,[controler::class, ‘show’]) → where(‘id’,’[0-9]+’) ;

Route::get(‘/blog/{name}’,[controler::class, ‘show’]) → where(‘name’,’[A-Za-z]+’) ;

Route::get(‘/blog/{id}{name}’,[controler::class, ‘show’]) → where([
‘id’=>’[0-9]+’,
‘name’ => ‘[A-Za-z]+’
]) ;

ou automatiquement :
Route::get(‘/blog/{id}’,[controler::class, ‘show’]) → whereNumber(‘id’) ;
Route::get(‘/blog/{name}’,[controler::class, ‘show’]) → whereAlpha(‘name’) ;

Route::get(‘/blog/{id}{name}’,[controler::class, ‘show’]) → whereNumber(‘id’)

→ whereAlpha(‘name’) ;

Routes nommées :
On peut nommer les routes pour eviter de tous les refaire en cas de changement des urls. POUR
CE FAIRE ON ÉCRIT LE ROUTE COMME SUIT :

Route::get(‘/blog’,[controler::class, ‘index’]) → name(‘blog.index’) ;

Puis pour appeler ce route dans notre vue :
<a href={{ route(‘blog.index’) }} >text</a>

Dans le cas d’un chemin avec paramètre :

Route::get(‘/blog/{id}’,[controler::class, ‘show’]) → name(‘blog.show’) ;
Puis pour appeler ce route dans notre vue :
<a href={{ route(‘blog.index’, [‘id’ => 1]) }} >text</a>
ou route(‘blog.index’, $post→id) //si on veut par exemple monntrer une page avec un
element l’id servira dans show()

pour les contrôleurs resource pas besoin de nommer le route.

route() est une méthode global qui permet d’afficher le route dans lequel on se trouve?Elle peut
être utilise partout dans le code pour afficher son résultat print_r(route(‘products’)) ; on peut l’écrire
dans la fonction du contrôleur qui retourne la vue par exemple
route() peut être utilise pour les boutons aussi.ex : <a href= »{{ route(‘products’) }} »></a>

Préfixes de routes :
Sert a regrouper les routes ayant le meme prefix.
Route::prefix(‘/blog’)→ group(function(){
Route::get(‘/{id}’,[controler::class, ‘show’]) → whereNumber(‘id’) ;
Route::get(‘/{name}’,[controler::class, ‘show’]) → whereAlpha(‘name’) ;
}) ;

Fallback routes :
Si l’utilisateur écrit un url non existant on peut utiliser un fallback router pour réécrire la page 404.
Pour ce faire dans web.php à la fin du fichier taper :
Route::fallback(FallbackControler::class) ;

Dans le contrôleur on crée invoke et on met un retour vers la vue souhaitée.

Création de notre première page

Si on tape dans vs code doc on aura un code d’une page HTML basique
Remarque
 • Retourner une vue dans un route n’est pas une bonne habitude il vaut mieux
retourner un contrôleur qui retourne une vue.
• Pour retourner une vue return view(‘nom vue’) ;
• welcome se trouve dans resources/views

Contrôleurs
C’est un intermédiaire qui prend une requête du front et retourne une réponse il peut soit récupérer
les données , soit les insérer à la db...
1. Création d’un contrôleur
On a 2 manières
• Très rapide avec artisan
php artisan make:controller nom_sans extension

Remarque
• pour voir les commande de artisan on tape php artisan list
• pour l’aide php artisan –help
• on peut ajouter help pour php artisan make:controller nom -help pour avoir de
l’aide dans les flags et commandes possible.ex : si on ajoute –force a commande de
création de controlleur il le cerera meme si il existe déjà.

• Manuel
on va dans app/Http/Controllers et on crée un nouveau fichier( .php) dans notre exemple
c’est productsController.php puis on tape dans le fichier par exemple :
<?php
namespace App\Http\Controllers;

class ProductsController extends Controller{}

2. Comment utiliser un contrôleur pour le route ?

Dans le fichier des routes web.php on écrit: use chemin du contrôleur exemple
use App\Http\Controllers\ProductsController ;
Puis on écrit le route comme suit :
Route::request(‘endpoint(dest)’, [nom class::class,’nom fonction dans le controleur’]) ;

exemple
Route ::get(‘/Products’,[ProductsController::class,’index ‘]) ;
et voici un exemple d’une fonction qui se trouve dans le controleur.
public function index(){
return view('products.index');
}
Cette fonction retourne la vue index qui se trouve dans me dossier view/products/
ou bien on peut faire (nouvelle méthode)
Route::get(‘endpoint’,’chemin vers le contrôleur’) ;
exemple : Route::get(‘/products’,’App\Http\Controllers\ProductContorller@index’) ;

//avant laravel 8 ne fonctionne plus sur laravel8

//Route::get('/products','ProductsController@index');
voir plus d’exemple dans firstproject

3.Contrôleur prés rempli :

On peut créer un contrôleur avec toutes les fonctions d éja crée comme suit :
php artisan make:controler name --resource

Elle contient index, create pour créer une ligne dans la db.
Store , show qui affiche une élément de la bd, update pour mettre a jour une ligne et destroy pour
détruire une ligne de la bd.

Pour ajouter toutes ces méthodes dans le route :

Route::resource(‘endpoint’, controllerName::class) ;

4. Single action controlers :

Parfois on peut seulement avoir besoin d’un contrôleur qui ne fait qu’une seul action. Dans ce cas
au lieu de créer index dans ce denier on crée une fonction comme ceci :
public function __invoke(){
return view(‘’) ;
}

cette fonction peut contenir n’importe quelle actions.

Passage de données aux vues

1-La fonction compact(‘nom de la variable’)
exemple :
public function index(){
$title = "welcome to my laravel 8 course";
return view('products.index',compact("title"));
}
on peut ajouter plusieurs données en les ajoutant de la même manière en paramètre de la fonction
compact .

2-la méthode with

cette méthode ne permet de transférer qu’une seul variable (tableau ou autre)
exemple :
return view('products.index')→with(‘title’,$title);

Remarque
• On peut utiliser une boucle sur le fichier html directement on tape @foreach ou @for …
• au,lieu de with il y a aussi compact :
◦ return view('products.index',compact(‘title’)) ;
◦ est utiliser pour envoyer des tableau comme ici title est un tableau

3-Directement a travers la fonction view

Est la meilleur méthode.
return view('products.index',[‘data’=> $data]) ;

Vues (views)
Laravel permet au lieu d’utiliser <?php et ?> de taper @if ou @php pour le code en php ce
qui facilite la tache.En plus il permet de directement créer le footer et header pour chaque
page si on veut que les pages ait le même header et footer.

Pour faire ceci on crée un dossier ou on met les elts redondants.On crée un dossier
layouts ou on mettera app.blae.php ce fichier contiendra la structure de notre projet mais
pas le code entier.
Par exemple on va mettre le header et le footer qu’on veut dans app et entre le header et
le footer on appel @yield qui permet de recevoir de la page enfant ce qu’on veut y mettre
exemple app la page parent va recevoir des autre tel que index.
Pour faire ceci on donne un nom en paramètre de @yield(‘content’) puis on supprime des
pages enfant le header et le footer dans ce cas on ne laisse que ce qui vient au milieu
dans index par exemple on tape
@extends('layouts.app')
pour appeler app puis
@section(‘content’)
//code special à la page
@endsection(‘content’)

section doit avoir le même nom que le paramètre de yield

on peut mettre footer et header dans un fichier chacun puis on apele @include(‘chemin’)

pour changer les liens actif dans un menu on peut faire dans <a class="{{ request()-
>is('about') ? 'active' : '' }}"> puis dans css on donne un couleur exemple .active{
color:red
}
si on met dans is(about) /* tous les chemins /* auront la fonction

on peut mettre les images dans public OU METTRE LE LIEN VERS EN GLISSANT D’UN
REPOSITORY GITHUB PAR EXEMPLe PUIS ON LES APPEL à PARTIR DE CE QUI ÉTÉ
MIS DANS PUBLIC VOIR CODE

URL(‘chemin’) c’est une fonction laravel qui peut servir a retourner les images du
chemin voir code

en tapant php artisan storage:link

sur le cmd un dossier storage pour garder les images de notre projet. C’est une
alternative à la méthode ou on met les images dans public elle est plus sur que
images.
Il y aussi asset pour inclure des fichier css js et des images c’est une fonction qu’on met à
la place de URL on met asset

Les structure en laravel avec blade

c’est ce qu’on a vu comme @if…@endif
on peut mettre ce qu’on veut dedans
{{$var→attr}} affiche un parametre envoyé a la vue .
<$php echo htmlentities($vars->attr) $> équivalent a la precedente

@if(5<10) @endif
@if(5<10) @elseif(cond) @endif
@if(5<10) @else @endif //toutes les combinaisons possibles
--------------------------------------
@unless(cond)

@endunless //unless ≠ if
---------------------------------------
@empty(cond) verifie si une variable est vide ou non dans la condition et on met le
traitement souhaite dans le corps
@endempty
----------------------------------------
@isset(var)//comme php ressemeble a empty
//traitement
@endisset
----------------------------------
@switch(var)
@case
@break
.
.
.
@default
@endswitch
--------------------------------
@for(init ;cond ; ++)
@endfor
--------------------------------
@foreach($vect as $var)
@endforeach
---------------------------------
@forelse($vect as $var)
//trait
@empty//cas vect vide
//trait
@endforelse

Nous avons pour forelse et foreach des fonctions cachée comme :

si on tape {{$loop→index }} cela va afficher les index des éléments à partir de 0
{{$loop→iteration }}c’est un index à partir de 1.
on a aussi :
{{$loop→remaining}}le nombre d’éléments restants (itérations)
{{$loop→ count}} le nombre d’éléments parcourir(nb itérations)
{{$loop→ first}} si c le premier éléments de la boucle
{{$loop→ last}} si c dernier élément de la boucle
{{$loop→ depth}} nb de boucles
{{$loop→ parent}} pour référencer la variable de la boucle parent si imbriqué ;
---------------------------------
on peut créer un compteur
{{$i=0 }}
@while(cond)
//trait
{{$i++}}
@endwhile

Usage des assets (CSS et JS (frontend))

Laravel utilise knix qui est utilise dans le front end pour executer le css javascript ….
voir webpack.mix.js
la fonction mix.js(source du fcihier js , destination des fichiers compilé)
.sass( de même,meme)
.postCss(meme,meme)

pour tious faire fonctionner on doit verifier si node est installé avec node -v puis npm
install ensuite npm run dev pour compiler une fois
npm run watch sert a compiler meme après changement

On peut installer le framework frontend avec la commande

php artisan preset framework (bootstrap par exemple)….
On peut appeler des present frontend depuis des github
pour les trouver taper dans google laravel presets le premier lien vers github t entrer puis
choisir le preset souhaité et suivez les instructions.

Databases & migrations

Orm permet de rédiger des requêtes a la bd
pour se connecter à la bd mysql -u user -p puis taper mdp

Puis on crée une bd avec create database nom ;

On peut vérifier aussi si la connexion à la deb a ete bien fa ite avec tiker comme suit :
1. Dans cmd taper : php artisan tinker
2. taper : DB::connection()→ getPdo() ;
3. to exit tape : exit ;

Pour créer des tables et tous on utilise la migration pour ce faire on crée d’abord un contrôleur puis
la fonction et le route vers la vue souhaitée.
Maintenant il faut créer une modèle qui servira à communiquer avec notre migration avec
php artisan make:model nom
On le trouvera dans app/model/ .

Pour créer une migration il y a 2 manières avec le cmd en tapant

php artisan make:migration create_posts_table.
On peut ajouter –create=nom qui remplie avec le code de la table nom ou --table= nom pour
modifier la table nom avec la migration.
Mais on aimerai que ça se fasse automatiquement donc on peut utiliser une seconde méthode qui
crée une migration et un modèle avec la commande
php artisan make:model nom -m
ici pas besoin de créer le modèle avant .
Les fichiers sont dans database/migrations.

Dans le fichier qui a été crée on trouve deux methode :

up : quand on fait un migrate il cherche le fichier de migration le plus récent et va appeler la
fonction up de ce dernier. En gros charger tous ce qui contenu dans cette dernière. Blueprint
contient toutes les méthodes pour faire la création de db … pour donner les attributs de la table on
écrit dans la fonction
$table→ type(‘nom’) ;
pour appliquer les changement on écrit php artisan migrate

Types :
• id()
• timestamp()
• string(‘nom colonne’)
• text(‘nom’)
• integer(‘nom’)
• boolean(‘nom’)
Les images sont sauvegardé en tant que string (url).

Autre :
• $table→ type(‘nom’) → nullable(); //peut être vide
• $table→ type(‘nom’) → default(1);
• $table→ type(‘nom’) → unique();

Down : permet de migrer vers le bas sans avoir a supprimer avec mysql ou defaire tous ce qui a
été fait par la migration pour l ‘appelé
php artisan migrate:reset
ou
php artisan migrate:refresh
pour annulé chaque migration faite dans cette instance puis les appliqué à nouveau.
Reset n’applique pas migrate.
La commande
php artisan migrate:install
permet de garder trace des migration encore ou non encore appliqué.

On a d’autre commandes :
php artisan migrate:fresh qui ressemble a refresh mais sans utliser la fonction down alors elle va
supprimer toutes les tables puis executer up .

php artisan migrate:rollback pour faire un rollback

php artisan migrate:status qui liste les migrations

Seeders
Ils permettent de créer des données dans la bd de maniére automatique.
php artisan make:seeder name
On le retrouve deans database/seeders.
Dans le seeder on trouve la fonction seeder ou on met :
$posts= [
[
‘title’ => ‘val’,
‘body’ => ‘val body’,//integer et boolean sans ‘’
],
[
‘title’ => ‘val2’,
‘body’ => ‘val body2’,//integer et boolean sans ‘’
]
]
foreach($posts as $key => $value){
Post::create($value);
}

On doit aussi dire qu seeder de base database seeder et dans ce dernier dans run on met :
$this→call(PostsTableSeeder::class) ;

Pour lancer tous cela :

php artisan refresh

php artisan migrate –seed //lancer avec migration

ou
php artisan migrate
php artisan db:seed

Factory Model
On la crée avec la commande suivante :
php artisan make:factory PostFactory –model=Post

Factory permet d’insérer des données (dummy data) dans une bd automatiquement pour pouvoir
faire des tests rapidement.

Dans database/factories/PostFactory.php on définit dans la fonction definition:

‘nom att’ => $this→faker→sentence(), //for fake sentence
‘nom att’ => $this→faker→realText($maxNbChars = nb), //generate a text has more params
‘nom att’ => $this→faker→text(), //plus grand que realtext
‘nom att’ => $this→faker→imageUrl(width, height),
‘nom att’ => $this→faker→numberBetween(min,max),
‘nom att’ => $this→faker→unique()->sentence(),

Pour tous les attributs (sauf enumerate)

Puis dans le seeder général(laravel 9)

Post::factory(nb_of_rows_to_add )→ create();
ou
Post::factory(nb_of_rows_to_add )→ create([‘col_name’ =>’val’ ]);
pour overirde la valeur d’une colonne on mettant toute les lignes avce val comme valeur pour la
colonne concernée.
Puis dans cmd : php artisan db:seed

Puis pour avoir des exemples de test on tape dans cmd (laravel8)
php artisan tinker puis \App\Models\Post::factory()→count(2)→create(); qui créera 2 ligne
dans bd

Query builder
C’est une interface permettant de communiquer avec les données de plusieurs bases de
données(non fluent query)
Non fluent Query :
DB:: operation(ex select)([‘table’=> ‘nomtabex(posts)’,’where’=>[‘id’ =>1]])

Mais il y a mieux Fluent query :

DB::table(‘posts’)→where(‘id’,1)→get()(recupere tous)

Mais il vaut mieux faire comme suit

$var = DB::operation(‘requete’ ) ;
dd($var);(il faut importer DB voir code)

exemple :
$var = DB::statement(‘select * from posts’) ; peut contenir une requete sql et permet de tester si la
requete peut etre executee.

$var = DB::select(‘select * from posts’) ; //retourne tous de la table posts

Quand on a des données a passer dans la requet il vaut mieux faire comme suit :
$var = DB::select(‘select * from posts where id = ?’,[1]) ;//cherche id = 1
ou
$var = DB::select(‘select * from posts where id =:id’,[‘id’ => 1]) ;

Pour insertion :
$var = DB::insert(‘insert into table posts (col1,col2,..) values( ?, ?,…)’,[
‘val1’, ‘val2’,….
]) ; //retourne un booléen .

Pour mise à jour :

$var = DB::update(‘update posts set col = ? where id= ?’,[
‘val1’, val_id
]) ; //retourne nombre de lignes mise à jour

Pour supression :
$var = DB::delete(‘delete from posts where id= ?’,[val_id]) ;/retourne nombre de lignes supprimées.

Ou encore avec table() :

$posts = DB::table('posts')→get(); //recupere tous. Get toujours à la fin .

$id = 7;
$posts = DB::table('table_name')→select(‘col1_name', ‘col2_name’,...)→get();
dd($posts);

Ou pour a clause Where :

$posts = DB::table('posts')
→where('created_at','>',now()→subDay()) //si on met pas < par defaut c’est =
->get();

$posts = DB::table('posts')
→ where('created_at','>',now()→subDay())
 → where('title','Mr.')
→ get();

$posts = DB::table('posts')
→ whereBetween('id',[1,10]) //1 et 10 inclus ou whereNotBetween
→get();

$posts = DB::table('posts')
→whereNotNull('title') //ou whereNull
->get();

$posts = DB::table('posts')
->select('title')
->distinct()
->get();

$posts = DB::table('posts')
→orderBy('title','asc')//ou desc asc is default
->get(); //first

$posts = DB::table('posts')
→latest()//oldest et inRandomOrder aussi
->get();

$posts = DB::table('posts')
→skip(30)
→take(10)
→get(); //prend 10 a partir du 31 eme

$posts = DB::table('posts')
→inRandomOrder();

$posts = DB::table('posts')
→ where(‘id’,10)
→first();

$posts = DB::table('posts')
→ where(‘id’,10)
→value(‘body’); //rertourne lavaleur de body ou id = 10

$posts = DB::table('posts')
->find(10); //retourne null si ne trouve pas l’id 10

$posts = DB :: table('posts') //on peut ajouter une condition where avant count
->count();

$posts = DB :: table('posts')
->min(‘col’);//ou max

$posts = DB :: table('posts')
 ->sum('id');

$posts = DB :: table('posts')
->avg('id');*/

Maintenant pour l’insertion

$posts = DB :: table('posts')
->insert ([
'title' => 'New Post', 'body' => 'New Body'
]);

$posts = DB :: table('posts')
->where('id','=',4)
->update([
'title' => 'New Title', 'body' => 'New Body2'
]);

$posts = DB :: table('posts')
->where('id','=',4)
->delete();

Eloquent
c’est un Orm (object relatioanl maker) , une classe eloquant permet de interagir avec des tables et
même des lignes. Il simplifie les traitement avec la BD.
php artisan make:model Car -m
Pour un modèle et un migration.

Dans car.php (le model) pas besoin de dire que la table est Cars c’est fait automatiquement si la
table existe et s’appele cars (avec s) pour changer le nom de la table à lier on met dans car.php

protected $table= ‘nom_table’ ; => dans ce cas on met cette ligne dans le modèle si on veut qu’il
interagisse avec une table d’un nom différent que son nom à lui

Aussi on peut changer la clé primaire dans le modèle comme suit :

protected $primaryKey=’nom_colonne’ ;
$primaryKey = false ; pour ne pas avoir de clé .et ca marche pour tous les attributs.

On peut aussi désactiver les timestamps dans le modèle comme suit :

protected $timestamps = false ;

On peut aussi customiser le format des dates comme suit :

protected $dateTime =’U’ ; //ici U veut dire on garde les secondes
protected $dateFormat =’h:m:s’ ;

On peut aussi le driver de la bd du modèle :

protected $connection = ‘sqlite’ ; ici le modèle utilise sqlite ;

On peut définir des valeurs par defaut des attributs dans le modèle comme suit :
protected $attributes=[
 ‘col_name’ => default_value,
];

php artisan make:controller CarsController –resource

--resource pour créer automatiquement des fonctions pour modifier et éditer…

Route::resource(‘/’,carsController::class);
//comme ça on récupère toutes les méthodes du contrôleur.
Autre manière de faire un route qui permet de retourner toutes les méthodes du contrôleurs pas
une a la fois comme on le faisait.

Puis sur cmd on tape php artisan route:list

pour nous montrer toutes les méthodes qu’on a créé auto.

Pour appeler les données de la base de données :

dans le contrôleur on appéle le modèle
avec use App\Model\Car ;
puis :
si on veut les retourner dans index.blade.php
on va dans la fct index
$cars = Car::all() ; //recupere toute la table
return view(‘index’, [‘cars’ => $cars]) ;//retourne un tableau puis dans index on itère avec for
each par exemple.

Au lieu de all on a aussi get pour pouvoir ajouter des conditions (where, orderBy... par exemple)
comme dans ce qui suit :

Car::where(‘id’,’=’,’4’)→ get() ;
{{$cars→ name}} affiche l’attribut name
car::all()→count() ;//retourne le count de tous.

Nous avons aussi la fonction chunk qui permet de traiter les données avant de les envoyée à la
vue exemple :
Car::chunk(nb_rows, function($cars){
foreach($cars as $car){
echo $car→name.’<br>’
}
}) ;
return view(‘…’) ;
dans la fonction on peut faire n’importe quelle traitement.

Car::sum(‘price’) ;
Car::avg(‘price’) ;
(les mêmes fonctions vu précédemment)

Pour retourner les données avec la vue on ecrit :

return view(‘view_name’ , [
‘nom’ => $car
]) ;
Pour récupérer une ligne :
$post = Post::find($id) ; //dans show ()
$post = Post::findOrFail($id) ;//si ne trouve pas retourne une exception.

Accéder à une requête

Dans cette partie il s’agira de traiter qui peuvent se manifester lors d’insertion de données
via les requêtes par exemple type msimatch .On va dans la fonction store de cars
controler par exemple et avant la creation de car on met le code :

Validation
$request->validate([
'name' => 'required|unique:cars|max:255'//max nb caracters,
'founded' => 'required|integer|min:0|max:2021',
'description' => 'required',
'image' => 'required|mimes:jpg,png,jpeg|max:5048'
]);
Donc on donne les conditions
il existe bien plus de condition voir doc laravel.
La syntaxe utilisée ici il ya ‘pipes|’ qui séparent les conditions. Mais il y a aussi une autre syntaxe
qui vient comme suit [‘cond1’,’cond2’,...].
Donc en gros en entrant dans store il vérifie si les données sont valide via le code ci dessus si les
données sont valide alors il passe au reste du code de store sinon erreur.

Pour savoir si une erreur a été trouve

@if($errors→any())
<div>….</div>
@endif

Dans le div on peut afficher les erreurs en itérant sur $errors→all()

Si on affiche directement les erreurs on aura des messages prédéfinies .

On peut créer nos propre règles avec : php artisan make:rule nom
Et on trouve le résultat dans le dossier rules le fichier créé contiendra plusieurs fonctions :
passes qui prend l’attribut et la valeur qui retourne un booléen si la valeur passe ou pas les
conditions
Exemple :
Si on veut qu’il soit majuscule alors return strtoupper($value)==$value ;
Cette fonction retourne le message d’erreur par exemple :
return ‘the:attribute must be uppercase’ ;
:attribute sera remplacé par le nom de l’attribut en question

puis on met dans le contrôleur

use chemin vers rule
et pour l’appliques sur un attribut exemple name
‘name' => new Uppercase,//upercase nom de la regle.
Remplir une bd :
On ajoute en dessous de form(tag debut) @csrf (à l’interieur de form apres ‘>’) avec méthode
post.qui génère un token pour des raisons de sécurité afin d’éviter que des personnes envoie a tes
users un form de ton site …
1. Dans la fonction create du contrôleur on retourne la vue qui contient le formulaire.
2. Dans form action = ‘’{{route(‘/store’)}}’’
3. Ensuite, dans le contrôleur on travaille dans la fonction store :
1. Si on retounre dans store dd($request→all()) on aura des donnée on peut aussi passer
seulement un attribut $request→name par exemple.
2. On peut faire dd(« ok ») pour savoir si tous va bien .
3. Store permet d’accéder aux données ajouté dans le formulaire par l’utilisateur.
4. Dans store pour inserer les données dans la bd on fait comme suit :
1. $car = new Car() ;
2. $car→name = $request→ name; //dans input le nom du input
1. de même pour tous les attributs.
2. Si un attribut est un booléen et dans notre page on utilise checkbox on peut
faire comme suit :
1. $car→is_forSale = $request→isForSlae ===’on’ ; //si vla = on alors true
3. À la fin on ajoute $car → save() ;
4. return redirect(‘vue’) ;
4. sinon aucune insertion ne sera effectué
5. on peut aussi on fait passer un array au model
6. on tape dans store
1. $car = Car::create([
‘name’ => $request→name,
…...//pour le reste comme plus haut
]) ; pas besoin de save
2. puis il faut les faire approuve pour ce faire on va dans le model et on tape
1. protected $fillable = [‘name’,…] ici on met les noms des colonnes qu’on va insérer
en chaîne de caractère
3. on peut utiliser make au lieu de create mais avec make on doit utiliser
$car - >save() ;

Image Upload
on modifie la table avec une migration pour ajouter un attribut contenant le nom de l’image up
contient comment ajouter l’att et down comment le supprimer.
'image' => 'required|mimes:jpg,png,jpeg|max:5048'
ceci doit être ajouter dans validate (dans store du controleur) comme dans validate ci dessus
On a plusieurs fonctions qu’on peut utiliser ex :
$test = $request→file(‘image’)→getMimetype() ; //ou guessExtension() ou getClientMimeType() ou
getClientExtension()
dd($test) ;
qui retourne le type de l’image
aussi store() asStore() storePublicly() pour suavegarder l’image
et move() aussi
Quand on veut changer le nom du fichier après qu’il soit donnée on utilise getClientOriginalName()
getSize() retourne la taille de l’image.
GetError() verifie si il ya une erreur(false/true)
valide() retourne true si c la bonne extension.
Pour donner un nom unique a l’image et éviter des erreurs
$newImageName = time().'-'.$request->name . '.'.$request->image->extension();
$request->image->move(public_path('images'), $newImageName);
Pour mettre image dans un dossier images dans public

on ajoute l’image dans fillable du contrôleur de Car.et on met $newImagename comme donnée a
mettre dans la BD.
L’appel de l’image pour l’afficher se fait src=’’{{ asset(‘images/’ . $car→image_path)}}’’

Pour laravel9 :
Dans le controlleur à la fin on crée une fonction comme suit :
private function storeImage($request){
$newImageName = uniqueid() . ‘-’ .$request→name . ‘.’ . $request->image-
>extension(); //attribut name de la table par exemple
return $request→image→move(public_path(‘images’),$newImageName) ;
}
• Puis dans store() :
‘image_path’=> $this→ storeImage($request),

Modification de BD :
On utilise dans ce cas edit et update les fonctions du contrôleur.
Dans edit on cherche la ligne a modifié avec
$car = Car::find($id)→first() ; //id est param de edit ou $car = Car::where(‘id’,$id)→get() ;
return view(‘cars.edit’)→with(‘car’,$car) ;
ce qui permettera de retourner un form ou les input contiennent les valeurs déjà existantes.//en
mettant {{$car→param}} dan value de input
Puis dans update (v8) :
public function update(Request $request, $id) {
$car = Car::where('id', $id)->update([
'name' => $request->input('name'),
'founded' => $request->input('founded'),
'description' => $request→input('description') )] ;
return redirect('/cars');//revenir a cars
}

V9 :

public function update(Request $request, $id) {

$car = Car::where('id', $id)->update([
'name' => $request->name,
'founded' => $request→founded,
‘is_new’ => $request→ is_new ≡ ‘on’,
'description' => $request→description )] ;
return redirect(route('cars.index’));//revenir a cars
}
 Ou bien plus simple :
Car::where(‘id’,$id)→ update($request→ except([‘_token’, ‘_method’])) ;
//ajouter redirect après
pour enlever de la requête les champs concernant la sécurité.

Dans le form en dessous de @csrf on ajout @method(‘PATCH’)(dans laravel 8 PUT)

Avant cela on peut ajouter une validation :

$request->validate([
'name' => 'required|max:255 |unique:cars,name'. $id, //ici
name unique mais peut être changé pour le même id
'founded' => 'required|integer|min:0|max:2021',
'description' => 'required',
'image' => 'required|mimes:jpg,png,jpeg|max:5048'
]);

Effacer dans une BD

//on peut passer le id mais on fait comme suit en passant le model pour éviter de faire une
recherche
public function destroy(Car $car) {
$car->delete();
return redirect('/cars');
}
Ou v9

public function destroy($id) {

Car::destroy($id) ;
return
redirect(route(‘index’))→
with(‘message’,’post
deleted’);
}
Pour afficher le message dans index :

@if(session()→ has(‘message’))
traitement
@endif

Ici on crée directement une form pas un anchor comme modifer. form doit contenir csrf et
@method(‘DELETE’) puis elle renverra vers un autre form qui contient les case a modifier (c’est ce
qu’on doit faire pour toutes les opérations))

Serialization
Pour convertir un array ou objet complexe en string. Pour laravel on a deux méthodes :
toArray() transforme une collection eloquant en array
$cars = Car::All()→toJson() ;
toJson() transforme une collection eloquant en jason object(pour api plus)car il retourne
une collection en chaîne de caractere pour les rendre en objet ou on peut separer les elt
on appel

$cars = json_decode($cars) ;
pour cacher les entrée qu’on veut cacher dans le model on ecrit
protected $hidden = [’id’,….] ;
pour afficher certaines données on ecrit dans le modele
protected $visible = [‘name’,….] ;
cela fonctionne avec Array et Json object

Form requests
Pour éviter de répéter la même validation et mieux structurer le code.
Pour la créer : php artisan make:request nom (ex createValidationRequest)
on y trouve 2 méthodes
• authorize(optionnel) : si retourne true l’utilisateur est autorisé a faire cette requête si false
non.
• rules : Vérifie des règles avant de la réaliser. On met dedans :
public function rules(){
return [
'name' => 'required|unique:cars',
‘founded' => 'required|integer|min:0|max:2021',
‘description' => 'required',
'image' => 'required|mimes:jpg,png,jpeg|max:5048'
]
}
• rules comme ca marche seulement si on une validation mais si par exemple la validation
est differente lors de la creation et mise à jour cela ,ne fonctionnera pas pour y remédier on
ecrit :
public function rules(){
$rules= [
'name' => 'required|unique:cars,name' .$this->id,
‘founded' => 'required|integer|min:0|max:2021',
‘description' => 'required',
'image' => 'mimes:jpg,png,jpeg|max:5048'
]
if(in_array($this→method(), [‘POST’])){
$rules[‘image’] = 'required|mimes:jpg,png,jpeg|max:5048' ;
}
return $rules ;
}
• Ce que nous avons fait est simple :
◦ pour id on doit utiliser this
◦ pour l’image comme elle n’est pas obligatoire pour modifier mais elle l’est pour la création, alors si la méthode est post la
règle contient required.

Elle s’appliquera à chaque fois qu’une requête en aura besoin il suffit seulement de l’ajouter dans
le contrôleur en question (ex cars)
use App\Http\Requests\createValidationRequest ;
et dans store on change le type $request en CreateValidatedrequest puis on appel la fonction
$request→validated() ; et c’est tout on enlève validate du haut.Puis pour le reste par exemple
dans update on change le type de $request et on appelle validated.
Pagination
Elle permet de limiter le nombre d’éléments retourner a la fois dans la page.
Pour ce faire dans le contrôleur par exemple dans index au lieu de get on utilise paginate
$Fournitures = Fourniture::orderBy(‘params’,’desc’) → paginate(20); //ici 20 à la fois

Maintenant si on a plusieurs pages on doit donner à l’utilisateur un moyens de les parcourir pour
ce faire :
• Dans notre page blade :
◦ {{ $var->links()}}

Les relations Eloquent

• Eloquent One to many
C’est quand on a un attribut qui peut avoir plusieurs valeurs pour une seul ligne. Pour ce
faire on crée une nouvelle table exemple car-modeles qui contient l’id de la igne de la table car un
id du modèle et le nom du modèle et par exemple un timestamp.

Si on veut par exemple laisser un utilisaeur créer plusieurs voitures dans la bd :

Pour ce faire on va dans la migration et dans up on crée la table normalement avec id de la voiture
en entier non signé ($table→ unsignedBigInteger(user_id)) et pour dire que c l’id de la table
user :
$table→foreign(‘user_id’)
→references(‘id’)
→on(‘users’)
→onDelete(‘cascade’) ;
ou set null au lieu de cascade pour mettre à null si la marque est supprimée.

Puis dans factory de car on ajoute à la fin:

‘user_id’ => 1
php artisan migrate:reset
php artisan migrate

Dans userModel :
public function cars(){
return $this→hasMany(Car::class);
}

Puis pour les afficher on utilise dashboard (dashborad.blade.php) exemple :

{{Auth::user()→name }}
@foreach(Auth::user)→cars as $car)
<h2>{{$car→name }}</h2>
@endforeach

Maintenant dans CarModel. On ajoute la fonction :

public function user(){
return $this→belongsTo(User::class);
}
si on veut afficher le user de la voiture {{ $car→user→name}} dans la page blade concerné

remarque : formater date {{$car→inseted_at→ format(‘d/m/Y’)}}

 • Has Many
par exemple une marque a plusieurs modèles et chaque modèle a plusieurs moteurs.Pour ce faire
on crée la table engines comme on l’a fait pour les modeles et on les relient. Pour les relier on va
dans le model car et on met la fonction

public function engines() {

return $this->hasManyThrough(
Engine::class,//la class moteur
CarModel::class,//classe intermediaire
'car_id', //Foreign key on CarModel table
'model_id' //Foreign key on Engine table
);
}

• HasOne
Exemple chaque voiture a plusieurs modèles et chaque modèle a une date de production.
De même dans le model de car-mode

public function productionDate() {

return $this->hasOneThrough(
CarProductionDate::class,
CarModel::class,
'car_id',
'model_id'
);}

• Eloquent One to One

Ici chaque élément de table a un élément de table2 lui correspondant. Exemple post a une meta :
Dans post_metas (une table contenant les meta) on ajoute
$table→ unsignedBigInteger(‘post_id’) ;
$table→foreign(‘post_id’)
→references(‘id’)
→on(‘posts’)
→onDelete(‘cascade’) ;

Puis on applique les migrations.

Puis on définie les reations :
Dans le modèle de Post :
public function meta()
{
return $this→ hasOne(PostMeta::class);
}
On pourrait la même chose dans le modèle de meta pour avoir une relation dans les deux
directions.
Pour acceder à la meta
{{ $post→meta→...}}
Si on utilise un formaulaire pour crér un poste et une meta on peut dans store (celle de post)
ajouter
$post = Post::create([
‘user_id’ => Auth::id(),
……
]) ;

$post→ meta()→ create([

‘post_id’ => $post→id,
‘col1’ => val1,
…..
]) ;

en cas d’erreurs dans database.php STRICT DOIT ÊTRE MIS A FALSE ;

• Eloquent Many to Many

exemple une voiture a plusieurs produit et chaque produit peut être relié a plusieurs voitures.Dans
ce cas créer seulement une table produit ne suffira pas donc on devra créer une table pivot
car_product contenant l’id du produit et de la voiture donc 2 attributs. Et une table car(existe déjà)
et une table product concernant le produit avec un seul id celui du produit.La table pivot va
connecter les instances de car avec celle de product qui lui correspondent.Pour ce faire on crée
une migration et un model products et de même pour car_product.puis on définit les relations dans
le model de car

Dans up de la migration de products

Schema::create(‘products’, function (Blueprint $table) {
$table→ id() ;
$table→string(‘title’) ;
$table→ timestamp() ;
}

Puis la table pivot on lui crée une migration

php artisan make:migration create_product_car_table ;

puis dans up :

Schema::create(‘product_car’, function (Blueprint {

$table)
$table→ unsignedBigInteger(‘product_id’) ;
$table→ unsignedBigInteger(‘car_id’) ;
$table→ foreign(‘product_id’) → references(‘id’) →
on(‘products’) → onDelete(‘cascade’);
$table→ foreign(‘car_id’)→ references(‘id’) →
on(‘cars’) → onDelete(‘cascade’);
}
Puis migrate.
Et dans cars.php
public function prducts() {
return $this-
>belongsToMany(Product::class);
}

Puis dans products.php :

public function cars() {

return $this->belongsToMany(Car::class);
}
Pour l’accès au produit comme on a fait plus haut et $car→products

Basic artisan commands

le fichier arisan dans le projet est appele quand on utilise la commande artisan.les
commandes artisan peuvent etre obtenue dans php artisan list
php artisan clear-compiled permet de vider les fichier de classes compiler comme vider un
cache laravel.
Php artisan down met l’app en mode maintenance
php artisan up la remet normal après maintenance.
Php artisan env donne l’environnement ou l’app est exécutée
php artisan help pour de l’aide
php artisan optimize permet de réinitialiser les route et les fichier de configuration.

php artisan cache:clear vide le cache.

php artisan auth:clear-resets supp les tokens expire de la db
php artisan key:generate application encription code random se trouvat dans .env
php artisan session:table crée une migration contenant les sessions des users
php artisan view:clear pour vider le cache des sessions si ca ne se charge pas.

Authentification

Ici nous allons restreindre l’accès a certaine page par exemple si on veut créer un article le user
doit etre authentifier pour ce faire dans posts controller au début ajouter :
public function __construct(){
$this→ middleware(‘auth’)→only([‘create’,’edit’,’update’,’destroy’]) ;
}
ici pour accéder a ces fonctions il fat être authentifier.
On peut aussi cacher les boutons qui ne concerne pas le user non authentifié comme suit :
@if(Auth::user())
<button> …
@endif
Maintenant pour modifier et supprimer un article seul celui qui l’a créé peut le faire :
@if(Auth::id() == $post → user→ id)
<button> …
@endif

Authentification and authorization

D’abord composer require laravel/ui

Puis: php artisan ui tailwindcss –auth //cas tailwind
puis
les migrations et models existent déjà .
Authentication : vérifier qui est la personne pur lui donner accès (login/logout)

Authorization : si le user identifier est autoriser a faire certaines operations

on doit effacer et optimiser les routes

php artisan route:clear
php artisan optimize
php artisan route:list //affiche les route
dans web.php Auth:route() ;

Pour restreindre l’accès des users selon des cas on fait :

si on veut limiter un user a modifier la voiture qu’il a insérer on doit lier la table car et users pour ce
faire on crée une migration add_user_id_to_cars_table puis dans la migration dans up
$table→integer(‘user_id’) ;

et dans down $table →dropColumn(‘user_id’) ; et on applique une migration puis dans le

controleur car dans store on ajoute user_id pres image_path comme suit ‘user_id’=>
auth()→user()→id l’ajouter dans $fillable aussi

dans le div de l’operation qu’on veut cacher des users non autoriser
on met @if(Auth::user())
maintenenat si on veut que seul l’utiliseur qui a ajoute une voiture puisse la modifier ou la
supprime on met
@if (isset(Auth::user()->id) && Auth::user()->id == $car->user_id)

pour bmoquer un utilisateur d’acceder une page a travers le url on va dans le car controleur on
met le constructeur

public function __construct() {

$this->middleware('auth', ['except' => ['index', 'show']]);
}
Il affiche seulement index et show pour les utilisateurs non enregistre

Facades
Ce sont des interfaces permettant d’englober un ensemble de classes complexes. En gros
ils en simplifient l’utilisation.Tous les services offerts par laravel sont mis disponibles via
des façades.

DebugBar
pour l’installer : composer require barryvdh/laravel-debugbar –dev //visible en dev
mode
on va dans config/app.php et on ajoute dans ‘providers’
Barryvdh\Debugbar\ServiceProvider::class,
Pour l’utiliser : on peut retourner plusieurs types de messages il suffit que dans web.php
avant de retourner une vue on tape Debugbar::type ;
avec type : info(‘message’)
error(‘message’)
warning(‘message’)
addMessage(‘message’)
Après actu on aura la debugbar en bas
Le message apparaîtra dans l’onglet message de la debugBar
Timeline
permet de connaître le temps que prend chaque requete et le temps de bot de l’application
pour l’activer dans web.php Debugbar::startMeasure(str,str);le 2eme str servira
comme message pour verifier en combien de temps il sera affiché.
Exceptions
pour les exceptions , pour ce faire dans web.php on met un block try/catch
try{
//action
//pour test
throw new Exception(‘mssg’) ;
}catch(Exception $e) {
Debugbar::addException($e) ;
}

Views
les templates(vues) rendered avec leurs parametres
Route
tous sur les routes appelés
Queries
probablement le plus important
affiche les requêtes effectuée sur les routes et le temps qu’elles prennent

Models
Tous les modèles
Session
token de la session, l’url du route précédent, messages flash et stack data
Request
Tous ce qui est en relation avec les requêtes

Remarque :
pour ajouter un fichier sans donner son chemin on fait :
ex : <link rel= ‘’stylesheet’’ href=’’{{ asset(‘css/app.css’) }}’’ >