Parametros de configuracion de un bundle distribuible

Hola amigos ¡

Para los que no hayais leido los anteriores posts sobre como crear un bundle y distribuirlo a los proyectos, os recomiendo que os paseis antes por aqui.

El truco de hoy consiste en como incluimos parametros de configuracion obligatorios en nuestros bundles distribuibles, para que el usuario que haga uso de este bundle se encargue de definirlos correctamente para el buen funcionamiento del bundle.

Para ello y revisando la documentacion oficial de Symfony explicare paso a paso como se consigue de una forma mas facil y clara (al menos a mi me a costado trabajo comprenderlo).

Imaginemos que nuestro bundle distribuible tiene un servicio que necesita varios parametros para conectarse a un API de terceros y por lo tanto hay que forzar al usuario a definir esa configuracion.

1- Definir los parametros en el DependencyInjection/Configuration.php

/**
 * This is the class that validates and merges configuration from your app/config files.
 *
 * To learn more see {@link http://symfony.com/doc/current/cookbook/bundles/configuration.html}
 */
class Configuration implements ConfigurationInterface
{
    /**
     * {@inheritdoc}
     */
    public function getConfigTreeBuilder()
    {
        $treeBuilder = new TreeBuilder();
        $rootNode = $treeBuilder->root('common');

        // Here you should define the parameters that are allowed to
        // configure your bundle. See the documentation linked above for
        // more information on that topic.
        $rootNode
            ->children()
                ->arrayNode('request_manager')
                    ->children()
                        ->scalarNode('api_url')->end()
                        ->scalarNode('api_user')->end()
                        ->scalarNode('api_password')->end()
                        ->scalarNode('api_token_auth')->end()
                    ->end()
                ->end()
            ->end();

        return $treeBuilder;
    }
}

En mi caso necesito 4 parametros a configurar en mi bundle distribuible llamado ‘common‘ que son:

-api_url

-api_user

-api_password

-api_token_auth

2- Añadir los parametros en el DI y sustituirlos en el servicio que los necesite en el archivo DependencyInjection/CommonBundle (sustituye Common por el nombre de tu bundle)

/**
 * This is the class that loads and manages your bundle configuration.
 *
 * @link http://symfony.com/doc/current/cookbook/bundles/extension.html
 */
class CommonExtension extends Extension
{
    /**
     * {@inheritdoc}
     */
    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('routing_api.yml');
        $loader->load('services.yml');

        $def = $container->getDefinition('my_vendor.request_manager_api');
        $def->replaceArgument(0, $config['request_manager']['api_url']);
        $def->replaceArgument(1, $config['request_manager']['api_user']);
        $def->replaceArgument(2, $config['request_manager']['api_password']);
        $def->replaceArgument(3, $config['request_manager']['api_token_auth']);
    }
}

De esta forma lo que se consigue es sustituir los parametros en la definicion del servicio por los que el usuario configure. Este servicio concreto tiene la siguiente definicion:

services:
    my_vendor.request_manager_api:
        class: MyVendor\CommonBundle\Services\RequestManagerAPI
        arguments:
            - '%api_url%'
            - '%api_email%'
            - '%api_password%'
            - '%api_token_auth%'
            - '@monolog.logger'
            - '@mrjeff.common.serializer'

Este servicio recibe 4 parametros en el constructor que sustituimos en el CommonExtension.

Guardamos los cambios del bundle en GIT  para que cuando lo actualicemos en otro proyecto se descarguen correctamente.

3- Actualizar el bundle en el proyecto donde lo usemos añadiendo la configuracion necesaria para dicho bundle y que nos dara error si no lo hacemos porque son parametros obligatorios. Para ello:

$ composer update

Esto nos instalara la nueva version del bundle con dichos parametros obligatorios

Ahora tenemos que crear esta configuracion con la misma estructura en el archivo app/config/config.yml, y quedaria algo asi:

common:
    request_manager:
        api_url: %api_url%
        api_user: %api_email%
        api_password: %api_password%
        api_token_auth: %api_token_auth%

Y como estamos haciendo referencia a parametros de nuestra aplicacion, tendremos que definirlos en nuestroparameters.yml/parameters.yml.dist tal que:

api_url: http://my-api-url.com
api_email: user@my-domain.com
api_password: XXX
api_token_auth: my-secret-token-is-not-visible

De esta forma nuestro proyecto ya podra usar el bundle con la configuracion necesaria para que funcione correctamente.

