Vox\Webservice\TransferRepository

Complexity

Total Complexity

23

Size/Duplication

Total Lines	157
Duplicated Lines	0 %

Test Coverage

Coverage

89.06%

Importance

Changes

0

9 Methods

Rating	Name	Duplication	Size	Complexity
A	__construct()	0	12	1
A	prepareCollection()	0	5	1
A	findOneBy()	0	16	4
A	findAll()	0	7	1
A	find()	0	11	3
B	findOneByCriteria()	0	23	6
A	getClassName()	0	3	1
A	findByCriteria()	0	17	3
A	findBy()	0	15	3

<?php

namespace Vox\Webservice;

use Doctrine\Common\Collections\ArrayCollection;
use Doctrine\Common\Collections\Collection;
use Vox\Webservice\Exception\WebserviceResponseException;
use Vox\Webservice\Proxy\ProxyFactoryInterface;

/**
 * the transfer repository does the job of requiring data from the webservice client for the correct transfer
 * however this pattern should be more flexible, a future release will fix this
 * 
 * @author Jhonatan Teixeira <jhonatan.teixeira@gmail.com>
 */
final class TransferRepository implements TransferRepositoryInterface
{
    private $transferName;
    
    /**
     * @var WebserviceClientInterface
     */
    private $webserviceClient;
    
    /**
     * @var ObjectStorageInterface
     */
    private $objectStorage;
    
    /**
     * @var TransferManagerInterface
     */
    private $transferManager;
    
    /**
     * @var ProxyFactoryInterface
     */
    private $proxyFactory;
    
    /**
     * @param string $transferName
     * @param WebserviceClientInterface $webserviceClient
     * @param ObjectStorageInterface $objectStorage
     * @param TransferManagerInterface $transferManager
     * @param ProxyFactoryInterface $proxyFactory
     */
    public function __construct(
        string $transferName, 
        WebserviceClientInterface $webserviceClient, 
        ObjectStorageInterface $objectStorage,
        TransferManagerInterface $transferManager,
        ProxyFactoryInterface $proxyFactory
    ) {
        $this->transferName     = $transferName;
        $this->webserviceClient = $webserviceClient;
        $this->objectStorage    = $objectStorage;
        $this->transferManager  = $transferManager;
        $this->proxyFactory     = $proxyFactory;
    }
    
    public function find($id)
    {
        $transfer = $this->objectStorage->fetchByParams($this->transferName, $id)
            ?? $this->proxyFactory
                ->createProxy($this->webserviceClient->get($this->transferName, $id), $this->transferManager);
        
        if ($transfer && !$this->objectStorage->contains($transfer)) {
            $this->objectStorage->attach($transfer);
        }
        
        return $transfer;

The expression return $transfer also could return the type ProxyManager\Proxy\AccessInterceptorValueHolderInterface which is incompatible with the return type mandated by Doctrine\Common\Persistence\ObjectRepository::find() of object|null.

    }

    public function findAll(): Collection
    {
        $collection = $this->webserviceClient->cGet($this->transferName);

        $this->prepareCollection($collection);

        return $collection;

The expression return $collection returns the type Vox\Webservice\TransferCollection which is incompatible with the return type mandated by Doctrine\Common\Persistence\ObjectRepository::findAll() of array.

    }

    public function findBy(array $criteria, array $orderBy = null, $limit = null, $offset = null): Collection
    {
        try {
            $collection = $this->webserviceClient->cGet($this->transferName, $criteria);
        } catch (WebserviceResponseException $exception) {
            if ($exception->getCode() == '404') {
                return new ArrayCollection();

The expression return new Doctrine\Common\Collections\ArrayCollection() returns the type Doctrine\Common\Collections\ArrayCollection which is incompatible with the return type mandated by Doctrine\Common\Persistence\ObjectRepository::findBy() of array.

            }

            throw $exception;
        }

        $this->prepareCollection($collection);

        return $collection;

The expression return $collection returns the type Vox\Webservice\TransferCollection which is incompatible with the return type mandated by Doctrine\Common\Persistence\ObjectRepository::findBy() of array.

    }

    public function findOneBy(array $criteria)
    {
        try {
            $collection = $this->webserviceClient->cGet($this->transferName, $criteria);
        } catch (WebserviceResponseException $exception) {
            if ($exception->getCode() == '404') {
                return null;
            }

            throw $exception;
        }

        $this->prepareCollection($collection);

        if ($collection->count() > 0) {
            return $collection->first();

The expression return $collection->first() also could return the type ProxyManager\Proxy\AccessInterceptorValueHolderInterface which is incompatible with the return type mandated by Doctrine\Common\Persistence\ObjectRepository::findOneBy() of object|null.

        }
    }

    public function findByCriteria(CriteriaInterface $criteria): Collection
    {
        $criteria->withOperationType(CriteriaInterface::OPERATION_TYPE_COLLECTION);

        try {
            $collection = $this->webserviceClient->getByCriteria($criteria, $this->transferName);
        } catch (WebserviceResponseException $ex) {
            if ($ex->getCode() == '404') {
                return new ArrayCollection();
            }

            throw $ex;
        }

        $this->prepareCollection($collection);

        return $collection;
    }

    public function findOneByCriteria(CriteriaInterface $criteria)
    {
        $criteria->withOperationType(CriteriaInterface::OPERATION_TYPE_ITEM);

        try {
            $transfer = $this->webserviceClient->getByCriteria($criteria, $this->transferName);
        } catch (WebserviceResponseException $exception) {
            if ($exception->getCode() == '404') {
                return null;
            }

            throw $exception;
        }

        if ($transfer && !$this->objectStorage->contains($transfer)) {
            $this->objectStorage->attach($transfer);
        }
        
        if ($transfer) {
            $transfer = $this->proxyFactory->createProxy($transfer, $this->transferManager);
        }

        return $transfer;
    }

    private function prepareCollection(TransferCollection $collection)
    {
        $collection->setObjectStorage($this->objectStorage)
            ->setTransferManager($this->transferManager)
            ->setProxyFactory($this->proxyFactory);
    }

    public function getClassName(): string
    {
        return $this->transferName;
    }
}