Indigerd\Repository\Rest\RestRepository

Complexity

Total Complexity

29

Size/Duplication

Total Lines	276
Duplicated Lines	0 %

Coupling/Cohesion

Components	1
Dependencies	6

Importance

Changes

0

21 Methods

Rating	Name	Duplication	Size	Complexity
A	__construct()	0	11	1
A	findOne()	0	9	2
A	findAll()	0	15	2
A	aggregate()	0	4	1
A	aggregateCount()	0	4	1
A	aggregateSum()	0	4	1
A	aggregateAverage()	0	4	1
A	aggregateMin()	0	4	1
A	aggregateMax()	0	4	1
A	create()	0	4	1
A	populate()	0	4	1
A	insert()	0	4	1
A	update()	0	4	1
A	delete()	0	4	1
A	updateAll()	0	4	1
A	deleteAll()	0	4	1
A	addHeader()	0	5	1
A	addToken()	0	6	2
A	request()	0	26	4
A	formatResponseExceptionMessage()	0	11	1
A	generateHeaders()	0	10	3

<?php declare(strict_types=1);

namespace Indigerd\Repository\Rest;

use GuzzleHttp\Client;
use GuzzleHttp\Exception\BadResponseException;
use Indigerd\Hydrator\Hydrator;
use Indigerd\Repository\RepositoryInterface;
use Indigerd\Repository\Rest\Exception\ClientException;
use Indigerd\Repository\Rest\Exception\ServerException;

class RestRepository implements RepositoryInterface
{
    /**
     * @var Hydrator
     */
    protected $hydrator;

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

    /**
     * @var string
     */
    protected $modelClass;

    protected $endpoint;

    /**
     * @var array
     */
    protected $headers;

    /**
     * RestRepository constructor.
     * @param Hydrator $hydrator
     * @param Client $client
     * @param string $modelClass
     * @param string $collectionClass

There is no parameter named $collectionClass. Was it maybe removed?

     * @param string $endpoint
     */
    public function __construct(
        Hydrator $hydrator,
        Client $client,
        string $modelClass,
        string $endpoint
    ) {
        $this->hydrator = $hydrator;
        $this->client = $client;
        $this->modelClass = $modelClass;
        $this->endpoint = $endpoint;
    }

    public function findOne(array $conditions = [], array $with = []): object
    {
        if (!isset($conditions['id'])) {
            throw new \InvalidArgumentException('No id provided');
        }
        $url = \rtrim($this->endpoint, '/') . '/' . $conditions['id'];
        $response = $this->request('get', $url);
        return $this->hydrator->hydrate($this->modelClass, $response['body']);
    }

    public function findAll(
        array $conditions = [],
        array $order = [],
        int $limit = 0,
        int $offset = 0,
        array $with = []
    ): array {
        $url = \rtrim($this->endpoint, '/');
        $response = $this->request('get', $url, $conditions);
        $result = [];
        foreach ($response['body'] as $item) {
            $result[] = $this->hydrator->hydrate($this->modelClass, $item);
        }
        return $result;
    }

    /**
     * @param string $expression
     * @param array $conditions
     * @return string
     */
    public function aggregate(string $expression, array $conditions): string
    {
        throw new \RuntimeException('Not implemented');
    }

    /**
     * @param string $field
     * @param array $conditions
     * @return string
     */
    public function aggregateCount(string $field = '', array $conditions = []): string
    {
        throw new \RuntimeException('Not implemented');
    }

    /**
     * @param string $field
     * @param array $conditions
     * @return string
     */
    public function aggregateSum(string $field, array $conditions): string
    {
        throw new \RuntimeException('Not implemented');
    }

    /**
     * @param string $field
     * @param array $conditions
     * @return string
     */
    public function aggregateAverage(string $field, array $conditions): string
    {
        throw new \RuntimeException('Not implemented');
    }

    /**
     * @param string $field
     * @param array $conditions
     * @return string
     */
    public function aggregateMin(string $field, array $conditions): string
    {
        throw new \RuntimeException('Not implemented');
    }

    /**
     * @param string $field
     * @param array $conditions
     * @return string
     */
    public function aggregateMax(string $field, array $conditions): string
    {
        throw new \RuntimeException('Not implemented');
    }

    /**
     * @param array $data
     * @return object
     */
    public function create(array $data= []): object
    {
        throw new \RuntimeException('Not implemented');
    }

    /**
     * @param object $entity
     * @param array $data
     */
    public function populate(object $entity, array $data): void
    {
        throw new \RuntimeException('Not implemented');
    }

    /**
     * @param object $entity
     */
    public function insert(object $entity): void
    {
        throw new \RuntimeException('Not implemented');
    }

    /**
     * @param object $entity
     */
    public function update(object $entity): void
    {
        throw new \RuntimeException('Not implemented');
    }

    /**
     * @param object $entity
     */
    public function delete(object $entity): void
    {
        throw new \RuntimeException('Not implemented');
    }

    /**
     * @param array $data
     * @param array $conditions
     * @return int
     */
    public function updateAll(array $data, array $conditions): int
    {
        throw new \RuntimeException('Not implemented');
    }

    /**
     * @param array $conditions
     * @return int
     */
    public function deleteAll(array $conditions): int
    {
        throw new \RuntimeException('Not implemented');
    }

    /**
     * @param string $header
     * @param string $value
     * @return $this
     */
    public function addHeader(string $header, string $value)
    {
        $this->headers[$header] = $value;
        return $this;
    }

    /**
     * @param string $token
     */
    public function addToken(string $token)
    {
        if (!empty($token)) {
            $this->addHeader('Authorization', $token);
        }
    }

    /**
     * @param string $method
     * @param string $url
     * @param array $params
     * @return array
     */
    protected function request(string $method, string $url, array $params = []): array
    {
        $this->addHeader('Accept', 'application/json');
        $params['headers'] = $this->headers;

        try {
            /** @var \Psr\Http\Message\ResponseInterface $userRequest */
            $userRequest = $this->client->{$method}($url, $params);
        } catch (\GuzzleHttp\Exception\ClientException $e) {
            $message = $this->formatResponseExceptionMessage($e);
            throw new ClientException($e->getResponse()->getStatusCode(), $message);
        } catch (\GuzzleHttp\Exception\ServerException $e) {
            $message = $this->formatResponseExceptionMessage($e);
            throw new ServerException($message, $e->getResponse()->getStatusCode());
        } catch (\Exception $e) {
            $message = \sprintf('Failed to to perform request to service (%s).', $e->getMessage());
            throw new ServerException($message, $e->getCode());
        }

        $data = \json_decode($userRequest->getBody()->getContents(), true);

        return [
            'headers' => $userRequest->getHeaders(),
            'body' => $data
        ];
    }

    /**
     * @param BadResponseException $e
     * @return string
     */
    private function formatResponseExceptionMessage(BadResponseException $e): string
    {
        $message = \sprintf(
            'Service responded with error (%s - %s).',
            $e->getResponse()->getStatusCode(),
            $e->getResponse()->getReasonPhrase()
        );
        $message .= "\n" . $e->getResponse()->getBody()->getContents();

        return $message;
    }
    
     /**
     * @param array $response
     * @return array
     */
    public function generateHeaders(array $response): array
    {
        $headers = [];
        foreach ($this->headers as $header => $value) {
            if (isset($response[$header][0])) {
                $headers[$value] = $response[$header];
            }
        }
        return $headers;
    }
}