Symfony2 FOS User Bundle

Symfony2 FOS User Bundle

FOS User Bundle fournit un cadre flexible pour la gestion des utilisateurs qui vise à gérer des tâches communes telles que l'enregistrement des utilisateurs et la récupération de mot de passe.
Les fonctionnalités incluent:

  • Les utilisateurs peuvent être stockés via Doctrine ORM
  • Support d'inscription, avec une confirmation facultative par courrier électronique
  • Support de remise à zéro

Installation

L'installation est un processus rapide de 7 étapes:

  1. Télécharger FOSUserBundle à l'aide du compositeur
  2. Activer le Bundle
  3. Créez votre classe d'utilisateur
  4. Configurez le security.yml de votre application
  5. Configurez le FOSUserBundle
  6. Importer le routage FOSUserBundle
  7. Mettre à jour votre schéma de base de données

Étape 1: Télécharger FOSUserBundle à l'aide du compositeur

Ajoutez FOSUserBundle dans votre composer.json:

{
   "exiger": {
"friendsofsymfony / user-bundle": "~2.0@dev"
   }
 }

Dites maintenant au compositeur de télécharger le paquet en exécutant la commande:

>compositeur update friendsofsymfony / user-bundle

Composer installera le paquet dans le répertoire fournisseur / friendsofsymfony de votre projet.

Étape 2: activer le paquet

Activer le bloc dans le noyau:

// app/AppKernel.php
   public function registerBundles()
   {
      $bundles = array(
      // ...
      new FOS\UserBundle\FOSUserBundle(),
      );
   }

Étape 3: Créez votre classe d'utilisateur

Créez laClasse d'utilisateur pour votre application. L'objectif principal de ce paquet est de persévérer dans cette Classe d'utilisateur dans une base de données.

Le bundle fournit des classes de base qui sont déjà mappées pour la plupart des champs pour faciliter la création de votre entité. Voici comment vous l'utilisez:

  1. Étendre la classe d'utilisateur de base (à partir du dossier Modèle si vous utilisez une des variantes de la doctrine)
  2. Mappez le champ d'identification. Il doit être protégé s'il est hérité de la classe parent.
namespace Jigar\UserBundle\Entity;

use FOS\UserBundle\Model\User as BaseUser;

use Doctrine\ORM\Mapping as ORM;

/**

 * @ORM\Entity

 * @ORM\Table(name="fos_user")

 */

class User extends BaseUser

{

    /**

     * @ORM\Id

     * @ORM\Column(type="integer")

     * @ORM\GeneratedValue(strategy="AUTO")

     */

    protected $id;



    public function __construct()

    {

        parent::__construct();

        // your own logic

    }

}

Étape 4: Configurez le security.yml de votre application

Voici un exemple minimal de la configuration nécessaire pour utiliser FOSUserBundle dans votre application:

# app/config/security.yml

Sécurité:

encodeurs:

FOS\UserBundle\Model\UserInterface: sha512 

    role_hierarchy:

        ROLE_ADMIN:       ROLE_USER

        ROLE_SUPER_ADMIN: ROLE_ADMIN

    providers:

        fos_userbundle:

            id: fos_user.user_provider.username

    firewalls:

        main:

            pattern: ^/

            form_login:

                provider: fos_userbundle

                csrf_provider: form.csrf_provider

            logout:       true

            anonymous:    true

    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 }

Étape 5: Configurez le FOSUserBundle

Ajoutez la configuration suivante à votre fichier config.yml.

# app/config/config.yml

fos_user:
    db_driver: orm
    firewall_name: main
    user_class: Jigar\UserBundle\Entity\User

Étape 6: Importer les fichiers de routage FOSUserBundle

En important les fichiers de routage, vous aurez des pages readymade pour des choses telles que la connexion, la création d'utilisateurs, etc.
Dans YAML:

# app/config/routing.yml

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

Étape 7: Mettre à jour votre schéma de base de données

Maintenant, vous devez mettre à jour votre schéma de base de données pour votre entité utilisateur que vous avez créée.

La commande de mise à jour du schéma est la suivante:

 >php app/console doctrine:schema:update --force

