• 15 heures
  • Moyenne

Ce cours est visible gratuitement en ligne.

course.header.alt.is_certifying

J'ai tout compris !

Mis à jour le 11/05/2020

Les ressources (1/2)

Connectez-vous ou inscrivez-vous gratuitement pour bénéficier de toutes les fonctionnalités de ce cours !

Dans ce chapitre nous allons commencer à étudier les ressources qui permettent de créer un contrôleur RESTful adapté à une ressource. Comme exemple pratique nous allons prendre le cas d'une table d'utilisateurs, une situation qui se retrouve dans la plupart des applications.

Les données

La migration

A partir d'un Laravel vierge on va commencer par configurer la base comme on l'a vu au chapitre précédent et par installer la migration pour créer la table des migrations dans la base :

php artisan migrate:install
Migration table created successfully.

Lorsqu'on installe Laravel on se retrouve avec deux migrations déjà présentes :

Les migrations présentes à l'installation.

Pour le moment on va garder seulement la première migration qui concerne la création de la table des utilisateurs. On va juste un peu la modifier ainsi :

<?php
use Illuminate\Database\Schema\Blueprint;
use Illuminate\Database\Migrations\Migration;
class CreateUsersTable extends Migration
{
/**
* Run the migrations.
*
* @return void
*/
public function up()
{
Schema::create('users', function(Blueprint $table)
{
$table->increments('id');
$table->string('name')->unique();
$table->string('email')->unique();
$table->string('password', 60);
$table->boolean('admin')->default(false);
$table->rememberToken();
$table->timestamps();
});
}
/**
* Reverse the migrations.
*
* @return void
*/
public function down()
{
Schema::drop('users');
}
}

