How to use jwt Authorization Bearer with rest-client-sdk-bundle ? #8

Activity

1. jdeniau

   added

   question

   on Feb 21, 2017
2. jdeniau commented on Feb 21, 2017

   

   jdeniau

   on Feb 21, 2017

   Last edited by jdeniau

   Member

   More actions

   The solution we use for now at Mapado is the following:

   We have another service that decorates mapado.rest_client_sdk.foo_http_client 👍

           <service id="mapado.rest_client_sdk.decorating_ticketing"                                                                                       
               class="Foo\Bar\DecoratingClient"                                                                               
               decorates="mapado.rest_client_sdk.foo_http_client"                                                                                    
               public="true"                                                                    
           >                                                                                                                                               
               <argument type="service" id="some_service" />                                                                                            
           </service>  

   The decorating client looks like this:

   <?php                                                                                                                                                   
                                                                                                                                                           
   namespace Foo\Bar\Decorator;                                                                                                         
                                                                                                                                                                                                       
   use GuzzleHttp\Client;                                                                                                     
   use GuzzleHttp\Exception\TransferException;                                                                                                             
   use Psr\Http\Message\RequestInterface;                                                                                                                                                       
   use Symfony\Component\HttpFoundation\Response;                                                                                                          
                                                                                                                                                           
   /**                                                                                                                                                     
    * DecoratoratingClient                                                                                                                                 
    */                                                                                                                                                     
   class DecoratingClient implements \GuzzleHttp\ClientInterface                                                                                           
   {                                                                                                                                                       
       /**                                                                                                                                                 
        * decorated client                                                                                                                                 
        *                                                                                                                                                  
        * @var Client                                                                                                                                      
        * @access private                                                                                                                                  
        */                                                                                                                                                 
       private $client;                                                                                                                                    
               
       /**
        * some service
        *
        * @var object
        * @access private
        */
       private $someService;
   
       /** 
        * is token already regenerated
        * @var bool
        * @access private
        */
       private $tokenRegenerated
   
       /**
        * __construct
        *
        * @param Client $client
        * @param object $someService
        * @access public
        */
       public function __construct(Client $client, object $someService) 
       {
           $this->client = $client;
           $this->someService = $someService;
       }
   
       /**
        * {@inheritdoc}
        */
       public function send(RequestInterface $request, array $options = [])
       {
           return $this->client->send($request, $options);
       }
   
       /**
        * {@inheritdoc}
        */
       public function sendAsync(RequestInterface $request, array $options = [])
       {
           return $this->client->sendAsync($request, $options);
       }
   
       /**
        * {@inheritdoc}
        */
       public function request($method, $uri, array $options = [])
       {
           $token = $this->someService->getTheJwtToken();
   
           $options['headers'] = array_merge($options['headers'], ['Authorization' => 'Bearer ' . $token]);
   
           try {
               return $this->client->request($method, $uri, $options);
           } catch (TransferException $e) {
               // regenerate token on 401 errors
               if (!$this->tokenRegenerated) {
                   $this->tokenRegenerated = true;
                   if ($e->getResponse()->getStatusCode() == Response::HTTP_UNAUTHORIZED) {
                       $token = $this->someService->regenerateToken();
                       $options['headers'] = array_merge(
                           $options['headers'],
                           [ 'Authorization' => 'Bearer ' . $token ]
                       );
   
                       // resend the same request
                       return $this->client->request($method, $uri, $options);
                   }
               }
   
               throw $e;
           }
       }
   
       /**
        * {@inheritdoc}
        */
       public function requestAsync($method, $uri, array $options = [])
       {
           return $this->client->requestAsync($method, $uri, $options);
       }
   
       public function getConfig($option = null)
       {
           return $this->client->getConfig($option);
       }
   }

   This way, you inject your token on every request you make.

   As I'm writing it, I think this is not a very optimal way of doing it but it works. We may provide a setHeaders function on the SDK to provide some default headers.

   👍React with 👍1Reacted by hvalcourtSerdy
3. jdeniau

   added

   enhancement

   on Feb 21, 2017
4. hvalcourtSerdy commented on Feb 21, 2017

   

   hvalcourtSerdy

   on Feb 21, 2017

   Author

   More actions

   Thanks, I will try this method to deliver in my sprint.

   After the sprint, maybe I can help with the setHeaders if you need ?

   Merci encore
5. jdeniau commented on Feb 21, 2017

   

   jdeniau

   on Feb 21, 2017

   Member

   More actions

   Would love to ! Thanks