Symfony2 FOS User Bundle

Symfony2 FOS User Bundle

FOS User Bundle bietet ein flexibles Framework für die Verwaltung von Benutzern, um gemeinsame Aufgaben wie Benutzerregistrierung und Passwortwiederherstellung zu verwalten.
Eigenschaften:

  • Benutzer können über ORM Doctrine gespeichert werden
  • Registrierungsunterstützung mit optionaler E-Mail-Bestätigung
  • Unterstützung zurücksetzen

Installation

Installation ist ein schneller 7-stufiger Prozess:

  1. Laden Sie FOSUserBundle mit dem Composer herunter
  2. Bundle aktivieren
  3. Erstellen Sie Ihre Benutzerklasse
  4. Konfigurieren Sie die security.yml Ihrer Anwendung
  5. Konfiguriere das FOSUserBundle
  6. FOSUserBundle-Routing importieren
  7. Aktualisiere dein Datenbankschema

Schritt 1: Laden Sie FOSUserBundle mit dem Komponisten herunter

Fügen Sie FOSUserBundle zu Ihrem composer.json hinzu:

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

Nun sagen Sie dem Komponisten, das Paket herunterzuladen, indem Sie den Befehl ausführen:

>komponist aktualisieren friendsofsymfony / user-bundle

Komponist wird das Paket im Verzeichnis des Lieferanten / friendsofsymfony Ihres Projekts installieren.

Schritt 2: Aktiviere das Paket

Block im Kernel aktivieren:

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

Schritt 3: Erstellen Sie Ihre Benutzerklasse

Erstellen Sie die Benutzerklasse für Ihre Anwendung. Das Hauptziel dieses Bündels besteht darin, dies fortzusetzen Benutzerklasse zu einer Datenbank.

Das Bündel bietet Basisklassen, die bereits den meisten Feldern zugeordnet sind, um die Erstellung Ihrer Entität zu erleichtern. Hier ist, wie Sie es verwenden:

  1. Erweitern Sie die Basisbenutzerklasse (aus dem Vorlagenordner, wenn Sie eine der Varianten der Lehre verwenden)
  2. Markieren Sie das Identifikationsfeld. Es muss geschützt werden, wenn es von der übergeordneten Klasse geerbt wird.
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

    }

}

Schritt 4: Konfigurieren Sie die security.yml Ihrer Anwendung

Hier ist ein minimales Beispiel für die Konfiguration, die für die Verwendung von FOSUserBundle in Ihrer Anwendung benötigt wird:

# app/config/security.yml

Sicherheit:

Geber:

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 }

Schritt 5: Konfigurieren Sie das FOSUserBundle

Fügen Sie der config.yml-Datei die folgende Konfiguration hinzu.

# app/config/config.yml

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

Schritt 6: Importieren von Routing-Dateien FOSUserBundle

Durch das Importieren von Routing-Dateien, haben Sie readymade Seiten für Dinge wie Login, Erstellen von Benutzern, und so weiter.
In 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

Schritt 7: Aktualisiere dein Datenbankschema

Jetzt müssen Sie Ihr Datenbankschema für Ihre Benutzerentität aktualisieren, die Sie erstellt haben.
Der Befehl zum Aktualisieren des Schemas lautet wie folgt:

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

Jetzt können Sie den Bündel-Feed in Ihrem Browser ausführen.

Unten ist die User-Klasse, die ich für verschiedene Felder erstellt habe, indem ich das FOS User Bundle erweitere.

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

/**
 * Benutzer
 *
 * @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;
    }

    /**
     * Vornamen definieren
     *
     * @param string $firstname
     * @return User
     */
    public function setFirstname($firstname)
    {
        $this->firstname = $firstname;
   
        return $this;
    }

    /**
     * Holen Sie sich den Vornamen
     *
     * @return string
     */
    public function getFirstname()
    {
        return $this->firstname;
    }

    /**
     * Definiere den Nachnamen
     *
     * @param string $lastname
     * @return User
     */
    public function setLastname($lastname)
    {
        $this->lastname = $lastname;
   
        return $this;
    }

    /**
     * Holen Sie sich den Nachnamen
     *
     * @return string
     */
    public function getLastname()
    {
        return $this->lastname;
    }

    /**
     * Geschlecht definieren
     *
     * @param string $gender
     * @return User
     */
    public function setGender($gender)
    {
        $this->gender = $gender;
   
        return $this;
    }

    /**
     * Holen Sie sich das Genre
     *
     * @return string
     */
    public function getGender()
    {
        return $this->gender;
    }

    /**
     * Freizeit definieren
     *
     * @param array $hobby
     * @return User
     */
    public function setHobby($hobby)
    {
        $this->hobby = $hobby;
   
        return $this;
    }

    /**
     * Holen Sie sich ein Hobby
     *
     * @return array
     */
    public function getHobby()
    {
        return $this->hobby;
    }

    /**
     * Stellen Sie das Telefon ein
     *
     * @param string $phone
     * @return User
     */
    public function setPhone($phone)
    {
        $this->phone = $phone;
   
        return $this;
    }

    /**
     * Holen Sie sich ein Telefon
     *
     * @return string
     */
    public function getPhone()
    {
        return $this->phone;
    }

    /**
     * Land definieren
     *
     * @param string $country
     * @return User
     */
    public function setCountry($country)
    {
        $this->country = $country;
   
        return $this;
    }
    /**
     * Holen Sie sich ein Land
     *
     * @return string
     */
    public function getCountry()
    {
        return $this->country;
    }
}

