Validation personnalisée en Symfony2

Question

Je suis nouveau à symfony. J'ai décidé de déplacer ma roue avec la version Symfony 2.

Dans mon formulaire utilisateur:

• Je voudrais l'unicité de validation du courrier électronique dans la base de données.
• Je voudrais également le mot de passe de validation avec champ Confirmer mot de passe.
• je ne pouvais trouver de l'aide dans le Symfony2 doc.

Answer 1

Ce truc m'a fallu un certain temps pour traquer aussi, alors voici ce que je suis venu avec. Pour être honnête, je ne suis pas vraiment sûr de la méthode getRoles () de l'entité utilisateur, mais cela est juste une configuration de test pour moi. éléments de contexte comme celui qui sont fournis uniquement par souci de clarté.

Voici quelques liens utiles pour en savoir plus:

• Une contrainte validation unicité que les forces
• un type de champ pour (vérifié à double entrée-) répétées champs

Je mis tout cela en place pour vous assurer qu'il a travaillé comme UserProvider pour la sécurité, ainsi que je vous pensé que faisiez probablement. Je vous ai également supposais utilisiez l'e-mail comme nom d'utilisateur, mais vous ne devez pas. Vous pouvez créer un champ de nom d'utilisateur distinct et utiliser. Voir de sécurité pour plus d'informations.

L'entité (seules les parties importantes, autogenerateable getters / setters sont omis):

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 classe Form:

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',
        );
    }
}
?>

Le contrôleur:

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");
    }

Section pertinente du 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

Consultez http://github.com/friendsofsymfony il y a un UserBundle qui ont cette fonctionnalité. Vous pouvez également consulter http://blog.bearwoods.com où il y a un billet de blog sur l'ajout d'un champ personnalisé, contrainte et validateur pour ReCaptcha.

ressources thoose devrait vous aider à démarrer sur le bon chemin si vous êtes toujours en cours d'exécution dans les ennuis sont généralement serviable et sympathique sur irc à # symfony-dev sur le réseau Freenode. Sur Freenoce il y a aussi un canal général #symfony où vous pouvez poser des questions sur la façon d'utiliser des choses où # symfony-dev est pour le développement de Symfony2 de base.

Espérons que cela vous aidera à aller de l'avant avec votre projet.

Answer 3

Je pense que la principale chose que vous devez regarder lors de la création de votre validateur personnalisé est la méthode constante spécifiée dans les getTargets ().

Si vous modifiez

self::PROPERTY_CONSTRAINT

à:

self::CLASS_CONSTRAINT

Vous devriez être en mesure d'accéder à toutes les propriétés de l'entité, non seulement une seule propriété.

---

Remarque:. Si vous utilisez des annotations pour définir vos contraintes que vous allez maintenant besoin de déplacer l'annotation qui définit votre validateur jusqu'au sommet de la classe comme il est maintenant applicable à l'ensemble de l'entité et non pas seulement la propriété unique

Answer 4

Vous devriez être en mesure d'obtenir tout ce que vous avez besoin de docs . Plus précisément les contraintes qui a des informations sur la vérification des e-mail. Il y a aussi la documentation sur l'écriture validateurs personnalisés .

Answer 5

Je l'ai fait tout comme sur http://symfony.com/doc/2.0 /book/validation.html

Ma config:

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

essayé de l'utiliser avec

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

mais il ne se déclenche pas?

Answer 6

e-mail unique base de données

validation.yml

Tableau de bord \ ArticleBundle \ Entité \ Article: contraintes: # - Symfony \ Pont \ Doctrine \ Validator \ Contraintes \ UniqueEntity: SENDEREMAIL - Symfony \ Pont \ Doctrine \ Validator \ Contraintes \ UniqueEntity: {champs: SENDEREMAIL, message: Ce message existe déjà}

Mot de passe avec le mot de passe de confirmation

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