[PUGXMultiUserBundle] Deux types de validation de compte différentes

Version imprimable

Bonjour,

J'utilise PUGXMultiUserBundle pour gérer 2 type de comptes différents dans mon application : Des Particuliers et des Professionnels.

/app/config/config.yml
Code:

1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31 32 33 34 35 36 37 38 39 # FOS User # --------------------------------- fos_user: db_driver: orm firewall_name: main user_class: My\SiteBundle\Entity\Utilisateur service: user_manager: pugx_user_manager registration: confirmation: enabled: true from_email: address: "%email_from%" sender_name: "%company_name%" # PUGX Multi User # --------------------------------- pugx_multi_user: users: user_professionel: entity: class: My\SiteBundle\Entity\Professionnel registration: form: type: My\SiteBundle\Form\Type\Registration\ProfessionnelType name: fos_user_registration_form template: MySiteBundle:Registration:professionnel.html.twig user_particulier: entity: class: My\SiteBundle\Entity\Particulier registration: form: type: My\SiteBundle\Form\Type\Registration\ParticulierType name: fos_user_registration_form template: MySiteBundle:Registration:particulier.html.twig
Seulement voila; ces deux types d'utilisateurs ont des modes de validation différents.

Les Particuliers reçoivent bien un mail avec un lien pour valider leur compte. (ça c'est bon)

Mais les Pros doivent attendre une validation manuelle de la parts de l'admin.

Je ne trouve pas comment différencier ces deux comportements dans la doc de PUGXMultiUserBundle. https://github.com/PUGX/PUGXMultiUse...s/doc/index.md

Merci de votre aide.

Enfin un peu de répis !

Voici quelles informations supplémentaires sur mes contrôleurs / routing / templates / Form.

(C'est peut-être là que se trouve la solution.. )
Je ne vais mettre que le code concernant les Professionnels car celui des particulier est identique.

On commence par le routing :

src/My/SiteBundle/Resources/config/routing.yml

Code:

1
2
3
my_site_compte_professionnel_creation:
    pattern:  /compte/professionnel/creation
    defaults: { _controller: MySiteBundle:Registration/Professionnel:register }

Voici mon contrôleur :

src/My/SiteBundle/Controller/Registration/ProfessionnelController.php

Code:

1
2
3
4
5
6
7
class ProfessionnelController extends BaseController {
    public function registerAction()    {
        return $this->container
            ->get('pugx_multi_user.registration_manager')
            ->register('My\SiteBundle\Entity\Professionnel');
    }
}

Un peut de template twig

src/My/SiteBundle/Resources/views/Registration/professionnel.html.twig

Code:

1
2
3
4
5
6
7
8
9
10
11
12
{% extends "MySiteBundle::layout.html.twig" %}
{% block fos_user_content %}
    {% trans_default_domain 'FOSUserBundle' %}
    <div class="container">
        <form action="{{ path('my_site_compte_particulier_creation') }}" {{ form_enctype(form) }} method="POST">
            {{ form_widget(form) }}
            <div>
                <input class="btn btn-primary" type="submit" value="{{ 'registration.submit'|trans }}" />
            </div>
        </form>
    </div>
{% endblock fos_user_content %}

Et voici la classe de formulaire

src/My/SiteBundle/Form/Type/Registration/EntrepriseType.php

Code:

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
class ProfessionnelType extends RegistrationFormType {
    public function buildForm(FormBuilderInterface $builder, array $options)     {
        $builder
            ->add('email', 'repeated', array(
                'type' => 'email',
                'first_options' => array('label' => 'form.email'),
                'second_options' => array('label' => 'form.email_confirmation'),
                'invalid_message' => 'fos_user.email.mismatch',
            ))
            ->add('nom', null, array('label' => 'nom', 'translation_domain' => 'FOSUserBundle'))
            ->add('prenom', null, array('label' => 'Prénom', 'translation_domain' => 'FOSUserBundle'))
            ->add('telephone', null, array('label' => 'Numéro de téléphone'))
            ->add('fonction', null, array('label' => 'Fonction'))
            ->add('username', null, array('label' => 'form.username', 'translation_domain' => 'FOSUserBundle'))
            ->add('plainPassword', 'repeated', array(
                'type' => 'password',
                'options' => array('translation_domain' => 'FOSUserBundle'),
                'first_options' => array('label' => 'form.password'),
                'second_options' => array('label' => 'form.password_confirmation'),
                'invalid_message' => 'fos_user.password.mismatch',
            ))
            ->add('cgu', 'checkbox', array(
                'label' => 'Acceptation des CGU',
                'required' => true,
                "mapped" => false,
                ))        ;
    }
 
    public function setDefaultOptions(OptionsResolverInterface $resolver)    {
        $resolver->setDefaults([
            'compound'     => true,
            'data_class' => 'My\SiteBundle\Entity\Professionnel',
            'cascade_validation' => true,
        ]);
    }
 
    public function getName()    {        return 'professionnel';    }
}

Dans l’espoir que ça inspire quelqu'un ...

Called Listeners

En examinant les événements déclenchés lors de la création du compte pro on trouve ça :

Code:

1
2
3
fos_user.registration.success 	 	EmailConfirmationListener::onRegistrationSuccess
fos_user.registration.completed 	AuthenticationListener::authenticate
fos_user.registration.completed 	FlashListener::addSuccessFlash

/vendor/friendsofsymfony/user-bundle/EventListener/EmailConfirmationListener.php

Code:

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
 
/* * This file is part of the FOSUserBundle package. */
 
namespace FOS\UserBundle\EventListener;
 
use FOS\UserBundle\FOSUserEvents;
use FOS\UserBundle\Event\FormEvent;
use FOS\UserBundle\Mailer\MailerInterface;
use FOS\UserBundle\Util\TokenGeneratorInterface;
use Symfony\Component\EventDispatcher\EventSubscriberInterface;
use Symfony\Component\HttpFoundation\RedirectResponse;
use Symfony\Component\HttpFoundation\Session\SessionInterface;
use Symfony\Component\Routing\Generator\UrlGeneratorInterface;
 
class EmailConfirmationListener implements EventSubscriberInterface
{
    private $mailer;
    private $tokenGenerator;
    private $router;
    private $session;
 
    public function __construct(MailerInterface $mailer, TokenGeneratorInterface $tokenGenerator, UrlGeneratorInterface $router, SessionInterface $session)    {
        $this->mailer = $mailer;
        $this->tokenGenerator = $tokenGenerator;
        $this->router = $router;
        $this->session = $session;
    }
 
    public static function getSubscribedEvents()    {
        return array(            FOSUserEvents::REGISTRATION_SUCCESS => 'onRegistrationSuccess',        );
    }
 
    public function onRegistrationSuccess(FormEvent $event)    {
        /** @var $user \FOS\UserBundle\Model\UserInterface */
        $user = $event->getForm()->getData();
        $user->setEnabled(false);
        if (null === $user->getConfirmationToken()) {
            $user->setConfirmationToken($this->tokenGenerator->generateToken());
        }
        $this->mailer->sendConfirmationEmailMessage($user);
        $this->session->set('fos_user_send_confirmation_email/email', $user->getEmail());
        $url = $this->router->generate('fos_user_registration_check_email');
        $event->setResponse(new RedirectResponse($url));
    }
}

C'est via ce mécanisme que le mail est envoyer.

Mais je ne vois pas du tous comment le désactiver lors que le compte utilisateur est un compte pros.

J'ai trouvé une solution. Mais je pense qu'elle est un peu tordu...

Premièrement : changement de stratégie.
On envoie pas le mail de validation par défault :

app/config/config.yml

Code:

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
# FOS User
# ---------------------------------
 
fos_user:
    db_driver: orm
    firewall_name: main
    user_class: My\SiteBundle\Entity\Utilisateur
    service:
        user_manager: pugx_user_manager
    registration:
        confirmation:
            enabled: false
    from_email:
            address:        "%email_from%"
            sender_name:    "%company_name%"

Ensuite je crée un listener d'événement (EventSubscriberInterface) pour envoyer le mail si l'utilisateur est un particulier ou rediriger vers une page d'explication pour les pro. :

src/My/SiteBundle/EventListener/FooListener.php

Code:

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
<?php
namespace My\SiteBundle\EventListener;
 
use *
 
class FooListener implements EventSubscriberInterface { FooListener::onRegistrationSuccess()
    private $mailer;
    private $tokenGenerator;
    private $router;
    private $session;
 
    public function __construct(MailerInterface $mailer, TokenGeneratorInterface $tokenGenerator, UrlGeneratorInterface $router, SessionInterface $session)    {
        $this->mailer = $mailer;
        $this->tokenGenerator = $tokenGenerator;
        $this->router = $router;
        $this->session = $session;
    }
 
    public static function getSubscribedEvents()    {
        return array(
            FOSUserEvents::REGISTRATION_SUCCESS => 'onRegistrationSuccess',
        );
    }
 
    public function onRegistrationSuccess(FormEvent $event)    {
        $user = $event->getForm()->getData();
        $user->setEnabled(false);
        if (null === $user->getConfirmationToken()) {
            $user->setConfirmationToken($this->tokenGenerator->generateToken());
        }
 
        if ($user instanceof Particulier) {
            $this->mailer->sendConfirmationEmailMessage($user);
            $this->session->set('fos_user_send_confirmation_email/email', $user->getEmail());
            $url = $this->router->generate('fos_user_registration_check_email');
            $event->setResponse(new RedirectResponse($url));
        } else {
            $url = $this->router->generate('my_site_user_registration');
            $event->setResponse(new RedirectResponse($url));
        }
    }
}

Je configure le service :

src/My/SiteBundle/Resources/config/foo.xml

Code:

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
<?xml version="1.0" encoding="UTF-8" ?>
 
<container xmlns="http://symfony.com/schema/dic/services"
    xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
    xsi:schemaLocation="http://symfony.com/schema/dic/services http://symfony.com/schema/dic/services/services-1.0.xsd">
 
    <services>
        <service id="my_site.listener.foo" class="My\SiteBundle\EventListener\FooListener">
            <tag name="kernel.event_subscriber" />
            <argument type="service" id="fos_user.mailer" />
            <argument type="service" id="fos_user.util.token_generator" />
            <argument type="service" id="router" />
            <argument type="service" id="session" />
            <argument type="service" id="logger" />
        </service>
    </services>
</container>

Que j'ajoute dans la conf de mon bundle :

src/My/SiteBundle/DependencyInjection/MySiteExtension.php

Code:

1
2
3
4
5
6
7
8
9
10
11
12
13
14
<?php
namespace My\SiteBundle\DependencyInjection;
use *;
 
class MySiteExtension extends Extension {
    public function load(array $configs, ContainerBuilder $container)    {
        $configuration = new Configuration();
        $config = $this->processConfiguration($configuration, $configs);
        $loader = new Loader\YamlFileLoader($container, new FileLocator(__DIR__.'/../Resources/config'));
        $loader->load('services.yml');
        $XmlFileLoader = new Loader\XmlFileLoader($container, new FileLocator(__DIR__.'/../Resources/config'));
        $XmlFileLoader->load('foo.xml');
    }
}

Ma fonction FooListener::onRegistrationSuccess() reprend le fonctionnement de FOS\UserBundle\EventListener\EmailConfirmationListener::onRegistrationSuccess() qui n'est plus appelé.

Si vous avez de meilleures propositions pour résoudre ce problème je suis preneur.
Peut-être que mon code aidera certains d'entre vous.

02/02/2016, 17h20
senol1

Une alternative

Rajoute un super utilisateur et désactive par défaut la validation et tu pourras créer sur le contrôleur du super une fonction ou événement qui déclenche automatique la validation pour l’utilisateur qui en a besoin.