Espero haber sido claro y conciso sobre la forma de conseguirlo. Si teneis dudas no dudeis en preguntar o consultar la documentacion oficial para su uso de forma avanzada en http://symfony.com/doc/current/bundles/configuration.html

Un saludo SymfonyDevs ¡¡¡

Recordad compartir este articulo en vuestras redes sociales, no os cuesta nada y puede ayudar a muchos compañeros ¡

 

Propagar parametros custom de un FormType a un FormType Embebido

Al hilo del mi ultimo post acerca de pasar parametros custom a un FormType desde un controlador, para por ejemplo rellenar un select con valores que vienen de otro sitio, me a surgido la duda siguiente:

¿Es posible propagar ese campo custom a un formulario embebido dentro del mismo FormType? Es decir, imaginad que tenemos un FormType con una serie de campos y dentro de ese FormType tenemos otro FormType con otros campos el cual un de ellos tambien se rellena con información externa.

Ejemplo:

CreateIncidentType:

public function buildForm(FormBuilderInterface $builder, array $options)
{
    $incidentType = $options['incident_type'];
    $incidentTypesOptions = array('' => '');
    /** @var IncidentType $item */
    foreach ($incidentType as $item) {
     $incidentTypesOptions[$item->getName()] = $item->getCode();
    }

    $builder
         ...OTROS CAMPOS
         ->add('visit_delivery', VisitType::class, array(
              'label' => 'Visita de Entrega',
              'incident_type' => $incidentType,
              'attr' => array(
                     'class' => 'form-control visit-delivery hide'
               ),
              'label_attr' => array(
                    'class' => 'hide'
              )
     ));
}
public function configureOptions(OptionsResolver $resolver)
{
    $resolver->setDefaults(array(
        'data_class' => CreateIncident::class,
        'incident_type' => null
    ));
}

He marcado en color las cosas a tener en cuenta. En mi caso VisitType es un formulario embebido dentro del CreateIncidentType y que tb recibe un parametro custom. Para ello, hacemos exactamente lo mismo que antes:

VisitType:

public function buildForm(FormBuilderInterface $builder, array $options)
{
    $incidentType = $options['incident_type']; 
    $builder
        ->add('visit_type_code', ChoiceType::class, array(
             'label' => 'Tipo',
             'choices' => $incidentType,
             'attr' => array(
                  'class' => 'form-control visit-type-code',
             ),
             'required' => true
         ));
}

public function configureOptions(OptionsResolver $resolver)
{
    $resolver->setDefaults(array(
        'data_class' => Visit::class,
        'incident_type' => null
    ));
}

De esa forma, hemos “propagado” el parametro que recibe el formtype inicial hacia el formulario embebido para usarlo dentro de el.

Por cierto, recordad que en el controller cuando creais el Form teneis que hacerlo asi:

$incidentModel = new CreateIncident();
$incidentForm = $this->createForm(CreateIncidentType::class, $incidentModel, array(
 'incident_type' => $incidentTypes
));

Espero que os sirva de ayuda o os de una idea de como enfocarlo.

Si te a gustado, ya sabes retuit, comparte y comenta ¡¡

Saludos Devs ¡¡¡

Enviar parametros a un FormType desde el Controller

El truco de hoy consiste en enviar información a un formulario desde un controlador. En mi caso el problema que tengo es el siguiente:

Tengo un formulario en el que los valores de un campo select (ChoiceType) los recojo de un servicio de una API Rest y se los tengo que enviar al formType para rellenar los valores(choices) de un campo de tipo ChoiceType.

La forma de hacerlo seria la siguiente:

Controller
$form = $this->createForm(ResumeCartType::class, $resumeCart, array(
    'pickupTime' => $timetablePickup->getPickup(),
    'deliveryTime' => $timetableDelivery->getDelivery()
));

En mi caso le envio 2 parametros (pickupTime y deliveryTime) cuyos valores son de tipo ArrayCollection con la informacion. Despues habria que recogerlos en el formulario de la siguiente forma:

