Créer un crud complet avec laravel 5

Dans cet article, nous allons voir comment créer une nouvelle commande laravel qui permet de générer un vrai CRUD en laravel (controller prérempli, model, request prérempli, un dossier views avec les 4 vues nécessaires => index, create, edit et show mais aussi la migration).

On va aussi voir comment créer un custom package sous laravel 5.
Impatient ? Commençons par le début, installer laravel.

Installation de Laravel 5

Pour installer L5, vous avez besoin de Composer , une fois installé, lancez la commande suivante :

composer create-project --prefer-dist laravel/laravel nomdudossier

Faites pointer votre hébergement sur le dossier public. Si tout fonctionne bien, vous devriez avoir une page avec écrit Laravel 5.

Création d’un custom package

A la racine de votre installation, créez un dossier /packages (c’est ici que l’on va créer notre package).
Chaque package est constitué d’un nom de « vendor » et un nom de package. Pour Laravel, comme on a pu le voir juste au dessus c’est laravel/laravel (vendor/nom de package).
Généralement on met son nom/pseudo en vendor et le nom du package… comme nom du package 😀
Une fois les 2 choisis, créez un dossier du nom du vendor et à l’intérieur un autre dossier du nom du package.
Par exemple, j’ai choisi « mrdebug » comme vendor et crudgen comme nom de package, j’ai donc ceci en arborescence :

A l’intérieur du dossier du package, créez un dossier appelé « src »
Chaque package a besoin d’un fichier composer.json avec toutes les infos nécessaires (dépendances potentielles etc…)
Pour le créer, faites :

composer init

Et suivez les consignes.

Pour charger le package dans laravel, il faut lui assigner un alias. Pour cela, il faut modifier le composer.json à la racine de laravel et rajouter notre alias dans la section psr-4.
Dans mon exemple, ça donne ceci

"psr-4": {
            "App\\": "app/",
            "Mrdebug\\Crudgen\\": "packages/mrdebug/crudgen/src"
}

Et faites un

composer dump-autoload

Dans le dossier racine de laravel.

Ensuite, nous devons créer un Service Provider pour indiquer à laravel quel controller, routes, views etc… utilisé.
Toujours à la racine faites un

php artisan make:provider CrudgenServiceProvider

Et on va déplacer ce fichier du dossier app/Providers dans notre dossier src du package
N’oubliez pas de changer le namespace du provider par Mrdebug\Crudgen

Allons ajouter ce nouveau provider. Retournez dans le dossier racine, allez dans le dossier config puis ouvrez app.php et ajoutez le dans le tableau providers :

Mrdebug\Crudgen\CrudgenServiceProvider::class,

Voila vous avez un package fonctionnel… mais pas très utile pour le moment 😀

Créer une commande permettant de générer un CRUD complet

Nous allons créer une commande donc on va faire comme pour le service provider, créer le fichier et le rapatrier dans le dossier du package :

php artisan make:console MakeCrud

On récupère notre fichier app/Console/MakeCrud.php créé et on le déplace dans le dossier src/Console du package que l’on crée pour l’occasion.
Et on oublie pas de modifier le namespace en Mrdebug\Crudgen\Console
Dans la méthode register du service provider crudgen, on va rajouter notre commande :

$this->commands(
            'Mrdebug\Crudgen\Console\MakeCrud'
        );

Pour tester que tout fonctionne bien, dans notre fichier console/Makecrud.php, modifiez le $signature qui sera notre nom de commande comme ceci :

protected $signature = 'make:crud';

dans la méthode handle, ajoutez :

echo "ok";

et dans la console tapez :

php artisan make:crud

Si vous avez bien le « ok » qui apparait dans la console, tout fonctionne bien et vous pouvez passer à la suite.

Comme vous pouvez vous en douter, tout le traitement se fera à partir d’ici.

Pour créer un CRUD complet, nous allons devoir créer un controller, un dossier pour les vues (avec comme page : index, create, edit et show), un fichier request pour gérer les erreurs, un modèle et enfin une migration pour créer la table.
Ça fait un peu de travail tout ça donc on boit un petit café et on est parti.

