{

/**

private static $_instance = null;

/**

protected static $_oauth_consumer_key = null;

/**

protected static $_oauth_consumer_secret = null;

/**

protected static $_oauth_bearer_token = null;

/**

protected static $_endpoint = 'https://api.twitter.com/1.1/';

/**

protected static $_endpoint_media = 'https://upload.twitter.com/1.1/';

/**

protected static $_endpoints_streaming = [

'public' => 'https://stream.twitter.com/1.1/',

'user' => 'https://userstream.twitter.com/1.1/',

'site' => 'https://sitestream.twitter.com/1.1/'

];

/**

protected static $_endpoint_oauth = 'https://api.twitter.com/';

/**

protected $_oauth_token = null;

/**

protected $_oauth_token_secret = null;

/**

protected $_return_format = CODEBIRD_RETURNFORMAT_OBJECT;

/**

protected $_supported_media_files = [IMAGETYPE_GIF, IMAGETYPE_JPEG, IMAGETYPE_PNG];

/**

protected $_streaming_callback = null;

/**

protected $_version = '3.0.0-dev';

/**

protected $_use_curl = true;

/**

protected $_timeout = 10000;

/**

protected $_connectionTimeout = 3000;

/**

protected $_remoteDownloadTimeout = 5000;

/**

protected $_proxy = [];

/**

public function __construct()

{

// Pre-define $_use_curl depending on cURL availability

$this->setUseCurl(function_exists('curl_init'));

}

/**

public static function getInstance()

{

if (self::$_instance === null) {

self::$_instance = new self;

}

return self::$_instance;

}

/**

public static function setConsumerKey($key, $secret)

{

self::$_oauth_consumer_key = $key;

self::$_oauth_consumer_secret = $secret;

}

/**

public static function setBearerToken($token)

{

self::$_oauth_bearer_token = $token;

}

/**

public function getVersion()

{

return $this->_version;

}

/**

public function setToken($token, $secret)

{

$this->_oauth_token = $token;

$this->_oauth_token_secret = $secret;

}

/**

public function logout()

{

$this->_oauth_token =

$this->_oauth_token_secret = null;

return true;

}

/**

public function setUseCurl($use_curl)

{

if ($use_curl && ! function_exists('curl_init')) {

throw new \Exception('To use cURL, the PHP curl extension must be available.');

}

$this->_use_curl = (bool) $use_curl;

}

/**

public function setTimeout($timeout)

{

$this->_timeout = (int) $timeout;

}

/**

public function setConnectionTimeout($timeout)

{

$this->_connectionTimeout = (int) $timeout;

}

/**

public function setRemoteDownloadTimeout($timeout)

{

$this->_remoteDownloadTimeout = (int) $timeout;

}

/**

public function setReturnFormat($return_format)

{

$this->_return_format = $return_format;

}

/**

public function setProxy($host, $port)

{

$this->_proxy['host'] = $host;

$this->_proxy['port'] = $port;

}

/**

public function setProxyAuthentication($authentication)

{

$this->_proxy['authentication'] = $authentication;

}

/**

public function setStreamingCallback($callback)

{

if (!is_callable($callback)) {

throw new \Exception('This is not a proper callback.');

}

$this->_streaming_callback = $callback;

}

/**

public function getApiMethods()

{

static $httpmethods = [

'GET' => [

'account/settings',

'account/verify_credentials',

'application/rate_limit_status',

'blocks/ids',

'blocks/list',

'direct_messages',

'direct_messages/sent',

'direct_messages/show',

'favorites/list',

'followers/ids',

'followers/list',

'friends/ids',

'friends/list',

'friendships/incoming',

'friendships/lookup',

'friendships/lookup',

'friendships/no_retweets/ids',

'friendships/outgoing',

'friendships/show',

'geo/id/:place_id',

'geo/reverse_geocode',

'geo/search',

'geo/similar_places',

'help/configuration',

'help/languages',

'help/privacy',

'help/tos',

'lists/list',

'lists/members',

'lists/members/show',

'lists/memberships',

'lists/ownerships',

'lists/show',

'lists/statuses',

'lists/subscribers',

'lists/subscribers/show',

'lists/subscriptions',

'mutes/users/ids',

'mutes/users/list',

'oauth/authenticate',

'oauth/authorize',

'saved_searches/list',

'saved_searches/show/:id',

'search/tweets',

'site',

'statuses/firehose',

'statuses/home_timeline',

'statuses/mentions_timeline',

'statuses/oembed',

'statuses/retweeters/ids',

'statuses/retweets/:id',

'statuses/retweets_of_me',

'statuses/sample',

'statuses/show/:id',

'statuses/user_timeline',

'trends/available',

'trends/closest',

'trends/place',

'user',

'users/contributees',

'users/contributors',

'users/profile_banner',

'users/search',

'users/show',

'users/suggestions',

'users/suggestions/:slug',

'users/suggestions/:slug/members'

],

'POST' => [

'account/remove_profile_banner',

'account/settings__post',

'account/update_delivery_device',

'account/update_profile',

'account/update_profile_background_image',

'account/update_profile_banner',

'account/update_profile_colors',

'account/update_profile_image',

'blocks/create',

'blocks/destroy',

'direct_messages/destroy',

'direct_messages/new',

'favorites/create',

'favorites/destroy',

'friendships/create',

'friendships/destroy',

'friendships/update',

'lists/create',

'lists/destroy',

'lists/members/create',

'lists/members/create_all',

'lists/members/destroy',

'lists/members/destroy_all',

'lists/subscribers/create',

'lists/subscribers/destroy',

'lists/update',

'media/upload',

'mutes/users/create',

'mutes/users/destroy',

'oauth/access_token',

'oauth/request_token',

'oauth2/invalidate_token',

'oauth2/token',

'saved_searches/create',

'saved_searches/destroy/:id',

'statuses/destroy/:id',

'statuses/filter',

'statuses/lookup',

'statuses/retweet/:id',

'statuses/update',

'statuses/update_with_media', // deprecated, use media/upload

'users/lookup',

'users/report_spam'

]

];

return $httpmethods;

}

/**

public function __call($fn, $params)

{

// parse parameters

$apiparams = $this->_parseApiParams($params);

// stringify null and boolean parameters

$apiparams = $this->_stringifyNullBoolParams($apiparams);

$app_only_auth = false;

if (count($params) > 1) {

// convert app_only_auth param to bool

$app_only_auth = !! $params[1];

}

// reset token when requesting a new token

// (causes 401 for signature error on subsequent requests)

if ($fn === 'oauth_requestToken') {

$this->setToken(null, null);

}

// map function name to API method

list($method, $method_template) = $this->_mapFnToApiMethod($fn, $apiparams);

$httpmethod = $this->_detectMethod($method_template, $apiparams);

$multipart = $this->_detectMultipart($method_template);

return $this->_callApi(

$httpmethod,

$method,

$apiparams,

$multipart,

$app_only_auth

);

}

/**

/**

protected function _parseApiParams($params)

{

$apiparams = [];

if (count($params) === 0) {

return $apiparams;

}

if (is_array($params[0])) {

// given parameters are array

$apiparams = $params[0];

return $apiparams;

}

// user gave us query-style params

parse_str($params[0], $apiparams);

if (! is_array($apiparams)) {

$apiparams = [];

}

return $apiparams;

}

/**

protected function _stringifyNullBoolParams($apiparams)

{

foreach ($apiparams as $key => $value) {

if (! is_scalar($value)) {

// no need to try replacing arrays

continue;

}

if (is_null($value)) {

$apiparams[$key] = 'null';

} elseif (is_bool($value)) {

$apiparams[$key] = $value ? 'true' : 'false';

}

}

return $apiparams;

}

/**

protected function _mapFnToApiMethod($fn, &$apiparams)

{

// replace _ by /

$method = $this->_mapFnInsertSlashes($fn);

// undo replacement for URL parameters

$method = $this->_mapFnRestoreParamUnderscores($method);

// replace AA by URL parameters

$method_template = $method;

$match = [];

if (preg_match_all('/[A-Z_]{2,}/', $method, $match)) {

foreach ($match as $param) {

$param = $param[0];

$param_l = strtolower($param);

$method_template = str_replace($param, ':' . $param_l, $method_template);

if (! isset($apiparams[$param_l])) {

for ($i = 0; $i < 26; $i++) {

$method_template = str_replace(chr(65 + $i), '_' . chr(97 + $i), $method_template);

}

throw new \Exception(

'To call the templated method "' . $method_template

. '", specify the parameter value for "' . $param_l . '".'

);

}

$method = str_replace($param, $apiparams[$param_l], $method);

unset($apiparams[$param_l]);

}

}

// replace A-Z by _a-z

for ($i = 0; $i < 26; $i++) {

$method = str_replace(chr(65 + $i), '_' . chr(97 + $i), $method);

$method_template = str_replace(chr(65 + $i), '_' . chr(97 + $i), $method_template);

}

return [$method, $method_template];

}

/**

protected function _mapFnInsertSlashes($fn)

{

$path = explode('_', $fn);

$method = implode('/', $path);

return $method;

}

/**

protected function _mapFnRestoreParamUnderscores($method)

{

$url_parameters_with_underscore = ['screen_name', 'place_id'];

foreach ($url_parameters_with_underscore as $param) {

$param = strtoupper($param);

$replacement_was = str_replace('_', '/', $param);

$method = str_replace($replacement_was, $param, $method);

}

return $method;

}

/**

/**

public function oauth_authenticate($force_login = NULL, $screen_name = NULL, $type = 'authenticate')

{

if (! in_array($type, ['authenticate', 'authorize'])) {

throw new \Exception('To get the ' . $type . ' URL, use the correct third parameter, or omit it.');

}

if ($this->_oauth_token === null) {

throw new \Exception('To get the ' . $type . ' URL, the OAuth token must be set.');

}

$url = self::$_endpoint_oauth . 'oauth/' . $type . '?oauth_token=' . $this->_url($this->_oauth_token);

if ($force_login) {

$url .= "&force_login=1";

}

if ($screen_name) {

$url .= "&screen_name=" . $screen_name;

}

return $url;

}

/**

public function oauth_authorize($force_login = NULL, $screen_name = NULL)

{

return $this->oauth_authenticate($force_login, $screen_name, 'authorize');

}

/**

public function oauth2_token()

{

if ($this->_use_curl) {

return $this->_oauth2TokenCurl();

}

return $this->_oauth2TokenNoCurl();

}

/**

protected function getCurlInitialization($url)

{

$ch = curl_init($url);

curl_setopt($ch, CURLOPT_RETURNTRANSFER, 1);

curl_setopt($ch, CURLOPT_FOLLOWLOCATION, 0);

curl_setopt($ch, CURLOPT_HEADER, 1);

curl_setopt($ch, CURLOPT_SSL_VERIFYPEER, 1);

curl_setopt($ch, CURLOPT_SSL_VERIFYHOST, 2);

curl_setopt($ch, CURLOPT_CAINFO, __DIR__ . '/cacert.pem');

curl_setopt(

$ch, CURLOPT_USERAGENT,

'codebird-php/' . $this->getVersion() . ' +https://github.com/jublonet/codebird-php'

);

if ($this->hasProxy()) {

curl_setopt($ch, CURLOPT_PROXYTYPE, CURLPROXY_HTTP);

curl_setopt($ch, CURLOPT_PROXY, $this->getProxyHost());

curl_setopt($ch, CURLOPT_PROXYPORT, $this->getProxyPort());

if ($this->hasProxyAuthentication()) {

curl_setopt($ch, CURLOPT_PROXYAUTH, CURLAUTH_BASIC);

curl_setopt($ch, CURLOPT_PROXYUSERPWD, $this->getProxyAuthentication());

}

}

return $ch;

}

/**

protected function getNoCurlInitialization($url, $contextOptions, $hostname = '')

{

$httpOptions = [];

$httpOptions['header'] = [

'User-Agent: codebird-php/' . $this->getVersion() . ' +https://github.com/jublonet/codebird-php'

];

$httpOptions['ssl'] = [

'verify_peer' => true,

'cafile' => __DIR__ . '/cacert.pem',

'verify_depth' => 5,

'peer_name' => $hostname

];

if ($this->hasProxy()) {

$httpOptions['request_fulluri'] = true;

$httpOptions['proxy'] = $this->getProxyHost() . ':' . $this->getProxyPort();

if ($this->hasProxyAuthentication()) {

$httpOptions['header'][] =

'Proxy-Authorization: Basic ' . base64_encode($this->getProxyAuthentication());

}

}

// merge the http options with the context options

$options = array_merge_recursive(

$contextOptions,

['http' => $httpOptions]

);

// concatenate $options['http']['header']

$options['http']['header'] = implode("\r\n", $options['http']['header']);

// silent the file_get_contents function

$content = @file_get_contents($url, false, stream_context_create($options));

$headers = [];

// API is responding

if (isset($http_response_header)) {

$headers = $http_response_header;

}

return [

$content,

$headers

];

}

protected function hasProxy()

{

if ($this->getProxyHost() === null) {

return false;

}

if ($this->getProxyPort() === null) {

return false;

}

return true;

}

protected function hasProxyAuthentication()

{

if ($this->getProxyAuthentication() === null) {

return false;

}

return true;

}

/**

protected function getProxyHost()

{

return $this->getProxyData('host');

}

/**

protected function getProxyPort()

{

return $this->getProxyData('port');

}

/**

protected function getProxyAuthentication()

{

return $this->getProxyData('authentication');

}

/**

private function getProxyData($name)

{

if (empty($this->_proxy[$name])) {

return null;

}

return $this->_proxy[$name];

}

/**

protected function _oauth2TokenCurl()

{

if (self::$_oauth_consumer_key === null) {

throw new \Exception('To obtain a bearer token, the consumer key must be set.');

}

$post_fields = [

'grant_type' => 'client_credentials'

];

$url = self::$_endpoint_oauth . 'oauth2/token';

$ch = $this->getCurlInitialization($url);

curl_setopt($ch, CURLOPT_POST, 1);

curl_setopt($ch, CURLOPT_POSTFIELDS, $post_fields);

curl_setopt($ch, CURLOPT_USERPWD, self::$_oauth_consumer_key . ':' . self::$_oauth_consumer_secret);

curl_setopt($ch, CURLOPT_HTTPHEADER, [

'Expect:'

]);

$result = curl_exec($ch);

// catch request errors

if ($result === false) {

throw new \Exception('Request error for bearer token: ' . curl_error($ch));

}

// certificate validation results

$validation_result = curl_errno($ch);

$this->_validateSslCertificate($validation_result);

$httpstatus = curl_getinfo($ch, CURLINFO_HTTP_CODE);

$reply = $this->_parseBearerReply($result, $httpstatus);

return $reply;

}

/**

protected function _oauth2TokenNoCurl()

{

if (self::$_oauth_consumer_key == null) {

throw new \Exception('To obtain a bearer token, the consumer key must be set.');

}

$url = self::$_endpoint_oauth . 'oauth2/token';

$hostname = parse_url($url, PHP_URL_HOST);

if ($hostname === false) {

throw new \Exception('Incorrect API endpoint host.');

}

$contextOptions = [

'http' => [

'method' => 'POST',

'protocol_version' => '1.1',

'header' => "Accept: */*\r\n"

. 'Authorization: Basic '

. base64_encode(

self::$_oauth_consumer_key

. ':'

. self::$_oauth_consumer_secret

),

'timeout' => $this->_timeout / 1000,

'content' => 'grant_type=client_credentials',

'ignore_errors' => true

]

];