FormType(ResumeCartType)
class ResumeCartType extends AbstractType
{
public function configureOptions(OptionsResolver $resolver)
{
 $resolver->setDefaults(array(
 'data_class' => 'Appbundle\Model\ResumeCart',
 'pickupTime' => null,
 'deliveryTime' => null
 ));
}
public function buildForm(FormBuilderInterface $builder, array $options)
{
    /** @var ArrayCollection $pickupRanges */
    $pickupRanges = $options['pickupTime'];

    //Operaciones para formar el array asociativo para 
    //el campo ChoiceType
    $pickupValues = array();
    /** @var Range $range */
    foreach ($pickupRanges as $range) {
        array_push($pickupValues, array($range->getTimeSlotCode() => $range->getTimeSlotCode()));
    }

    /** @var ArrayCollection $deliveryRanges */
    $deliveryRanges = $options['deliveryTime'];    
    $builder
            ...//Otros campos de tu modelo
            ->add('time_pickup', ChoiceType::class, array(
                'choices' => $pickupValues,
                'expanded' => true,
                'multiple' => false,
                'required' => true
            ))
}

Lo primero es definir esos parametros en el metodo configureOptions() y despues podemos recogerlos usando el parametro $options[‘clave’], hacer lo que necesitemos y despues pasarselo al campo que necesitemos. En mi caso recibo un ArrayCollection que tengo que transformar a un array simple asociativo(clave => valor) para pasarselo al ChoiceType ya que este objeto necesita ese formato para formar correctamente el elemento <select> en la vista.

De esta forma tan simple, podemos enviarle los parametros que necesitemos a nuestros formularios. Existen muchas mas formas, incluso recuperando datos de una Entidad usando traits, pero eso ya viene muy bien explicado en la documentacion oficial de Symfony.

Espero que os sirva y si teneis sugerencias, no dudeis en postearlas. Seguro que hay muchas mas formas de hacer estas cositas, y incluso mejores supongo, pero esta es la mas sencilla que he encontrado.

Un saludo SymfonyDevs ¡¡

Edito:

Existe otra opcion oficial en Symfony que desconocia hasta ayer que soluciona esto sin recorrer la coleccion manualmente. En nuestro FormType debemos indicarle el choice_label y choice_value y Symfony lo hace solo por nosotros.

->add('incident_type_code', ChoiceType::class, array(
    'label' => 'Tipo de Incidencia',
    'choices' => $options['incident_types'],
    'choice_label' => 'name',
    'choice_value' => 'code',
    'placeholder' => '',
    'attr' => array(
        'class' => 'form-control incident-type-code',
    ),
    'required' => true
))

De esa forma nos ahorramos el bucle y seguimos fieles a Symfomy.

Saludos ‘¡

Registro con ventana modal con FOSUserBundle en Symfony 3

Comumente las aplicaciones web desarrolladas ya sea con Symfony o no, suelen tener ciertas caracteristicas similares(no en todos los casos, obviamente), pero muchas de ellas se parecen en algunas funcionalidades. En este caso, y como este blog trata sobre Symfony, voy a explicar un caso comun sobre la gestion de usuarios, y mas concretamente el registro de usuario, y su solucion usando el FOSUserBundle para la gestion de usuarios en Symfony 3.

Generalmente las aplicaciones web, pueden ofrecer al usuario una de estas 2 formas para que se registren en el web.

Una de esas opciones y la mas “sencilla”, seria la de una pagina o vista con un formulario donde el usuario rellena dichos campos, y al enviar dicho formulario, se le envia a otra pagina distinta(ya sea de bienvenida, de procesar compra, etc.). Digo sencilla porque el FOSUserBundle de Symfony 3 ya ofrece esta funcionalidad de esa forma.

La segunda forma, seria la que podriamos ver cuando pulsamos un boton de la cabecera o header, y nos aparece una ventana modal en forma de capa con un fondo oscuro, en la que nos aparece el formulario con los campos, y que nos guia a traves de ese modal a otra parte de la aplicacion. (He tenido que ocultar ciertos detalles de esta captura por temas legales y de privacidad)

Registro con ventana modal
Registro con ventana modal

A efectos logicos, podria ser practicamente igual una forma que la otra, pero a efectos practicos no es igual, y su solucion es algo mas compleja que reescribir las vistas del FOSUserBundle y alguna que otra cosa mas. Tenemos que hacer varias cosas mas para que todo esto funcione y sea correcto usando las buenas practicas en Symfony 3. Dicho esto, comenzamos.

NOTA: en el proyecto estoy usando Symfony 3 y la ultima version del FOSUSerBundle, aunque supongo que para Symfony 2 sera practicamente igual.

1- Instalamos FOSUserBundle(composer.json)

“friendsofsymfony/user-bundle”: “dev-master”

2- Inicializamos en bundle en la aplicacion(app/AppKernel.php):

new FOS\UserBundle\FOSUserBundle(),

3- Importamos las rutas del FOSUserBundle para que esten accesibles:

#fos_user:
#    resource: "@FOSUserBundle/Resources/config/routing/all.xml"

fos_user_security:
    resource: "@FOSUserBundle/Resources/config/routing/security.xml"

fos_user_profile:
    resource: "@FOSUserBundle/Resources/config/routing/profile.xml"
    prefix: /profile

fos_user_register:
    resource: "@FOSUserBundle/Resources/config/routing/registration.xml"
    prefix: /register

fos_user_resetting:
    resource: "@FOSUserBundle/Resources/config/routing/resetting.xml"
    prefix: /resetting

fos_user_change_password:
    resource: "@FOSUserBundle/Resources/config/routing/change_password.xml"
    prefix: /profile

NOTA: Atentos a que la primera ruta esta comentada, pues importa todas las rutas del FOS, pero puede que no las queramos tener todas disponibles, por eso las importamos una a una a mano, mas abajo.

4- Configuramos el bundle(app/config/config.yml)

Una buena practica es crear un nuevo archivo por ejemplo “fos.yml” y añadir la configuracion especifica ahi, y despues importarlo en el config.yml.

fos_user:
    db_driver: orm # other valid values are 'mongodb', 'couchdb' and 'propel'
    firewall_name: main
    user_class: UserBundle\Entity\User
    registration:
        form:
            type: UserBundle\Form\RegistrationType
    use_username_form_type: false

NOTA: Por una parte, configuramos para que el formulario de registro use nuestro formulario(ya que lo tendremos que sobrescribir) y despues desactivamos que el formulario haga uso de la validacion por el campo username. Mas adelante, lo explicare.

5- Definimos la seguridad, roles, y providers(app/config/security.yml)

# To get started with security, check out the documentation:
# http://symfony.com/doc/current/book/security.html
security:

