Application\Model\AbstractFile

Complexity

Total Complexity

14

Size/Duplication

Total Lines	139
Duplicated Lines	0 %

Test Coverage

Coverage

85.29%

Importance

Changes

0

8 Methods

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

<?php

declare(strict_types=1);

namespace Application\Model;

use Doctrine\ORM\Mapping as ORM;
use GraphQL\Doctrine\Annotation as API;
use Psr\Http\Message\UploadedFileInterface;

/**
 * Wrapping class for an uploaded file
 *
 * @ORM\MappedSuperclass
 * @ORM\Table(uniqueConstraints={
 *     @ORM\UniqueConstraint(name="unique_name", columns={"filename"})
 * })
 */
abstract class AbstractFile extends AbstractModel
{
    /**
     * Get base path where the files are stored in the server
     *
     * @return string
     */
    abstract protected function getBasePath(): string;

    /**
     * Get list of accepted MIME types
     *
     * @return string[]
     */
    abstract protected function getAcceptedMimeTypes(): array;

    /**
     * @var string
     * @ORM\Column(type="string", length=190)
     */
    private $filename = '';

    /**
     * @var string
     * @ORM\Column(type="string", length=255)
     */
    private $mime = '';

    /**
     * Set the file
     *
     * @param UploadedFileInterface $file
     *
     * @throws \Exception
     */
    public function setFile(UploadedFileInterface $file): void
    {
        $this->generateUniqueFilename($file->getClientFilename());

It seems like $file->getClientFilename() can also be of type null; however, parameter $originalFilename of Application\Model\AbstractFile::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();
    }

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

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

    /**
     * Get mime
     *
     * @return string
     */
    public function getMime(): string
    {
        return $this->mime;
    }

    /**
     * Get absolute path to file on disk
     *
     * @API\Exclude
     *
     * @return string
     */
    public function getPath(): string
    {
        return realpath('.') . '/' . $this->getBasePath() . $this->getFilename();
    }

    /**
     * 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();
        if (file_exists($path) && is_file($path) && mb_strpos($this->getFilename(), 'dw4jV3zYSPsqE2CB8BcP8ABD0.') === false) {
            unlink($path);
        }
    }

    /**
     * Generate unique filename while trying to preserve original extension
     *
     * @param string $originalFilename
     */
    private function generateUniqueFilename(string $originalFilename): void
    {
        $extension = pathinfo($originalFilename, PATHINFO_EXTENSION);
        $filename = uniqid() . ($extension ? '.' . $extension : '');
        $this->setFilename($filename);
    }

    /**
     * Delete file and throw exception if MIME type is invalid
     *
     * @throws \Exception
     */
    private function validateMimeType(): void
    {
        $path = $this->getPath();
        $mime = mime_content_type($path);

        // Validate mimetype
        if (!in_array($mime, $this->getAcceptedMimeTypes(), true)) {
            unlink($path);

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

        $this->mime = $mime;
    }
}