Base::createEntity() - Code Metrics - Inspection of "chore: CI fixes" - neta-io/shopware-sdk - Measure and Improve Code Quality continuously with Scrutinizer

Completed

Push — master ( b98016...0803ae )

by Mohamed

created 2019-04-26 10:06 UTC

Base::createEntity() A

↳ Parent: Base

Complexity

Conditions	2
Paths	2

Size

Total Lines

Duplication

Lines	0
Ratio	0 %

Code Coverage

Tests	0
CRAP Score	6

Importance

Changes

Metric	Value
dl	0
loc	12
ccs	0
cts	10
cp	0
rs	9.8666
c	0
b	0
f	0
cc	2
nc	2
nop	1
crap	6

<?php

namespace Neta\Shopware\SDK\Query;

use Neta\Shopware\SDK\ShopwareClient;
use Neta\Shopware\SDK\Util\ArrayUtil;
use Neta\Shopware\SDK\Util\Constants;
use Psr\Http\Message\ResponseInterface;
use Neta\Shopware\SDK\Exception\MethodNotAllowedException;

/**
 * Class Base.
 *
 * @author    Alexander Mahrt <[email protected]>
 * @copyright 2016 LeadCommerce <[email protected]>
 */
abstract class Base
{
    /**
     * @var ShopwareClient
     */
    protected $client;

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

    /**
     * @var array
     */
    protected $methodsAllowed = [
        Constants::METHOD_CREATE,
        Constants::METHOD_GET,
        Constants::METHOD_GET_BATCH,
        Constants::METHOD_UPDATE,
        Constants::METHOD_UPDATE_BATCH,
        Constants::METHOD_DELETE,
        Constants::METHOD_DELETE_BATCH,
    ];

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

    /**
     * @var int
     */
    protected $total;

    /**
     * Base constructor.
     *
     * @param $client
     */
    public function __construct($client)
    {
        $this->client = $client;
        $this->queryPath = $this->getQueryPath();
    }

    /**
     * Gets the query path to look for entities.
     * E.G: 'variants' or 'articles'.
     *
     * @return string
     */
    abstract protected function getQueryPath();

    /**
     * Finds all entities.
     *
     * @return \Neta\Shopware\SDK\Entity\Base[]
     */
    public function findAll()
    {
        $this->validateMethodAllowed(Constants::METHOD_GET_BATCH);

        return $this->fetch($this->queryPath);
    }

    /**
     * Finds entities by params.
     *
     * e.g.:
     *
     * $params = [
     *      'limit' => 10,
     *      'start' => 20,
     *      'sort' => [
     *          [
     *              'property' => 'name',
     *              'direction' => 'ASC'
     *          ]
     *      ],
     *      'filter' => [
     *          [
     *              'property' => 'name',
     *              'expression' => 'LIKE',
     *              'value' => '%foo'
     *          ],
     *          [
     *              'operator'   => 'AND',
     *              'property'   => 'number',
     *              'expression' => '>',
     *              'value'      => '500'
     *          ]
     *      ]
     * ]
     *
     * @param array $params
     *
     * @return \Neta\Shopware\SDK\Entity\Base[]
     */
    public function findByParams($params)
    {
        $this->validateMethodAllowed(Constants::METHOD_GET_BATCH);

        return $this->fetch($this->queryPath, 'GET', null, [], $params);
    }

    /**
     * Validates if the requested method is allowed.
     *
     * @param $method
     *
     * @throws MethodNotAllowedException
     */
    private function validateMethodAllowed($method)
    {
        if (! in_array($method, $this->methodsAllowed)) {
            throw new MethodNotAllowedException('Method ' . $method . ' is not allowed for ' . get_class($this));
        }
    }

    /**
     * Fetch and build entity.
     *
     * @param        $uri
     * @param string $method
     * @param null   $body
     * @param array  $headers
     * @param array  $uriParams
     *
     * @return array|mixed
     */
    protected function fetch($uri, $method = 'GET', $body = null, $headers = [], $uriParams = [])
    {
        if (is_array($uriParams) && count($uriParams) > 0) {
            if (strpos($uri, '?') !== false) {
                parse_str(substr($uri, strpos($uri, '?') + 1), $existingUriParams);
                ArrayUtil::mergeRecursiveWithOverrule($existingUriParams, $uriParams);
/**
 * @return array|string
 */
function returnsDifferentValues($x) {
    if ($x) {
        return 'foo';
    }

    return array();
}

$x = returnsDifferentValues($y);
if (is_array($x)) {
    // $x is an array.
}
                $uri = substr($uri, 0, strpos($uri, '?')) . '?' . http_build_query($existingUriParams);
            } else {
                $uri = $uri . '?' . http_build_query($uriParams);
            }
        }
        $response = $this->client->request($uri, $method, $body, $headers);

        return $this->createEntityFromResponse($response);
    }

