Formular Validierung

[nikosch]

Vereinheitlichung von Daten, für die mehrere Eingabe-Formate gültig sind:
- Datumsangaben
- Telefonnummern
- Währungen ohne Nachkommastellen > Float

[Gast]

Danke fuer eure Anregungen werde mich mal die Tage an die Implementierung setzen. Habe allerdings vorher noch eine kleine Frage. Haltet ihr es fuer sinnvoll in der abstrakten Klasse Validator noch ein error-Attribut hinzuzufuegen, dass die Standrad-Fehlermeldung enthaelt, die jedoch ueber eine Methode angepasst werden kann?

MfG, Andy

[Bleda]

Du könntest auch einfach die getError() Methode in der abstrakten Klasse schon so implementieren, dass sie eine Standardmeldung zurückgibt. In den abgeleiteten Klassen kannst du dann die Methode einfach überschreiben und damit machen was du willst. Wo du die Meldung selber ablegst ist natürlich wieder eine andere Frage (Im Code, Sprachfile...).

[Manko10]

Möglich ist auch die Benutzung von GNU Gettext (entweder selbst implementieren oder sich mit den Gettext-Funktionen von PHP herumärgern).

[MaMo-Net]

Hallo,

mir ist bewusst, dass das Thema schon älter ist, aber ich möchte es dennoch nochmal aufgreifen, da ich mir auf Basis dieses Themas nun auch einen Validator (ohne Formulargenerierung) gebastelt habe, ich stehe jedoch noch vor einigen konzeptionellen Problemen.

Ich habe folgende Klassen:
Validator - Bündelt die einzelnen "Elemente" (jedes Formularfeld wäre ein Element), die validiert werden sollen
ValidatorElement - Entspricht dem o.g. "Element", bündelt die einzelnen Validationsregeln
AbstractValidator - Basisklasse für einzelne Validationsregeln
BetweenValidator (z.B.) - Spezielle Implementierung einer Validationsregel

Nutzen könne man das ganze z.B. so (vereinfacht, nur eine Regel):

<?php
$validator = new Validator($_REQUEST);
$validatorElement = new ValidatorElement('test');
$betweenValidator = new BetweenValidator(1, 10);
$betweenValidator->setMessages(
    array(
        'NOT_BETWEEN_INCLUSIVE' => 'Gegebener Wert nicht im passenden Bereich ...'
    )
);
$validatorElement->addValidator($betweenValidator);
$validator->addElement($validatorElement);
if ($validator->isValid() == false) {
    $output = $validator->getErrors();
}
else {
    $output = $validatorElement->getValue(); // anstatt $_REQUEST['test']
}
?>

Nun könnte man diese einzelne Regel auch nur mit dem BetweenValidator prüfen, aber das ist auch nur ein einfaches Beispiel, bei mehreren Validationsregeln und mehreren Feldern wird das ja erst sinnvoll. Nun ist das schon ein ziemlicher Klotz für ein wenig Validation, v.a. die Sprachbehandlung finde ich viel zu umständlich und würde die Nutzung gerne kompakter gestalten.
Schön kompakt wäre es z.B. so, aber einerseits ist das vllt. nicht allzu schön und die Sprachbehandlung fehlt auch noch:

<?php
$validatorElement = new ValidatorElement('test');
$validatorElement->addValidators(
    new BetweenValidator(1, 10),
    new XYZValidator('Blubb'),
    // ...
);
$validator = new Validator($_REQUEST);
$validator->addElements($validatorElement, ..., ...);
if ($validator->isValid() == false) {
    $output = $validator->getErrors();
}
else {
    $output = $validatorElement->getValue(); // anstatt $_REQUEST['test']
}
?>

Hat jemand eine Idee, wie man das halbwegs kompakt, aber dennoch möglichst flexibel gestalten könnte?

Ansonsten würde ich auch gerne einmal wissen, ob sonstige konzeptionelle Verbesserung möglich wären.

Dank und Grüße
MaMo

Anhang: Source Code

<?php
/**
 * Validator class that bundles the ValidatorElement objects.
 *
 * Validation classes base on a concept discussed at php.de, see link.
 *
 * @package        Core
 * @subpackage    Security
 * @author        Matthias Mohr
 * @author        Andreas Wilhelm
 * @copyright    Copyright (c) 2004-2010, Viscacha.org
 * @since         1.0
 * @see            http://www.php.de/software-design/50128-formular-validierung.html
 */
