Publié le

Internationalisation sous Laravel 5

Il est relativement facile de créer un site multilingue sous Laravel 5.4. La solution que je vous propose en terme d’internationalisation n’est pas la seule, mais elle conviendra à la plupart. Pour mettre en place la localization, il est comme vous allez le voir pas nécessaire de modifier beaucoup de fichiers. Notre but est de gérer les choix, faire un choix de langue par défaut et afficher la possibilité de choisir la langue.

Nous commençons par définir la langue par défaut et les langues disponibles dans le fichier config.app. Nous définissons ici que la langue par défaut est le français.

'locale' => 'fr',
    'languages' => [
    'fr' => 'Français',
    'de' => 'Deutsch',
    'en' => 'English'
    ],  

    'fallback_locale' => 'fr',

Lorsque l’on modifie le fichier config/app.php, il faut exécuter la commande suivante pour que les système prenne en compte les changement:
php artisan cache:clear

Nous créons ensuite un Middleware qui permettra de toujours avoir une langue définie. Nous créons donc le fichier app\Http\Middleware\Language.php

<?php


namespace App\Http\Middleware;

use Closure;
use Illuminate\Foundation\Application;
use Illuminate\Http\Request;
use Illuminate\Support\Facades\App;
use Illuminate\Support\Facades\Config;
use Illuminate\Support\Facades\Session;

class Language
{
    public function handle($request, Closure $next)
    {     
        $segment_1 = $request->segment(1);

        $arr_languages = config('app.languages');
        //la page d'accueil sans choix de langue
        if(is_null($segment_1) && is_null(Session::get('applocale')) ){
            //Comme aucune langue n'est definie on prend celle par défault
            $fallback_locale = config('app.fallback_locale');
            Session::put('applocale', $fallback_locale);   
            Session::put('lang_name', $arr_languages[$fallback_locale]);
        }
        //Le segment correspond a une des langues que l'on a                    
        if(isset($arr_languages[$segment_1])){
            //Si la langue de l'url n'est pas celle de la session, on la change
            if($segment_1 !=Session::get('applocale')){
                Session::put('applocale', $segment_1);   
                Session::put('lang_name', $arr_languages[$segment_1]); 
            } 
        }   
        //si c'est la home, on redirige avec la langue a la fin
        if(is_null($segment_1)){
              return redirect(url('/')."/".Session::get('applocale')."/"); 
        }
        //On set la langue pour les fichier de trad
        App::setLocale(Session::get('applocale'));
        
        return $next($request);
    }
}

Nous modifions ensuite le fichier app\Http\Kernel.php pour ajouter notre middleware à la fin:

protected $middlewareGroups = [
	'web' => [
		...
		\App\Http\Middleware\Language::class,
	],
];

Nous créons la route qui gère les langues de la page d’accueil dans le fichier routes/web.php

Route::get('/{lang?}', function () {
    return view('welcome');
})->where('lang', implode('|', array_flip(config('app.languages'))));

Nous créons ensuite la zone qui permet à l’utilisateur de changer la langue en modifiant le fichier welcome.

@if (Route::has('login'))
<div class="top-right links">
<a href="{ { url('/login') } }">Login</a>
<a href="{ { url('/register') } }">Register</a> 
 
 @foreach ( config('app.languages') as $local_code => $local_string)
 @if($local_string !== config('app.lang_name'))
<?php
 $style = 'padding:0';
 if ($local_code == session('applocale')){
 $style = 'padding:0;border-bottom:2px solid red;';
 }
 ?>
<a style='<?php echo $style;?>' href="{!! url('/') !!}/{ { $local_code } }/"><img width="32" height="22" alt="{ { $local_string } }" title="{ { $local_string } }" src="{!! asset('img/' . $local_code . '-flag.png') !!}"></a>
 @endif
 @endforeach

Et finalement nous créons nos fichiers de langue dans le répertoire resources/ lang. Dans mon cas je vais créer de/customlang.php,fr/customlang.php, en/customlang.php, … qui contiendront le tableau de mes traductions sous la forme suivant:

 return [
 'test' => 'Es klappt',
];