Ersetzen Sie einen Formulartyp:

FOSUserBundle bietet Funktionen für die Registrierung neuer Benutzer, die Aktualisierung Ihres Profils, das Ändern Ihres Passworts und vieles mehr. Wenn Sie mehr Eigenschaften zum Formular hinzufügen mögen,müssen Sie Eigenschaften in Ihrer Benutzerklasse hinzufügen , wie oben beschrieben. Dann können Sie Ihr eigenes Anmeldeformular erstellen.

Der erste Schritt besteht darin, einen neuen Formulartyp in deinem eigenen Paket zu erstellen. Die folgende Klasse erweitert das grundlegende FOSUserBundle RegistrationFormType und fügt dann die benutzerdefinierten Felder hinzu.

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';
    }
}

Jetzt hast du dein benutzerdefiniertes Formular mit FOS User Bundle erstellt, also musst du es als Service deklarieren.
Hier ist das Beispiel für die Konfiguration des Formulartyps als Dienst im YAML-Format:

# 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 }

Ersetzen von Controllern:

Dann habe ich einen Plattencontroller gemacht, indem ich den Recorder-Controller des FOS-Benutzers FOL wie folgt lösche:

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


Figure shows the registration page which I have created by using the FOS User Bundle.

FOSUserBundle Emails:

  •   Bestätigung der Registrierung

Die E-Mail-Bestätigungsanforderung für ein neues Konto ist standardmäßig deaktiviert. Um es zu aktivieren, aktualisiere deine Konfiguration wie folgt:

# app/config/config.yml

fos_user:

    # ...

         Anmeldung:
                 Bestätigung:
            enabled:    true

 Passwort zurücksetzen

Das FOSUserBundle bietet die Passwort-Reset-Funktionalität in einem zweistufigen Prozess. Zuerst muss der Benutzer ein Passwort zurücksetzen. Sobald die Anfrage gestellt ist, wird eine E-Mail gesendet, die einen Link enthält. Nach dem Besuch des Links wird der Benutzer durch das in der URL enthaltene Token identifiziert. Wenn der Benutzer den Link besucht und das Token bestätigt ist, erhält der Benutzer ein Formular, um ein neues Passwort einzugeben.

  Standard-Mailer-Implementierungen

Das Paket kommt mit drei E-Mail-Implementierungen. Sie sind unten aufgeführt von Service ID:

  • fos_user.mailer.default ist die Standardimplementierung und verwendet Swiftmailer zum Senden von E-Mails.
  • fos_user.mailer.twig_swift verwendet Swiftmailer, um E-Mails und Twig-Blöcke zu senden, um die Nachricht zu machen.
  • fos_user.mailer.noop ist eine E-Mail-Implementierung, die nicht funktioniert, also wird keine E-Mail gesendet.

  Konfigurieren der E-Mail-Adresse des Absenders

Mit dem Standard-Absender FOSUserBundle können Sie die E-Mail-Adresse des Absenders der vom Paket gesendeten E-Mails konfigurieren. Sie können die Adresse global oder per E-Mail konfigurieren.

Um die E-Mail-Adresse des Absenders für alle vom Paket gesendeten E-Mails zu konfigurieren, aktualisieren Sie einfach Ihre fos_user-Konfiguration wie folgt:

# app/config/config.yml

fos_user:
    der E-Mail:
        address:        noreply@symfonydemo.com
        sender_name:    Symfony Demo App

Das Bündel bietet auch die Flexibilität, damit Sie die E-Mail-Adresse des Absenders für E-Mails einzeln konfigurieren können.

Um die E-Mail-Adresse des Absenders für die Bestätigung der Benutzerregistrierung zu konfigurieren, aktualisieren Sie Ihre fos_user-Konfiguration wie folgt:

# app/config/config.yml

fos_user:
         Anmeldung:
           Bestätigung:
            der E-Mail:
                Adresse:        registration@symfonydemo.com
                Absendername:    Symfony Demo Registration

Sie können auch die fos_user-Konfiguration aktualisieren, um die E-Mail-Adresse des Absenders für die E-Mail-Adresse für das Passwort zurückzusetzen:

# app/config/config.yml

fos_user:
    Anmeldung::
        Bestätigung:
            der E-Mail:
                Adresse:        registration@symfonydemo.com
                Absendername:    Symfony Demo Registration

  HTML-Mail senden

Der Standard-Absender unterstützt nur das Senden von Klartextnachrichten. Wenn Sie Multiparty-Nachrichten senden möchten, ist die einfachste Lösung die Verwendung der TwigSwiftMailer-Implementierung. Es erwartet, dass Ihr Zweigmuster 3 Blöcke definiert:

  • Thema mit dem Betreff der E-Mail
  • body_text, das die Klartextversion der Nachricht wiedergibt
  • body_html macht mail html


Hier kannst du es benutzen:

# app/config/config.yml

fos_user:

    # ...

    service:

        mailer: fos_user.mailer.twig_swift

      Reset:

        email:

            Vorlage: 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 %}

Hallo {{ user.username }} !

Sie können Ihre E-Mail zurücksetzen, indem Sie {{ confirmationUrl }}

Gruß,

das Symfony-Team

{% endautoescape %}

{% endblock %}

{% block body_html %}

{#

     Du kannst natürlich das html direkt hier machen
 
     Inklusive eines Modells wie hier gemacht hilft, die Dinge trocken zu halten
 
     das Erbe des Modells

#}

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

{% endblock %}