src/Security/GoogleAuthenticator.php line 21

  1. <?php
  2. # src/Security/GoogleAuthenticator.php
  3. namespace App\Security;
  5. use App\Entity\User;
  6. use App\IlaveU\ShopBundle\Entity\Customer\Customer;
  7. use League\OAuth2\Client\Provider\GoogleUser;
  8. use Doctrine\ORM\EntityManagerInterface;
  9. use KnpU\OAuth2ClientBundle\Client\ClientRegistry;
  10. use KnpU\OAuth2ClientBundle\Security\Authenticator\OAuth2Authenticator;
  11. use Symfony\Component\HttpFoundation\RedirectResponse;
  12. use Symfony\Component\HttpFoundation\Request;
  13. use Symfony\Component\HttpFoundation\Response;
  14. use Symfony\Component\Routing\RouterInterface;
  15. use Symfony\Component\Security\Core\Authentication\Token\TokenInterface;
  16. use Symfony\Component\Security\Core\Exception\AuthenticationException;
  17. use Symfony\Component\Security\Http\Authenticator\Passport\Badge\UserBadge;
  18. use Symfony\Component\Security\Http\Authenticator\Passport\Passport;
  19. use Symfony\Component\Security\Http\Authenticator\Passport\SelfValidatingPassport;
  21. class GoogleAuthenticator extends OAuth2Authenticator
  22. {
  23.     private ClientRegistry $clientRegistry;
  24.     private EntityManagerInterface $entityManager;
  25.     private RouterInterface $router;
  27.     public function __construct(
  28.         ClientRegistry $clientRegistry,
  29.         EntityManagerInterface $entityManager,
  30.         RouterInterface $router
  31.     ) {
  32.         $this->clientRegistry = $clientRegistry;
  33.         $this->entityManager = $entityManager;
  34.         $this->router = $router;
  35.     }
  37.     public function supports(Request $request): ?bool
  38.     {
  39.         // continue ONLY if the current ROUTE matches the check ROUTE
  40.         return $request->attributes->get('_route') === 'connect_google_check';
  41.     }
  43.     public function authenticate(Request $request): Passport
  44.     {
  45.         $client = $this->clientRegistry->getClient('google');
  46.         $accessToken = $this->fetchAccessToken($client);
  48.         return new SelfValidatingPassport(
  49.             new UserBadge($accessToken->getToken(), function () use (
  50.                 $accessToken,
  51.                 $client
  52.             ) {
  53.                 /** @var GoogleUser $googleUser */
  54.                 $googleUser = $client->fetchUserFromToken($accessToken);
  56.                 $email = $googleUser->getEmail();
  58.                 // have they logged in with Google before? Easy!
  59.                 $existingUser = $this->entityManager
  60.                     ->getRepository(User::class)
  61.                     ->findOneBy(['googleId' => $googleUser->getId()]);
  63.                 //User doesnt exist, we create it !
  64.                 if (!$existingUser) {
  65.                     $existingUserPerMail = $this->entityManager
  66.                         ->getRepository(User::class)
  67.                         ->findOneBy(['username' => $email]);
  68.                     if ($existingUserPerMail) {
  69.                         $existingUser = $existingUserPerMail;
  70.                     } else {
  71.                         $existingUser = new User();
  72.                         $existingUser->setUsername($email);
  73.                         $existingUser->setPassword($googleUser->getId());
  74.                         $existingUser->setRoles(["ROLE_CUSTOMER"]);
  75.                     }
  77.                     $existingUser->setGoogleId($googleUser->getId());
  79.                     //Customer
  81.                     //$existingUser->setHostedDomain($googleUser->getHostedDomain());
  82.                 }
  83.                 $existingCustomer = $this->entityManager
  84.                     ->getRepository(Customer::class)
  85.                     ->findOneBy(['user' => $existingUser]);
  87.                 if (!$existingCustomer or !$existingCustomer->getUser()) {
  88.                     $existingCustomerPerEmail = $this->entityManager
  89.                     ->getRepository(Customer::class)
  90.                     ->findOneBy(['email' => $email]);
  91.                     if(!$existingCustomerPerEmail){
  92.                         $existingCustomer = new Customer();
  93.                         $existingCustomer->setEmail($googleUser->getEmail());
  94.                         $existingCustomer->setPhone('060000000000');
  95.                         $existingCustomer->setAddress('');
  96.                     }else{
  97.                         $existingCustomer = $existingCustomerPerEmail;
  98.                     }
  99.                     
  100.                 }
  102.                 $existingCustomer->setFirstName($googleUser->getFirstName() ?? "--");
  103.                 $existingCustomer->setLastName($googleUser->getLastName() ?? "--");
  105.                 $existingCustomer->setUser($existingUser);
  106.                 $existingUser->setAvatar($googleUser->getAvatar());
  107.                 $this->entityManager->persist($existingCustomer);
  109.                 $this->entityManager->persist($existingUser);
  110.                 $this->entityManager->flush();
  112.                 return $existingUser;
  113.             })
  114.         );
  115.     }
  117.     public function onAuthenticationSuccess(
  118.         Request $request,
  119.         TokenInterface $token,
  120.         string $firewallName
  121.     ): ?Response {
  122.         // change "app_dashboard" to some route in your app
  123.         return new RedirectResponse(
  124.             $this->router->generate('connect_google_after_connexion')."?googleId=123"
  125.         );
  127.         // or, on success, let the request continue to be handled by the controller
  128.         //return null;
  129.     }
  131.     public function onAuthenticationFailure(
  132.         Request $request,
  133.         AuthenticationException $exception
  134.     ): ?Response {
  135.         $message = strtr(
  136.             $exception->getMessageKey(),
  137.             $exception->getMessageData()
  138.         );
  140.         return new Response($message, Response::HTTP_FORBIDDEN);
  141.     }
  143.     //    public function start(Request $request, AuthenticationException $authException = null): Response
  144.     //    {
  145.     //        /*
  146.     //         * If you would like this class to control what happens when an anonymous user accesses a
  147.     //         * protected page (e.g. redirect to /login), uncomment this method and make this class
  148.     //         * implement Symfony\Component\Security\Http\EntryPoint\AuthenticationEntryPointInterface.
  149.     //         *
  150.     //         * For more details, see https://symfony.com/doc/current/security/experimental_authenticators.html#configuring-the-authentication-entry-point
  151.     //         */
  152.     //    }
  153. }