Pour afficher mes traduction il me suffira d’écrire les ligne suivantes (nom_du_fichier.indice_du_tableau):

{{ trans('customlang.test') }} //avec blade
@lang('customlang.test')  //avec blade

Il faudra maintenant tenir compte de la langue dans le fichier de routage. Vous pouvez le faire de la façon suivante:

Route::get('{lang}/contact', 'Frontend\ContactController@index');

Comme nous utilisons les sessions Laravel, il est utile de savoir que vous pouvez supprimer toutes les sessions en supprimant tous les fichiers présent dans storage/framework/sessions/

Publié le

Fonction globales et helpers

Il y a de nombreuses solutions pour créer des helpers sous Laravel. Je vous propose donc une solution qui me convient. La première étape consiste à créer un fichier dans un nouveau dossier sous app/ Helpers/ BackendHelper.php. Dans mon exemple que vais écrire une fonction qui me génère une string en minuscule propre en enlevant les caractères accentués les plus probables pour moi. Je pourrai ensuite l’utiliser pour générer des urls.

namespace App\Helpers;

class BackendHelper
{
 public static function convertToUrl(string $string)
 {
    $unwanted_array = array( 'Š'=>'S', 'š'=>'s', 'Ž'=>'Z', 'ž'=>'z', 'À'=>'A', 
      'Á'=>'A', 'Â'=>'A', 'Ã'=>'A', 'Ä'=>'A', 'Å'=>'A', 'Æ'=>'A', 'Ç'=>'C', 'È'=>'E', 
      'É'=>'E','Ê'=>'E', 'Ë'=>'E', 'Ì'=>'I', 'Í'=>'I', 'Î'=>'I', 'Ï'=>'I', 'Ñ'=>'N', 
      'Ò'=>'O', 'Ó'=>'O', 'Ô'=>'O', 'Õ'=>'O', 'Ö'=>'O', 'Ø'=>'O', 'Ù'=>'U','Ú'=>'U', 
      'Û'=>'U', 'Ü'=>'U', 'Ý'=>'Y', 'Þ'=>'B', 'ß'=>'Ss', 'à'=>'a', 'á'=>'a', 'â'=>'a', 
      'ã'=>'a', 'ä'=>'a', 'å'=>'a', 'æ'=>'a', 'ç'=>'c','è'=>'e', 'é'=>'e', 'ê'=>'e', 
      'ë'=>'e', 'ì'=>'i', 'í'=>'i', 'î'=>'i', 'ï'=>'i', 'ð'=>'o', 'ñ'=>'n', 'ò'=>'o', 
      'ó'=>'o', 'ô'=>'o', 'õ'=>'o','ö'=>'o', 'ø'=>'o', 'ù'=>'u', 'ú'=>'u', 'û'=>'u', 
      'ý'=>'y', 'þ'=>'b', 'ÿ'=>'y','G'=>'G', 'I'=>'I', 'S'=>'S', 'g'=>'g', 'i'=>'i', 
      's'=>'s', 'ü'=>'u','a'=>'a', 'A'=>'A', '?'=>'s', '?'=>'S', '?'=>'t', '?'=>'T' );
    
   $string = strtr( $string, $unwanted_array );
    return htmlentities(strtolower($string));
 }
}

J’ajoute ensuite un alias dans le fichier config/app.php

...
'aliases' => [
    ...
    'BackendHelper' => App\Helpers\BackendHelper::class,
 ],

Maintenant que tout est en place, pour l’utiliser dans une vue avec blade ou en php j’utilise les lignes de commande suivante:

{!! BackendHelper::convertToUrl('Catégorie Électro-ménager') !!}

Une fois cela fais, il faut recharger les fichiers dans le cache a l’aide de la fonction suivante:

composer dump-autoload

Pour l’utiliser dans un contrôleur