list($reply, $headers) = $this->getNoCurlInitialization($url, $contextOptions, $hostname);

$result = '';

foreach ($headers as $header) {

$result .= $header . "\r\n";

}

$result .= "\r\n" . $reply;

// find HTTP status

$httpstatus = '500';

$match = [];

if (!empty($headers[0]) && preg_match('/HTTP\/\d\.\d (\d{3})/', $headers[0], $match)) {

$httpstatus = $match[1];

}

$reply = $this->_parseBearerReply($result, $httpstatus);

return $reply;

}

/**

/**

protected function _parseBearerReply($result, $httpstatus)

{

list($headers, $reply) = $this->_parseApiHeaders($result);

$reply = $this->_parseApiReply($reply);

$rate = $this->_getRateLimitInfo($headers);

switch ($this->_return_format) {

case CODEBIRD_RETURNFORMAT_ARRAY:

$reply['httpstatus'] = $httpstatus;

$reply['rate'] = $rate;

if ($httpstatus === 200) {

self::setBearerToken($reply['access_token']);

}

break;

case CODEBIRD_RETURNFORMAT_JSON:

if ($httpstatus === 200) {

$parsed = json_decode($reply, false, 512, JSON_BIGINT_AS_STRING);

self::setBearerToken($parsed->access_token);

}

break;

case CODEBIRD_RETURNFORMAT_OBJECT:

$reply->httpstatus = $httpstatus;

$reply->rate = $rate;

if ($httpstatus === 200) {

self::setBearerToken($reply->access_token);

}

break;

}

return $reply;

}

/**