Tout d’abord, nous allons établir les conventions de nommage.
Un controller est au pluriel avec la première lettre en majuscule et est suivi par « Controller », ex : ArticlesController
Le dossier de views est en minuscules et au pluriel, ex : articles
Un request est au singulier avec la première lettre en majuscule et est suivi par « Request », ex : ArticleRequest
Un modèle est au singulier avec la première lettre en majuscule, ex : Article

Pour commencer, je propose de changer le format de la commande comme ceci :

protected $signature = 'make:crud {name_crud} {colonnes}';

Pour lancer la commande il faudra désormais faire comme ceci :

php artisan make:crud Articles "titre, contenu"

Articles est donc le nom du CRUD et titre, contenu sont les colonnes pour notre table articles.

Dans la méthode handle du fichier MakeCrud.php commençons par créer nos variables dans les différents formats nécessaires pour respecter les conventions :

public function handle()
{
    $name_crud = ucfirst($this->argument('name_crud'));
    $name_pluriel=str_plural($name_crud);
    $name_singulier=str_singular($name_crud);
    $name_singulier_minuscule=str_singular(strtolower($name_crud));
    $name_pluriel_minuscule=str_plural(strtolower($name_crud));
}

$this->argument permet de récupérer les paramètres de la commande, ici name_crud est le 1er argument (Articles).
str_plural() permet de mettre notre nom au pluriel et str_singular() au singulier.

Étape 1: créer un controller

Avant de réfléchir à plusieurs façons de faire, on peut se demander comment fait laravel pour créer un controller.
Alors tout se passe dans le fichier \laravel\framework\src\Illuminate\Routing\Console\ ControllerMakeCommand.php

return __DIR__.'/stubs/controller.stub';

et ce fichier contient (je supprime les commentaires) :

<?php

namespace DummyNamespace;

use Illuminate\Http\Request;

use DummyRootNamespaceHttp\Requests;
use DummyRootNamespaceHttp\Controllers\Controller;

class DummyClass extends Controller
{
    public function index()
    {
        //
    }

    public function create()
    {
        //
    }

    public function store(Request $request)
    {
        //
    }

    public function show($id)
    {
        //
    }

    public function edit($id)
    {
        //
    }

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

    public function destroy($id)
    {
        //
    }
}

On voit visiblement que laravel utilise des placeholders pour remplir le nom de ses controllers avec les vraies données et que ces placeholders commencent tous par Dummy.
Dans le fichier vendor\laravel\framework\src\Illuminate\Console\GeneratorCommand.php on peut voir que ces placeholders sont remplacés avec un str_replace :

$stub = str_replace(
            'DummyNamespace', $this->getNamespace($name), $stub
        );

On a assez d’infos pour faire ce que l’on souhaite.
Tout d’abord, dans notre dossier src du package, on va créer un dossier stubs pour stocker tous nos .stub. Et dans ce dossier, un fichier Controller.stub avec le contenu du .stub situé ci-dessus et on va ajouter 2 use :

use DummyRootNamespaceDummyModel;
use DummyRootNamespaceHttp\Requests\DummyModelRequest;

Le 1er permettra de charger notre Modèle et le 2e notre Request

Par exemple : DummyRootNamespace sera remplacé par App\ et DummyModel par Article
Pour la méthode index nous voulons afficher tous nos articles :

public function index()
{
    $articles= Article::all();
    return view('articles.index', ['articles'=>$articles]);
}

Si on traduit ça avec des placeholders on obtient :

public function index()
{
    DummyCreateVariable$= DummyModel::all();
    return view('DummyVariable.index', ['DummyVariable'=>DummyCreateVariable$]);
}

DummyCreateVariable$ permet de créer une variable au pluriel
DummyModel une variable respectant le format modèle

La méthode create :

public function create()
{
    return view('DummyVariable.create');
}

La méthode store :

public function store(ArticleRequest $request)
{
    $article = new Article;
    $article->titre=$request->input('titre') ;
    $article->save();

    return redirect()->route('articles.index');
}

2 particularités la variable est au singulier et on a un nouveau traitement

$article->titre=$request->input('titre') ;

Ce bloc sera remplacé par un placeholder :

public function store(DummyModelRequest $request)
{
    DummyCreateVariableSing$ = new DummyModel;
    DummyUpdate
        
    DummyCreateVariableSing$->save();

    return redirect()->route('DummyVariable.index');
}

La méthode show :

