TransferRepository::findOneByCriteria() - Code Metrics - Inspection of "correção de getByCriteria" - jhonatanTeixeira/restfull-client-orm - Measure and Improve Code Quality continuously with Scrutinizer

Passed

Push — master ( 638587...464501 )

by JHONATAN

created 2018-03-22 19:16 UTC

TransferRepository::findOneByCriteria() B

↳ Parent: TransferRepository

Complexity

Conditions	6
Paths	6

Size

Total Lines	23
Code Lines	12

Duplication

Lines	0
Ratio	0 %

Code Coverage

Tests	11
CRAP Score	6.0208

Importance

Changes

Metric	Value
dl	0
loc	23
ccs	11
cts	12
cp	0.9167
rs	8.5906
c	0
b	0
f	0
cc	6
eloc	12
nc	6
nop	1
crap	6.0208

<?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 <[email protected]>
 */
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;

    }

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

        $this->prepareCollection($collection);

        return $collection;
interface HasName {
    /** @return string */
    public function getName();
}

class Name {
    public $name;
}

class User implements HasName {
    /** @return string|Name */
    public function getName() {
        return new Name('foo'); // This is a violation of the ``HasName`` interface
                                // which only allows a string value to be returned.
    }
}
    }

    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();
interface HasName {
    /** @return string */
    public function getName();
}

class Name {
    public $name;
}

class User implements HasName {
    /** @return string|Name */
    public function getName() {
        return new Name('foo'); // This is a violation of the ``HasName`` interface
                                // which only allows a string value to be returned.
    }
}
            }

            throw $exception;
        }

        $this->prepareCollection($collection);

        return $collection;
interface HasName {
    /** @return string */
    public function getName();
}

class Name {
    public $name;
}

class User implements HasName {
    /** @return string|Name */
    public function getName() {
        return new Name('foo'); // This is a violation of the ``HasName`` interface
                                // which only allows a string value to be returned.
    }
}
    }

    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();

        }
    }

    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;
    }
}


