Creare un sistema di registrazione e login utenti con Laravel 4

User Management Laravel 4  – Vediamo come creare un sistema di registrazione e login utenti con Laravel 4

Continua la nostra guida completa a Laravel4 con questo nuovo capitolo tutto dedicato alla creazione di un solido user managment system con registrazione e login utenti (multilivello) completo.Per fruire al meglio di questo tutorial vi consiglio di visitare la sezione dedicata a Laravel e di leggere i precedenti articoli.

[button link=”http://www.targetweb.it/tutorial-e-guide-laravel/” color=”blue” target=”blank” size=”large”]Guida Laravel 4[/button]

Configurazione auth system

Per iniziare andiamo a configurare l’auth system di Laravel agendo su un particolare file di configurazione.

Aprite il file /app/config/auth.php:

<?php
return array(

    /*
    |--------------------------------------------------------------------------
    | Default Authentication Driver
    |--------------------------------------------------------------------------
    |
    | This option controls the authentication driver that will be utilized.
    | This driver manages the retrieval and authentication of the users
    | attempting to get access to protected areas of your application.
    |
    | Supported: "database", "eloquent"
    |
    */

    'driver' => 'eloquent',

    /*
    |--------------------------------------------------------------------------
    | Authentication Model
    |--------------------------------------------------------------------------
    |
    | When using the "Eloquent" authentication driver, we need to know which
    | Eloquent model should be used to retrieve your users. Of course, it
    | is often just the "User" model but you may use whatever you like.
    |
    */

    'model' => 'User',

    /*
    |--------------------------------------------------------------------------
    | Authentication Table
    |--------------------------------------------------------------------------
    |
    | When using the "Database" authentication driver, we need to know which
    | table should be used to retrieve your users. We have chosen a basic
    | default value but you may easily change it to any table you like.
    |
    */

    'table' => 'users',

    /*
    |--------------------------------------------------------------------------
    | Password Reminder Settings
    |--------------------------------------------------------------------------
    |
    | Here you may set the settings for password reminders, including a view
    | that should be used as your password reminder e-mail. You will also
    | be able to set the name of the table that holds the reset tokens.
    |
    | The "expire" time is the number of minutes that the reminder should be
    | considered valid. This security feature keeps tokens short-lived so
    | they have less time to be guessed. You may change this as needed.
    |
    */

    'reminder' => array(
        'email' => 'emails.auth.reminder',
        'table' => 'password_reminders',
        'expire' => 60,
    ),
);

Come vedete scegliamo come auth system driver eloquent. Come model di default usiamo User e come tabella di login usiamo users ovviamente potete cambiare questi parametri come meglio vi aggrada.

Impostiamo il database

A questo punto creiamo il database che andrà a contenere gli utenti del nostro sito. Creiamo per prima cosa la tabella da terminale (*Vedi nota) :

php artisan migrate:make create_users_table --table=users --create

Troverete un file chiamato create_users_table dentro la cartella /app/database/migrations.

* Nota: per aprire il terminale digita cmd da windows. Nella shell di sistema spostati all’interno della cartella contenente il tuo progetto laravel usando il comando CD. Ad esempio:

 cd C:\\xampp/htdocs/test

Una volta dentro digita il comando che trovi in questa guida. Una volta eseguito il comando da terminale apri il file che si è creato:

File: /app/database/migrations/…….._create_users_table.php:

<?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->timestamps();
        });
    }

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

Questo ovviamente è un file con impostazioni basilari (id/timestamp) andiamo ad aggiungere i nostri campi nella tabella:

<?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->string('id', 8)->primary();
            $table->string('username', 128);
            $table->string('password', 64);
            $table->string('role', 128); 
            $table->string('email', 128);

$table->timestamps(); }); } /** * Reverse the migrations. * * @return void */ public function down() { Schema::drop('users'); } }

In questa versione impostiamo username, password, email e ruolo dell’utente. Il ruolo è basilare per poter poi definire diversi livelli di accesso alla nostra applicazione. A questo punto eseguiamo la migration da console:

//Console:
php artisan migrate