public function show($id)
{
    DummyCreateVariableSing$ = DummyModel::findOrFail($id);
    return view('DummyVariable.show',['DummyVariableSing'=>DummyCreateVariableSing$]);
}

La méthode edit :

public function edit($id)
{
    DummyCreateVariableSing$ = DummyModel::findOrFail($id);
    return view('DummyVariable.edit',['DummyVariableSing'=>DummyCreateVariableSing$]);    
}

La méthode update :

public function update(DummyModelRequest $request, $id)
{
    DummyCreateVariableSing$ = DummyModel::findOrFail($id);
    DummyUpdate
        
    DummyCreateVariableSing$->save();
    return redirect()->route('DummyVariable.index');
}

Et enfin la méthode destroy

public function destroy($id)
{
    DummyCreateVariableSing$ = DummyModel::findOrFail($id);

    DummyCreateVariableSing$->delete();
    return redirect()->route('DummyVariable.index');
}

Et voila le controller est construit, il ne manque plus qu’à remplacer les placeholders dans le traitement de la commande.
Nous allons créer une methode pour récupérer le path vers le dossier de nos stubs dans notre MakeCrud :

private function getStubPath()
{

    return __DIR__.'/../stubs';
}

De retour dans notre méthode handle, on récupère le contenu de notre fichier :

$controller_stub= File::get($this->getStubPath().'/Controller.stub');

Remplacons nos placeholders :

$controller_stub = str_replace('DummyClass', $name_pluriel.'Controller', $controller_stub);
$controller_stub = str_replace('DummyModel', $name_singulier, $controller_stub);
$controller_stub = str_replace('DummyVariableSing', $name_singulier_minuscule, $controller_stub);
$controller_stub = str_replace('DummyVariable', $name_pluriel_minuscule, $controller_stub);

Pour le DummyNamespace, créez une méthode :

protected function getDefaultNamespaceController($rootNamespace)
{
    return $rootNamespace.'Http\Controllers';
}

Et vous pouvez ajouter le remplacement des 2 derniers placeholders :

$controller_stub = str_replace('DummyNamespace', $this->getDefaultNamespaceController($this->laravel->getNamespace()), $controller_stub);
$controller_stub = str_replace('DummyRootNamespace', $this->laravel->getNamespace(), $controller_stub);

On va devoir récupérer nos différentes colonnes pour pouvoir les ajouter dans le placeholder de nos méthodes store et update :

$colonnes = $this->argument('colonnes');
if($colonnes=='')
    $colonnes=[];
else
    $colonnes=explode(',', $colonnes);
    
$cols='';

foreach ($colonnes as $colonne) 
{
    $cols.='DummyCreateVariableSing$->'.trim($colonne).'=$request->input(\''.trim($colonne).'\');'."\n\t";
}

On a généré notre DummyUpdate.

Voici nos 3 derniers placeholders manquants pour finir notre controller :

$controller_stub = str_replace('DummyUpdate', $cols, $controller_stub);
$controller_stub = str_replace('DummyCreateVariable$', '$'.$name_pluriel_minuscule, $controller_stub);
$controller_stub = str_replace('DummyCreateVariableSing$', '$'.$name_singulier_minuscule, $controller_stub);

Il ne reste plus qu’a créer notre controller dans le bon dossier et afficher sa création dans la console :

if(!File::exists($this->getRealpathBase('app/Http/Controllers').'/'.$name_pluriel.'Controller.php'))
{
    File::put($this->getRealpathBase('app/Http/Controllers').'/'.$name_pluriel.'Controller.php', $controller_stub);
    $this->line("<info>Created Controller:</info> $name_pluriel");
    
}
else
    $this->error('Controller '.$name_pluriel.' already exists');

Il nous faut aussi la méthode pour recuperer le bon path :

protected function getRealpathBase($directory)
{
    return realpath(base_path($directory));
}

Le partie générant le controller est désormais terminée, on passe à la création des vues.

Etape 2 les vues

Tout d’abord il faut créer le dossier des vues et puis nous créerons des stubs pour ces différentes vues et enfin nous sauvegarderons ces vues générées dans le dossier adéquat (resources/views).

Création du dossier :

