First complete upload on nas
This commit is contained in:
@@ -0,0 +1,629 @@
|
||||
<?php
|
||||
|
||||
/**
|
||||
* TwitterOAuth - https://github.com/ricardoper/TwitterOAuth
|
||||
* PHP library to communicate with Twitter OAuth API version 1.1
|
||||
*
|
||||
* @author Ricardo Pereira <github@ricardopereira.es>
|
||||
* @copyright 2013
|
||||
*/
|
||||
|
||||
/*************************************** config ***************************************/
|
||||
|
||||
$config = array(
|
||||
'consumer_key' => '', // Your Twitter App Consumer Key
|
||||
'consumer_secret' => '', // Your Twitter App Consumer Secret
|
||||
'oauth_token' => '', // Your Twitter App Access Token
|
||||
'oauth_token_secret' => '', // Your Twitter App Access Token Secret
|
||||
'output_format' => 'object'
|
||||
);
|
||||
|
||||
/**************************************************************************************/
|
||||
|
||||
//use TwitterOAuth\Exception\TwitterException;
|
||||
|
||||
class TwitterOAuth
|
||||
{
|
||||
protected $url = 'https://api.twitter.com/1.1/';
|
||||
protected $auth_url = 'https://api.twitter.com/';
|
||||
protected $outputFormats = array('text', 'json', 'array', 'object');
|
||||
protected $defaultFormat = 'object';
|
||||
protected $config = array();
|
||||
protected $call = '';
|
||||
protected $method = 'GET';
|
||||
protected $getParams = array();
|
||||
protected $postParams = array();
|
||||
protected $encoded_bearer_credentials = null;
|
||||
protected $bearer_access_token = null;
|
||||
protected $headers = null;
|
||||
protected $response = null;
|
||||
protected $cachefile = '';
|
||||
|
||||
/**
|
||||
* Prepare a new conection with Twitter API via OAuth
|
||||
*
|
||||
* The application ``consumer_key`` and ``consumer_key_secret`` are required
|
||||
* for most actions, unless when using application-only authentication with a bearer-token.
|
||||
* The ``oauth_token`` and ``oauth_token_secret`` are required for user type actions.
|
||||
*
|
||||
* @param array $config Configuration array with OAuth access data
|
||||
*/
|
||||
public function __construct(array $config)
|
||||
{
|
||||
$required = array(
|
||||
'consumer_key' => '',
|
||||
'consumer_secret' => '',
|
||||
);
|
||||
|
||||
if (count(array_intersect_key($required, $config)) !== count($required)) {
|
||||
//throw new \Exception('Missing parameters in configuration array');
|
||||
}
|
||||
|
||||
if (!isset($config['output_format']) || !in_array($config['output_format'], $this->outputFormats)) {
|
||||
$config['output_format'] = $this->defaultFormat;
|
||||
}
|
||||
|
||||
$this->config = $config;
|
||||
|
||||
unset($required, $config);
|
||||
}
|
||||
|
||||
private function object_to_array($data)
|
||||
{
|
||||
if (is_array($data) || is_object($data))
|
||||
{
|
||||
$result = array();
|
||||
foreach ($data as $key => $value)
|
||||
{
|
||||
$result[$key] = $this->object_to_array($value);
|
||||
}
|
||||
return $result;
|
||||
}
|
||||
return $data;
|
||||
}
|
||||
|
||||
/**
|
||||
* Send a GET call to Twitter API via OAuth
|
||||
*
|
||||
* @param string $call Twitter resource string
|
||||
* @param array $getParams GET parameters to send
|
||||
* @return mixed Output with selected format
|
||||
*/
|
||||
public function get($call, array $getParams = null)
|
||||
{
|
||||
$this->call = $call;
|
||||
|
||||
$this->method = 'GET';
|
||||
$this->resetParams();
|
||||
$this->cachefile = '.tweetcache';
|
||||
|
||||
if ($getParams !== null && is_array($getParams)) {
|
||||
$this->getParams = $getParams;
|
||||
}
|
||||
$result = $this->object_to_array($this->sendRequest());
|
||||
|
||||
if (is_file($this->cachefile)) {
|
||||
$cache = json_decode(file_get_contents($this->cachefile),true);
|
||||
}
|
||||
|
||||
if (!isset($result['errors'])) {
|
||||
$cache[$this->getParams['screen_name']]['time'] = time();
|
||||
$cache[$this->getParams['screen_name']]['tweets'] = $result;
|
||||
$file = $this->cachefile;
|
||||
file_put_contents($file,json_encode($cache));
|
||||
} else {
|
||||
$result = isset($cache[$this->getParams['screen_name']]) ? $cache[$this->getParams['screen_name']]['tweets'] : $result['errors'][0]['message'];
|
||||
}
|
||||
return json_encode( array_slice($result, 0, $getParams['count']) );
|
||||
}
|
||||
|
||||
/**
|
||||
* Send a POST call to Twitter API via OAuth
|
||||
*
|
||||
* @param string $call Twitter resource string
|
||||
* @param array $postParams POST parameters to send
|
||||
* @param array $getParams GET parameters to send
|
||||
* @return mixed Output with selected format
|
||||
*/
|
||||
public function post($call, array $postParams = null, array $getParams = null)
|
||||
{
|
||||
$this->call = $call;
|
||||
|
||||
$this->method = 'POST';
|
||||
$this->resetParams();
|
||||
|
||||
if ($postParams !== null && is_array($postParams)) {
|
||||
$this->postParams = $postParams;
|
||||
}
|
||||
|
||||
if ($getParams !== null && is_array($getParams)) {
|
||||
$this->getParams = $getParams;
|
||||
}
|
||||
|
||||
return $this->sendRequest();
|
||||
}
|
||||
|
||||
protected function resetParams() {
|
||||
$this->headers = null;
|
||||
$this->response = null;
|
||||
|
||||
$this->postParams = array();
|
||||
$this->getParams = array();
|
||||
}
|
||||
|
||||
/**
|
||||
* Returns raw response body
|
||||
*
|
||||
* @return string Single string with encoded values
|
||||
*/
|
||||
public function getResponse() {
|
||||
return $this->response;
|
||||
}
|
||||
|
||||
/**
|
||||
* Returns response headers as array.
|
||||
* This can be useful to avoid extra requests for rate-limit info
|
||||
* x-rate-limit-limit (max request per period)
|
||||
* x-rate-limit-remaining (remaining this period)
|
||||
* x-rate-limit-reset (start of next period, UTC timestamp)
|
||||
*
|
||||
* @return array with http_code and header lines
|
||||
*/
|
||||
public function getHeaders() {
|
||||
return $this->headers;
|
||||
}
|
||||
|
||||
/**
|
||||
* Converting parameters array to a single string with encoded values
|
||||
*
|
||||
* @param array $params Input parameters
|
||||
* @return string Single string with encoded values
|
||||
*/
|
||||
protected function getParams(array $params)
|
||||
{
|
||||
$r = '';
|
||||
|
||||
ksort($params);
|
||||
|
||||
foreach ($params as $key => $value) {
|
||||
$r .= '&' . $key . '=' . rawurlencode($value);
|
||||
}
|
||||
|
||||
unset($params, $key, $value);
|
||||
|
||||
return trim($r, '&');
|
||||
}
|
||||
|
||||
/**
|
||||
* Getting full URL from a Twitter resource
|
||||
*
|
||||
* @param bool $withParams If true then parameters will be outputted
|
||||
* @return string Full URL
|
||||
*/
|
||||
protected function getUrl($withParams = false)
|
||||
{
|
||||
$getParams = '';
|
||||
|
||||
if ($withParams === true) {
|
||||
$getParams = $this->getParams($this->getParams);
|
||||
|
||||
if (!empty($getParams)) {
|
||||
$getParams = '?' . $getParams;
|
||||
}
|
||||
}
|
||||
|
||||
if ($this->encoded_bearer_credentials && !$this->bearer_access_token) {
|
||||
$url = $this->auth_url . $this->call;
|
||||
} else {
|
||||
$url = $this->url . $this->call . '.json' . $getParams;
|
||||
}
|
||||
|
||||
return $url;
|
||||
}
|
||||
|
||||
/**
|
||||
* Getting OAuth parameters to be used in request headers
|
||||
*
|
||||
* @return array OAuth parameters
|
||||
*/
|
||||
protected function getOauthParameters()
|
||||
{
|
||||
$time = time();
|
||||
|
||||
return array(
|
||||
'oauth_consumer_key' => $this->config['consumer_key'],
|
||||
'oauth_nonce' => trim(base64_encode($time), '='),
|
||||
'oauth_signature_method' => 'HMAC-SHA1',
|
||||
'oauth_timestamp' => $time,
|
||||
'oauth_token' => $this->config['oauth_token'],
|
||||
'oauth_version' => '1.0'
|
||||
);
|
||||
}
|
||||
|
||||
/**
|
||||
* Converting all parameters arrays to a single string with encoded values
|
||||
*
|
||||
* @return string Single string with encoded values
|
||||
*/
|
||||
protected function getRequestString()
|
||||
{
|
||||
$params = array_merge($this->getParams, $this->postParams, $this->getOauthParameters());
|
||||
|
||||
$params = $this->getParams($params);
|
||||
|
||||
return rawurlencode($params);
|
||||
}
|
||||
|
||||
/**
|
||||
* Getting OAuth signature base string
|
||||
*
|
||||
* @return string OAuth signature base string
|
||||
*/
|
||||
protected function getSignatureBaseString()
|
||||
{
|
||||
$method = strtoupper($this->method);
|
||||
|
||||
$url = rawurlencode($this->getUrl());
|
||||
|
||||
return $method . '&' . $url . '&' . $this->getRequestString();
|
||||
}
|
||||
|
||||
/**
|
||||
* Getting a signing key
|
||||
*
|
||||
* @return string Signing key
|
||||
*/
|
||||
protected function getSigningKey()
|
||||
{
|
||||
return $this->config['consumer_secret'] . '&' . $this->config['oauth_token_secret'];
|
||||
}
|
||||
|
||||
/**
|
||||
* Calculating the signature
|
||||
*
|
||||
* @return string Signature
|
||||
*/
|
||||
protected function calculateSignature()
|
||||
{
|
||||
return base64_encode(hash_hmac('sha1', $this->getSignatureBaseString(), $this->getSigningKey(), true));
|
||||
}
|
||||
|
||||
/**
|
||||
* Converting OAuth parameters array to a single string with encoded values
|
||||
*
|
||||
* @return string Single string with encoded values
|
||||
*/
|
||||
protected function getOauthString()
|
||||
{
|
||||
// User-keys check moved here for app-only token support
|
||||
$required = array(
|
||||
'oauth_token' => '',
|
||||
'oauth_token_secret' => ''
|
||||
);
|
||||
if (count(array_intersect_key($required, $this->config)) !== count($required)) {
|
||||
//throw new \Exception('Missing parameters in configuration array');
|
||||
}
|
||||
|
||||
$oauth = array_merge($this->getOauthParameters(), array('oauth_signature' => $this->calculateSignature()));
|
||||
|
||||
ksort($oauth);
|
||||
|
||||
$values = array();
|
||||
|
||||
foreach ($oauth as $key => $value) {
|
||||
$values[] = $key . '="' . rawurlencode($value) . '"';
|
||||
}
|
||||
|
||||
$oauth = implode(', ', $values);
|
||||
|
||||
unset($values, $key, $value);
|
||||
|
||||
return $oauth;
|
||||
}
|
||||
|
||||
/**
|
||||
* Building request HTTP headers
|
||||
*
|
||||
* @return array HTTP headers
|
||||
*/
|
||||
protected function buildRequestHeader()
|
||||
{
|
||||
if ($this->encoded_bearer_credentials) {
|
||||
if ($this->bearer_access_token) {
|
||||
return array(
|
||||
"Authorization: Bearer " . $this->bearer_access_token
|
||||
);
|
||||
} else {
|
||||
return array(
|
||||
"Authorization: Basic " . $this->encoded_bearer_credentials,
|
||||
"Content-Type: application/x-www-form-urlencoded;charset=UTF-8"
|
||||
);
|
||||
}
|
||||
} else {
|
||||
// OAuth headers
|
||||
return array(
|
||||
'Authorization: OAuth ' . $this->getOauthString(),
|
||||
'Expect:'
|
||||
);
|
||||
}
|
||||
}
|
||||
|
||||
/**
|
||||
* Processing Twitter Exceptions in case of error
|
||||
*
|
||||
* @param string $type Depends of response format (array|object)
|
||||
* @param mixed $ex Exceptions
|
||||
* @throws Exception\TwitterException
|
||||
*/
|
||||
protected function processExceptions($type, $ex)
|
||||
{
|
||||
switch ($type) {
|
||||
case 'array':
|
||||
foreach ($ex['errors'] as $error) {
|
||||
//throw new TwitterException($error['message'], $error['code']);
|
||||
}
|
||||
|
||||
break;
|
||||
|
||||
default:
|
||||
foreach ($ex->errors as $error) {
|
||||
//throw new TwitterException($error->message, $error->code);
|
||||
}
|
||||
}
|
||||
|
||||
unset($type, $ex, $error);
|
||||
}
|
||||
|
||||
/**
|
||||
* Outputs the response in the selected format
|
||||
*
|
||||
* @param string $response
|
||||
* @return mixed
|
||||
*/
|
||||
protected function processOutput($response)
|
||||
{
|
||||
$format = $this->config['output_format'];
|
||||
|
||||
switch ($format) {
|
||||
case 'text':
|
||||
if (substr($response, 2, 6) == 'errors') {
|
||||
$response = json_decode($response);
|
||||
|
||||
$this->processExceptions('object', $response);
|
||||
}
|
||||
|
||||
break;
|
||||
|
||||
case 'json':
|
||||
if (!headers_sent()) {
|
||||
header('Cache-Control: no-cache, must-revalidate');
|
||||
header('Expires: Tue, 19 May 1981 00:00:00 GMT');
|
||||
header('Content-type: application/json');
|
||||
}
|
||||
|
||||
if (substr($response, 2, 6) == 'errors') {
|
||||
$response = json_decode($response);
|
||||
|
||||
$this->processExceptions('object', $response);
|
||||
}
|
||||
|
||||
break;
|
||||
|
||||
case 'array':
|
||||
$response = json_decode($response, true);
|
||||
|
||||
if (isset($response['errors'])) {
|
||||
$this->processExceptions('array', $response);
|
||||
}
|
||||
|
||||
break;
|
||||
|
||||
default:
|
||||
$response = json_decode($response);
|
||||
|
||||
if (isset($response->errors)) {
|
||||
$this->processExceptions('object', $response);
|
||||
}
|
||||
}
|
||||
|
||||
unset($format);
|
||||
|
||||
return $response;
|
||||
}
|
||||
|
||||
/**
|
||||
* Process curl headers to array
|
||||
*/
|
||||
protected function processCurlHeaders($headerContent)
|
||||
{
|
||||
$this->headers = array();
|
||||
|
||||
// Split the string on every "double" new line (multiple headers).
|
||||
$arrRequests = explode("\r\n\r\n", $headerContent);
|
||||
|
||||
// Loop of response headers. The "count() -1" is to
|
||||
// skip an empty row for the extra line break before the body of the response.
|
||||
for ($index = 0; $foo = count($arrRequests) -1, $index < $foo; $index++) {
|
||||
|
||||
foreach (explode("\r\n", $arrRequests[$index]) as $i => $line)
|
||||
{
|
||||
if ($i === 0)
|
||||
$this->headers[$index]['http_code'] = $line;
|
||||
else
|
||||
{
|
||||
list ($key, $value) = explode(': ', $line);
|
||||
$this->headers[$index][$key] = $value;
|
||||
}
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
|
||||
/**
|
||||
* Send GET or POST requests to Twitter API
|
||||
*
|
||||
* @throws Exception\TwitterException
|
||||
* @return mixed Response output
|
||||
*/
|
||||
protected function sendRequest()
|
||||
{
|
||||
$url = $this->getUrl(true);
|
||||
|
||||
$header = $this->buildRequestHeader();
|
||||
|
||||
$options = array(
|
||||
CURLOPT_URL => $url,
|
||||
CURLOPT_HEADER => true,
|
||||
CURLOPT_HTTPHEADER => $header,
|
||||
CURLOPT_RETURNTRANSFER => true,
|
||||
CURLOPT_SSL_VERIFYPEER => false,
|
||||
);
|
||||
|
||||
if (!empty($this->postParams)) {
|
||||
$options[CURLOPT_POST] = count($this->postParams);
|
||||
$options[CURLOPT_POSTFIELDS] = $this->getParams($this->postParams);
|
||||
}
|
||||
|
||||
$c = curl_init();
|
||||
|
||||
curl_setopt_array($c, $options);
|
||||
|
||||
$response = curl_exec($c);
|
||||
|
||||
if ($n = curl_errno($c)) {
|
||||
//throw new \Exception("cURL error ($n) : ".curl_error($c));
|
||||
}
|
||||
|
||||
$header_size = curl_getinfo($c, CURLINFO_HEADER_SIZE);
|
||||
$headers = substr($response, 0, $header_size);
|
||||
$this->processCurlHeaders($headers);
|
||||
|
||||
$this->response = substr($response, $header_size);
|
||||
|
||||
curl_close($c);
|
||||
|
||||
unset($response, $options, $c);
|
||||
|
||||
if (!in_array($this->response[0], array('{', '['))) {
|
||||
//throw new TwitterException("($url) ".str_replace(array("\n", "\r", "\t"), '', strip_tags($this->response)), 0);
|
||||
}
|
||||
|
||||
return $this->processOutput($this->response);
|
||||
}
|
||||
|
||||
|
||||
/**
|
||||
* Set an Application-only bearer-token
|
||||
*
|
||||
* When set, API-requests will use the app-token
|
||||
* instead of OAuth consumer keys.
|
||||
* https://dev.twitter.com/docs/auth/application-only-auth
|
||||
*
|
||||
* @throws Exception
|
||||
* @param string $token bearer-token
|
||||
*/
|
||||
public function setBearerToken($token = null)
|
||||
{
|
||||
if (empty($token)) {
|
||||
//throw new \Exception('Token invalid (empty)');
|
||||
}
|
||||
|
||||
$this->generateEncodedBearerCredentials();
|
||||
$this->bearer_access_token = $token;
|
||||
}
|
||||
|
||||
/**
|
||||
* Get an application-only token from consumer keys
|
||||
*
|
||||
* @return string Returns access-token on success
|
||||
*/
|
||||
public function getBearerToken()
|
||||
{
|
||||
$this->generateEncodedBearerCredentials();
|
||||
|
||||
$this->post('oauth2/token', array('grant_type' => 'client_credentials'));
|
||||
|
||||
$this->bearer_access_token = $this->processTokenResponse('oauth2/token');
|
||||
|
||||
return $this->bearer_access_token;
|
||||
}
|
||||
|
||||
/**
|
||||
* Revoke / invalidate an application-only token
|
||||
*
|
||||
* @param string $token Bearer-token
|
||||
* @throws Exception
|
||||
* @return string Returns the same token on success
|
||||
*/
|
||||
public function invalidateBearerToken($token = null)
|
||||
{
|
||||
if (empty($token)) {
|
||||
//throw new \Exception('Token invalid (empty)');
|
||||
}
|
||||
|
||||
$this->generateEncodedBearerCredentials();
|
||||
|
||||
$this->post("oauth2/invalidate_token", array("access_token" => rawurldecode($token)));
|
||||
|
||||
$return_token = $this->processTokenResponse('oauth2/invalidate_token');
|
||||
|
||||
return $return_token;
|
||||
}
|
||||
|
||||
/**
|
||||
* Generates basic authorization credentials for token request
|
||||
*
|
||||
*/
|
||||
protected function generateEncodedBearerCredentials()
|
||||
{
|
||||
$this->bearer_access_token = null;
|
||||
$this->encoded_bearer_credentials = null;
|
||||
|
||||
$bearer_credentials = urlencode($this->config['consumer_key']) . ":" . urlencode($this->config['consumer_secret']);
|
||||
|
||||
$this->encoded_bearer_credentials = base64_encode($bearer_credentials);
|
||||
}
|
||||
|
||||
/**
|
||||
* Process oauth2 response, returns the bearer-access-token
|
||||
*
|
||||
* @param string $response
|
||||
* @throws Exception\TwitterException
|
||||
* @return mixed
|
||||
*/
|
||||
protected function processTokenResponse($path)
|
||||
{
|
||||
// json-decode raw response (as object)
|
||||
$response = json_decode($this->response);
|
||||
|
||||
$token = false;
|
||||
|
||||
switch ($path) {
|
||||
case 'oauth2/token':
|
||||
if (isset($response->token_type) && $response->token_type == 'bearer') {
|
||||
$token = $response->access_token;
|
||||
}
|
||||
break;
|
||||
|
||||
case 'oauth2/invalidate_token':
|
||||
if (isset($response->access_token)) {
|
||||
$token = $response->access_token;
|
||||
}
|
||||
break;
|
||||
}
|
||||
|
||||
unset($response);
|
||||
|
||||
return $token;
|
||||
}
|
||||
|
||||
}
|
||||
|
||||
$tw = new TwitterOAuth($config);
|
||||
$params = array(
|
||||
'screen_name' => 'creative_ws',
|
||||
'count' => 6,
|
||||
'exclude_replies' => false
|
||||
);
|
||||
$res = $tw->get('statuses/user_timeline', $params);
|
||||
echo $res;
|
||||
@@ -0,0 +1,726 @@
|
||||
<?php
|
||||
/**
|
||||
* tmhOAuth
|
||||
*
|
||||
* An OAuth 1.0A library written in PHP.
|
||||
* The library supports file uploading using multipart/form as well as general
|
||||
* REST requests. OAuth authentication is sent using the an Authorization Header.
|
||||
*
|
||||
* @author themattharris
|
||||
* @version 0.7.4
|
||||
*
|
||||
* 19 February 2013
|
||||
*/
|
||||
class tmhOAuth {
|
||||
const VERSION = '0.7.4';
|
||||
|
||||
var $response = array();
|
||||
|
||||
/**
|
||||
* Creates a new tmhOAuth object
|
||||
*
|
||||
* @param string $config, the configuration to use for this request
|
||||
* @return void
|
||||
*/
|
||||
public function __construct($config=array()) {
|
||||
$this->params = array();
|
||||
$this->headers = array();
|
||||
$this->auto_fixed_time = false;
|
||||
$this->buffer = null;
|
||||
|
||||
// default configuration options
|
||||
$this->config = array_merge(
|
||||
array(
|
||||
// leave 'user_agent' blank for default, otherwise set this to
|
||||
// something that clearly identifies your app
|
||||
'user_agent' => '',
|
||||
// default timezone for requests
|
||||
'timezone' => 'UTC',
|
||||
|
||||
'use_ssl' => true,
|
||||
'host' => 'api.twitter.com',
|
||||
|
||||
'consumer_key' => '',
|
||||
'consumer_secret' => '',
|
||||
'user_token' => '',
|
||||
'user_secret' => '',
|
||||
'force_nonce' => false,
|
||||
'nonce' => false, // used for checking signatures. leave as false for auto
|
||||
'force_timestamp' => false,
|
||||
'timestamp' => false, // used for checking signatures. leave as false for auto
|
||||
|
||||
// oauth signing variables that are not dynamic
|
||||
'oauth_version' => '1.0',
|
||||
'oauth_signature_method' => 'HMAC-SHA1',
|
||||
|
||||
// you probably don't want to change any of these curl values
|
||||
'curl_connecttimeout' => 30,
|
||||
'curl_timeout' => 10,
|
||||
|
||||
// for security this should always be set to 2.
|
||||
'curl_ssl_verifyhost' => 2,
|
||||
// for security this should always be set to true.
|
||||
'curl_ssl_verifypeer' => true,
|
||||
|
||||
// you can get the latest cacert.pem from here http://curl.haxx.se/ca/cacert.pem
|
||||
'curl_cainfo' => dirname(__FILE__) . DIRECTORY_SEPARATOR . 'cacert.pem',
|
||||
'curl_capath' => dirname(__FILE__),
|
||||
|
||||
'curl_followlocation' => false, // whether to follow redirects or not
|
||||
|
||||
// support for proxy servers
|
||||
'curl_proxy' => false, // really you don't want to use this if you are using streaming
|
||||
'curl_proxyuserpwd' => false, // format username:password for proxy, if required
|
||||
'curl_encoding' => '', // leave blank for all supported formats, else use gzip, deflate, identity
|
||||
|
||||
// streaming API
|
||||
'is_streaming' => false,
|
||||
'streaming_eol' => "\r\n",
|
||||
'streaming_metrics_interval' => 60,
|
||||
|
||||
// header or querystring. You should always use header!
|
||||
// this is just to help me debug other developers implementations
|
||||
'as_header' => true,
|
||||
'debug' => false,
|
||||
),
|
||||
$config
|
||||
);
|
||||
$this->set_user_agent();
|
||||
date_default_timezone_set($this->config['timezone']);
|
||||
}
|
||||
|
||||
|
||||
/**
|
||||
* Sets the useragent for PHP to use
|
||||
* If '$this->config['user_agent']' already has a value it is used instead of one
|
||||
* being generated.
|
||||
*
|
||||
* @return void value is stored to the config array class variable
|
||||
*/
|
||||
private function set_user_agent() {
|
||||
if (!empty($this->config['user_agent']))
|
||||
return;
|
||||
|
||||
if ($this->config['curl_ssl_verifyhost'] && $this->config['curl_ssl_verifypeer']) {
|
||||
$ssl = '+SSL';
|
||||
} else {
|
||||
$ssl = '-SSL';
|
||||
}
|
||||
|
||||
$ua = 'tmhOAuth ' . self::VERSION . $ssl . ' - //github.com/themattharris/tmhOAuth';
|
||||
$this->config['user_agent'] = $ua;
|
||||
}
|
||||
|
||||
/**
|
||||
* Generates a random OAuth nonce.
|
||||
* If 'force_nonce' is true a nonce is not generated and the value in the configuration will be retained.
|
||||
*
|
||||
* @param string $length how many characters the nonce should be before MD5 hashing. default 12
|
||||
* @param string $include_time whether to include time at the beginning of the nonce. default true
|
||||
* @return void value is stored to the config array class variable
|
||||
*/
|
||||
private function create_nonce($length=12, $include_time=true) {
|
||||
if ($this->config['force_nonce'] == false) {
|
||||
$sequence = array_merge(range(0,9), range('A','Z'), range('a','z'));
|
||||
$length = $length > count($sequence) ? count($sequence) : $length;
|
||||
shuffle($sequence);
|
||||
|
||||
$prefix = $include_time ? microtime() : '';
|
||||
$this->config['nonce'] = md5(substr($prefix . implode('', $sequence), 0, $length));
|
||||
}
|
||||
}
|
||||
|
||||
/**
|
||||
* Generates a timestamp.
|
||||
* If 'force_timestamp' is true a nonce is not generated and the value in the configuration will be retained.
|
||||
*
|
||||
* @return void value is stored to the config array class variable
|
||||
*/
|
||||
private function create_timestamp() {
|
||||
$this->config['timestamp'] = ($this->config['force_timestamp'] == false ? time() : $this->config['timestamp']);
|
||||
}
|
||||
|
||||
/**
|
||||
* Encodes the string or array passed in a way compatible with OAuth.
|
||||
* If an array is passed each array value will will be encoded.
|
||||
*
|
||||
* @param mixed $data the scalar or array to encode
|
||||
* @return $data encoded in a way compatible with OAuth
|
||||
*/
|
||||
private function safe_encode($data) {
|
||||
if (is_array($data)) {
|
||||
return array_map(array($this, 'safe_encode'), $data);
|
||||
} else if (is_scalar($data)) {
|
||||
return str_ireplace(
|
||||
array('+', '%7E'),
|
||||
array(' ', '~'),
|
||||
rawurlencode($data)
|
||||
);
|
||||
} else {
|
||||
return '';
|
||||
}
|
||||
}
|
||||
|
||||
/**
|
||||
* Decodes the string or array from it's URL encoded form
|
||||
* If an array is passed each array value will will be decoded.
|
||||
*
|
||||
* @param mixed $data the scalar or array to decode
|
||||
* @return string $data decoded from the URL encoded form
|
||||
*/
|
||||
private function safe_decode($data) {
|
||||
if (is_array($data)) {
|
||||
return array_map(array($this, 'safe_decode'), $data);
|
||||
} else if (is_scalar($data)) {
|
||||
return rawurldecode($data);
|
||||
} else {
|
||||
return '';
|
||||
}
|
||||
}
|
||||
|
||||
/**
|
||||
* Returns an array of the standard OAuth parameters.
|
||||
*
|
||||
* @return array all required OAuth parameters, safely encoded
|
||||
*/
|
||||
private function get_defaults() {
|
||||
$defaults = array(
|
||||
'oauth_version' => $this->config['oauth_version'],
|
||||
'oauth_nonce' => $this->config['nonce'],
|
||||
'oauth_timestamp' => $this->config['timestamp'],
|
||||
'oauth_consumer_key' => $this->config['consumer_key'],
|
||||
'oauth_signature_method' => $this->config['oauth_signature_method'],
|
||||
);
|
||||
|
||||
// include the user token if it exists
|
||||
if ( $this->config['user_token'] )
|
||||
$defaults['oauth_token'] = $this->config['user_token'];
|
||||
|
||||
// safely encode
|
||||
foreach ($defaults as $k => $v) {
|
||||
$_defaults[$this->safe_encode($k)] = $this->safe_encode($v);
|
||||
}
|
||||
|
||||
return $_defaults;
|
||||
}
|
||||
|
||||
/**
|
||||
* Extracts and decodes OAuth parameters from the passed string
|
||||
*
|
||||
* @param string $body the response body from an OAuth flow method
|
||||
* @return array the response body safely decoded to an array of key => values
|
||||
*/
|
||||
public function extract_params($body) {
|
||||
$kvs = explode('&', $body);
|
||||
$decoded = array();
|
||||
foreach ($kvs as $kv) {
|
||||
$kv = explode('=', $kv, 2);
|
||||
$kv[0] = $this->safe_decode($kv[0]);
|
||||
$kv[1] = $this->safe_decode($kv[1]);
|
||||
$decoded[$kv[0]] = $kv[1];
|
||||
}
|
||||
return $decoded;
|
||||
}
|
||||
|
||||
/**
|
||||
* Prepares the HTTP method for use in the base string by converting it to
|
||||
* uppercase.
|
||||
*
|
||||
* @param string $method an HTTP method such as GET or POST
|
||||
* @return void value is stored to the class variable 'method'
|
||||
*/
|
||||
private function prepare_method($method) {
|
||||
$this->method = strtoupper($method);
|
||||
}
|
||||
|
||||
/**
|
||||
* Prepares the URL for use in the base string by ripping it apart and
|
||||
* reconstructing it.
|
||||
*
|
||||
* Ref: 3.4.1.2
|
||||
*
|
||||
* @param string $url the request URL
|
||||
* @return void value is stored to the class variable 'url'
|
||||
*/
|
||||
private function prepare_url($url) {
|
||||
$parts = parse_url($url);
|
||||
|
||||
$port = isset($parts['port']) ? $parts['port'] : false;
|
||||
$scheme = $parts['scheme'];
|
||||
$host = $parts['host'];
|
||||
$path = isset($parts['path']) ? $parts['path'] : false;
|
||||
|
||||
$port or $port = ($scheme == 'https') ? '443' : '80';
|
||||
|
||||
if (($scheme == 'https' && $port != '443')
|
||||
|| ($scheme == 'http' && $port != '80')) {
|
||||
$host = "$host:$port";
|
||||
}
|
||||
|
||||
// the scheme and host MUST be lowercase
|
||||
$this->url = strtolower("$scheme://$host");
|
||||
// but not the path
|
||||
$this->url .= $path;
|
||||
}
|
||||
|
||||
/**
|
||||
* Prepares all parameters for the base string and request.
|
||||
* Multipart parameters are ignored as they are not defined in the specification,
|
||||
* all other types of parameter are encoded for compatibility with OAuth.
|
||||
*
|
||||
* @param array $params the parameters for the request
|
||||
* @return void prepared values are stored in the class variable 'signing_params'
|
||||
*/
|
||||
private function prepare_params($params) {
|
||||
// do not encode multipart parameters, leave them alone
|
||||
if ($this->config['multipart']) {
|
||||
$this->request_params = $params;
|
||||
$params = array();
|
||||
}
|
||||
|
||||
// signing parameters are request parameters + OAuth default parameters
|
||||
$this->signing_params = array_merge($this->get_defaults(), (array)$params);
|
||||
|
||||
// Remove oauth_signature if present
|
||||
// Ref: Spec: 9.1.1 ("The oauth_signature parameter MUST be excluded.")
|
||||
if (isset($this->signing_params['oauth_signature'])) {
|
||||
unset($this->signing_params['oauth_signature']);
|
||||
}
|
||||
|
||||
// Parameters are sorted by name, using lexicographical byte value ordering.
|
||||
// Ref: Spec: 9.1.1 (1)
|
||||
uksort($this->signing_params, 'strcmp');
|
||||
|
||||
// encode. Also sort the signed parameters from the POST parameters
|
||||
foreach ($this->signing_params as $k => $v) {
|
||||
$k = $this->safe_encode($k);
|
||||
|
||||
if (is_array($v))
|
||||
$v = implode(',', $v);
|
||||
|
||||
$v = $this->safe_encode($v);
|
||||
$_signing_params[$k] = $v;
|
||||
$kv[] = "{$k}={$v}";
|
||||
}
|
||||
|
||||
// auth params = the default oauth params which are present in our collection of signing params
|
||||
$this->auth_params = array_intersect_key($this->get_defaults(), $_signing_params);
|
||||
if (isset($_signing_params['oauth_callback'])) {
|
||||
$this->auth_params['oauth_callback'] = $_signing_params['oauth_callback'];
|
||||
unset($_signing_params['oauth_callback']);
|
||||
}
|
||||
|
||||
if (isset($_signing_params['oauth_verifier'])) {
|
||||
$this->auth_params['oauth_verifier'] = $_signing_params['oauth_verifier'];
|
||||
unset($_signing_params['oauth_verifier']);
|
||||
}
|
||||
|
||||
// request_params is already set if we're doing multipart, if not we need to set them now
|
||||
if ( ! $this->config['multipart'])
|
||||
$this->request_params = array_diff_key($_signing_params, $this->get_defaults());
|
||||
|
||||
// create the parameter part of the base string
|
||||
$this->signing_params = implode('&', $kv);
|
||||
}
|
||||
|
||||
/**
|
||||
* Prepares the OAuth signing key
|
||||
*
|
||||
* @return void prepared signing key is stored in the class variable 'signing_key'
|
||||
*/
|
||||
private function prepare_signing_key() {
|
||||
$this->signing_key = $this->safe_encode($this->config['consumer_secret']) . '&' . $this->safe_encode($this->config['user_secret']);
|
||||
}
|
||||
|
||||
/**
|
||||
* Prepare the base string.
|
||||
* Ref: Spec: 9.1.3 ("Concatenate Request Elements")
|
||||
*
|
||||
* @return void prepared base string is stored in the class variable 'base_string'
|
||||
*/
|
||||
private function prepare_base_string() {
|
||||
$url = $this->url;
|
||||
|
||||
# if the host header is set we need to rewrite the basestring to use
|
||||
# that, instead of the request host. otherwise the signature won't match
|
||||
# on the server side
|
||||
if (!empty($this->custom_headers['Host'])) {
|
||||
$url = str_ireplace(
|
||||
$this->config['host'],
|
||||
$this->custom_headers['Host'],
|
||||
$url
|
||||
);
|
||||
}
|
||||
|
||||
$base = array(
|
||||
$this->method,
|
||||
$url,
|
||||
$this->signing_params
|
||||
);
|
||||
$this->base_string = implode('&', $this->safe_encode($base));
|
||||
}
|
||||
|
||||
/**
|
||||
* Prepares the Authorization header
|
||||
*
|
||||
* @return void prepared authorization header is stored in the class variable headers['Authorization']
|
||||
*/
|
||||
private function prepare_auth_header() {
|
||||
unset($this->headers['Authorization']);
|
||||
|
||||
uksort($this->auth_params, 'strcmp');
|
||||
if (!$this->config['as_header']) :
|
||||
$this->request_params = array_merge($this->request_params, $this->auth_params);
|
||||
return;
|
||||
endif;
|
||||
|
||||
foreach ($this->auth_params as $k => $v) {
|
||||
$kv[] = "{$k}=\"{$v}\"";
|
||||
}
|
||||
$this->auth_header = 'OAuth ' . implode(', ', $kv);
|
||||
$this->headers['Authorization'] = $this->auth_header;
|
||||
}
|
||||
|
||||
/**
|
||||
* Signs the request and adds the OAuth signature. This runs all the request
|
||||
* parameter preparation methods.
|
||||
*
|
||||
* @param string $method the HTTP method being used. e.g. POST, GET, HEAD etc
|
||||
* @param string $url the request URL without query string parameters
|
||||
* @param array $params the request parameters as an array of key=value pairs
|
||||
* @param string $useauth whether to use authentication when making the request.
|
||||
* @return void
|
||||
*/
|
||||
private function sign($method, $url, $params, $useauth) {
|
||||
$this->prepare_method($method);
|
||||
$this->prepare_url($url);
|
||||
$this->prepare_params($params);
|
||||
|
||||
// we don't sign anything is we're not using auth
|
||||
if ($useauth) {
|
||||
$this->prepare_base_string();
|
||||
$this->prepare_signing_key();
|
||||
|
||||
$this->auth_params['oauth_signature'] = $this->safe_encode(
|
||||
base64_encode(
|
||||
hash_hmac(
|
||||
'sha1', $this->base_string, $this->signing_key, true
|
||||
)));
|
||||
|
||||
$this->prepare_auth_header();
|
||||
}
|
||||
}
|
||||
|
||||
/**
|
||||
* Make an HTTP request using this library. This method doesn't return anything.
|
||||
* Instead the response should be inspected directly.
|
||||
*
|
||||
* @param string $method the HTTP method being used. e.g. POST, GET, HEAD etc
|
||||
* @param string $url the request URL without query string parameters
|
||||
* @param array $params the request parameters as an array of key=value pairs. Default empty array
|
||||
* @param string $useauth whether to use authentication when making the request. Default true
|
||||
* @param string $multipart whether this request contains multipart data. Default false
|
||||
* @param array $headers any custom headers to send with the request. Default empty array
|
||||
* @return int the http response code for the request. 0 is returned if a connection could not be made
|
||||
*/
|
||||
public function request($method, $url, $params=array(), $useauth=true, $multipart=false, $headers=array()) {
|
||||
// reset the request headers (we don't want to reuse them)
|
||||
$this->headers = array();
|
||||
$this->custom_headers = $headers;
|
||||
|
||||
$this->config['multipart'] = $multipart;
|
||||
|
||||
$this->create_nonce();
|
||||
$this->create_timestamp();
|
||||
|
||||
$this->sign($method, $url, $params, $useauth);
|
||||
|
||||
if (!empty($this->custom_headers))
|
||||
$this->headers = array_merge((array)$this->headers, (array)$this->custom_headers);
|
||||
|
||||
return $this->curlit();
|
||||
}
|
||||
|
||||
/**
|
||||
* Make a long poll HTTP request using this library. This method is
|
||||
* different to the other request methods as it isn't supposed to disconnect
|
||||
*
|
||||
* Using this method expects a callback which will receive the streaming
|
||||
* responses.
|
||||
*
|
||||
* @param string $method the HTTP method being used. e.g. POST, GET, HEAD etc
|
||||
* @param string $url the request URL without query string parameters
|
||||
* @param array $params the request parameters as an array of key=value pairs
|
||||
* @param string $callback the callback function to stream the buffer to.
|
||||
* @return void
|
||||
*/
|
||||
public function streaming_request($method, $url, $params=array(), $callback='') {
|
||||
if ( ! empty($callback) ) {
|
||||
if ( ! is_callable($callback) ) {
|
||||
return false;
|
||||
}
|
||||
$this->config['streaming_callback'] = $callback;
|
||||
}
|
||||
$this->metrics['start'] = time();
|
||||
$this->metrics['interval_start'] = $this->metrics['start'];
|
||||
$this->metrics['tweets'] = 0;
|
||||
$this->metrics['last_tweets'] = 0;
|
||||
$this->metrics['bytes'] = 0;
|
||||
$this->metrics['last_bytes'] = 0;
|
||||
$this->config['is_streaming'] = true;
|
||||
$this->request($method, $url, $params);
|
||||
}
|
||||
|
||||
/**
|
||||
* Handles the updating of the current Streaming API metrics.
|
||||
*
|
||||
* @return array the metrics for the streaming api connection
|
||||
*/
|
||||
private function update_metrics() {
|
||||
$now = time();
|
||||
if (($this->metrics['interval_start'] + $this->config['streaming_metrics_interval']) > $now)
|
||||
return false;
|
||||
|
||||
$this->metrics['tps'] = round( ($this->metrics['tweets'] - $this->metrics['last_tweets']) / $this->config['streaming_metrics_interval'], 2);
|
||||
$this->metrics['bps'] = round( ($this->metrics['bytes'] - $this->metrics['last_bytes']) / $this->config['streaming_metrics_interval'], 2);
|
||||
|
||||
$this->metrics['last_bytes'] = $this->metrics['bytes'];
|
||||
$this->metrics['last_tweets'] = $this->metrics['tweets'];
|
||||
$this->metrics['interval_start'] = $now;
|
||||
return $this->metrics;
|
||||
}
|
||||
|
||||
/**
|
||||
* Utility function to create the request URL in the requested format
|
||||
*
|
||||
* @param string $request the API method without extension
|
||||
* @param string $format the format of the response. Default json. Set to an empty string to exclude the format
|
||||
* @return string the concatenation of the host, API version, API method and format
|
||||
*/
|
||||
public function url($request, $format='json') {
|
||||
$format = strlen($format) > 0 ? ".$format" : '';
|
||||
$proto = $this->config['use_ssl'] ? 'https:/' : 'http:/';
|
||||
|
||||
// backwards compatibility with v0.1
|
||||
if (isset($this->config['v']))
|
||||
$this->config['host'] = $this->config['host'] . '/' . $this->config['v'];
|
||||
|
||||
$request = ltrim($request, '/');
|
||||
|
||||
$pos = strlen($request) - strlen($format);
|
||||
if (substr($request, $pos) === $format)
|
||||
$request = substr_replace($request, '', $pos);
|
||||
|
||||
return implode('/', array(
|
||||
$proto,
|
||||
$this->config['host'],
|
||||
$request . $format
|
||||
));
|
||||
}
|
||||
|
||||
/**
|
||||
* Public access to the private safe decode/encode methods
|
||||
*
|
||||
* @param string $text the text to transform
|
||||
* @param string $mode the transformation mode. either encode or decode
|
||||
* @return string $text transformed by the given $mode
|
||||
*/
|
||||
public function transformText($text, $mode='encode') {
|
||||
return $this->{"safe_$mode"}($text);
|
||||
}
|
||||
|
||||
/**
|
||||
* Utility function to parse the returned curl headers and store them in the
|
||||
* class array variable.
|
||||
*
|
||||
* @param object $ch curl handle
|
||||
* @param string $header the response headers
|
||||
* @return string the length of the header
|
||||
*/
|
||||
private function curlHeader($ch, $header) {
|
||||
$this->response['raw'] .= $header;
|
||||
|
||||
list($key, $value) = array_pad(explode(':', $header, 2), 2, null);
|
||||
|
||||
$key = trim($key);
|
||||
$value = trim($value);
|
||||
|
||||
if ( ! isset($this->response['headers'][$key])) {
|
||||
$this->response['headers'][$key] = $value;
|
||||
} else {
|
||||
if (!is_array($this->response['headers'][$key])) {
|
||||
$this->response['headers'][$key] = array($this->response['headers'][$key]);
|
||||
}
|
||||
$this->response['headers'][$key][] = $value;
|
||||
}
|
||||
|
||||
return strlen($header);
|
||||
}
|
||||
|
||||
/**
|
||||
* Utility function to parse the returned curl buffer and store them until
|
||||
* an EOL is found. The buffer for curl is an undefined size so we need
|
||||
* to collect the content until an EOL is found.
|
||||
*
|
||||
* This function calls the previously defined streaming callback method.
|
||||
*
|
||||
* @param object $ch curl handle
|
||||
* @param string $data the current curl buffer
|
||||
* @return int the length of the data string processed in this function
|
||||
*/
|
||||
private function curlWrite($ch, $data) {
|
||||
$l = strlen($data);
|
||||
if (strpos($data, $this->config['streaming_eol']) === false) {
|
||||
$this->buffer .= $data;
|
||||
return $l;
|
||||
}
|
||||
|
||||
$buffered = explode($this->config['streaming_eol'], $data);
|
||||
$content = $this->buffer . $buffered[0];
|
||||
|
||||
$this->metrics['tweets']++;
|
||||
$this->metrics['bytes'] += strlen($content);
|
||||
|
||||
if ( ! is_callable($this->config['streaming_callback']))
|
||||
return 0;
|
||||
|
||||
$metrics = $this->update_metrics();
|
||||
$stop = call_user_func(
|
||||
$this->config['streaming_callback'],
|
||||
$content,
|
||||
strlen($content),
|
||||
$metrics
|
||||
);
|
||||
$this->buffer = $buffered[1];
|
||||
if ($stop)
|
||||
return 0;
|
||||
|
||||
return $l;
|
||||
}
|
||||
|
||||
/**
|
||||
* Makes a curl request. Takes no parameters as all should have been prepared
|
||||
* by the request method
|
||||
*
|
||||
* the response data is stored in the class variable 'response'
|
||||
*
|
||||
* @return int the http response code for the request. 0 is returned if a connection could not be made
|
||||
*/
|
||||
private function curlit() {
|
||||
$this->response['raw'] = '';
|
||||
|
||||
// method handling
|
||||
switch ($this->method) {
|
||||
case 'POST':
|
||||
break;
|
||||
default:
|
||||
// GET, DELETE request so convert the parameters to a querystring
|
||||
if ( ! empty($this->request_params)) {
|
||||
foreach ($this->request_params as $k => $v) {
|
||||
// Multipart params haven't been encoded yet.
|
||||
// Not sure why you would do a multipart GET but anyway, here's the support for it
|
||||
if ($this->config['multipart']) {
|
||||
$params[] = $this->safe_encode($k) . '=' . $this->safe_encode($v);
|
||||
} else {
|
||||
$params[] = $k . '=' . $v;
|
||||
}
|
||||
}
|
||||
$qs = implode('&', $params);
|
||||
$this->url = strlen($qs) > 0 ? $this->url . '?' . $qs : $this->url;
|
||||
$this->request_params = array();
|
||||
}
|
||||
break;
|
||||
}
|
||||
|
||||
|
||||
// configure curl
|
||||
$c = curl_init();
|
||||
curl_setopt_array($c, array(
|
||||
CURLOPT_USERAGENT => $this->config['user_agent'],
|
||||
CURLOPT_CONNECTTIMEOUT => $this->config['curl_connecttimeout'],
|
||||
CURLOPT_TIMEOUT => $this->config['curl_timeout'],
|
||||
CURLOPT_RETURNTRANSFER => true,
|
||||
CURLOPT_SSL_VERIFYPEER => $this->config['curl_ssl_verifypeer'],
|
||||
CURLOPT_SSL_VERIFYHOST => $this->config['curl_ssl_verifyhost'],
|
||||
|
||||
CURLOPT_FOLLOWLOCATION => $this->config['curl_followlocation'],
|
||||
CURLOPT_PROXY => $this->config['curl_proxy'],
|
||||
CURLOPT_ENCODING => $this->config['curl_encoding'],
|
||||
CURLOPT_URL => $this->url,
|
||||
// process the headers
|
||||
CURLOPT_HEADERFUNCTION => array($this, 'curlHeader'),
|
||||
CURLOPT_HEADER => false,
|
||||
CURLINFO_HEADER_OUT => true,
|
||||
));
|
||||
|
||||
if ($this->config['curl_cainfo'] !== false)
|
||||
curl_setopt($c, CURLOPT_CAINFO, $this->config['curl_cainfo']);
|
||||
|
||||
if ($this->config['curl_capath'] !== false)
|
||||
curl_setopt($c, CURLOPT_CAPATH, $this->config['curl_capath']);
|
||||
|
||||
if ($this->config['curl_proxyuserpwd'] !== false)
|
||||
curl_setopt($c, CURLOPT_PROXYUSERPWD, $this->config['curl_proxyuserpwd']);
|
||||
|
||||
if ($this->config['is_streaming']) {
|
||||
// process the body
|
||||
$this->response['content-length'] = 0;
|
||||
curl_setopt($c, CURLOPT_TIMEOUT, 0);
|
||||
curl_setopt($c, CURLOPT_WRITEFUNCTION, array($this, 'curlWrite'));
|
||||
}
|
||||
|
||||
switch ($this->method) {
|
||||
case 'GET':
|
||||
break;
|
||||
case 'POST':
|
||||
curl_setopt($c, CURLOPT_POST, true);
|
||||
curl_setopt($c, CURLOPT_POSTFIELDS, $this->request_params);
|
||||
break;
|
||||
default:
|
||||
curl_setopt($c, CURLOPT_CUSTOMREQUEST, $this->method);
|
||||
}
|
||||
|
||||
if ( ! empty($this->request_params) ) {
|
||||
// if not doing multipart we need to implode the parameters
|
||||
if ( ! $this->config['multipart'] ) {
|
||||
foreach ($this->request_params as $k => $v) {
|
||||
$ps[] = "{$k}={$v}";
|
||||
}
|
||||
$this->request_params = implode('&', $ps);
|
||||
}
|
||||
curl_setopt($c, CURLOPT_POSTFIELDS, $this->request_params);
|
||||
}
|
||||
|
||||
if ( ! empty($this->headers)) {
|
||||
foreach ($this->headers as $k => $v) {
|
||||
$headers[] = trim($k . ': ' . $v);
|
||||
}
|
||||
curl_setopt($c, CURLOPT_HTTPHEADER, $headers);
|
||||
}
|
||||
|
||||
if (isset($this->config['prevent_request']) && (true == $this->config['prevent_request']))
|
||||
return 0;
|
||||
|
||||
// do it!
|
||||
$response = curl_exec($c);
|
||||
$code = curl_getinfo($c, CURLINFO_HTTP_CODE);
|
||||
$info = curl_getinfo($c);
|
||||
$error = curl_error($c);
|
||||
$errno = curl_errno($c);
|
||||
curl_close($c);
|
||||
|
||||
// store the response
|
||||
$this->response['code'] = $code;
|
||||
$this->response['response'] = $response;
|
||||
$this->response['info'] = $info;
|
||||
$this->response['error'] = $error;
|
||||
$this->response['errno'] = $errno;
|
||||
|
||||
if (!isset($this->response['raw'])) {
|
||||
$this->response['raw'] = '';
|
||||
}
|
||||
$this->response['raw'] .= $response;
|
||||
|
||||
return $code;
|
||||
}
|
||||
}
|
||||
@@ -0,0 +1,280 @@
|
||||
<?php
|
||||
/**
|
||||
* tmhUtilities
|
||||
*
|
||||
* Helpful utility and Twitter formatting functions
|
||||
*
|
||||
* @author themattharris
|
||||
* @version 0.5.0
|
||||
*
|
||||
* 04 September 2012
|
||||
*/
|
||||
class tmhUtilities {
|
||||
const VERSION = '0.5.0';
|
||||
/**
|
||||
* Entifies the tweet using the given entities element.
|
||||
* Deprecated.
|
||||
* You should instead use entify_with_options.
|
||||
*
|
||||
* @param array $tweet the json converted to normalised array
|
||||
* @param array $replacements if specified, the entities and their replacements will be stored to this variable
|
||||
* @return the tweet text with entities replaced with hyperlinks
|
||||
*/
|
||||
public static function entify($tweet, &$replacements=array()) {
|
||||
return tmhUtilities::entify_with_options($tweet, array(), $replacements);
|
||||
}
|
||||
|
||||
/**
|
||||
* Entifies the tweet using the given entities element, using the provided
|
||||
* options.
|
||||
*
|
||||
* @param array $tweet the json converted to normalised array
|
||||
* @param array $options settings to be used when rendering the entities
|
||||
* @param array $replacements if specified, the entities and their replacements will be stored to this variable
|
||||
* @return the tweet text with entities replaced with hyperlinks
|
||||
*/
|
||||
public static function entify_with_options($tweet, $options=array(), &$replacements=array()) {
|
||||
$default_opts = array(
|
||||
'encoding' => 'UTF-8',
|
||||
'target' => '',
|
||||
);
|
||||
|
||||
$opts = array_merge($default_opts, $options);
|
||||
|
||||
$encoding = mb_internal_encoding();
|
||||
mb_internal_encoding($opts['encoding']);
|
||||
|
||||
$keys = array();
|
||||
$is_retweet = false;
|
||||
|
||||
if (isset($tweet['retweeted_status'])) {
|
||||
$tweet = $tweet['retweeted_status'];
|
||||
$is_retweet = true;
|
||||
}
|
||||
|
||||
if (!isset($tweet['entities'])) {
|
||||
return $tweet['text'];
|
||||
}
|
||||
|
||||
$target = (!empty($opts['target'])) ? ' target="'.$opts['target'].'"' : '';
|
||||
|
||||
// prepare the entities
|
||||
foreach ($tweet['entities'] as $type => $things) {
|
||||
foreach ($things as $entity => $value) {
|
||||
$tweet_link = "<a href=\"https://twitter.com/{$tweet['user']['screen_name']}/statuses/{$tweet['id']}\"{$target}>{$tweet['created_at']}</a>";
|
||||
|
||||
switch ($type) {
|
||||
case 'hashtags':
|
||||
$href = "<a href=\"https://twitter.com/search?q=%23{$value['text']}\"{$target}>#{$value['text']}</a>";
|
||||
break;
|
||||
case 'user_mentions':
|
||||
$href = "@<a href=\"https://twitter.com/{$value['screen_name']}\" title=\"{$value['name']}\"{$target}>{$value['screen_name']}</a>";
|
||||
break;
|
||||
case 'urls':
|
||||
case 'media':
|
||||
$url = empty($value['expanded_url']) ? $value['url'] : $value['expanded_url'];
|
||||
$display = isset($value['display_url']) ? $value['display_url'] : str_replace('http://', '', $url);
|
||||
// Not all pages are served in UTF-8 so you may need to do this ...
|
||||
$display = urldecode(str_replace('%E2%80%A6', '…', urlencode($display)));
|
||||
$href = "<a href=\"{$value['url']}\"{$target}>{$display}</a>";
|
||||
break;
|
||||
}
|
||||
$keys[$value['indices']['0']] = mb_substr(
|
||||
$tweet['text'],
|
||||
$value['indices']['0'],
|
||||
$value['indices']['1'] - $value['indices']['0']
|
||||
);
|
||||
$replacements[$value['indices']['0']] = $href;
|
||||
}
|
||||
}
|
||||
|
||||
ksort($replacements);
|
||||
$replacements = array_reverse($replacements, true);
|
||||
$entified_tweet = $tweet['text'];
|
||||
foreach ($replacements as $k => $v) {
|
||||
$entified_tweet = mb_substr($entified_tweet, 0, $k).$v.mb_substr($entified_tweet, $k + strlen($keys[$k]));
|
||||
}
|
||||
$replacements = array(
|
||||
'replacements' => $replacements,
|
||||
'keys' => $keys
|
||||
);
|
||||
|
||||
mb_internal_encoding($encoding);
|
||||
return $entified_tweet;
|
||||
}
|
||||
|
||||
/**
|
||||
* Returns the current URL. This is instead of PHP_SELF which is unsafe
|
||||
*
|
||||
* @param bool $dropqs whether to drop the querystring or not. Default true
|
||||
* @return string the current URL
|
||||
*/
|
||||
public static function php_self($dropqs=true) {
|
||||
$protocol = 'http';
|
||||
if (isset($_SERVER['HTTPS']) && strtolower($_SERVER['HTTPS']) == 'on') {
|
||||
$protocol = 'https';
|
||||
} elseif (isset($_SERVER['SERVER_PORT']) && ($_SERVER['SERVER_PORT'] == '443')) {
|
||||
$protocol = 'https';
|
||||
}
|
||||
|
||||
$url = sprintf('%s://%s%s',
|
||||
$protocol,
|
||||
$_SERVER['SERVER_NAME'],
|
||||
$_SERVER['REQUEST_URI']
|
||||
);
|
||||
|
||||
$parts = parse_url($url);
|
||||
|
||||
$port = $_SERVER['SERVER_PORT'];
|
||||
$scheme = $parts['scheme'];
|
||||
$host = $parts['host'];
|
||||
$path = @$parts['path'];
|
||||
$qs = @$parts['query'];
|
||||
|
||||
$port or $port = ($scheme == 'https') ? '443' : '80';
|
||||
|
||||
if (($scheme == 'https' && $port != '443')
|
||||
|| ($scheme == 'http' && $port != '80')) {
|
||||
$host = "$host:$port";
|
||||
}
|
||||
$url = "$scheme://$host$path";
|
||||
if ( ! $dropqs)
|
||||
return "{$url}?{$qs}";
|
||||
else
|
||||
return $url;
|
||||
}
|
||||
|
||||
public static function is_cli() {
|
||||
return (PHP_SAPI == 'cli' && empty($_SERVER['REMOTE_ADDR']));
|
||||
}
|
||||
|
||||
/**
|
||||
* Debug function for printing the content of an object
|
||||
*
|
||||
* @param mixes $obj
|
||||
*/
|
||||
public static function pr($obj) {
|
||||
|
||||
if (!self::is_cli())
|
||||
echo '<pre style="word-wrap: break-word">';
|
||||
if ( is_object($obj) )
|
||||
print_r($obj);
|
||||
elseif ( is_array($obj) )
|
||||
print_r($obj);
|
||||
else
|
||||
echo $obj;
|
||||
if (!self::is_cli())
|
||||
echo '</pre>';
|
||||
}
|
||||
|
||||
/**
|
||||
* Make an HTTP request using this library. This method is different to 'request'
|
||||
* because on a 401 error it will retry the request.
|
||||
*
|
||||
* When a 401 error is returned it is possible the timestamp of the client is
|
||||
* too different to that of the API server. In this situation it is recommended
|
||||
* the request is retried with the OAuth timestamp set to the same as the API
|
||||
* server. This method will automatically try that technique.
|
||||
*
|
||||
* This method doesn't return anything. Instead the response should be
|
||||
* inspected directly.
|
||||
*
|
||||
* @param string $method the HTTP method being used. e.g. POST, GET, HEAD etc
|
||||
* @param string $url the request URL without query string parameters
|
||||
* @param array $params the request parameters as an array of key=value pairs
|
||||
* @param string $useauth whether to use authentication when making the request. Default true.
|
||||
* @param string $multipart whether this request contains multipart data. Default false
|
||||
*/
|
||||
public static function auto_fix_time_request($tmhOAuth, $method, $url, $params=array(), $useauth=true, $multipart=false) {
|
||||
$tmhOAuth->request($method, $url, $params, $useauth, $multipart);
|
||||
|
||||
// if we're not doing auth the timestamp isn't important
|
||||
if ( ! $useauth)
|
||||
return;
|
||||
|
||||
// some error that isn't a 401
|
||||
if ($tmhOAuth->response['code'] != 401)
|
||||
return;
|
||||
|
||||
// some error that is a 401 but isn't because the OAuth token and signature are incorrect
|
||||
// TODO: this check is horrid but helps avoid requesting twice when the username and password are wrong
|
||||
if (stripos($tmhOAuth->response['response'], 'password') !== false)
|
||||
return;
|
||||
|
||||
// force the timestamp to be the same as the Twitter servers, and re-request
|
||||
$tmhOAuth->auto_fixed_time = true;
|
||||
$tmhOAuth->config['force_timestamp'] = true;
|
||||
$tmhOAuth->config['timestamp'] = strtotime($tmhOAuth->response['headers']['date']);
|
||||
return $tmhOAuth->request($method, $url, $params, $useauth, $multipart);
|
||||
}
|
||||
|
||||
/**
|
||||
* Asks the user for input and returns the line they enter
|
||||
*
|
||||
* @param string $prompt the text to display to the user
|
||||
* @return the text entered by the user
|
||||
*/
|
||||
public static function read_input($prompt) {
|
||||
echo $prompt;
|
||||
$handle = fopen("php://stdin","r");
|
||||
$data = fgets($handle);
|
||||
return trim($data);
|
||||
}
|
||||
|
||||
/**
|
||||
* Get a password from the shell.
|
||||
*
|
||||
* This function works on *nix systems only and requires shell_exec and stty.
|
||||
*
|
||||
* @param boolean $stars Wether or not to output stars for given characters
|
||||
* @return string
|
||||
* @url http://www.dasprids.de/blog/2008/08/22/getting-a-password-hidden-from-stdin-with-php-cli
|
||||
*/
|
||||
public static function read_password($prompt, $stars=false) {
|
||||
echo $prompt;
|
||||
$style = shell_exec('stty -g');
|
||||
|
||||
if ($stars === false) {
|
||||
shell_exec('stty -echo');
|
||||
$password = rtrim(fgets(STDIN), "\n");
|
||||
} else {
|
||||
shell_exec('stty -icanon -echo min 1 time 0');
|
||||
$password = '';
|
||||
while (true) :
|
||||
$char = fgetc(STDIN);
|
||||
if ($char === "\n") :
|
||||
break;
|
||||
elseif (ord($char) === 127) :
|
||||
if (strlen($password) > 0) {
|
||||
fwrite(STDOUT, "\x08 \x08");
|
||||
$password = substr($password, 0, -1);
|
||||
}
|
||||
else
|
||||
fwrite(STDOUT, "*");
|
||||
$password .= $char;
|
||||
endif;
|
||||
endwhile;
|
||||
}
|
||||
|
||||
// Reset
|
||||
shell_exec('stty ' . $style);
|
||||
echo PHP_EOL;
|
||||
return $password;
|
||||
}
|
||||
|
||||
/**
|
||||
* Check if one string ends with another
|
||||
*
|
||||
* @param string $haystack the string to check inside of
|
||||
* @param string $needle the string to check $haystack ends with
|
||||
* @return true if $haystack ends with $needle, false otherwise
|
||||
*/
|
||||
public static function endswith($haystack, $needle) {
|
||||
$haylen = strlen($haystack);
|
||||
$needlelen = strlen($needle);
|
||||
if ($needlelen > $haylen)
|
||||
return false;
|
||||
|
||||
return substr_compare($haystack, $needle, -$needlelen) === 0;
|
||||
}
|
||||
}
|
||||
Reference in New Issue
Block a user