AcquiroPay\Services\Entities

Complexity

Total Complexity

19

Size/Duplication

Total Lines	203
Duplicated Lines	0 %

Coupling/Cohesion

Components	1
Dependencies	9

Importance

Changes

0

17 Methods

Rating	Name	Duplication	Size	Complexity
A	__construct()	0	5	1
A	getCountries()	0	4	1
A	getCurrencies()	0	4	1
A	getProducts()	0	4	1
A	getCountry()	0	4	1
A	getCurrency()	0	4	1
A	getProduct()	0	4	1
A	getSite()	0	7	1
A	getMerchant()	0	7	1
A	getList()	0	6	1
A	get()	0	6	1
A	getEntityCollection()	0	9	2
A	getEntity()	0	6	1
A	makeGetRequest()	0	4	1
A	makeRequest()	0	8	1
A	resource()	0	6	1
A	response2Entity()	0	10	2

<?php

declare(strict_types=1);

namespace AcquiroPay\Services;

use stdClass;
use RuntimeException;
use AcquiroPay\Helpers\Str;
use InvalidArgumentException;
use Illuminate\Support\Collection;
use AcquiroPay\Models\Entities\Site;
use AcquiroPay\Models\Entities\Entity;
use GuzzleHttp\Client as GuzzleClient;
use AcquiroPay\Models\Entities\Country;
use AcquiroPay\Models\Entities\Product;
use AcquiroPay\Models\Entities\Currency;
use AcquiroPay\Models\Entities\Merchant;
use function GuzzleHttp\json_decode as decode;
use AcquiroPay\Contracts\Mapper as MapperContract;
use AcquiroPay\Contracts\Entities as EntitiesContract;

class Entities implements EntitiesContract
{
    protected $client;
    protected $mapper;

    public function __construct(GuzzleClient $client, MapperContract $mapper)
    {
        $this->client = $client;
        $this->mapper = $mapper;
    }

    /**
     * Get countries.
     *
     * @param array $parameters
     * @return Collection
     */
    public function getCountries(array $parameters = []): Collection
    {
        return $this->getEntityCollection(Country::class, $parameters);
    }

    /**
     * Get currencies.
     *
     * @param array $parameters
     * @return Collection
     */
    public function getCurrencies(array $parameters = []): Collection
    {
        return $this->getEntityCollection(Currency::class, $parameters);
    }

    /**
     * Get products.
     *
     * @param array $parameters
     * @return Collection
     */
    public function getProducts(array $parameters = []): Collection
    {
        return $this->getEntityCollection(Product::class, $parameters);
    }

    /**
     * Get country by id.
     *
     * @param int $id
     * @param array $parameters
     * @return Country|null
     */
    public function getCountry(int $id, array $parameters = []): ?Country
    {
        return $this->getEntity(new Country(), $id, $parameters);
    }

    /**
     * Get currency by id.
     *
     * @param int $id
     * @param array $parameters
     * @return Currency|null
     */
    public function getCurrency(int $id, array $parameters = []): ?Currency
    {
        return $this->getEntity(new Currency(), $id, $parameters);
    }

    /**
     * Get product by id.
     *
     * @param int $id
     * @param array $parameters
     * @return Product|null
     */
    public function getProduct(int $id, array $parameters = []): ?Product
    {
        return $this->getEntity(new Product(), $id, $parameters);
    }

    /**
     * Get site by product id.
     *
     * @param int $productId
     * @param array $parameters
     * @return Site|null
     */
    public function getSite(int $productId, array $parameters = []): ?Site
    {
        $url = $this->resource(Product::class).'/'.$productId.'/site';
        $resp = $this->makeGetRequest($url, $parameters);

        return $this->response2Entity($resp, new Site());
    }

    /**
     * Get merchant by product id.
     *
     * @param int $productId
     * @param array $parameters
     * @return Merchant|null
     */
    public function getMerchant(int $productId, array $parameters = []): ?Merchant
    {
        $url = $this->resource(Merchant::class).'/'.$productId.'/merchant';
        $resp = $this->makeGetRequest($url, $parameters);

        return $this->response2Entity($resp, new Merchant());
    }

    /**
     * Get entities list.
     *
     * @param string $entityName
     * @param array $params
     * @return stdClass
     */
    public function getList(string $entityName, array $params = []): stdClass
    {
        $url = $this->resource($entityName);

        return $this->makeGetRequest($url, $params);
    }

    /**
     * Get entity.
     *
     * @param string $entityName
     * @param $id
     * @param array $params
     * @return stdClass
     */
    public function get(string $entityName, $id, array $params = []): stdClass
    {
        $url = $this->resource($entityName).'/'.$id;

        return $this->makeGetRequest($url, $params);
    }

    /**
     * Get entity as collection.
     *
     * @param string $className
     * @param array $params
     * @return Collection
     */
    protected function getEntityCollection(string $className, array $params): Collection
    {
        $resp = $this->getList($className, $params);
        if (isset($resp->result, $resp->result->data)) {
            return collect($this->mapper->mapArray($resp->result->data, [], $className));
        }

        return collect();
    }

    protected function getEntity(Entity $entity, $id, array $params): ?Entity
    {
        $resp = $this->get(get_class($entity), $id, $params);

        return $this->response2Entity($resp, $entity);
    }

    protected function makeGetRequest(string $url, array $params): stdClass
    {
        return $this->makeRequest('get', $url, ['query' => $params]);
    }

    /**
     * @param string $method
     * @param string $url
     * @param array $options
     * @return mixed
     * @throws RuntimeException
     * @throws InvalidArgumentException
     */
    protected function makeRequest(string $method, string $url, array $options)
    {
        $response = $this->client->request($method, 'services/entities/'.$url, $options);
        $response = (string) $response->getBody()->getContents();
        $response = decode($response);

        return $response ?? new stdClass();
    }

    protected function resource(string $className): string
    {
        $value = Str::snake(Str::classBaseName($className), '-');

        return Str::lower($value);
    }

    protected function response2Entity($resp, Entity $entity): ?Entity
    {
        if (isset($resp->result)) {
            $this->mapper->map($resp->result, $entity);

            return $entity;
        }

        return null;
    }
}