[MVC] - Probleme $validate et gestion des erreurs avec une table

Peut etre une piste pour tes messages,
perso j'ai refait la classe de validation pour avoir plusieurs règles par champs par exemple et j'ai une classe à part qui gere la validation le controle ne se fait plus dans le model (je trouve ca plus simple)
ensuite pour tes message tu peux au lieu de mettre un message mettre une variable du type MA_VAR et après deux solutions lorsque tu as une erreur soit tu récupère les données dans un fichier soit dans une table le tout en passant par une fonction get_message dans ta classe par exemple

@dragonball

Merci pour cette première réponse.
Pourrais-tu me montrer tes différentes fonctions et ta classe de validation, pour avoir un exemple ??

Ce n'est pas bête, par contre ça me fait modifier toutes mes validations. Je vais voir ça et y réfléchir encore.

je me suis pas mal inspiré de la classe de validation de cake

<?php
class Validation {
/**
 * Some complex patterns needed in multiple places
 *
 * @var array
 * @access private
 */
    var $__pattern = array(
        'hostname' => '(?:[a-z0-9]-a-z0-9]*\.)*(?:[a-z0-9]-a-z0-9]{0,62})\.(?:(?:[a-z]{2}\.)?[a-z]{2,4}|museum|travel)'
    );  

/**
 * Cette fonction va renvoyer une instance de la classe car en static $this n'est pas accessible
 *
 * @return object Instance de la classe Validation
 */ 
    function &getInstance() {

        static $instance = array();
        if(!$instance) { $instance[0] = &new Validation(); }
        return $instance[0];
    }   

/**
 * Cette fonction va lancer la règle de validation
 *
 * @param varchar $val Valeur à tester
 * @param mixed $rule Règle de validation à lancer
 * @return boolean
 */ 
    static function check($val, $rule) {

        $_this = &Validation::getInstance(); //On va créer une instence de la classe car en static l'objet $this n'est pas accessible

        //Si la règle est un tableau
        if(is_array($rule)) { 

            $function = $rule[0]; //On récupère la fonction qui sera toujours dans la première clée du tableau
            unset($rule[0]); //On la supprime la fonction du tableau de règle

        } 
        else { $function = $rule; } //Sinon on affecte directement la fonction

        if(method_exists($_this, $function)) { //On teste si la méthode existe dans la classe

            $params = am(array($val), $rule); //On génère une variable contenant les paramètres de la fonction
            return call_user_func_array(array($_this, $function), $params); //Et on retourne le résultat de la fonction

        } else { return false; } //Si la méthode n'existe pas on génère une erreur
    }

/**
 * Cette fonction va contrôler que la valeur passée en paramètre n'est pas vide
 *
 * @param varchar $val Valeur à tester
 * @return boolean
 */ 
    static function notEmpty($val) { return !empty($val); }
/**
 * Cette fonction va contrôler que la valeur passée en paramètre est bien un email
 *
 * @param varchar $val Valeur à tester
 * @return boolean
 */ 
    static function email($val) { 
        $_this = &Validation::getInstance(); //On va créer une instence de la classe car en static l'objet $this n'est pas accessible
        $regex = '/^[a-z0-9!#$%&\'*+\/=?^_`{|}~-]+(?:\.[a-z0-9!#$%&\'*+\/=?^_`{|}~-]+)*@' . $_this->__pattern'hostname'] . '$/i';
        return preg_match($regex, $val) ? true : false; 
    }
/**
 * Cette fonction va contrôler que la valeur passée en paramètre ne contient que des lettres
 *
 * @param varchar $val Valeur à tester
 * @return boolean
 */     
    static function alphabetic($val) { return preg_match('/^(ÀÂÇÈÉÊËÎÏÔÙÛÜàâçèéêëîïôùûüa-zA-Z -]+)$/', $val) ? true : false; }
/**
 * Cette fonction va contrôler que la valeur passée en paramètre ne contient que des lettres et des chiffres
 *
 * @param varchar $val Valeur à tester
 * @return boolean
 */ 
    static function alphanumeric($val) { return preg_match('/^(ÀÂÇÈÉÊËÎÏÔÙÛÜàâçèéêëîïôùûüa-zA-Z0-9 -]+)$/', $val) ? true : false; }
/**
 * Cette fonction va contrôler que la valeur passée en paramètre ne contient que des nombres
 *
 * @param varchar $val Valeur à tester
 * @return boolean
 */ 
    static function numeric($val) { return is_numeric($val); }
