ApplicationConfiguration.php

<?php

namespace SumUp\Application;

use SumUp\Exceptions\SumUpConfigurationException;
use SumUp\SdkInfo;

/**
 * Class ApplicationConfiguration
 *
 * @package SumUp\ApplicationConfiguration
 */
class ApplicationConfiguration implements ApplicationConfigurationInterface
{
    /**
     * The default scopes that are recommended to be requested every time.
     */
    const DEFAULT_SCOPES = ['payments', 'transactions.history', 'user.app-settings', 'user.profile_readonly'];

    /**
     * Header name for the SDK's User-Agent.
     */
    const USER_AGENT_HEADER = 'User-Agent';

    /**
     * The possible values for grant type.
     */
    const GRANT_TYPES = ['authorization_code', 'client_credentials', 'password'];

    /**
     * The client ID.
     *
     * @var string
     */
    protected $appId;

    /**
     * The client secret.
     *
     * @var string
     */
    protected $appSecret;

    /**
     * The scopes that are needed for all services the application uses.
     *
     * @var array
     */
    protected $scopes;

    /**
     * The base URL of the SumUp API.
     *
     * @var string;
     */
    protected $baseURL;

    /**
     * The merchant's username. Needed only if the authorization flow is "password".
     *
     * @var string
     */
    protected $username;

    /**
     * The merchant's account password. Needed only if the authorization flow is "password".
     *
     * @var string
     */
    protected $password;

    /**
     * The authorization grant type. Allowed values are: 'authorization_code'|'client_credentials'|'password'.
     *
     * @var string
     */
    protected $grantType;

    /**
     * The authorization code.
     *
     * @var string
     */
    protected $code;

    /**
     * The access token.
     *
     * @var null|string
     */
    protected $accessToken;

    /**
     * The refresh token.
     *
     * @var null|string
     */
    protected $refreshToken;

    /**
     * Flag whether to use GuzzleHttp over cURL if both are present.
     *
     * @var $forceGuzzle
     */
    protected $forceGuzzle;

    /**
     * Custom headers to be sent with every request.
     *
     * @var array $customHeaders
     */
    protected $customHeaders;

    /**
     * Path to a custom CA bundle. If not provided, the SDK ships one by default.
     *
     * @var string|null
     */
    protected $caBundlePath;

    /**
     * The API key for authentication.
     *
     * @var string|null
     */
    protected $apiKey;

    /**
     * Create a new application configuration.
     *
     * @param array $config
     *
     * @throws SumUpConfigurationException
     */
    public function __construct(array $config = [])
    {
        $config = array_merge([
            'api_key' => null,
            'app_id' => null,
            'app_secret' => null,
            'grant_type' => 'authorization_code',
            'base_uri' => 'https://api.sumup.com',
            'scopes' => [],
            'code' => null,
            'access_token' => null,
            'refresh_token' => null,
            'username' => null,
            'password' => null,
            'use_guzzlehttp_over_curl' => false,
            'custom_headers' => [],
            'ca_bundle_path' => null
        ], $config);

        $this->apiKey = $config['api_key'];
        $this->setAppId($config['app_id']);
        $this->setAppSecret($config['app_secret']);
        $this->setScopes($config['scopes']);
        $this->setGrantType($config['grant_type']);
        $this->baseURL = $config['base_uri'];
        $this->username = $config['username'];
        $this->password = $config['password'];
        $this->code = $config['code'];
        $this->accessToken = $config['access_token'];
        $this->refreshToken = $config['refresh_token'];
        $this->setForceGuzzle($config['use_guzzlehttp_over_curl']);
        $this->setCustomHeaders($config['custom_headers']);
        $this->setCABundlePath($config['ca_bundle_path']);
    }

    /**
     * Returns the client ID.
     *
     * @return string
     */
    public function getAppId(): string
    {
        return $this->appId;
    }

    /**
     * Returns the client secret.
     *
     * @return string
     */
    public function getAppSecret(): string
    {
        return $this->appSecret;
    }

    /**
     * Returns the scopes.
     *
     * @return array
     */
    public function getScopes(): array
    {
        return $this->scopes;
    }

    /**
     * Returns the scopes formatted as they should appear in the request.
     *
     * @return string
     */
    public function getFormattedScopes(): string
    {
        return implode(' ', $this->scopes);
    }

    /**
     * Returns the base URL of the SumUp API.
     *
     * @return string
     */
    public function getBaseURL(): string
    {
        return $this->baseURL;
    }

    /**
     * Returns authorization code.
     *
     * @return string
     */
    public function getCode(): string
    {
        return $this->code;
    }