    encoders:
        UserBundle\Entity\User: sha512
        FOS\UserBundle\Model\UserInterface: sha512

    role_hierarchy:
        ROLE_ADMIN:       ROLE_USER
        ROLE_SUPER_ADMIN: ROLE_ADMIN

    # http://symfony.com/doc/current/book/security.html#where-do-users-come-from-user-providers
    providers:
        fos_userbundle:
            id: fos_user.user_provider.username_email

    firewalls:
        # disables authentication for assets and the profiler, adapt it according to your needs
        dev:
            pattern: ^/(_(profiler|wdt)|css|images|js)/
            security: false

        main:
            pattern: ^/
            form_login:
                provider: fos_userbundle
                csrf_token_generator: security.csrf.token_manager
                login_path: fos_user_security_login
                check_path: fos_user_security_check
                failure_path: fos_user_security_login
                always_use_default_target_path: true
                default_target_path: homepage
                # if you are using Symfony < 2.8, use the following config instead:
                # csrf_provider: form.csrf_provider

            logout:       true
            anonymous:    true
            # activate different ways to authenticate

            # http_basic: ~
            # http://symfony.com/doc/current/book/security.html#a-configuring-how-your-users-will-authenticate

            # form_login: ~
            # http://symfony.com/doc/current/cookbook/security/form_login_setup.html

    access_control:
        - { path: ^/login$, role: IS_AUTHENTICATED_ANONYMOUSLY }
        - { path: ^/register, role: IS_AUTHENTICATED_ANONYMOUSLY }
        - { path: ^/resetting, role: IS_AUTHENTICATED_ANONYMOUSLY }
        - { path: ^/admin/, role: ROLE_ADMIN }

NOTA: En nuestro caso, tenemos un par de roles muy sencillos y poco mas.

6- Creamos la entity User que extenderá la que lleva el FOSUserBundle, con algunos campos más:

use FOS\UserBundle\Model\User as BaseUser;
use Doctrine\ORM\Mapping as ORM;

/**
 * @ORM\Entity
 * @ORM\Table(name="ecommerce_user")
 */
class User extends BaseUser
{
 /**
 * @ORM\Id
 * @ORM\Column(type="integer")
 * @ORM\GeneratedValue(strategy="AUTO")
 */
 protected $id;

 /**
 * @ORM\Column(type="string", length=250, nullable=true)
 */
 protected $name;