/**
 * Cette fonction va contrôler que la valeur passée en paramètre ne contient pas plus de x caractères ou n'est pas supérieur à x
 *
 * @param mixed $val Valeur à tester
 * @param integer $x Longueur maximale possible
 * @return boolean
 */ 
    static function maxLength($val, $x) {

        if(is_int($val)) return ($val > $x) ? false : true; //Si c'est un entier il ne doit pas être supérieur $x
        else if(is_string($val)) return (strlen($val) > $x) ? false : true; //Si c'est une chaine de caractères elle ne doit pas contenir plus de $x caractères
    }
/**
 * Cette fonction va contrôler que la valeur passée en paramètre ne contient pas moins de x caractères ou n'est pas inférieure à x
 *
 * @param mixed $val Valeur à tester
 * @param integer $x Longueur minimale possible
 * @return boolean
 */     
    static function minLength($val, $x) {

        if(is_int($val)) return ($val < $x) ? false : true; //Si c'est un entier il ne doit pas être inférieur $x
        else if(is_string($val)) return (strlen($val) < $x) ? false : true; //Si c'est une chaine de caractères elle ne doit pas contenir mois de $x caractères
    }

/**
 * Cette fonction va contrôler que la valeur passée en paramètre est comprise entre les valeurs de la variable $range
 *
 * @param mixed $val Valeur à tester
 * @param integer $min Valeur minimum
 * @param integer $max Valeur maximum
 * @return boolean
 */ 
    static function between($val, $min, $max) {

        if(is_int($val)) return ($val < $min || $val > $max) ? false : true;
        else if(is_string($val)) return (strlen($val) < $min || strlen($val) > $max) ? false : true;
    }

/**
 * Cette fonction va contrôler que la valeur passée en paramètre est conforme à l'expression régulière
 *
 * @param varchar $val Valeur à tester
 * @param varchar $regex expression régulière
 * @return boolean
 */     
    static function custom($val, $regex) { return (!preg_match($regex, $val)) ? false : true; }
/**
 * Checks that a value is a valid URL according to http://www.w3.org/Addressing/URL/url-spec.txt
 *
 * The regex checks for the following component parts:
 *
 * - a valid, optional, scheme
 * - a valid ip address OR
 * a valid domain name as defined by section 2.3.1 of http://www.ietf.org/rfc/rfc1035.txt
 * with an optional port number
 * - an optional valid path
 * - an optional query string (get parameters)
 * - an optional fragment (anchor tag)
 *
 * @param string $check Value to check
 * @param boolean $strict Require URL to be prefixed by a valid scheme (one of http(s)/ftp(s)/file/news/gopher)
 * @return boolean Success
 * @access public
 */ 
    static function url($val, $strict = false) {

        $_this = &Validation::getInstance();
        $_this->__populateIp();
        $validChars = '(' . preg_quote('!"$&\'()*+,-.@_:;=~') . '\/0-9a-z\p{L}\p{N}]|(%[0-9a-f]{2}))';

        $regex = 
            '/^(?:(?:https?|ftps?|file|news|gopher):\/\/)' . (!empty($strict) ? '' : '?') .
            '(?:' . $_this-> __pattern'IPv4'] . '|\' . $_this->__ pattern'IPv6'] . '\]|' . $_this->__pattern'hostname'] . ')' .
            '(?::[1-9][0-9]{0,4})?' .
            '(?:\/?|\/' . $validChars . '*)?' .
            '(?:\?' . $validChars . '*)?' .
            '(?:#' . $validChars . '*)?$/iu';

        return preg_match($regex, $val) ? true : false;
    }

