WordPress

<?php


namespace App\Security;


use App\Entity\User;
use Doctrine\ORM\EntityManagerInterface;
use FOS\UserBundle\Model\UserManagerInterface;
use Intervention\Image\ImageManager;
use KnpU\OAuth2ClientBundle\Client\ClientRegistry;
use KnpU\OAuth2ClientBundle\Security\Authenticator\SocialAuthenticator;
use League\OAuth2\Client\Provider\FacebookUser;
use Symfony\Component\HttpFoundation\File\File;
use Symfony\Component\HttpFoundation\RedirectResponse;
use Symfony\Component\HttpFoundation\Request;
use Symfony\Component\HttpFoundation\Response;
use Symfony\Component\HttpFoundation\Session\Flash\FlashBagInterface;
use Symfony\Component\HttpFoundation\Session\Session;
use Symfony\Component\Routing\RouterInterface;
use Symfony\Component\Security\Core\Authentication\Token\TokenInterface;
use Symfony\Component\Security\Core\Exception\AuthenticationException;
use Symfony\Component\Security\Core\User\UserInterface;
use Symfony\Component\Security\Core\User\UserProviderInterface;

class FacebookAuthenticator extends SocialAuthenticator
{
    private $clientRegistry;
    private $em;
    private $router;
    private $userManager;
    private $session;
    private $flashBag;

    public function __construct(ClientRegistry $clientRegistry,
                                EntityManagerInterface $em,
                                RouterInterface $router,
                                UserManagerInterface $userManager,
//                                Session $session,
                                FlashBagInterface $flashBag)
    {
        $this->clientRegistry = $clientRegistry;
        $this->em = $em;
        $this->router = $router;
        $this->userManager = $userManager;
//        $this->session = $session;
        $this->flashBag = $flashBag;
    }

    /**
     * Does the authenticator support the given Request?
     *
     * If this returns false, the authenticator will be skipped.
     *
     * @return bool
     */
    public function supports(Request $request)
    {
        return $request->attributes->get('_route') === 'connect_facebook_check';
    }

    /**
     * Get the authentication credentials from the request and return them
     * as any type (e.g. an associate array).
     *
     * Whatever value you return here will be passed to getUser() and checkCredentials()
     *
     * For example, for a form login, you might:
     *
     *      return [
     *          'username' => $request->request->get('_username'),
     *          'password' => $request->request->get('_password'),
     *      ];
     *
     * Or for an API token that's on a header, you might use:
     *
     *      return ['api_key' => $request->headers->get('X-API-TOKEN')];
     *
     * @return mixed Any non-null value
     *
     * @throws \UnexpectedValueException If null is returned
     */
    public function getCredentials(Request $request)
    {
        return $this->fetchAccessToken($this->getFacebookClient());
    }

    /**
     * Return a UserInterface object based on the credentials.
     *
     * The *credentials* are the return value from getCredentials()
     *
     * You may throw an AuthenticationException if you wish. If you return
     * null, then a UsernameNotFoundException is thrown for you.
     *
     * @param mixed $credentials
     *
     * @param UserProviderInterface $userProvider
     * @return UserInterface|null
     * @throws \Exception
     */
    public function getUser($credentials, UserProviderInterface $userProvider)
    {
        /**@var FacebookUser $facebookUser**/
        $facebookUser = $this->getFacebookClient()->fetchUserFromToken($credentials);

        $email = $facebookUser->getEmail();

        // 1) have they logged in with Facebook before? Easy!
        $existingUser = $this->em->getRepository(User::class)->findOneBy(['facebookId' => $facebookUser->getId()]);

        if ($existingUser){
            return $existingUser;
        }

        // 2) do we have a matching user by email?
        $user = $this->em->getRepository(User::class)->findOneBy(['email'=>$email]);

        if (!$user){
            $user = new User();
            $email = $facebookUser->getEmail();
            $firstname = $facebookUser->getFirstName();
            $lastname = $facebookUser->getLastName();

//            $username = null;
            if (!$email){
                return null;
            }
            $user->setFacebookId($facebookUser->getId());
            $user->setEmail($email);
            $user->setFirstName($firstname);
            $user->setLastName($lastname);
            $user->setJoinedOn(new \DateTime());
            $user->setUsername($email);
            $user->setPlainPassword(rand(100000,99999999));
            $user->setEnabled(true);

            //dd($facebookUser->getId());

            /*$dp = $facebookUser->getPictureUrl();
            $pic = new File($dp);
            $ext = $pic->guessExtension();
            $manager = new ImageManager(['driver' => 'gd']);
            $image = $manager->make($dp);
            $saveDir = "uploads/avatar";
            $avatarName = uniqid().".".$ext;
            $image->resize(200, null, function ($constraint){
                $constraint->aspectRatio();
            })->crop(200,200)->save($saveDir.DIRECTORY_SEPARATOR.$avatarName);
            $user->setAvatar($avatarName);*/
        }

        // 3) Maybe you just want to "register" them by creating
        // a User object

        /*$this->em->persist($user);
        $this->em->flush();*/
        $this->userManager->updateUser($user);

        return $userProvider->loadUserByUsername($user->getUsername());

//        return $user;
    }

    /**
     * Called when authentication executed, but failed (e.g. wrong username password).
     *
     * This should return the Response sent back to the user, like a
     * RedirectResponse to the login page or a 403 response.
     *
     * If you return null, the request will continue, but the user will
     * not be authenticated. This is probably not what you want to do.
     *
     * @return Response|null
     */
    public function onAuthenticationFailure(Request $request, AuthenticationException $exception)
    {
        $message = strtr($exception->getMessage(), $exception->getMessageData());

        $this->flashBag->add('notice', 'Registration could not be completed because your Facebook account has not been registered with an email address');

        return new RedirectResponse('/register');
    }

    /**
     * Called when authentication executed and was successful!
     *
     * This should return the Response sent back to the user, like a
     * RedirectResponse to the last page they visited.
     *
     * If you return null, the current request will continue, and the user
     * will be authenticated. This makes sense, for example, with an API.
     *
     * @param string $providerKey The provider (i.e. firewall) key
     *
     * @return Response|null
     */
    public function onAuthenticationSuccess(Request $request, TokenInterface $token, $providerKey)
    {
//        $targetUrl = $this->router->generate('dashboard');

        /**
         * @var User $user
         */
        $user = $token->getUser();
        if (count($user->getRoles()) > 1){
            $targetUrl = $this->router->generate('dashboard');
        }else{
            $user->setRoles([]);
            $this->em->persist($user);
            $this->em->flush();
            $targetUrl = $this->router->generate('fos_user_registration_confirmed');
        }

        return new RedirectResponse($targetUrl);
    }

    public function getFacebookClient(){
        return $this->clientRegistry->getClient('facebook_main');
    }

    /**
     * Called when authentication is needed, but it's not sent.
     * This redirects to the 'login'.
     * @param Request $request
     * @param AuthenticationException|null $authException
     * @return RedirectResponse
     */
    public function start(Request $request, AuthenticationException $authException = null)
    {
        $targetUrl = $this->router->generate('login');
        return new RedirectResponse(
            $targetUrl, // might be the site, where users choose their oauth provider
            Response::HTTP_TEMPORARY_REDIRECT
        );
    }


}