src/App/Controller/API/AuthController.php line 254

  1. <?php
  3. declare(strict_types=1);
  5. namespace App\Controller\API;
  7. use API\Exception\ValidationException;
  8. use App\DTO\APIRequest\AuthDTO;
  9. use App\DTO\Auth\AuthJWTResponse;
  10. use App\DTO\Auth\AuthUserRawData;
  11. use App\Entity\Users;
  12. use App\Security\EmailAuthenticator;
  13. use App\Security\FacebookSignedRequestAuthenticator;
  14. use App\Security\GoogleOAuth2Authenticator;
  15. use App\Service\User\UserLoginService;
  16. use App\Service\User\UsersManagementService;
  17. use Doctrine\ORM\EntityManagerInterface;
  18. use Exception;
  19. use KnpU\OAuth2ClientBundle\Client\ClientRegistry;
  20. use KnpU\OAuth2ClientBundle\Client\Provider\FacebookClient;
  21. use League\OAuth2\Client\Provider\Exception\IdentityProviderException;
  22. use League\OAuth2\Client\Token\AccessToken;
  23. use Lexik\Bundle\JWTAuthenticationBundle\Services\JWTTokenManagerInterface;
  24. use Symfony\Bundle\FrameworkBundle\Controller\AbstractController;
  25. use Symfony\Component\HttpFoundation\JsonResponse;
  26. use Symfony\Component\HttpFoundation\Request;
  27. use Symfony\Component\HttpFoundation\Response;
  28. use Symfony\Component\Routing\Attribute\Route;
  29. use Symfony\Component\Security\Core\Exception\AuthenticationException;
  31. #[Route(path: "/auth")]
  32. final class AuthController extends AbstractController
  33. {
  34.     public function __construct(
  35.         private readonly EntityManagerInterface $em,
  36.         private readonly UserLoginService $userLoginService
  37.     )
  38.     {
  39.     }
  41.     #[Route(path: "/facebook/verify", methods: ["GET"], name: "api.auth.facebook.check")]
  42.     public function getAuthFacebookCheck(
  43.         Request $request,
  44.         ClientRegistry $clientRegistry,
  45.         JWTTokenManagerInterface $jwt,
  46.         UsersManagementService $usersManagementService,
  47.         EntityManagerInterface $em,
  48.     ) {
  49.         $accessToken = $request->get('access_token');
  51.         /** @var FacebookClient $client */
  52.         $client = $clientRegistry->getClient('facebook_main');
  54.         try {
  55.             $t = new AccessToken(
  56.                 [
  57.                     'access_token' => $accessToken,
  58.                 ]
  59.             );
  61.             $facebookUser = $client->fetchUserFromToken($t);
  62.         } catch (IdentityProviderException $e) {
  63.             return $this->json(
  64.                 new AuthJWTResponse(
  65.                     AuthJWTResponse::STATUS_ERROR,
  66.                     null,
  67.                     $e->getMessage()
  68.                 ),
  69.                 Response::HTTP_FORBIDDEN
  70.             );
  71.         }
  73.         /** @var Users $user */
  74.         $user = $this
  75.             ->em
  76.             ->getRepository(Users::class)
  77.             ->findByFacebook($facebookUser->getId());
  78.         if (!$user) {
  79.             $authUserRawData = (new AuthUserRawData())
  80.                 ->setIdentity($facebookUser->getId())
  81.                 ->setFirstName($facebookUser->getFirstName())
  82.                 ->setLastName($facebookUser->getLastName())
  83.                 ->setAvatar($facebookUser->getPictureUrl())
  84.                 ->setLanguage($request->getLocale());
  86.             $user = $usersManagementService->createUser(Users::AUTH_FB, $authUserRawData, $this->getUser());
  87.         } else {
  88.             try {
  89.                 $avatar = $facebookUser->getPictureUrl();
  90.                 if (!empty($avatar)) {
  91.                     $user->getUserData()->setPicture($avatar);
  92.                     $em->flush();
  93.                 }
  94.             } catch (\Throwable $e) {
  95.             }
  96.         }
  98.         $token = $jwt->create($user);
  100.         return $this->json(
  101.             new AuthJWTResponse(
  102.                 AuthJWTResponse::STATUS_SUCCESS,
  103.                 $token
  104.             )
  105.         );
  106.     }
  108.     #[Route(path: "/apple/verify", methods: ["GET"], name: "api.auth.apple.check")]
  109.     public function getAuthAppleCheck(
  110.         Request $request,
  111.         ClientRegistry $clientRegistry,
  112.         JWTTokenManagerInterface $jwt,
  113.         UsersManagementService $usersManagementService
  114.     ) {
  115.         $accessToken = $request->get('access_token');
  116.         $code = $request->get('code');
  117.         $firstName = (string)$request->get('first_name');
  118.         $lastName = (string)$request->get('last_name');
  120.         try {
  121.             $appleUser = $usersManagementService->decodeAppleAccessToken($accessToken);
  122.         } catch (Exception $e) {
  123.             return $this->json(
  124.                 new AuthJWTResponse(
  125.                     AuthJWTResponse::STATUS_ERROR,
  126.                     null,
  127.                     $e->getMessage()
  128.                 ),
  129.                 Response::HTTP_FORBIDDEN
  130.             );
  131.         }
  133.         /** @var Users $user */
  134.         $user = $this
  135.             ->em
  136.             ->getRepository(Users::class)
  137.             ->findByApple($appleUser['id']);
  138.         if (!$user) {
  139.             $authUserRawData = (new AuthUserRawData())
  140.                 ->setIdentity($appleUser['id'])
  141.                 ->setEmail($appleUser['email'])
  142.                 ->setFirstName($firstName)
  143.                 ->setLastName($lastName);
  145.             $user = $usersManagementService->createUser(Users::AUTH_APPLE, $authUserRawData, $this->getUser());
  146.         }
  148.         $token = $jwt->create($user);
  150.         return $this->json(
  151.             new AuthJWTResponse(
  152.                 AuthJWTResponse::STATUS_SUCCESS,
  153.                 $token
  154.             )
  155.         );
  156.     }
  158.     #[Route(path: "/google/verify", methods: ["GET"], name: "api.auth.google.check")]
  159.     public function getAuthGoogleCheck(
  160.         Request $request,
  161.         ClientRegistry $clientRegistry,
  162.         JWTTokenManagerInterface $jwt,
  163.         UsersManagementService $usersManagementService
  164.     ) {
  165.         $accessToken = $request->get('access_token');
  167.         try {
  168.             $googleUser = $usersManagementService->decodeGoogleAccessToken($accessToken);
  169.         } catch (Exception $e) {
  170.             return $this->json(
  171.                 new AuthJWTResponse(
  172.                     AuthJWTResponse::STATUS_ERROR,
  173.                     null,
  174.                     $e->getMessage()
  175.                 ),
  176.                 Response::HTTP_FORBIDDEN
  177.             );
  178.         }
  180.         // $identity $googleUser['id']
  181.         $identity = $googleUser['email'];
  183.         /** @var Users $user */
  184.         $user = $this
  185.             ->em
  186.             ->getRepository(Users::class)
  187.             ->findByGoogle($identity);
  188.         if (!$user) {
  189.             $authUserRawData = (new AuthUserRawData())
  190.                 ->setIdentity($identity)
  191.                 ->setEmail($googleUser['email'])
  192.                 ->setFirstName($googleUser['first_name'])
  193.                 ->setLastName($googleUser['last_name'])
  194.                 ->setAvatar($googleUser['picture'])
  195.                 ->setLanguage($googleUser['locale']);
  197.             $user = $usersManagementService->createUser(Users::AUTH_GOOGLE, $authUserRawData, $this->getUser());
  198.         }
  200.         $token = $jwt->create($user);
  202.         return $this->json(
  203.             new AuthJWTResponse(
  204.                 AuthJWTResponse::STATUS_SUCCESS,
  205.                 $token
  206.             )
  207.         );
  208.     }
  210.     #[Route(path: "/huawei/verify", methods: ["GET"])]
  211.     public function getAuthHuaweiCheck(
  212.         Request $request,
  213.         ClientRegistry $clientRegistry,
  214.         JWTTokenManagerInterface $jwt,
  215.         UsersManagementService $usersManagementService
  216.     ) {
  217.         $accessToken = $request->get('access_token');
  219.         try {
  220.             $huaweiUser = $usersManagementService->decodeHuaweiAccessToken($accessToken);
  221.         } catch (Exception $e) {
  222.             return $this->json(
  223.                 new AuthJWTResponse(
  224.                     AuthJWTResponse::STATUS_ERROR,
  225.                     null,
  226.                     $e->getMessage()
  227.                 ),
  228.                 Response::HTTP_FORBIDDEN
  229.             );
  230.         }
  232.         // $identity $googleUser['id']
  233.         $identity = $huaweiUser['id'];
  235.         /** @var Users $user */
  236.         $user = $this
  237.             ->em
  238.             ->getRepository(Users::class)
  239.             ->findByHuawei($identity);
  240.         if (!$user) {
  241.             $authUserRawData = (new AuthUserRawData())
  242.                 ->setIdentity($identity)
  243.                 ->setEmail($huaweiUser['id']."@huawei.com")
  244.                 ->setFirstName($huaweiUser['first_name'])
  245.                 ->setLastName($huaweiUser['last_name'])
  246.                 ->setLanguage($huaweiUser['locale']);
  248.             $user = $usersManagementService->createUser(Users::AUTH_HUAWEI, $authUserRawData, $this->getUser());
  249.         }
  251.         $token = $jwt->create($user);
  253.         return $this->json(
  254.             new AuthJWTResponse(
  255.                 AuthJWTResponse::STATUS_SUCCESS,
  256.                 $token
  257.             )
  258.         );
  259.     }
  261.     #[Route(path: "/guest", methods: ["GET"])]
  262.     public function getAuthGuest(
  263.         Request $request,
  264.         JWTTokenManagerInterface $jwt,
  265.         UsersManagementService $usersManagementService
  266.     ): JsonResponse {
  267.         $deviceIdentity = $request->get('device_identity');
  269.         if ($deviceIdentity) {
  270.             $user = $usersManagementService->findOrCreateGuestUserByDeviceIdentity($deviceIdentity);
  271.         } else {
  272.             $user = $usersManagementService->createGuestUser();
  273.         }
  275.         $token = $jwt->create($user);
  277.         return $this->json(
  278.             new AuthJWTResponse(
  279.                 AuthJWTResponse::STATUS_SUCCESS,
  280.                 $token
  281.             )
  282.         );
  283.     }
  285.     #[Route(path: "", methods: ["POST"])]
  286.     public function auth(
  287.         AuthDTO $requestDTO,
  288.         Request $request,
  289.         JWTTokenManagerInterface $jwt,
  290.         GoogleOAuth2Authenticator $googleOAuth2Authenticator,
  291.         FacebookSignedRequestAuthenticator $facebookAuthenticator,
  292.         EmailAuthenticator $emailAuthenticator
  293.     ): AuthJWTResponse
  294.     {
  295.         $request->request->set('type', $requestDTO->type);
  296.         $request->request->set('token', $requestDTO->token);
  297.         $request->request->set('email', $requestDTO->email);
  298.         $request->request->set('password', $requestDTO->password);
  300.         try {
  301.             $passport = match ($requestDTO->type) {
  302.                 'email' => $emailAuthenticator->authenticate($request),
  303.                 'google' => $googleOAuth2Authenticator->authenticate($request),
  304.                 'facebook' => $facebookAuthenticator->authenticate($request),
  305.                 default => throw new AuthenticationException('Invalid type')
  306.             };
  307.         } catch (AuthenticationException $e) {
  308.             match ($requestDTO->type) {
  309.                 'email' => throw ValidationException::violation('Invalid email or password', $requestDTO->email, 'email'),
  310.                 default =>throw ValidationException::violation('Invalid credentials', $requestDTO->token, 'token')
  311.             };
  312.         }
  314.         $user = $passport->getUser();
  315.         if (!$user instanceof Users) {
  316.             throw $this->createAccessDeniedException();
  317.         }
  319.         $token = $jwt->create($user);
  320.         $this->userLoginService->callLoginRoutines($user, $request);
  322.         return new AuthJWTResponse(
  323.             AuthJWTResponse::STATUS_SUCCESS,
  324.             $token
  325.         );
  326.     }
  327. }