OOP - Validering

Formfelter

Validering af formfelter foretages på to måder:

Om et felt er tomt / ikke tomt.
Om syntaksen er i orden, for felter der indeholder specielle værdier (f.eks: email adresse).

Valideringen starter og slutter i HTML-programmer, der indeholder en Form.

Den fysiske udførelse af al validering foretages (hovedsagelig) i klassen "Validation". Derved fastholdes muligheden for "kodegenbrug".

Opbygningen af Validation-klassen er ret så kompleks og af stort set samme omfang hvad enten der skal valideres et enkelt eller mange form-felter. Indsatsen kan dog begrænses ved at klassen grundlægggende kan kopieres / genbruges fra opgave til opgave.

HTML: Program-top.

Validation klassen instantieres i topdelen af programmet, der indeholder formen, med $objForm tilknyttet.
Startes af Validation __construct()

$objForm = newForm();
$objValid = new Validation($objForm);

Valideringen startes med funktionen isValid() fra denne kode i HTML-top.

if ($objValid->isValid()) {
   if ($objUser->updateUser($objValid->_post, $user['id'])) {
      Helper::redirect('/?page=summary');
   } else {
      $mess = "<p class=\"red\">There was a problem updating your details.<br />";
      $mess .= "Please contact administrator.</p>";
   }
}

Valideringsstyring

I HTML-filens topdel indsættes arrays til styring af forekommende felter og valideringsform for felter, der skal valideres, der skal benyttes for hvert enkelt felt i formen.

Fortæller $objValid, hvilke felter der vil komme data fra.

Valideringsstyring
Der etableres to eller 3 arrays til listning af de relevante felter fra formen.

Expected
Array med alle felter i formen
Required
Array med de felter i formen, der skal valideres på "normal" vis.
Special
Array med de felter i formen, der skal have speciel validering (f.eks. e-mail).
Oprettes kun når felter med behov for speciel validering forekommer.

Feltnavnene skal i alle tre situationer anføres i feltorden.

if ($objForm->isPost('valgfrit feltnavn fra formen')) {
   $objValid->_expected = array(
      'first_name',
      ...
      'email'
   );
   $objValid->_required = array(
      'first_name',
      ...,
      'email'
   );
   $objValid->_special = array(
      'email' => 'email'
   );
}

Klasse: Validation

Klassen "Validation" vil grundlæggende være genbrugelig. Der skal dog foretages følgende tilpasninger:

//Validation messages: I egenskaben skal identer og tekster skal tilpasses til det aktuelle bohov i både site og Admin.
Funktionen "check special": Ved flere special end "email" skal der tilpasses dertil.
Flere special: Der etableres flere funktioner baseret på "isEmail"-modellen.

