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\Filesystem;
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 RecursiveArrayIterator;
use RecursiveIteratorIterator;
use ILIAS\HTTP\GlobalHttpState;
use ilFileUtils;
use ILIAS\UI\Component\Input\Field\PhpUploadLimit;
 
final class FileUploadImpl implements FileUpload
{
    private bool $processed = false;
    private bool $moved = false;
    private array $uploadResult = [];
    private array $rejectedUploadResult = [];
    private ?array $uploadStreams = null;
 
 
 
 
    public function __construct(
        private PreProcessorManager $processorManager,
        private Filesystems $filesystems,
        private GlobalHttpState $globalHttpState,
        private ?PhpUploadLimit $upload_limit = null
    ) {
    }
 
    private function hardRemoveUpload(string $identifier, ProcessingStatus $status): never
    {
        // 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($status->getMessage());
    }
 
    public function moveOneFileTo(UploadResult $uploadResult, string $destination, int $location = Location::STORAGE, string $file_name = '', bool $override_existing = false): bool
    {
        if (!$this->processed) {
            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());
        }
 
        return true;
    }
 
 
    public function moveFilesTo(string $destination, int $location = Location::STORAGE): void
    {
        if (!$this->processed) {
            throw new \RuntimeException('Can not move unprocessed files.');
        }
 
        if ($this->moved) {
            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, string $path): UploadResult
    {
        return new UploadResult(
            $result->getName(),
            $result->getSize(),
            $result->getMimeType(),
            $result->getMetaData(),
            $result->getStatus(),
            $path
        );
    }
 
 
    private function regenerateUploadResultWithCopyError(UploadResult $result, string $errorReason): UploadResult
    {
        return new UploadResult(
            $result->getName(),
            $result->getSize(),
            $result->getMimeType(),
            $result->getMetaData(),
            new ProcessingStatus(ProcessingStatus::REJECTED, $errorReason),
            ''
        );
    }
 
 
    private function selectFilesystem(int $location): Filesystem
    {
        return match ($location) {
            Location::CUSTOMIZING => $this->filesystems->customizing(),
            Location::STORAGE => $this->filesystems->storage(),
            Location::WEB => $this->filesystems->web(),
            Location::TEMPORARY => $this->filesystems->temp(),
            default => throw new \InvalidArgumentException("No filesystem found for location code \"$location\""),
        };
    }
 
 
    public function uploadSizeLimit(): int
    {
        return $this->upload_limit?->getPhpUploadLimitInBytes() ?? ilFileUtils::getPhpUploadSizeLimitInBytes();
    }
 
 
    public function register(PreProcessor $preProcessor): void
    {
        if (!$this->processed) {
            $this->processorManager->with($preProcessor);
        } else {
            throw new IllegalStateException('Can not register processor after the upload was processed.');
        }
    }
 
 
    public function process(): void
    {
        if ($this->processed) {
            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) {
                $this->rejectFailedUpload($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, $processingResult);
                    continue;
                }
 
                $result = new UploadResult(
                    $metadata->getFilename(),
                    $metadata->getUploadSize(),
                    $metadata->getMimeType(),
                    $metadata->additionalMetaData(),
                    $processingResult,
                    is_string($identifier) ? $identifier : ''
                );
                $this->uploadResult[$identifier] = $result;
            } else {
                $this->rejectFailedUpload($metadata);
            }
        }
 
        $this->processed = true;
    }
 
 
    private function rejectFailedUpload(Metadata $metadata): void
    {
        //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(): array
    {
        if ($this->processed) {
            return array_merge($this->uploadResult, $this->rejectedUploadResult);
        }
 
        throw new IllegalStateException('Can not fetch results without processing the uploads.');
    }
 
 
    public function hasUploads(): bool
    {
        if ($this->moved) {
            return false;
        }
 
        $uploadedFiles = $this->flattenUploadedFiles($this->globalHttpState->request()->getUploadedFiles());
 
        return ($uploadedFiles !== []);
    }
 
 
    private function flattenUploadedFiles(array $uploadedFiles): array
    {
        $recursiveIterator = new RecursiveIteratorIterator(
            new RecursiveArrayIterator(
                $uploadedFiles,
                RecursiveArrayIterator::CHILD_ARRAYS_ONLY
            ),
            RecursiveIteratorIterator::LEAVES_ONLY
        );
 
        return iterator_to_array($recursiveIterator, false);
    }
 
 
    public function hasBeenProcessed(): bool
    {
        return $this->processed;
    }
}