Este documento describe la validación de datos en Symfony2. Symfony2 incluye un componente Validator que facilita la validación de datos antes de guardarlos en una base de datos o pasarlos a un servicio web. Se pueden definir restricciones como NotBlank y Email en las propiedades de una entidad para validar los datos. El servicio validator puede utilizarse para validar objetos y valores individuales y devolver errores. También es posible crear restricciones personalizadas.

1. Validación
Realizada por:
Christian Aquino |@cj_aquino
Diego Ramirez |@thedarsideofit
Gonzalo Alonso |@GonzaloAlonsoD
Diego Barros |@Inmzombie
Para: Hydras C&S |@hydras_cs
Basada en Libro Symfony 2 en español Nacho Pacheco y The Book

2. Validando
La validación es una tarea muy común en aplicaciones
web.
● Los datos introducidos en formularios se tienen que
validar.
● Los datos también se deben validar antes de escribirlos
en una base de datos o pasarlos a un servicio web.
Symfony2 viene con un componente Validator que facilita y
transparenta esta tarea. Este componente está basado en
la especificación de validación Bean JSR303.

3. Fundamentos de la validación
// src/Acme/BlogBundle/Entity/Author.php
use SymfonyComponentValidatorConstraints as Assert;
class Author
{
/**
* Restricciones
*/
public $name;
}
/**
* @AssertNotBlank()
*/

4. Usando el servicio validador
public function indexAction()
{
$author = new Author();
// ... hace algo con el objeto $author
$validator = $this->get('validator');
$errors = $validator->validate($author);
if (count($errors) > 0) {
return new Response(print_r($errors, true));
} else {
return new Response('The author is valid! Yes!');
}
}

5. Usando el servicio validador
Si la propiedad $name está vacía, verás el siguiente
mensaje de error:
AcmeBlogBundleAuthor.name:
This value should not be blank
Si insertas un valor en la propiedad $name aparecerá el
satisfactorio mensaje de éxito:
The author is valid! Yes!

