Borobudur\Http\UploadFileBag

Complexity

Total Complexity

45

Size/Duplication

Total Lines	420
Duplicated Lines	0 %

Coupling/Cohesion

Components	1
Dependencies	6

Importance

Changes

0

21 Methods

Rating	Name	Duplication	Size	Complexity
A	__construct()	0	9	2
A	replaceAcceptedMimeTypes()	0	9	1
A	addAcceptedMimeTypes()	0	8	2
A	setAcceptedMimeType()	0	11	1
A	allAcceptedMimeTypes()	0	4	1
A	isMimeTypeAccepted()	0	9	2
A	set()	0	12	3
A	isValid()	0	14	3
A	executeInSafeMode()	0	22	3
A	move()	0	6	1
A	copy()	0	6	1
A	deleteAll()	0	8	1
A	getErrorMessage()	0	14	2
A	walkIn()	0	4	1
A	convertToFile()	0	20	4
A	createFileFromArray()	0	11	2
A	normalizeFilesArray()	0	20	4
A	collectData()	0	16	4
A	isFileUpload()	0	7	1
A	createDirectoryAndCall()	0	16	3
A	walkInRecursively()	0	12	3

<?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;

use Borobudur\Http\Exception\InvalidArgumentException;
use Borobudur\Http\Exception\RuntimeException;
use Borobudur\Http\File\AcceptedMimeType;
use Borobudur\Http\File\FileTrait;
use Borobudur\Http\File\UploadedFile;
use Closure;

/**
 * @author      Iqbal Maulana <iq.bluejack@gmail.com>
 * @created     8/2/15
 */
class UploadFileBag extends ParameterBag
{
    use FileTrait;

    /**
     * Global accepted file mime types.
     *
     * @var AcceptedMimeType
     */
    public static $acceptedMimeTypes;

    /**
     * Upload file keys mapping.
     *
     * @var array
     */
    private static $fileKeys = array('error', 'name', 'size', 'tmp_name', 'type');

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

    /**
     * Constructor.
     *
     * @param array $files
     * @param bool  $tested
     */
    public function __construct(array $files = array(), $tested = false)
    {
        if (null === self::$acceptedMimeTypes) {
            self::$acceptedMimeTypes = new AcceptedMimeType();
        }

        $this->tested = (bool) $tested;
        parent::__construct($files);
    }

    /**
     * Clear mime types and replace with sets of it.
     *
     * @param array $mimeTypes
     *
     * @return $this
     */
    public function replaceAcceptedMimeTypes(array $mimeTypes)
    {
        self::$acceptedMimeTypes->clear();
        $this->walkIn(function (UploadedFile &$file) {
            $file->getAcceptedMimeType()->clear();
        });

        return $this->addAcceptedMimeTypes($mimeTypes);
    }

    /**
     * Add sets of mime type.
     *
     * @param array $mimeTypes
     *
     * @return $this
     */
    public function addAcceptedMimeTypes(array $mimeTypes)
    {
        foreach ($mimeTypes as $mimeType) {
            $this->setAcceptedMimeType($mimeType);
        }

        return $this;
    }

    /**
     * Set mime type to all children.
     *
     * @param string $mimeType
     *
     * @return $this
     */
    public function setAcceptedMimeType($mimeType)
    {
        $mimeType = strtolower(trim($mimeType));
        self::$acceptedMimeTypes->set($mimeType);

        $this->walkIn(function (UploadedFile &$file) use ($mimeType) {
            $file->getAcceptedMimeType()->set($mimeType);
        });

        return $this;
    }

    /**
     * Get all accepted mime types.
     *
     * @return array
     */
    public function allAcceptedMimeTypes()
    {
        return self::$acceptedMimeTypes->all();
    }

    /**
     * Check if specified mime type is accepted.
     *
     * @param string $mimeType
     *
     * @return bool
     */
    public function isMimeTypeAccepted($mimeType)
    {
        $accepted = self::$acceptedMimeTypes->all();
        if (empty($accepted)) {
            return true;
        }

        return self::$acceptedMimeTypes->isAccepted($mimeType);
    }

    /**
     * {@inheritdoc}
     */
    public function set($key, $value)
    {
        if (false === is_array($value) && false === $value instanceof UploadedFile) {
            throw new InvalidArgumentException(sprintf(
                'Uploaded file should be an array or instance of "%s", "%s" given.',
                'Borobudur\Http\File\UploadedFile',
                gettype($value)
            ));
        }

        return parent::set($key, $this->convertToFile($value));
    }

    /**
     * Check if file is valid to all composite children.
     *
     * @return bool
     */
    public function isValid()
    {
        try {
            $this->walkIn(function (UploadedFile $file) {
                if (false === $file->isValid()) {
                    throw new \Exception;
                }
            });

            return true;
        } catch (\Exception $e) {
            return false;
        }
    }

    /**
     * Execute closure function to all composite files children.
     *
     * Files will be deleted if exception.
     *
     * @param Closure $closure
     *
     * @return $this
     */
    public function executeInSafeMode(Closure $closure)
    {
        $successes = array();

        $this->walkIn(function (UploadedFile $file = null, $key, $parentKey = null) use (
            &$successes,
            &$closure,
            &$lastKey
        ) {
            try {
                if (null === $file = call_user_func($closure, $file, $key)) {
                    self::collectData($successes, $file, $key, $parentKey);
                }
            } catch (RuntimeException $e) {
                // Remove uploaded images if exception
                (new static($successes))->deleteAll();
                throw $e;
            }
        });

        return new static($successes);
    }

