Phauthentic / file-storage

src/FileFactory.php

<?php

/**
 * Copyright (c) Florian Krämer (https://florian-kraemer.net)
 * Licensed under The MIT License
 * For full copyright and license information, please see the LICENSE.txt
 * Redistributions of files must retain the above copyright notice.
 *
 * @copyright Copyright (c) Florian Krämer (https://florian-kraemer.net)
 * @author    Florian Krämer
 * @link      https://github.com/Phauthentic
 * @license   https://opensource.org/licenses/MIT MIT License
 */

declare(strict_types=1);

namespace Phauthentic\Infrastructure\Storage;

use Phauthentic\Infrastructure\Storage\Exception\FileDoesNotExistException;
use Phauthentic\Infrastructure\Storage\Exception\FileNotReadableException;
use Phauthentic\Infrastructure\Storage\Utility\MimeType;
use Phauthentic\Infrastructure\Storage\Utility\PathInfo;
use Phauthentic\Infrastructure\Storage\Utility\StreamWrapper;
use Psr\Http\Message\UploadedFileInterface;
use RuntimeException;

/**
 * File Factory
 */
class FileFactory implements FileFactoryInterface
{
    /**
     * @inheritDoc
     */
    public static function fromUploadedFile(
        UploadedFileInterface $uploadedFile,
        string $storage
    ): FileInterface {
        static::checkUploadedFile($uploadedFile);

        $file = File::create(
            (string)$uploadedFile->getClientFilename(),
            (int)$uploadedFile->getSize(),
            (string)$uploadedFile->getClientMediaType(),
            $storage
        );

        return $file->withResource(
            StreamWrapper::getResource($uploadedFile->getStream())
        );
    }

    /**
     * @inheritDoc
     */
    public static function fromDisk(string $path, string $storage): FileInterface
    {
        static::checkFile($path);

        $info = PathInfo::for($path);
        $filesize = filesize($path);
        if ($filesize === false) {
            throw new RuntimeException(sprintf('Failed to get file size for: %s', $path));
        }

        $extension = $info->extension();
        $mimeType = $extension !== null ? MimeType::byExtension($extension) : 'application/octet-stream';
        if ($mimeType === null) {

The condition $mimeType === null is always false.

            $mimeType = 'application/octet-stream';
        }

        $file = File::create(
            $info->basename(),
            $filesize,
            $mimeType,
            $storage,
        );

        $resource = fopen($path, 'rb');

        return $file->withResource($resource);
    }

    /**
     * Checks if the uploaded file is a valid upload
     *
     * @param \Psr\Http\Message\UploadedFileInterface $uploadedFile Uploaded File
     * @return void
     */
    protected static function checkUploadedFile(UploadedFileInterface $uploadedFile): void
    {
        if ($uploadedFile->getError() !== UPLOAD_ERR_OK) {
            throw new RuntimeException(sprintf(
                'Can\'t create storage object from upload with error code: %d',
                $uploadedFile->getError()
            ));
        }
    }

    /**
     * @param string $path Path
     * @return void
     */
    protected static function checkFile(string $path): void
    {
        if (!file_exists($path)) {
            throw FileDoesNotExistException::filename($path);
        }

        if (!is_readable($path)) {
            throw FileNotReadableException::filename($path);
        }
    }
}