[LARAVEL] Mon premier projet en Laravel

mardi 23 janvier 2018

Dans le cadre d’un nouveau projet, j’ai décidé de m’attaquer à un nouveau framework php qui a le vent en poupe pour l’instant: LARAVEL
Je vais donc vous décrire ici comment j’ai mis en place ce projet et toutes les fonctionnalités du framework que j’ai trouvé fort intéressantes et utiles dans le cadre de mon projet.

Avant toute chose et comme la plupart des projets php maintenant, il est nécessaire d’avoir composer installé sur votre serveur.

Création d’un nouveau projet

Il est même possible de créer son projet Laravel avec composer via la commande suivante:

composer create-project --prefer-dist laravel/laravel project_name "5.4.*"

Il est aussi possible de définir la version de laravel que vous souhaitez installé.
Dans mon cas, j’ai choisit la version 5.4 qui n’est pas la dernière actuellement car mon serveur de production ne tourne pas encore en php7 du coup j’ai pris la dernière version de Laravel qui supporte encore php5.6.x

Pour connaitre la version de notre laravel:

php artisan --version

Création et configuration de la base de donnée pour le projet

Ci dessous vous trouverez les requêtes à faire dans mysql pour créer votre utilisateur pour l’application et la création de la database.

CREATE USER 'username'@'localhost' IDENTIFIED BY 'password';
CREATE DATABASE dbname;
GRANT ALL ON dbname.* TO username@'localhost';

N’oubliez pas de remplacer localhost par % si vous souhaitez qu’on puisse se connecter depuis l’extérieur avec le user « username ».

ENV

Ensuite, il vous reste à compléter le fichier .env sur la racine de votre projet pour rentrer les informations nécessaire à l’application de se connecter à la db.

Ce fichier .env comporte toutes les variables d’environnements à définir sur chaque serveur.
Vous y retrouver les définitions de variables de votre application pour qu’elle se connecte à la base de donnée, sache si on est en local ou en production pour activer ou non le mode debug par exmeple, ou encore les chemins utiles à l’application.

Vous pouvez rajouter des variables d’environnements dans ce fichier et avoir accès depuis votre code php via l’instruction suivante:

$folder= env('AWS_FOLDER');

Artisan

Laravel fourni aussi un utilitaire appelé artisan qui permet d’exécuter plusieurs commandes en ligne depuis le terminal pour faciliter votre développement dans Laravel.

Par exemple pour mettre le site en maintenance:

php artisan down

Et pour le remettre en ligne:

php artisan up

Tout au long de ce tutoriel vous trouverez plein de commande utile pour la gestion de mon projet avec artisan.

Migration

La migration est un outil fournit par laravel pour permettre de créer des scripts qui vont créer la structure de chaque table (db) de notre projet.
Avec cet outil, on va pouvoir créer les tables et aussi créer des script d’update (alter) de la structure des tables.

Voici la commande de création de script:

php artisan make:migration add_votes_to_users_table --table=users

Il va donc générer un fichier script dans le répertoire database/migrations dans lequel vous allez pouvoir en php créer/modifier/supprimer la structure de votre base de donnée. Par contre, pour la création de votre table je conseille de créer le script depuis la commande qui créera le modèle correspondant (voir section Model du tutoriel). Car Laravel comporte aussi un ORM qui permet de gérer automatiquement le lien entre nos modèles et la base de donnée.

Voici un exemple de script:

class AddVotesToUsers extends Migration
{
    /**
     * Run the migrations.
     *
     * @return void
     */
    public function up()
    {
        Schema::table('users', function (Blueprint $table) {
            $table->integer('vote')->default(0);
        });
    }

    /**
     * Reverse the migrations.
     *
     * @return void
     */
    public function down()
    {
        Schema::table('users', function (Blueprint $table) {
            //
        });
    }
}

Une fois que votre script est prêt, il ne reste plus qu’a l’exécuter au travers de la commande:

php artisan migrate

Attention: une table nommée migrations sera aussi créée et utilisée pour que Laravel sache à quel batch on se trouve pour ne pas exécuter à chaque fois tous les scripts.
Donc il faut voir le système de migration comme une suite de script de mise à jour de la base de donnée.

Seed

Cet outil de Laravel permet quand à lui d’alimenter les tables que vous avez précédemment créer avec vos scripts de migration.
Très utile par exemple, pour créer déjà vos comptes utilisateurs par défaut de votre application.

