Zibios\WrikePhpGuzzle\Client\GuzzleClient

Complexity

Total Complexity

13

Size/Duplication

Total Lines	111
Duplicated Lines	0 %

Coupling/Cohesion

Components	2
Dependencies	2

Test Coverage

Coverage

35%

Importance

Changes

0

6 Methods

Rating	Name	Duplication	Size	Complexity
A	__construct()	0	5	1
A	getBearerToken()	0	4	1
A	executeRequestForParams()	0	6	1
A	transformApiException()	0	4	1
A	setBearerToken()	0	9	2
C	calculateOptionsForParams()	0	29	7

<?php
/**
 * This file is part of the WrikePhpGuzzle package.
 *
 * (c) Zbigniew Ślązak
 *
 * For the full copyright and license information, please view the LICENSE
 * file that was distributed with this source code.
 */

namespace Zibios\WrikePhpGuzzle\Client;

use GuzzleHttp\Client as BaseClient;
use Psr\Http\Message\ResponseInterface;
use Zibios\WrikePhpLibrary\Client\ClientInterface;
use Zibios\WrikePhpLibrary\Enum\Api\RequestMethodEnum;
use Zibios\WrikePhpLibrary\Exception\Api\ApiException;
use Zibios\WrikePhpLibrary\Transformer\ApiExceptionTransformerInterface;

/**
 * Guzzle Client
 */
class GuzzleClient extends BaseClient implements ClientInterface
{
    /**
     * @var string
     */
    protected $bearerToken = '';

    /**
     * @var ApiExceptionTransformerInterface
     */
    protected $apiExceptionTransformer;

    /**
     * Client constructor.
     *
     * @param ApiExceptionTransformerInterface $apiExceptionTransformer
     * @param array $config
     */
    public function __construct(ApiExceptionTransformerInterface $apiExceptionTransformer, array $config = [])
    {
        $this->apiExceptionTransformer = $apiExceptionTransformer;
        parent::__construct($config);
    }

    /**
     * @return string
     */
    public function getBearerToken()
    {
        return $this->bearerToken;
    }

    /**
     * @param string $bearerToken
     *
     * @return $this
     * @throws \InvalidArgumentException
     */
    public function setBearerToken($bearerToken)
    {
        if (is_string($bearerToken) === false) {
            throw new \InvalidArgumentException('Bearer Token should be a string!');
        }
        $this->bearerToken = $bearerToken;

        return $this;
    }

    /**
     * @param string $requestMethod
     * @param string $path
     * @param array $params
     *
     * @return ResponseInterface
     * @throws \InvalidArgumentException
     * @throws \Exception|ApiException
     */
    public function executeRequestForParams($requestMethod, $path, array $params)
    {
        $options = $this->calculateOptionsForParams($requestMethod, $params);

        return $this->request($requestMethod, $path, $options);
    }

    /**
     * @param string $requestMethod
     * @param array $params
     *
     * @return array

Consider making the return type a bit more specific; maybe use array<string,array<string,string>>.

     * @throws \InvalidArgumentException
     */
    protected function calculateOptionsForParams($requestMethod, array $params)
    {
        $requestMethod = strtoupper($requestMethod);
        $options = [];

        switch ($requestMethod) {
            case RequestMethodEnum::GET:
                if (count($params) > 0) {
                    $options['query'] = $params;
                }
                break;
            case RequestMethodEnum::PUT:
            case RequestMethodEnum::POST:
                if (count($params) > 0) {
                    $options['json'] = $params;
                }
                break;
            case RequestMethodEnum::DELETE:
                break;
            default:
                throw new \InvalidArgumentException();
        }
        $options['headers'] = [
            'Content-Type' => 'application/json',
            'Authorization' => sprintf('Bearer %s', $this->bearerToken),
        ];

        return $options;
    }

    /**
     * @param \Exception $exception
     *
     * @return \Exception|ApiException
     */
    public function transformApiException(\Exception $exception)
    {
        return $this->apiExceptionTransformer->transform($exception);
    }
}