Validation des champs de formulaire de tableau en erreur laravel 4

Comment peut-on valider des champs de formulaire qui sont des tableaux? Regardez le code suivant

UserPhone Modèle:

 public static $rules= array(
    'phonenumber'=>'required|numeric',
    'isPrimary'=>'in:0,1'
)
...........

UserController:

$validation = UserPhone::validate(Input::only('phonenumber')));


    if($validation->passes())
      {
         $allInputs = Input::only('phonenumber','tid');
         $loopSize = sizeOf($allInputs);

         for($i=0;$i<$loopSize;$i++)
         {

         $phone = UserPhone::find($allInputs['tid'][$i]);
         $phone->phonenumber = $allInputs['phonenumber'][$i];
         $phone->save();

        }

     return Redirect::to('myprofile')->with('message','Update OK');

  }
  else
  {
     return Redirect::to('editPhone')->withErrors($validation);

  } 

}

la $validation vient d'un BaseModel qui s'étend Éloquent.

De mon point de vue:

 <?php $counter=1; ?>
          @foreach($phones as $thephone)

           <section class="col col-12">
              <label class="label">Phone Number {{$counter++}}</label>
              <label class="input">
              <i class="icon-append icon-phone"></i>
                 {{Form::text('phonenumber[]',$thephone->phonenumber)}}
                 {{Form::hidden('tid[]',$thephone->id)}}
              </label>
            </section>
          @endforeach

Tout fonctionne bien et j'ai tous les numéros de téléphone que je veux dans le Formulaire de mise à Jour, mais je ne peux pas mettre à jour le modèle, car la validation échoue avec le message "Numéro de téléphone doit être un nombre".

Je sais qu'il n'y a pas une solution simple pour la validation de la matrice de champs de formulaire et j'ai essayé d'étendre la classe validator mais sans succès.

Comment puis-je valider ce type de champs?

source d'informationauteur Archimidis M

laravel laravel-4

Voici la solution que j'utilise:

Utilisation

Simplement transformer vos règles habituelles en préfixant each. Par exemple:

'names' => 'required|array|each:exists,users,name'

Noter que le each règle suppose que votre domaine est un tableau, donc n'oubliez pas d'utiliser le array la règle avant, comme illustré ici.

Messages D'Erreur

Messages d'erreur sera automatiquement calculée par la forme singulière (à l'aide de Laravel est str_singular() helper) de votre domaine. Dans l'exemple précédent, l'attribut est name.

Tableaux Imbriqués

Cette méthode fonctionne hors de la boîte avec des tableaux imbriqués quelle que soit la profondeur en pointillé. Par exemple, cela fonctionne:

'members.names' => 'required|array|each:exists,users,name'

Encore une fois, l'attribut utilisé pour les messages d'erreur ici sera name.

Règles Personnalisées

Cette méthode prend en charge aucun de vos règles personnalisées de la boîte.

Mise en œuvre

1. Étendre la classe validator

class ExtendedValidator extends Illuminate\Validation\Validator {

    public function validateEach($attribute, $value, $parameters)
    {
        //Transform the each rule
        //For example, `each:exists,users,name` becomes `exists:users,name`
        $ruleName = array_shift($parameters);
        $rule = $ruleName.(count($parameters) > 0 ? ':'.implode(',', $parameters) : '');

        foreach ($value as $arrayKey => $arrayValue)
        {
            $this->validate($attribute.'.'.$arrayKey, $rule);
        }

        //Always return true, since the errors occur for individual elements.
        return true;
    }

    protected function getAttribute($attribute)
    {
        //Get the second to last segment in singular form for arrays.
        //For example, `group.names.0` becomes `name`.
        if (str_contains($attribute, '.'))
        {
            $segments = explode('.', $attribute);

            $attribute = str_singular($segments[count($segments) - 2]);
        }

        return parent::getAttribute($attribute);
    }
}

2. Enregistrez votre extension de validation

N'importe où dans votre habituelle des emplacements des fichiers d'amorce, ajoutez le code suivant:

Validator::resolver(function($translator, $data, $rules, $messages)
{
    return new ExtendedValidator($translator, $data, $rules, $messages);
});

Et c'est tout! Profitez-en!

Bonus: les règles de Taille avec les tableaux

Comme un commentaire l'a souligné, il n'y a apparemment pas de moyen facile pour valider la taille des matrices. Cependant, la Laravel documentation est incomplète pour les règles de taille: il ne mentionne pas qu'il peut compter les éléments du tableau. Cela signifie que vous êtes réellement permis d'utiliser sizeminmax et between règles pour compter les éléments d'un tableau.

Il fonctionne le mieux pour étendre la classe de validation et de ré-utiliser le Validateur fonctions:

Validator::resolver(function($translator, $data, $rules, $messages)
{

    return new Validation($translator, $data, $rules, $messages);

});

class Validation extends Illuminate\Validation\Validator {

