Neta\Shopware\SDK\Query\Base

Complexity

Total Complexity

31

Size/Duplication

Total Lines	352
Duplicated Lines	0 %

Coupling/Cohesion

Components	1
Dependencies	6

Test Coverage

Coverage

81.58%

Importance

Changes

0

19 Methods

Rating	Name	Duplication	Size	Complexity
	getQueryPath()	0	1	?
	getClass()	0	1	?
A	__construct()	0	5	1
A	findAll()	0	6	1
A	findByParams()	0	6	1
A	validateMethodAllowed()	0	6	2
A	fetch()	0	15	4
B	createEntityFromResponse()	0	25	8
A	createEntity()	0	12	2
A	findOne()	0	6	1
A	create()	0	6	1
A	update()	0	6	1
A	updateBatch()	0	10	2
A	delete()	0	6	1
A	deleteBatch()	0	6	1
A	getData()	0	4	1
A	getTotal()	0	4	1
A	fetchSimple()	0	4	1
A	fetchJson()	0	7	2

<?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 <amahrt@leadcommerce.de>
 * @copyright 2016 LeadCommerce <amahrt@leadcommerce.de>
 */
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);

It seems like $existingUriParams can also be of type null; however, Neta\Shopware\SDK\Util\ArrayUtil::mergeRecursiveWithOverrule() does only seem to accept array, maybe add an additional type check?

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

The expression $this->fetch($this->queryPath . '/' . $id, 'GET', null, 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.

    }

    /**
     * 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);

The expression $this->fetch($this->queryPath, 'POST', $entity->getArrayCopy(), 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.

    }

    /**
     * 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 = [])

The parameter $params is not used and could be removed.

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