Discussion :

[Rémy DEV]

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 :

Sélectionner tout - Visualiser dans une fenêtre à part

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.

[Rémy DEV]

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 :

Sélectionner tout - Visualiser dans une fenêtre à part

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 :

Sélectionner tout - Visualiser dans une fenêtre à part

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 :

Sélectionner tout - Visualiser dans une fenêtre à part

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 :

Sélectionner tout - Visualiser dans une fenêtre à part

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 ...

[Rémy DEV]

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

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

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 :

Sélectionner tout - Visualiser dans une fenêtre à part

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.

[Rémy DEV]

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 :

Sélectionner tout - Visualiser dans une fenêtre à part

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 :

Sélectionner tout - Visualiser dans une fenêtre à part

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 :

Sélectionner tout - Visualiser dans une fenêtre à part

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 :

Sélectionner tout - Visualiser dans une fenêtre à part

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.

[senol1]

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.