    /**
     * Creates an entity.
     *
     * @param ResponseInterface $response
     *
     * @return array|\Neta\Shopware\SDK\Entity\Base
     */
    protected function createEntityFromResponse(ResponseInterface $response)
    {
        $result = [];
        $content = $response->getBody()->getContents();
        $content = json_decode($content);
        $this->data = isset($content->data) ? $content->data : null;
        $this->total = isset($content->total) ? $content->total : null;

        if (is_array($this->data)) {
            $result = array_map(function ($item) {
                if (isset($item->id)) {
                    return $this->createEntity($item);
                }
                if (isset($item->data) && isset($item->data->id)) {
                    return $this->createEntity($item->data);
                }
            }, $this->data);
        }

        if (is_object($this->data)) {
            $result = $this->createEntity($this->data);
        }

        return $result;
    }

    /**
     * Creates an entity based on the getClass method.
     *
     * @param $content
     *
     * @return \Neta\Shopware\SDK\Entity\Base
     */
    protected function createEntity($content)
    {
        $class = $this->getClass();
        $entity = new $class();

        if ($entity instanceof \Neta\Shopware\SDK\Entity\Base) {
            $content = json_decode(json_encode($content), true);
            $entity->setEntityAttributes($content);
        }

        return $entity;
    }

    /**
     * Gets the class for the entities.
     *
     * @return string
     */
    abstract protected function getClass();

    /**
     * Finds an entity by its id.
     *
     * @param mixed $id
     * @param array $params
     *
     * @return \Neta\Shopware\SDK\Entity\Base
     */
    public function findOne($id, $params = [])
    {
        $this->validateMethodAllowed(Constants::METHOD_GET);

        return $this->fetch($this->queryPath . '/' . $id, 'GET', null, [], $params);

    }

    /**
     * Creates an entity.
     *
     * @param \Neta\Shopware\SDK\Entity\Base $entity
     * @param array                                  $params
     *
     * @return \Neta\Shopware\SDK\Entity\Base
     * @throws MethodNotAllowedException
     */
    public function create(\Neta\Shopware\SDK\Entity\Base $entity, $params = [])
    {
        $this->validateMethodAllowed(Constants::METHOD_CREATE);

        return $this->fetch($this->queryPath, 'POST', $entity->getArrayCopy(), [], $params);

    }

    /**
     * Updates an entity.
     *
     * @param \Neta\Shopware\SDK\Entity\Base $entity
     * @param array                                  $params
     *
     * @return array|mixed
     * @throws MethodNotAllowedException
     */
    public function update(\Neta\Shopware\SDK\Entity\Base $entity, $params = [])
    {
        $this->validateMethodAllowed(Constants::METHOD_UPDATE);

        return $this->fetch($this->queryPath . '/' . $entity->getId(), 'PUT', $entity->getArrayCopy(), [], $params);
    }

    /**
     * Updates a batch of this entity.
     *
     * @param \Neta\Shopware\SDK\Entity\Base[] $entities
     * @param array                                    $params
     *
     * @return \Neta\Shopware\SDK\Entity\Base[]
     */
    public function updateBatch($entities, $params = [])
    {
        $this->validateMethodAllowed(Constants::METHOD_UPDATE_BATCH);
        $body = [];
        foreach ($entities as $entity) {
            $body[] = $entity->getArrayCopy();
        }

        return $this->fetch($this->queryPath . '/', 'PUT', $body, [], $params);
    }

    /**
     * Deletes an entity by its id..
     *
     * @param mixed $id
     * @param array $params
     *
     * @return array|mixed
     * @throws MethodNotAllowedException
     */
    public function delete($id, $params = [])

    {
        $this->validateMethodAllowed(Constants::METHOD_DELETE);

        return $this->fetch($this->queryPath . '/' . $id, 'DELETE');
    }

    /**
     * Deletes a batch of this entity given by ids.
     *
     * @param array $ids
     * @param array $params
     *
     * @return array|mixed
     * @throws MethodNotAllowedException
     */
    public function deleteBatch(array $ids, $params = [])
    {
        $this->validateMethodAllowed(Constants::METHOD_DELETE_BATCH);

        return $this->fetch($this->queryPath . '/', 'DELETE', $ids, [], $params);
    }