class Validator {

    protected $data = array();
    protected $elements = array();
    protected $errors = array();

    /**
     * @param array Array with data to validate
     */
    public function __construct($data) {
        $this->data = $data;
    }

    /**
     * Adds an element to the Validator.
     *
     * If you specify an Element with a name that was used by another element before, this element
     * won't overwrite the element specified before.
     *
     * @param ValidatorElement
     */
    public function addElement(ValidatorElement $element) {
        $name = $element->getName();
        if (isset($this->data[$name]) == true) {
            $element->setValue($this->data[$name]);
        }

        // check if entry exists
        if(!isset($this->elements[$name])) {
            $this->elements[$name] = $element;
        }
        else {
            // Write a message to the log file as this can lead to unapplied Validators (risky)!
            ErrorHandling::getDebug()->addText(
                "Validation: You specified an element multiple times, this can be a security hole!"
            );
        }
    }

    /**
     * Checks if any errors accured in this form.
     *
     * @return boolean
     */
    public function isValid() {
        $isValid = true;
        foreach($this->elements as $element) {
            if($element->isValid() == false) {
                $isValid = false;
                $this->errors[$element->getName()] = $element->getErrors();
            }
        }
        return $isValid;
    }

    /**
     * Returns the errors accured in a validator.
     *
     * @return array
     */
    public function getErrors() {
        return $this->errors;
    }
}
?>

<?php
/**
 * ValidatorElement class that bundles the validation rules and filters for this element.
 *
 * @package        Core
 * @subpackage    Security
 * @author        Andreas Wilhelm
 * @author        Matthias Mohr
 * @copyright    Copyright (c) 2004-2010, Viscacha.org
 * @since         1.0
 * @see            http://www.php.de/software-design/50128-formular-validierung.html
 */
class ValidatorElement {

    protected $name;
    protected $value;
    protected $validators;
    protected $errors;

    /**
     * @param string Element name
     */
    public function __construct($name, $value = null) {
        $this->validators = array();
        $this->errors = array();
        $this->name = $name;
        $this->value = $value;
    }

    /**
     * Adds a validator to an element.
     *
     * @param AbstractValidator
     * @param boolean Make this Validator optional (true) or not (false, default).
     * @todo Find a better method for the in_array check (maybe a uniqueId method for validators)
     */
    public function addValidator(AbstractValidator $validator, $optional = false) {
        // Don't add a validator with the same data multiple times
        if(in_array($validator, $this->validators) == false) {
            $validator->setOptional($optional);
            $this->validators[] = $validator;
        }
    }

    /**
     * Returns the name of an element.
     *
     * @return string
     */
    public function getName() {
        return $this->name;
    }

    /**
     * Returns the value of an element.
     *
     * @return mixed
     */
    public function getValue() {
        return $this->value;
    }

    /**
     * Assigns a value to an element.
     *
     * @param mixed
     */
    public function setValue($value) {
        $this->value = $value;
    }

    /**
    * Checks if any errrors accured in this element.
    *
    * @return Boolean
    */
    public function isValid() {
        $isValid = true;
        foreach($this->validators as $validator) {
            if($validator->isValid($this->value) == false) {
                $isValid = false;
                $this->errors = array_merge($this->errors, $validator->getErrors());
            }
        }
        return $isValid;
    }

    /**
    * Returns the errors occured in an element.
    *
    * @access public
    * @return Array
    */
    public function getErrors() {
        return $this->errors;
    }
}
?>

<?php
/**
 * Abstract validator that has to be extended by all Validator rule classes.
 *
 * @package        Core
 * @subpackage    Security
 * @author        Matthias Mohr
 * @copyright    Copyright (c) 2004-2010, Viscacha.org
 * @since         1.0
 * @see            http://www.php.de/software-design/50128-formular-validierung.html
 * @abstract
 */
abstract class AbstractValidator {

    private $errors;
    private $messages;
    protected $optional;

    /**
     * Constructs a new validator rule.
     */
    public function  __construct() {
        $this->reset();
        $this->messages = array();
    }

    /**
     * Checks the specified parameter against the rules.
     *
     * @param mixed
     * @return boolean returns true if valid, false if invalid.
     */
    public abstract function isValid($value);