use App\Helpers\BackendHelper;
...
public function newCat(Request $request){
   ...
   $new_cat->url_fr  = BackendHelper::convertToUrl($request->input('url_fr'));
   ...
}

Charger automatiquement des classes – AutoLoad

Si vous désirez que votre classe soit accessible depuis partour, voua avez aussi comme solution de l’ajouter à l’Autoload de Laravel. Pour ce faire il faut modifier le fichier composer.json présent à la racine de votre dossier et le modifier de la façon suivante:

"autoload": {
   "classmap": [
      "database"
   ],
   "files": [
      "app/Helpers/lessc.inc.php", //#### Classe à inclure
      "app/Helpers/geshi/geshi.php" //#### Classe à inclure
   ],

Maintenant si vous ne voulez pas avoir l’erreur Class not found vous devez exécuter la commande suivante: composer dump-autoload

Publié le

Pagination dans une collection

Nous allons ajouter très facilement une pagination à nos collection. Laravel met à disposition des outils extrêmement simple d’utilisations. Dans notre cas, la liste des categories dispose d’une pagination tous les 5 enregistrements. Elle est mise en place dans notre contrôleur CategoriesController.php avec la ligne suivante

public function listAll(){
  $categorie = \App\Categorie::paginate(5);
  return view('backend.categories.list',array('categories'=>$categorie));
}

il serait bien sur également possible d’accéder aux enregistrements de la façon suivante:

public function listAll(){
  $categorie = DB::table('ategorie')->paginate(5) ; /*  Requiert use Illuminate\Support\Facades\DB;*/
  return view('backend.categories.list',array('categories'=>$categorie));
}

et dans la vue list.blade.php avec la ligne suivante:

{!! $categories->links(); !!}

Passer paramètres supplémentaire au système de pagination

Il est souvent très utile de passer des paramètres supplémentaire au système de pagination. Ils permettent par exemple de paginer des résultats triés. L’exemple ci-dessous vous montre comment faire.

public function listAll(){
/*{!! $categories->links(); !!}*/ 
/* On ajoute des paramètre a la pagination en utilisant ->appends(*/
  echo $terms->appends(array('sort' => $sort))->links();
Publié le

Création simplifié de formulaires, affichage de listes, validation de formulaire

Laravel permet de créer assez simplement des formulaire sécurisé avec des options. Si vous désirez utiliser cette option, il faut depuis Laravel 5.4 installer un package de la façon suivante. (Vous trouvez une information complète sur le site de doc Laravel.

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

et aller modifier ensuite le fichier config/app.php en ajoutant les 3 lignes suivante:

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

Création des pages du backend, des contrôleurs et modification du routage

Affichage de liste dans le backend

Nous allons maintenant créer les pages permettant de modifier, créer et supprimer nos catégories depuis la partie backend de notre site. Je vais vous donner tout le code et expliquer ensuite ce qui se passe.

Routage avec contrôle de paramètres et de connexion

J’ai ajouté les nouvelles routes suivantes à mon fichier routes/ web.php afin de pouvoir éditer, lister, créer et supprimer des catégories.

A noter 3 choses:
Les Route::get et Routes::any : any me permet de récupérer les valeurs de mes formulaires en POST.
Le ->where(‘id’, ‘[0-9]+’) : Qui permet de mettre une expression régulière qui contrôle que l’id est bien transmis et est numérique.
Le ->middleware(‘auth’); : Qui permet de restreindre l’accès aux utilisateurs connectés

Contrôleurs du backend et options de validations

Vous voyez ici le code source complet de mon controller Http/ Controllers/ Backend/ CategoriesController.php. J’ai décidé de faire un seul contrôleur pour toute la gestion des catégories. Ce n’est pas forcément idéal mais ca permet des fois d’aller plus vite ou d’être plus lisbible.

namespace App\Http\Controllers\Backend;

use Illuminate\Http\Request;
use App\Http\Controllers\Controller;
//use Illuminate\Support\Facades\DB; nécessaire pour l'utilisation de DB::table

class CategoriesController extends Controller
{
   public function listAll(){
     $categorie = \App\Categorie::paginate(5);
     return view('backend.categories.list',array('categories'=>$categorie));
   }
   public function newCat(Request $request){
 
   if(!is_null($request->input('name'))){
     $this->validate($request, [
       'name' => "required|max:255|min:4|unique:categories",//validateur contrôle le nom
     ]);
     $new_cat = new \App\Categorie; 
     $new_cat->name = trim($request->input('name'));
     $new_cat->save();
     return $this->listAll()->withSuccessMsg('Catégorie '.$new_cat->name.' créee avec succès');
   }
   return view('backend.categories.new');
 }
 
 public function delete($id){
   $categorie = \App\Categorie::find($id);
   if(!is_null($categorie)){ //la catégorie n'a pu être trouvé, on retourne sur l'accueil
     $categorie->delete();
     return $this->listAll()->withSuccessMsg(sprintf('suppression %s effectuées',$categorie->name));
   }
   return $this->listAll();
 }
 public function edit($id,Request $request){

   $categorie = \App\Categorie::find($id);
   if(is_null($categorie)){ //la catégorie n'a pu être trouvé, on retourne sur l'accueil
     return redirect('home');
   }
   if(!is_null($request->input('name'))){
 
       $this->validate($request, [
       'name' => "required|max:255|min:4|unique:categories,name,".$id,//validateor controle le nom sauf pour cet id
     ]);
 
     $name = trim($request->input('name'));
     /* 
     $check = \App\Categorie::where('name', $name)->where('id','!=',$id)->get()->count();
     $check = DB::('categories')->where('name', '=', $name)->where('id', '!=', $id)->get()->count();
     if($check!=0){
       $categorie->name = $name;
       return view('backend.categories.edit',array('categorie'=>$categorie))->withErrorMsg(sprintf('Le nom %s est déjà utilisé',$name)); 
     } 
     */ 
     $categorie->name = $name;
     $categorie->save();
     return view('backend.categories.edit',array('categorie'=>$categorie))->withSuccessMsg('Modifications effectuées');
   }
   return view('backend.categories.edit',array('categorie'=>$categorie));
 }
}

Charger un modèle

Vous avez un exemple de chargement de modèle de 3 manières différentes. Nous utilisons find() afin de charger selon l’id ou avec la clause where() qui permet d’effectuer une recherche sur n’importes quels champs.

//retourne un objet de mon modèle Categorie ou null s'il n'en trouve pas 
$categorie = \App\Categorie::find($id);
//retourne le nombre d'élément du même nom et avec un id différent
$check = \App\Categorie::where('name', $name)->where('id','!=',$id)->get()->count();
//Même chose de la ligne précédente mais d'une autre manière
//pour cette solution il faut ajouter [use Illuminate\Support\Facades\DB;] en haut de votre controller
$check = DB::('categories')->where('name', '=', $name)->where('id', '!=', $id)->get()->count();

Validation des champs de formulaire

Laravel fourni de nombreux outils permettant de contrôler la validation des champs de formulaire. Vous avez-ici un exemple d’utilisation.

//validateur qui contrôle que le champs est setté, qu'il est de la bonne 
//taille et qu'il est unique
$this->validate($request, [
 'name' => "required|max:255|min:4|unique:categories",
]);
//validateur qui contrôle en plus que le nom est unique sauf pour lui-même
$this->validate($request, [
 'name' => "required|max:255|min:4|unique:categories,name,".$id,
]);
//////les erreurs de validation sont affichés par notre fichier app.blade.php
//@if (count($errors) > 0)
// @foreach ($errors->all() as $error)
// {{ $error }}
// @endforeach
//@endif

Formulaires dans les vues

L’exemple ci-dessous affiche le formulaire de modification. Comme @extends(‘home’) le signale, il va utiliser le template et ajouter dans sa section content le code contenu entre section(‘content’) et endsection. Ce code contient la création simplifié de formulaire et d’ajout de champs et bouton

Ajouter une valeur par défaut à un champ de formulaire:
Form::text(‘input name’,’valeur par defaut’,$fiche->npa,array(‘class’ => ‘small_input’) );

{ { Form::open(array('url' => 'backend/categories/edit/'.$categorie->id)) } }
 <table style='width:100%'>
 <tr>
 <td>ID</td>
 <td>{ { $categorie->id } }</td>
 </tr>
 <tr>
 <td>Categorie</td>
 <td><?php echo Form::text('name',$categorie->name );?></td>
 </tr>
 <tr>
 <td></td>
 <td> <?php echo Form::submit('Save');?></td>
 </tr>
 </table> 
 { { Form::close() } } 
@endsection</pre>
 <td></td>
 <td> <?php echo Form::submit('Save');?></td>
 </tr>
 </table> 

@endsection

Publié le

Authentification Laravel et personnalisation du template blade

Nous allons maintenant mettre en place le système d’authentification de Laravel et utiliser le template blade pour afficher les pages plus élégamment. Pour activer l’authentification, il suffit d’exécuter la ligne suivant en mode console.

php artisan make:auth

Elle aura pour effet d’ajouter ces 2 lignes dans votre fichier routes/web.php et les champs login et register sur la home.

Auth::routes();
Route::get('/home', 'HomeController@index');/

Vous pouvez donc maintenant créer un compte et vous connecter.

Bloquer l’accès aux personnes non connectées

Comme vous le verrez plus tard, vous avez plusieurs solutions pour bloquer l’accès à certaines pages aux personnes qui ne se sont pas connectées et les rediriger vers la page de connexion. Je vous donne ici 3 possibilités avant de mettre à disposition du code qui utilise ces fonctions. La première solution se met en place dans les routes et la seconde dans le controllers. 2 solutions de mise en place dans le routes\web.php

//Ajouter ->middleware('auth'); à la fin de la ligne
Route::get('/backend/categories', 'Backend\CategoriesController@index')->middleware('auth');

//... autre manière ... en si signalant avec middleware
Route::any('backend/categories/new/', 
[
 'middleware' => 'auth',
 'uses'=>'Backend\CategoriesController@newCat',
]);

Mise en place dans le controller

 public function __construct()
 {
    $this->middleware('auth');//limite l'accès aux personne connectées
 }

Personnaliser le template Blade – L’espace membre

Espace membre de base

Je vais maintenant ajouter un menu à gauche de mon espace membre et afficher des liens qui pointerons sur mes futures pages d’administration.

Routage et principe d’affichage pour le tamplate Blade

Parmi les modification que j’ai effectuée sur le fichier resources/ views/ layouts/ app.blade.php, j’ai personnalisé une zone si l’utilisateur est connecté ou non qui affichera mon menu personnalisé. J’ai également créer une zone qui affichera les différents messages d’erreur ou d’information.

@if (Auth::guest())
   @yield('content')
@else
@endif
//...
//...
//...
 
 @if (!empty($success_msg))// Un utilisant une session bootsrap
{{ $success_msg }}
 @endif 
 @if (!empty($info_msg))// Un utilisant une session bootsrap
{{ $info_msg }
 @endif 
 @if (!empty($error_msg))// Un utilisant une session bootstrap
{{ $error_msg }}
 @endif 
 @if (count($errors) > 0)//Afficher les message d'erreur levé par laravel
         @foreach ($errors->all() as $error)  
{{ $error }}
         @endforeach
 @endif
Publié le

Utilisation de la base de données dans Laravel 5

Nous allons maintenant créer une nouvelle table categories qui contiendra comme son nom l’indique les catégories dans notre site à l’aide de l’outil migration de Laravel, créer le modèle et afficher les informations qu’elle contient dans une vue.

Créer une table avec l’outil de migration

Le fichier de migration permet à Laravel de créer des tables dans la base et d’en suivre les modifications. Pour cela, il faut bien sur avoir connecté la base de données… Pour utiliser l’outil de migration et générer les bases du fichier, écrivez la commande suivante en SSH.

php artisan make:migration create_categories_table

vous devez maintenant avoir un fichier nommé 2016_11_28_130745_create_categories_table.php dans le répertoire database/migrations. Il contient les bases requises. Nous allons ensuite le modifier pour y insérer les champs qui nous intéressent. Comme nous voulons ajouter les champs nom et parent, nous modifions comme suit:

<?php

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

class CreateCategoriesTable extends Migration
{
 public function up()//fonction de création appelée lors de la commande: php artisan migrate
 {
 Schema::create('categories', function (Blueprint $table) {
 $table->increments('id');
 $table->string('name');
 $table->integer('parent')->default(0);
 $table->timestamps();//ajoute les champs created_at et updated_at
 });
 }

 public function down()//fonction inverse à la création appelée lors de la fonction : php artisan migrate:rollback
 {
 Schema::drop('categories');
 }
}

La liste des type de colonnes possible est disponible sur la doc de laravel. Pour exécuter le fichier de création, il suffit de faire la commande suivante qui aura pour effet de créer votre table categories dans la base de données:

php artisan migrate
// pour annuler les migrate dans l'ordre ou ils ont été effectués
// php artisan migrate:rollback

Créer le modèle correspondant à la table

Pour créer votre modèle, Laravel nous met a disposition un outil de création. Nous allons donc créer notre modèle Categorie qui comme vous l’avez constaté et au singulier. Pour créer ce modèle nous exécutons la commande suivant qui va généré le fichier et le placer dans le répertoire app\:

php artisan make:model Categorie

Nous ouvrons modifions ce fichier pour qu’il contiennent le code suivant:

<?php

namespace App;

use Illuminate\Notifications\Notifiable;
use Illuminate\Database\Eloquent\Model;

class Categorie extends Model
{
 use Notifiable; 
 
 protected $table = 'categories';//nom de notre table
 public $timestamps = true; //champs created_at updated_at 
 
 protected $fillable = [ //champs que l'on peut modifier
 'name',
 ];
 
}


protected $fillable = [] permet de signaler quels sont les champs que l’on pourra modifier. Si vous désirez utiliser l’approche inverse et ne signaler que ceux que l’on ne pourra pas modifier utiliser la notation suivante:  $guarded = [‘id’]; // inverse de $fillable

Afficher et modifier les données d’un table

Pour créer et afficher les données présentes dans la table, nous allons créer une controller, une vue et modifier le fichier web.php. Afin de donner plus rapidement un aperçu je vais tout modifier d’un coup et vous expliquer après.

Ajouter les lignes suivantes à la fin du fichier routes\web.php

Route::get('/categories', 'Frontend\CategoriesController@index');
Route::get('/categories/create', 'Frontend\CategoriesController@create');
Route::get('/categories/last/', 'Frontend\CategoriesController@last');
Route::get('/categories/first/', 'Frontend\CategoriesController@first');
Route::get('/categories/find/{categorieId}', 'Frontend\CategoriesController@find');
Route::get('/categories/{categorieId}', function ($categorieId) {
 return \App\Categorie::find($categorieId);
});

Créez le fichier app\Http\Controllers\Frontend\CategoriesController.php contenant ce qui suit:


 public function last()
 {
 $categorie = \App\Categorie::all()->last();
 return view('frontend.categories',array('categories'=>$categorie));
 }
 public function first()
 {
 $categorie = \App\Categorie::first();
 return view('frontend.categories',array('categories'=>$categorie));
 }
 public function create()
 {
 // méthode de création d'objets
 $categorie = \App\Categorie::create([
 'name'=>'categorie_'.mt_rand(0,200),
 ]);
 // autre méthode de création d'objets
 $new_cat = new \App\Categorie; // attention, il y a bien sur un NEW
 $new_cat->name = 'categorie_methode2_'.mt_rand(0,200);
 $new_cat->save();
 
 $categories = \App\Categorie::all();//retourne toutes les donnée
 return view('frontend.categories',array('categories'=>$categories));
 
 }
 public function find($categorieId)
 {
 $categories = \App\Categorie::where('name','like','%'.$categorieId.'%')->get()->first();
 return view('frontend.categories',array('categories'=>$categories));
 }
}

Et la vue contenant le code ci-dessous (resources\view\frontend\categories.php)

//nous regadrons si c'est une collection ou un objet pour utiliser 
//la même view sans avoir d'exception
if(sizeof($categories)>1){
 echo "***** Une collection ********
";
 foreach($categories as $cat)
 {
 echo $cat->id." ".$cat->name."
";
 }
} else {
 echo "******** Un objet ********
";
 print_r($categories->name);
}

Vous comprendrez très vite une fois les pages affichées.

http://www.votre-site.com/categories/create : Va créer automatiquement des catégories en appelant CategoriesController::create() et afficher la liste de toutes les catégories à l’aide de la vue.

http://www.votre-site.com/categories: Va afficher la liste de toutes les catégories à l’aide de la vue.

http://www.votre-site.com/categories/find/8 : Va utiliser la fonction find du controller CategoriesController.php pour trouver les categories ayant 8 dans leur nom. S’il n’y en a pas il n’affichera rien sinon il affichera la liste à l’aide de la vue que nous venons de créer.

http://www.votre-site.com/categories/1 : Retourne la catégorie ayant pour id 1 sans passer par une vue ou un controller. C’est le moyen le plus rapide de voir les données du modèle.

http://www.votre-site.com/categories/first : Retourne le premier enregistrement de la table

http://www.votre-site.com/categories/last: Retourne le dernierenregistrement de la table

Publié le

Helloworld – Premier controller et vue

Maintenant que Laravel est installé, nous allons créer la première page qui pourrait être la célèbre Helloworld.

Avant d’aller plus loin, il est utile de savoir que le fichier log de  Laravel se trouve a l’endroit suivant: storage/logs

Ce tuto va vous permettre de comprendre le système de routage, les contrôleurs et les vues. Nous allons créer la page About-Us. Les fichiers modifiés et crées sont les suivant:

Fichiers à modifier ou créer pour afficher une page

La première étape est de modifier le fichier routes/web.php et d’ajouter la gestion de la nouvelle URL. Pour ce faire ajouter la ligne suivante à la fin du fichier web.php.

Route::get('/About-us', 'Frontend\AboutUsController@index');

Cette ligne signale au système qu’au moment ou la page About-us est appelée, le contrôleur AboutUsController du dossier Frontend sera appelé et plus précisément la fonction index. (Le dossier frontend n’est pas indispensable mais uniquement crée dans un but de lisibilité.) Pour aller plus loin dans l’exemple il faut donc créer le fichier App\Http\Controllers\Frontend\AboutUsController.phpcontenant le code suivant:

namespace App\Http\Controllers\Frontend;
use Illuminate\Http\Request;
use App\Http\Controllers\Controller;

class AboutUsController extends Controller
{
    public function index()
    {
           return 'We are in the page AboutUsController';
    }
}

Comme vous l’aurez compris, lorsque l’on ouvre la page About-us, le texte suivant est affiché. We are in the page AboutUsControllerComme dans notre cas, nous voulons utiliser une vue, il suffit de l’ajouter et de signaler au controller d’utiliser notre vue. Pour ce faire, créez le fichier resources/views/frontend/aboutus.php contenant le code suivant: (le dossier frontend n’est pas indispensable mais uniquement crée dans un but de lisibilité.)

<?php
echo "<h1>About-us</h1>";
echo "<p>Page Helloworld!</p>";
phpinfo();
?>

L’exemple est maintenant terminé. Vous avez un exemple complet de routage avec controller et vue. Nous pouvons maintenant passer au chapitre suivant qui va vous apprendre à utiliser la base de donnée et faire les migrations.

Publié le

Installation de Laravel 5.4 sur serveur Ubuntu

Bien que soit disant simple, l’installation et la compréhension des fichiers nécessaires à l’utilisation de Laraval peuvent poser parfois quelques problèmes. Je mets donc ici la marche à suivre que j’utilise pour mettre en place un nouveau site sur un serveur Ubuntu 16 avec PHP7 afin qu’elle puisse être utile à d’autres.

Pour installer avec composer j’ai besoin de curl et composer. Je les installe de la façon suivante:

sudo apt-get install php-curl
sudo apt-get install curl
sudo apt-get install php7.0-zip

curl -sS https://getcomposer.org/installer | php
sudo mv composer.phar /usr/local/bin/composer.phar
alias composer='/usr/local/bin/composer.phar'

Connecter vous en ssh et aller dans votre dossier public. Dans mon cas: home/web-presence/public_html:

composer global require "laravel/installer"
composer create-project --prefer-dist laravel/laravel webp
Aperçu de la console lors de l’installation de Laravel

Je déplace ensuite le contenu de mon dossier webp dans son dossier parent puis le contenu du dossier public dans mon dossier public_html. Mon dossier public (public_html) ressemble maintenant à cela:

Dans mon cas, je mets ensuite le user et group correspondant à mon virtual server:

chown -R www-data:www-data *

Pour ne pas avoir une page blanche sur la page d’accueil du site Laravel et dans mes log(var\log\vistualmin\xxx.log) d’erreurs le message suivant:

[autoindex:error] [pid 21829] AH01276: Cannot serve directory /home/xxxxxxx.com/public_html/: No matching DirectoryIndex (index.html,index.htm,index.php,index.php4,index.php5) found, and server-generated directory index forbidden by Options directive

Je signale à Laravel que je n’utilise pas un dossier public mais public_html en modifiant le fichier index.php de la sorte.

$app = require_once __DIR__.'/../bootstrap/app.php';
echo __DIR__;
// set the public path to this directory
$app->bind('path.public', function() {
    return __DIR__;
});

Si j’essaie d’afficher la page, j’ai à nouveau une page blanche et dans mes log(var\log\vistualmin\xxx.log) d’erreurs le message suivant:

[:error] [pid 24658] PHP Fatal error: Uncaught UnexpectedValueException: The stream or file « /home/xxxxxxx.com/storage/logs/laravel.log » could not be opened: failed to open stream: Permission denied in /home/xxxxxxx.com/vendor/monolog/monolog/src/Monolog/Handler/StreamHandler.php:107\nStack trace:\n#0 /home/xxxxxxx.com/vendor/monolog/monolog/src/Monolog/Handler/AbstractProcessingHandler.php(37):

Il faut donc que je modifie certains droits d’accès à mes fichiers. J’exécute donc les commandes suivantes pour changer les droits d’écriture et lecture::

sudo chmod -R 777 storage
sudo chmod -R 777 bootstrap/cache
Vous devriez maintenant avoir la page suivante visible:
Page d’accueil standard Laravel

Pour installer et lier la base de données, modifiez le fichier .env  (qui est parfois un fichier caché) et entrez les informations de connexion:

DB_CONNECTION=mysql
DB_HOST=127.0.0.1
DB_PORT=3306
DB_DATABASE=********
DB_USERNAME=********
DB_PASSWORD=*********

Si le fichier .env n’est pas modifié, vous risquez d’avoir l’erreur suivante:

[Illuminate\Database\QueryException] SQLSTATE[HY000] [1045] Access denied for user ‘homestead’@’localhost’ (using password: YES) (SQL: select * from information_schema.tables where table_schema = homestead and table_name = migrations)

Pour créer les tables de la base de données, il suffit maintenant d'effectuer la commande:
php artisan migrate

Elle va créer les tables migrations, password_resets, users

#Comme j'utilise laravelcollective/html je l'installe aussi (optionnel)
composer require laravelcollective/html
php artisan cache:clear

Nous pouvons maintenant passer au chapitre suivant qui va vous apprendre à les bases des vues et contrôleurs laravel.