    /**
     * Magically adds validation methods. Normally the Laravel Validation methods
     * only support single values to be validated like 'numeric', 'alpha', etc.
     * Here we copy those methods to work also for arrays, so we can validate
     * if a value is OR an array contains only 'numeric', 'alpha', etc. values.
     *
     * $rules = array(
     *     'row_id' => 'required|integerOrArray', //"row_id" must be an integer OR an array containing only integer values
     *     'type'   => 'inOrArray:foo,bar' //"type" must be 'foo' or 'bar' OR an array containing nothing but those values
     * );
     *
     * @param string $method Name of the validation to perform e.g. 'numeric', 'alpha', etc.
     * @param array $parameters Contains the value to be validated, as well as additional validation information e.g. min:?, max:?, etc.
     */
    public function __call($method, $parameters)
    {

        //Convert method name to its non-array counterpart (e.g. validateNumericArray converts to validateNumeric)
        if (substr($method, -7) === 'OrArray')
            $method = substr($method, 0, -7);

        //Call original method when we are dealing with a single value only, instead of an array
        if (! is_array($parameters[1]))
            return call_user_func_array(array($this, $method), $parameters);

        $success = true;
        foreach ($parameters[1] as $value) {
            $parameters[1] = $value;
            $success &= call_user_func_array(array($this, $method), $parameters);
        }

        return $success;

    }

    /**
     * All ...OrArray validation functions can use their non-array error message counterparts
     *
     * @param mixed $attribute The value under validation
     * @param string $rule Validation rule
     */
    protected function getMessage($attribute, $rule)
    {

        if (substr($rule, -7) === 'OrArray')
            $rule = substr($rule, 0, -7);

        return parent::getMessage($attribute, $rule);

    }
}

4

chacun()

Il n'est pas dans les docs, mais le 4.2 de la branche peut avoir une solution simple autour de la ligne 220.

Tout comme le sometimes($attribute, $rules, callable $callback) fonction, il est maintenant un each($attribute, $rules) fonction.

De l'utiliser, le code pourrait être quelque chose de plus simple qu'un sometimes() appel:
```
$v->each('array_attribute',array('rule','anotherRule')); //$v is your validator
```
Mises en garde
- sometimes() et each() ne semblent pas être facilement chainable les uns avec les autres donc, si vous voulez faire spécifiquement conditionnée règles sur les valeurs de tableau, vous êtes mieux avec de la magie des solutions dans d'autres réponses pour l'instant.
- each() ne va que d'un niveau de profondeur ce qui n'est pas différent des autres solutions. La bonne chose à propos de la magie de solutions, c'est qu'ils vont de 0 ou de 1 niveau profond, au besoin, par l'appel de la base de règles de manière appropriée, de sorte que je suppose que si vous vouliez aller de 1 à 2 niveaux de profondeur, vous pouvez simplement fusionner les deux approches en appelant each() et de transmettre la magie de la règle de l'autre des réponses.
- each() ne prend qu'un seul attributpas un tableau d'attributs comme sometimes() n', mais l'ajout de cette fonctionnalité pour each() ne serait pas un énorme changement pour la each() fonction - il suffit de faire une boucle par la $attribute et array_merge() $data et la array_get() résultat. Quelqu'un peut faire un pull request sur le master s'ils voient qu'il est souhaitable, et il n'a pas déjà été fait, et nous pouvons voir si il le fait dans une version future.

Voici une mise à jour du code de Ronald, parce que mes règles personnalisées ne marcherait pas avec l'extension tableau. Testé avec Laravel 4.1, les règles par défaut, les règles étendues, ...

public function __call($method, $parameters) {
    $isArrayRule = FALSE;
    if(substr($method, -5) === 'Array') {
        $method = substr($method, 0, -5);
        $isArrayRule = TRUE;
    }

    //
    $rule = snake_case(substr($method, 8));

    //Default or custom rule
    if(!$isArrayRule) {
        //And we have a default value (not an array)
        if(!is_array($parameters[1])) {
            //Try getting the custom validation rule
            if(isset($this->extensions[$rule])) {
                return $this->callExtension($rule, $parameters);
            }

            //None found
            throw new \BadMethodCallException("Method [$method] does not exist.");
        } //Array given for default rule; cannot be!
        else return FALSE;
    }

    //Array rules
    $success = TRUE;
    foreach($parameters[1] as $value) {
        $parameters[1] = $value;

        //Default rule exists, use it
        if(is_callable("parent::$method")) {
            $success &= call_user_func_array(array($this, $method), $parameters);
        } else {
            //Try a custom rule
            if(isset($this->extensions[$rule])) {
                $success &= $this->callExtension($rule, $parameters);
            }

            //No custom rule found
            throw new \BadMethodCallException("Method [$method] does not exist.");
        }
    }

    //Did any of them (array rules) fail?
    return $success;
}

1

Il y a maintenant de la matrice de règles de validation dans le cas où cette aide à quelqu'un. Il ne semble pas que cela a été écrit dans les docs encore.

https://github.com/laravel/laravel/commit/6a2ad475cfb21d12936cbbb544d8a136fc73be97

Vous devez vous connecter pour publier un commentaire.