FileUploadImpl.php

Go to the documentation of this file.

<?php
 
namespace ILIAS\FileUpload;
 
use ILIAS\Filesystem\Exception\IOException;
use ILIAS\Filesystem\Filesystems;
use ILIAS\Filesystem\Stream\FileStream;
use ILIAS\Filesystem\Stream\Streams;
use ILIAS\FileUpload\Collection\EntryLockingStringMap;
use ILIAS\FileUpload\Collection\ImmutableMapWrapper;
use ILIAS\FileUpload\DTO\Metadata;
use ILIAS\FileUpload\DTO\ProcessingStatus;
use ILIAS\FileUpload\DTO\UploadResult;
use ILIAS\FileUpload\Exception\IllegalStateException;
use ILIAS\FileUpload\Processor\PreProcessor;
use ILIAS\FileUpload\Processor\PreProcessorManager;
use ILIAS\HTTP\GlobalHttpState;
use Psr\Http\Message\UploadedFileInterface;
use RecursiveArrayIterator;
use RecursiveIteratorIterator;
 
final class FileUploadImpl implements FileUpload
{
 
    private $processorManager;
    private $filesystems;
    private $globalHttpState;
    private $processed;
    private $moved;
    private $uploadResult;
    private $rejectedUploadResult;
    private $uploadStreams;
 
 
 
 
    public function __construct(PreProcessorManager $processorManager, Filesystems $filesystems, GlobalHttpState $globalHttpState)
    {
        $this->processorManager = $processorManager;
        $this->filesystems = $filesystems;
        $this->globalHttpState = $globalHttpState;
        $this->processed = false;
        $this->moved = false;
        $this->uploadResult = [];
        $this->rejectedUploadResult = [];
    }
 
    private function hardRemoveUpload(string $identifier) : void
    {
        // we delete the file from the temporary directory and remove it from the global $_FILES array
        $file_stream = $this->uploadStreams[$identifier];
        $uri = $file_stream->getMetadata('uri');
        $file_stream->close();
        unlink($uri);
        unset($this->uploadStreams[$identifier]);
        unset($_FILES[$identifier]);
        throw new IllegalStateException("File upload removed due to security reasons.");
    }
 
