src/Api/Authentication/Authenticator.php line 26

Open in your IDE?
  1. <?php
  2. /**
  3.  * Created by PhpStorm.
  4.  * User: samuelp
  5.  * Date: 1/21/18
  6.  * Time: 2:10 PM
  7.  */
  9. namespace App\Api\Authentication;
  12. use App\Entity\User;
  13. use Doctrine\ORM\EntityManagerInterface;
  14. use Lexik\Bundle\JWTAuthenticationBundle\Encoder\JWTEncoderInterface;
  15. use Lexik\Bundle\JWTAuthenticationBundle\TokenExtractor\AuthorizationHeaderTokenExtractor;
  16. use Symfony\Component\HttpFoundation\JsonResponse;
  17. use Symfony\Component\HttpFoundation\Request;
  18. use Symfony\Component\HttpFoundation\Response;
  19. use Symfony\Component\Security\Core\Authentication\Token\TokenInterface;
  20. use Symfony\Component\Security\Core\Exception\AuthenticationException;
  21. use Symfony\Component\Security\Core\Exception\CustomUserMessageAuthenticationException;
  22. use Symfony\Component\Security\Core\User\UserInterface;
  23. use Symfony\Component\Security\Core\User\UserProviderInterface;
  24. use Symfony\Component\Security\Guard\AbstractGuardAuthenticator;
  26. class Authenticator extends AbstractGuardAuthenticator {
  30.     /**
  31.      * @var JWTEncoderInterface
  32.      */
  33.     private $JWTEncoder;
  35.     /**
  36.      * @var EntityManagerInterface
  37.      */
  38.     private $entityManager;
  40.     public function __construct(JWTEncoderInterface $JWTEncoder, EntityManagerInterface $entityManager) {
  42.         $this->JWTEncoder = $JWTEncoder;
  43.         $this->entityManager = $entityManager;
  44.     }
  49.     /**
  50.      * Get the authentication credentials from the request and return them
  51.      * as any type (e.g. an associate array).
  52.      *
  53.      * Whatever value you return here will be passed to getUser() and checkCredentials()
  54.      *
  55.      * For example, for a form login, you might:
  56.      *
  57.      *      return array(
  58.      *          'username' => $request->request->get('_username'),
  59.      *          'password' => $request->request->get('_password'),
  60.      *      );
  61.      *
  62.      * Or for an API token that's on a header, you might use:
  63.      *
  64.      *      return array('api_key' => $request->headers->get('X-API-TOKEN'));
  65.      *
  66.      * @param Request $request
  67.      *
  68.      * @return mixed Any non-null value
  69.      *
  70.      * @throws \UnexpectedValueException If null is returned
  71.      */
  72.     public function getCredentials(Request $request) {
  73. //        dump($request);die;
  74.        $extractor = new AuthorizationHeaderTokenExtractor(
  75.            'Bearer', 'Auth'
  76.        );
  77.        $token = $extractor->extract($request);
  78.        if(!$token){
  79.            return ;
  80.        }
  82.        return $token;
  83.     }
  85.     /**
  86.      * Return a UserInterface object based on the credentials.
  87.      *
  88.      * The *credentials* are the return value from getCredentials()
  89.      *
  90.      * You may throw an AuthenticationException if you wish. If you return
  91.      * null, then a UsernameNotFoundException is thrown for you.
  92.      *
  93.      * @param mixed $credentials
  94.      * @param UserProviderInterface $userProvider
  95.      *
  96.      * @throws AuthenticationException
  97.      *
  98.      * @return UserInterface|null
  99.      */
  100.     public function getUser($credentials, UserProviderInterface $userProvider) {
  101.         $data = null;
  103.         try {
  104.             $data = $this->JWTEncoder->decode($credentials);
  105.         } catch (\Exception $e) {
  106.             throw new \Symfony\Component\Security\Core\Exception\BadCredentialsException($e->getMessage(), 0, $e);
  107.         }
  110.         if($data === false){
  111.             /*$response = [
  112.                 'message' => "Invalid Token"
  113.             ];*/
  115.             throw new CustomUserMessageAuthenticationException("Invalid Token");
  116.         }
  117.         $id = $data['user_id'];
  119.         return $this->entityManager->getRepository(User::class)->findOneBy([
  120.             'id' => $id
  121.         ]);
  122.     }
  124.     /**
  125.      * Returns true if the credentials are valid.
  126.      *
  127.      * If any value other than true is returned, authentication will
  128.      * fail. You may also throw an AuthenticationException if you wish
  129.      * to cause authentication to fail.
  130.      *
  131.      * The *credentials* are the return value from getCredentials()
  132.      *
  133.      * @param mixed $credentials
  134.      * @param UserInterface $user
  135.      *
  136.      * @return bool
  137.      *
  138.      * @throws AuthenticationException
  139.      */
  140.     public function checkCredentials($credentials, UserInterface $user) {
  141.         // TODO: Implement checkCredentials() method.
  143.         return true;
  144.     }
  146.     /**
  147.      * Called when authentication executed, but failed (e.g. wrong username password).
  148.      *
  149.      * This should return the Response sent back to the user, like a
  150.      * RedirectResponse to the login page or a 403 response.
  151.      *
  152.      * If you return null, the request will continue, but the user will
  153.      * not be authenticated. This is probably not what you want to do.
  154.      *
  155.      * @param Request $request
  156.      * @param AuthenticationException $exception
  157.      *
  158.      * @return Response|null
  159.      */
  160.     public function onAuthenticationFailure(Request $request, AuthenticationException $exception) {
  161.         // TODO: Implement onAuthenticationFailure() method.
  165.        /* $response = new JsonResponse([
  166.                 'error' => [
  167.                 'message' => $exception->getMessage()
  168.             ]
  169.         ],Response::HTTP_UNAUTHORIZED );*/
  171.         
  172.         $response = new JsonResponse([
  173.                 'error' => $exception->getMessage().': Please login again'
  174.         ],Response::HTTP_UNAUTHORIZED );
  176.         return $response;
  178.     }
  180.     /**
  181.      * Called when authentication executed and was successful!
  182.      *
  183.      * This should return the Response sent back to the user, like a
  184.      * RedirectResponse to the last page they visited.
  185.      *
  186.      * If you return null, the current request will continue, and the user
  187.      * will be authenticated. This makes sense, for example, with an API.
  188.      *
  189.      * @param Request $request
  190.      * @param TokenInterface $token
  191.      * @param string $providerKey The provider (i.e. firewall) key
  192.      *
  193.      * @return Response|null
  194.      */
  195.     public function onAuthenticationSuccess(Request $request, TokenInterface $token, $providerKey) {
  196.         // TODO: Implement onAuthenticationSuccess() method.
  197.         return;
  198.     }
  200.     /**
  201.      * Does this method support remember me cookies?
  202.      *
  203.      * Remember me cookie will be set if *all* of the following are met:
  204.      *  A) This method returns true
  205.      *  B) The remember_me key under your firewall is configured
  206.      *  C) The "remember me" functionality is activated. This is usually
  207.      *      done by having a _remember_me checkbox in your form, but
  208.      *      can be configured by the "always_remember_me" and "remember_me_parameter"
  209.      *      parameters under the "remember_me" firewall key
  210.      *  D) The onAuthenticationSuccess method returns a Response object
  211.      *
  212.      * @return bool
  213.      */
  214.     public function supportsRememberMe() {
  215.         // TODO: Implement supportsRememberMe() method.
  216.         return false;
  217.     }
  221.     /**
  222.      * Returns a response that directs the user to authenticate.
  223.      *
  224.      * This is called when an anonymous request accesses a resource that
  225.      * requires authentication. The job of this method is to return some
  226.      * response that "helps" the user start into the authentication process.
  227.      *
  228.      * Examples:
  229.      *  A) For a form login, you might redirect to the login page
  230.      *      return new RedirectResponse('/login');
  231.      *  B) For an API token authentication system, you return a 401 response
  232.      *      return new Response('Auth header required', 401);
  233.      *
  234.      * @param Request $request The request that resulted in an AuthenticationException
  235.      * @param AuthenticationException $authException The exception that started the authentication process
  236.      *
  237.      * @return Response
  238.      */
  239.     public function start(Request $request, AuthenticationException $authException = null) {
  240.         return new JsonResponse([
  241.             'error' => [
  242.                 'message' => 'auth required'
  243.             ]
  244.         ], Response::HTTP_UNAUTHORIZED);
  245.     }
  247.     public function supports(Request $request): bool
  248.     {
  249.         // TODO: Implement supports() method.
  250.         if($request->headers->get('Auth')){
  251.             return true;
  252.         }
  254.         return false;
  255.     }
  256. }