 /**
 * @ORM\Column(type="string", length=250, nullable=true)
 */
 protected $surname;

 public function __construct()
 {
     parent::__construct();
     // your own logic

     $this->enabled = true;
 }

 /**
 * @return string
 */
 public function getName()
 {
 return $this->name;
 }

 /**
 * @param string $name
 */
 public function setName($name)
 {
 $this->name = $name;
 }

 /**
 * @return string
 */
 public function getSurname()
 {
 return $this->surname;
 }

 /**
 * @param string $surname
 */
 public function setSurname($surname)
 {
 $this->surname = $surname;
 }

 /**
 * @param string $email
 *
 * @return $this|\FOS\UserBundle\Model\UserInterface
 */
 public function setEmail($email)
 {
     $this->setUsername($email);
     return parent::setEmail($email);
 }
}

NOTA: Prestad especial atencion al metodo setEmail(). Este metodo esta implementado en la clase BaseUser del FOS, pero nosotros necesitamos “sobrescribirlo” porque en nuestro caso el email sera nuestro “Identificador” del usuario con el que se podra “logear” en la aplicacion web.

Por supuesto, hay que aplicar los nuevas cambios en la base de datos usando el comando:

$ php bin/console doctrine:schema:update –force –dump-sql

7- Sobrescribir el formulario de registro del FOS por el nuestro personalizado:

class RegistrationType extends AbstractType
{
    /**
     * @param FormBuilderInterface $builder
     * @param array $options
     */
    public function buildForm(FormBuilderInterface $builder, array $options)
    {
        $builder
            ->add('name', TextType::class, array(
                'label' => 'Nombre',
                'required' => true,
                'constraints' => array(
                    new NotBlank(),
                ),
            ))
            ->add('surname', TextType::class, array(
                'label' => 'Apellidos',
                'required' => true,
                'constraints' => array(
                  new NotBlank(),
                ),
            ))
            ->add('email', EmailType::class, array(
                'label' => 'Email',
                'required' => true,
                'constraints' => array(
                    new NotBlank(),
                ),
            ))
            ->add('plainPassword', TextType::class, array(
                'label' => 'Contraseña',
                'required' => true,
                'constraints' => array(
                    new NotBlank(),
                )
            )
        );
    }

    public function configureOptions(OptionsResolver $resolver)
    {
        $resolver->setDefaults(array(
            'data_class' => 'UserBundle\Entity\User',
            'csrf_token_id' => 'registration'
        ));
    }

