Nuove Features in Laravel 5.2

() translation by (you can also view the original English article)

In questo articolo, daremo un'occhiata alle nuove caratteristiche di Laravel 5.2 e le descriveremo una per una. Le nuove funzionalità sono elencate di seguito:

route model binding implicito
convalida di form come array
API rate-limiting middleware
middleware groups
autenticazione automatica
driver di autenticazione multipli

Driver di autenticazione multipli

Questa funzione vi aiuterà soprattutto quando dovrete usare Doctrine ORM Auth con più provider. Nei miei progetti preferisco avere l'autenticazione utente e admin separata da altro; questa caratteristica mi aiuterà a raggiungere questo obiettivo facilmente. Vediamo un esempio config/auth.php:

//...
    'guards' => [
        'user' => [
            'driver' => 'session',
            'provider' => 'users',
        ],
        'admin' => [
            'driver' => 'session',
            'provider' => 'admin',
        ],

        'api' => [
            'driver' => 'token',
            'provider' => 'users',
        ],
    ],
//...
    'providers' => [
        'users' => [
            'driver' => 'doctrine',
            'model' =>  App\Entities\Users::class,
        ],
        'admin' => [
            'driver' => 'doctrine',
            'model' =>  App\Entities\Admin::class,
        ],
    ],

Ora, quando si utilizza Auth::attempt([...]), Laravel chiamerà la protezione predefinita; invece se si desidera utilizzare una protezione specifica, basta chiamarla con il suo nome, ad esempio Auth::guard('admin').

Per l'autenticazione sulla route con una protezione specifica, è possibile chiamare semplicemente il nome:

