WordPress

<?php


namespace App\Security;


use App\Entity\User;
use Doctrine\ORM\EntityManagerInterface;
use FOS\UserBundle\Model\UserManagerInterface;
use KnpU\OAuth2ClientBundle\Client\ClientRegistry;
use KnpU\OAuth2ClientBundle\Client\OAuth2Client;
use KnpU\OAuth2ClientBundle\Security\Authenticator\SocialAuthenticator;
use League\OAuth2\Client\Provider\GoogleUser;
use Symfony\Component\EventDispatcher\EventDispatcher;
use Symfony\Component\HttpFoundation\Cookie;
use Symfony\Component\HttpFoundation\RedirectResponse;
use Symfony\Component\HttpFoundation\Request;
use Symfony\Component\HttpFoundation\Response;
use Symfony\Component\HttpFoundation\Session\Session;
use Symfony\Component\HttpFoundation\Session\SessionInterface;
use Symfony\Component\Routing\RouterInterface;
use Symfony\Component\Security\Core\Authentication\Token\Storage\TokenStorageInterface;
use Symfony\Component\Security\Core\Authentication\Token\TokenInterface;
use Symfony\Component\Security\Core\Authentication\Token\UsernamePasswordToken;
use Symfony\Component\Security\Core\Encoder\PasswordEncoderInterface;
use Symfony\Component\Security\Core\Encoder\UserPasswordEncoderInterface;
use Symfony\Component\Security\Core\Exception\AuthenticationException;
use Symfony\Component\Security\Core\User\UserInterface;
use Symfony\Component\Security\Core\User\UserProviderInterface;
use Symfony\Component\Security\Guard\AuthenticatorInterface;
use Symfony\Component\Security\Guard\GuardAuthenticatorHandler;
use Symfony\Component\Security\Guard\Token\GuardTokenInterface;
use Symfony\Component\Security\Guard\Token\PostAuthenticationGuardToken;
use Symfony\Component\Security\Http\Event\InteractiveLoginEvent;

class GoogleAuthenticator extends SocialAuthenticator implements AuthenticatorInterface
{

    private $clientRegistry;
    private $em;
    private $router;
    private $userManager;
    const  ACCESS_TOKEN_NAME = '';
    private $tokenStorage;
    private $session;
    private $encoder;


    /**
     * GoogleAuthenticator constructor.
     * @param ClientRegistry $clientRegistry
     * @param EntityManagerInterface $em
     * @param UserManagerInterface $userManager
     * @param UserPasswordEncoderInterface $encoder
     * @param TokenStorageInterface $tokenStorage
     * @param RouterInterface $router
     * @param SessionInterface $session
     */
    public function __construct(ClientRegistry $clientRegistry,EntityManagerInterface $em, UserManagerInterface $userManager, UserPasswordEncoderInterface $encoder,
                                TokenStorageInterface $tokenStorage,RouterInterface $router,SessionInterface $session)
    {
        $this->clientRegistry = $clientRegistry;
        $this->em = $em;
        $this->router = $router;
        $this->userManager = $userManager;
        $this->tokenStorage = $tokenStorage;
        $this->session = $session;
        $this->encoder = $encoder;

    }


    public function start(Request $request, AuthenticationException $authException = null)
    {
        return $request->request->has('_username') && $request->request->has('_password');
    }


    public function onAuthenticationFailure(Request $request, AuthenticationException $exception)
    {
        $message = strtr($exception->getMessage(), $exception->getMessageData());

       // return new RedirectResponse('/login');
        return new Response($message, Response::HTTP_FORBIDDEN);
    }

    public function supports(Request $request)
    {

        return $request->getPathInfo() == '/connect/google/check' && $request->isMethod('GET');
    }

    public function getCredentials(Request $request)
    {
        return $this->fetchAccessToken($this->getGoogleClient());
    }

    public function getUser($credentials, UserProviderInterface $userProvider)
    {
        /** @var GoogleUser $googleUser */
        $googleUser = $this->getGoogleClient()
            ->fetchUserFromToken($credentials);

        $email = $googleUser->getEmail();

        $user = $this->em->getRepository('App:User')
            ->findOneBy(['email' => $email]);
        if (!$user) {
            $user = new User();
            $user->setEmail($googleUser->getEmail());
            $user->setFirstName($googleUser->getFirstName());
            $user->setLastName($googleUser->getLastName());
            $user->setJoinedOn(new \DateTime());
            $user->setUsername($googleUser->getEmail());
            $user->setEnabled(true);
//            $user->setApprovedAt(new \DateTime());
//            $user->setIdentityVerified(User::IDENTITY_VERIFIED);
//            $user->setRegistrationComplete(1);
//            $user->setRoles(['role_member']);
            $userPassword = rand(9000, 20000);
            $user->addRole('ROLE_USER');
            $encoded = $this->encoder->encodePassword($user,$userPassword);
            //$user->setPlainPassword($encoded);
            $user->setPassword($encoded);
            $user->setAvatar($googleUser->getAvatar());
            $this->em->persist($user);
            $this->em->flush();
        }

        $this->userManager->updateUser($user);




       return $user;
    }

    public function onAuthenticationSuccess(Request $request, TokenInterface $token, $providerKey)
    {
        /**
         * @var User $user
         */
        $user = $token->getUser();
//        dump($token->getUser());die;
//        dump(count($user->getRoles()));die;
        if (count($user->getRoles()) > 1){
            $targetUrl = $this->router->generate('dashboard');
            return new RedirectResponse($targetUrl);
        }else{

            //$user->addRole('ROLE_USER');
            $this->em->persist($user);
            $this->em->flush();
            $this->userManager->updateUser($user);
           // $firewallName = "main";

            $user_token = new UsernamePasswordToken($user, null, $providerKey, $user->getRoles());


            $this->tokenStorage->setToken($user_token);

           // $user_token->setUser($user);

            $this->session->start();

            $this->session->set('_security_main', serialize($user_token));

            $this->session->save();

            //$cookie = new Cookie($this->session->getName(), $this->session->getId());

            $targetUrl = $this->router->generate('fos_user_registration_confirmed');

            return new RedirectResponse($targetUrl);


        }
    }

    /**
     * @return OAuth2Client
     */
    private function getGoogleClient()
    {
        return $this->clientRegistry
            ->getClient('google');
    }

    /**
     * Create an authenticated token for the given user.
     *
     * If you don't care about which token class is used or don't really
     * understand what a "token" is, you can skip this method by extending
     * the AbstractGuardAuthenticator class from your authenticator.
     *
     * @param UserInterface $user
     * @param string  $providerKey The provider (i.e. firewall) key
     *
     * @return PostAuthenticationGuardToken
     *@see AbstractGuardAuthenticator
     *
     */
    public function createAuthenticatedToken(UserInterface $user, $providerKey)
    {
        return new PostAuthenticationGuardToken(
            $user,
            $providerKey,
            $user->getRoles()
        );

    }

}