Comporre la gerarchia - prima parte

Come appreso dalla lezione precedente, la nostra gerarchia sarà composta da 3 parti fondamentali: l'interfaccia IFormCheck, la classe astratta AFormCheck che implementa la precedente e la classe finale FormCheck. In questa lezione vedremo come costruire l'interfaccia completa e la prima parte della classe astratta. Partiamo dall'interfaccia IFormCheck, che assume la seguente forma:

// ----------------------------------------
// interfaccia IFormCheck
// ----------------------------------------
interface IFormCheck {
        public function checkName();
        public function checkLastname();
        public function checkEMail();
        public function checkYear();
        public function checkAll();
        public function setErrorMsgs($errs);
}

Come possiamo notare, quest'ultima contiene tutti i metodi pubblici che la classe FormCheck dovrà ridefinire. Ovviamente i metodi checkName, checkLastname, checkEMail e checkYear avranno il compito di validare rispettivamente il nome, il cognome, l'e-mail e l'anno di nascita forniti dall'utente. Il metodo checkAll è decisamente il più interessante: richiamandolo, ci si assicura che tutti i precedenti controlli siano stati effettuai. checkAll restituirà true nel caso in cui l'esito sia positivo e false nel caso contrario. In entrambe le situazioni, degli opportuni messaggi (gestiti tramite la classe astratta AFormCheck) verranno stampati.

Infine, il metodo setErrorMsgs servirà a personalizzare i messaggi di errore da visualizzare per ogni campo il cui valore fornito risulti errato.

La classe astratta AFormCheck

Il compito fondamentale della classe AFormCheck è quello di gestire il tracking ed il reporting degli errori che si presentano nei dati ricevuti dagli utenti. La classe è dichiarata come abstract perchè non deve essere utilizzata direttamente dall'utente, ma vuole essere solamente un "wrapper" di funzionalità fondamentali da condividere con più classi.

Per questo motivo AFormCheck conterrà:

• le proprietà pubbliche, private e protette fondamentali
• il metodo costruttore che inizializza le precedenti ricavando i dati dai campi dell'array superglobale $_POST
• i metodi trackErrorMsg, getErrorMsg ed internalError, che analizzeremo dettagliatamente successivamente

Ecco il codice della prima parte della classe AFormCheck (proprietà e costruttore):

// ----------------------------------------
// class AFormCheck
//              implements IFormCheck
// ----------------------------------------
abstract class AFormCheck implements IFormCheck {
        public $name;
        public $lastname;
        public $email;
        public $year;
        public $errorMsgs = array(
                'name' => 'Il nome deve essere composto da caratteri alfanumerici e deve contenere dai 4 ai 10 caratteri al massimo.',
                'lastname' => 'Il cognome deve essere composto da caratteri alfanumerici e deve contenere dai 4 ai 15 caratteri al massimo.',
                'email' => 'L' e-mail deve essere composta nella seguente forma: "mailname@mailserver.mailext"',
                'year' => 'L'anno di nascita deve essere superiore al 1900'
        );
        private $err = '';
        public $clean = array();
        // costruttore
        public function __construct() {
                $this->name = $_POST['name'];
                $this->lastname = $_POST['lastname'];
                $this->email = $_POST['email'];
                $this->year = $_POST['year'];
        }
        // ...

Le proprietà pubbliche name, lastname, email e year verranno impostate ai rispettivi valori dell'array superglobale $_POST in fase di costruzione dell'istanza. L'array errorMsgs contiene tutti i messaggi da stampare nel caso si presenti un errore con uno o più campi del form.

La proprietà privata err servirà per tenere traccia degli errori: nel caso in cui il suo valore risulti inalterato, significa che non si sono presentate inesattezze. L'array clean infine, verrà popolato con i dati che hanno passato la validazione, in modo che possano essere usati in tutta tranquillità.

La seconda parte della classe AFormCheck, è composta da metodi per la registrazione e la gestione degli errori. Ecco il codice:

// ...
        // metodi di tracking/erroring
        protected function trackErrorMsg($field) {
                if($this->errorMsgs[$field]) {
                        $this->err .= "<p>" . $this->errorMsgs[$field] . "</p>";
                }
                else {
                        $this->internalError();
                }
        }
        protected function getErrorMsg() {
                if($this->err != '') {
                        echo "<h4>Errore!</h4>";
                        echo $this->err;
                        return false;
                }
                else {
                        echo "<h4>Ok!</h4>";
                        echo "<p>Tutti i campi del form sono stati inviati correttamente.</p>";
                        return true;
                }
        }
        protected function internalError() {
                trigger_error('Non esiste un errore di questo tipo.', E_USER_WARNING);
        }
}

Il metodo trackErrorMsg, che verrà richiamato dai metodi pubblici della classe FormCheck, si occupa della registrazione degli errori. Se esiste nell'array errorMsgs un campo con il nome passato come parametro (ad esempio name, lastname, email e year) verrà registrato il rispettivo messaggio di errore. In caso contrario, verrà generato un errore di tipo E_WARNING per indurre lo sviluppatore a comprendere che il campo specificato non è attualmente esistente, tramite il metodo protetto internalError.

Infine, il metodo getErrorMsg si occupa di stampare l'errore o la lista di errori registrati, se esistono, oppure di visualizzare un messaggio che indica che tutti i campi del form sono stati inviati correttamente.