Borobudur\Http\File\UploadedFile

Complexity

Total Complexity

47

Size/Duplication

Total Lines	432
Duplicated Lines	0 %

Coupling/Cohesion

Components	1
Dependencies	4

Importance

Changes

0

21 Methods

Rating	Name	Duplication	Size	Complexity
A	__construct()	0	15	4
A	fromArray()	0	10	1
A	getMaxFileSize()	0	10	2
B	convertFileSize()	0	21	5
A	defineFileSize()	0	13	3
A	setTest()	0	6	1
A	isTested()	0	4	1
A	getOriginalName()	0	4	1
A	getOriginalExtension()	0	4	1
A	getMimeType()	0	4	1
A	getSize()	0	4	1
A	getAcceptedMimeType()	0	4	1
A	getError()	0	4	1
A	isValid()	0	10	4
B	move()	0	26	4
A	copy()	0	22	3
A	remove()	0	16	4
A	getErrorMessage()	0	19	4
A	getMessageFormat()	0	10	2
A	prepare()	0	10	2
A	getName()	0	7	1

<?php
/*
 * This file is part of the Borobudur-Http package.
 *
 * (c) Hexacodelabs <http://hexacodelabs.com>
 *
 * For the full copyright and license information, please view the LICENSE
 * file that was distributed with this source code.
 */

namespace Borobudur\Http\File;

use Borobudur\Http\File\Exception\FileException;
use Borobudur\Http\File\Exception\FileNotFoundException;

/**
 * @author      Iqbal Maulana <iq.bluejack@gmail.com>
 * @created     8/2/15
 */
final class UploadedFile extends \SplFileInfo
{
    use FileTrait;

    /**
     * Error message mapping.
     *
     * @var array
     */
    private static $errorMessages = array(
        UPLOAD_ERR_INI_SIZE   => 'The file "%s" exceeds your upload_max_filesize ini directive (limit is %d KiB).',
        UPLOAD_ERR_FORM_SIZE  => 'The file "%s" exceeds the upload limit defined in your form.',
        UPLOAD_ERR_PARTIAL    => 'The file "%s" was only partially uploaded.',
        UPLOAD_ERR_NO_FILE    => 'No file was uploaded.',
        UPLOAD_ERR_CANT_WRITE => 'The file "%s" could not be written on disk.',
        UPLOAD_ERR_NO_TMP_DIR => 'File could not be uploaded: missing temporary directory.',
        UPLOAD_ERR_EXTENSION  => 'File upload was stopped by a PHP extension.',
    );

    /**
     * @var string
     */
    private $originalName;
    
    /**
     * @var string
     */
    private $mimeType;

    /**
     * @var int
     */
    private $size;

    /**
     * @var int
     */
    private $error;

    /**
     * @var bool
     */
    private $test;

    /**
     * @var bool
     */
    private $mimeTypeValid;

    /**
     * @var AcceptedMimeType
     */
    private $acceptedMimeTypes;

    /**
     * Constructor.
     *
     * @param string $file
     * @param string $originalName
     * @param string $mimeType
     * @param int    $size
     * @param int    $error
     * @param bool   $test
     */
    public function __construct($file, $originalName, $mimeType = null, $size = null, $error = null, $test = false)
    {
        if (false === $test && false === is_file($file)) {
            throw new FileNotFoundException($file);
        }

        $this->originalName = $originalName;
        $this->mimeType = $mimeType;
        $this->size = $size;
        $this->error = $error ?: UPLOAD_ERR_OK;
        $this->test = (bool) $test;
        $this->acceptedMimeTypes = new AcceptedMimeType();

        parent::__construct($file);
    }

    /**
     * Factory create UploadedFile from array.
     *
     * @param array $uploadedFile
     *
     * @return UploadedFile
     */
    public static function fromArray(array $uploadedFile)
    {
        return new UploadedFile(
            $uploadedFile['tmp_name'],
            $uploadedFile['name'],
            mime_content_type($uploadedFile['tmp_name']),
            $uploadedFile['size'],
            $uploadedFile['error']
        );
    }

    /**
     * Get maximum file size of an uploaded file base on php.ini
     *
     * @return int
     */
    public static function getMaxFileSize()
    {
        $iniMax = strtolower(ini_get('upload_max_filesize'));

        if ('' === $iniMax) {
            return PHP_INT_MAX;
        }

        return self::convertFileSize($iniMax, self::defineFileSize($iniMax));
    }

    /**
     * Convert file size from string to int.
     *
     * @param string $iniMax
     * @param int    $max
     *
     * @return int
     */
    private static function convertFileSize($iniMax, $max)
    {
        switch (substr($iniMax, -1)) {
            case 't':
                $max *= 1024;
            // terabyte calculation
            case 'g':
                $max *= 1024;
            // gigabyte calculation
            case 'm':
                $max *= 1024;
            // megabyte calculation
            case 'k':
                $max *= 1024;

                return $max;
            // kilobyte calculation
        }

        return $max;
    }

    /**
     * Define file size.
     *
     * @param string $iniMax
     *
     * @return int|string
     */
    private static function defineFileSize($iniMax)
    {
        $max = ltrim($iniMax, '+');
        if (0 === strpos($max, '0x')) {
            return intval($max, 16);
        }

        if (0 === strpos($max, '0')) {
            return intval($max, 8);
        }

        return (int) $max;
    }

