Symfony2 : Comment obtenir le formulaire de validation des erreurs, après liaison de la demande pour la forme

Vous avez deux façons de le faire:

• ne pas rediriger l'utilisateur sur l'erreur et l'affichage {{ form_errors(form) }} au sein de fichier de modèle
• erreur d'accès à la matrice comme $form->getErrors()

Ci-dessous est la solution qui a fonctionné pour moi. Cette fonction est dans un contrôleur et retournera un tableau structuré de tous les messages d'erreur et le champ qui les ont provoquées.

Symfony 2.0:

private function getErrorMessages(\Symfony\Component\Form\Form $form) {
    $errors = array();
    foreach ($form->getErrors() as $key => $error) {
        $template = $error->getMessageTemplate();
        $parameters = $error->getMessageParameters();

        foreach($parameters as $var => $value){
            $template = str_replace($var, $value, $template);
        }

        $errors[$key] = $template;
    }
    if ($form->hasChildren()) {
        foreach ($form->getChildren() as $child) {
            if (!$child->isValid()) {
                $errors[$child->getName()] = $this->getErrorMessages($child);
            }
        }
    }

    return $errors;
}

Symfony 2.1 et plus récente:

private function getErrorMessages(\Symfony\Component\Form\Form $form) {      
    $errors = array();

    if ($form->hasChildren()) {
        foreach ($form->getChildren() as $child) {
            if (!$child->isValid()) {
                $errors[$child->getName()] = $this->getErrorMessages($child);
            }
        }
    } else {
        foreach ($form->getErrors() as $key => $error) {
            $errors[] = $error->getMessage();
        }   
    }

    return $errors;
}

Pour obtenir bon (traduisible) messages, actuellement à l'aide de SF 2.6.3, voici ma dernière fonction (comme aucun des ci-dessus semblent plus travailler):

 private function getErrorMessages(\Symfony\Component\Form\Form $form) {      
    $errors = array();
    foreach ($form->getErrors(true, false) as $error) {
        //My personnal need was to get translatable messages
        //$errors[] = $this->trans($error->current()->getMessage());
        $errors[] = $error->current()->getMessage();
    }

    return $errors;
}

que la Forme::méthode getErrors() renvoie une instance de FormErrorIterator, sauf si vous passez le deuxième argument ($aplatir) à vrai. (Il sera ensuite de retour à un FormError exemple, et vous devrez appeler la méthode getMessage() directement, sans les() méthode:

 private function getErrorMessages(\Symfony\Component\Form\Form $form) {      
    $errors = array();
    foreach ($form->getErrors(true, true) as $error) {
        //My personnal need was to get translatable messages
        //$errors[] = $this->trans($error->getMessage());
        $errors[] = $error->getMessage();
    }

    return $errors;
}

)

La chose la plus importante est en fait de définir le premier argument à true afin d'obtenir les erreurs.
Laissant le second argument ($aplatir) à sa valeur par défaut (vrai) sera de retour FormError cas, tandis qu'il sera de retour FormErrorIterator cas lorsque la valeur est false.

Pour mes messages flash j'ai été heureux avec $form->getErrorsAsString()

Modifier (à partir de Benji_X80):
Pour SF3 utilisation $form->getErrors(true, false);

Vous pouvez également utiliser le service validator pour obtenir des violations de contrainte:

$errors = $this->get('validator')->validate($user);

SYMFONY 3.X

