JPBernius\OAuth2\Client\Provider\DooProvider

Complexity

Total Complexity

21

Size/Duplication

Total Lines	220
Duplicated Lines	0 %

Coupling/Cohesion

Components	4
Dependencies	5

Test Coverage

Coverage

87.1%

Importance

Changes	4
Bugs	0	Features	1

15 Methods

Rating	Name	Duplication	Size	Complexity
A	getConfigurableOptions()	0	13	1
A	getBaseUri()	0	4	1
A	getResourceOwnerDetailsUrl()	0	4	1
A	getDefaultScopes()	0	4	1
A	getScopeSeparator()	0	4	2
A	createResourceOwner()	0	4	1
A	__construct()	0	14	2
A	getBaseAuthorizationUrl()	0	4	1
A	getBaseAccessTokenUrl()	0	4	1
A	checkResponse()	0	8	3
A	createAccessToken()	0	14	2
A	getDefaultHeaders()	0	6	1
A	getAccessTokenOptions()	0	10	2
A	getAccessTokenBody()	0	4	1
A	getBearerAuthorizationHeader()	0	5	1

<?php
/**
 * This file is based on the Generic Provider from the league/oauth2-client library
 *
 * For the full copyright and license information, please view the LICENSE
 * file that is distributed with the league/oauth2-client library.
 */

namespace JPBernius\OAuth2\Client\Provider;

use League\OAuth2\Client\Grant\AbstractGrant;
use League\OAuth2\Client\Provider\AbstractProvider;
use League\OAuth2\Client\Provider\Exception\IdentityProviderException;
use League\OAuth2\Client\Provider\GenericResourceOwner;
use League\OAuth2\Client\Token\AccessToken;
use League\OAuth2\Client\Tool\BearerAuthorizationTrait;
use Psr\Http\Message\ResponseInterface;

/**
 * OAuth 2.0 service provider for interaction with doo.net API using Bearer token authentication.
 */
class DooProvider extends AbstractProvider
{
    use BearerAuthorizationTrait;

    /**
     * @var string
     */
    private $apiUrl = 'https://api.doo.net/v1/';

    /**
     * @var string
     */
    private $uriAuthorize = 'oauth';

    /**
     * @var string
     */
    private $uriAccessToken = 'oauth';

    /**
     * @var string
     */
    private $uriResourceOwnerDetails = 'organizers/current';

    /**
     * @var array|null
     */
    private $scopes = null;

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

    /**
     * @var string
     */
    private $responseError = 'error';

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

    /**
     * @var string
     */
    private $responseResourceOwnerId = 'id';

    /**
     * @param array $options
     * @param array $collaborators
     */
    public function __construct(array $options = [], array $collaborators = [])
    {
        $possible   = $this->getConfigurableOptions();
        $configured = array_intersect_key($options, array_flip($possible));

        foreach ($configured as $key => $value) {
            $this->$key = $value;
        }

        // Remove all options that are only used locally
        $options = array_diff_key($options, $configured);

        parent::__construct($options, $collaborators);
    }

    /**
     * Returns all options that can be configured.
     *
     * @return array
     */
    protected function getConfigurableOptions()
    {
        return [
            'urlAuthorize',
            'urlAccessToken',
            'uriResourceOwnerDetails',
            'scopeSeparator',
            'responseError',
            'responseCode',
            'scopes',
            'apiUrl'
        ];
    }

    public function getBaseUri()
    {
        return $this->apiUrl;
    }

    /**
     * @inheritdoc
     */
    public function getBaseAuthorizationUrl()
    {
        return $this->getBaseUri() . $this->uriAuthorize;
    }

    /**
     * @inheritdoc
     */
    public function getBaseAccessTokenUrl(array $params)
    {
        return $this->getBaseUri() . $this->uriAccessToken;
    }

    /**
     * @inheritdoc
     */
    public function getResourceOwnerDetailsUrl(AccessToken $token)
    {
        return $this->getBaseUri() . $this->uriResourceOwnerDetails;
    }

    /**
     * @inheritdoc
     */
    public function getDefaultScopes()
    {
        return $this->scopes;
    }

    /**
     * @inheritdoc
     */
    protected function getScopeSeparator()
    {
        return $this->scopeSeparator ?: parent::getScopeSeparator();
    }

    /**
     * @inheritdoc
     */
    protected function checkResponse(ResponseInterface $response, $data)
    {
        if (!empty($data[$this->responseError])) {
            $error = $data[$this->responseError];
            $code  = $this->responseCode ? $data[$this->responseCode] : 0;
            throw new IdentityProviderException($error, $code, $data);
        }
    }

    /**
     * @inheritdoc
     */
    protected function createResourceOwner(array $response, AccessToken $token)
    {
        return new GenericResourceOwner($response, $this->responseResourceOwnerId);
    }

    /**
     * @param array $response
     * @param AbstractGrant $grant
     * @return AccessToken
     */
    protected function createAccessToken(array $response, AbstractGrant $grant)
    {
        if (isset($response['data'])) {
            $data = $response['data'];
            return new AccessToken($data);
        }

        throw new IdentityProviderException(
            'Bad Request',
            400,
            'Data provided for issuing access_token is not correct'
        );
        
    }

    /**
     * Returns the default headers used by this provider.
     *
     * Typically this is used to set 'Accept' or 'Content-Type' headers.
     *
     * @return array
     */
    protected function getDefaultHeaders()
    {
        return [
            'Accept' => 'application/hal+json'
        ];
    }

    /**
     * Builds request options used for requesting an access token.
     *
     * @param  array $params
     * @return array
     */
    protected function getAccessTokenOptions(array $params)
    {
        $options = ['headers' => ['content-type' => 'application/json']];

        if ($this->getAccessTokenMethod() === self::METHOD_POST) {
            $options['body'] = $this->getAccessTokenBody($params);
        }

        return $options;
    }

    /**
     * Returns the request body for requesting an access token.
     *
     * @param  array $params
     * @return string
     */
    protected function getAccessTokenBody(array $params)
    {
        return json_encode($params);
    }

    public function getBearerAuthorizationHeader()
    {
        $token = $this->getAccessToken('client_credentials')->getToken();
        return $this->getAuthorizationHeaders($token);
    }
}