On créé une classe UserSeed pour alimenter la table Users

php artisan make:seeder UsersTableSeeder

Cette commande va donc créer la classe UsersTableSeeder dans database/seeds, qu’on va éditer comme suit:

class UsersTableSeeder extends Seeder
{
    /**
     * Run the database seeds.
     *
     * @return void
     */
    public function run()
    {
        DB::table('users')->delete();
        DB::table('users')->insert([
            'name'     => 'Lastname Firstname',
            'username' => 'username',
            'email'    => 'test@test.net',
            'admin'    => 1,
            'password' => Hash::make('password'),
            "created_at" =>  \Carbon\Carbon::now(),
            "updated_at" => \Carbon\Carbon::now(), 
        ]);
    }
}

Voici la commande pour alimenter la table Users

php artisan db:seed --class=UsersTableSeeder

ou pour lancer tous les seeds:

php artisan db:seed

Si jamais vous obtenez un message d’erreur comme quoi la classe « Seeder » n’existe pas mais elle est quand même présente dans votre projet, il faut demander à composer de rafraichir la liste des classes qu’il charge:

composer dump-autoload

AUTH

Laravel nous fournit tout un module de gestion d’authentification (controllers/middelware/routes/views) appelé Auth.

Il va créer par défaut un controller home qui ne sera accessible que si on est identifié.
Il créé aussi les routes d’Authentifications ainsi que la route pour le controller home. Il créé aussi une vue pour la page de login et la page de register pour enregistrer de nouveaux users.
Bien sûr, si vous modifié la table Users ne pas oublié de mettre à jour les controllers et vues de ce module.

Voici la ligne de commande pour mettre en place ce module

php artisan make:auth

Routes

Cet outil permet de centraliser au même endroit toutes les chemins de votre application / api. Dans deux fichiers distincts:

  • /routes/web.php => définit les routes qui correspondent à votre interface Web. Ces routes sont affectées au groupe de middleware Web, qui fournit des fonctionnalités telles que l’état de session et la protection CSRF.
  • /routes/api.php => définit les routes pour les webservices.

Pour chaque route, on peut définir les controllers utiliser pour chaque route ainsi que les middelwares qui est du code appelé avant d’effectuer le routage.

Par exemple le module Auth utilise le middelware Auth pour vérifier l’identification avant d’accéder à la page:

Route::get('/live','LiveController@show')->middleware('auth');

Ici, quand l’utilisateur se dirige vers /live le middelware auth se chargera de vérifier si l’utilisateur est logué et si c’est le cas il est redirigé vers le controller LiveController. Dans le cas contraire, une demande d’authentification sera nécessaire pour aller plus loin.

Voici une commande très utile pour voir la liste de toutes les routes définies dans votre projet:

php artisan route:list

Middleware

Comme dit précédemment cette technique consiste a exécuter du code avant ou après une requête demandé par le client, avant même d’arriver au controller et donc effectuer le routage.

Pour créer un middelware:

php artisan make:middleware IsAdminUser

Ici, je souhaite créér un middleware pour savoir si l’utilisateur est de type admin pour avoir accès à certaines section du site privées, par exemple pour pouvoir créer de nouveaux utilisateurs.
Il va donc générer un fichier dans app/Http/MiddleWare.

    public function handle($request, Closure $next)
    {
        if (Auth::user() &&  Auth::user()->admin == 1) {
            return $next($request);
        }
        return redirect('/');
    }

Une fois la classe du Middleware créée, il faut aussi rajouter le chemin de cette classe dans la propriété $routeMiddleware du fichier app/Http/Kernel.php pour être reconnu par le système.

protected $routeMiddleware = [
'isadmin.user' => \App\Http\Middleware\IsAdminUser::class,....
];

Controllers

Pour rappel, les controllers se chargent de tout le code à exécuter avant d’afficher les informations à la vue.

On encode tous les controllers dans le dossier app/Http/Controllers via la commande:

php artisan make:controller UserController

Views

Les vues se chargent de toute ce qui est présentation des informations de votre site internet ou api.
Elle se retrouve dans le dossier /ressources/views et utilise le système de theming blade.
Il n’y a pas de ligne de commande pour générer ces fichiers via artisan, il suffit juste de créer des fichiers blade.php dans le dossier ressources.Il est possible de créer sa propre arborescence dans le dossier ressource et mettre un . de séparation pour les chemins d’accès vers ces vues.