    /**
     * Sets whether this validator is optional or not.
     *
     * @param boolean true = optional, false = required
     */
    public function setOptional($optional) {
        $this->optional = $optional;
    }

    /**
     * Returns the error codes as array.
     *
     * @return array
     */
    public function getErrors() {
        return $this->errors;
    }

    /**
     * Returns the number of errors.
     *
     * @return int
     */
    public function countErrors() {
        return count($this->errors);
    }

    /**
     * Sets the human readable error messages.
     *
     * You have to specify an array with the error codes as keys and the messages itself as values.
     *
     * @param array
     */
    public function setMessages(array $messages) {
        $this->messages = $messages;
    }

    /**
     * Returns the error messages as array.
     *
     * The keys are the error codes and the values are the human readable messages.
     * You have to specify the messages before with AbstractValidator::setMessages().
     * If no error message is found for an error code the error code will be returned as value.
     *
     * @return array
     */
    public function getMessages() {
        $messages = array();
        foreach ($this->errors as $code) {
            if (isset($this->messages[$code]) == true) {
                $messages[$code] = $this->messages[$code];
            }
            else {
                $messages[$code] = $code;
            }
        }
        return $messages;
    }

    /**
     * Adds an error message to the error array.
     *
     * @param string Error code
     */
    protected function setError($error) {
        $this->errors[] = $error;
    }

    /**
     * Resets the validator to be able to validate another value.
     */
    protected function reset() {
        $this->errors = array();
    }

}
?>

<?php
/**
 * Validates that a number is between two numbers.
 *
 * @package        Core
 * @subpackage    Security
 * @author        Matthias Mohr
 * @copyright    Copyright (c) 2004-2010, Viscacha.org
 * @since         1.0
 * @see            http://www.php.de/software-design/50128-formular-validierung.html
 */
class BetweenValidator extends AbstractValidator {

    const NOT_BETWEEN_EXCLUSIVE = 'NOT_BETWEEN_EXCLUSIVE';
    const NOT_BETWEEN_INCLUSIVE = 'NOT_BETWEEN_INCLUSIVE';

    protected $min;
    protected $max;
    protected $inclusive;

    public function  __construct($min, $max, $inclusive = true) {
        parent::__construct();
        $this->min = $min;
        $this->max = $max;
        $this->inclusive = $inclusive;
    }

    public function isValid($value) {
        $this->reset();
        if ($this->optional == true && empty($value) == true) {
            return true;
        }
        if ($this->inclusive == true) {
            if (Numbers::isDecimal($value) == true && $this->min >= $value && $value <= $this->max) {
                return true;
            }
            else {
                $this->setError(self::NOT_BETWEEN_INCLUSIVE);
                return false;
            }
        }
        else {
            if (Numbers::isDecimal($value) == true && $this->min > $value && $value < $this->max) {
                return true;
            }
            else {
                $this->setError(self::NOT_BETWEEN_EXCLUSIVE);
                return false;
            }
        }
    }

}
?>

[robo47]

Schau dir vielleicht mal im Zend Framework die Umsetzung mit Zend_Form + Zend_Validate an, alle Validatoren haben standard-messages, in Kombination mit Zend_Translate hat man da mit ein paar Zeilen auch Übersetzungen ohne händisch am Code was zu ändern (nur über ne Sprachdatei) und das lieses sich theorhetisch ähnlich auch umsetzen um eine zentrale Klasse zu basteln die für die Texte zuständig ist.

Ansonsten kannst du natürlich auch die Formen in extra Datei erstellen, beim Zend Framework sieht das so aus dass man nen init-methode hat die man überschreiben kann:

dann macht man im code nur noch ein $form = new FooForm(); und hat die Klasse mit allen Validatoren und soweiter.

class ContactForm extends Zend_Form
{

    public function init()
    {
        parent::init();
        $this->setAction('/action')
             ->setAttrib('id', 'contactForm');

        $this->addElement('Text',
                          'Betreff',
                          array('label'=>'Betreff: ',
                                'required' => false,
                                'filters' => array(new Zend_Filter_StringTrim())));

        $this->addElement('Text',
                          'Absender',
                          array('label'=>'Name: ',
                                'required' => false,
                                'filters' => array(new Zend_Filter_StringTrim())));

        $this->addElement('Text',
                          'AbsenderEmailadresse',
                          array('label'=>'Email: ',
                                'required' => false,
                                'filters' => array(new Zend_Filter_StringTrim())));

        $this->addElement('Textarea',
                          'Nachricht',
                          array('label'=>'Nachricht:',
                                'required' => true,
                                'rows' => 10,
                                'cols'=> 60,
                                'input' => null,
                                'filters' => array(new Zend_Filter_StringTrim())));


        $this->addElement('Button',
                          'Absenden',
                          array('type' => 'submit'));
    }
} 

