LauLamanApps\IzettleApi\API\Image\ImageFileUpload

Complexity

Total Complexity

12

Size/Duplication

Total Lines	85
Duplicated Lines	0 %

Coupling/Cohesion

Components	2
Dependencies	4

Importance

Changes

0

6 Methods

Rating	Name	Duplication	Size	Complexity
A	__construct()	0	6	1
A	getUploadRequest()	0	7	1
A	validateFile()	0	6	1
A	validateFileSize()	0	7	2
A	validatedImageType()	0	19	4
A	validateImageSize()	0	16	3

<?php

declare(strict_types=1);

namespace LauLamanApps\IzettleApi\API\Image;

use Exception;
use LauLamanApps\IzettleApi\API\Image\Exceptions\FileIsNotAnImageException;
use LauLamanApps\IzettleApi\API\Image\Exceptions\ImageIsToSmallException;
use LauLamanApps\IzettleApi\API\Image\Exceptions\ImageTypeNotAllowedException;
use LauLamanApps\IzettleApi\API\Image\Exceptions\MaximumImageFileSizeExcededException;

interface ImageUploadRequestInterface
{
    public function getUploadRequest(): array;
}

final class ImageUrlUpload implements ImageUploadRequestInterface

Each interface must be in a file by itself

{
    /**
     * @var
     */
    private $imageUrl;

    public function __construct( string $imageUrl)
    {
        $this->imageUrl = $imageUrl;
    }

    public function getUploadRequest(): array
    {
        return [
            'imageUrl' => $this->imageUrl
        ];
    }
}

final class ImageFileUpload implements ImageUploadRequestInterface

PSR1 recommends that each class should be in its own file to aid autoloaders.

{
    const ALLOWED_FILE_TYPES = [
        IMAGETYPE_GIF => 'GIF',
        IMAGETYPE_JPEG => 'JPEG',
        IMAGETYPE_PNG => 'PNG',
        IMAGETYPE_BMP => 'BMP',
        IMAGETYPE_TIFF_II => 'TIFF',
        IMAGETYPE_TIFF_MM => 'TIFF'
    ];
    const MAX_FILE_SIZE_MB = 5;
    const MINIMAL_HEIGHT = 50;
    const MINIMAL_WIDTH = 50;

    private $imageFormat;
    private $imageData;

    private function __construct(string $filename)
    {
        $this->validateFile($filename);
        $this->imageFormat = self::ALLOWED_FILE_TYPES[exif_imagetype($filename)];
        $this->imageData = file_get_contents($filename);
    }

    public function getUploadRequest(): array
    {
        return [
            'imageFormat' => $this->imageFormat,
            'imageData' => $this->imageData,
        ];
    }


    private function validateFile($file)
    {
        self::validateFileSize($file);
        self::validatedImageType($file);
        self::validateImageSize($file);
    }

    private static function validateFileSize($file)
    {
        $maxFileSizeBytes = (self::MAX_FILE_SIZE_MB * 1024 * 1024);
        if (filesize($file) > $maxFileSizeBytes) {
            throw new MaximumImageFileSizeExcededException(sprintf('Max file size is \'%d Mb\'', self::MAX_FILE_SIZE_MB));
        }
    }

    private static function validatedImageType(string $file)
    {
        $type = false;

        try {
            $type = exif_imagetype($file);
        } catch (Exception $e) {

Consider adding a comment why this CATCH block is empty.

        }

        if ($type == false) {

It seems like you are loosely comparing $type of type integer to the boolean false. If you are specifically checking for 0, consider using something more explicit like === 0 instead.

            throw new FileIsNotAnImageException();
        }

        if (!array_key_exists($type, self::ALLOWED_FILE_TYPES)) {
            throw new ImageTypeNotAllowedException(
                sprintf('Allowed: %s', implode(', ', self::ALLOWED_FILE_TYPES))
            );
        }
    }

    private static function validateImageSize($file)
    {
        list($width, $height) = getimagesize($file);

        if ($width < self::MINIMAL_WIDTH or $height < self::MINIMAL_HEIGHT) {
            throw new ImageIsToSmallException(
                sprintf(
                    'Minimal image dimensions not met. Required: \'%dx%d\' Provided: \'%dx%d\'',
                    self::MINIMAL_HEIGHT,
                    self::MINIMAL_WIDTH,
                    $height,
                    $width
                )
            );
        }
    }
}