Maintenant, vous pouvez exécuter le flux bundle dans votre navigateur.

Vous trouverez ci-dessous la classe Utilisateur que j'ai créée pour différents champs en étendant le FOS User Bundle.

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

/**
 * Utilisateur
 *
 * @ORM\Table(name="fos_user")
 * @ORM\Entity(repositoryClass="Jigar\UserBundle\Entity\UserRepository")
 */
class User extends BaseUser
{
    /**
     * @var integer
     *
     * @ORM\Column(name="id", type="integer")
     * @ORM\Id
     * @ORM\GeneratedValue(strategy="AUTO")
     */
    protected $id;
    /**
     * @var string $firstname
     *
     * @ORM\Column(name="firstName", type="string", length=255)
     */
    protected $firstname;
    /**
     *
     * @var string
     *
     * @ORM\Column(name="lastname", type="string", length=255)
     */
    protected $lastname;
    /**
     *
     * @var string
     *
     * @ORM\Column(name="gender", type="string", length=1)
     */
    protected $gender;
   
    /**
     *
     * @var string
     *
     * @ORM\Column(name="hobby", type="array")
     */
    protected $hobby;
   
    /**
     *
     * @var string
     *
     * @ORM\Column(name="country", type="string", length=55)
     */
    protected $country;

    /**
     *
     * @var string
     *
     * @ORM\Column(name="phone", type="string", length=15)
     */
    protected $phone;

    public function __construct()
    {
        parent::__construct();
    }
   
    /**
     * Get id
     *
     * @return integer
     */
    public function getId()
    {
        return $this->id;
    }

    /**
     * Définir le prénom
     *
     * @param string $firstname
     * @return User
     */
    public function setFirstname($firstname)
    {
        $this->firstname = $firstname;
   
        return $this;
    }

    /**
     * Obtenir le prénom
     *
     * @return string
     */
    public function getFirstname()
    {
        return $this->firstname;
    }

    /**
     * Définir le nom de famille
     *
     * @param string $lastname
     * @return User
     */
    public function setLastname($lastname)
    {
        $this->lastname = $lastname;
   
        return $this;
    }

    /**
     *  Obtenir le nom de famille
     *
     * @return string
     */
    public function getLastname()
    {
        return $this->lastname;
    }

    /**
     * Définir le genre
     *
     * @param string $gender
     * @return User
     */
    public function setGender($gender)
    {
        $this->gender = $gender;
   
        return $this;
    }

    /**
     * Obtenez le genre
     *
     * @return string
     */
    public function getGender()
    {
        return $this->gender;
    }

    /**
     * Définir le loisir
     *
     * @param array $hobby
     * @return User
     */
    public function setHobby($hobby)
    {
        $this->hobby = $hobby;
   
        return $this;
    }

    /**
     * Obtenir un passe-temps
     *
     * @return array
     */
    public function getHobby()
    {
        return $this->hobby;
    }

    /**
     * Définir le téléphone
     *
     * @param string $phone
     * @return User
     */
    public function setPhone($phone)
    {
        $this->phone = $phone;
   
        return $this;
    }

    /**
     * Obtenir un téléphone
     *
     * @return string
     */
    public function getPhone()
    {
        return $this->phone;
    }

    /**
     *  Définir le pays
     *
     * @param string $country
     * @return User
     */
    public function setCountry($country)
    {
        $this->country = $country;
   
        return $this;
    }
    /**
     * Obtenir le pays
     *
     * @return string
     */
    public function getCountry()
    {
        return $this->country;
    }
}

Remplacer un type de formulaire:

FOSUserBundle fournit des fonctionnalités pour l'enregistrement de nouveaux utilisateurs, la mise à jour de votre profil, la modification de votre mot de passe et bien plus encore. Si vous souhaitez ajouter plus de propriétés au formulaire, vous devez ajouter des propriétés dans votre classe d'utilisateurs comme indiqué ci-dessus. Ensuite, vous pouvez créer votre propre formulaire d'inscription.

La première étape consiste à créer un nouveau type de formulaire dans votre propre paquetage. La classe suivante étend le FOSUserBundle RegistrationFormType de base, puis ajoute les champs personnalisés.