$dossierview=$name_pluriel_minuscule;
if (!File::isDirectory($this->getRealpathBase('resources/views').'/'.$dossierview))
{
    File::makeDirectory($this->getRealpathBase('resources/views').'/'.$dossierview, 0755, true);
    $this->line("<info>Created views directory:</info> $dossierview");
    
}
else
    $this->error('Views directory '.$dossierview.' already exists');

Une fois le dossier de vues crée, il faut créer les vues (index, create, edit et show).
Notre page index sera un tableau récapitulatif avec tous les champs et les boutons de modération classiques (voir, editer, supprimer).
Dans le dossier stubs de notre package, créons un fichier index.stub avec ce contenu :

@extends('default')

@section('content')

<div class="pull-right"><a href="{{ route('DummyVariable.create') }}" class="btn btn-info">Creer</a></div>

<table class="table table-bordered">
    <thead>
        <tr>
            <th>id</th>
            DummyHeaderTable
            <th>Action</th>
        </tr>
    </thead>
    <tbody>
        @foreach(DummyCreateVariable$ as DummyCreateVariableSing$)

            <tr>
                <td>{{ DummyCreateVariableSing$->id }}</td>
                DummyIndexTable
                <td>
                    <a href="{{ route('DummyVariable.show', [DummyCreateVariableSing$->id]) }}" class="btn btn-info">Voir</a>
                    <a href="{{ route('DummyVariable.edit', [DummyCreateVariableSing$->id]) }}" class="btn btn-primary">Editer</a>
                    {!! Form::open(['method' => 'DELETE','route' => ['DummyVariable.destroy', DummyCreateVariableSing$->id]]) !!}
                    {!! Form::submit('Supprimer', ['class' => 'btn btn-danger']) !!}
                {!! Form::close() !!}
                </td>
            </tr>

        @endforeach
    </tbody>
</table>

@stop