hier könnte man auch die form-klasse erweitern und dann eine methode nachs init klemmen die z.b. für alle validatoren automatisch aus einer Datei die passenden Meldungen liest wenn sie projekt-spezifisch sind.

[MaMo-Net]

Hi,

danke für deinen Post. Ich hatte mir Zend_Validate schon angesehen und habe mir nun nochmal genauer Zend_Translate/Locale angesehen, das ist ja im Grunde nichts anderes als ein eindeutiger Key, der dann quasi ersetzt wird durch die entsprechende Sprachstring. So habe ich das im Moment auch schon in der Vorgängerversion implementiert, ich dachte jetzt aber, man könnte das evtl. flexibler gestalten, so dass man verschiedene Sprachstrings nutzen kann, z.B. ne lange ausführliche Erklärung für eine Ausgabe über dem Formular und wenn man z.B. AJAX nutzt nur eine kurzer Hinweis. Nunja, das ist kein Muss, die Key-Ersetzungs-Methode ist ausreichend, aber wäre sicherlich "nice to have".

Die zusätzlichen Klassen pro Validierungszusammenstellung finde ich etwas overkill, das geht ja in die entgegengesetzte Richtung wie ich es eigentlich haben möchte.

Mal gucken ob uns noch was besseres einfällt...

Gruß
MaMo

[dr.e.]

Hallo MaMo-Net,

vielleicht interessiert dich auch der neue Ansatz des APF zum Thema Formular-Validierung. Hier wurde für das neue Release eine Trennung von Validator und zu validierendem Objekt (ebeso für das Thema Filter) nach dem Observer-Pattern eingeführt. Für die Ausgabe der Validierungs-Texte gilt hier das Listener-Prinzip, sprich die Ausgabe-Repräsentation registriert sich als Listener beim Formular-Element, das wiederum von einem externen Validator (Observer) validiert wird. So lassen sich i18n Sprachtexte sehr gut wiederverwenden.

Du arbeitest im Vergleich zum Zend-Framework nicht mit einer expliziten PHP-Klasse, sondern definierst über den HTML/XML-Code dein Formular mit allen seinen Komponenten (Formular-Felder, Messages, Validatoren, Filter, ...) und erreichst über diese lose Kopplung eine sehr gute Wiederverwendbarkeit der Einzel-Komponenten.

Die Zuordnung der Sprach-Werte findet jedoch auch beim APF über Keys statt, die in einer Sprach-Sektion (z.B. "[de]") stehen. Beispiele für diese Art der Formular-Definition findest du im Kapitel Aufbau von Validatoren und Ausgabe von Validator-Fehlermeldungen.

[MaMo-Net]

Hallo dr.e,

danke auch für deinen Beitrag, habe mir deine Seiten kurz angesehen, bin jedoch noch nicht 100%ig durchgestiegen, v.a. wie du das meinst mit dem Observer in Kombination mit den Sprachtexten. Hatte jetzt aber auch noch nicht wieder Zeit en masse, muss mich mit dem Thema Formular-Validierung in ein paar Tagen nochmal auseinandersetzen, derzeit liegen irgendwie laufend andere Dinge an. Außerdem warte ich auf ein neues Buch, das gibt ggf. noch ein wenig Input.

Ich melde mich dann (sicher) nochmal.

Gruß MaMo

[Phoscur]

DomainObjects

Unabhängig von der momentanen Unterhaltung, aber zum Thema:
Ich bin mir nicht sicher wie ich das mit der Validierung machen soll. Ich möchte einen DomainLayer auf PHP- und JavaScript-Seite bauen und würde Validierung direkt im DomainObjekt-Setter ansiedeln. Mir ist dann allerdings auch unklar, wie ich das mit einem Formular verbinde. Für JavaScript könnte man direkt das onChange Event verwenden. Die Kommunikation der JS und PHP DomainObjekte ist eine andere Geschichte, doch die Umsetzung der Validierung interessiert auch mich. Bisher hatte ich nur an eine Bibliotheksklasse Validator gedacht mit verschiedenen Methoden wie isName(), isEmail(), isURL(), isFloat(), isNum(), etc.. So würde ich das denn auf beiden Seiten umsetzen.
Insgesamt habe ich wahrscheinlich gar nicht soviele Formulare (Login + Optionen?).
Welche Probleme können denn bei meinem Aufbau auftreten? Ich bin mir nicht sicher, ob es sich überhaupt lohnt Formulare generisch umzusetzen, mir wird ein Template reichen.
Was spricht dagegen Validierung ins DomainObject zu legen?

