CREATION DE MIGRATION ET RELATION

INSTALLATION LARAVEL
composer create-project laravel/laravel example-app

Si le dossier existe déjà.

Rentre dans le dossier et

composer create-project laravel/laravel .

Une fois installa on terminée

cd example-app

php artisan serve

Le projet est accessible sur http://localhost:8000

Mode maintenance  Php ar san down

Mise en disponibilité php ar san up

ARCHITECTURE DE LARAVEL

 Le fichier composer.json con ent la liste des dépendances nécessaires à notre projet, ce
fichier doit être versionné.
 Le dossier vendor con ent lui les sources de ces dépendances, ce dossier ne doit pas être
versionné.
 Le fichier composer.lock con ent l'état exact (la version) de nos dépendances au moment où
l'on travaille sur le projet, pour moi il doit être versionné.

ROUTING

Channels.php : Définir des évènements laravel côté serveur qui vont appeler des services côté client
(websocket) . Interac on entre le serveur / client

Console.php : Ligne de commande qu’on veut appelé depuis url

Api.php pour par exemple

Route ::get(‘/maroute, func on(){

return ‘Ma premiere route’;

}) ;

Route::get(‘routetpl’, func on(){

return view(‘monviewtpl’); // resources/views/ monviewtpl.blade.php

})

Route::get($url, $callback);
Route::post($url, $callback);
Route::put($url, $callback);
Route::patch($url, $callback);
Route::delete($url, $callback);
Route::op ons($url, $callback);

Route ::get(‘/user’, [UserController ::class, ‘index’]);

Route::resource(‘users’, UserController ::class);

Permet de générer

- /users
- /users/create
- /users/{user}
- /users/{user}/edit,
- /users {POST}

//Passer un paramètre

Route::get('/name/{name}', function($name){
return 'nom : ' . $name;
});

//Passer un paramètre non obligatoire

Route::get('/titre/{titre?}', function($titre = 'Mon titre'){

return $name;
});

//Route avec controle de variable

Route::get('/user/{name}', function($name){
return $name;
})->where('name', '[A-Za-z]+ ');

//Redirection d'url

Route::redirect('/ici','/la');
Route::redirect('/ancien-url','/nouveau-url', 301);
//ou
Route::permanentRedirect('/ancien-url','/nouveau-url');

GET

CREATION DE TABLES
Migra on table existant

Lancer la migra on des tables existantes

php artisan migrate

Création de nouvelle tables

Table pour les rôles

php artisan make:migration create_roles_table

Une fois ce e migra on create_roles_table crée, voici le code qu’il faut ajouter :
<?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('roles', function (Blueprint $table) {
$table->id();
$table->string('name')->unique();
$table->timestamps();
});
}

public function down(): void

{
Schema::dropIfExists('roles');
}
};

bigIncrements jsonb string

bigInteger lineString text
binary longText meTz
boolean macAddress me
char mediumIncrements mestampTz
dateTimeTz mediumInteger mestamp
dateTime mediumText mestampsTz
date morphs mestamps
decimal mul LineString nyIncrements
double mul Point nyInteger
enum mul Polygon nyText
float nullableMorphs unsignedBigInteger
foreignId nullableTimestamps unsignedDecimal
foreignIdFor nullableUlidMorphs unsignedInteger
foreignUlid nullableUuidMorphs unsignedMediumInteger
foreignUuid point unsignedSmallInteger
 geometryCollec on polygon unsignedTinyInteger
geometry ulidMorphs
rememberToken uuidMorphs
id set ulid
increments smallIncrements uuid
integer smallInteger year
ipAddress so DeletesTz
json so Deletes

Element de remplissent par défaut la table

php artisan make:seed RolesTableSeeder

Modifier le fichier

<?php

namespace Database\Seeders;

use Illuminate\Database\Console\Seeds\WithoutModelEvents;
use Illuminate\Database\Seeder;
use Illuminate\Support\Facades\DB;

class RolesTableSeeder extends Seeder

{
public function run(): void
{
// Insérer les rôles dans la table "roles"
DB::table('roles')->insert([
['name' => 'admin'],
['name' => 'user'],
['name' => 'subscriber'],
]);
}
}

Pour vider toute la table

php artisan migrate:fresh

Puis lancez ensuite la commande qui va remplir notre table rôle :

php artisan db:seed --class=RolesTableSeeder

php artisan make:migration add_role_id_to_users_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::table('users', function (Blueprint $table) {
$table->foreignId('role_id')->default(2); // Le rôle par défaut
est "user"
$table->foreign('role_id')->references('id')->on('roles');
});
}

public function down()

