Xsolve\SalesforceClient\Security\Authentication\Authenticator

Complexity

Total Complexity

14

Size/Duplication

Total Lines	100
Duplicated Lines	0 %

Coupling/Cohesion

Components	1
Dependencies	8

Test Coverage

Coverage

87.88%

Importance

Changes

0

5 Methods

Rating	Name	Duplication	Size	Complexity
A	__construct()	0	5	1
A	authenticate()	0	19	3
A	parse()	0	18	3
A	regenerate()	0	10	3
A	hasRequiredFields()	0	16	4

<?php

namespace Xsolve\SalesforceClient\Security\Authentication;

use Xsolve\SalesforceClient\Http\ClientInterface;
use Xsolve\SalesforceClient\Http\HttpException;
use Xsolve\SalesforceClient\Request\RequestInterface;
use Xsolve\SalesforceClient\Security\Authentication\Strategy\RegenerateStrategyInterface;
use Xsolve\SalesforceClient\Security\Token\Token;
use Xsolve\SalesforceClient\Security\Token\TokenInterface;

class Authenticator implements AuthenticatorInterface
{
    const ENDPOINT = '/services/oauth2/token';

    /**
     * @var ClientInterface
     */
    protected $client;

    /**
     * @var RegenerateStrategyInterface[]
     */
    protected $regenerateStrategies;

    /**
     * @param ClientInterface               $client
     * @param RegenerateStrategyInterface[] $regenerateStrategies
     */
    public function __construct(ClientInterface $client, array $regenerateStrategies = [])
    {
        $this->client = $client;
        $this->regenerateStrategies = $regenerateStrategies;
    }

    /**
     * {@inheritdoc}
     */
    public function authenticate(Credentials $credentials): TokenInterface
    {
        try {
            $response = $this->client->request(RequestInterface::METHOD_POST, self::ENDPOINT, [
                'form_params' => $credentials->getParameters(),
            ])->getBody();
        } catch (HttpException $e) {
            throw new Exception\AuthenticationRequestException('Authentication request failed.', 400, $e);
        }

        $parsedBody = $this->parse($response);

        return new Token(
            $parsedBody['token_type'],
            $parsedBody['access_token'],
            $parsedBody['instance_url'],
            isset($parsedBody['refresh_token']) ? $parsedBody['refresh_token'] : ''
        );
    }

    /**
     * @throws Exception\InvalidAuthenticationResponseException
     */
    private function parse($rawResponse): array
    {
        $parsedBody = json_decode($rawResponse, true);

        if (!$parsedBody) {
            throw new Exception\InvalidAuthenticationResponseException(
                sprintf('Cannot decode response: %s', $rawResponse)
            );
        }

        if (!$this->hasRequiredFields($parsedBody)) {
            throw new Exception\InvalidAuthenticationResponseException(
                'Response does not contains required fields: token_type, access_token, instance_url.'
            );
        }

        return $parsedBody;
    }

    /**
     * {@inheritdoc}
     */
    public function regenerate(Credentials $credentials, TokenInterface $token): TokenInterface
    {
        foreach ($this->regenerateStrategies as $strategy) {
            if ($strategy->supports($credentials, $token)) {
                return $this->authenticate($strategy->getCredentials($credentials, $token));
            }
        }

        throw new Exception\UnsupportedCredentialsException('Strategy not found for given credentials and token.');
    }

    protected function hasRequiredFields(array $array): bool
    {
        if (!isset($array['token_type'])) {
            return false;
        }

        if (!isset($array['access_token'])) {
            return false;
        }

        if (!isset($array['instance_url'])) {
            return false;
        }

        return true;
    }
}