    /**
     * @return array
     */
    public function getData()
    {
        return $this->data;
    }

    /**
     * @return int
     */
    public function getTotal()
    {
        return $this->total;
    }

    /**
     * @param        $uri
     * @param string $method
     * @param null   $body
     * @param array  $headers
     *
     * @return mixed|ResponseInterface
     */
    protected function fetchSimple($uri, $method = 'GET', $body = null, $headers = [])
    {
        return $this->client->request($uri, $method, $body, $headers);
    }

    /**
     * Fetch as json object.
     *
     * @param        $uri
     * @param string $method
     * @param null   $body
     * @param array  $headers
     *
     * @return false|\stdClass
     */
    protected function fetchJson($uri, $method = 'GET', $body = null, $headers = [])
    {
        $response = $this->client->request($uri, $method, $body, $headers);
        $response = json_decode($response->getBody()->getContents());

        return $response ? $response : null;
    }
}


1			<?php
2
3			namespace Neta\Shopware\SDK\Query;
4
5			use Neta\Shopware\SDK\ShopwareClient;
6			use Neta\Shopware\SDK\Util\ArrayUtil;
7			use Neta\Shopware\SDK\Util\Constants;
8			use Psr\Http\Message\ResponseInterface;
9			use Neta\Shopware\SDK\Exception\MethodNotAllowedException;
10
11			/**
12			* Class Base.
13			*
14			* @author Alexander Mahrt <[email protected]>
15			* @copyright 2016 LeadCommerce <[email protected]>
16			*/
17			abstract class Base
18			{
19			/**
20			* @var ShopwareClient
21			*/
22			protected $client;
23
24			/**
25			* @var string
26			*/
27			protected $queryPath;
28
29			/**
30			* @var array
31			*/
32			protected $methodsAllowed = [
33			Constants::METHOD_CREATE,
34			Constants::METHOD_GET,
35			Constants::METHOD_GET_BATCH,
36			Constants::METHOD_UPDATE,
37			Constants::METHOD_UPDATE_BATCH,
38			Constants::METHOD_DELETE,
39			Constants::METHOD_DELETE_BATCH,
40			];
41
42			/**
43			* @var array
44			*/
45			protected $data;
46
47			/**
48			* @var int
49			*/
50			protected $total;
51
52			/**
53			* Base constructor.
54			*
55			* @param $client
56			*/
57			public function __construct($client)
58			{
59			$this->client = $client;
60			$this->queryPath = $this->getQueryPath();
61			}
62
63			/**
64			* Gets the query path to look for entities.
65			* E.G: 'variants' or 'articles'.
66			*
67			* @return string
68			*/
69			abstract protected function getQueryPath();
70
71			/**
72			* Finds all entities.
73			*
74			* @return \Neta\Shopware\SDK\Entity\Base[]
75			*/
76			public function findAll()
77			{
78			$this->validateMethodAllowed(Constants::METHOD_GET_BATCH);
79
80			return $this->fetch($this->queryPath);
81			}
82
83			/**
84			* Finds entities by params.
85			*
86			* e.g.:
87			*
88			* $params = [
89			* 'limit' => 10,
90			* 'start' => 20,
91			* 'sort' => [
92			* [
93			* 'property' => 'name',
94			* 'direction' => 'ASC'
95			* ]
96			* ],
97			* 'filter' => [
98			* [
99			* 'property' => 'name',
100			* 'expression' => 'LIKE',
101			* 'value' => '%foo'
102			* ],
103			* [
104			* 'operator' => 'AND',
105			* 'property' => 'number',
106			* 'expression' => '>',
107			* 'value' => '500'
108			* ]
109			* ]
110			* ]
111			*
112			* @param array $params
113			*
114			* @return \Neta\Shopware\SDK\Entity\Base[]
115			*/
116			public function findByParams($params)
117			{
118			$this->validateMethodAllowed(Constants::METHOD_GET_BATCH);
119
120			return $this->fetch($this->queryPath, 'GET', null, [], $params);
121			}
122
123			/**
124			* Validates if the requested method is allowed.
125			*
126			* @param $method
127			*
128			* @throws MethodNotAllowedException
129			*/
130			private function validateMethodAllowed($method)
131			{
132			if (! in_array($method, $this->methodsAllowed)) {
133			throw new MethodNotAllowedException('Method ' . $method . ' is not allowed for ' . get_class($this));
134			}
135			}
136
137			/**
138			* Fetch and build entity.
139			*
140			* @param $uri
141			* @param string $method
142			* @param null $body
143			* @param array $headers
144			* @param array $uriParams
145			*
146			* @return array\|mixed
147			*/
148			protected function fetch($uri, $method = 'GET', $body = null, $headers = [], $uriParams = [])
149			{
150			if (is_array($uriParams) && count($uriParams) > 0) {
151			if (strpos($uri, '?') !== false) {
152			parse_str(substr($uri, strpos($uri, '?') + 1), $existingUriParams);
153			ArrayUtil::mergeRecursiveWithOverrule($existingUriParams, $uriParams);
			0 ignored issues – show Bug introduced 2019-04-26 10:46 UTC by Report Bug Copy Issue Report It seems like `$existingUriParams` can also be of type `null`; however, `Neta\Shopware\SDK\Util\A...RecursiveWithOverrule()` does only seem to accept `array`, maybe add an additional type check? If a method or function can return multiple different values and unless you are sure that you only can receive a single value in this context, we recommend to add an additional type check: /** * @return array\|string */ function returnsDifferentValues($x) { if ($x) { return 'foo'; } return array(); } $x = returnsDifferentValues($y); if (is_array($x)) { // $x is an array. } If this a common case that PHP Analyzer should handle natively, please let us know by opening an issue. Loading history...
154			$uri = substr($uri, 0, strpos($uri, '?')) . '?' . http_build_query($existingUriParams);
155			} else {
156			$uri = $uri . '?' . http_build_query($uriParams);
157			}
158			}
159			$response = $this->client->request($uri, $method, $body, $headers);
160
161			return $this->createEntityFromResponse($response);
162			}
163
164			/**
165			* Creates an entity.
166			*
167			* @param ResponseInterface $response
168			*
169			* @return array\|\Neta\Shopware\SDK\Entity\Base
170			*/
171			protected function createEntityFromResponse(ResponseInterface $response)
172			{
173			$result = [];
174			$content = $response->getBody()->getContents();
175			$content = json_decode($content);
176			$this->data = isset($content->data) ? $content->data : null;
177			$this->total = isset($content->total) ? $content->total : null;
178
179			if (is_array($this->data)) {
180			$result = array_map(function ($item) {
181			if (isset($item->id)) {
182			return $this->createEntity($item);
183			}
184			if (isset($item->data) && isset($item->data->id)) {
185			return $this->createEntity($item->data);
186			}
187			}, $this->data);
188			}
189
190			if (is_object($this->data)) {
191			$result = $this->createEntity($this->data);
192			}
193
194			return $result;
195			}
196
197			/**
198			* Creates an entity based on the getClass method.
199			*
200			* @param $content
201			*
202			* @return \Neta\Shopware\SDK\Entity\Base
203			*/
204			protected function createEntity($content)
205			{
206			$class = $this->getClass();
207			$entity = new $class();
208
209			if ($entity instanceof \Neta\Shopware\SDK\Entity\Base) {
210			$content = json_decode(json_encode($content), true);
211			$entity->setEntityAttributes($content);
212			}
213
214			return $entity;
215			}
216
217			/**
218			* Gets the class for the entities.
219			*
220			* @return string
221			*/
222			abstract protected function getClass();
223
224			/**
225			* Finds an entity by its id.
226			*
227			* @param mixed $id
228			* @param array $params
229			*
230			* @return \Neta\Shopware\SDK\Entity\Base
231			*/
232			public function findOne($id, $params = [])
233			{
234			$this->validateMethodAllowed(Constants::METHOD_GET);
235
236			return $this->fetch($this->queryPath . '/' . $id, 'GET', null, [], $params);
			0 ignored issues – show Bug Compatibility introduced 2019-04-26 10:46 UTC by Report Bug Copy Issue Report The expression `$this->fetch($this->quer...ull, array(), $params);` of type `array\|Neta\Shopware\SDK\Entity\Base` adds the type `array` to the return on line 236 which is incompatible with the return type documented by `Neta\Shopware\SDK\Query\Base::findOne` of type `Neta\Shopware\SDK\Entity\Base`. Loading history...
237			}
238
239			/**
240			* Creates an entity.
241			*
242			* @param \Neta\Shopware\SDK\Entity\Base $entity
243			* @param array $params
244			*
245			* @return \Neta\Shopware\SDK\Entity\Base
246			* @throws MethodNotAllowedException
247			*/
248			public function create(\Neta\Shopware\SDK\Entity\Base $entity, $params = [])
249			{
250			$this->validateMethodAllowed(Constants::METHOD_CREATE);
251
252			return $this->fetch($this->queryPath, 'POST', $entity->getArrayCopy(), [], $params);
			0 ignored issues – show Bug Compatibility introduced 2019-04-26 10:46 UTC by Report Bug Copy Issue Report The expression `$this->fetch($this->quer...y(), array(), $params);` of type `array\|Neta\Shopware\SDK\Entity\Base` adds the type `array` to the return on line 252 which is incompatible with the return type documented by `Neta\Shopware\SDK\Query\Base::create` of type `Neta\Shopware\SDK\Entity\Base`. Loading history...
253			}
254
255			/**
256			* Updates an entity.
257			*
258			* @param \Neta\Shopware\SDK\Entity\Base $entity
259			* @param array $params
260			*
261			* @return array\|mixed
262			* @throws MethodNotAllowedException
263			*/
264			public function update(\Neta\Shopware\SDK\Entity\Base $entity, $params = [])
265			{
266			$this->validateMethodAllowed(Constants::METHOD_UPDATE);
267
268			return $this->fetch($this->queryPath . '/' . $entity->getId(), 'PUT', $entity->getArrayCopy(), [], $params);
269			}
270
271			/**
272			* Updates a batch of this entity.
273			*
274			* @param \Neta\Shopware\SDK\Entity\Base[] $entities
275			* @param array $params
276			*
277			* @return \Neta\Shopware\SDK\Entity\Base[]
278			*/
279			public function updateBatch($entities, $params = [])
280			{
281			$this->validateMethodAllowed(Constants::METHOD_UPDATE_BATCH);
282			$body = [];
283			foreach ($entities as $entity) {
284			$body[] = $entity->getArrayCopy();
285			}
286
287			return $this->fetch($this->queryPath . '/', 'PUT', $body, [], $params);
288			}
289
290			/**
291			* Deletes an entity by its id..
292			*
293			* @param mixed $id
294			* @param array $params
295			*
296			* @return array\|mixed
297			* @throws MethodNotAllowedException
298			*/
299			public function delete($id, $params = [])
			0 ignored issues – show Unused Code introduced 2019-04-26 09:57 UTC by Report Bug Copy Issue Report The parameter `$params` is not used and could be removed. This check looks from parameters that have been defined for a function or method, but which are not used in the method body. Loading history...
300			{
301			$this->validateMethodAllowed(Constants::METHOD_DELETE);
302
303			return $this->fetch($this->queryPath . '/' . $id, 'DELETE');
304			}
305
306			/**
307			* Deletes a batch of this entity given by ids.
308			*
309			* @param array $ids
310			* @param array $params
311			*
312			* @return array\|mixed
313			* @throws MethodNotAllowedException
314			*/
315			public function deleteBatch(array $ids, $params = [])
316			{
317			$this->validateMethodAllowed(Constants::METHOD_DELETE_BATCH);
318
319			return $this->fetch($this->queryPath . '/', 'DELETE', $ids, [], $params);
320			}
321
322			/**
323			* @return array
324			*/
325			public function getData()
326			{
327			return $this->data;
328			}
329
330			/**
331			* @return int
332			*/
333			public function getTotal()
334			{
335			return $this->total;
336			}
337
338			/**
339			* @param $uri
340			* @param string $method
341			* @param null $body
342			* @param array $headers
343			*
344			* @return mixed\|ResponseInterface
345			*/
346			protected function fetchSimple($uri, $method = 'GET', $body = null, $headers = [])
347			{
348			return $this->client->request($uri, $method, $body, $headers);
349			}
350
351			/**
352			* Fetch as json object.
353			*
354			* @param $uri
355			* @param string $method
356			* @param null $body
357			* @param array $headers
358			*
359			* @return false\|\stdClass
360			*/
361			protected function fetchJson($uri, $method = 'GET', $body = null, $headers = [])
362			{
363			$response = $this->client->request($uri, $method, $body, $headers);
364			$response = json_decode($response->getBody()->getContents());
365
366			return $response ? $response : null;
367			}
368			}
369

neta-io / shopware-sdk

GitHub Access Token became invalid

Push — master ( b98016...0803ae )

Base::createEntity() A

Complexity

Size

Duplication

Code Coverage

Importance

Duplication Side-by-Side

Filter issues like