Link0\Bunq\Client

Complexity

Total Complexity

22

Size/Duplication

Total Lines	178
Duplicated Lines	10.11 %

Coupling/Cohesion

Components	2
Dependencies	20

Importance

Changes

0

11 Methods

Rating	Name	Duplication	Size	Complexity
A	__construct()	0	17	1
A	get()	0	8	1
A	post()	9	9	1
A	put()	9	9	1
A	delete()	0	6	1
A	processResponse()	0	7	1
D	mapResponse()	0	25	10
A	addRequestIdMiddleware()	0	7	1
A	addRequestSignatureMiddleware()	0	8	1
A	addServerResponseMiddleware()	0	9	2
A	addDebugMiddleware()	0	6	2

<?php

namespace Link0\Bunq;

use GuzzleHttp\Client as GuzzleClient;
use GuzzleHttp\HandlerStack;
use GuzzleHttp\Middleware;
use Link0\Bunq\Domain\Certificate;
use Link0\Bunq\Domain\DeviceServer;
use Link0\Bunq\Domain\Id;
use Link0\Bunq\Domain\Keypair;
use Link0\Bunq\Domain\Keypair\PublicKey;
use Link0\Bunq\Domain\MonetaryAccountBank;
use Link0\Bunq\Domain\Payment;
use Link0\Bunq\Domain\Token;
use Link0\Bunq\Domain\UserCompany;
use Link0\Bunq\Domain\UserPerson;
use Link0\Bunq\Middleware\DebugMiddleware;
use Link0\Bunq\Middleware\RequestIdMiddleware;
use Link0\Bunq\Middleware\RequestSignatureMiddleware;
use Link0\Bunq\Middleware\ResponseSignatureMiddleware;
use Psr\Http\Message\ResponseInterface;

class Client
{
    /**
     * @var GuzzleClient
     */
    private $guzzle;

    /**
     * @var HandlerStack
     */
    private $handlerStack;

    /**
     * @param Environment $environment
     */
    public function __construct(Environment $environment, Keypair $keypair, PublicKey $serverPublicKey = null, string $sessionToken = '')
    {
        $this->handlerStack = HandlerStack::create();

        $this->addRequestIdMiddleware($sessionToken);
        $this->addRequestSignatureMiddleware($keypair);
        $this->addServerResponseMiddleware($serverPublicKey);
        $this->addDebugMiddleware($environment);

        $this->guzzle = new GuzzleClient([
            'base_uri' => $environment->endpoint(),
            'handler' => $this->handlerStack,
            'headers' => [
                'User-Agent' => 'Link0 Bunq API Client'
            ]
        ]);
    }

    /**
     * @param string $endpoint
     * @return array
     */
    public function get(string $endpoint, array $headers = [])
    {
        return $this->processResponse(
            $this->guzzle->request('GET', $endpoint, [
                'headers' => $headers,
            ])
        );
    }

    /**
     * @param string $endpoint
     * @param array $body
     * @param array $headers
     * @return array
     */
    public function post(string $endpoint, array $body, array $headers = [])

This method seems to be duplicated in your project.

    {
        return $this->processResponse(
            $this->guzzle->request('POST', $endpoint, [
                'json' => $body,
                'headers' => $headers,
            ])
        );
    }

    /**
     * @param string $endpoint
     * @param array $body
     * @param array $headers
     * @return array
     */
    public function put(string $endpoint, array $body, array $headers = [])

This method seems to be duplicated in your project.

    {
        return $this->processResponse(
            $this->guzzle->request('PUT', $endpoint, [
                'json' => $body,
                'headers' => $headers,
            ])
        );
    }

    /**
     * @param string $endpoint
     * @param array $headers
     * @return void
     */
    public function delete(string $endpoint, array $headers = [])
    {
        $this->guzzle->request('DELETE', $endpoint, [
            'headers' => $headers,
        ]);
    }

    /**
     * @param ResponseInterface $response
     * @return array|PaginatedResponse
     */
    private function processResponse(ResponseInterface $response)
    {
        $contents = (string) $response->getBody();
        $json = json_decode($contents, true);

        return new PaginatedResponse($this, $json);
    }

    public function mapResponse(string $key, array $value)
    {
        switch ($key) {
            case 'DeviceServer':
                return DeviceServer::fromArray($value);
            case 'MonetaryAccountBank':
                return MonetaryAccountBank::fromArray($value);
            case 'UserPerson':
                return UserPerson::fromArray($value);
            case 'UserCompany':
                return UserCompany::fromArray($value);
            case 'Id':
                return Id::fromInteger($value['id']);
            case 'CertificatePinned':
                return Certificate::fromArray($value);
            case 'Payment':
                return Payment::fromArray($value);
            case 'ServerPublicKey':
                return PublicKey::fromServerPublicKey($value);
            case 'Token':
                return Token::fromArray($value);
            default:
                throw new \Exception("Unknown struct type: " . $key);
        }
    }

    /**
     * @param string $sessionToken
     * @return void
     */
    private function addRequestIdMiddleware(string $sessionToken)
    {
        $this->handlerStack->push(
            Middleware::mapRequest(new RequestIdMiddleware($sessionToken)),
            'bunq_request_id'
        );
    }

    /**
     * @param Keypair $keypair
     * @return void
     */
    private function addRequestSignatureMiddleware(Keypair $keypair)
    {
        // TODO: Figure out if we can skip this middleware on POST /installation
        $this->handlerStack->push(
            Middleware::mapRequest(new RequestSignatureMiddleware($keypair->privateKey())),
            'bunq_request_signature'
        );
    }

    /**
     * @param PublicKey|null $serverPublicKey
     * @return void
     */
    private function addServerResponseMiddleware(PublicKey $serverPublicKey = null)
    {
        // If we have obtained the server's public key, we can verify responses
        if ($serverPublicKey instanceof PublicKey) {
            $this->handlerStack->push(
                Middleware::mapResponse(new ResponseSignatureMiddleware($serverPublicKey))
            );
        }
    }

    /**
     * @param Environment $environment
     * @return void
     */
    private function addDebugMiddleware(Environment $environment)
    {
        if ($environment->inDebugMode()) {
            $this->handlerStack->push(DebugMiddleware::tap(), 'debug_tap');
        }
    }
}