Vox\Webservice\WebserviceClient

Complexity

Total Complexity

18

Size/Duplication

Total Lines	137
Duplicated Lines	0 %

Test Coverage

Coverage

90.91%

Importance

Changes

0

9 Methods

Rating	Name	Duplication	Size	Complexity
A	cGet()	0	17	3
A	get()	0	15	3
A	getClient()	0	7	2
A	getResource()	0	3	1
A	getMetadata()	0	3	1
A	put()	0	19	3
A	__construct()	0	10	1
A	post()	0	14	2
A	delete()	0	9	2

<?php

namespace Vox\Webservice;

use GuzzleHttp\ClientInterface;
use GuzzleHttp\Psr7\Request;
use Metadata\MetadataFactoryInterface;
use RuntimeException;
use Symfony\Component\Serializer\Normalizer\DenormalizerInterface;
use Symfony\Component\Serializer\Normalizer\NormalizerInterface;
use Vox\Webservice\Exception\WebserviceResponseException;
use Vox\Webservice\Mapping\Resource;
use Vox\Webservice\Metadata\TransferMetadata;

/**
 * the webservice client does the actual work of consuming and publishing data to the external webservices
 *
 * @author Jhonatan Teixeira <jhonatan.teixeira@gmail.com>
 */
class WebserviceClient implements WebserviceClientInterface
{
    /**
     * @var ClientRegistryInterface
     */
    private $clientRegistry;

    /**
     * @var MetadataFactoryInterface
     */
    private $metadataFactory;

    /**
     * @var DenormalizerInterface
     */
    private $denormalizer;

    /**
     * @var NormalizerInterface
     */
    private $normalizer;

    public function __construct(
        ClientRegistryInterface $clientRegistry,
        MetadataFactoryInterface $metadataFactory,
        DenormalizerInterface $denormalizer,
        NormalizerInterface $normalizer
    ) {
        $this->clientRegistry  = $clientRegistry;
        $this->metadataFactory = $metadataFactory;
        $this->denormalizer    = $denormalizer;
        $this->normalizer      = $normalizer;
    }

    public function cGet(string $transferName, array $filters = []): TransferCollection
    {
        $resource = $this->getResource($transferName);
        $client   = $this->getClient($transferName);
        $options  = ['headers' => ['Content-Type' => 'application/json']];

        if (!empty($filters)) {
            $options['query'] = $filters;
        }

        $response = $client->request('GET', $resource->route, $options);

        if ($response->getStatusCode() >= 300) {
            throw new WebserviceResponseException($response, new Request('GET', $response->route, $options));

Accessing route on the interface Psr\Http\Message\ResponseInterface suggest that you code against a concrete implementation. How about adding an instanceof check?

        }

        return new TransferCollection($transferName, $this->denormalizer, $response);
    }

    public function delete(string $transferName, $id)
    {
        $resource = $this->getResource($transferName);
        $client   = $this->getClient($transferName);
        $route    = sprintf('%s/%s', $resource->route, $id);
        $response = $client->request('DELETE', $route);

        if ($response->getStatusCode() >= 300) {
            throw new WebserviceResponseException($response, new Request('DELETE', $route));
        }
    }

    public function get(string $transferName, $id)
    {
        $resource = $this->getResource($transferName);
        $client   = $this->getClient($transferName);
        $route    = sprintf('%s/%s', $resource->route, $id);
        $response = $client->request('GET', $route, ['headers' => ['Content-Type' => 'application/json']]);
        
        if ($response->getStatusCode() >= 300) {
            throw new WebserviceResponseException($response, new Request('GET', $route));
        }

        $contents = $response->getBody()->getContents();
        
        if ($contents) {
            return $this->denormalizer->denormalize(json_decode($contents, true), $transferName);
        }
    }

    public function post($transfer)
    {
        $data = $this->normalizer->normalize($transfer, 'json');

        $resource = $this->getResource(get_class($transfer));
        $client   = $this->getClient(get_class($transfer));
        $response = $client->request('POST', $resource->route, ['json' => $data]);

        if ($response->getStatusCode() >= 300) {
            throw new WebserviceResponseException($response, new Request('POST', $resource->route, ['json' => $data]));
        }

        $contents = $response->getBody()->getContents();
        $this->denormalizer->denormalize(json_decode($contents, true), $transfer);
    }

    public function put($transfer)
    {
        $data     = $this->normalizer->normalize($transfer, 'json');
        $metadata = $this->getMetadata(get_class($transfer));
        $resource = $this->getResource(get_class($transfer));
        $client   = $this->getClient(get_class($transfer));

        if (empty($metadata->id)) {
            throw new RuntimeException('no id mapped for class ' . get_class($transfer));
        }

        $route    = sprintf('%s/%s', $resource->route, $metadata->id->getValue($transfer));
        $response = $client->request('PUT', $route, ['json' => $data]);

        if ($response->getStatusCode() >= 300) {
            throw new WebserviceResponseException($response, new Request('PUT', $route, ['json' => $data]));
        }

        $this->denormalizer->denormalize(json_decode($response->getBody()->getContents(), true), $transfer);
    }

    private function getClient(string $transferName, Resource $resource = null): ClientInterface
    {
        if (null === $resource) {
            $resource = $this->getResource($transferName);
        }

        return  $this->clientRegistry->get($resource->client);
    }

    private function getResource(string $transferName): Resource
    {
        return $this->getMetadata($transferName)->getAnnotation(Resource::class, true);

The expression return $this->getMetadata($transferName)->getAnnotation(Vox\Webservice\Mapping\Resource::class, true) could return the type null which is incompatible with the type-hinted return Vox\Webservice\Mapping\Resource. Consider adding an additional type-check to rule them out.

    }

    private function getMetadata(string $transferName): TransferMetadata
    {
        return $this->metadataFactory->getMetadataForClass($transferName);

The expression return $this->metadataFactory->getMetadataForClass($transferName) returns the type null|Metadata\ClassHierarchyMetadata which is incompatible with the type-hinted return Vox\Webservice\Metadata\TransferMetadata.

    }
}