<?php



namespace MyUserBundleController;

use FOSUserBundleControllerResettingController as FOSResettingController;
use FOSUserBundleFOSUserEvents;
use FOSUserBundleEventFormEvent;
use FOSUserBundleEventGetResponseUserEvent;
use FOSUserBundleEventFilterUserResponseEvent;
use FOSUserBundleModelUserInterface;
use SymfonyBundleFrameworkBundleControllerController;
use SymfonyComponentHttpFoundationRequest;
use SymfonyComponentHttpFoundationRedirectResponse;
use SymfonyComponentHttpKernelExceptionNotFoundHttpException;
use MyUserBundleEntityUser;
use SensioBundleFrameworkExtraBundleConfigurationRoute;
use MyUserBundleUserEvents;

/**
 * Controller managing the resetting of the password
 *
 * @author Thibault Duplessis <thibault.duplessis@gmail.com>
 * @author Christophe Coevoet <stof@notk.org>
 */
class ResettingController extends FOSResettingController
{


    /**
     * Request reset user password: submit form and send email
     */
    public function sendEmailAction(Request $request)
    {
        $username = $request->request->get('username');

        /** @var $user UserInterface */
        $user = $this->get('fos_user.user_manager')->findUserByUsernameOrEmail($username);

        if (null === $user) {
            return $this->render('FOSUserBundle:Resetting:request.html.twig', array(
                'invalid_username' => $username
            ));
        }

        if ($user->isPasswordRequestNonExpired($this->container->getParameter('fos_user.resetting.token_ttl'))) {
            return $this->render('FOSUserBundle:Resetting:passwordAlreadyRequested.html.twig');
        }

        if (null === $user->getConfirmationToken()) {
            /** @var $tokenGenerator FOSUserBundleUtilTokenGeneratorInterface */
            $tokenGenerator = $this->get('fos_user.util.token_generator');
            $user->setConfirmationToken($tokenGenerator->generateToken());
        }

        $this->get('fos_user.mailer')->sendResettingEmailMessage($user);
        $user->setPasswordRequestedAt(new DateTime());
        $user->setPasswordRequestedClicked(false);
        $this->get('fos_user.user_manager')->updateUser($user);

        $_SESSION['views'] = 1;

        return new RedirectResponse($this->generateUrl('fos_user_resetting_check_email',
            array('email' => $this->getObfuscatedEmail($user))
        ));
    }


    /**
     * Reset user password
     */
    public function resetAction(Request $request, $token)
    {
        /** @var $formFactory FOSUserBundleFormFactoryFactoryInterface */
        $formFactory = $this->get('fos_user.resetting.form.factory');
        /** @var $userManager FOSUserBundleModelUserManagerInterface */
        $userManager = $this->get('fos_user.user_manager');
        /** @var $dispatcher SymfonyComponentEventDispatcherEventDispatcherInterface */
        $dispatcher = $this->get('event_dispatcher');

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


        //Here there is a reaction for using expired token (column confirmation token === null) - redirection to page with possibility of sending another one.
        if (null === $user) {
               return $this->redirectToRoute('fos_user_invalid_token_click');

        }



        if ($_SESSION['views'] == 1){
            $event = new GetResponseUserEvent($user, $request);
            $dispatcher->dispatch(UserEvents::RESETTING_RESET_CLICK_CHECK, $event);

            if (null !== $event->getResponse()) {
                return $event->getResponse();
            } else {
                $user->setPasswordRequestedClicked(true);
                $userManager->updateUser($user);
                $_SESSION['views']++;
                $_SESSION['views']++;
            }
        } else {
            $_SESSION['views']++;
        }

        if ($_SESSION['views'] == 5){
            $event = new GetResponseUserEvent($user, $request);
            $dispatcher->dispatch(UserEvents::RESETTING_RESET_CLICK_CHECK, $event);

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



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

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



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




        $form->handleRequest($request);


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


            $userManager->updateUser($user);

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

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

            return $response;
        }

        $userManager->updateUser($user);
        return $this->render('FOSUserBundle:Resetting:reset.html.twig', array(
            'token' => $token,
            'form' => $form->createView(),
        ));
    }