/*
 * Lazily popualate the IP address patterns used for validations
 *
 * @return void
 * @access private
 */
    function __populateIp() {

        if (!isset($this->__pattern'IPv6'])) {
            $pattern = '((([0-9A-Fa-f]{1,4}:){7}(([0-9A-Fa-f]{1,4})|:))|(([0-9A-Fa-f]{1,4}:){6}';
            $pattern .= '(:|((25[0-5]|2[0-4]\d|[01]?\d{1,2})(\.(25[0-5]|2[0-4]\d|[01]?\d{1,2})){3})';
            $pattern .= '|(:[0-9A-Fa-f]{1,4})))|(([0-9A-Fa-f]{1,4}:){5}((:((25[0-5]|2[0-4]\d|[01]?\d{1,2})';
            $pattern .= '(\.(25[0-5]|2[0-4]\d|[01]?\d{1,2})){3})?)|((:[0-9A-Fa-f]{1,4}){1,2})))|(([0-9A-Fa-f]{1,4}:)';
            $pattern .= '{4}(:[0-9A-Fa-f]{1,4}){0,1}((:((25[0-5]|2[0-4]\d|[01]?\d{1,2})(\.(25[0-5]|2[0-4]\d|[01]?\d{1,2}))';
            $pattern .= '{3})?)|((:[0-9A-Fa-f]{1,4}){1,2})))|(([0-9A-Fa-f]{1,4}:){3}(:[0-9A-Fa-f]{1,4}){0,2}';
            $pattern .= '((:((25[0-5]|2[0-4]\d|[01]?\d{1,2})(\.(25[0-5]|2[0-4]\d|[01]?\d{1,2})){3})?)|';
            $pattern .= '((:[0-9A-Fa-f]{1,4}){1,2})))|(([0-9A-Fa-f]{1,4}:){2}(:[0-9A-Fa-f]{1,4}){0,3}';
            $pattern .= '((:((25[0-5]|2[0-4]\d|[01]?\d{1,2})(\.(25[0-5]|2[0-4]\d|[01]?\d{1,2}))';
            $pattern .= '{3})?)|((:[0-9A-Fa-f]{1,4}){1,2})))|(([0-9A-Fa-f]{1,4}:)(:[0-9A-Fa-f]{1,4})';
            $pattern .= '{0,4}((:((25[0-5]|2[0-4]\d|[01]?\d{1,2})(\.(25[0-5]|2[0-4]\d|[01]?\d{1,2})){3})?)';
            $pattern .= '|((:[0-9A-Fa-f]{1,4}){1,2})))|(:(:[0-9A-Fa-f]{1,4}){0,5}((:((25[0-5]|2[0-4]';
            $pattern .= '\d|[01]?\d{1,2})(\.(25[0-5]|2[0-4]\d|[01]?\d{1,2})){3})?)|((:[0-9A-Fa-f]{1,4})';
            $pattern .= '{1,2})))|(((25[0-5]|2[0-4]\d|[01]?\d{1,2})(\.(25[0-5]|2[0-4]\d|[01]?\d{1,2})){3})))(%.+)?';
            $this->__pattern'IPv6'] = $pattern;
        }
        if (!isset($this->__pattern'IPv4'])) {
            $pattern = '(?:(?:25[0-5]|2[0-4][0-9]|(?:(?:1[0-9])?|[1-9]?)[0-9])\.){3}(?:25[0-5]|2[0-4][0-9]|(?:(?:1[0-9])?|[1-9]?)[0-9])';
            $this->__pattern'IPv4'] = $pattern;
        }
    }   
}
?>

Oui je sais j'avais pas trop envi de me faire .....

Donc ensuite dans le model

/**
 * Cette fonction est en charge de la validation des données avant modification de la base de données
 *
 * @param object $datas Données à sauvegarder
 * @return boolean Retourne vrai si la validation est correcte, faux sinon
 */ 
    function validates($datas) {

        if(isset($this->validate)) { //Si on a un tableau de validation dans la classe

            $errors = array(); //Tableau d'erreurs qui sera retourné

            foreach($this->validate as $k => $v) { //On va parcourir tous les champs à valider

                //Par défaut si le champ est présent dans les données à valider 
                //mais pas dans les données envoyées par le formulaire on génère une erreur
                if(!isset($datas->$k)) { $errors$k] = $v'message']; } 
                else {
                    $isValid = false; //Par défaut on renverra toujours faux

                    //On va tester si il y à plusieurs règles de validation
                    //Si on a pas directement accès à la clée rule cela signifie qu'il y à plusieurs règles
                    if(!isset($v'rule'])) {

                        //On va donc les parcourir
                        foreach($v as $kRule => $vRule) { 

                            $isValid = Validation::check($datas->$k, $vRule'rule']); 
                            if(!$isValid) { $errors$k]$kRule] = $vRule'message']; } //On injecte le message
                        }   
                    } else { 

                        $isValid = Validation::check($datas->$k, $v'rule']); 
                        if(!$isValid) { $errors$k] = $v'message']; } //On injecte le message
                    }
                }
            }   

            $this->errors = $errors;

            if(isset($this->Form)) { $this->Form->errors = $errors; } //On injecte les messages d'erreurs dans la gestion des formulaires

            //return false;

            if(empty($errors)) { return true; }
            else { return false; }
        } else {

            return true;
        }
    }

Voila en gros comment je fais bon j'ai fait ça a l'arrache donc si il y a des améliorations possibles je prend
:)

bonjour,
Rien à voir avec votre question, mais lorsque j'ai lu le code de dragonball dans son dernier post, j'ai remarquer la syntaxe suivante :

$params = am(array($val), $rule);

Que veux dire la syntaxe am.

Cordialement