@extends(‘default’) signifie que cette page « hérite » du template default. Dans le dossier resources/views, créez un fichier default.blade.php avec ce contenu (on inclue le minimum d’une page html et on ajoute bootstrap pour avoir un rendu css déjà fait :

<!DOCTYPE html>
<html>
<head>
    <link rel="stylesheet" href="https://maxcdn.bootstrapcdn.com/bootstrap/3.3.6/css/bootstrap.min.css">
</head>
<body>
    <div class="container">@yield('content')</div>
</body>
</html>

Si vous avez du mal avec ce templating, je vous renvoie sur la doc blade de laravel.

Pour la page create.stub, on va afficher un formulaire pour créer un article :

@extends('default')

@section('content')

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

{!! Form::open(['route' => 'DummyVariable.store']) !!}

    DummyFormCreate

    {{ Form::submit('Creer', array('class' => 'btn btn-primary')) }}

{{ Form::close() }}


@stop

Pour la page edit.stub, un formulaire aussi mais pour éditer cette fois-ci :

@extends('default')

@section('content')

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

{{ Form::model(DummyCreateVariableSing$, array('route' => array('DummyVariable.update', DummyCreateVariableSing$->id), 'method' => 'PUT')) }}

    DummyFormCreate
    {{ Form::submit('Editer', array('class' => 'btn btn-primary')) }}

{{ Form::close() }}
@stop

Et enfin la page show.stub, on affiche juste l’id :

@extends('default')

@section('content')

    {{ DummyCreateVariableSing$->id }}

@stop

Comme pour le controller il va falloir remplacer nos placeholders commencant par Dummy par ce qu’on souhaite (page index) :

$index_stub= File::get($this->getStubPath().'/index.stub');
$index_stub = str_replace('DummyCreateVariable$', '$'.$name_pluriel_minuscule, $index_stub);
$index_stub = str_replace('DummyCreateVariableSing$', '$'.$name_singulier_minuscule, $index_stub);

Pour le DummyHeaderTable et le DummyIndexTable, nous allons avoir besoin de recuperer nos colonnes :

$cols=$th_index=$index_view='';
foreach ($colonnes as $colonne) 
{
	//traitement precedent
	$th_index .="<th>".trim($colonne)."</th>\n\t\t\t";
	$index_view .="<td>{{ DummyCreateVariableSing$->".trim($colonne)." }}</td>\n\t\t\t\t";
}

Puis nous pouvons reprendre nos remplacements :

$index_stub = str_replace('DummyHeaderTable', $th_index, $index_stub);
$index_stub = str_replace('DummyIndexTable', $index_view, $index_stub);
$index_stub = str_replace('DummyCreateVariableSing$', '$'.$name_singulier_minuscule, $index_stub);
$index_stub = str_replace('DummyVariable', $name_pluriel_minuscule, $index_stub);

Puis on crée la page index.blade.php dans notre dossier resources/view/articles :

if(!File::exists($this->getRealpathBase('resources/views/'.$dossierview).'/index.blade.php'))
{
    File::put($this->getRealpathBase('resources/views/'.$dossierview).'/index.blade.php', $index_stub);
    $this->line("<info>Created View:</info> index.blade.php");
}
else
    $this->error('View index.blade.php already exists');

Pour la page create :

$create_stub= File::get($this->getStubPath().'/create.stub');
$create_stub = str_replace('DummyVariable', $name_pluriel_minuscule, $create_stub);

Pour le DummyFormCreate, on va avoir besoin de nos colonnes, on ne va pas se prendre la tête, on crée un champ texte normal pour tous les champs :

$cols=$th_index=$index_view=$form_create='';
foreach ($colonnes as $colonne) 
{
	//traitement precedent
	$form_create .=
	    '
	        <div class="form-group">
	            {{ Form::label(\''.trim($colonne).'\', \''.ucfirst(trim($colonne)).'\') }}
	            {{ Form::text(\''.trim($colonne).'\', null, array(\'class\' => \'form-control\')) }}
	        </div>
	    ';
}

Puis on reprend nos remplacements et on crée la vue :

$create_stub = str_replace('DummyFormCreate', $form_create, $create_stub);
if(!File::exists($this->getRealpathBase('resources/views/'.$dossierview).'/create.blade.php'))
{
    File::put($this->getRealpathBase('resources/views/'.$dossierview).'/create.blade.php', $create_stub);
    $this->line("<info>Created View:</info> create.blade.php");
}
else
    $this->error('View create.blade.php already exists');

Pour la page show :

$show_stub= File::get($this->getStubPath().'/show.stub');
$show_stub = str_replace('DummyCreateVariableSing$', '$'.$name_singulier_minuscule, $show_stub);
if(!File::exists($this->getRealpathBase('resources/views/'.$dossierview).'/show.blade.php'))
{
    File::put($this->getRealpathBase('resources/views/'.$dossierview).'/show.blade.php', $show_stub);
    $this->line("<info>Created View:</info> show.blade.php");
}
else
    $this->error('View show.blade.php already exists');

Et enfin pour la page edit :

$edit_stub= File::get($this->getStubPath().'/edit.stub');
$edit_stub = str_replace('DummyCreateVariableSing$', '$'.$name_singulier_minuscule, $edit_stub);
$edit_stub = str_replace('DummyVariable', $name_pluriel_minuscule, $edit_stub);
$edit_stub = str_replace('DummyFormCreate', $form_create, $edit_stub);
if(!File::exists($this->getRealpathBase('resources/views/'.$dossierview).'/edit.blade.php'))
{
    File::put($this->getRealpathBase('resources/views/'.$dossierview).'/edit.blade.php', $edit_stub);
    $this->line("<info>Created View:</info> edit.blade.php");
}
else
    $this->error('View edit.blade.php already exists');

Etape 3 le request

Avec laravel, vous pouvez soit valider vos données via le controller ($this->validate) mais vous pouvez aussi créer un « form request » (une classe custom qui contient la logique de validation).
Personnellement, je trouve « plus propre » de séparer la logique de validation du controller.

Dans le dossier stubs, créez un fichier Request.stub avec ce contenu :

<?php

namespace DummyNamespace;

use DummyRootNamespaceHttp\Requests\Request;

class DummyClass extends Request
{
    /**
     * Determine if the user is authorized to make this request.
     *
     * @return bool
     */
    public function authorize()
    {
        return true;
    }

    /**
     * Get the validation rules that apply to the request.
     *
     * @return array
     */
    public function rules()
    {
        return 
        [
            DummyRulesRequest
        ];
    }
}

Comme vous en doutez, on va remplacer nos Dummy et on va créer notre request dans le bon dossier:

$request_stub= File::get($this->getStubPath().'/Request.stub');
$request_stub = str_replace('DummyNamespace', $this->getDefaultNamespaceRequest($this->laravel->getNamespace()), $request_stub);
$request_stub = str_replace('DummyRootNamespace', $this->laravel->getNamespace(), $request_stub);    
$request_stub = str_replace('DummyRulesRequest', $rules, $request_stub);
$request_stub = str_replace('DummyClass', $name_singulier.'Request', $request_stub);
if(!File::exists($this->getRealpathBase('app/Http/Requests').'/'.$name_singulier.'Request.php'))
{
    File::put($this->getRealpathBase('app/Http/Requests').'/'.$name_singulier.'Request.php', $request_stub);
    $this->line("<info>Created Request:</info> $name_singulier");
}
else
    $this->error('Request ' .$name_singulier. ' already exists');

Et on va créer notre methode pour récupérer le namespace des requests

protected function getDefaultNamespaceRequest($rootNamespace)
{
    return $rootNamespace.'Http\Requests';
}

Et on va créer notre $rules, on ne se casse pas la tête, on met tous les champs en requis :

$cols=$th_index=$index_view=$form_create=$rules='';

foreach ($colonnes as $colonne) 
{
	//traitement precedent
	$rules .="'".trim($colonne)."'=>'"."required',\n\t\t";

}

Etape 4 le modèle

Pour le modele, on va faire ça simplement, on va appeler la commande qui crée 1 modèle de base :

$this->call('make:model', ['name' => $name_singulier]);

Etape 5 la migration

La migration permet de modifier/partager facilement votre schéma de base de données.

On va créer une migration pour notre package avec les champs indiqués.

Dans le dossier stubs, on va créer un fichier migration.stub avec ce contenu :

<?php

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

class DummyClass extends Migration
{
    /**
     * Run the migrations.
     *
     * @return void
     */
    public function up()
    {
        Schema::create('DummyTable', function (Blueprint $table) {
            $table->increments('id');
            DummyFields
            $table->timestamps();
        });
    }

    /**
     * Reverse the migrations.
     *
     * @return void
     */
    public function down()
    {
        Schema::drop('DummyTable');
    }
}

On va remplacer nos Dummy :

$migration_stub= File::get($this->getStubPath().'/migration.stub');
$table=str_plural(snake_case($name_crud));
$migration_stub= str_replace('DummyTable', $table, $migration_stub);
$migration_stub= str_replace('DummyClass', studly_case('create_' . $table . '_table'), $migration_stub);
$migration_stub= str_replace('DummyFields', $fields_migration, $migration_stub);
$date = date('Y_m_d_His');

File::put(database_path('/migrations/') . $date . '_create_' . $table . '_table.php', $migration_stub);

Créons la variable $fields_migration en mettant nos champs comme chaine de caractères (string) :

$cols=$th_index=$index_view=$form_create=$rules=$fields_migration='';
foreach ($colonnes as $colonne) 
{
	//traitement precedent

	$fields_migration .='$table'."->string('".trim($colonne)."');\n";
}

Voila le plus gros est fini 🙂
Il ne reste plus qu’à lancer la commande :

php artisan make:crud Article "titre, contenu"

Si tout se passe bien vous devriez avoir ceci:

Dans le fichier app/http/routes.php il vous suffit de rajouter cette ligne :

Route::resource('articles', 'ArticlesController');

Rendez-vous désormais sur votre site /articles

Si vous avez l’erreur : Access denied for user ‘homestead’@’localhost’
Configurez correctement votre fichier .env

Si vous avez l’erreur : Table ‘laravel_test.articles’
C’est normal, vous devez lancer la migration, alors soit 2 solutions :
Soit tous les champs en varchar vous suffisent et vous pouvez lancer la migration avec

php artisan migrate

Soit vous souhaitez modifier la migration et corrigez le fichier database/migrations/…create_articles_table

Je vais modifier $table->string(‘contenu’); en $table->text(‘contenu’);
Et lancer la commande de migration :

php artisan migrate

Vous avez désormais une page avec un tableau vide, cliquez sur le bouton créer en haut a droite.
Si vous avez cette erreur Undefined variable: errors
Deplacez votre route dans le middleware web de votre fichier app/http/routes.php.

Si vous avez l’erreur Class ‘Form’ not found
Il vous manque le package pour créer les forms.

Lancez la commande :

composer require laravelcollective/html

Une fois installé, dans config/app.php, rajoutez le provider :

'providers' => [
    // ...
    Collective\Html\HtmlServiceProvider::class,
    // ...
  ],

Et 2 alias :

'aliases' => [
    // ...
      'Form' => Collective\Html\FormFacade::class,
      'Html' => Collective\Html\HtmlFacade::class,
    // ...
  ],

Dans le fichier resources/views/articles/create.blade.php et edit.blade.php, vous pouvez modifier le 2ème champ en textarea.

Voici votre rendu final:

Page create:

Page index:

Page edit:

Et la gestion des erreurs est fonctionnelle:

Mission accomplie vous avez votre crud complet, généré entièrement avec les vues, le controller, la gestion d’erreur, le modèle et même la migration.

Voici le repo bitbucket où toutes les sources sont dispo : https://bitbucket.org/mrdebug/crudgen

En amélioration, on pourrait préciser le type de champ que l’on souhaite dans la commande et rajouter quels champs sont requis. L’appel de la commande pour être comme ceci:

php artisan make:crud Articles "titre:string, contenu:text" "titre, contenu"

On pourrait aussi créer un fichier Request spécialement pour l’update (pour les cas où les champs requis ne sont pas les mêmes lors de la création et de la mise à jour), il faudra aussi adapter les vues create et edit en fonction.

Si vous avez apprécié cet article, n’hésitez pas à le partager sur les réseaux sociaux et/ou de laisser un commentaire ci dessous.

Bon dev à vous 😉

28 mars 2016
john
5

A propos de l'auteur

Jonathan Escarem, développeur web freelance. Me contacter

5 réflexions au sujet de « Créer un crud complet avec laravel 5 »

Temps approximatif pour la lecture des commentaires : 2 mins

f4b1 Le 19 avril 2017 à 8 h 54 min | Répondre

Merci pour ce tutoriel, j’ai pu aller très vite et après quelques ajustements, c’était parfait !
- john Le 25 novembre 2020 à 1 h 57 min | Répondre
  
  top c’était le but 🙂
abdoul kader Le 7 septembre 2017 à 9 h 48 min | Répondre

Bonjour
Je voudrai savoir si la commande PHP artisan make:console existe en laravel 5.3
- john Le 25 novembre 2020 à 1 h 59 min | Répondre
  
  En laravel c’est make:console mais oui elle existe 🙂

josselin Le 2 août 2018 à 21 h 29 min | Répondre

resalutation

jai oublier de préciser tourne sur laragon/laravel 5 et php 7.2

2me erreur constater :

function store et update de ArticlesController:class remplacer

 
use Illuminate\Support\Facades\Input;
 //
	$article->titre=$request->input('titre');
        $article->contenu=$request->input('contenu');

par

 
   $article->titre=Input::get('titre');
        $article->contenu=Input::get('contenu');

Créer un crud complet avec laravel 5

Installation de Laravel 5

Création d’un custom package

Créer une commande permettant de générer un CRUD complet

Étape 1: créer un controller

Etape 2 les vues

Etape 3 le request

Etape 4 le modèle

Etape 5 la migration

A propos de l'auteur

5 réflexions au sujet de « Créer un crud complet avec laravel 5 »

Laisser un commentaire Annuler la réponse

Besoin d’un prestataire?

Commentaires récents

Twitter

Catégories

Top Articles

A propos

Créer un crud complet avec laravel 5

Installation de Laravel 5

Création d’un custom package

Créer une commande permettant de générer un CRUD complet

Étape 1: créer un controller

Etape 2 les vues

Etape 3 le request

Etape 4 le modèle

Etape 5 la migration

A propos de l'auteur

5 réflexions au sujet de « Créer un crud complet avec laravel 5 »

Laisser un commentaire Annuler la réponse

Besoin d’un prestataire?

Commentaires récents

Twitter

Catégories

Top Articles

Comment tricher à Candy Crush facilement (43 commentaires)

Script upload avec progressbar en php 5.4 et utilisation de session.upload_progress (39 commentaires)

Mini PopUp, un plugin wordpress pour afficher une fenêtre modale facilement (8 commentaires)

Créer un crud complet avec laravel 5 (5 commentaires)

Afficher un extrait d’un article sans couper de mots (2 commentaires)

A propos