    public function getBlockPrefix()
    {
        return 'user_registration';
    }
}

En  nuestro caso, no necesitamos el campo “username” o “password” con validacion que “impone” el formulario base del FOSUserBundle. Es por ello, que lo sobrescribimos de esta forma. Si nos acordamos bien, definimos en fos.yml que el formulario de registro iba a ser uno nuestro. Pues bien, este es el que se usara.

Uno de los problemas que me encontre al usar el formulario base del FOS fue que esos campos(username, o password con validacion) debian mostrarse si o si, y aunque se oculten para no mostrarse, el formulario daba error, sobretodo por Javascript al decir que dichos campos no eran “focusable” , es decir, no podia situarse el foco(raton, tabulador teclado, etc.) en ellos.

8- Sobrescribir el controlador del registro

Aqui os explicare porque, ya que en mi caso, el controller base del FOS redirige a una pagina nueva, y en nuestro caso no es asi, sino la misma pagina donde estabamos pero mostrando la ventana modal. Por lo tanto, necesitamos sobrescribir dicha funcionalidad.

El bundle nos dice en su documentacion, que para poder “sobrescribir” un Controller, necesitamos crear un bundle “hijo” que herede del FOS.

8.1- Creamos un nuevo UserBundle

$ php bin/console generate:bundle –namespace=UserBundle –dir=src

8.2- Le decimos que nuestro nuevo bundle herede del FOSUserBundle (src/UserBundle/UserBundle.php)

class UserBundle extends Bundle
{
    public function getParent()
    {
        return 'FOSUserBundle';
    }
}

8.3- Creamos un nuevo RegisterController.php que sustituira el del FOS

<?php

/*
 * This file overrides the FOSUserBundle registration controller.
 *
 * (c) FriendsOfSymfony <http://friendsofsymfony.github.com/>
 *
 * For the full copyright and license information, please view the LICENSE
 * file that was distributed with this source code.
 */

namespace UserBundle\Controller;

use AppBundle\Controller\BaseController;
use FOS\UserBundle\Event\FilterUserResponseEvent;
use FOS\UserBundle\Event\FormEvent;
use FOS\UserBundle\Event\GetResponseUserEvent;
use FOS\UserBundle\Form\Factory\FactoryInterface;
use FOS\UserBundle\FOSUserEvents;
use FOS\UserBundle\Model\UserInterface;
use FOS\UserBundle\Model\UserManagerInterface;
use Symfony\Component\EventDispatcher\EventDispatcherInterface;
use Symfony\Component\HttpFoundation\RedirectResponse;
use Symfony\Component\HttpFoundation\Request;
use Symfony\Component\HttpFoundation\Response;
use Symfony\Component\HttpKernel\Exception\NotFoundHttpException;
use Symfony\Component\Security\Core\Exception\AccessDeniedException;

/**
 * Controller managing the registration.
 *
 * @author Thibault Duplessis <thibault.duplessis@gmail.com>
 * @author Christophe Coevoet <stof@notk.org>
 */
class RegistrationController extends BaseController
{
    /**
     * @param Request $request
     *
     * @return Response
     */
    public function registerAction(Request $request)
    {
        /** @var $formFactory FactoryInterface */
        $formFactory = $this->get('fos_user.registration.form.factory');
        /** @var $userManager UserManagerInterface */
        $userManager = $this->get('fos_user.user_manager');
        /** @var $dispatcher EventDispatcherInterface */
        $dispatcher = $this->get('event_dispatcher');

        $user = $userManager->createUser();

        $event = new GetResponseUserEvent($user, $request);
        $dispatcher->dispatch(FOSUserEvents::REGISTRATION_INITIALIZE, $event);

        if (null !== $event->getResponse()) {
            return $event->getResponse();
        }

        $form = $formFactory->createForm();
        $form->setData($user);

        $form->handleRequest($request);

        if ($form->isSubmitted()) {
            if ($form->isValid()) {
                $event = new FormEvent($form, $request);
                $dispatcher->dispatch(FOSUserEvents::REGISTRATION_SUCCESS, $event);

                $userManager->updateUser($user);

                if (null === $response = $event->getResponse()) {
                    $url = $this->generateUrl('fos_user_registration_confirmed');
                    $response = new RedirectResponse($url);
                }

                $dispatcher->dispatch(FOSUserEvents::REGISTRATION_COMPLETED, new FilterUserResponseEvent($user, $request, $response));

                return $response;
            }

            $event = new FormEvent($form, $request);
            $dispatcher->dispatch(FOSUserEvents::REGISTRATION_FAILURE, $event);

            if (null !== $response = $event->getResponse()) {
                return $response;
            }
        }

        return $this->redirectToReferer($request);

//        return $this->render('FOSUserBundle:Registration:register.html.twig', array(
//            'form' => $form->createView(),
//        ));
    }

    /**
     * Tell the user to check his email provider.
     */
    public function checkEmailAction()
    {
        $email = $this->get('session')->get('fos_user_send_confirmation_email/email');

        if (empty($email)) {
            return new RedirectResponse($this->get('router')->generate('fos_user_registration_register'));
        }

        $this->get('session')->remove('fos_user_send_confirmation_email/email');
        $user = $this->get('fos_user.user_manager')->findUserByEmail($email);

        if (null === $user) {
            throw new NotFoundHttpException(sprintf('The user with email "%s" does not exist', $email));
        }

        return $this->render('FOSUserBundle:Registration:check_email.html.twig', array(
            'user' => $user,
        ));
    }

    /**
     * Receive the confirmation token from user email provider, login the user.
     *
     * @param Request $request
     * @param string  $token
     *
     * @return Response
     */
    public function confirmAction(Request $request, $token)
    {
        /** @var $userManager \FOS\UserBundle\Model\UserManagerInterface */
        $userManager = $this->get('fos_user.user_manager');

        $user = $userManager->findUserByConfirmationToken($token);

        if (null === $user) {
            throw new NotFoundHttpException(sprintf('The user with confirmation token "%s" does not exist', $token));
        }

        /** @var $dispatcher EventDispatcherInterface */
        $dispatcher = $this->get('event_dispatcher');

        $user->setConfirmationToken(null);
        $user->setEnabled(true);

        $event = new GetResponseUserEvent($user, $request);
        $dispatcher->dispatch(FOSUserEvents::REGISTRATION_CONFIRM, $event);

        $userManager->updateUser($user);

        if (null === $response = $event->getResponse()) {
            $url = $this->generateUrl('fos_user_registration_confirmed');
            $response = new RedirectResponse($url);
        }

        $dispatcher->dispatch(FOSUserEvents::REGISTRATION_CONFIRMED, new FilterUserResponseEvent($user, $request, $response));

        return $response;
    }

