Validación personalizada en Symfony2

Question

Soy nuevo en Symfony. He decidido mover mi rueda con Symfony versión 2.

En mi formulario de usuario:

• Me gustaría validar la singularidad del correo electrónico en la base de datos.
• También me gustaría validar la contraseña con el campo Confirmar contraseña.
• Podría encontrar cualquier ayuda en el Symfony2 Doc.

Answer 1

Esto me llevó un tiempo rastrear también, así que esto es lo que se me ocurrió. Para ser honesto, no estoy realmente seguro del método getRoles () de la entidad de usuario, pero esto es solo una configuración de prueba para mí. Los elementos de contexto como ese se proporcionan únicamente para mayor claridad.

Aquí hay algunos enlaces útiles para leer más:

• Una restricción de validación que obliga a la singularidad
• Un tipo de campo para campos repetidos (verificados de doble entrada)

Establecí todo esto para asegurarme de que funcionó como un proveedor de usuarios para la seguridad también, ya que pensé que probablemente lo hicieras. También supuse que estaba usando el correo electrónico como nombre de usuario, pero no es necesario. Puede crear un campo de nombre de usuario separado y usarlo. Ver Seguridad para más información.

La entidad (solo las partes importantes; se omiten los getters/setters autogénicos):

namespace Acme\UserBundle\Entity;

use Symfony\Component\Security\Core\User\UserInterface;
use Symfony\Bridge\Doctrine\Validator\Constraints as DoctrineAssert;
use Doctrine\ORM\Mapping as ORM;

/**
 * @ORM\Entity()
 * @ORM\HasLifecycleCallbacks()
 *
 * list any fields here that must be unique
 * @DoctrineAssert\UniqueEntity(
 *     fields = { "email" }
 * )
 */
class User implements UserInterface
{
    /**
     * @ORM\Id
     * @ORM\Column(type="integer")
     * @ORM\GeneratedValue(strategy="AUTO")
     */
    protected $id;

    /**
     * @ORM\Column(type="string", length="255", unique="true")
     */
    protected $email;

    /**
     * @ORM\Column(type="string", length="128")
     */
    protected $password;

    /**
     * @ORM\Column(type="string", length="5")
     */
    protected $salt;

    /**
     * Create a new User object
     */
    public function __construct() {
        $this->initSalt();
    }

    /**
     * Generate a new salt - can't be done as prepersist because we need it before then
     */
    public function initSalt() {
        $this->salt = substr(str_shuffle(str_repeat('ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789',5)),0,5);
    }

    /**
     * Is the provided user the same as "this"?
     *
     * @return bool
     */
    public function equals(UserInterface $user) {
        if($user->email !== $this->email) {
            return false;
        }

        return true;
    }

    /**
     * Remove sensitive information from the user object
     */
    public function eraseCredentials() {
        $this->password = "";
        $this->salt = "";
    }


    /**
     * Get the list of roles for the user
     *
     * @return string array
     */
    public function getRoles() {
        return array("ROLE_USER");
    }

    /**
     * Get the user's password
     *
     * @return string
     */
    public function getPassword() {
        return $this->password;
    }

    /**
     * Get the user's username
     *
     * We MUST have this to fulfill the requirements of UserInterface
     *
     * @return string
     */
    public function getUsername() {
        return $this->email;
    }

    /**
     * Get the user's "email"
     *
     * @return string
     */
    public function getEmail() {
        return $this->email;
    }

    /**
     * Get the user's salt
     *
     * @return string
     */
    public function getSalt() {
        return $this->salt;
    }

    /**
     * Convert this user to a string representation
     *
     * @return string
     */

    public function __toString() {
        return $this->email;
    }
}
?>

La clase de formulario:

namespace Acme\UserBundle\Form\Type;

use Symfony\Component\Form\AbstractType;
use Symfony\Component\Form\FormBuilder;

class UserType extends AbstractType {
    public function buildForm(FormBuilder $builder, array $options) {
        $builder->add('email');
        /* this field type lets you show two fields that represent just
           one field in the model and they both must match */
        $builder->add('password', 'repeated', array (
            'type'            => 'password',
            'first_name'      => "Password",
            'second_name'     => "Re-enter Password",
            'invalid_message' => "The passwords don't match!"
        ));
    }

    public function getName() {
        return 'user';
    }

    public function getDefaultOptions(array $options) {
        return array(
            'data_class' => 'Acme\UserBundle\Entity\User',
        );
    }
}
?>

