Class yii\authclient\clients\Twitter

                public function api($apiSubUrl, $method = 'GET', array $params = [], array $headers = [])
{
    if (preg_match('/^https?:\\/\\//is', $apiSubUrl)) {
        $url = $apiSubUrl;
    } else {
        $url = $this->apiBaseUrl . '/' . $apiSubUrl;
    }
    $accessToken = $this->getAccessToken();
    if (!is_object($accessToken) || !$accessToken->getIsValid()) {
        throw new Exception('Invalid access token.');
    }
    return $this->apiInternal($accessToken, $url, $method, $params, $headers);
}

            

                protected function apiInternal($accessToken, $url, $method, array $params, array $headers)
{
    $params['oauth_consumer_key'] = $this->consumerKey;
    $params['oauth_token'] = $accessToken->getToken();
    $response = $this->sendSignedRequest($method, $url, $params, $headers);
    return $response;
}

            

                public function buildAuthUrl(OAuthToken $requestToken = null, array $params = [])
{
    if (!is_object($requestToken)) {
        $requestToken = $this->getState('requestToken');
        if (!is_object($requestToken)) {
            throw new Exception('Request token is required to build authorize URL!');
        }
    }
    $params['oauth_token'] = $requestToken->getToken();
    return $this->composeUrl($this->authUrl, $params);
}

            

                protected function composeAuthorizationHeader(array $params, $realm = '')
{
    $header = 'Authorization: OAuth';
    $headerParams = [];
    if (!empty($realm)) {
        $headerParams[] = 'realm="' . rawurlencode($realm) . '"';
    }
    foreach ($params as $key => $value) {
        if (substr_compare($key, 'oauth', 0, 5)) {
            continue;
        }
        $headerParams[] = rawurlencode($key) . '="' . rawurlencode($value) . '"';
    }
    if (!empty($headerParams)) {
        $header .= ' ' . implode(', ', $headerParams);
    }
    return $header;
}

            

                protected function composeRequestCurlOptions($method, $url, array $params)
{
    $curlOptions = [];
    switch ($method) {
        case 'GET': {
            $curlOptions[CURLOPT_URL] = $this->composeUrl($url, $params);
            break;
        }
        case 'POST': {
            $curlOptions[CURLOPT_POST] = true;
            $curlOptions[CURLOPT_HTTPHEADER] = ['Content-type: application/x-www-form-urlencoded'];
            if (!empty($params)) {
                $curlOptions[CURLOPT_POSTFIELDS] = http_build_query($params, '', '&', PHP_QUERY_RFC3986);
            }
            $authorizationHeader = $this->composeAuthorizationHeader($params);
            if (!empty($authorizationHeader)) {
                $curlOptions[CURLOPT_HTTPHEADER][] = $authorizationHeader;
            }
            break;
        }
        case 'HEAD': {
            $curlOptions[CURLOPT_CUSTOMREQUEST] = $method;
            if (!empty($params)) {
                $curlOptions[CURLOPT_URL] = $this->composeUrl($url, $params);
            }
            break;
        }
        default: {
            $curlOptions[CURLOPT_CUSTOMREQUEST] = $method;
            if (!empty($params)) {
                $curlOptions[CURLOPT_POSTFIELDS] = $params;
            }
        }
    }
    return $curlOptions;
}

            

                protected function composeSignatureBaseString($method, $url, array $params)
{
    unset($params['oauth_signature']);
    uksort($params, 'strcmp'); // Parameters are sorted by name, using lexicographical byte value ordering. Ref: Spec: 9.1.1
    $parts = [
        strtoupper($method),
        $url,
        http_build_query($params, '', '&', PHP_QUERY_RFC3986)
    ];
    $parts = array_map('rawurlencode', $parts);
    return implode('&', $parts);
}

            

                protected function composeSignatureKey()
{
    $signatureKeyParts = [
        $this->consumerSecret
    ];
    $accessToken = $this->getAccessToken();
    if (is_object($accessToken)) {
        $signatureKeyParts[] = $accessToken->getTokenSecret();
    } else {
        $signatureKeyParts[] = '';
    }
    $signatureKeyParts = array_map('rawurlencode', $signatureKeyParts);
    return implode('&', $signatureKeyParts);
}

            

                protected function composeUrl($url, array $params = [])
{
    if (strpos($url, '?') === false) {
        $url .= '?';
    } else {
        $url .= '&';
    }
    $url .= http_build_query($params, '', '&', PHP_QUERY_RFC3986);
    return $url;
}

            

                protected function convertXmlToArray($xml)
{
    if (!is_object($xml)) {
        $xml = simplexml_load_string($xml);
    }
    $result = (array) $xml;
    foreach ($result as $key => $value) {
        if (is_object($value)) {
            $result[$key] = $this->convertXmlToArray($value);
        }
    }
    return $result;
}

            

                protected function createSignatureMethod(array $signatureMethodConfig)
{
    if (!array_key_exists('class', $signatureMethodConfig)) {
        $signatureMethodConfig['class'] = signature\HmacSha1::className();
    }
    return Yii::createObject($signatureMethodConfig);
}

            

                protected function createToken(array $tokenConfig = [])
{
    if (!array_key_exists('class', $tokenConfig)) {
        $tokenConfig['class'] = OAuthToken::className();
    }
    return Yii::createObject($tokenConfig);
}

            

                protected function defaultCurlOptions()
{
    return [
        CURLOPT_USERAGENT => Yii::$app->name . ' OAuth ' . $this->version . ' Client',
        CURLOPT_CONNECTTIMEOUT => 30,
        CURLOPT_TIMEOUT => 30,
        CURLOPT_SSL_VERIFYPEER => false,
    ];
}

            

                protected function defaultNormalizeUserAttributeMap()
{
    return [];
}

            

                protected function defaultReturnUrl()
{
    $params = $_GET;
    unset($params['oauth_token']);
    $params[0] = Yii::$app->controller->getRoute();
    return Yii::$app->getUrlManager()->createAbsoluteUrl($params);
}

            

                protected function defaultViewOptions()
{
    return [];
}

            

                protected function determineContentTypeByHeaders(array $headers)
{
    if (isset($headers['content_type'])) {
        if (stripos($headers['content_type'], 'json') !== false) {
            return self::CONTENT_TYPE_JSON;
        }
        if (stripos($headers['content_type'], 'urlencoded') !== false) {
            return self::CONTENT_TYPE_URLENCODED;
        }
        if (stripos($headers['content_type'], 'xml') !== false) {
            return self::CONTENT_TYPE_XML;
        }
    }
    return self::CONTENT_TYPE_AUTO;
}

            

                protected function determineContentTypeByRaw($rawContent)
{
    if (preg_match('/^\\{.*\\}$/is', $rawContent)) {
        return self::CONTENT_TYPE_JSON;
    }
    if (preg_match('/^[^=|^&]+=[^=|^&]+(&[^=|^&]+=[^=|^&]+)*$/is', $rawContent)) {
        return self::CONTENT_TYPE_URLENCODED;
    }
    if (preg_match('/^<.*>$/is', $rawContent)) {
        return self::CONTENT_TYPE_XML;
    }
    return self::CONTENT_TYPE_AUTO;
}

            

                public function fetchAccessToken(OAuthToken $requestToken = null, $oauthVerifier = null, array $params = [])
{
    if (!is_object($requestToken)) {
        $requestToken = $this->getState('requestToken');
        if (!is_object($requestToken)) {
            throw new Exception('Request token is required to fetch access token!');
        }
    }
    $this->removeState('requestToken');
    $defaultParams = [
        'oauth_consumer_key' => $this->consumerKey,
        'oauth_token' => $requestToken->getToken()
    ];
    if ($oauthVerifier === null) {
        if (isset($_REQUEST['oauth_verifier'])) {
            $oauthVerifier = $_REQUEST['oauth_verifier'];
        }
    }
    if (!empty($oauthVerifier)) {
        $defaultParams['oauth_verifier'] = $oauthVerifier;
    }
    $response = $this->sendSignedRequest($this->accessTokenMethod, $this->accessTokenUrl, array_merge($defaultParams, $params));
    $token = $this->createToken([
        'params' => $response
    ]);
    $this->setAccessToken($token);
    return $token;
}

            

                public function fetchRequestToken(array $params = [])
{
    $this->removeState('token');
    $defaultParams = [
        'oauth_consumer_key' => $this->consumerKey,
        'oauth_callback' => $this->getReturnUrl(),
        //'xoauth_displayname' => Yii::$app->name,
    ];
    if (!empty($this->scope)) {
        $defaultParams['scope'] = $this->scope;
    }
    $response = $this->sendSignedRequest($this->requestTokenMethod, $this->requestTokenUrl, array_merge($defaultParams, $params));
    $token = $this->createToken([
        'params' => $response
    ]);
    $this->setState('requestToken', $token);
    return $token;
}

            

                protected function generateCommonRequestParams()
{
    $params = [
        'oauth_version' => $this->version,
        'oauth_nonce' => $this->generateNonce(),
        'oauth_timestamp' => $this->generateTimestamp(),
    ];
    return $params;
}

            

                protected function generateNonce()
{
    return md5(microtime() . mt_rand());
}

            

                protected function generateTimestamp()
{
    return time();
}

            

                public function getAccessToken()
{
    if (!is_object($this->_accessToken)) {
        $this->_accessToken = $this->restoreAccessToken();
    }
    return $this->_accessToken;
}

            

                public function getCurlOptions()
{
    return $this->_curlOptions;
}

            

                public function getId()
{
    if (empty($this->_id)) {
        $this->_id = $this->getName();
    }
    return $this->_id;
}

            

                public function getName()
{
    if ($this->_name === null) {
        $this->_name = $this->defaultName();
    }
    return $this->_name;
}

            

                public function getNormalizeUserAttributeMap()
{
    if ($this->_normalizeUserAttributeMap === null) {
        $this->_normalizeUserAttributeMap = $this->defaultNormalizeUserAttributeMap();
    }
    return $this->_normalizeUserAttributeMap;
}

            

                public function getReturnUrl()
{
    if ($this->_returnUrl === null) {
        $this->_returnUrl = $this->defaultReturnUrl();
    }
    return $this->_returnUrl;
}

            

                public function getSignatureMethod()
{
    if (!is_object($this->_signatureMethod)) {
        $this->_signatureMethod = $this->createSignatureMethod($this->_signatureMethod);
    }
    return $this->_signatureMethod;
}

            

                protected function getState($key)
{
    if (!Yii::$app->has('session')) {
        return null;
    }
    /* @var \yii\web\Session $session */
    $session = Yii::$app->get('session');
    $key = $this->getStateKeyPrefix() . $key;
    $value = $session->get($key);
    return $value;
}

            

                protected function getStateKeyPrefix()
{
    return get_class($this) . '_' . sha1($this->authUrl) . '_';
}

            

                public function getTitle()
{
    if ($this->_title === null) {
        $this->_title = $this->defaultTitle();
    }
    return $this->_title;
}

            

                public function getUserAttributes()
{
    if ($this->_userAttributes === null) {
        $this->_userAttributes = $this->normalizeUserAttributes($this->initUserAttributes());
    }
    return $this->_userAttributes;
}

            

                public function getViewOptions()
{
    if ($this->_viewOptions === null) {
        $this->_viewOptions = $this->defaultViewOptions();
    }
    return $this->_viewOptions;
}

            

                protected function mergeCurlOptions($options1, $options2)
{
    $args = func_get_args();
    $res = array_shift($args);
    while (!empty($args)) {
        $next = array_shift($args);
        foreach ($next as $k => $v) {
            if (is_array($v) && !empty($res[$k]) && is_array($res[$k])) {
                $res[$k] = array_merge($res[$k], $v);
            } else {
                $res[$k] = $v;
            }
        }
    }
    return $res;
}

            

                protected function normalizeUserAttributes($attributes)
{
    foreach ($this->getNormalizeUserAttributeMap() as $normalizedName => $actualName) {
        if (is_scalar($actualName)) {
            if (array_key_exists($actualName, $attributes)) {
                $attributes[$normalizedName] = $attributes[$actualName];
            }
        } else {
            if (is_callable($actualName)) {
                $attributes[$normalizedName] = call_user_func($actualName, $attributes);
            } elseif (is_array($actualName)) {
                $haystack = $attributes;
                $searchKeys = $actualName;
                $isFound = true;
                while (($key = array_shift($searchKeys)) !== null) {
                    if (is_array($haystack) && array_key_exists($key, $haystack)) {
                        $haystack = $haystack[$key];
                    } else {
                        $isFound = false;
                        break;
                    }
                }
                if ($isFound) {
                    $attributes[$normalizedName] = $haystack;
                }
            } else {
                throw new InvalidConfigException('Invalid actual name "' . gettype($actualName) . '" specified at "' . get_class($this) . '::normalizeUserAttributeMap"');
            }
        }
    }
    return $attributes;
}

            

                protected function processResponse($rawResponse, $contentType = self::CONTENT_TYPE_AUTO)
{
    if (empty($rawResponse)) {
        return [];
    }
    switch ($contentType) {
        case self::CONTENT_TYPE_AUTO: {
            $contentType = $this->determineContentTypeByRaw($rawResponse);
            if ($contentType == self::CONTENT_TYPE_AUTO) {
                throw new Exception('Unable to determine response content type automatically.');
            }
            $response = $this->processResponse($rawResponse, $contentType);
            break;
        }
        case self::CONTENT_TYPE_JSON: {
            $response = Json::decode($rawResponse, true);
            break;
        }
        case self::CONTENT_TYPE_URLENCODED: {
            $response = [];
            parse_str($rawResponse, $response);
            break;
        }
        case self::CONTENT_TYPE_XML: {
            $response = $this->convertXmlToArray($rawResponse);
            break;
        }
        default: {
            throw new Exception('Unknown response type "' . $contentType . '".');
        }
    }
    return $response;
}

            

                public function refreshAccessToken(OAuthToken $token)
{
    // @todo
    return null;
}

            

                protected function removeState($key)
{
    if (!Yii::$app->has('session')) {
        return true;
    }
    /* @var \yii\web\Session $session */
    $session = Yii::$app->get('session');
    $key = $this->getStateKeyPrefix() . $key;
    $session->remove($key);
    return true;
}

            

                protected function restoreAccessToken()
{
    $token = $this->getState('token');
    if (is_object($token)) {
        /* @var $token OAuthToken */
        if ($token->getIsExpired() && $this->autoRefreshAccessToken) {
            $token = $this->refreshAccessToken($token);
        }
    }
    return $token;
}

            

                protected function saveAccessToken(OAuthToken $token)
{
    return $this->setState('token', $token);
}

            

                protected function sendRequest($method, $url, array $params = [], array $headers = [])
{
    $curlOptions = $this->mergeCurlOptions(
        $this->defaultCurlOptions(),
        $this->getCurlOptions(),
        [
            CURLOPT_HTTPHEADER => $headers,
            CURLOPT_RETURNTRANSFER => true,
            CURLOPT_URL => $url,
        ],
        $this->composeRequestCurlOptions(strtoupper($method), $url, $params)
    );
    $curlResource = curl_init();
    foreach ($curlOptions as $option => $value) {
        curl_setopt($curlResource, $option, $value);
    }
    $response = curl_exec($curlResource);
    $responseHeaders = curl_getinfo($curlResource);
    // check cURL error
    $errorNumber = curl_errno($curlResource);
    $errorMessage = curl_error($curlResource);
    curl_close($curlResource);
    if ($errorNumber > 0) {
        throw new Exception('Curl error requesting "' .  $url . '": #' . $errorNumber . ' - ' . $errorMessage);
    }
    if (strncmp($responseHeaders['http_code'], '20', 2) !== 0) {
        throw new InvalidResponseException($responseHeaders, $response, 'Request failed with code: ' . $responseHeaders['http_code'] . ', message: ' . $response);
    }
    return $this->processResponse($response, $this->determineContentTypeByHeaders($responseHeaders));
}

            

                protected function sendSignedRequest($method, $url, array $params = [], array $headers = [])
{
    $params = array_merge($params, $this->generateCommonRequestParams());
    $params = $this->signRequest($method, $url, $params);
    return $this->sendRequest($method, $url, $params, $headers);
}

            

                public function setAccessToken($token)
{
    if (!is_object($token)) {
        $token = $this->createToken($token);
    }
    $this->_accessToken = $token;
    $this->saveAccessToken($token);
}

            

                public function setCurlOptions(array $curlOptions)
{
    $this->_curlOptions = $curlOptions;
}

            

                public function setId($id)
{
    $this->_id = $id;
}

            

                public function setName($name)
{
    $this->_name = $name;
}

            

                public function setNormalizeUserAttributeMap($normalizeUserAttributeMap)
{
    $this->_normalizeUserAttributeMap = $normalizeUserAttributeMap;
}

            

                public function setReturnUrl($returnUrl)
{
    $this->_returnUrl = $returnUrl;
}

            

                public function setSignatureMethod($signatureMethod)
{
    if (!is_object($signatureMethod) && !is_array($signatureMethod)) {
        throw new InvalidParamException('"' . get_class($this) . '::signatureMethod" should be instance of "\yii\autclient\signature\BaseMethod" or its array configuration. "' . gettype($signatureMethod) . '" has been given.');
    }
    $this->_signatureMethod = $signatureMethod;
}

            

                protected function setState($key, $value)
{
    if (!Yii::$app->has('session')) {
        return $this;
    }
    /* @var \yii\web\Session $session */
    $session = Yii::$app->get('session');
    $key = $this->getStateKeyPrefix() . $key;
    $session->set($key, $value);
    return $this;
}

            

                public function setTitle($title)
{
    $this->_title = $title;
}

            

                public function setUserAttributes($userAttributes)
{
    $this->_userAttributes = $this->normalizeUserAttributes($userAttributes);
}

            

                public function setViewOptions($viewOptions)
{
    $this->_viewOptions = $viewOptions;
}

            

                protected function signRequest($method, $url, array $params)
{
    $signatureMethod = $this->getSignatureMethod();
    $params['oauth_signature_method'] = $signatureMethod->getName();
    $signatureBaseString = $this->composeSignatureBaseString($method, $url, $params);
    $signatureKey = $this->composeSignatureKey();
    $params['oauth_signature'] = $signatureMethod->generateSignature($signatureBaseString, $signatureKey);
    return $params;
}