: <?php                                                                                
                 : /**                                                                                  
                 :  * HTTP_OAuth                                                                        
                 :  *                                                                                   
                 :  * Implementation of the OAuth specification                                         
                 :  *                                                                                   
                 :  * PHP version 5.2.0+                                                                
                 :  *                                                                                   
                 :  * LICENSE: This source file is subject to the New BSD license that is               
                 :  * available through the world-wide-web at the following URI:                        
                 :  * http://www.opensource.org/licenses/bsd-license.php. If you did not receive        
                 :  * a copy of the New BSD License and are unable to obtain it through the web,        
                 :  * please send a note to license@php.net so we can mail you a copy immediately.      
                 :  *                                                                                   
                 :  * @category  HTTP                                                                   
                 :  * @package   HTTP_OAuth                                                             
                 :  * @author    Jeff Hodsdon <jeffhodsdon@gmail.com>                                   
                 :  * @copyright 2009 Jeff Hodsdon <jeffhodsdon@gmail.com>                              
                 :  * @license   http://www.opensource.org/licenses/bsd-license.php New BSD License     
                 :  * @link      http://pear.php.net/package/HTTP_OAuth                                 
                 :  * @link      http://github.com/jeffhodsdon/HTTP_OAuth                               
                 :  */                                                                                  
                 :                                                                                      
                 : require_once 'HTTP/OAuth.php';                                                       
                 : require_once 'HTTP/OAuth/Consumer/Request.php';                                      
                 : require_once 'HTTP/OAuth/Consumer/Exception/InvalidResponse.php';                    
                 :                                                                                      
                 : /**                                                                                  
                 :  * HTTP_OAuth_Consumer                                                               
                 :  *                                                                                   
                 :  * Main consumer class that assists consumers in establishing OAuth                  
                 :  * creditials and making OAuth requests.                                             
                 :  *                                                                                   
                 :  * <code>                                                                            
                 :  * $consumer = new HTTP_OAuth_Consumer('key', 'secret');                             
                 :  * $consumer->getRequestToken('http://example.com/oauth/request_token', $callback);  
                 :  *                                                                                   
                 :  * // Store tokens                                                                   
                 :  * $_SESSION['token']        = $consumer->getToken();                                
                 :  * $_SESSION['token_secret'] = $consumer->getTokenSecret();                          
                 :  *                                                                                   
                 :  * $url = $consumer->getAuthorizeUrl('http://example.com/oauth/authorize');          
                 :  * http_redirect($url); // function from pecl_http                                   
                 :  *                                                                                   
                 :  * // When they come back via the $callback url                                      
                 :  * $consumer = new HTTP_OAuth_Consumer('key', 'secret', $_SESSION['token'],          
                 :  *     $_SESSION['token_secret']);                                                   
                 :  * $consumer->getAccessToken('http://example.com/oauth/access_token');               
                 :  *                                                                                   
                 :  * // Store tokens                                                                   
                 :  * $_SESSION['token']        = $consumer->getToken();                                
                 :  * $_SESSION['token_secret'] = $consumer->getTokenSecret();                          
                 :  *                                                                                   
                 :  * // $response is an instance of HTTP_OAuth_Consumer_Response                       
                 :  * $response = $consumer->sendRequest('http://example.com/oauth/protected_resource');
                 :  * </code>                                                                           
                 :  *                                                                                   
                 :  * @category  HTTP                                                                   
                 :  * @package   HTTP_OAuth                                                             
                 :  * @author    Jeff Hodsdon <jeffhodsdon@gmail.com>                                   
                 :  * @copyright 2009 Jeff Hodsdon <jeffhodsdon@gmail.com>                              
                 :  * @license   http://www.opensource.org/licenses/bsd-license.php New BSD License     
                 :  * @link      http://pear.php.net/package/HTTP_OAuth                                 
                 :  * @link      http://github.com/jeffhodsdon/HTTP_OAuth                               
                 :  */                                                                                  
                 : class HTTP_OAuth_Consumer extends HTTP_OAuth                                         
                 : {                                                                                    
                 :                                                                                      
                 :     /**                                                                              
                 :      * Consumer key                                                                  
                 :      *                                                                               
                 :      * @var string $key Consumer key                                                 
                 :      */                                                                              
                 :     protected $key = null;                                                           
                 :                                                                                      
                 :     /**                                                                              
                 :      * secret                                                                        
                 :      *                                                                               
                 :      * @var string $secret Consumer secret                                           
                 :      */                                                                              
                 :     protected $secret = null;                                                        
                 :                                                                                      
                 :     /**                                                                              
                 :      * Token                                                                         
                 :      *                                                                               
                 :      * @var string Access/Request token                                              
                 :      */                                                                              
                 :     protected $token = null;                                                         
                 :                                                                                      
                 :     /**                                                                              
                 :      * Token secret                                                                  
                 :      *                                                                               
                 :      * @var string $tokenSecret Access/Request token secret                          
                 :      */                                                                              
                 :     protected $tokenSecret = null;                                                   
                 :                                                                                      
                 :     /**                                                                              
                 :      * Signature method                                                              
                 :      *                                                                               
                 :      * @var string $signatureMethod Signature method                                 
                 :      */                                                                              
                 :     protected $signatureMethod = 'HMAC-SHA1';                                        
                 :                                                                                      
                 :     /**                                                                              
                 :      * Instance of HTTP_OAuth_Consumer_Request                                       
                 :      *                                                                                
                 :      * @see accept()                                                                 
                 :      * @see getOAuthConsumerRequest()                                                
                 :      * @var HTTP_OAuth_Consumer_Request                                              
                 :      */                                                                              
                 :     protected $consumerRequest = null;                                               
                 :                                                                                      
                 :     /**                                                                              
                 :      * Instance of the last request made                                             
                 :      *                                                                               
                 :      * @var HTTP_OAuth_Consumer_Request $lastRequest The last request made           
                 :      */                                                                              
                 :     protected $lastRequest = null;                                                   
                 :                                                                                      
                 :     /**                                                                              
                 :      * Instance of the last response received                                        
                 :      *                                                                                
                 :      * @var HTTP_OAuth_Consumer_Response                                             
                 :      */                                                                              
                 :     protected $lastResponse =null;                                                   
                 :                                                                                      
                 :     /**                                                                              
                 :      * Construct                                                                     
                 :      *                                                                               
                 :      * @param string $key         Consumer key                                       
                 :      * @param string $secret      Consumer secret                                    
                 :      * @param string $token       Access/Reqest token                                
                 :      * @param string $tokenSecret Access/Reqest token secret                         
                 :      *                                                                               
                 :      * @return void                                                                  
                 :      */                                                                              
                 :     public function __construct($key, $secret, $token = null, $tokenSecret = null)   
                 :     {                                                                                
              12 :         $this->key    = $key;                                                        
              12 :         $this->secret = $secret;                                                     
              12 :         $this->setToken($token);                                                     
              12 :         $this->setTokenSecret($tokenSecret);                                         
              12 :     }                                                                                
                 :                                                                                      
                 :     /**                                                                              
                 :      * Get request token                                                             
                 :      *                                                                               
                 :      * @param string $url        Request token url                                   
                 :      * @param string $callback   Callback url                                        
                 :      * @param array  $additional Additional parameters to be in the request          
                 :      *                           recommended in the spec.                            
                 :      * @param string $method     HTTP method to use for the request                  
                 :      *                                                                               
                 :      * @return void                                                                  
                 :      * @throws HTTP_OAuth_Consumer_Exception_InvalidResponse Missing token/secret    
                 :      */                                                                              
                 :     public function getRequestToken($url, $callback = 'oob',                         
                 :         array $additional = array(), $method = 'POST'                                
                 :     ) {                                                                              
               2 :         $this->debug('Getting request token from ' . $url);                          
               2 :         $additional['oauth_callback'] = $callback;                                   
                 :                                                                                      
               2 :         $this->debug('callback: ' . $callback);                                      
               2 :         $response = $this->sendRequest($url, $additional, $method);                  
               2 :         $data     = $response->getDataFromBody();                                    
               2 :         if (empty($data['oauth_token']) || empty($data['oauth_token_secret'])) {     
               1 :             throw new HTTP_OAuth_Consumer_Exception_InvalidResponse(                 
               1 :                 'Failed getting token and token secret from response', $response     
               1 :             );                                                                       
                 :         }                                                                            
                 :                                                                                      
               1 :         $this->setToken($data['oauth_token']);                                       
               1 :         $this->setTokenSecret($data['oauth_token_secret']);                          
               1 :     }                                                                                
                 :                                                                                      
                 :     /**                                                                              
                 :      * Get access token                                                              
                 :      *                                                                               
                 :      * @param string $url        Access token url                                    
                 :      * @param string $verifier   OAuth verifier from the provider                    
                 :      * @param array  $additional Additional parameters to be in the request          
                 :      *                           recommended in the spec.                            
                 :      * @param string $method     HTTP method to use for the request                  
                 :      *                                                                               
                 :      * @return array Token and token secret                                          
                 :      * @throws HTTP_OAuth_Consumer_Exception_InvalidResponse Mising token/secret     
                 :      */                                                                              
                 :     public function getAccessToken($url, $verifier = '',                             
                 :         array $additional = array(), $method = 'POST'                                
                 :     ) {                                                                              
               3 :         if ($this->getToken() === null || $this->getTokenSecret() === null) {        
               1 :             throw new HTTP_OAuth_Exception('No token or token_secret');              
                 :         }                                                                            
                 :                                                                                      
               2 :         $this->debug('Getting access token from ' . $url);                           
               2 :         if($verifier !== null) {                                                     
               2 :             $additional['oauth_verifier'] = $verifier;                               
               2 :         }                                                                            
                 :                                                                                      
               2 :         $this->debug('verifier: ' . $verifier);                                      
               2 :         $response = $this->sendRequest($url, $additional, $method);                  
               2 :         $data     = $response->getDataFromBody();                                    
               2 :         if (empty($data['oauth_token']) || empty($data['oauth_token_secret'])) {     
               1 :             throw new HTTP_OAuth_Consumer_Exception_InvalidResponse(                 
               1 :                 'Failed getting token and token secret from response', $response     
               1 :             );                                                                       
                 :         }                                                                            
                 :                                                                                      
               1 :         $this->setToken($data['oauth_token']);                                       
               1 :         $this->setTokenSecret($data['oauth_token_secret']);                          
               1 :     }                                                                                
                 :                                                                                      
                 :     /**                                                                              
                 :      * Get authorize url                                                             
                 :      *                                                                               
                 :      * @param string $url        Authorize url                                       
                 :      * @param array  $additional Additional parameters for the auth url              
                 :      *                                                                               
                 :      * @return string Authorize url                                                  
                 :      */                                                                              
                 :     public function getAuthorizeUrl($url, array $additional = array())               
                 :     {                                                                                
               1 :         $params = array('oauth_token' => $this->getToken());                         
               1 :         $params = array_merge($additional, $params);                                 
                 :                                                                                      
               1 :         return sprintf('%s?%s', $url, HTTP_OAuth::buildHTTPQuery($params));          
                 :     }                                                                                
                 :                                                                                      
                 :     /**                                                                              
                 :      * Send request                                                                  
                 :      *                                                                               
                 :      * @param string $url        URL of the protected resource                       
                 :      * @param array  $additional Additional parameters                               
                 :      * @param string $method     HTTP method to use                                  
                 :      *                                                                               
                 :      * @return HTTP_OAuth_Consumer_Response Instance of a response class             
                 :      */                                                                              
                 :     public function sendRequest($url, array $additional = array(), $method = 'POST') 
                 :     {                                                                                
                 :         $params = array(                                                             
               5 :             'oauth_consumer_key'     => $this->key,                                  
               5 :             'oauth_signature_method' => $this->getSignatureMethod()                  
               5 :         );                                                                           
                 :                                                                                      
               5 :         if ($this->getToken()) {                                                     
               5 :             $params['oauth_token'] = $this->getToken();                              
               5 :         }                                                                            
                 :                                                                                      
               5 :         $params = array_merge($additional, $params);                                 
                 :                                                                                      
               5 :         $req = clone $this->getOAuthConsumerRequest();                               
                 :                                                                                      
               5 :         $req->setUrl($url);                                                          
               5 :         $req->setMethod($method);                                                    
               5 :         $req->setSecrets($this->getSecrets());                                       
               5 :         $req->setParameters($params);                                                
               5 :         $this->lastResponse = $req->send();                                          
               5 :         $this->lastRequest  = $req;                                                  
                 :                                                                                      
               5 :         return $this->lastResponse;                                                  
                 :     }                                                                                
                 :                                                                                      
                 :     /**                                                                              
                 :      * Get key                                                                       
                 :      *                                                                               
                 :      * @return string Consumer key                                                   
                 :      */                                                                              
                 :     public function getKey()                                                         
                 :     {                                                                                
               1 :         return $this->key;                                                           
                 :     }                                                                                
                 :                                                                                      
                 :     /**                                                                              
                 :      * Get secret                                                                    
                 :      *                                                                               
                 :      * @return string Consumer secret                                                
                 :      */                                                                              
                 :     public function getSecret()                                                      
                 :     {                                                                                
               1 :         return $this->secret;                                                        
                 :     }                                                                                
                 :                                                                                      
                 :     /**                                                                              
                 :      * Get token                                                                     
                 :      *                                                                               
                 :      * @return string Token                                                          
                 :      */                                                                              
                 :     public function getToken()                                                       
                 :     {                                                                                
               8 :         return $this->token;                                                         
                 :     }                                                                                
                 :                                                                                      
                 :     /**                                                                              
                 :      * Set token                                                                     
                 :      *                                                                               
                 :      * @param string $token Request/Access token                                     
                 :      *                                                                               
                 :      * @return void                                                                  
                 :      */                                                                              
                 :     public function setToken($token)                                                 
                 :     {                                                                                
              12 :         $this->debug('token is now: ' . $token);                                     
              12 :         $this->token = $token;                                                       
              12 :     }                                                                                
                 :                                                                                      
                 :     /**                                                                              
                 :      * Get token secret                                                              
                 :      *                                                                               
                 :      * @return string Accessoken secret                                              
                 :      */                                                                              
                 :     public function getTokenSecret()                                                 
                 :     {                                                                                
               4 :         return $this->tokenSecret;                                                   
                 :     }                                                                                
                 :                                                                                      
                 :     /**                                                                              
                 :      * Set token secret                                                              
                 :      *                                                                               
                 :      * @param string $secret Token secret                                            
                 :      *                                                                               
                 :      * @return void                                                                  
                 :      */                                                                              
                 :     public function setTokenSecret($secret)                                          
                 :     {                                                                                
              12 :         $this->debug('token_secret is now: ' . $secret);                             
              12 :         $this->tokenSecret = $secret;                                                
              12 :     }                                                                                
                 :                                                                                      
                 :     /**                                                                              
                 :      * Get signature method                                                          
                 :      *                                                                               
                 :      * @return string Signature method                                               
                 :      */                                                                              
                 :     public function getSignatureMethod()                                             
                 :     {                                                                                
               6 :         return $this->signatureMethod;                                               
                 :     }                                                                                
                 :                                                                                      
                 :     /**                                                                              
                 :      * Set signature method                                                          
                 :      *                                                                               
                 :      * @param string $method Signature method to use                                 
                 :      *                                                                               
                 :      * @return void                                                                  
                 :      */                                                                              
                 :     public function setSignatureMethod($method)                                      
                 :     {                                                                                
               1 :         $this->signatureMethod = $method;                                            
               1 :     }                                                                                
                 :                                                                                      
                 :     /**                                                                              
                 :      * Get secrets                                                                   
                 :      *                                                                               
                 :      * @return array Array possible secrets                                          
                 :      */                                                                              
                 :     public function getSecrets()                                                     
                 :     {                                                                                
               5 :         return array($this->secret, (string) $this->tokenSecret);                    
                 :     }                                                                                
                 :                                                                                      
                 :     /**                                                                              
                 :      * Accepts a custom instance of HTTP_OAuth_Consumer_Request.                     
                 :      *                                                                                
                 :      * @param HTTP_OAuth_Consumer_Request $object Custom instance                    
                 :      *                                                                                
                 :      * @see getOAuthConsumerRequest()                                                
                 :      * @return void                                                                  
                 :      */                                                                              
                 :     public function accept($object)                                                  
                 :     {                                                                                
               3 :         $class = get_class($object);                                                 
                 :         switch ($class)                                                              
                 :         {                                                                            
               3 :         case 'HTTP_OAuth_Consumer_Request':                                          
               1 :             $this->consumerRequest = $object;                                        
               1 :             break;                                                                   
               2 :         case 'HTTP_Request2':                                                        
               1 :             $this->getOAuthConsumerRequest()->accept($object);                       
               1 :             break;                                                                   
               1 :         default:                                                                     
               1 :             throw new HTTP_OAuth_Exception('Could not accept: ' . $class);           
                 :             break;                                                                   
               1 :         }                                                                            
               2 :     }                                                                                
                 :                                                                                      
                 :     /**                                                                              
                 :      * Gets instance of HTTP_OAuth_Consumer_Request                                  
                 :      *                                                                               
                 :      * @see accept()                                                                 
                 :      * @return HTTP_OAuth_Consumer_Request                                           
                 :      */                                                                              
                 :     public function getOAuthConsumerRequest()                                        
                 :     {                                                                                
               3 :         if (!$this->consumerRequest instanceof HTTP_OAuth_Consumer_Request) {        
               3 :             $this->consumerRequest = new HTTP_OAuth_Consumer_Request;                
               3 :         }                                                                             
               3 :         return $this->consumerRequest;                                               
                 :     }                                                                                
                 :                                                                                      
                 :     /**                                                                              
                 :      * Gets the last request                                                         
                 :      *                                                                               
                 :      * @return null|HTTP_OAuth_Consumer_Request Instance of the last request         
                 :      * @see self::sendRequest()                                                      
                 :      */                                                                              
                 :     public function getLastRequest()                                                 
                 :     {                                                                                
               1 :         return $this->lastRequest;                                                   
                 :     }                                                                                
                 :                                                                                      
                 :     /**                                                                              
                 :      * Gets the most recent HTTP_OAuth_Consumer_Response object                      
                 :      *                                                                                
                 :      * @return HTTP_OAuth_Consumer_Response|null                                     
                 :      */                                                                              
                 :     public function getLastResponse()                                                
                 :     {                                                                                
               1 :         return $this->lastResponse;                                                  
                 :     }                                                                                
                 : }                                                                                    
                 :                                                                                      
                 : ?>