El controlador:

namespace Acme\UserBundle\Controller;

use Symfony\Bundle\FrameworkBundle\Controller\Controller;
use Symfony\Component\HttpFoundation\Request;
use Acme\UserBundle\Entity\User;
use Acme\UserBundle\Form\Type\UserType;


class userController extends Controller
{
    public function newAction(Request $request) {
        $user = new User();
        $form = $this->createForm(new UserType(), $user);

        if ($request->getMethod() == 'POST') {
            $form->bindRequest($request);

            if ($form->isValid()) {
                // encode the password
                $factory = $this->get('security.encoder_factory');
                $encoder = $factory->getEncoder($user);
                $password = $encoder->encodePassword($user->getPassword(), $user->getSalt());
                $user->setPassword($password);

                $em = $this->getDoctrine()->getEntityManager();
                $em->persist($user);
                $em->flush();

                return $this->redirect($this->generateUrl('AcmeUserBundle_submitNewSuccess'));
            }
        }

        return $this->render('AcmeUserBundle:User:new.html.twig', array (
            'form' => $form->createView()
        ));
    }

    public function submitNewSuccessAction() {
        return $this->render("AcmeUserBundle:User:submitNewSuccess.html.twig");
    }

Sección relevante de Security.yml:

security:
    encoders:
        Acme\UserBundle\Entity\User:
            algorithm: sha512
            iterations: 1
            encode_as_base64: true

    role_hierarchy:
        ROLE_ADMIN:       ROLE_USER
        ROLE_SUPER_ADMIN: [ROLE_USER, ROLE_ADMIN, ROLE_ALLOWED_TO_SWITCH]

    providers:
        main:
            entity: { class: Acme\UserBundle\Entity\User, property: email }

    firewalls:
        secured_area:
            pattern:    ^/
            form_login:
                check_path: /login_check
                login_path: /login
            logout:
                path:   /logout
                target: /demo/
            anonymous: ~

Answer 2

Verificar http://github.com/friendsofsymfony Hay un usuario de usuario que tiene esa funcionalidad. También puedes comprobar http://blog.bearwoods.com Donde hay una publicación de blog sobre cómo agregar un campo personalizado, restricción y validador para Recaptcha.

Los recursos deberían comenzar a comenzar en el camino correcto si todavía tiene problemas, las personas generalmente son serviciales y amigables en IRC en #Symfony-Dev en la red de FreeNode. En Freenoce también hay un canal general #Symfony donde puede hacer preguntas sobre cómo usar cosas donde #Symfony-Dev es para el desarrollo de Symfony2 Core.

Esperemos que esto lo ayude a avanzar con su proyecto.

Answer 3

Creo que lo principal que debe tener en cuenta al crear su validador personalizado es la constante especificada en el método getTargets ().

Si cambias

self::PROPERTY_CONSTRAINT

a:

self::CLASS_CONSTRAINT

Debería poder acceder a todas las propiedades de la entidad, no solo una sola propiedad.

---

Nota: Si está utilizando anotaciones para definir sus restricciones, ahora deberá mover la anotación que define su validador hasta la parte superior de la clase, ya que ahora es aplicable a toda la entidad y no solo a la propiedad única.

Answer 4

Deberías poder obtener todo lo que necesitas del documentos. Específicamente el restricciones que tiene información sobre la verificación de correo electrónico. También hay documentación sobre la escritura Validadores personalizados.

Answer 5

He hecho todo como en http://symfony.com/doc/2.0/book/validation.html

Mi configuración:

validator.debit_card:
        class: My\Validator\Constraints\DebitCardValidator
        tags:
            - { name: validator.constraint_validator, alias: debit_card }

Intenté usarlo con

@assert:DebitCard
@assert:debitCard
@assert:debit_card

¿Pero no se activa?

Answer 6

correo electrónico único de la base de datos

Validation.yml

Panel de tablero Artículobundle Entity Artículo: Restricciones: # - Symfony Bridge Doctrine Validator Restricts UniqueEntity: Senderemail - Symfony Bridge Doctrine Validator Restraints UniqueEntity: {Fields: Senderemail, Mensaje: este correo electrónico ya existe}

Contraseña con contraseña de confirmación

    $builder->add('password', 'repeated', array(
       'first_name' => 'password',
       'second_name' => 'confirm',
       'type' => 'password',
       'required' => false,
    ));