    public function InvalidTokenTtlMessageAction() {
        return $this->render('UserBundle:Resetting:invalidTokenTtlRes.html.twig');
    }

    public function InvalidTokenClickMessageAction() {
        return $this->render('UserBundle:Resetting:invalidTokenClickRes.html.twig');
    }


}

<?php



namespace MyUserBundleEventListener;

use FOSUserBundleEventListenerResettingListener as FOSResettingListener;
use FOSUserBundleFOSUserEvents;
use MyUserBundleUserEvents;
use FOSUserBundleEventFormEvent;
use FOSUserBundleEventGetResponseUserEvent;
use SymfonyComponentEventDispatcherEventSubscriberInterface;
use SymfonyComponentHttpFoundationRedirectResponse;
use SymfonyComponentRoutingGeneratorUrlGeneratorInterface;
use MyUserBundleEntityUser;

class ResettingListener extends FOSResettingListener
{
    private $router;
    private $tokenTtl;

    public function __construct(UrlGeneratorInterface $router, $tokenTtl)
    {
        $this->router = $router;
        $this->tokenTtl = $tokenTtl;
    }

    public static function getSubscribedEvents()
    {
        return array(
            UserEvents::RESETTING_RESET_CLICK_CHECK => 'onResettingClickCheck',
            FOSUserEvents::RESETTING_RESET_INITIALIZE => 'onResettingResetInitialize',
            FOSUserEvents::RESETTING_RESET_SUCCESS => 'onResettingResetSuccess',

        );
    }

    public function onResettingClickCheck(GetResponseUserEvent $event){
        //checking if link hasn't expired due to its usage
        if ($event->getUser()->isPasswordRequestedClicked() === true){
            $event->setResponse(new RedirectResponse($this->router->generate('fos_user_invalid_token_click')));
        }
    }

    public function onResettingResetInitialize(GetResponseUserEvent $event)
    {
        //checking if link hasn't expired due to exceeding token Ttl
        if (!$event->getUser()->isPasswordRequestNonExpired($this->tokenTtl)) {
            $event->setResponse(new RedirectResponse($this->router->generate('fos_user_invalid_token_ttl')));
        }

    }

    public function onResettingResetSuccess(FormEvent $event)
    {

        /** @var $user FOSUserBundleModelUserInterface */
        $user = $event->getForm()->getData();

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



    }
}

<?php

namespace MyUserBundleEntity;

use DoctrineORMMapping as ORM;
use FOSUserBundleModelUser as BaseUser;
use MyBackendBundleEntity;
use GedmoMappingAnnotation as Gedmo;
use SymfonyComponentSecurityCoreUserUserInterface;
use DoctrineCommonCollectionsArrayCollection;


/**
 * User
 *
 * @ORMTable(name="user")
 * @ORMEntity(repositoryClass="MyUserBundleRepositoryUserRepository")
 */
class User extends BaseUser
{
    /**
     * @var int
     *
     * @ORMColumn(name="id", type="integer", nullable = false)
     * @ORMId
     * @ORMGeneratedValue(strategy="AUTO")
     */
    protected $id;


    /**
     * @GedmoSlug(fields={"username"})
     * @ORMColumn(length=128, unique=true)
     */
    private $slug;


    /**
     *
     * @ORMManyToMany(targetEntity="MyBackendBundleEntityEvent", mappedBy="users")
     * @ORMJoinColumn(name="id", referencedColumnName="id", nullable=false)
     * @ORMOrderBy({"date"="ASC"})
     *
     */
    protected $events;



    /**
     * @var DoctrineCommonCollectionsArrayCollection $event_org
     * @ORMOneToMany(targetEntity="MyBackendBundleEntityEvent", mappedBy="user_org", cascade={"all"})
     */
    protected $event_org;



