Luilliarcec\LaravelImgur\Support\LaravelImgur

Complexity

Total Complexity

18

Size/Duplication

Total Lines	224
Duplicated Lines	0 %

Importance

Changes	2
Bugs	0	Features	0

12 Methods

Rating	Name	Duplication	Size	Complexity
A	upload()	0	11	1
A	remove()	0	9	1
A	setResponse()	0	3	1
A	getBody()	0	11	2
A	getHeaders()	0	12	2
A	setBody()	0	3	1
A	getResponse()	0	3	1
A	setHeaders()	0	3	1
A	getImageThumbnails()	0	16	2
A	__construct()	0	5	1
A	fileType()	0	11	3
A	thumbnails()	0	7	2

<?php

namespace Luilliarcec\LaravelImgur\Support;

use GuzzleHttp\Client;
use Illuminate\Http\UploadedFile;
use Luilliarcec\LaravelImgur\Exceptions\InvalidArgumentException;

class LaravelImgur extends ImgurResponse
{
    /**
     * Api connection url
     */
    private $apiUrl;

    /**
     * Base url access
     */
    private $baseUrl;

    /**
     * Guzzle client for request
     *
     * @var Client
     */
    private $client;

    /**
     * Image to upload
     */
    private $image;

    /**
     * Request Header
     */
    private $headers = [];

    /**
     * Parameters Request Body
     */
    private $body = [];

    /**
     * Thumbnails available
     */
    protected $thumbnails = ['s', 'b', 't', 'm', 'l', 'h'];

    /**
     * Imgur constructor.
     *
     */
    public function __construct()
    {
        $this->client = new Client();
        $this->apiUrl = config('imgur.api_url');
        $this->baseUrl = config('imgur.base_url');
    }

    /**
     * Set header request
     *
     * @param array $headers
     */
    public function setHeaders(array $headers)
    {
        $this->headers = $headers;
    }

    /**
     * Get header request
     *
     * @return array
     */
    private function getHeaders(): array
    {
        if (empty($this->headers)) {
            return [
                'headers' => [
                    'authorization' => 'Client-ID ' . config('imgur.client_id'),
                    'content-type' => 'application/x-www-form-urlencoded',
                ]
            ];
        }

        return $this->headers;
    }

    /**
     * Set body request
     *
     * @param array $params
     */
    public function setBody(array $params)
    {
        $this->body = $params;
    }

    /**
     * Get body request
     *
     * @return array
     */
    private function getBody(): array
    {
        if (empty($this->body)) {
            return [
                'form_params' => [
                    'image' => $this->image
                ]
            ];
        }

        return $this->body;
    }

    /**
     * Set response
     *
     * @param mixed $response
     */
    public function setResponse($response)
    {
        $this->response = $response;
    }

    /**
     * Get response
     *
     * @return mixed
     */
    public function getResponse()
    {
        return $this->response;
    }

    /**
     * Upload the resource to imgur
     *
     * @param string|UploadedFile $image
     * @return mixed
     * @throws InvalidArgumentException
     */
    public function upload($image)
    {
        $this->image = $this->fileType($image);

        $response = $this->client->post($this->apiUrl, array_merge($this->getHeaders(), $this->getBody()));

        $this->setResponse(json_decode($response->getBody()->getContents()));

        $this->fillData();

        return $this;
    }

    /**
     * Remove an image by its deleteHash
     *
     * @param string $hash
     * @return bool
     */
    public function remove(string $hash)
    {
        $response = $this->client->delete($this->apiUrl . '/' . $hash, $this->getHeaders());

        $this->setResponse(json_decode($response->getBody()->getContents()));

        $this->flushData();

        return $this->getResponse()->success;
    }

    /**
     * Convert the image to thumbnails depending on the size.
     *
     * @param string $link
     * @param string $size
     * @return string
     * @throws InvalidArgumentException
     */
    public function thumbnails(string $link, string $size)
    {
        if (!in_array($size, $this->thumbnails)) {
            throw new InvalidArgumentException("Imgur does not support this {$size} type.");
        }

        return $this->getImageThumbnails($link, $size);
    }

    /**
     * Check that the file type is an UploadedFile instance or a url
     *
     * @param string|UploadedFile $image
     * @return string
     * @throws InvalidArgumentException
     */
    private function fileType($image)
    {
        if ($image instanceof UploadedFile) {
            return base64_encode(file_get_contents($image->path()));
        }

        if (filter_var($image, FILTER_VALIDATE_URL)) {
            return $image;
        }

        throw new InvalidArgumentException("Invalid argument provided.");
    }

    /**
     * Get the link of the image converted to Thumbnails
     *
     * @param string $size
     * @param string $link
     * @return string
     */
    private function getImageThumbnails(string $link, string $size)
    {
        $imageArray = explode('.', explode($this->baseUrl, $link)[1]);

        $image = $imageArray[0];
        $extension = '.' . $imageArray[1];

        $possibleSize = substr($image, strlen($image) - 1);

        if (in_array($possibleSize, $this->thumbnails)) {
            $image = substr_replace($image, $size, strlen($image) - 1);
        } else {
            $image .= $size;
        }

        return $this->baseUrl . $image . $extension;
    }
}