On aura les champs :

  • id : entier auto-incrémenté qui sera la clé primaire de la table,

  • name : texte (varchar 255) pour le nom (unique),

  • email : texte (varchar 255) pour l'email (unique),

  • password : texte de 60 caractères pour le mot de passe (ce qui ne signifie pas que le mot de passe pourra avoir 60 caractères parce qu'on va stocker ici une version cryptée de ce mot de passe),

  • admin : valeur booléeenne pour indiquer s'il s'agit d'un administrateur avecfalse comme valeur par défaut,

  • remember_token : texte de 100 caractères qui sert pour l'authentification que nous verrons dans un chapitre ultérieur,

  • created_at et updated_at créés par la méthodetimestamps,

Ensuite on lance la migration :

php artisan migrate
Migrated: 2014_10_12_000000_create_users_table

Et on doit se retrouver avec la table créée :

 

La table des utilisateurs

Une ressource

Création

On va maintenant créer une ressource avec Artisan :

php artisan make:controller UserController --resource
Controller created successfully.Vous trouvez comme résultat le contrôleur
app/Http/Controllers/UserController
 :
<?php
namespace App\Http\Controllers;
use Illuminate\Http\Request;
use App\Http\Requests;
use App\Http\Controllers\Controller;
class UserController extends Controller
{
/**
* Display a listing of the resource.
*
* @return \Illuminate\Http\Response
*/
public function index()
{
//
}
/**
* Show the form for creating a new resource.
*
* @return \Illuminate\Http\Response
*/
public function create()
{
//
}
/**
* Store a newly created resource in storage.
*
* @param \Illuminate\Http\Request $request
* @return \Illuminate\Http\Response
*/
public function store(Request $request)
{
//
}
/**
* Display the specified resource.
*
* @param int $id
* @return \Illuminate\Http\Response
*/
public function show($id)
{
//
}
/**
* Show the form for editing the specified resource.
*
* @param int $id
* @return \Illuminate\Http\Response
*/
public function edit($id)
{
//
}
/**
* Update the specified resource in storage.
*
* @param \Illuminate\Http\Request $request
* @param int $id
* @return \Illuminate\Http\Response
*/
public function update(Request $request, $id)
{
//
}
/**
* Remove the specified resource from storage.
*
* @param int $id
* @return \Illuminate\Http\Response
*/
public function destroy($id)
{
//
}
}

Les 7 méthodes créées couvrent la gestion complète des utilisateurs :

  1. index : pour afficher la liste des utilisateurs,

  2. create : pour envoyer le formulaire pour la création d'un nouvel utilisateur,

  3. store : pour créer un nouvel utilisateur,

  4. show : pour afficher les données d'un utilisateur,

  5. edit : pour envoyer le formulaire pour la modification d'un utilisateur,

  6. update : pour modifier les données d'un utilisateur,

  7. destroy : pour supprimer un utilisateur. 

Les routes

Pour créer toutes les routes il suffit de cette unique ligne de code :

<?php
Route::resource('user', 'UserController');

Pour connaître les routes ainsi créées on va encore utiliser Artisan :

php artisan route:list
Les routes de la ressource

Vous trouvez 7 routes, avec chacune une url, qui pointent sur les 7 méthodes de notre contrôleur. Notez également que chaque route a aussi un nom qui peut être utilisé par exemple pour une redirection. Nous allons à présent considérer chacune de ces routes et créer la gestion des données, les vues, et le code nécessaire au niveau du contrôleur.

Le contrôleur

Il nous faut à présent coder le contrôleur. Pour rester dans la démarche de bonne organisation des classes je vais continuer à limiter le contrôleur à la réception des requêtes et l'envoi des réponses. Il va donc falloir injecter :

  • la validation

  • la gestion des données.

Pour la validation on va avoir deux cas :‌

  • la création d'un utilisateur avec vérification de l'unicité du nom et de l'email et la conformité du mot de passe,

  • la modification d'un utilisateur, avec la même vérification d'unicité mais en excluant l'enregistrement en cours de modification. D'autre part nous n'allons pas inclure le mot de passe dans cette modification.

On va donc avoir besoin de deux requêtes de formulaire : une pour la création et l'autre pour la modification.

Pour la gestion une seule classe  UserRepository suffira.

Si on considère ces injections voici le code du contrôleur :

<?php
namespace App\Http\Controllers;
use App\Http\Requests\UserCreateRequest;
use App\Http\Requests\UserUpdateRequest;
use App\Repositories\UserRepository;
use Illuminate\Http\Request;
class UserController extends Controller
{
protected $userRepository;
protected $nbrPerPage = 4;
public function __construct(UserRepository $userRepository)
{
$this->userRepository = $userRepository;
}
public function index()
{
$users = $this->userRepository->getPaginate($this->nbrPerPage);
$links = $users->render();
return view('index', compact('users', 'links'));
}
public function create()
{
return view('create');
}
public function store(UserCreateRequest $request)
{
$user = $this->userRepository->store($request->all());
return redirect('user')->withOk("L'utilisateur " . $user->name . " a été créé.");
}
public function show($id)
{
$user = $this->userRepository->getById($id);
return view('show', compact('user'));
}
public function edit($id)
{
$user = $this->userRepository->getById($id);
return view('edit', compact('user'));
}
public function update(UserUpdateRequest $request, $id)
{
$this->userRepository->update($id, $request->all());
return redirect('user')->withOk("L'utilisateur " . $request->input('name') . " a été modifié.");
}
public function destroy($id)
{
$this->userRepository->destroy($id);
return back();
}
}

Nous allons évidemment analyser tout ça dans le détail mais globalement vous voyez que le code est très épuré :

  • réception de la requête,

  • délégation du traitement si nécessaire (validation et gestion),

  • envoi de la réponse.

La validation

Création d'un utilisateur

On va créer une requête de formulaire pour la création d'un utilisateur. Je ne vous réitère pas la démarche de création avec artisan parce que nous l'avons déjà vue plusieurs fois. Voici le code de la classe :

<?php
namespace App\Http\Requests;
use App\Http\Requests\Request;
class UserCreateRequest extends Request
{
public function authorize()
{
return true;
}
public function rules()
{
return [
'name' => 'required|max:255|unique:users',
'email' => 'required|email|max:255|unique:users',
'password' => 'required|confirmed|min:6'
];
}
}

Avec ces règles :

  • name : requis, longueur maximale de 255 caractères, et unique dans la table users,

  • email : requis, adresse valide, longueur maximale de 255 caractères, et unique dans la table users,

  • password : requis, longueur minimale de 6 caractères et doit correspondre à ce qui est entré dans le champ de confirmation du mot de passe.

Modification d'un utilisateur

Pour la modification d'un utilisateur nous allons avoir un petit souci. En effet on veut conserver l'unicité du nom et de l'email dans la base, il est donc judicieux de prévoir une règle "unique". Mais comme les valeurs du nom et de l'email existants sont déjà dans la base on va avoir un échec de la validation en cas de non modification de l'une de ces deux valeurs, ce qui est fortement probable. Comment nous en sortir ? Étant donné que nous disposons d'une fonction on peut effectuer tous les traitements que l'on veut. Voici alors la requête de formulaire pour la modification d'un utilisateur :

<?php
namespace App\Http\Requests;
use App\Http\Requests\Request;
class UserUpdateRequest extends Request
{
public function authorize()
{
return true;
}
public function rules()
{
$id = $this->user;
return [
'name' => 'required|max:255|unique:users,name,' . $id,
'email' => 'required|email|max:255|unique:users,email,' . $id
];
}
}

On récupère l'id de l'utilisateur dans l'url. Ensuite on utilise une possibilité d'exclusion de la règle "unique". 

Vous devez donc avoir ces 2 fichiers pour la validation :

Les fichiers de la validation

Dans le prochain chapitre nous poursuivrons l'étude de cette ressource avec la gestion des données et les vues.

En résumé

  • Lors de la migration le constructeur de schéma permet de fixer toutes les propriétés des champs.

  • Une ressource dans Laravel est constituée d'un contrôleur comportant les 7 méthodes permettant une gestion complète.

  • Les routes vers une ressource sont créées avec une simple ligne de code.

  • Pour une ressource la validation est toujours différente entre la création et la modification et il faut adapter le code pour en tenir compte.

Exemple de certificat de réussite
Exemple de certificat de réussite