    /**
     * @var DateTime
     * @ORMColumn(name="confirmation_token_requested_at", type="datetime")
     */
    protected $confirmationTokenRequestedAt;


    /**
     * @var boolean
     * @ORMColumn(name="password_requested_clicked", type="boolean", nullable=true)
     */
    protected $passwordRequestedClicked;





    public function __toString()
    {
        return $this->getUsername();
    }


    /**
     * Get id
     *
     * @return int
     */
    public function getId()
    {
        return $this->id;
    }

    public function __construct()
    {
        parent::__construct();
        $this->event_org = new DoctrineCommonCollectionsArrayCollection();


    }

    /**
     * Add event
     *
     * @param MyBackendBundleEntityEvent $event
     *
     * @return User
     */
    public function addEvent(MyBackendBundleEntityEvent $event)
    {
        $this->events[] = $event;
        $event->addUser($this);

        return $this;
    }

    /**
     * Remove event
     *
     * @param MyBackendBundleEntityEvent $event
     */
    public function removeEvent(MyBackendBundleEntityEvent $event)
    {
        $this->events->removeElement($event);
    }

    /**
     * Get events
     *
     * @return DoctrineCommonCollectionsCollection
     */
    public function getEvents()
    {
        return $this->events;
    }






    /**
     * Set slug
     *
     * @param string $slug
     *
     * @return User
     */
    public function setSlug($slug)
    {
        $this->slug = $slug;

        return $this;
    }

    /**
     * Get slug
     *
     * @return string
     */
    public function getSlug()
    {
        return $this->slug;
    }

    /**
     * Add eventOrg
     *
     * @param MyBackendBundleEntityEvent $eventOrg
     *
     * @return User
     */
    public function addEventOrg(MyBackendBundleEntityEvent $eventOrg)
    {
        $this->event_org[] = $eventOrg;

        return $this;
    }

    /**
     * Remove eventOrg
     *
     * @param MyBackendBundleEntityEvent $eventOrg
     */
    public function removeEventOrg(MyBackendBundleEntityEvent $eventOrg)
    {
        $this->event_org->removeElement($eventOrg);
    }

    /**
     * Get eventOrg
     *
     * @return DoctrineCommonCollectionsCollection
     */
    public function getEventOrg()
    {
        return $this->event_org;
    }

        /**
     * Set confirmationTokenRequestedAt
     *
     * @param DateTime $confirmationTokenRequestedAt
     *
     * @return User
     */
    public function setConfirmationTokenRequestedAt(DateTime $date = null)
    {
        $this->confirmationTokenRequestedAt = $date;

        return $this;
    }

    /**
     * Gets the timestamp that the user requested a confirmation_token.
     *
     * @return null|DateTime
     */
    public function getConfirmationTokenRequestedAt()
    {
        return $this->confirmationTokenRequestedAt;
    }

    public function isConfirmationTokenNonExpired($ttl)
    {

        return $this->getConfirmationTokenRequestedAt() instanceof DateTime &&
        $this->getConfirmationTokenRequestedAt()->getTimestamp() + $ttl > time();
    }

    /**
     * Set passwordRequestedClicked
     *
     * @param boolean $passwordRequestedClicked
     *
     * @return User
     */
    public function setPasswordRequestedClicked($boolean)
    {
        $this->passwordRequestedClicked = (Boolean) $boolean;

        return $this;
    }

    /**
     * Get passwordRequestedClicked
     *
     * @return boolean
     */
    public function getPasswordRequestedClicked()
    {
        return $this->passwordRequestedClicked;
    }

    /**
     * Checks whether the user has used password request.
     *
     *
     * @return Boolean true if the user is enabled, false otherwise
     */
    public function isPasswordRequestedClicked() {
        return $this->passwordRequestedClicked;
    }
}