namespace Jigar\UserBundle\Form\Type;

use Symfony\Component\Form\FormBuilderInterface;
use FOS\UserBundle\Form\Type\RegistrationFormType as BaseType;
use Symfony\Component\OptionsResolver\OptionsResolverInterface;

class RegistrationFormType extends BaseType
{
    public function setDefaultOptions(OptionsResolverInterface $resolver)
    {
        $resolver->setDefaults(array(
            'data_class' => 'Jigar\UserBundle\Entity\User',
        ));
    }
    public function buildForm(FormBuilderInterface $builder, array $options)
    {
        parent::buildForm($builder, $options);

        $builder->add('firstname')
                ->add('lastname')
                ->add('gender', 'choice',array(
                    'choices' => array('m' => 'Male', 'f' => 'Female'),
                    'expanded' => true ))
                ->add('hobby', 'choice',
                        array('choices' => array(
                            'travelling'=> 'Travelling',
                            'photography'=> 'Photography',
                            'reading'   => 'Reading'
                            ),
                            'expanded' => 'true',
                            'multiple' => 'true',
                        ))
                ->add('country', 'choice', array(
                    'empty_value' => 'Choose an option',
                    'choices' => array(
                        'IN' => 'India',
                        'USA' => 'USA',
                        'AU' => 'Australia'
                    )
                ))
                ->add('phone');
    }
    public function getName()
    {
        return 'jigar_user_registration';
    }
}

Maintenant, vous avez créé votre formulaire personnalisé en utilisant FOS User Bundle, donc vous devez le déclarer en tant que service.
Voici l'exemple de la configuration du type de formulaire en tant que service au format YAML:

# src/Jigar/UserBundle/Resources/config/services.yml

services:

    jigar_user.registration.form.type:

        class: Jigar\UserBundle\Form\Type\RegistrationFormType

        arguments: [%fos_user.model.user.class%]

        tags:

            - { name: form.type, alias: jigar_user_registration }

Overriding of Controllers:

Ensuite, j'ai fait un contrôleur d'enregistrement en annulant le contrôleur d'enregistrement du FOL de l'utilisateur FOS comme suit:

 namespace Jigar\UserBundle\Controller;

use Symfony\Bundle\FrameworkBundle\Controller\Controller;
use Symfony\Component\HttpFoundation\Request;
use FOS\UserBundle\Event\GetResponseUserEvent;
use FOS\UserBundle\FOSUserEvents;
use FOS\UserBundle\Event\FormEvent;
use Symfony\Component\HttpFoundation\RedirectResponse;
use FOS\UserBundle\Event\FilterUserResponseEvent;
class RegistrationController extends Controller
{
    public function registerAction(Request $request)
    {
        /** @var $formFactory \FOS\UserBundle\Form\Factory\FactoryInterface */
        $formFactory = $this->container->get('fos_user.registration.form.factory');
        /** @var $userManager \FOS\UserBundle\Model\UserManagerInterface */
        $userManager = $this->container->get('fos_user.user_manager');
        /** @var $dispatcher \Symfony\Component\EventDispatcher\EventDispatcherInterface */
        $dispatcher = $this->container->get('event_dispatcher');

        $user = $userManager->createUser();
        $user->setEnabled(true);

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

        if (null !== $event->getResponse()) {
            return $event->getResponse();
        }
       
        $form = $formFactory->createForm();
        $form->setData($user);

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

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

                $userManager->updateUser($user);

                if (null === $response = $event->getResponse()) {
                    $url = $this->container->get('router')->generate('jigar_user_registration_confirmed');
                    $response = new RedirectResponse($url);
                }

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

                return $response;
            }
        }

        return $this->container->get('templating')->renderResponse('JigarUserBundle:Registration:register.html.'.$this->getEngine(), array(
            'form' => $form->createView(),
        ));
    }
?>


La figure montre la page d'enregistrement que j'ai créée en utilisant le FOS User Bundle.

FOSUserBundle Emails:

  •   confirmation d'enregistrement

L'exigence de confirmation par courrier électronique pour un nouveau compte est désactivée par défaut. Pour l'activer, mettez à jour votre configuration comme suit:

