Application\Traits\HasImage

Complexity

Total Complexity

19

Size/Duplication

Total Lines	132
Duplicated Lines	0 %

Test Coverage

Coverage

85.71%

Importance

Changes	2
Bugs	0	Features	0

9 Methods

Rating	Name	Duplication	Size	Complexity
A	hasImage()	0	3	1
A	getPath()	0	4	1
A	getFilename()	0	4	1
A	setFilename()	0	4	1
A	setFile()	0	15	3
A	deleteFile()	0	11	5
A	getMime()	0	13	3
A	generateUniqueFilename()	0	5	2
A	validateMimeType()	0	25	2

<?php

declare(strict_types=1);

namespace Application\Traits;

use Application\Api\FileException;
use Doctrine\ORM\Mapping as ORM;
use Exception;
use GraphQL\Doctrine\Attribute as API;
use Psr\Http\Message\UploadedFileInterface;
use Throwable;

/**
 * Trait for all objects with a name.
 */
trait HasImage
{
    #[ORM\Column(type: 'string', length: 2000)]
    private string $filename = '';

    /**
     * Set the image file.
     */
    #[API\Input(type: '?GraphQL\Upload\UploadType')]
    public function setFile(UploadedFileInterface $file): void
    {
        try {
            $this->generateUniqueFilename($file->getClientFilename());

It seems like $file->getClientFilename() can also be of type null; however, parameter $originalFilename of Application\Traits\HasImage::generateUniqueFilename() does only seem to accept string, maybe add an additional type check?

            $path = $this->getPath();
            if (file_exists($path)) {
                throw new Exception('A file already exist with the same name: ' . $this->getFilename());
            }
            $file->moveTo($path);

            $this->validateMimeType();
        } catch (Throwable $e) {
            throw new FileException($file, $e);
        }
    }

    /**
     * Set filename (without path).
     */
    #[API\Exclude]
    public function setFilename(string $filename): void
    {
        $this->filename = $filename;
    }

    /**
     * Get filename (without path).
     */
    #[API\Exclude]
    public function getFilename(): string
    {
        return $this->filename;
    }

    public function hasImage(): bool
    {
        return !empty($this->filename);
    }

    /**
     * Get absolute path to image on disk.
     */
    #[API\Exclude]
    public function getPath(): string
    {
        return realpath('.') . '/' . self::IMAGE_PATH . $this->getFilename();

The constant Application\Traits\HasImage::IMAGE_PATH was not found. Maybe you did not declare it correctly or list all dependencies?

    }

    /**
     * Automatically called by Doctrine when the object is deleted
     * Is called after database update because we can have issues on remove operation (like integrity test)
     * and it's preferable to keep a related file on drive before removing it definitely.
     */
    #[ORM\PostRemove]
    public function deleteFile(): void
    {
        $path = $this->getPath();
        global $container;
        $config = $container->get('config');
        $unlink = $config['files']['unlink'];

        if (file_exists($path) && is_file($path)) {
            if ($this->getFilename() !== 'dw4jV3zYSPsqE2CB8BcP8ABD0.jpg' && $unlink) {
                unlink($path);
            }
        }
    }

    public function getMime(): string
    {
        $path = $this->getPath();
        $mime = mime_content_type($path);
        if ($mime === false) {
            throw new Exception('Could not get mimetype for path: ' . $path);
        }

        if ($mime === 'image/svg') {
            $mime = 'image/svg+xml';
        }

        return $mime;
    }

    /**
     * Delete file and throw exception if MIME type is invalid.
     */
    private function validateMimeType(): void
    {
        $mime = $this->getMime();

        // Validate image mimetype
        $acceptedMimeTypes = [
            'image/bmp',
            'image/x-ms-bmp',
            'image/gif',
            'image/jpeg',
            'image/pjpeg',
            'image/png',
            'image/svg+xml',
            'image/tiff',
            'image/vnd.adobe.photoshop',
            'image/webp',
            'image/heif',
            'image/heic',
        ];

        if (!in_array($mime, $acceptedMimeTypes, true)) {
            $path = $this->getPath();
            unlink($path);

            throw new Exception('Invalid file type of: ' . $mime);
        }
    }

    /**
     * Generate unique filename while trying to preserver original extension.
     */
    private function generateUniqueFilename(string $originalFilename): void
    {
        $extension = pathinfo($originalFilename, PATHINFO_EXTENSION);
        $filename = uniqid() . ($extension ? '.' . $extension : '');

Are you sure $extension of type array|string can be used in concatenation?

        $this->setFilename($filename);
    }
}