A questo punto se aprite phpmyadmin troverete già la vostra bella tabella users appena creata. Andiamo a popolare la tabella con il primo utente della nostra app, per farlo useremo la funzionalità di seeding offerta da Laravel4. Per farlo iniziamo a creare un file chiamato UserTableSeeder.php all’interno della cartella database/seeds in questo modo:

// File: /app/database/seeds/UserTableSeeder.php:
<?php
class UserTableSeeder extends Seeder {

    public function run()
    {
        // !!! Cancella prima tutti gli utenti (se Presenti) !!!
        DB::table('users')->delete();

        User::create(array(
            'id'        => '1',
            'username'  => 'Administrator Targetweb',
            'password'  => Hash::make('password'),
            'role'  => 'Administrator',
            'email' => 'admin@localhost' )); } }

Creiamo un file DatabaseSeeder.php e mettiamo dentro questo codice:

//File: /app/database/seeds/DatabaseSeeder.php:
<?php

class DatabaseSeeder extends Seeder {

    /**
     * Run the database seeds.
     *
     * @return void
     */
    public function run()
    {
        Eloquent::unguard();

        $this->call('UserTableSeeder');
    }
}

Da console, facciamo avviare il seeding:

//Console:
php artisan db:seed

Fatto! a questo punto avrete progettato la vostra tabella users e popolata con il primo utente amministratore!

Il form di login

Ora che abbiamo sviluppato il nostro database andiamo a creare le varie viste/controller che andranno a comporre il nostro user system. Per prima cosa creiamo un file AuthController.php all’interno dellla cartella controllers. Ecco il codice:

//File: /app/controllers/AuthController.php:
<?php

class AuthController extends BaseController {

    public function showLogin()
    {
        // Check
        if (Auth::check())
        {
            // Redirect
            return Redirect::to('/')->with('success', 'Sei Già Loggato');
        }

        // Visualizzo form
        return View::make('auth/login');
    }
}

Con questa prima sezione di codice diciamo  a Laravel di controllare lo status dell’utente:

• Se è Loggato rendirizzalo all’home page del sito con il messaggio “Sei Già Loggato”
• Altrimenti visualizza la vista presente nella cartella views/auth/login.blade.php in quanto il visitatore deve effettuare l’accesso

Ecco il codice per il form di login:

/app/views/auth/login.blade.php:
@extends('layouts.master')

@section('title')
@parent
:: Login
@stop

{{-- Content --}}
@section('content')
<div class="page-header">
    <h2>Login</h2>
</div>

{{ Form::open(array('url' => 'login', 'class' => 'form-horizontal')) }}

    <!-- Name -->
    <div class="control-group {{{ $errors->has('username') ? 'error' : '' }}}">
        {{ Form::label('username', 'Username', array('class' => 'control-label')) }}

        <div class="controls">
            {{ Form::text('username', Input::old('username')) }}
            {{ $errors->first('username') }}
        </div>
    </div>

    <!-- Password -->
    <div class="control-group {{{ $errors->has('password') ? 'error' : '' }}}">
        {{ Form::label('password', 'Password', array('class' => 'control-label')) }}

        <div class="controls">
            {{ Form::password('password') }}
            {{ $errors->first('password') }}
        </div>
    </div>

    <!-- Login button -->
    <div class="control-group">
        <div class="controls">
            {{ Form::submit('Login', array('class' => 'btn')) }}
        </div>
    </div>

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

**Vedi nota 1

Se avete letto le precedenti lezioni non dovreste aver problemi a capire il codice sopra-elencato. Se ne avete vi invito a leggere questo articolo in particolare sulle views:

