Thruster\Component\Http\UploadedFile

Complexity

Total Complexity

24

Size/Duplication

Total Lines	184
Duplicated Lines	0 %

Coupling/Cohesion

Components	1
Dependencies	3

Importance

Changes	1
Bugs	0	Features	0

7 Methods

Rating	Name	Duplication	Size	Complexity
D	__construct()	0	45	10
A	getStream()	0	18	4
B	moveTo()	0	29	6
A	getSize()	0	4	1
A	getError()	0	4	1
A	getClientFilename()	0	4	1
A	getClientMediaType()	0	4	1

<?php

namespace Thruster\Component\Http;

use Doctrine\Instantiator\Exception\InvalidArgumentException;
use GuzzleHttp\Psr7\Stream;
use Psr\Http\Message\StreamInterface;
use Psr\Http\Message\UploadedFileInterface;
use SebastianBergmann\GlobalState\RuntimeException;

/**
 * Class UploadedFile
 *
 * @package Thruster\Component\Http
 * @author  Aurimas Niekis <aurimas@niekis.lt>
 */
class UploadedFile implements UploadedFileInterface
{
    /**
     * @var string
     */
    protected $clientFilename;

    /**
     * @var string
     */
    protected $clientMediaType;

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

    /**
     * @var string
     */
    protected $file;

    /**
     * @var int
     */
    protected $fileSize;

    /**
     * @var bool
     */
    protected $moved = false;

    /**
     * @var StreamInterface
     */
    protected $stream;

    public function __construct(
        string $tempFile,
        int $fileSize,
        int $errorStatus,
        string $clientFilename = null,
        string $clientMediaType = null
    ) {
        if ($errorStatus === UPLOAD_ERR_OK) {
            if (false === file_exists($tempFile)) {
                throw new InvalidArgumentException(
                    'Temp File does not exists'
                );
            }

            $this->file = $tempFile;
            $this->fileSize = $fileSize;
        }

        if (false === is_int($errorStatus)
            || 0 > $errorStatus
            || 8 < $errorStatus
        ) {
            throw new InvalidArgumentException(
                'Invalid error status for UploadedFile; must be an UPLOAD_ERR_* constant'
            );
        }

        $this->error = $errorStatus;

        if (null !== $clientFilename && false === is_string($clientFilename)) {
            throw new InvalidArgumentException(
                'Invalid client filename provided for UploadedFile; must be null or a string'
            );
        }

        $this->clientFilename = $clientFilename;

        if (null !== $clientMediaType && false === is_string($clientMediaType)) {
            throw new InvalidArgumentException(
                'Invalid client media type provided for UploadedFile; must be null or a string'
            );
        }

        $this->clientMediaType = $clientMediaType;
    }

    /**
     * {@inheritdoc}
     * @throws \RuntimeException if the upload was not successful.
     */
    public function getStream()
    {
        if ($this->error !== UPLOAD_ERR_OK) {
            throw new RuntimeException('Cannot retrieve stream due to upload error');
        }

        if ($this->moved) {
            throw new RuntimeException('Cannot retrieve stream after it has already been moved');
        }

        if ($this->stream) {
            return $this->stream;
        }

        $this->stream = new Stream(fopen($this->file, 'rb'));

        return $this->stream;
    }

    /**
     * {@inheritdoc}
     *
     * @see http://php.net/is_uploaded_file
     * @see http://php.net/move_uploaded_file
     *
     * @param string $targetPath Path to which to move the uploaded file.
     *
     * @throws \RuntimeException if the upload was not successful.
     * @throws \InvalidArgumentException if the $path specified is invalid.
     * @throws \RuntimeException on any error during the move operation, or on
     *     the second or subsequent call to the method.
     */
    public function moveTo($targetPath)
    {
        if ($this->error !== UPLOAD_ERR_OK) {
            throw new RuntimeException('Cannot retrieve stream due to upload error');
        }

        if (false !== is_string($targetPath)) {
            throw new InvalidArgumentException(
                'Invalid path provided for move operation; must be a string'
            );
        }

        if (true === empty($targetPath)) {
            throw new InvalidArgumentException(
                'Invalid path provided for move operation; must be a non-empty string'
            );
        }

        if (true === $this->moved) {
            throw new RuntimeException('Cannot move file; already moved!');
        }

        $status = rename($this->file, $targetPath);
        if (false === $status) {
            throw new RuntimeException('Cannot move file!');
        }

        $this->moved = true;
    }

    /**
     * {@inheritdoc}
     */
    public function getSize()
    {
        return $this->fileSize;
    }

    /**
     * {@inheritdoc}
     *
     * @see http://php.net/manual/en/features.file-upload.errors.php
     * @return int One of PHP's UPLOAD_ERR_XXX constants.
     */
    public function getError()
    {
        return $this->error;
    }

    /**
     * {@inheritdoc}
     */
    public function getClientFilename()
    {
        return $this->clientFilename;
    }

    /**
     * {@inheritdoc}
     */
    public function getClientMediaType()
    {
        return $this->clientMediaType;
    }
}