class Validation {

Egenskab, der indeholder alle returnerede form-data. Etableres med Construct.
   // form object
   private $objForm;

Egenskab med array til opsamling af "id" for alle fejlbehæftede felter. Etableres med add2Errors().
   // for storing all error ids
   private $_error = array();

Egenskab med array indeholdende alle de fejltekster der kan forekomme i både site og admin. Som "id" anvendes feltnavnet fra <input name="feltnavn".
Vedligeholdes manuelt i valgfri orden efterhånden som behov opstår.
   // validation messages
   public $_message = array(
      "first_name" => "Please provide your first name",
      "last_name" => "Please provide your last name",
      "address_1" => "Please provide the first line of your address",
      "address_2" => "Please provide the second line of your address",
      "town" => "Please provide your town name",
      "county" => "Please provide your county name",
      "post_code" => "Please provide your post code",
      "country" => "Please select your country",
      "email" => "Please provide your valid email address",
      "email_duplicate" => "This email address is already taken",
      "login" => "Username and / or password were incorrect",
      "password" => "Please choose your password",
      "confirm_password" => "Please confirm your password",
      "password_mismatch" => "Passwords did not match",
      "category" => "Please select the category",
      "name" => "Please provide a name",
      "description" => "Please provide a description",
      "price" => "Please provide a price",
      "name_duplicate" => "This name is already taken"
   );

Egenskab med array indeholdende navne på "expected" felter. Tilført fra HTML-top.
   // list of expected fields
   public $_expected = array();

Egenskab med array indeholdende navne på "required" felter. Tilført fra i HTML-top.
   // list of require fields
   public $_required = array();

Egenskab med array indeholdende navne på "special" felter. Tilført fra HTML-top.
   // list of special validation fields
   // array('field_name' => 'format')
   public $_special = array();

Egenskab med array indeholdende alle "value"-data fra formen. Etableret med / brugt af process().
   // post array
   public $_post = array();

Egenskab med array med POST-felter, der skal fjernes (uklart hvordan data tilføres egenskaben). Bruges af isValid() til at tømme $_POST.
   // fields to be removed from the $_post array
   public $_post_remove = array();

Egenskab med array !!!!!!!
   // fields to be specifically formatted
   // array('field_name' => 'format'
   public $_post_format = array();

Construct der starter $objForm instantieret i HTML-programmet.
   public function __construct($objForm) {
      $this->objForm = $objForm;
   }

Startes fra isValid()
Opbygger egenskaben _post ud fra _expected og validerer med funktionen check ud fra _post.
Bruger også funktionerne objForm->isPost() og objForm->getPostArray().
   public function process() {
      if ($this->objForm->isPost() && !empty($this->_required)) {
         // get only expected fields
         $this->_post = $this->objForm->getPostArray($this->_expected);
         if (!empty($this->_post)) {
            foreach($this->_post as $key => $value) {
               $this->check($key, $value);
            }
         }
      }
   }

Bruges i check() og checkSpecial() til at opdatere _error egenskaben.
   public function add2Errors($key) {
      $this->_errors[] = $key;
   }

Bruges i process() til at udskille records fra _special til validering med checkSpecial(). For øvrige "required" valideres for tomt værdifelt. Ved tomt felt anvendes add"Error().
   public function check($key, $value) {
      if (!empty($this->_special) && array_key_exists($key, $this->_special)) {
         $this->checkSpecial($key, $value);
      } else {
         if (in_array($key, $this->_required) && empty($value)) {
            $this->add2Errors($key);
         }
      }
   }

Bruges i check() til at validere værdier fra _special felter. "Case" giver mulighed for at validere valgfrit antal _special-værdier i hver sin funktion.
Ved fejl anvendes add"Error().
   public function checkSpecial($key, $value) {
      switch($this->_special[$key]) {
         case 'email':
         if (!$this->isEmail($value)) {
            $this->add2Errors($key);
         }
         break;
      }
   }

Funktion til at validere e-mail adresse.
   public function isEmail($email = null) {
      if (!empty($email)) {
         $result = filter_var($email, FILTER_VALIDATE_EMAIL);
         return !$result ? false : true;
      }
      return false;
   }

Startes fra HTML.
Starter process()-funktionen.
Når ingen fejl tømmes egenskaben $_post.
   public function isValid() {
      $this->process();
      if (empty($this->_errors) && !empty($this->_post)) {
         // remove all unwanted fields
         if (!empty($this->_post_remove)) {
            foreach($this->_post_remove as $value) {
               unset($this->_post[$value]);
            }
         }
         // format all required fields
         if (!empty($this->_post_format)) {
            foreach($this->_post_format as $key => $value) {
               $this->format($key, $value);
            }
         }
         return true;
      }
      return false;
   }

Funktion relateret til validering af password og hashing når korrekt.
   public function format($key, $value) {
      switch($value) {
         case 'password':
         $this->_post[$key] = Login::string2hash($this->_post[$key]);
         break;
      }
   }

   public function validate($key) {
      if (!empty($this->_errors) && in_array($key, $this->_errors)) {
         return $this->wrapWarn($this->_message[$key]);
      }
   }

   public function wrapWarn($mess = null) {
      if (!empty($mess)) {
         return "<span class=\"warn\">{$mess}</span>";
      }
   }
}

Klasse: Form

process()-funktionen i "Validation" anvender 2 funktioner fra klassen objForm:

Afklarer om $_POST forefindes.
public function isPost($field = null) {
   if (!empty($field)) {
      if (isset($_POST[$field])) {
         return true;
      }
      return false;
   } else {
      if (!empty($_POST)) {
         return true;
      }
      return false;
   }
}

Bruger $_POST til at bygge array ($out) med værdier for de poster, der er indeholdt i $expected.
public function getPostArray($expected = null) {
   $out = array();
   if ($this->isPost()) {
      foreach($_POST as $key => $value) {
         if (!empty($expected)) {
            if (in_array($key, $expected)) {
               $out[$key] = strip_tags($value);
            }
         } else {
            $out[$key] = strip_tags($value);
         }
      }
   }
   return $out;
}

HTML: "input type"-felter.

For hvert "input type"-felt i formen, der skal valideres, indsættes en PHP-linie til at vise evt. fejltekster.

Ved valideringens afslutning - men før fejlbehæftet formular returneres til klient -:

For hvert felt udføres funktionen validate(). ved forekomst af fejl for feltet indsættes den relevante fejltekst.

<?php echo $objValid->validate('feltnavn'); ?>
<input type="text" name="feltnavn"
...