repo_zf1/documentation/manual/fr/module_specs/Zend_Validate-WritingValidators.xml

<?xml version="1.0" encoding="utf-8"?>
<!-- EN-Revision: 11089 -->
<!-- Reviewed: no -->
<sect1 id="zend.validate.writing_validators">
    <title>Écrire des validateurs</title>

    <para><classname>Zend_Validate</classname> fournit un ensemble de validateurs habituellement nécessaires, mais inévitablement,
    les développeurs souhaiteront écrire des validateurs sur mesure pour leurs besoins particuliers. La méthode
    d'écriture d'un validateur personnalisé est décrit dans cette section.</para>

    <para><classname>Zend_Validate_Interface</classname> définit trois méthodes, <code>isValid()</code>,
    <code>getMessages()</code>, et <code>getErrors()</code>, qui peuvent être implémentées par des classes d'utilisateur
    afin de créer les objets de validation sur mesure. Un objet qui implémente l'interface
    <classname>Zend_Validate_Interface</classname> peut être ajouté à une chaîne de validateur avec
    <classname>Zend_Validate::addValidator()</classname>. De tels objets peuvent également être employés avec <link
    linkend="zend.filter.input"><classname>Zend_Filter_Input</classname></link>.</para>

    <para>Comme vous avez déjà pu déduire de la description ci-dessus de <classname>Zend_Validate_Interface</classname>, les
    classes de validation fournie avec Zend Framework retourne une valeur booléenne pour savoir si une valeur est
    validée ou non. Elles fournissent également des informations sur la raison pour laquelle la validation a échoué sur
    une valeur. La mise à disposition de ces raisons d'échec de validation peut être utilisée par une application dans
    différents buts, tels que fournir des statistiques pour l'analyse de la facilité d'utilisation.</para>

    <para>La fonctionnalité de base de message d'échec de validation est implémentée dans
    <classname>Zend_Validate_Abstract</classname>. Pour inclure cette fonctionnalité en créant une classe de validation, étendez
    simplement <classname>Zend_Validate_Abstract</classname>. Dans la classe étendue vous implémenteriez la logique de la méthode
    <code>isValid()</code> et définiriez les variables de message et les modèles de message qui correspondent aux types
    d'échecs de validation qui peuvent se produire. Si une valeur ne passe pas vos essais de validation, alors
    <code>isValid()</code> devrait renvoyer <code>false</code>. Si la valeur passe vos essais de validation, alors
    <code>isValid()</code> devrait renvoyer <code>true</code>.</para>

    <para>En général, la méthode <code>isValid()</code> ne devrait lever aucune exception, excepté où il est impossible
    de déterminer si la valeur d'entrée est valide. Quelques exemples de cas raisonnables pour lever une exception
    pourraient être si un fichier ne peut pas être ouvert, un serveur de LDAP ne pourraient pas être contacté, ou une
    connexion de base de données est indisponible, où quand une telle chose peut être exigée pour que le succès ou
    l'échec de validation soit déterminé.</para>

    <example id="zend.validate.writing_validators.example.simple">
        <title>Création d'une simple classe de validation</title>

        <para>L'exemple suivant démontre comment un validateur personnalisé très simple pourrait être écrit. Dans ce
        cas-ci les règles de validation sont simplement que la valeur d'entrée doit être une valeur en virgule
        flottante. <programlisting role="php"><![CDATA[
class MonValidateur_Float extends Zend_Validate_Abstract
{
    const FLOAT = 'float';

    protected $_messageTemplates = array(
        self::FLOAT => "'%value%' n'est pas une valeur en virgule flottante"
    );

    public function isValid($value)
    {
        $this->_setValue($value);

        if (!is_float($value)) {
            $this->_error();
            return false;
        }

        return true;
    }
}
]]></programlisting> La classe définit un modèle pour son message unique d'échec de validation, qui inclut le paramètre
        magique intégré, <code>%value%</code>. L'appel à <code>_setValue()</code> prépare l'objet pour insérer
        automatiquement la valeur examinée dans le message d'échec, si la validation de la valeur échoue. L'appel à
        <code>_error()</code> trace la raison d'échec de validation. Puisque cette classe définit seulement un message
        d'échec, il n'est pas nécessaire de fournir à <code>_error()</code> le nom du modèle de message d'échec.</para>
    </example>

    <example id="zend.validate.writing_validators.example.conditions.dependent">
        <title>Écriture d'une classe de validation ayant des conditions de dépendances</title>

        <para>L'exemple suivant démontre un ensemble plus complexe de règles de validation, où on l'exige que la valeur
        d'entrée doit être numérique et dans la plage des valeurs limites minimum et maximum. Une valeur d'entrée ferait
        échouer la validation pour exactement une des raisons suivantes : <itemizedlist>
                <listitem>
                    <para>La valeur d'entrée n'est pas numérique.</para>
                </listitem>

                <listitem>
                    <para>La valeur d'entrée est inférieure que la valeur permise minimum.</para>
                </listitem>

                <listitem>
                    <para>La valeur d'entrée est supérieure que la valeur permise maximum.</para>
                </listitem>
            </itemizedlist></para>

        <para>Ces raisons d'échec de validation sont alors traduites dans les définitions de la classe : <programlisting
        role="php"><![CDATA[
class MonValidateur_NumericBetween extends Zend_Validate_Abstract
{
    const MSG_NUMERIC = 'msgNumeric';
    const MSG_MINIMUM = 'msgMinimum';
    const MSG_MAXIMUM = 'msgMaximum';

    public $minimum = 0;
    public $maximum = 100;

    protected $_messageVariables = array(
        'min' => 'minimum',
        'max' => 'maximum'
    );

    protected $_messageTemplates = array(
        self::MSG_NUMERIC => "'%value%' n'est pas numérique",
        self::MSG_MINIMUM => "'%value%' doit être supérieure à '%min%'",
        self::MSG_MAXIMUM => "'%value%' doit être inférieure à '%max%'"
    );

    public function isValid($value)
    {
        $this->_setValue($value);

        if (!is_numeric($value)) {
            $this->_error(self::MSG_NUMERIC);
            return false;
        }

        if ($value < $this->minimum) {
            $this->_error(self::MSG_MINIMUM);
            return false;
        }

        if ($value > $this->maximum) {
            $this->_error(self::MSG_MAXIMUM);
            return false;
        }

        return true;
    }
}
]]></programlisting> Les propriétés publiques <code>$minimum</code> et <code>$maximum</code> ont été établies pour
        fournir les frontières minimum et maximum d'une valeur pour qu'elle soit validée avec succès. La classe définit
        également deux variables de message qui correspondent aux propriétés publiques et permettent que
        <code>min</code> et <code>max</code> soient employés dans des modèles de message en tant que paramètres
        magiques, comme avec <code>value</code>.</para>

        <para>Noter que si n'importe quel élément de la validation vérifié dans <code>isValid()</code> échoue, un
        message approprié d'échec est préparé, et la méthode renvoie immédiatement <code>false</code>. Ces règles de
        validation sont donc séquentiellement dépendantes. C'est-à-dire, que si un essai échoue, il n'y a aucun besoin
        d'examiner les règles suivantes de validation. Ce besoin peut exister, cependant. L'exemple suivant illustre
        comment écrire une classe ayant des règles indépendantes de validation, où l'objet de validation peut renvoyer
        des raisons multiples pour lesquelles une tentative particulière de validation a échoué.</para>
    </example>

    <example id="zend.validate.writing_validators.example.conditions.independent">
        <title>Validation avec des conditions indépendantes, avec raisons multiples d'échec</title>

        <para>Considérons l'écriture d'une classe de validation pour le contrôle de résistance d'un mot de passe - quand
        un utilisateur est requis afin de choisir un mot de passe qui respecte certains critères pour aider à la
        sécurisation des comptes d'utilisateur. Supposons que les critères de sécurité de mot de passe imposent que le
        mot de passe : <itemizedlist>
                <listitem>
                    <para>est au moins une longueur de 8 caractères,</para>
                </listitem>

                <listitem>
                    <para>contient au moins une lettre majuscule,</para>
                </listitem>

                <listitem>
                    <para>contient au moins une lettre minuscule,</para>
                </listitem>

                <listitem>
                    <para>et contient au moins un caractère de chiffre.</para>
                </listitem>
            </itemizedlist></para>

        <para>La classe suivante implémente ces critères de validation : <programlisting role="php"><![CDATA[
class MonValidateur_PasswordStrength extends Zend_Validate_Abstract
{
    const LENGTH = 'length';
    const UPPER  = 'upper';
    const LOWER  = 'lower';
    const DIGIT  = 'digit';

    protected $_messageTemplates = array(
        self::LENGTH =>
            "'%value%' doit avoir une longueur d'au moins 8 caractères",
        self::UPPER  =>
            "'%value%' doit contenir au moins une lettre majuscule",
        self::LOWER  =>
            "'%value%' doit contenir au moins une lettre minuscule",
        self::DIGIT  =>
            "'%value%' doit contenir au moins un chiffre"
    );

    public function isValid($value)
    {
        $this->_setValue($value);

        $isValid = true;

        if (strlen($value) < 8) {
            $this->_error(self::LENGTH);
            $isValid = false;
        }

        if (!preg_match('/[A-Z]/', $value)) {
            $this->_error(self::UPPER);
            $isValid = false;
        }

        if (!preg_match('/[a-z]/', $value)) {
            $this->_error(self::LOWER);
            $isValid = false;
        }

        if (!preg_match('/\d/', $value)) {
            $this->_error(self::DIGIT);
            $isValid = false;
        }

        return $isValid;
    }
}
]]></programlisting>Noter que les quatre critères d'essais dans <code>isValid()</code> ne renvoient pas immédiatement
        <code>false</code>. Ceci permet à la classe de validation de fournir toutes les raisons pour lesquelles le mot
        de passe d'entrée n'a pas réussi à remplir les conditions de validation. Si, par exemple, un utilisateur entre
        la chaîne "<code>#$%</code>" comme mot de passe, <code>isValid()</code> entraînera que les quatre messages
        d'échec de validation seront retournés lors de l'appel suivant à <code>getMessages()</code>.</para>
    </example>
</sect1>