class AuthTokenProvider in TMGMT Translator Smartling 8.2

Class AuthTokenProvider @package Smartling\AuthApi

Hierarchy

• class \Smartling\AuthApi\AuthTokenProvider extends \Smartling\BaseApiAbstract implements \Smartling\AuthApi\AuthApiInterface

10 files declare their use of AuthTokenProvider

AuthApiTest.php in api-sdk-php/tests/unit/AuthApiTest.php

AuthApiTest.php in vendor/smartling/api-sdk-php/tests/unit/AuthApiTest.php

BufferLogger.php in src/Logger/BufferLogger.php

ContextApiFunctionalTest.php in api-sdk-php/tests/functional/ContextApiFunctionalTest.php

ContextApiFunctionalTest.php in vendor/smartling/api-sdk-php/tests/functional/ContextApiFunctionalTest.php

... See full list

File

api-sdk-php/src/AuthApi/AuthTokenProvider.php, line 13

Namespace

Smartling\AuthApi

class AuthTokenProvider extends BaseApiAbstract implements AuthApiInterface {
  const ENDPOINT_URL = 'https://api.smartling.com/auth-api/v2';
  const RESPONSE_KEY_ACCESS_TOKEN = 'accessToken';
  const RESPONSE_KEY_ACCESS_TOKEN_TTL = 'expiresIn';
  const RESPONSE_KEY_REFRESH_TOKEN = 'refreshToken';
  const RESPONSE_KEY_REFRESH_TOKEN_TTL = 'refreshExpiresIn';
  const RESPONSE_KEY_TOKEN_TYPE = 'tokenType';

  /**
   * @var string
   */
  private $userIdentifier;

  /**
   * @var string
   */
  private $secretKey;

  /**
   * @var array
   */
  private $data = [];

  /**
   * @var int
   */
  private $requestTimestamp = 0;

  /**
   * @return string
   */
  private function getUserIdentifier() {
    return $this->userIdentifier;
  }

  /**
   * @param string $userIdentifier
   */
  private function setUserIdentifier($userIdentifier) {
    $this->userIdentifier = $userIdentifier;
  }

  /**
   * @return string
   */
  private function getSecretKey() {
    return $this->secretKey;
  }

  /**
   * @param string $secretKey
   */
  private function setSecretKey($secretKey) {
    $this->secretKey = $secretKey;
  }

  /**
   * AuthTokenProvider constructor.
   *
   * @param string $userIdentifier
   * @param string $secretKey
   * @param ClientInterface $client
   * @param LoggerInterface $logger
   */
  public function __construct($userIdentifier, $secretKey, ClientInterface $client, $logger = null) {
    parent::__construct('', $client, $logger, self::ENDPOINT_URL);
    $this
      ->setUserIdentifier($userIdentifier);
    $this
      ->setSecretKey($secretKey);
  }

  /**
   * Creates and returns instance of AuthTokenProvider
   *
   * @param string $userIdentifier
   * @param string $secretKey
   * @param LoggerInterface $logger
   *
   * @return AuthTokenProvider
   */
  public static function create($userIdentifier, $secretKey, $logger = null) {
    $client = self::initializeHttpClient(self::ENDPOINT_URL);
    return new self($userIdentifier, $secretKey, $client, $logger);
  }

  /**
   * Checks if token exists
   */
  private function tokenExists() {
    return is_array($this->data) && array_key_exists(self::RESPONSE_KEY_ACCESS_TOKEN, $this->data);
  }

  /**
   * Checks if token is expired
   */
  private function tokenExpired() {
    return $this
      ->tokenExists() && time() > $this->requestTimestamp + $this->data[self::RESPONSE_KEY_ACCESS_TOKEN_TTL];
  }

  /**
   * Sends /authenticate request
   */
  private function authenticate() {
    $this->requestTimestamp = time();
    $requestData = $this
      ->getDefaultRequestData('json', [
      'userIdentifier' => $this
        ->getUserIdentifier(),
      'userSecret' => $this
        ->getSecretKey(),
    ], false);
    return $this
      ->sendRequest('authenticate', $requestData, self::HTTP_METHOD_POST);
  }

  /**
   * Renews tokens
   */
  private function tokenRenew() {
    if ($this
      ->tokenExists() && $this
      ->tokenCanBeRenewed()) {
      $requestData = $this
        ->getDefaultRequestData('json', [
        'refreshToken' => $this->data[self::RESPONSE_KEY_REFRESH_TOKEN],
      ], false);
      return $this
        ->sendRequest('authenticate/refresh', $requestData, self::HTTP_METHOD_POST);
    }
    else {
      return $this
        ->authenticate();
    }
  }

  /**
   * Checks if token can be renewed
   */
  private function tokenCanBeRenewed() {
    return $this
      ->tokenExists() && time() > $this->requestTimestamp + $this->data[self::RESPONSE_KEY_REFRESH_TOKEN_TTL];
  }

  /**
   * @inheritdoc
   */
  public function getAccessToken() {
    if (!$this
      ->tokenExists()) {
      $this->requestTimestamp = time();
      $this->data = $this
        ->authenticate();
    }
    if ($this
      ->tokenExpired()) {
      $this
        ->tokenRenew();
    }
    return $this->data[self::RESPONSE_KEY_ACCESS_TOKEN];
  }

  /**
   * @inheritdoc
   */
  public function getTokenType() {
    return $this
      ->tokenExists() ? $this->data[self::RESPONSE_KEY_TOKEN_TYPE] : '';
  }

  /**
   * @inheritdoc
   */
  public function resetToken() {
    $this->data = [];
  }

}

Members

Name	Modifiers	Type	Description	Overrides
AuthTokenProvider::$data	private	property
AuthTokenProvider::$requestTimestamp	private	property
AuthTokenProvider::$secretKey	private	property
AuthTokenProvider::$userIdentifier	private	property
AuthTokenProvider::authenticate	private	function	Sends /authenticate request
AuthTokenProvider::create	public static	function	Creates and returns instance of AuthTokenProvider
AuthTokenProvider::ENDPOINT_URL		constant
AuthTokenProvider::getAccessToken	public	function	@inheritdoc
AuthTokenProvider::getSecretKey	private	function
AuthTokenProvider::getTokenType	public	function	@inheritdoc
AuthTokenProvider::getUserIdentifier	private	function
AuthTokenProvider::resetToken	public	function	@inheritdoc
AuthTokenProvider::RESPONSE_KEY_ACCESS_TOKEN		constant
AuthTokenProvider::RESPONSE_KEY_ACCESS_TOKEN_TTL		constant
AuthTokenProvider::RESPONSE_KEY_REFRESH_TOKEN		constant
AuthTokenProvider::RESPONSE_KEY_REFRESH_TOKEN_TTL		constant
AuthTokenProvider::RESPONSE_KEY_TOKEN_TYPE		constant
AuthTokenProvider::setSecretKey	private	function
AuthTokenProvider::setUserIdentifier	private	function
AuthTokenProvider::tokenCanBeRenewed	private	function	Checks if token can be renewed
AuthTokenProvider::tokenExists	private	function	Checks if token exists
AuthTokenProvider::tokenExpired	private	function	Checks if token is expired
AuthTokenProvider::tokenRenew	private	function	Renews tokens
AuthTokenProvider::__construct	public	function	AuthTokenProvider constructor.