Par exemple, pour accéder à la vue dans /ressources/views/home/live.blade.php

@include('home.live')

Concernant les fichiers js/css/img nécessaire dans vos template blade, il faut les mettres dans votre dossier public/js,public/css,public/img.

Pour avoir accès à la base url dans votre template blade utiliser la fonction url:

<p><a href="{{ url('/') }}">Home</a></p>

Model

Un Modèle contient le code Business de votre projet et ce qui est en relation avec vos tables si nécessaire.
Pour créer une classe modèle avec un script de migration db

php artisan make:model Media -m

Il va donc créer une classe modèle dans le folder app/, ainsi qu’un script de création de table dans le folder migration

Voici un exemple de script de création de table pour l’objet ORM Media

    public function up()
    {
        Schema::create('media', function (Blueprint $table) {
            $table->increments('id');
            $table->string('original_filename',100);
            $table->string('filename',100);
            $table->string('path',255);
            $table->integer('user_id')->unsigned();
            $table->foreign('user_id')->references('id')->on('users');
            $table->string('size',255);
            $table->string('mime',50);
            $table->timestamps();
        });
    }

Eloquent

Est l’outil ORM de Laravel permettant donc la liaison entre vos models eloquent et la base de donnée. Cette fonctionnalité permet d’interagir avec vos modèles et votre base de donnée avec beaucoup plus de facilité. Pour créer par exemple un record en db, il suffit de faire un new du model de compléter les propriétés du model et d’ensuite de faire appel à la méthode save() pour sauver l’objet en base de donnée. De plus, eloquent fournit aussi un nouveau type du language php collect qui donne une flopée de fonction et manipulation à pouvoir faire sure ce type de variable.

Laravel propose aussi un nouveau type « collect » fortement utilisé quand on retourne une liste après une query.
Ce type d’objet permet aussi des fonctions fort intéressantes comme par exemple la fonction map qui permet de modifier tous les enregistrements de notre collections.

            $schedulelists = ScheduleList::whereIn('id', $schedules_id->toArray())->get();
            $schedulelistids = $schedulelists->map(function($schedulelist){
                return $schedulelist->id;
            });

Et donc la collection avec le map ne retournera que les ids de la requête.

Pour plus d’info: cliquez ici

Session

Pour sauver une variable en session:

Session::put('step', 'live');

Pour récupérer un objet en session:

Session::get('step')

Pour afficher une variable de type session dans une vue :

@if(Session::get('step') == "live")

Form

Laravel met aussi à disposition une gestion de vos formulaires via des instructions.

Pour utliser les composants form de Laravel, il faut installer d’abord le package via composer:

composer require "laravelcollective/html":"^5.4.0"

Esnuite, on ajoute le provider et les aliases dans /config/app

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

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

Voici un exemple pour créer un champs texte dans votre vue

{{ Form::text('duration_'.$nbstep,$cuestep->duration, array('class' => 'time','required' => '', 'autofocus' => ''))}}

Bien sur le controller doit retourner les variables présente dans le composant.

Pour plus d’info: cliquez ici

MVC

Dans les routes on définit les controllers qui s’appliquent sur chaque route et aussi le middleware si nécessaire

Par exemple

Route::get('/cuelists','CueListsController@show')->middleware('auth');
Route::post('/cuelists/manage', 'CueListsController@change')->middleware('auth');

Ensuite dans chaque controller on retourne la vue

public function show() {
	$this->cuelistsName = array("test1","test2");
        Session::put('step', 'cuelists');
        return view('home')->with("cuelist",$this->cuelistsName);
}

On peut aussi passé les paramètres de nos models / controllers vers la vue avec la fonction ->with.

Service Provider

Les classes de type Service Provider permettent de lancer du code au démarrage de votre application ou d’enregistrer des nouvelles dépendances.

Voici la commande de création de classe de type Service Provider:

php artisan make:provider nameProvider

Cette classe sera créé dans le dossier app/Providers

Pour que cette classe soit utilisée au démarrage de votre application il faut assi rajouter le lien vers cette classe dans la propriété providers du fichier config/app.php

Voici un tour d’horizon de Laravel.

Be Sociable, Share!

Tags: framework , Laravel , PHP