[robo47]

Nur um das mal kurz zu erwähnen, weil ich letztens mir auch gedanken über die ganze Validierung/Filterung in Javascript gemacht habe.

Ich bin für mich zu dem Schluss gekommen den overhead das ganze komplett via ajax zu lösen hinzunehmen, weil es für mich schon etwas gegen DRY verstößt in 2 Sprachen das gleiche zu erfinden inklusive tests etc.
Wenn man die gleiche Validierung mit PHP und JS braucht hat, hat man in der Praxis immer die doppelte Menge Code für diesen Bereich. Wenn man neben Validatoren noch Filter nutzt, hat man auch nochmal die ganzen Filter die man auch noch in JS basteln muss.

Wenn man also irgendwann einen neuen Validator oder Filter braucht muss man das ganze dann in JS und PHP entwickeln und testen und vor allem schauen dass es auch in allen Fällen 1:1 immer die gleichen Ergebnisse bringt und man muss irgendwie dann noch die Fehlermeldungen zwischen PHP und Javascript sharen, da kann beispielsweise schon unterschiedliches Verhalten der Regex-Engines von PHP und Javascript Unterschiede bringen und der fakt dass Javascript manche dinge in regex nicht unterstützt die PHP mittels preg_* kann, utf-8, etc.

Also für mich war das ganze im Endeffekt zu viel Overhead auch im Hinblick auf den Aufwand das ganze zu testen und so.

Da ich das Zend Framework nutze, habe ich mir deshalb das hier angeschaut:
Live Validierung mit dem Zend Framework und jQuery | Kristof Dreier
und baue das dann noch etwas aus (Klassen-basierte aktivierung, spinner um auch eventuelle längere validierungsprozesse zu verdeutlichen, einzelfeld-validierung... etc) so kann ich jederzeit einfach einen Filter oder Validator in PHP schreiben und hinzufügen, kein zusätzlicher Code für das JS, Nachteil ist halt der Overhead dass jegliche Validierung immer auch einen http-request bedeutet, womit ich aktuell leben kann, ausserdem erlaubt es mir auch ohne aufwand einfach fremde Validatoren die jemand für ZF-Applikationen geschrieben hat zu nutzen ohne passenden JS-Code zu nutzen.

[MaMo-Net]

Hi,

um die Argumentation von robo47 etwas fortzuführen, es gibt auch diverse Validatoren in meinem Konzept die hinterher auch gegen z.B. eine Datenbank prüfen (z.B. Nutzername schon vorhanden, MX-Prüfung bei E-Mail-Adressen, Passwort-Sicherheit mit Wörterbuch-Check etc.). JS kann ja quasi nur eine textuelle Prüfung durchführen ohne irgendwas dahinter liegendes, daher werde ich diesen Weg auch beschreiten.

@Phoscur Was meinst du mit DomainObject?

Gruß
MaMo

[Phoscur]

@Phoscur Was meinst du mit DomainObject?

Für das Thema müsste man hier topicsprengend ausholen. Ich empfehle dir einfach ein wenig Literatur dazu zu lesen. Die Profis hier wissen aber wovon ich rede.

@robo:
Bei einer viel JavaScript komme ich um einen Haufen Duplikation nicht drumherum, versuche das aber natürlich zu minimieren.

[Koala]

man muß in JS nicht noch mal alles prüfen, und nicht alles doppelt (in PHP und JS) programmieren.

Es reicht doch eine grobe Prüfung ob int, Datum, leer etc.

Die genaue Prüfung erfolgt durch PHP.

[nikosch]

Naja, das ist die Frage. Wenn eine optische OK-Meldung erfolgt und nach dem Submit der selbe Wert als fehlerhaft abgegeben wird, ist das nicht sehr nutzerfreundlich.