Per validazione si intende il processo di verifica dei dati inseriti dagli utenti attraverso un form. Un form può ricevere un gran numero di dati differenti, come ad esempio campi di testo, numeri di telefono, pdf, immagini, check box etc… . Una volta che i dati arrivano al server devono essere confrontati con dei pattern, in modo da stabilire se sono coerenti con il tipo di informazione che ci aspettiamo.

Se un dato non è presente o non è inserito correttamente l’informazione non viene registrata ma restituita indietro con un messaggio di errore. L’utente dovrà quindi modificare i dati inseriti prima di sottoscrivere nuovamente il form.

Laravel fornisce un sistema semplice per eseguire la validazione degli input che fa uso di regole predefinite. Il primo passo consiste nel recuperare gli input inseriti nel form. Successivamente è necessario definire un array con le regole di validazione. Una volta eseguita la verifica dei dati possiamo procedere con il salvataggio delle informazioni nel database oppure con un la generazione di messaggi di errore e il redirect verso il form.

 Recupero dei dati inviati

Riceviamo alcuni dati provenienti da un form e li salviamo in un array. Tra gli input troviamo vari tipi di campo tra cui un immagine, del testo, e dei campi numerici.

/*
|--------------------------------------------------------------------------
| recupero dati che provengono da un form
|--------------------------------------------------------------------------
*/
$data = array(
	'titolo' => Input::get( 'titolo' ),
	'email' => Input::get( 'email' ),
	'telefono' => Input::get( 'telefono' ),
	'prezzo' => Input::get( 'prezzo' ),
	'testo' => Input::get( 'testo_annuncio' ),
	'immagine' => Input::file( 'immagine'),
);

Definizione delle regole di validazione

Creiamo un altro array in cui le chiavi devono corrispondere a quelle dell’array $data. Il valore in questo caso è il nome di una o più regole che devono essere rispettate.

/*
|--------------------------------------------------------------------------
| decidiamo le regole di validazione
|--------------------------------------------------------------------------
*/
$regole = array(
	'titolo' => 'required',
	'email' => array( 'required', 'email' ),
	'telefono' => array( 'required', 'numeric', 'digits_between:8,15' ),
	'prezzo' => array( 'required', 'numeric' ),
	'testo' => array( 'required', 'min:100', 'max:700' ),
	'immagine' => array( 'image', 'min:100', 'max:600' )
);

Nell’esempio required controlla che l’input non sia vuoto, integer che il campo contenga un numero intero, email deve essere un’email formattata correttamente e così via, le regole sono di facile interpretazione.

Possiamo notare che il significato di alcune regole cambia asseconda del contenuto dell’input. La regola min:100 riferita al campo immagine, significa che un file non pesare meno di 100 Kb. Nel caso del testo significa che non può avere meno di 100 caratteri oppure 100 cifre per i numeri.

Quando vogliamo applicare più regole a uno stesso input possiamo elencarle sotto forma di array oppure utilizzare una sintassi particolare che fa uso del carattere ‘pipe’ |. Per il campo potevamo scrivere

'categoria' => array( 'required|integer' ),

Regola unique

Una regola particolare è unique e permette di verificare che il valore immesso non sia già stato utilizzato precedentemente.
Ad esempio se vogliamo controllare che l’username inserito non sia già presente nella tabella utenti del database scriviamo

'username' => 'unique:utenti'

Di default viene cercato all’interno della colonna che ha lo stesso nome del campo.
È possibile specificare una colonna particolare, ad esempio nickname

'username' => 'unique:utenti,nickname'

Per ignorare un particolare id possiamo indicarlo dopo la colonna

'username' => 'unique:utenti,nickname, 12'

Lista completa delle regole di validazione

Per un elenco completo delle regole rimandiamo alla documentazione ufficiale di Laravel.

Validazione

Una volta costruito l’array $regole lo passiamo al metodo Validator::make() assieme all’array con gli input.

/*
|--------------------------------------------------------------------------
| validazione
|--------------------------------------------------------------------------
*/
$validator = Validator::make( $data, $regole ) ;
if ($validator->fails())
{
     return Redirect::to( 'form' )->withErrors( $validator );
}

// altrimenti registrazione nel database

Mostrare gli errori di validazione

Ci spostiamo nella vista ad esempio nel file form.blade.php
form.blade

Verificare l’esistenza di qualche errore

Per accertarci che è stato generato qualche errore possiamo possiamo utilizzare il metodo $errors->has().

@if ( $errors->has() )
     <span class="errore">Ricontrolla tutti i campi</span>
@endif

Generare tutti i messaggi di errore

@foreach ( $errors->all() as $messaggio )
     {{ $messaggio  }}
@endforeach

Tutti i messaggi relativi a un campo

@foreach ( $errors->get( 'email' ) as $messaggio )
     {{ $messaggio  }}
@endforeach

Solo il primo errore per un campo

{{ $errors->first( 'testo') }}

Personalizzare l’html di un messaggio

Utilizziamo il segnaposto :message per riferirci al messaggio nel secondo parametro di $errors->first().

{{ $errors->first( 'testo', '<span class="errore">:message</span>') }}

Creare una regola di validazione personalizzata

Non sempre tra le regole preimpostate da Laravel troviamo quello che ci interessa.
In questi casi possiamo creare facilmente una nuova regola attraverso il metodo Validator::extend.

Come esempio creiamo la regola max_width che verifica che la larghezza di una immagine non sia superiore a un valore di default o a uno da noi impostato.

Dove inserire il codice

Per prima cosa creiamo un file validator.php allo stesso livello di routes.php.
custom-validation-laravel
Affinché il file venga caricato correttamente modifichiamo il file app/start/global.php
laravel-global-file

Alla fine del file inseriamo una riga per l’inclusione del file.

require app_path().'/validator.php';

a questo punto possiamo editare validator.php

Validator::extend( 'max_width', function( $attribute, $value, $px = array( 600 ) )
{
$size = getimagesize( $value->getRealPath() );
$width = $size[ 0 ];

  if ( isset( $px[ 0 ] ) && $px[ 0 ] != 0 && $width < $px[ 0 ] )
  {
    return true;
  }

  return false;
});

Come primo parametro passiamo il nome della regola. Il secondo è una funzione anonima che a sua volta può ricevere:

$attribute: il nome della regola
$value: il contenuto dell’input
$px: il terzo parametro contiene le opzioni aggiuntive della regola.

Creare un nuovo tag segnaposto

Per inserire una larghezza personalizzata dobbiamo creare un segnaposto :width che svolge la stessa funzione di :max, :min etc…

Sempre all’interno di validator.php utilizziamo un nuovo metodo: Validator::replacer.

Validator::replacer('max_width', function( $message, $attribute, $rule, $parameters  )
{
	if ( empty( $parameters ) )
		$parameters[ 0 ] = 600;

    return str_replace( ':width', $parameters[ 0 ], $message);
});

Aggiungere un messaggio di errore per max_width

Il messaggio di errore deve essere inserito all’interno del file validation.php  come abbiamo visto nel post che parta della localizzazione di Laravel.

"max_width" => ":attribute supera i :width pixel",

Utilizzare max_width

La nuova regola deve essere utilizzata assieme a ‘image‘ che verifica che il file inviato sia un’immagine. Nell’esempio imponiamo che l’immagine non superi i 1000 pixel di larghezza.

$regole = array(
     'immagine' => array( 'image', 'max_width:1000' )
);

  inStileWeb.com
blog comments powered by Disqus