    /**
     * Tell the user his account is now confirmed.
     */
    public function confirmedAction()
    {
        $user = $this->getUser();
        if (!is_object($user) || !$user instanceof UserInterface) {
            throw new AccessDeniedException('This user does not have access to this section.');
        }

        return $this->render('FOSUserBundle:Registration:confirmed.html.twig', array(
            'user' => $user,
            'targetUrl' => $this->getTargetUrlFromSession(),
        ));
    }

    /**
     * @return mixed
     */
    private function getTargetUrlFromSession()
    {
        $key = sprintf('_security.%s.target_path', $this->get('security.token_storage')->getToken()->getProviderKey());

        if ($this->get('session')->has($key)) {
            return $this->get('session')->get($key);
        }
    }
}

Si observais en rojo he comentado el render de su propia vista, y en verde mi codigo, que devuelve al usuario a la pagina de donde a venido. Podriamos pasarle algun parametro o flag para que cuando se cargue esa vista, abra automaticamente la ventana modal y muestre algo, por ejemplo. Eso lo dejo a vuestro a vuestra eleccion. Ademas, tambien tenemos que implementar el resto de metodos que hay en dicho controlador, en mi caso los he dejado igual que estaban.

SUGERENCIA: Al comenzar el proyecto solo tenia un unico bundle (AppBundle) donde iba metiendo la logica de negocio de la aplicacion web. Al necesitar “sobrescribir” el FOSUserBundle, he necesitado crear un nuevo UserBundle por lo que “todo” lo relacionado con los usuarios lo he migrado al UserBundle(Controllers, vistas, js, Entity, etc.) para no mezclarlo con el resto de cosas que iran en ApBundle.

El resto ya es cosa vuestra, es decir debereis usar algun plugin de jQuery o lo que useis para implementar vuestro “overlay” o dialogo modal y pintar alli el formulario. Os dejo un ejemplo de como quedaria el mio:

REGISTER-MODAL.HTML.TWIG

El action del controller quedaria de la siguiente forma:

/**
 * @Route("/", name="homepage")
 */
public function indexAction(Request $request)
{
    /** @var $formFactory FactoryInterface */
    $formFactory = $this->get('fos_user.registration.form.factory');
    $user = new User();
    $form = $formFactory->createForm();
    $form->setData($user);

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

El siguiente problema al que me enfrento es el siguiente: Imaginad que mi aplicacion web tiene 10 paginas en el front. En la cabecera(header) es donde se llama a la ventana modal para mostrar el formulario de registro, es decir, que por logica en cada Action del Controller deberia crear el formulario cada vez y enviarselo como parametro a cada vista( 10 veces al menos ).

Para evitar duplicar el mismo bloque cada vez, me ha pasado un buen amigo una idea que me parece bastante acertada, y consiste en usar la funcion “render” de twig para llamar a un controller y que este se encargue de crear el formulario. Esto se haria asi:

En nuestro template(footer.html.twig) usamos la funcion twig asi:

{{ render(controller('AppBundle:Default:registerModal')) }}

Y en nuestro controller, creamos el formulario de registro y pintamos la vista “parcial”, y hacemos lo siguiente:

/**
 * @Route("/register-modal", name="register_modal")
 */
public function registerModalAction()
{
    /** @var $formFactory FactoryInterface */
    $formFactory = $this->get('fos_user.registration.form.factory');
    $user = new User();
    $form = $formFactory->createForm();
    $form->setData($user);

    return $this->render('UserBundle:user:register-modal.html.twig', array(
        'form' => $form->createView()
    ));
}

De esta forma, todas las vistas que muestren el footer, construiran el formulario de registro y mostraran la ventana modal con el registro de usuario, asi no “duplicamos” la misma logica en todos los action del controlador.

 

Espero que os haya gustado, y si teneis otra forma distinta de hacerlo o teneis alguna pregunta, no dudeis en preguntar y compartirlo en las redes sociales.

Saludos SymfonyDevs ¡¡