Validare i form con CakePHP

Controllare che i dati inviati dagli utenti siano stati correttamente specificati è un'operazione con non dovrebbe mai essere tralasciata. Spesso ci si ritrova purtroppo in situazioni in cui un sito internet non controlla correttamente i dati da noi immessi e non produce i risultati desiderati in caso si commettano degli errori durante l'immissione. PHP ha recentemente aggiunto delle funzionalità per filtrare i dati in ingresso in base a determinati pattern di validazione ma, come per molti altri framework, CakePHP fornisce un sistema integrato di validazione dei dati che risulta molto semplice ed intuitivo. Questo sistema è anche utilizzato internamente dal framework stesso all'interno degli script generati automaticamente per l'implementazione di interfacce CRUD (Create, Read, Update and Delete).

In questo articolo valuteremo cosa offre CakePHP per la validazione dei dati facendo alcuni esempi pratici di uso quotidiano.

I validatori di default

CakePHP viene fornito con una serie di validatori di default. Questi validatori sono espressioni regolari che vengono utilizzate per validare i dati di un modello a runtime. I validatori di default a disposizione sono quattro:

• VALID_NOT_EMPTY: controlla che il valore di un attributo del modello non sia vuoto;
• VALID_NUMBER: controlla che il valore di un attributo del modello sia un numero valido;
• VALID_EMAIL: controlla che il valore di un attributo del modello sia un'email valida;
• VALID_YEAR: controlla che il valore di un attributo del modello sia un valore annuale valido;

Quando definiamo un modello possiamo specificare delle espressioni regolari da utilizzare per la validazione che verranno applicate a runtime. Tra queste espressioni regolari, compatibili con Perl, possiamo anche utilizzare quelle di default:

<?php

class TestModel extends AppModel
{
   var $name = 'TestModel';
   
   var $validate = array(
      'numer'           =>   VALID_NUMBER,
      'required_field'  =>   VALID_NOT_EMPTY,
      'email'           =>   VALID_EMAIL,
      'custom'          =>   '/[a-n]+/i'
   );
}

?>

I validatori sono specificati nella variabile $validate, che è un array associativo che mappa ad ogni proprietà di un modello il suo validatore. Ogni volta si tenterà di accedere in scrittura ad un elemento del modello sarà la classe AppModel stessa che si occuperà di recuperare il validatore e, se presente, di applicarlo al valore assegnato. Se fosse necessario validare manualmente i campi è possibile utilizzare direttamente il metodo validate() del modello.

Normalmente il processo di validazione e notifica degli errori di un form è integrato in modo trasparente nel controller. Se fosse necessario è comunque possibile recuperare la lista dei campi che non hanno passato la validazione utilizzando il metodo invalidFields() del modello.

Utilizzando espressioni regolari possiamo quindi sfruttarne tutte le potenzialità per validare i nostri dati, mantenendo allo stesso tempo un'ottima organizzazione del codice. Il modello definito sopra può quindi essere agganciato ad una vista e ad un controller in modo che la gestione degli errori avvenga quasi automaticamente.

Il controller potrebbe avere un aspetto simile al seguente:

<?php

class BlogController extends AppController
{
   var $uses = array( 'TestModel' );

   function add()
   {
      if( empty( $this->data ) ) 
      {
         $this->render();
      }else
      {
         if( $this-> TestModel->save( $this->data ) )
         {
           /**
            * I dati sono corretti quindi possiamo procedere con
            * l'eventuale inserimento.
            */
         }else
         {
           /**
            * In questo caso ci sono stati degli errori e
            * procediamo con la notifica all'utente.
            */
            $this->set( 'errorMessage', 'Ci sono stati degli errori. Correggerli.' );
            $this->render();
         }
      }
   }
}

?>

Mentre la vista potrebbe essere impostata come segue:

<h2>Add post to blog</h2>
<form action="<?php echo $html->url('/test/add')?>" method="post">
   <div class="blog_add">
      <p>Numero:
         <?php echo $html->input( 'TestModel/number', array('size'=>'40'))?>
         <?php echo $html->tagErrorMsg('TestModel/number', 'deve essere un numero.')?>
      </p>
      <p>Email:
         <?php echo $html->input( 'TestModel/email', array('size'=>'40'))?>
         <?php echo $html->tagErrorMsg('TestModel/email', 'deve essere un'email.')?>
      </p>
      <p>Required:
         <?php echo $html->input( 'TestModel/required_field', array('size'=>'40'))?>
         <?php echo $html->tagErrorMsg('TestModel/required_field', Il campo è richiesto')?>
      </p>
      <p>Custom:
         <?php echo $html->input( 'TestModel/custom', array('size'=>'40'))?>
         <?php echo $html->tagErrorMsg('TestModel/custom', 'custom deve essere una serie di lettere dalla a alla n')?>
      </p>
      <p>
         <?=$html->submit( 'Aggiungi' )?>
      </p>
   </div>
</form>

Validazione ed errori personalizzati

Il classico sistema di validazione attraverso espressioni regolari utilizzato da CakePHP può essere comodo in molte situazioni. Purtroppo però capitano casi in cui la validazione non si limita a controllare che il dato inserito corrisponda ad una determinata sequenza, ma può accadere che il dato debba essere controllato con check aggiuntivi dipendenti dalla situazione. Per esempio potrebbe essere necessario controllare che lo username di un utente non sia già presente nel database, oppure che la data di pubblicazione di un articolo sia successiva a quella odierna.

In tutti questi casi è comunque possibile validate a mano parte dei dati, notificando al framework eventuali errori che verranno trattati come se fossero stati generati internamente durante la validazione. Vediamo un esempio di controller, creato su un modello User immaginario, che effettua la validazione personalizzata:

<?php

class UsersController extends AppController
{
  var $uses = array( 'User' );

   function create()
   {
      if ( !empty( $this->data[ 'User' ] ) )
      {
         $user = $this->User->findByUsername( $this->data[ 'User '][ 'username' ] );

         if ( !empty( $user[ 'User' ][ 'username' ] ) )
         {
            $this->User->invalidate( 'username' );
         }

         if( $this->User->save( $this->data ) )
         {
            $this->redirect( '/users/index/saved' );
         }else
         {
             $this->render();
         }
      }
   }
}

?>

Come possiamo notare dal controller precedente, prima di procedere con la normale validazione del modello (che avviene al salvataggio) eseguiamo una validazione manuale. La validazione manuale controlla che lo username impostato sia univoco e in caso affermativo procede con il normale flusso di lavoro. In caso invece lo username non fosse univoco invalidiamo manualmente il campo username utilizzando il metodo invalidate (string $field) del modello. Invalidando un campo in questo modo lo si aggiunge alla lista dei campi contenenti errori, che verranno successivamente evidenziati nella lista.

Conclusione

In questo articolo abbiamo accennato alla validazione dei dati con CakePHP. La validazione delle informazioni in input è estremamente importante ma spesso tediosa; avere strumenti che la automatizzino è sempre una buona cosa, soprattutto se fortemente integrati con i framework che si utilizzano abitualmente