    /**
     * Returns grant type.
     *
     * @return string;
     */
    public function getGrantType(): string
    {
        return $this->grantType;
    }

    /**
     * Returns merchant's username.
     *
     * @return string
     */
    public function getUsername(): string
    {
        return $this->username;
    }

    /**
     * Returns merchant's password.
     *
     * @return string
     */
    public function getPassword(): string
    {
        return $this->password;
    }

    /**
     * Returns initial access token.
     *
     * @return null|string
     */
    public function getAccessToken(): ?string
    {
        return $this->accessToken;
    }

    /**
     * Returns initial refresh token.
     *
     * @return null|string
     */
    public function getRefreshToken(): ?string
    {
        return $this->refreshToken;
    }

    /**
     * Returns the flag whether to use GuzzleHttp.
     *
     * @return bool
     */
    public function getForceGuzzle(): bool
    {
        return $this->forceGuzzle;
    }

    /**
     * Returns associative array with custom headers.
     *
     * @return array
     */
    public function getCustomHeaders(): array
    {
        return $this->customHeaders;
    }

    /**
     * Returns the path to the CA bundle used for HTTPS verification.
     *
     * @return string|null
     */
    public function getCABundlePath(): ?string
    {
        if (!empty($this->caBundlePath)) {
            return $this->caBundlePath;
        }

        return $this->getDefaultCABundlePath();
    }

    /**
     * Returns the API key if set.
     *
     * @return string|null
     */
    public function getApiKey(): ?string
    {
        return $this->apiKey;
    }

    /**
     * Set application ID.
     *
     * @param ?string $appId
     *
     * @throws SumUpConfigurationException
     */
    protected function setAppId(?string $appId): void
    {
        if (empty($appId) && empty($this->apiKey)) {
            throw new SumUpConfigurationException('Missing mandatory parameter app_id or api_key');
        }
        $this->appId = $appId;
    }

    /**
     * Set application secret.
     *
     * @param string $appSecret
     *
     * @throws SumUpConfigurationException
     */
    protected function setAppSecret(?string $appSecret): void
    {
        if (empty($appSecret) && empty($this->apiKey)) {
            throw new SumUpConfigurationException('Missing mandatory parameter app_secret or api_key');
        }
        $this->appSecret = $appSecret;
    }

    /**
     * Set the authorization grant type.
     *
     * @param string $grantType
     *
     * @throws SumUpConfigurationException
     */
    protected function setGrantType(string $grantType): void
    {
        if (!in_array($grantType, $this::GRANT_TYPES)) {
            throw new SumUpConfigurationException('Invalid parameter for "grant_type". Allowed values are: ' . implode(' | ', $this::GRANT_TYPES) . '.');
        }
        $this->grantType = $grantType;
    }

    /**
     * Set the scopes and always include the default ones.
     *
     * @param array $scopes
     */
    protected function setScopes(array $scopes = []): void
    {
        $this->scopes = array_unique(array_merge($this::DEFAULT_SCOPES, $scopes), SORT_REGULAR);
    }

    /**
     * Set the flag whether to use GuzzleHttp.
     *
     * @param bool $forceGuzzle
     */
    protected function setForceGuzzle(bool $forceGuzzle): void
    {
        $this->forceGuzzle = $forceGuzzle;
    }

    /**
     * Set the associative array with custom headers.
     *
     * @param array $customHeaders
     */
    public function setCustomHeaders(array $customHeaders): void
    {
        $customHeaders[self::USER_AGENT_HEADER] = SdkInfo::getUserAgent();

        $this->customHeaders = $customHeaders;
    }

    /**
     * Set the CA bundle path used for TLS verification.
     *
     * @param string|null $caBundlePath
     *
     * @throws SumUpConfigurationException
     */
    protected function setCABundlePath(?string $caBundlePath): void
    {
        if ($caBundlePath === null || $caBundlePath === '') {
            $this->caBundlePath = null;
            return;
        }

        if (!is_readable($caBundlePath)) {
            throw new SumUpConfigurationException(sprintf('The provided ca_bundle_path "%s" is not readable.', $caBundlePath));
        }

        $this->caBundlePath = $caBundlePath;
    }

    /**
     * Returns the path to the CA bundle shipped with the SDK, if present.
     *
     * @return string|null
     */
    private function getDefaultCABundlePath(): ?string
    {
        $path = realpath(__DIR__ . '/../../../resources/ca-bundle.crt');
        if ($path && is_readable($path)) {
            return $path;
        }

        return null;
    }
}