Inktale\Api\Inktale

Complexity

Total Complexity

13

Size/Duplication

Total Lines	137
Duplicated Lines	0 %

Coupling/Cohesion

Components	1
Dependencies	6

Importance

Changes	2
Bugs	1	Features	1

8 Methods

Rating	Name	Duplication	Size	Complexity
A	__construct()	0	4	2
A	setApiKey()	0	4	1
A	createStore()	0	9	1
A	getProducts()	0	11	2
B	createArtwork()	0	24	3
A	getArtwork()	0	6	1
A	getArtworks()	0	10	2
A	getApiClient()	0	4	1

<?php


namespace Inktale\Api;


use Inktale\Api\Exceptions\InktaleApiException;
use Inktale\Api\Params\ArtworkCreationParams;
use Inktale\Api\Structures\ArtworkItem;
use Inktale\Api\Structures\ArtworkListItem;
use Inktale\Api\Structures\ProductItem;
use Inktale\Api\Structures\StoreItem;

class Inktale
{
    /** @var InktaleApiClient */
    private $api;

    /**
     * @param InktaleApiClient|null $apiClient
     */
    public function __construct(InktaleApiClient $apiClient = null)
    {
        $this->api = $apiClient ?: new InktaleApiClient;
    }

    /**
     * Set api key to be used for next requests
     *
     * @param string|null $apiKey
     */
    public function setApiKey($apiKey)
    {
        $this->api->setApiKey($apiKey);
    }

    /**
     * Create a new store and retrieve the api key. This request does not require an api key to be set
     *
     * @param string $email
     * @param string $name
     *
     * @return StoreItem
     * @throws InktaleApiException
     */
    public function createStore($email, $name)
    {
        $response = $this->api->post('store', [
            'email' => $email,
            'name' => $name,
        ]);

        return StoreItem::fromArray($response['store']);
    }

    /**
     * Fetch list of available products that artwork can be created on
     *
     * @return ProductItem[]
     * @throws InktaleApiException
     */
    public function getProducts()
    {
        $response = $this->api->get('products');

        $re = [];
        foreach ($response['products'] as $v) {
            $re[] = ProductItem::fromArray($v);
        }

        return $re;
    }

    /**
     * Create a new artwork on given products.
     * Response is an artwork id.
     * WARNING! Artwork creation is asynchronous!
     *
     * @param ArtworkCreationParams $params
     * @return string Newly created artwork id
     * @throws InktaleApiException
     */
    public function createArtwork(ArtworkCreationParams $params)
    {
        $productTypes = [];

        foreach ($params->getProducts() as $k => $v) {
            $productTypes[] = [
                'productType' => $k,
                'profit' => $v,
            ];
        };

        $data = [
            'url' => $params->imageUrl,
            'name' => $params->name,
            'publish' => $params->publish ? 1 : 0,
            'description' => $params->description,
            'productTypes' => $productTypes,
            'keywords' => $params->keywords,
        ];

        $response = $this->api->post('artwork', $data);

        return $response['artworkId'];
    }

    /**
     * Get an artwork with files and products
     *
     * @param string $artworkId
     * @return ArtworkItem
     * @throws InktaleApiException
     */
    public function getArtwork($artworkId)
    {
        $response = $this->api->get('artwork/' . $artworkId);

        return ArtworkItem::fromArray($response['artwork']);
    }

    /**
     * Get a list of artworks
     *
     * @param int $page Page number (starting from 1)
     * @param int $perPage Items per page, up to 100
     * @param bool $publishedOnly
     * @return ArtworkListItem
     */
    public function getArtworks($page, $perPage, $publishedOnly = false)
    {
        $response = $this->api->get('artworks', [
            'page' => $page,
            'perPage' => $perPage,
            'publishedOnly' => $publishedOnly ? 1 : 0,
        ]);

        return ArtworkListItem::fromArray($response);
    }

    /**
     * Current API client instance
     *
     * @return InktaleApiClient
     */
    public function getApiClient()
    {
        return $this->api;
    }
}