    public function moveOneFileTo(UploadResult $uploadResult, $destination, $location = Location::STORAGE, $file_name = '', $override_existing = false)
    {
        if ($this->processed === false) {
            throw new \RuntimeException('Can not move unprocessed files.');
        }
        $filesystem = $this->selectFilesystem($location);
        $tempResults = [];
 
        if ($uploadResult->getStatus()->getCode() == ProcessingStatus::REJECTED) {
            return false;
        }
 
        try {
            $path = rtrim($destination, "/") . '/' . ($file_name == "" ? $uploadResult->getName() : $file_name);
            if ($override_existing && $filesystem->has($path)) {
                $filesystem->delete($path);
            }
            $filesystem->writeStream($path, Streams::ofPsr7Stream($this->uploadStreams[$uploadResult->getPath()]));
            $tempResults[] = $this->regenerateUploadResultWithPath($uploadResult, $path);
        } catch (IOException $ex) {
            $this->regenerateUploadResultWithCopyError($uploadResult, $ex->getMessage());
        }
    }
 
 
    public function moveFilesTo($destination, $location = Location::STORAGE)
    {
        if ($this->processed === false) {
            throw new \RuntimeException('Can not move unprocessed files.');
        }
 
        if ($this->moved === true) {
            throw new \RuntimeException('Can not move the files a second time.');
        }
 
        $filesystem = $this->selectFilesystem($location);
        $tempResults = [];
 
        foreach ($this->uploadResult as $key => $uploadResult) {
            if ($uploadResult->getStatus()->getCode() == ProcessingStatus::REJECTED) {
                continue;
            }
 
            try {
                $path = $destination . '/' . $uploadResult->getName();
                $filesystem->writeStream($path, Streams::ofPsr7Stream($this->uploadStreams[$key]));
                $tempResults[] = $this->regenerateUploadResultWithPath($uploadResult, $path);
            } catch (IOException $ex) {
                $this->regenerateUploadResultWithCopyError($uploadResult, $ex->getMessage());
            }
        }
 
        $this->uploadResult = $tempResults;
        $this->uploadStreams = null;
        $this->moved = true;
    }
 
 
    private function regenerateUploadResultWithPath(UploadResult $result, $path)
    {
        return new UploadResult(
            $result->getName(),
            $result->getSize(),
            $result->getMimeType(),
            $result->getMetaData(),
            $result->getStatus(),
            $path
        );
    }
 
 
    private function regenerateUploadResultWithCopyError(UploadResult $result, $errorReason)
    {
        return new UploadResult(
            $result->getName(),
            $result->getSize(),
            $result->getMimeType(),
            $result->getMetaData(),
            new ProcessingStatus(ProcessingStatus::REJECTED, $errorReason),
            ''
        );
    }
 
 
    private function selectFilesystem($location)
    {
        switch ($location) {
            case Location::CUSTOMIZING:
                return $this->filesystems->customizing();
            case Location::STORAGE:
                return $this->filesystems->storage();
            case Location::WEB:
                return $this->filesystems->web();
            case Location::TEMPORARY:
                return $this->filesystems->temp();
            default:
                throw new \InvalidArgumentException("No filesystem found for location code \"$location\"");
        }
    }
 
 
    public function uploadSizeLimit()
    {
        return \ilUtil::getUploadSizeLimitBytes();
    }
 
 
    public function register(PreProcessor $preProcessor)
    {
        if ($this->processed === false) {
            $this->processorManager->with($preProcessor);
        } else {
            throw new IllegalStateException('Can not register processor after the upload was processed.');
        }
    }
 
 
    public function process()
    {
        if ($this->processed === true) {
            throw new IllegalStateException('Can not reprocess the uploaded files.');
        }
 
        $uploadedFiles = $this->globalHttpState->request()->getUploadedFiles();
        $collectFilesFromNestedFields = $this->flattenUploadedFiles($uploadedFiles);
        foreach ($collectFilesFromNestedFields as $file) {
            $metadata = new Metadata($file->getClientFilename(), $file->getSize(), $file->getClientMediaType());
            try {
                $stream = Streams::ofPsr7Stream($file->getStream());
            } catch (\RuntimeException $e) {
                $this->rejectFailedUpload($file, $metadata);
                continue;
            }
 
            // we take the temporary file name as an identifier as it is the only unique attribute.
            $identifier = $file->getStream()->getMetadata('uri');
 
            $identifier = is_array($identifier) ? '' : $identifier;
            
            $this->uploadStreams[$identifier] = $stream;
 
            if ($file->getError() === UPLOAD_ERR_OK) {
                $processingResult = $this->processorManager->process($stream, $metadata);
 
                // we do discard if the result is a DENIED that there is no further pissibility to process the file.
                if ($processingResult->getCode() === ProcessingStatus::DENIED) {
                    $this->hardRemoveUpload($identifier);
                    continue;
                }
 
                $result = new UploadResult(
                    $metadata->getFilename(),
                    $metadata->getUploadSize(),
                    $metadata->getMimeType(),
                    $metadata->additionalMetaData(),
                    $processingResult,
                    is_string($identifier)?$identifier:''
                );
                $this->uploadResult[$identifier] = $result;
            } else {
                $this->rejectFailedUpload($file, $metadata);
            }
        }
 
        $this->processed = true;
    }
 
 
    private function rejectFailedUpload(UploadedFileInterface $file, Metadata $metadata)
    {
        //reject failed upload
        $processingStatus = new ProcessingStatus(ProcessingStatus::REJECTED, 'Upload failed');
        $extraMetadata = new ImmutableMapWrapper(new EntryLockingStringMap());
        $result = new UploadResult(
            $metadata->getFilename(),
            $metadata->getUploadSize(),
            $metadata->getMimeType(),
            $extraMetadata,
            $processingStatus,
            ''
        );
 
        $this->rejectedUploadResult[] = $result;
    }
 
 
    public function getResults()
    {
        if ($this->processed) {
            return array_merge($this->uploadResult, $this->rejectedUploadResult);
        }
 
        throw new IllegalStateException('Can not fetch results without processing the uploads.');
    }
 
 
    public function hasUploads()
    {
        if ($this->moved) {
            return false;
        }
 
        $uploadedFiles = $this->flattenUploadedFiles($this->globalHttpState->request()->getUploadedFiles());
 
        return (count($uploadedFiles) > 0);
    }
 
 
    protected function flattenUploadedFiles($uploadedFiles)
    {
        $recursiveIterator = new RecursiveIteratorIterator(
            new RecursiveArrayIterator(
                $uploadedFiles,
                RecursiveArrayIterator::CHILD_ARRAYS_ONLY
            ),
            RecursiveIteratorIterator::LEAVES_ONLY
        );
 
        return iterator_to_array($recursiveIterator, false);
    }
 
 
    public function hasBeenProcessed()
    {
        return $this->processed;
    }
}