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 ILIAS\HTTP\Services;
use Psr\Http\Message\UploadedFileInterface;
use RecursiveArrayIterator;
use RecursiveIteratorIterator;
use ILIAS\HTTP\GlobalHttpState;
use ilFileUtils;

final class FileUploadImpl implements FileUpload
{
    private PreProcessorManager $processorManager;
    private Filesystems $filesystems;
    private GlobalHttpState $globalHttpState;
    private bool $processed;
    private bool $moved;
    private array $uploadResult;
    private array $rejectedUploadResult;
    private ?array $uploadStreams = null;




    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, string $rejection_message): 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($rejection_message);
    }

    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
    {
        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(): int
    {
        return ilFileUtils::getUploadSizeLimitBytes();
    }


    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 $e) {
                $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->getMessage());
                    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 !== []);
    }


    protected 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;
    }
}