6. Colección de errores a plantilla
if (count($errors) > 0) {
return $this->render('AcmeBlogBundle:Author:validate.
html.twig', array(
'errors' => $errors,
));
} else { // ...}
<ul>
{% for error in errors %}
<li>{{ error.message }}</li>
{% endfor %}
</ul>

7. Validación y formularios
public function updateAction(Request $request)
{
$author = new Author();
$form = $this->createForm(new AuthorType(), $author);
if ($request->isMethod('POST')) {
$form->bind($request);
if ($form->isValid()) {
// validación superada, haz algo con el objeto $author
return $this->redirect($this->generateUrl(...));
}
}}

8. Configurando anotaciones
# app/config/config.yml
framework:
validation: { enable_annotations: true }
<!-- app/config/config.xml -->
<framework:config>
<framework:validation enable-annotations="true" />
</framework:config>
// app/config/config.php
$container->loadFromExtension('framework', array('validation' =>
array(
'enable_annotations' => true,
)));

9. Restricciones
A fin de validar un objeto, basta con asignar una o más
restricciones a tu clase y luego pasarla al servicio
validador.
Una restricción simplemente es un objeto PHP que hace
una declaración asertiva.
En la vida real: «El pastel no se debe quemar». En
Symfony2, son similares: son aserciones de que una
condición es verdadera.
Dado un valor, una restricción te dirá si o no el valor se
adhiere a las reglas de tu restricción.

10. Restricciones básicas
● NotBlank
● Blank
● NotNull
● Null
● True
● False
● Type

11. Restricciones de cadena
● Email
● MinLength
● MaxLength
● Length
● Url
● Regex
● Ip

12. Restricciones de número
● Max
● Min
● Range
Restricciones de fecha
● Date
● DateTime
● Time

13. Restricciones de colección
● Choice
● Collection
● Count
● UniqueEntity
● Language
● Locale
● Country
Restricciones de archivo
● File
● Image

14. Restricciones de financieras
● CardScheme
● Luhn
Otras restricciones
● Callback
● All
● UserPassword
● Valid

15. Configurando restricciones
// src/Acme/BlogBundle/Entity/Author.php
use SymfonyComponentValidatorConstraints as Assert;
class Autor
{
/**
* @AssertChoice(
* choices = { "male", "female" },
* message = "Choose a valid gender."
* )
*/
public $gender;
}
/**
* @AssertChoice({"male", "female"})
*/

16. Propiedades
La validación de propiedades de clase es la técnica de
validación más básica.
// Acme/BlogBundle/Entity/Author.php
use SymfonyComponentValidatorConstraints as Assert;
class Autor
{
/**
* @AssertNotBlank()
* @AssertLength(min = "3")
*/
private $firstName;
}

17. Captadores
Las restricciones también se pueden aplicar al valor devuelto por un método,
público que comience con get o is
// src/Acme/BlogBundle/Entity/Author.php
use SymfonyComponentValidatorConstraints as Assert;
class Author
{
/**
* @AssertTrue(message = "The password cannot match your first
name")
*/
public function isPasswordLegal()
{
// return true or false
return ($this->firstName != $this->password);
}
}

18. Clases - Callback
// src/Acme/BlogBundle/Entity/Author.php
namespace AcmeBlogBundleEntity;
use SymfonyComponentValidatorConstraints as Assert;
/**
* @AssertCallback(methods={"isAuthorValid"})
*/
class Author
{
}

19. // ...
use SymfonyComponentValidatorExecutionContext;
class Author
{
// ...
private $firstName;
public function isAuthorValid(ExecutionContext $context)
{
// de alguna manera hay un arreglo de "nombres ficticios"
$fakeNames = array();
// comprueba si el nombre en realidad es un nombre ficticio
if (in_array($this->getFirstName(), $fakeNames)) {
$context->addViolationAtSubPath('firstname', 'This name sounds totally
fake!', array(), null);
}
}
}

20. Validando grupos
// src/Acme/BlogBundle/Entity/User.php
namespace AcmeBlogBundleEntity;
use
SymfonyComponentSecurityCoreUserUserInterface;
use SymfonyComponentValidatorConstraints as Assert;
class User implements UserInterface
{
/**
* @AssertEmail(groups={"registration"})
*/
private $email;

21. Validando grupos
/**
* @AssertNotBlank(groups={"registration"})
* @AssertLength(min=7, groups={"registration"})
*/
private $password;
/**
* @AssertLength(min = "2")
*/
private $city;
}

22. Form - validando grupos
use
SymfonyComponentOptionsResolverOptionsResolverInte
rface;
public function setDefaultOptions(OptionsResolverInterface
$resolver)
{
$resolver->setDefaults(array(
'validation_groups' => array('registration')
));
}

23. Validando valores y arreglos
como verificar que una cadena es una dirección de correo electrónico válida
use SymfonyComponentValidatorConstraintsEmail;
// ...
public function addEmailAction($email)
{
$emailConstraint = new Email();
// puedes fijar todas las "opciones" de restricción de esta manera
$emailConstraint->message = 'Invalid email address';
// usa el validador para validar el valor
$errorList = $this->get('validator')->validateValue(
$email,
$emailConstraint
);

24. Validando valores y arreglos
como verificar que una cadena es una dirección de correo electrónico válida
if (count($errorList) == 0) {
// esta ES una dirección de correo válida, haz algo
} else {
// esta *no* es una dirección de correo electrónico válida
$errorMessage = $errorList[0]->getMessage();
// ... haz algo con el error
}
// ...
}
El método validateValue devuelve un objeto
SymfonyComponentValidatorConstraintViolationList, que actúa como un
arreglo de errores. Cada error de la colección es un objeto
SymfonyComponentValidatorConstraintViolation, que contiene el mensaje de
error en su método getMessage.

25. Crear restricciones personalizadas
Puedes crear una restricción personalizada extendiendo la
clase base “constraint”,
SymfonyComponentValidatorConstraint. A modo de
ejemplo vas a crear un sencillo validador que compruebe si
una cadena únicamente contiene caracteres
alfanuméricos.

26. Creando la clase de la restricción
// src/Acme/DemoBundle/Validator/Constraints/ContainsAlphanumeric.php
namespace AcmeDemoBundleValidatorConstraints;
use SymfonyComponentValidatorConstraint;
/**
* @Annotation
*/
class ContainsAlphanumeric extends Constraint
{
public $message = 'The string "%string%" contains an illegal
character: it can only contain letters or numbers.';
}

27. Creando el validador directamente
// src/Acme/DemoBundle/Validator/Constraints/ContainsAlphanumericValidator.php
namespace AcmeDemoBundleValidatorConstraints;
use SymfonyComponentValidatorConstraint;
use SymfonyComponentValidatorConstraintValidator;
class ContainsAlphanumericValidator extends
ConstraintValidator
{
public function validate($value, Constraint $constraint)
{
if (!preg_match('/^[a-zA-Za0-9]+$/', $value, $matches)) {
$this->context->addViolation($constraint->message,
array('%string%' => $value));
}
}
}

28. // src/Acme/DemoBundle/Entity/AcmeEntity.php
use SymfonyComponentValidatorConstraints as Assert;
use AcmeDemoBundleValidatorConstraints as
AcmeAssert;
class AcmeEntity
{
/**
* @AssertNotBlank
* @AcmeAssertContainsAlphanumeric
*/
protected $name;
}
Usando el nuevo validador