Autres SF 3.X les méthodes indiquées ici ne fonctionne pas pour moi parce que je pouvais envoyer les données vide à la forme (mais j'ai NotNull/NotBlanck contraintes). Dans ce cas, la chaîne de l'erreur devrait ressembler à ceci :

string(282) "ERROR: This value should not be blank.
ERROR: This value should not be blank.
ERROR: This value should not be blank.
ERROR: This value should not be blank.
ERROR: This value should not be blank.
ERROR: This value should not be null.
name:
    ERROR: This value should not be blank.
"

Qui n'est pas très utile. J'ai donc fait ceci:

public function buildErrorArray(FormInterface $form)
{
    $errors = [];

    foreach ($form->all() as $child) {
        $errors = array_merge(
            $errors,
            $this->buildErrorArray($child)
        );
    }

    foreach ($form->getErrors() as $error) {
        $errors[$error->getCause()->getPropertyPath()] = $error->getMessage();
    }

    return $errors;
}

Qui permettrait le retour que :

array(7) {
  ["data.name"]=>
  string(31) "This value should not be blank."
  ["data.street"]=>
  string(31) "This value should not be blank."
  ["data.zipCode"]=>
  string(31) "This value should not be blank."
  ["data.city"]=>
  string(31) "This value should not be blank."
  ["data.state"]=>
  string(31) "This value should not be blank."
  ["data.countryCode"]=>
  string(31) "This value should not be blank."
  ["data.organization"]=>
  string(30) "This value should not be null."
}

Si vous utilisez les validateurs personnalisés, Symfony ne retourne pas d'erreurs générés par ces validateurs dans $form->getErrors(). $form->getErrorsAsString() sera de retour toutes les erreurs que vous avez besoin, mais sa sortie est malheureusement formaté comme une chaîne de caractères, pas un tableau.

La méthode que vous utilisez pour obtenir toutes les erreurs (peu importe d'où ils viennent), dépend de la version de Symfony que vous utilisez.

La plupart des solutions proposées impliquent la création d'une fonction récursive, qui analyse toutes les formes d'enfants, et des extraits pertinents des erreurs dans un tableau. Symfony 2.3 n'a pas le $form->hasChildren() fonction, mais il n'ont $form->all().

Ici est une classe d'assistance pour Symfony 2.3, que vous pouvez utiliser pour extraire toutes les erreurs de toute forme.
(Il est basé sur le code d'un commentaire par yapro sur un bogue lié à un ticket de Symfony github compte.)

namespace MyApp\FormBundle\Helpers;

use Symfony\Component\Form\Form;

class FormErrorHelper
{
    /**
     * Work-around for bug where Symfony (2.3) does not return errors from custom validaters,
     * when you call $form->getErrors().
     * Based on code submitted in a comment here by yapro:
     * https://github.com/symfony/symfony/issues/7205
     *
     * @param Form $form
     * @return array Associative array of all errors
     */
    public function getFormErrors($form)
    {
        $errors = array();

        if ($form instanceof Form) {
            foreach ($form->getErrors() as $error) {
                $errors[] = $error->getMessage();
            }

            foreach ($form->all() as $key => $child) {
                /** @var $child Form */
                if ($err = $this->getFormErrors($child)) {
                    $errors[$key] = $err;
                }
            }
        }

        return $errors;
    }
}

Code d'appel:

namespace MyApp\ABCBundle\Controller;

use MyApp\FormBundle\Helpers;

class MyController extends Controller
{
    public function XYZAction()
    {
        //Create form.

        if (!$form->isValid()) {
            $formErrorHelper = new FormErrorHelper();
            $formErrors = $formErrorHelper->getFormErrors($form);

            //Set error array into twig template here.
        }
    }

}

Pour Symfony 2.1, et ce, pour une utilisation avec des Rameaux d'affichage d'erreur j'ai modifié la fonction pour ajouter un FormError au lieu de simplement les récupérer, de cette façon, vous avez plus de contrôle sur les erreurs et ne pas avoir à utiliser error_bubbling sur chaque entrée. Si vous ne définissez pas de la manière ci-dessous {{ form_errors(form) }} restera vide:

/**
 * @param \Symfony\Component\Form\Form $form
 *
 * @return void
 */
private function setErrorMessages(\Symfony\Component\Form\Form $form) {      

    if ($form->count() > 0) {
        foreach ($form->all() as $child) {
            if (!$child->isValid()) {
                if( isset($this->getErrorMessages($child)[0]) ) {
                    $error = new FormError( $this->getErrorMessages($child)[0] );
                    $form->addError($error);
                }
            }
        }
    }

}

Je suis venu avec cette solution. Il fonctionne solide avec la dernière Symfony 2.4.

Je vais essayer de donner quelques explications.

À l'aide d'une validateur

Je pense que c'est une mauvaise idée d'utiliser distinct de validation pour valider les entités et retour violation de la contrainte de messages, comme suggéré par d'autres auteurs.

1. Vous devez valider manuellement toutes les entités, spécifiez les groupes de validation, etc, etc. Avec le complexe des formes hiérarchiques, il n'est pas pratique du tout et va sortir de mains rapidement.

2. Cette façon vous serez en validant le formulaire deux fois: une fois avec le formulaire et une fois avec distinct du programme de validation. C'est une mauvaise idée du point de vue des performances.

Je suggère de manière récursive itération de type de formulaire avec ses enfants à recueillir des messages d'erreur.

À l'aide de certaines méthodes proposées avec exclusif SI l'instruction

Quelques réponses suggéré par un autre auteurs contiennent mutuellement exclusives SI ce type de déclarations: if ($form->count() > 0) ou if ($form->hasChildren()).

Aussi loin que je peux voir, chaque formulaire peut contenir des erreurs, ainsi que les enfants. Je ne suis pas expert avec Formulaires Symfony composant, mais dans la pratique, vous n'obtiendrez pas des erreurs de la forme elle-même, comme protection CSRF erreur ou champs supplémentaires erreur. Je suggère de supprimer cette séparation.

À l'aide de dénormalisée résultat de la structure

Certains auteurs suggèrent de mettre toutes les erreurs à l'intérieur d'un simple tableau. De sorte que tous les messages d'erreur de la forme elle-même et de ses enfants sera ajouté à le même tableau avec les différentes stratégies d'indexation: numéro de type d'erreurs, et le nom de base pour les enfants des erreurs. Je suggère d'utiliser les données normalisées de la structure de la forme:

errors:
    - "Self error"
    - "Another self error"

children
    - "some_child":
        errors:
            - "Children error"
            - "Another children error"

        children
            - "deeper_child":
                errors:
                    - "Children error"
                    - "Another children error"

    - "another_child":
        errors:
            - "Children error"
            - "Another children error"

De cette façon, le résultat peut être facilement répété plus tard.

Ma solution

Alors, voici ma solution à ce problème:

use Symfony\Component\Form\Form;

/**
 * @param Form $form
 * @return array
 */
protected function getFormErrors(Form $form)
{
    $result = [];

    //No need for further processing if form is valid.
    if ($form->isValid()) {
        return $result;
    }

    //Looking for own errors.
    $errors = $form->getErrors();
    if (count($errors)) {
        $result['errors'] = [];
        foreach ($errors as $error) {
            $result['errors'][] = $error->getMessage();
        }
    }

    //Looking for invalid children and collecting errors recursively.
    if ($form->count()) {
        $childErrors = [];
        foreach ($form->all() as $child) {
            if (!$child->isValid()) {
                $childErrors[$child->getName()] = $this->getFormErrors($child);
            }
        }
        if (count($childErrors)) {
            $result['children'] = $childErrors;
        }
    }

    return $result;
}

J'espère que ça aidera quelqu'un.

Pour Symfony 2.1:

C'est ma dernière solution avec la mise en beaucoup d'autres solutions:

protected function getAllFormErrorMessages($form)
{
    $retval = array();
    foreach ($form->getErrors() as $key => $error) {
        if($error->getMessagePluralization() !== null) {
            $retval['message'] = $this->get('translator')->transChoice(
                $error->getMessage(), 
                $error->getMessagePluralization(), 
                $error->getMessageParameters(), 
                'validators'
            );
        } else {
            $retval['message'] = $this->get('translator')->trans($error->getMessage(), array(), 'validators');
        }
    }
    foreach ($form->all() as $name => $child) {
        $errors = $this->getAllFormErrorMessages($child);
        if (!empty($errors)) {
           $retval[$name] = $errors; 
        }
    }
    return $retval;
}