1		<?php
2
3		namespace Vox\Webservice;
4
5		use Doctrine\Common\Collections\ArrayCollection;
6		use Doctrine\Common\Collections\Collection;
7		use Vox\Webservice\Exception\WebserviceResponseException;
8		use Vox\Webservice\Proxy\ProxyFactoryInterface;
9
10		/**
11		* the transfer repository does the job of requiring data from the webservice client for the correct transfer
12		* however this pattern should be more flexible, a future release will fix this
13		*
14		* @author Jhonatan Teixeira <[email protected]>
15		*/
16		final class TransferRepository implements TransferRepositoryInterface
17		{
18		private $transferName;
19
20		/**
21		* @var WebserviceClientInterface
22		*/
23		private $webserviceClient;
24
25		/**
26		* @var ObjectStorageInterface
27		*/
28		private $objectStorage;
29
30		/**
31		* @var TransferManagerInterface
32		*/
33		private $transferManager;
34
35		/**
36		* @var ProxyFactoryInterface
37		*/
38		private $proxyFactory;
39
40		/**
41		* @param string $transferName
42		* @param WebserviceClientInterface $webserviceClient
43		* @param ObjectStorageInterface $objectStorage
44		* @param TransferManagerInterface $transferManager
45		* @param ProxyFactoryInterface $proxyFactory
46		*/
47	21	public function __construct(
48		string $transferName,
49		WebserviceClientInterface $webserviceClient,
50		ObjectStorageInterface $objectStorage,
51		TransferManagerInterface $transferManager,
52		ProxyFactoryInterface $proxyFactory
53		) {
54	21	$this->transferName = $transferName;
55	21	$this->webserviceClient = $webserviceClient;
56	21	$this->objectStorage = $objectStorage;
57	21	$this->transferManager = $transferManager;
58	21	$this->proxyFactory = $proxyFactory;
59	21	}
60
61	11	public function find($id)
62		{
63	11	$transfer = $this->objectStorage->fetchByParams($this->transferName, $id)
64	11	?? $this->proxyFactory
65	11	->createProxy($this->webserviceClient->get($this->transferName, $id), $this->transferManager);
66
67	11	if ($transfer && !$this->objectStorage->contains($transfer)) {
68	11	$this->objectStorage->attach($transfer);
69		}
70
71	11	return $transfer;
		0 ignored issues – show Bug Best Practice introduced 2017-12-26 15:26 UTC by Report Bug Copy Issue Report The expression `return $transfer` also could return the type `ProxyManager\Proxy\Acces...torValueHolderInterface` which is incompatible with the return type mandated by `Doctrine\Common\Persiste...bjectRepository::find()` of `object\|null`. Loading history...
72		}
73
74	2	public function findAll(): Collection
75		{
76	2	$collection = $this->webserviceClient->cGet($this->transferName);
77
78	2	$this->prepareCollection($collection);
79
80	2	return $collection;
		0 ignored issues – show Bug Best Practice introduced 2017-12-09 01:30 UTC by Report Bug Copy Issue Report The expression `return $collection` returns the type `Vox\Webservice\TransferCollection` which is incompatible with the return type mandated by `Doctrine\Common\Persiste...ctRepository::findAll()` of `array`. In the issue above, the returned value is violating the contract defined by the mentioned interface. Let's take a look at an example: interface HasName { /** @return string / public function getName(); } class Name { public $name; } class User implements HasName { /* @return string\|Name */ public function getName() { return new Name('foo'); // This is a violation of the ``HasName`` interface // which only allows a string value to be returned. } } Loading history...
81		}
82
83	3	public function findBy(array $criteria, array $orderBy = null, $limit = null, $offset = null): Collection
84		{
85		try {
86	3	$collection = $this->webserviceClient->cGet($this->transferName, $criteria);
87	1	} catch (WebserviceResponseException $exception) {
88	1	if ($exception->getCode() == '404') {
89	1	return new ArrayCollection();
		0 ignored issues – show Bug Best Practice introduced 2018-01-19 21:46 UTC by Report Bug Copy Issue Report The expression `return new Doctrine\Comm...tions\ArrayCollection()` returns the type `Doctrine\Common\Collections\ArrayCollection` which is incompatible with the return type mandated by `Doctrine\Common\Persiste...ectRepository::findBy()` of `array`. In the issue above, the returned value is violating the contract defined by the mentioned interface. Let's take a look at an example: interface HasName { /** @return string / public function getName(); } class Name { public $name; } class User implements HasName { /* @return string\|Name */ public function getName() { return new Name('foo'); // This is a violation of the ``HasName`` interface // which only allows a string value to be returned. } } Loading history...
90		}
91
92		throw $exception;
93		}
94
95	2	$this->prepareCollection($collection);
96
97	2	return $collection;
		0 ignored issues – show Bug Best Practice introduced 2018-01-19 21:46 UTC by Report Bug Copy Issue Report The expression `return $collection` returns the type `Vox\Webservice\TransferCollection` which is incompatible with the return type mandated by `Doctrine\Common\Persiste...ectRepository::findBy()` of `array`. In the issue above, the returned value is violating the contract defined by the mentioned interface. Let's take a look at an example: interface HasName { /** @return string / public function getName(); } class Name { public $name; } class User implements HasName { /* @return string\|Name */ public function getName() { return new Name('foo'); // This is a violation of the ``HasName`` interface // which only allows a string value to be returned. } } Loading history...
98		}
99
100	2	public function findOneBy(array $criteria)
101		{
102		try {
103	2	$collection = $this->webserviceClient->cGet($this->transferName, $criteria);
104	1	} catch (WebserviceResponseException $exception) {
105	1	if ($exception->getCode() == '404') {
106	1	return null;
107		}
108
109		throw $exception;
110		}
111
112	1	$this->prepareCollection($collection);
113
114	1	if ($collection->count() > 0) {
115	1	return $collection->first();
		0 ignored issues – show Bug Best Practice introduced 2018-02-02 20:42 UTC by Report Bug Copy Issue Report The expression `return $collection->first()` also could return the type `ProxyManager\Proxy\Acces...torValueHolderInterface` which is incompatible with the return type mandated by `Doctrine\Common\Persiste...Repository::findOneBy()` of `object\|null`. Loading history...
116		}
117		}
118
119	2	public function findByCriteria(CriteriaInterface $criteria): Collection
120		{
121	2	$criteria->withOperationType(CriteriaInterface::OPERATION_TYPE_COLLECTION);
122
123		try {
124	2	$collection = $this->webserviceClient->getByCriteria($criteria, $this->transferName);
125	1	} catch (WebserviceResponseException $ex) {
126	1	if ($ex->getCode() == '404') {
127	1	return new ArrayCollection();
128		}
129
130		throw $ex;
131		}
132
133	1	$this->prepareCollection($collection);
134
135	1	return $collection;
136		}
137
138	2	public function findOneByCriteria(CriteriaInterface $criteria)
139		{
140	2	$criteria->withOperationType(CriteriaInterface::OPERATION_TYPE_ITEM);
141
142		try {
143	2	$transfer = $this->webserviceClient->getByCriteria($criteria, $this->transferName);
144	1	} catch (WebserviceResponseException $exception) {
145	1	if ($exception->getCode() == '404') {
146	1	return null;
147		}
148
149		throw $exception;
150		}
151
152	1	if ($transfer && !$this->objectStorage->contains($transfer)) {
153	1	$this->objectStorage->attach($transfer);
154		}
155
156	1	if ($transfer) {
157	1	$transfer = $this->proxyFactory->createProxy($transfer, $this->transferManager);
158		}
159
160	1	return $transfer;
161		}
162
163	6	private function prepareCollection(TransferCollection $collection)
164		{
165	6	$collection->setObjectStorage($this->objectStorage)
166	6	->setTransferManager($this->transferManager)
167	6	->setProxyFactory($this->proxyFactory);
168	6	}
169
170		public function getClassName(): string
171		{
172		return $this->transferName;
173		}
174		}
175

jhonatanTeixeira / restfull-client-orm

Push — master ( 638587...464501 )

TransferRepository::findOneByCriteria() B

Complexity

Size

Duplication

Code Coverage

Importance

Duplication Side-by-Side

Filter issues like