    /**
     * Set test state.
     *
     * @param bool $tested
     *
     * @return $this
     */
    public function setTest($tested)
    {
        $this->test = (bool) $tested;

        return $this;
    }

    /**
     * Check if file is tested.
     *
     * @return bool
     */
    public function isTested()
    {
        return $this->test;
    }

    /**
     * Get client original name.
     *
     * @return string
     */
    public function getOriginalName()
    {
        return $this->originalName;
    }

    /**
     * Get client original extension.
     *
     * @return string
     */
    public function getOriginalExtension()
    {
        return pathinfo($this->originalName, PATHINFO_EXTENSION);
    }

    /**
     * Get file mime type.
     *
     * @return string|null
     */
    public function getMimeType()
    {
        return $this->mimeType;
    }

    /**
     * Get file size.
     *
     * @return int|null
     */
    public function getSize()
    {
        return $this->size;
    }

    /**
     * Get accepted mime type.
     *
     * @return AcceptedMimeType
     */
    public function getAcceptedMimeType()
    {
        return $this->acceptedMimeTypes;
    }

    /**
     * Get upload error.
     *
     * @return int
     */
    public function getError()
    {
        return $this->error;
    }

    /**
     * Check file was uploaded successfully.
     *
     * @return bool
     */
    public function isValid()
    {
        if (false === $this->mimeTypeValid = $this->acceptedMimeTypes->isAccepted($this->getMimeType())) {
            return false;
        }

        $isOk = UPLOAD_ERR_OK === $this->error;

        return $this->test ? $isOk : $isOk && is_uploaded_file($this->getPathname());
    }

    /**
     * Move file to new location.
     *
     * @param string      $directory Destination folder
     * @param string|null $name      New file name if needed
     *
     * @return UploadedFile
     *
     * @throws FileException
     */
    public function move($directory, $name = null)
    {
        if ($this->isValid()) {
            $target = $this->prepare($directory, $name);
            try {
                if (true === $this->test) {
                    rename($this->getPathname(), $target);
                } else {
                    move_uploaded_file($this->getPathname(), $target);
                }
            } catch (\RuntimeException $e) {
                throw new FileException(sprintf(
                    'Could not move file "%s" to "%s" (%s)',
                    $this->getPathname(),
                    $target,
                    strip_tags($e->getMessage())
                ));
            }

            $this->chmod($target);

            return $target;
        }

        throw new FileException($this->getErrorMessage());
    }

    /**
     * Copy file to new location.
     *
     * @param string      $directory
     * @param string|null $name
     *
     * @return UploadedFile
     *
     * @throws FileException
     */
    public function copy($directory, $name = null)
    {
        if ($this->isValid()) {
            $target = $this->prepare($directory, $name);
            try {
                copy($this->getPathname(), $target);
            } catch (\RuntimeException $e) {
                throw new FileException(sprintf(
                    'Could not move file "%s" to "%s" (%s)',
                    $this->getPathname(),
                    $target,
                    strip_tags($e->getMessage())
                ));
            }

            $this->chmod($target);

            return $target;
        }

        throw new FileException($this->getErrorMessage());
    }

    /**
     * Remove uploaded files.
     *
     * @return $this
     */
    public function remove()
    {
        if (file_exists($this->getPathname()) && is_writable($this->getPathname())) {
            try {
                unlink($this->getPathname());
            } catch (\Exception $e) {
                throw new FileException(sprintf(
                    'Could not remove file "%s" (%s)',
                    $this->getPathname(),
                    strip_tags($e->getMessage())
                ));
            }
        }

        return $this;
    }

    /**
     * Get error message based on error code.
     *
     * @return string
     */
    public function getErrorMessage()
    {
        if (false === $this->mimeTypeValid) {
            return sprintf(
                'File "%s" only accepted by mime type(s) "%s", "%s" given.',
                $this->getOriginalName(),
                implode(', ', $this->acceptedMimeTypes),
                $this->getMimeType()
            );
        }

        if (UPLOAD_ERR_OK == $this->error) {
            return null;
        }

        $maxFileSize = $this->error === UPLOAD_ERR_INI_SIZE ? self::getMaxFileSize() : 0;

        return sprintf($this->getMessageFormat(), $this->getOriginalName(), $maxFileSize);
    }

    /**
     * Get error message format.
     *
     * @return string
     */
    private function getMessageFormat()
    {
        if (isset(self::$errorMessages[$this->error])) {
            $message = self::$errorMessages[$this->error];
        } else {
            $message = 'The file "%s" was not uploaded due to an unknown error.';
        }

        return $message;
    }

    /**
     * Prepare file.
     *
     * @param string      $directory
     * @param string|null $name
     *
     * @return UploadedFile
     */
    private function prepare($directory, $name = null)
    {
        $this->createDirectory($directory);

        $directory = rtrim($directory, '/\\') . DIRECTORY_SEPARATOR;
        $name = null === $name ? $this->getOriginalName() : $this->getName($name);
        $file = $directory . $name;

        return new self($file, $name, $this->mimeType, $this->size, $this->error, true);
    }

    /**
     * Get file name.
     *
     * @param string $name
     *
     * @return string
     */
    private function getName($name)
    {
        $name = str_replace('\\', '/', $name);
        $parts = explode('/', $name);

        return reset($parts);
    }
}