[button link=”http://www.targetweb.it/gestire-il-layout-in-laravel-4-guida-al-blade-template-system/” color=”blue” target=”blank” size=”large”]Views[/button]

A questo punto andiamo a definire la route (il percorso) per accedere al login:

//File: /app/routes.php:
<?php

/*
|--------------------------------------------------------------------------
| Application Routes
|--------------------------------------------------------------------------
|
| Here is where you can register all of the routes for an application.
| It's a breeze. Simply tell Laravel the URIs it should respond to
| and give it the Closure to execute when that URI is requested.
|
*/

Route::get('/', 'HomeController@showWelcome');

// Authentication/Login
Route::get('login', 'AuthController@showLogin');

NOTA 1:  Per completezza, vi posto anche il layout master dell’applicativo. Il master di prova che ho usato utilizza Twitter Bootstrap come Framework base.

//File: /app/views/layouts/master.blade.php:
        <!-- Navbar -->
        <div class="navbar navbar-inverse navbar-fixed-top">
            <div class="navbar-inner">
                <div class="container">
                    <!-- .btn-navbar is used as the toggle for collapsed navbar content -->
                    <a class="btn btn-navbar" data-toggle="collapse" data-target=".nav-collapse">
                        <span class="icon-bar"></span>
                        <span class="icon-bar"></span>
                        <span class="icon-bar"></span>
                    </a>

                    <a class="brand" href="#">Targetweb</a>

                    <!-- Everything you want hidden at 940px or less, place within here -->
                    <div class="nav-collapse collapse">
                        <ul class="nav">
                            <li><a href="{{{ URL::to('') }}}">Home</a></li>
                        </ul>
                    </div>

                    <div class="nav pull-right">
                        <ul class="nav">
                            @if ( Auth::guest() )
                                <li>{{ HTML::link('login', 'Login') }}</li>
                            @else
                                <li>{{ HTML::link('logout', 'Logout') }}</li>
                            @endif
                        </ul>
                    </div>
                </div>
            </div>
        </div>

Fatto! Avete realizzato la vostra prima interfaccia di Login in Laravel4! Cosa manca ora? Bhè per ora abbiamo creato solamente il form di login ora andremo a vedere come elaborare l’accesso dei vari utenti.

Elaborare il login effettuato

Aggiungiamo per prima cosa la route che rimandi all’elaborazione via POST del form.

//File: /app/routes.php:
<?php

/*
|--------------------------------------------------------------------------
| Application Routes
|--------------------------------------------------------------------------
|
| Here is where you can register all of the routes for an application.
| It's a breeze. Simply tell Laravel the URIs it should respond to
| and give it the Closure to execute when that URI is requested.
|
*/

Route::get('/', 'HomeController@showWelcome');

// Authentication
Route::get('login', 'AuthController@showLogin');

//Aggiungo il POST
Route::post('login', 'AuthController@postLogin');

A questo punto sempre nel nostro AuthController andiamo a mettere anche la funzione per verificare il login (postLogin()) :

//File: /app/controllers/AuthController.php:
<?php

class AuthController extends BaseController {

    public function showLogin()
    {
        // Checkì
        if (Auth::check())
        {
            // Redirectì
            return Redirect::to('/')->with('success', 'You are already logged in');
        }

        // Form Login
        return View::make('auth/login');
    }

    public function postLogin()
    {
        // Input
        $userdata = array(
            'username' => Input::get('username'),
            'password' => Input::get('password')
        );

        // validation.
        $rules = array(
            'username'  => 'Required',
            'password'  => 'Required'
        );

        // Validate the inputs.
        $validator = Validator::make($userdata, $rules);

        // Check if the form validates with success.
        if ($validator->passes())
        {
            // rimuovo username
            unset($userdata['username']);

            // Tentativo login
            if (Auth::attempt($userdata))
            {
                // Redirect a una pagina 
                return Redirect::to('/')->with('success', 'You have logged in successfully');
            }
            else
            {
                // Redirect login
                return Redirect::to('login')->withErrors(array('password' => 'Password invalid'))->withInput(Input::except('password'));
            }
        }

        // Errore
        return Redirect::to('login')->withErrors($validator)->withInput(Input::except('password'));
    }
}

Grazie alla funzione auth::attempt si effattua la validazione del login presente nella tabella mysql users. Nella prima porzione di codice invece si effettua tramite il validatore il controllo dei vari campi inseriti.

Logout system

Ora che abbiamo finito il nostro login system andiamo a inserire la route per potersi disconnettere.

//File: /app/routes.php:
<?php

/*
|--------------------------------------------------------------------------
| Application Routes
|--------------------------------------------------------------------------
|
| Here is where you can register all of the routes for an application.
| It's a breeze. Simply tell Laravel the URIs it should respond to
| and give it the Closure to execute when that URI is requested.
|
*/

Route::get('/', 'HomeController@showWelcome');

// Authentication
Route::get('login', 'AuthController@showLogin');
Route::post('login', 'AuthController@postLogin');

//Logout
Route::get('logout', 'AuthController@getLogout');

Ecco la funzione presente sempre all’interno di AuthController.php

   public function getLogout()
    {
        // Log out
        Auth::logout();

        // Redirect
        return Redirect::to('/')->with('success', 'You are logged out');
    }

Semplice  e veloce!

Codice completo Login/Logout App in Laravel4

<?php

class AuthController extends BaseController {

    public function showLogin()
    {
        // Check 
        if (Auth::check())
        {
            // Redirect 
            return Redirect::to('/')->with('success', 'You are already logged in');
        }

        // Login form
        return View::make('auth/login');
    }

    public function postLogin()
    {

        $userdata = array(
            'id'       => Input::get('username'),
            'username' => Input::get('username'),
            'password' => Input::get('password')
        );

        $rules = array(
            'username'  => 'Required',
            'password'  => 'Required'
        );

        $validator = Validator::make($userdata, $rules);

        if ($validator->passes())
        {

            unset($userdata['username']);

            if (Auth::attempt($userdata))
            {
                // Redirect 
                return Redirect::to('/')->with('success', 'You have logged in successfully');
            }
            else
            {
                // Redirect
                return Redirect::to('login')->withErrors(array('password' => 'Password invalid'))->withInput(Input::except('password'));
            }
        }

        //Errore
        return Redirect::to('login')->withErrors($validator)->withInput(Input::except('password'));
    }

    public function getLogout()
    {
        // Log out
        Auth::logout();

        // Redirect 
        return Redirect::to('/')->with('success', 'You are logged out');
    }
}

Showing Success-Messages

Il codice sotto indicato serve a far visualizzare i vari messaggi di errore/success che vengono elaborati dalla nostra applicazione. Mettete il codice in un punto a vostra scelta del vostro template master (master.blade.php):

<!-- Success-Messages -->
  @if ($message = Session::get('success'))
    <div class="alert alert-success alert-block">
        <button type="button" class="close" data-dismiss="alert">&times;</button>
        <h4>Tutto ok!</h4>
     {{{ $message }}}
   </div>
 @endif

Questa funzionalità è facilmente utilizzabile per tutte le vostre applicazioni in Laravel.

Proteggere le pagine – Creazione admin area

Creiamo una vista da tenere “nascosta” ai non loggati:

/app/views/dashboard.blade.php:
@extends('layouts.master')

@section('title')
@parent
:: Dashboard
@stop

@section('content')
<h1>Dashboard</h1>
<p>Dashboard utente privata</p>
@stop

Aggiungiamo il render della vista nel nostro HomeController.php

//File: /app/controllers/HomeController.php:
<?php
class HomeController extends BaseController {

    public function showWelcome()
    {
        return View::make('hello');
    }

    public function showDashboard()
    {
        return View::make('dashboard');
    }
}

Aggiungiamo ora la route che rende la pagina “nascosta” a chi non ha le credenziali per accedere:

// Route Loggato Si/No 
Route::group(array('before' => 'auth'), function()
{
    Route::get('dashboard', 'HomeController@showDashboard');
});

A questo punto digitando /dashboard da loggati vedrete la pagina Dashboard nascosta, altrimenti verrete reindirizzati.

Form Registrazione nuovi utenti

[lightgrey_box] Contenuto bloccato –  Scarica la versione completa qui sotto per avere questo contenuto. Donazione Libera [/lightgrey_box]

Codice completo Registrazione

[lightgrey_box] Contenuto bloccato –  Scarica la versione completa qui sotto per avere questo contenuto. Donazione Libera [/lightgrey_box]

Conclusioni & Guida Completa

Se la guida ti è stata utile condividila sui tuoi social network preferiti. Se invece mi vuoi offrire una pizza effettua una donazione via paypal (trovi il form poco sopra), per ringraziarti potrai scaricare la guida in formato PDF per poterla leggere ovunque vuoi. Man mano che usciranno le lezioni la guida PDF ottenuta tramite la donazione conterrà tutte le lezioni precedenti con qualche interessante aggiunta. Oltre a questo effettuando una donazione otterrai l’accesso alla nostra mailing list PREMIUM dove sarai avvisato di tutte le nuove release della guida!

Hai domande o consigli? Commenta questo articolo!