{
Schema::table('users', function (Blueprint $table) {
$table->dropForeign(['role_id']);
$table->dropColumn('role_id');
});
}
};

ROUTE
Les différents types de relation entre les modèles de
données dans Laravel
hasOne : Cette relation indique qu’un enregistrement dans la table A ne peut être associé
qu’à un seul enregistrement dans la table B. Il s’agit d’une relation « un à un » entre deux
modèles de données. Ainsi la relation hasOne peut être décrite comme une association de
type 1:1. Par exemple :

 Un utilisateur ne peut avoir qu’un seul profil.

 Une voiture n’a qu’une seule plaque d’immatriculation.
 Un commentaire n’a qu’un seul auteur.

hasMany : Cette relation indique qu’un enregistrement dans la table A peut être associé à
plusieurs enregistrements dans la table B. La relation hasMany peut être décrite comme une
association de type 1:n. Par exemple :

 Un article de blog peut avoir plusieurs commentaires.

 Un sondage peu avoir plusieurs propositions.
 Une commande ou un panier peut avoir plusieurs articles.

belongsTo : Cette relation indique qu’un enregistrement dans la table A appartient à un

enregistrement unique dans la table B. La relation belongsTo peut également être décrite
comme une association de type 1:n. Quelques exemples :

 Un commentaire n’appartient qu’à un seul article.

 Un article n’est écrit que par un seul auteur.
 Une image n’a été upload que par un seul utilisateur.

Pour mieux comprendre la différence entre les deux dernières relations hasMany et
belongsTo. on peut schématiser les choses de la manière suivante :

 La relation hasMany est utilisée lorsqu’un modèle est en relation avec plusieurs
instances d’un autre modèle. Par exemple, un utilisateur peut avoir plusieurs
commentaires, ou une entreprise peut avoir plusieurs employés. Dans ce cas, le
modèle qui a plusieurs instances est considéré comme le modèle parent et le modèle
qui a une seule instance est considéré comme le modèle enfant. Ainsi, la relation
hasMany est définie dans le modèle parent en utilisant la méthode hasMany.

 La relation belongsTo est utilisée lorsqu’un modèle est en relation avec une seule
instance d’un autre modèle. Donc un commentaire peut être associé qu’à un seul
utilisateur, ou un employé peut être associé qu’à une seule entreprise. Dans ce
cas, le modèle qui a une seule instance est considéré comme le modèle parent et le
modèle qui a plusieurs instances est considéré comme le modèle enfant. La relation
belongsTo est définie dans le modèle enfant en utilisant la méthode belongs. On
peut considérer que c’est la fonction » inverse » qui vient compléter notre hasMany
que nous venons de voir au dessus.

belongsToMany : Cette nouvelle relation indique qu’un enregistrement dans la table A peut
être associé à plusieurs enregistrements dans la table B, et vice versa. Cette relation est
souvent utilisée pour représenter des relations de type » many-to-many « . On peut donc
aussi indiquer que la relation belongsToMany peut être décrite comme une association de
type n:m. Quelques exemples :

 Plusieurs catégories peuvent être associées à plusieurs articles de blog.

 Des produits peuvent être dans plusieurs commandes.
 Des utilisateurs ont des langages de programmation préférés sur leur profil.
 Des fables mentionnent des animaux.

hasManyThrough : Cette relation permet de traverser une relation belongsTo pour

récupérer des enregistrements de la table B en passant par la table intermédiaire C. Avec
notre exemple de blog simple mentionné au début, on veut donc par exemple récupérer tous
les commentaires d’un utilisateur. Pour cela on peut utiliser la relation hasManyThrough en
passant par la table des articles. Nous verrons dans le code juste après comment mettre ça en
pratique.

Dit autrement, la relation hasManyThrough peut être décrite comme une association de
type 1:n, mais en passant par une table de plus. Il faut donc imaginer qu’un enregistrement
dans une table A peut être associé à plusieurs enregistrements dans une table B en passant par
une table C.

hasOneThrough : Cette relation est similaire à hasManyThrough, sauf qu’elle permet de

récupérer un enregistrement unique de la table B plutôt que plusieurs enregistrements. Par
exemple, pour récupérer le profil d’un utilisateur en passant par la table des utilisateurs, on
peut utiliser la relation hasOneThrough. Ainsi un enregistrement dans une table A est
associé à exactement un enregistrement dans une table B en passant par une table C.

Verb URI Action Route Name

GET /categories index categories.index
GET /categories/create create categories.create
POST /categories store categories.store
GET /categories/{photo} show categories.show
GET /categories/{photo}/edit edit categories.edit
PUT/PATCH /categories/{photo} update categories.update
DELETE /categories/{photo} destroy categories.destroy