1 <?php
  2 /**
  3  * @package     Joomla.Platform
  4  * @subpackage  OAuth2
  5  *
  6  * @copyright   Copyright (C) 2005 - 2017 Open Source Matters, Inc. All rights reserved
  7  * @license     GNU General Public License version 2 or later; see LICENSE
  8  */
  9 
 10 defined('JPATH_PLATFORM') or die;
 11 
 12 use Joomla\Registry\Registry;
 13 
 14 /**
 15  * Joomla Platform class for interacting with an OAuth 2.0 server.
 16  *
 17  * @since       12.3
 18  * @deprecated  4.0  Use the `joomla/oauth2` framework package that will be bundled instead
 19  */
 20 class JOAuth2Client
 21 {
 22     /**
 23      * @var    Registry  Options for the JOAuth2Client object.
 24      * @since  12.3
 25      */
 26     protected $options;
 27 
 28     /**
 29      * @var    JHttp  The HTTP client object to use in sending HTTP requests.
 30      * @since  12.3
 31      */
 32     protected $http;
 33 
 34     /**
 35      * @var    JInput  The input object to use in retrieving GET/POST data.
 36      * @since  12.3
 37      */
 38     protected $input;
 39 
 40     /**
 41      * @var    JApplicationWeb  The application object to send HTTP headers for redirects.
 42      * @since  12.3
 43      */
 44     protected $application;
 45 
 46     /**
 47      * Constructor.
 48      *
 49      * @param   Registry         $options      JOAuth2Client options object
 50      * @param   JHttp            $http         The HTTP client object
 51      * @param   JInput           $input        The input object
 52      * @param   JApplicationWeb  $application  The application object
 53      *
 54      * @since   12.3
 55      */
 56     public function __construct(Registry $options = null, JHttp $http = null, JInput $input = null, JApplicationWeb $application = null)
 57     {
 58         $this->options = isset($options) ? $options : new Registry;
 59         $this->http = isset($http) ? $http : new JHttp($this->options);
 60         $this->application = isset($application) ? $application : new JApplicationWeb;
 61         $this->input = isset($input) ? $input : $this->application->input;
 62     }
 63 
 64     /**
 65      * Get the access token or redict to the authentication URL.
 66      *
 67      * @return  string  The access token
 68      *
 69      * @since   12.3
 70      * @throws  RuntimeException
 71      */
 72     public function authenticate()
 73     {
 74         if ($data['code'] = $this->input->get('code', false, 'raw'))
 75         {
 76             $data['grant_type'] = 'authorization_code';
 77             $data['redirect_uri'] = $this->getOption('redirecturi');
 78             $data['client_id'] = $this->getOption('clientid');
 79             $data['client_secret'] = $this->getOption('clientsecret');
 80             $response = $this->http->post($this->getOption('tokenurl'), $data);
 81 
 82             if ($response->code >= 200 && $response->code < 400)
 83             {
 84                 if (strpos($response->headers['Content-Type'], 'application/json') === 0)
 85                 {
 86                     $token = array_merge(json_decode($response->body, true), array('created' => time()));
 87                 }
 88                 else
 89                 {
 90                     parse_str($response->body, $token);
 91                     $token = array_merge($token, array('created' => time()));
 92                 }
 93 
 94                 $this->setToken($token);
 95 
 96                 return $token;
 97             }
 98             else
 99             {
100                 throw new RuntimeException('Error code ' . $response->code . ' received requesting access token: ' . $response->body . '.');
101             }
102         }
103 
104         if ($this->getOption('sendheaders'))
105         {
106             $this->application->redirect($this->createUrl());
107         }
108 
109         return false;
110     }
111 
112     /**
113      * Verify if the client has been authenticated
114      *
115      * @return  boolean  Is authenticated
116      *
117      * @since   12.3
118      */
119     public function isAuthenticated()
120     {
121         $token = $this->getToken();
122 
123         if (!$token || !array_key_exists('access_token', $token))
124         {
125             return false;
126         }
127         elseif (array_key_exists('expires_in', $token) && $token['created'] + $token['expires_in'] < time() + 20)
128         {
129             return false;
130         }
131         else
132         {
133             return true;
134         }
135     }
136 
137     /**
138      * Create the URL for authentication.
139      *
140      * @return  JHttpResponse  The HTTP response
141      *
142      * @since   12.3
143      * @throws  InvalidArgumentException
144      */
145     public function createUrl()
146     {
147         if (!$this->getOption('authurl') || !$this->getOption('clientid'))
148         {
149             throw new InvalidArgumentException('Authorization URL and client_id are required');
150         }
151 
152         $url = $this->getOption('authurl');
153 
154         if (strpos($url, '?'))
155         {
156             $url .= '&';
157         }
158         else
159         {
160             $url .= '?';
161         }
162 
163         $url .= 'response_type=code';
164         $url .= '&client_id=' . urlencode($this->getOption('clientid'));
165 
166         if ($this->getOption('redirecturi'))
167         {
168             $url .= '&redirect_uri=' . urlencode($this->getOption('redirecturi'));
169         }
170 
171         if ($this->getOption('scope'))
172         {
173             $scope = is_array($this->getOption('scope')) ? implode(' ', $this->getOption('scope')) : $this->getOption('scope');
174             $url .= '&scope=' . urlencode($scope);
175         }
176 
177         if ($this->getOption('state'))
178         {
179             $url .= '&state=' . urlencode($this->getOption('state'));
180         }
181 
182         if (is_array($this->getOption('requestparams')))
183         {
184             foreach ($this->getOption('requestparams') as $key => $value)
185             {
186                 $url .= '&' . $key . '=' . urlencode($value);
187             }
188         }
189 
190         return $url;
191     }
192 
193     /**
194      * Send a signed Oauth request.
195      *
196      * @param   string  $url      The URL for the request.
197      * @param   mixed   $data     The data to include in the request
198      * @param   array   $headers  The headers to send with the request
199      * @param   string  $method   The method with which to send the request
200      * @param   int     $timeout  The timeout for the request
201      *
202      * @return  string  The URL.
203      *
204      * @since   12.3
205      * @throws  InvalidArgumentException
206      * @throws  RuntimeException
207      */
208     public function query($url, $data = null, $headers = array(), $method = 'get', $timeout = null)
209     {
210         $token = $this->getToken();
211 
212         if (array_key_exists('expires_in', $token) && $token['created'] + $token['expires_in'] < time() + 20)
213         {
214             if (!$this->getOption('userefresh'))
215             {
216                 return false;
217             }
218 
219             $token = $this->refreshToken($token['refresh_token']);
220         }
221 
222         if (!$this->getOption('authmethod') || $this->getOption('authmethod') == 'bearer')
223         {
224             $headers['Authorization'] = 'Bearer ' . $token['access_token'];
225         }
226         elseif ($this->getOption('authmethod') == 'get')
227         {
228             if (strpos($url, '?'))
229             {
230                 $url .= '&';
231             }
232             else
233             {
234                 $url .= '?';
235             }
236 
237             $url .= $this->getOption('getparam') ? $this->getOption('getparam') : 'access_token';
238             $url .= '=' . $token['access_token'];
239         }
240 
241         switch ($method)
242         {
243             case 'head':
244             case 'get':
245             case 'delete':
246             case 'trace':
247             $response = $this->http->$method($url, $headers, $timeout);
248             break;
249             case 'post':
250             case 'put':
251             case 'patch':
252             $response = $this->http->$method($url, $data, $headers, $timeout);
253             break;
254             default:
255             throw new InvalidArgumentException('Unknown HTTP request method: ' . $method . '.');
256         }
257 
258         if ($response->code < 200 || $response->code >= 400)
259         {
260             throw new RuntimeException('Error code ' . $response->code . ' received requesting data: ' . $response->body . '.');
261         }
262 
263         return $response;
264     }
265 
266     /**
267      * Get an option from the JOAuth2Client instance.
268      *
269      * @param   string  $key  The name of the option to get
270      *
271      * @return  mixed  The option value
272      *
273      * @since   12.3
274      */
275     public function getOption($key)
276     {
277         return $this->options->get($key);
278     }
279 
280     /**
281      * Set an option for the JOAuth2Client instance.
282      *
283      * @param   string  $key    The name of the option to set
284      * @param   mixed   $value  The option value to set
285      *
286      * @return  JOAuth2Client  This object for method chaining
287      *
288      * @since   12.3
289      */
290     public function setOption($key, $value)
291     {
292         $this->options->set($key, $value);
293 
294         return $this;
295     }
296 
297     /**
298      * Get the access token from the JOAuth2Client instance.
299      *
300      * @return  array  The access token
301      *
302      * @since   12.3
303      */
304     public function getToken()
305     {
306         return $this->getOption('accesstoken');
307     }
308 
309     /**
310      * Set an option for the JOAuth2Client instance.
311      *
312      * @param   array  $value  The access token
313      *
314      * @return  JOAuth2Client  This object for method chaining
315      *
316      * @since   12.3
317      */
318     public function setToken($value)
319     {
320         if (is_array($value) && !array_key_exists('expires_in', $value) && array_key_exists('expires', $value))
321         {
322             $value['expires_in'] = $value['expires'];
323             unset($value['expires']);
324         }
325 
326         $this->setOption('accesstoken', $value);
327 
328         return $this;
329     }
330 
331     /**
332      * Refresh the access token instance.
333      *
334      * @param   string  $token  The refresh token
335      *
336      * @return  array  The new access token
337      *
338      * @since   12.3
339      * @throws  Exception
340      * @throws  RuntimeException
341      */
342     public function refreshToken($token = null)
343     {
344         if (!$this->getOption('userefresh'))
345         {
346             throw new RuntimeException('Refresh token is not supported for this OAuth instance.');
347         }
348 
349         if (!$token)
350         {
351             $token = $this->getToken();
352 
353             if (!array_key_exists('refresh_token', $token))
354             {
355                 throw new RuntimeException('No refresh token is available.');
356             }
357 
358             $token = $token['refresh_token'];
359         }
360 
361         $data['grant_type'] = 'refresh_token';
362         $data['refresh_token'] = $token;
363         $data['client_id'] = $this->getOption('clientid');
364         $data['client_secret'] = $this->getOption('clientsecret');
365         $response = $this->http->post($this->getOption('tokenurl'), $data);
366 
367         if ($response->code >= 200 || $response->code < 400)
368         {
369             if (strpos($response->headers['Content-Type'], 'application/json') === 0)
370             {
371                 $token = array_merge(json_decode($response->body, true), array('created' => time()));
372             }
373             else
374             {
375                 parse_str($response->body, $token);
376                 $token = array_merge($token, array('created' => time()));
377             }
378 
379             $this->setToken($token);
380 
381             return $token;
382         }
383         else
384         {
385             throw new Exception('Error code ' . $response->code . ' received refreshing token: ' . $response->body . '.');
386         }
387     }
388 }
389 

Joomla! Framework TM API documentation generated by ApiGen 2.8.0
Joomla!® and Joomla! Framework™ are trademarks of Open Source Matters, Inc. in the United States and other countries.