# app/config/config.yml

fos_user:

    # ...

    registration:
        confirmation:
            enabled:    true

  Réinitialiser le mot de passe

Le FOSUserBundle fournit une fonctionnalité de réinitialisation de mot de passe dans un processus en deux étapes. D'abord, l'utilisateur doit demander une réinitialisation du mot de passe. Une fois la demande effectuée, un courrier électronique est envoyé contenant un lien à visiter. Après avoir visité le lien, l'utilisateur sera identifié par le jeton contenu dans l'url. Lorsque l'utilisateur visite le lien et le jeton est confirmé, l'utilisateur recevra un formulaire pour entrer un nouveau mot de passe.

  Implémentations de Mailer par défaut

Le paquet est livré avec trois implémentations de messagerie. Ils sont listés ci-dessous par l'ID du service:

  • fos_user.mailer.default est l'implémentation par défaut, et utilise Swiftmailer pour envoyer des emails.
  • fos_user.mailer.twig_swift utilise Swiftmailer pour envoyer des courriels et des blocs Twig pour rendre le message.
  • fos_user.mailer.noop est une implémentation de messagerie qui ne fonctionne pas, donc aucun courrier électronique n'est envoyé.

  Configuration de l'adresse e-mail de l'expéditeur

L'expéditeur par défaut FOSUserBundle vous permet de configurer l'adresse e-mail de l'expéditeur des emails envoyés par le paquet. Vous pouvez configurer l'adresse à l'échelle mondiale ou par courrier électronique.

Pour configurer l'adresse e-mail de l'expéditeur pour tous les courriels envoyés par le paquet, il suffit de mettre à jour votre configuration fos_user comme suit:

# app/config/config.yml

fos_user:
    de l'email:
        Adresse:        noreply@symfonydemo.com
        sender_name:    Symfony Demo App

Le bundle offre également la flexibilité de vous permettre de configurer l'adresse e-mail de l'expéditeur pour les courriels individuellement.

Pour configurer l'adresse e-mail de l'expéditeur pour la confirmation de l'inscription de l'utilisateur, mettez à jour votre configuration fos_user comme suit:

# app/config/config.yml

fos_user:
    enregistrement:
        confirmation:
            de l'email:
                Adresse:        registration@symfonydemo.com
                sender_name:    Symfony Demo Registration

Vous pouvez également mettre à jour la configuration fos_user pour modifier l'adresse e-mail de l'expéditeur pour le courriel de demande de réinitialisation du mot de passe:

# app/config/config.yml

fos_user:
    enregistrement:
        confirmation:
            de l'email:
                Adresse:        registration@symfonydemo.com
                sender_name:    Symfony Demo Registration

  Envoi de courriers HTML

L'expéditeur par défaut ne prend en charge que l'envoi de messages texte en clair. Si vous souhaitez envoyer des messages multipartites, la solution la plus simple est d'utiliser l'implémentation TwigSwiftMailer à la place. Il s'attend à ce que votre modèle de brindille définisse 3 blocs:

  • sujet contenant le sujet du courrier électronique
  • body_text rendant la version en texte brut du message
  • body_html rendant le courrier html


Voici comment vous pouvez l'utiliser:

# app/config/config.yml

fos_user:

    # ...

    service:

        mailer: fos_user.mailer.twig_swift

    réinitialisation:

        email:

            template: JigarUserBundle:User:resetting.email.html.twig

           {# src/Jigar/UserBundle/Resources/views/User/resetting.email.html.twig #}

{% block subject %}Resetting your password{% endblock %}

{% block body_text %}

{% autoescape false %}

Bonjour {{ user.username }} !

Vous pouvez réinitialiser votre courriel en accédant à {{ confirmationUrl }}

Salutations,

l'équipe Symfony

{% endautoescape %}

{% endblock %}

{% block body_html %}

{#

    Vous pouvez bien sûr rendre le html directement ici.

    Y compris un modèle tel que fait ici permet de garder les choses DRY en utilisant

    l'héritage du modèle

#}

{% include 'JigarUserBundle:User:resetting_email.html.twig' %}

{% endblock %}