The OAuth parameters that respresent this UserCredential.

 @return Hash
550924
def request_params
      case account_type
      when AccountType::MANAGED
        managed_request_params
      when AccountType::FEDERATED
        federated_request_params
      else
        fail UnsupportedAccountTypeError, account_type
      end
    end
55692
protected function temporaryCredentialsProtocolHeader($uri)
    {
        $parameters = array_merge($this->baseProtocolParameters(), array(
            'oauth_callback' => $this->clientCredentials->getCallbackUri(),
        ));

        $parameters['oauth_signature'] = $this->signature->sign($uri, $parameters, 'POST');

        return $this->normalizeProtocolParameters($parameters);
    }
1303394
public function getBasicAuth()
    {
        if (empty($this->basicAuth))
            return "";

        if (empty($this->basicAuth["username"]))
            // Username cannot be empty in Basic Authentication
            return "";

        $username = $this->basicAuth["username"];
        $password = isset($this->basicAuth["password"]) ? $this->basicAuth["password"] : "";
        return sprintf("%s:%s@", $username, $password);
    }
110476
public function get_oauth_params( $params, $method ) {

		$params = array_merge( $params, array(
			'oauth_consumer_key'     => $this->consumer_key,
			'oauth_timestamp'        => time(),
			'oauth_nonce'            => sha1( microtime() ),
			'oauth_signature_method' => 'HMAC-' . self::HASH_ALGORITHM,
		) );

		// the params above must be included in the signature generation
		$params['oauth_signature'] = $this->generate_oauth_signature( $params, $method );

		return $params;
	}
1178937
public static function getAuth()
    {
        $result = null;
        if ($user = Arr::key('PHP_AUTH_USER', $_SERVER, true)) {
            $result .= $user;

            if ($password = Arr::key('PHP_AUTH_PW', $_SERVER, true)) {
                $result .= ':' . $password;
            }

            $result .= '@';
        }

        return $result;
    }
531484
function get_hash()
    {
        $prefs = $this->get_prefs();

        // generate a random hash and store it in user prefs
        if (empty($prefs['client_hash'])) {
            $prefs['client_hash'] = rcube_utils::random_bytes(16);
            $this->save_prefs(array('client_hash' => $prefs['client_hash']));
        }

        return $prefs['client_hash'];
    }
559681
private function fetchCredentials()
    {
        $backoff = new ExponentialBackoff($this->retries, $this->getRetryFunction());

        try {
            return $backoff->execute(
                [$this->getCredentialsFetcher(), 'fetchAuthToken'],
                [$this->authHttpHandler]
            );
        } catch (\Exception $ex) {
            throw $this->convertToGoogleException($ex);
        }
    }
225060
public function getPassword() : IHashedPassword
    {
        return new class implements IHashedPassword
        {
            /**
             * Gets the hashed password string.
             *
             * @return string
             */
            public function getHash() : string
            {
                // TODO: Implement getHash() method.
            }

            /**
             * Gets the hashing algorithm.
             *
             * @return string
             */
            public function getAlgorithm() : string
            {
                // TODO: Implement getAlgorithm() method.
            }

            /**
             * Gets the hashing cost factor.
             *
             * @return int
             */
            public function getCostFactor() : int
            {
                // TODO: Implement getCostFactor() method.
            }

            /**
             * Returns an associated array of the values indexed by the property names.
             *
             * This returns all properties regardless of accessibility.
             *
             * @return array
             */
            public function toArray() : array
            {
                // TODO: Implement toArray() method.
            }

            /**
             * Sets the properties of the object.
             *
             * The property types and structure are NOT validated in any way
             * and as such this should only be used for restoring object
             * state from a persistence store which is in a valid state.
             *
             * @param array $properties
             *
             * @return void
             */
            public function hydrate(array $properties)
            {
                // TODO: Implement hydrate() method.
            }
        };
    }