1	Route::group(['middleware' =>['auth:admin']], function () {
2	//...
3	}

A volte, piuttosto che un semplice login nella tua app, si può richiedere che gli utenti aggiungano un api_token alla fine della loro stringa di query e utilizzarla per autenticare la loro richiesta. TokenGuard vi permetterà di raggiungere questo obiettivo facilmente.

Se si desidera utilizzare l'autenticazione con token, prima di tutto è necessario aggiungere un campo api_token univoco di 60 caratteri nella tabella del database del modello selezionato (entity in doctrine). Ora è possibile utilizzare facilmente un api guard nella tua app.

Route model binding implicito

Una delle nuove funzionalità di 5.2 Laravel davvero molto pratica è l'associazione del modello alla route. È possibile associare il modello al percorso; prima bisognava crearlo manualmente:

1	Route::get('user/{id}', function ($id) {
2	$user = Users::findOrFail($id);
3	// ...
4	});

O si può fare qualcosa di simile:

  //...
  $router->model('user', 'App\User');
  //...

  $router->get('profile/{user}', function(App\User $user) {
    //
});

Laravel 5.2 rende tutto ancora più facile. Basta passare un parametro nella closure della route, e verrà automaticamente verrà trattata come un'associazione di modello al percorso:

1	Route::get('user/{id}', function (App\User $user) {
2	//...
3	});

Ora è più semplice associare il modello al tuo percorso.

Per impostazione predefinita, Laravel utilizza la colonna id del modello. Ma se ci si aspetta di cambiare la mappatura, puoi cambiare il tuo modello in questo modo:

class User extends Model 
{
    public function getRouteKeyName()
    {
        return 'UserEmail';
    }
}

Eloquent implementa Illuminate\Contracts\Routing\UrlRoutable, in questo modo puoi sovrascrivere il metodo getKeyRouteName(). Definisce quale colonna deve essere utilizzata per cercarlo da un URL.

Middleware groups

Come potete vedere nella sezione precedente, abbiamo creato una guardia diversa per utente e amministratore. In questo caso, se si desidera assegnare un middleware a un gruppo di route per l'utente o ad un gruppo di route per l'area admin, Laravel 5.2 consente di creare un collegamento con un nome chiave.

Per definire il gruppo di middleware, è necessario modificare il kernel.php nella cartella https:

protected $middlewareGroups = [
     //...
    'admin' => [
        'acl',
        'web',
        'auth',
    ]
];

E ora è possibile utilizzarlo facilmente nel tuo gruppo di route.

Middleware per rate-limiting delle api

Se utilizzi le API di un'altra applicazione come GitHub, utilizzando l'autenticazione di base o OAuth per le richieste, si possono fare fino a 5.000 richieste all'ora. Questa limitazione è chiamata rate limiting. Se si desidera avere qualcosa di simile nella tua app, si può utilizzare la nuova funzionalità di Laravel 5.2. Laravel 5.2 ha aggiunto un nuovo throttle middleware che gestirà la limitazione delle richieste. Ad esempio, potrebbe essere qualcosa di simile:

Route::group(['prefix' => 'api', 'middleware' => 'throttle'], function () {
    Route::get('user', function () {
        return Users::all();
    });
});

Per impostazione predefinita, il middleware throttle consente 60 tentativi al minuto in kernel.php:

1	//...
2	'api' => [
3	'throttle:60,1',
4	'auth:api',
5	],

È possibile modificarlo come si vuole o anche personalizzarlo per un percorso specifico:

Route::group(['prefix' => 'api', 'middleware' => 'throttle:10,1000'], function () {
    Route::get('user', function () {
        return Users::all();
    });
});

Implementare l'autenticazione

Laravel 5.2 fornisce un modo rapido per preimpostare tutto il necessario per l'autenticazione utilizzando questo comando:

1	php artisan make:auth

Utilizzando questo comando in una nuova applicazione si otterranno view di registrazione e di accesso, nonché percorsi per tutte le autenticazioni. Il mio file di route assomiglia a questo:

1	Route::group(['middleware' => 'web'], function () {
2	Route::auth();
3	Route::get('/home', 'HomeController@index');
4	});

Il metodo Route:: auth() è una scorciatoia per definire i seguenti percorsi(route):

// Authentication Routes...
$this->get('login', 'Auth\AuthController@showLoginForm');
$this->post('login', 'Auth\AuthController@login');
$this->get('logout', 'Auth\AuthController@logout');

// Registration Routes...
$this->get('register', 'Auth\AuthController@showRegistrationForm');
$this->post('register', 'Auth\AuthController@register');

// Password Reset Routes...
$this->get('password/reset/{token?}', 'Auth\PasswordController@showResetForm');
$this->post('password/email', 'Auth\PasswordController@sendResetLinkEmail');
$this->post('password/reset', 'Auth\PasswordController@reset');

Sarà generato anche un controller HomeController, che sarà responsabile delle richieste di login alla dashboard della tua applicazione. Ma è possibile personalizzare o rimuovere questo controller in base alle esigenze dell'applicazione.

Validazione di form array

Un altro aspetto importante con cui ho lavorato sono i form array in HTML. Se inserisci una stringa tra le parentesi quadre allora il risultato sarà un array associativo, altrimenti sarà un array numerico:

<form action="" method="POST">
    <input type="text" name="name[first]">
    <input type="text" name="name[last]">
    <input type="submit">
</form>

Il risultato, usando print_r($_POST) sarà:

array(
     'name' => array(
         'first' => ''
         'last' => ''
     )
 )

Questo ti semplificherà molto il lavoro di validazione di un form. Ora vediamo la convalida dei nostri campi utente in Laravel 5.2:

    public function Validator()
    {
        $this->validate(Request::all(), [
            'name.*.first' => 'required|string',
            'name.*.last' => 'string',
        ]);
    }

Avrai notato che la forma della convalida è name.*.last, con un asterisco in mezzo, che quasi indica che si potrebbe aggiungere la chiave di un'array o quello che preferisci.

Conclusione

Laravel 5.2 è una piccola release che ti permette di lavorare meglio e in maniera più veloce. Come puoi notare, molte di queste feature sono anche semplici da imparare.