    /**
     * Move all composite files children to new location.
     *
     * Return new UploadFileBag with files that uploaded.
     *
     * @param string $directory New folder location.
     *
     * @return $this
     */
    public function move($directory)
    {
        return $this->createDirectoryAndCall($directory, function (UploadedFile $file) use ($directory) {
            return $file->move($directory);
        });
    }

    /**
     * Copy all composite files children to new location.
     *
     * Return new UploadedFileBag with files that copied.
     *
     * @param string $directory
     *
     * @return $this
     */
    public function copy($directory)
    {
        return $this->createDirectoryAndCall($directory, function (UploadedFile $file) use ($directory) {
            return $file->copy($directory);
        });
    }

    /**
     * Remove all composite files children.
     *
     * @return $this
     */
    public function deleteAll()
    {
        $this->walkIn(function (UploadedFile $file) {
            $file->remove();
        });

        return $this;
    }

    /**
     * Get all composite children error message.
     *
     * @return array
     */
    public function getErrorMessage()
    {
        $messages = array();

        $this->walkIn(function (UploadedFile $file, $key, $parentKey = null) use (&$messages) {
            $msg = $file->getErrorMessage();

            if (null !== $msg) {
                self::collectData($messages, $msg, $key, $parentKey);
            }
        });

        return $messages;
    }

    /**
     * Walk into all file.
     *
     * @param Closure $callback
     */
    public function walkIn(Closure $callback)
    {
        $this->walkInRecursively($callback, $this->parameters);
    }

    /**
     * Convert file information to UploadedFile or sets of it.
     *
     * @param UploadedFile|array $fileInfo
     *
     * @return UploadedFile|UploadedFile[]
     */
    protected function convertToFile($fileInfo)
    {
        if ($fileInfo instanceof UploadedFile) {
            return $fileInfo->setTest($this->tested);
        }

        $fileInfo = $this->normalizeFilesArray($fileInfo);
        if (is_array($fileInfo)) {
            $keys = array_keys($fileInfo);
            sort($keys);

            if ($keys == self::$fileKeys) {
                $fileInfo = $this->createFileFromArray($fileInfo);
            } else {
                $fileInfo = array_map(array($this, 'convertToFile'), $fileInfo);
            }
        }

        return $fileInfo;
    }

    /**
     * Create UploadedFile from array file info.
     *
     * @param array $fileInfo
     *
     * @return UploadedFile|null
     */
    protected function createFileFromArray(array $fileInfo)
    {
        if (UPLOAD_ERR_NO_FILE == $fileInfo['error']) {
            return null;
        }

        $fileInfo = UploadedFile::fromArray($fileInfo)->setTest($this->tested);
        $fileInfo->getAcceptedMimeType()->replace(self::$acceptedMimeTypes->all());

        return $fileInfo;
    }

    /**
     * Normalize nested $_FILES array.
     *
     * @param array $fileInfo
     *
     * @return array
     */
    protected function normalizeFilesArray(array $fileInfo)
    {
        if (self::isFileUpload($fileInfo) || !is_array($fileInfo['name'])) {
            return $fileInfo;
        }

        $normalized = array();

        foreach ($fileInfo['name'] as $key => $name) {
            $normalized[$key] = $this->normalizeFilesArray(array(
                'error'    => $fileInfo['error'][$key],
                'name'     => $name,
                'type'     => $fileInfo['type'][$key],
                'tmp_name' => $fileInfo['tmp_name'][$key],
                'size'     => $fileInfo['size'][$key],
            ));
        }

        return $normalized;
    }

    /**
     * Collecting data.
     *
     * @param array           $array
     * @param mixed           $data
     * @param string|int      $key
     * @param string|int|null $parentKey
     */
    private static function collectData(array &$array, $data, $key, $parentKey = null)
    {
        if (!is_int($key) && !isset($array[$key])) {
            $array[$key] = $data;

            return;
        }

        if (!isset($array[$parentKey])) {
            $array[$parentKey] = array($data);

            return;
        }

        $array[$parentKey][] = $data;
    }

    /**
     * Check if specified file is file upload.
     *
     * @param array $fileInfo
     *
     * @return bool
     */
    private static function isFileUpload(array $fileInfo)
    {
        $keys = array_keys($fileInfo);
        sort($keys);

        return $keys == self::$fileKeys;
    }

    /**
     * @param string  $directory
     * @param Closure $caller
     *
     * @return $this
     */
    private function createDirectoryAndCall($directory, Closure $caller)
    {
        if ($this->isValid()) {
            $this->createDirectory($directory);

            return $this->executeInSafeMode($caller);
        }

        throw new RuntimeException(implode(".\n", array_map(function ($message) {
            if (is_array($message)) {
                return implode(".\n", $message);
            }

            return $message;
        }, $this->getErrorMessage())));
    }

    /**
     * Walk in recursively.
     *
     * @param Closure    $callback
     * @param array      $data
     * @param mixed|null $parentKey
     */
    private function walkInRecursively(Closure $callback, array $data, $parentKey = null)
    {
        $me = $this;

        array_walk($data, function ($file, $key) use (&$callback, &$me, $parentKey) {
            if (is_array($file)) {
                $me->walkInRecursively($callback, $file, is_int($key) ? $parentKey : $key);
            }

            call_user_func($callback, $file, $key, $parentKey);
        });
    }
}