119223
public function get_signable_parameters() {/*{{{*/
    // Grab all parameters
    $params = $this->parameters;

    // Remove oauth_signature if present
    if (isset($params['oauth_signature'])) {
      unset($params['oauth_signature']);
    }

    // Urlencode both keys and values
    $keys = OAuthUtil::urlencode_rfc3986(array_keys($params));
    $values = OAuthUtil::urlencode_rfc3986(array_values($params));
    $params = array_combine($keys, $values);

    // Sort by keys (natsort)
    uksort($params, 'strcmp');

    // Generate key=value pairs
    $pairs = array();
    foreach ($params as $key=>$value ) {
      if (is_array($value)) {
        // If the value is an array, it's because there are multiple
        // with the same key, sort them, then add all the pairs
        natsort($value);
        foreach ($value as $v2) {
          $pairs[] = $key . '=' . $v2;
        }
      } else {
        $pairs[] = $key . '=' . $value;
      }
    }

    // Return the pairs, concated with &
    return implode('&', $pairs);
  }
1230149
protected function baseProtocolParameters()
    {
        $dateTime = new \DateTime();

        return array(
            'oauth_consumer_key' => $this->clientCredentials->getIdentifier(),
            'oauth_nonce' => $this->nonce(),
            'oauth_signature_method' => $this->signature->method(),
            'oauth_timestamp' => $dateTime->format('U'),
            'oauth_version' => '1.0',
        );
    }
210101
public function getRedirectHash()
    {
        $redirect = $this->parameters->get('redirect');

        if (!is_array($redirect) || empty($redirect['hash'])) {
            return '';
        }

        return '#' . $redirect['hash'];
    }
517447
public function getCredentials()
    {
        $secret = $this->getSecret();

        if (!isset($secret['username']) || !isset($secret['password'])) {
            throw new CredentialError('Unrecognized credential secret');
        }

        return parent::getCredentials();
    }
982639
function getAuthorizationHeader ()
	{
		if (!$this->signed)
		{
			$this->sign($this->usr_id);
		}
		$h   = array();
		$h[] = 'Authorization: OAuth realm=""';
		foreach ($this->param as $name => $value)
		{
			if (strncmp($name, 'oauth_', 6) == 0 || strncmp($name, 'xoauth_', 7) == 0)
          	{
				$h[] = $name.'="'.$value.'"';
			}
		}
		$hs = implode(', ', $h);
		return $hs;
	}
491165
public function get_signable_parameters(): string
	{
		// Grab all parameters
		$params = $this->parameters;

		// Remove oauth_signature if present
		// Ref: Spec: 9.1.1 ("The oauth_signature parameter MUST be excluded.")
		if (isset($params['oauth_signature'])) {
			unset($params['oauth_signature']);
		}

		return Util::build_http_query($params);
	}
265368
function getXAuthToken($username, $password) {
    $parameters = array();
    $parameters['x_auth_username'] = $username;
    $parameters['x_auth_password'] = $password;
    $parameters['x_auth_mode'] = 'client_auth';
    $request = $this->oAuthRequest($this->accessTokenURL(), 'POST', $parameters);
    $token = OAuthUtil::parse_parameters($request);
    $this->token = new OAuthConsumer($token['oauth_token'], $token['oauth_token_secret']);
    return $token;
  }
748266
public function getParameters()
    {
        $params = explode("\n", trim($this->_response));

        foreach ($params as $param) {
            list($key, $val) = explode('=', $param, 2);
            $param_array[$key] = $val;
        }

        $param_array['identity'] = substr($param_array['otp'], 0, 12);

        return $param_array;
    }
234216
public function getOAuth()
    {
        if ($this->oauthResponse instanceof InstagramOAuth) {
            return $this->oauthResponse;
        }

        $accessToken = new stdClass;
        $accessToken->access_token = null;

        $this->oauthResponse = new InstagramOAuth($accessToken);

        return $this->oauthResponse;
    }