class.ilCertificateBackgroundImageUpload.php

Go to the documentation of this file.

<?php
 
declare(strict_types=1);
 
use ILIAS\FileUpload\DTO\UploadResult;
use ILIAS\FileUpload\FileUpload;
use ILIAS\Filesystem\Filesystem;
use ILIAS\FileUpload\Exception\IllegalStateException;
use ILIAS\Filesystem\Exception\FileNotFoundException;
use ILIAS\Filesystem\Exception\IOException;
use ILIAS\FileUpload\Location;
 
class ilCertificateBackgroundImageUpload
{
    private const BACKGROUND_IMAGE_NAME = 'background.jpg';
    private const BACKGROUND_THUMBNAIL_IMAGE_NAME = 'background.jpg.thumb.jpg';
    private const BACKGROUND_TEMPORARY_FILENAME = 'background_upload_tmp';
    private FileUpload $fileUpload;
    private string $certificatePath;
    private ilLanguage $language;
    private string $rootDirectory;
    private Filesystem $fileSystem;
    private ilCertificateUtilHelper $utilHelper;
    private ilCertificateFileUtilsHelper $fileUtilsHelper;
    private string $clientId;
    private LegacyPathHelperHelper $legacyPathHelper;
    private ilLogger $logger;
    private Filesystem $tmp_file_system;
 
    public function __construct(
        FileUpload $fileUpload,
        string $certificatePath,
        ilLanguage $language,
        ilLogger $logger,
        ?Filesystem $fileSystem = null,
        ?ilCertificateUtilHelper $utilHelper = null,
        ?ilCertificateFileUtilsHelper $certificateFileUtilsHelper = null,
        ?LegacyPathHelperHelper $legacyPathHelper = null,
        string $rootDirectory = CLIENT_WEB_DIR,
        string $clientID = CLIENT_ID,
        ?Filesystem $tmp_file_system = null
    ) {
        $this->fileUpload = $fileUpload;
        $this->certificatePath = $certificatePath;
        $this->language = $language;
        $this->logger = $logger;
        $this->rootDirectory = $rootDirectory;
 
        if (null === $fileSystem) {
            global $DIC;
            $fileSystem = $DIC->filesystem()->web();
        }
        $this->fileSystem = $fileSystem;
 
        if (null === $utilHelper) {
            $utilHelper = new ilCertificateUtilHelper();
        }
        $this->utilHelper = $utilHelper;
 
        if (null === $certificateFileUtilsHelper) {
            $certificateFileUtilsHelper = new ilCertificateFileUtilsHelper();
        }
        $this->fileUtilsHelper = $certificateFileUtilsHelper;
 
        if (null === $legacyPathHelper) {
            $legacyPathHelper = new LegacyPathHelperHelper();
        }
        $this->legacyPathHelper = $legacyPathHelper;
 
        $this->clientId = $clientID;
 
        if (null === $tmp_file_system) {
            global $DIC;
            $tmp_file_system = $DIC->filesystem()->temp();
        }
        $this->tmp_file_system = $tmp_file_system;
    }
 
    public function uploadBackgroundImage(string $imageTempFilename, int $version, ?array $pending_file = null): string
    {
        $imagepath = $this->rootDirectory . $this->certificatePath;
 
        if (!$this->fileSystem->hasDir($imagepath)) {
            ilFileUtils::makeDirParents($imagepath);
        }
 
        $backgroundImageTempFilePath = $this->uploadFile($imageTempFilename, $pending_file);
 
        $backgroundImagePath = $this->certificatePath . 'background_' . $version . '.jpg';
 
        $this->utilHelper->convertImage(
            $backgroundImageTempFilePath,
            $this->rootDirectory . $backgroundImagePath,
            'JPEG'
        );
 
        $backgroundImageThumbnailPath = $this->createBackgroundImageThumbPath();
 
        $this->utilHelper->convertImage(
            $backgroundImageTempFilePath,
            $backgroundImageThumbnailPath,
            'JPEG',
            "100"
        );
 
        $convert_filename = self::BACKGROUND_IMAGE_NAME;
 
        // something went wrong converting the file. use the original file and hope, that PDF can work with it
        if (!$this->fileSystem->has($backgroundImagePath) && !ilFileUtils::moveUploadedFile(
            $backgroundImageTempFilePath,
            $convert_filename,
            $this->rootDirectory . $backgroundImagePath
        )) {
            throw new ilException('Unable to convert the file and the original file');
        }
 
        if ($this->fileSystem->has($backgroundImageTempFilePath)) {
            $this->fileSystem->delete($backgroundImageTempFilePath);
        }
 
        if ($this->fileSystem->has($backgroundImagePath)) {
            return $this->certificatePath . 'background_' . $version . '.jpg';
        }
 
        throw new ilException('The given temporary filename is empty');
    }
 
    private function uploadFile(string $temporaryFilename, ?array $pending_file = null): string
    {
        if (!$this->fileUpload->hasBeenProcessed()) {
            $this->fileUpload->process();
        }
 
        if (false === $this->fileUpload->hasUploads()) {
            throw new ilException($this->language->txt('upload_error_file_not_found'));
        }
 
        $uploadResults = $this->fileUpload->getResults();
        if (isset($uploadResults[$temporaryFilename])) {
            $uploadResult = $uploadResults[$temporaryFilename];
            $processingStatus = $uploadResult->getStatus();
            if ($processingStatus->getCode() === ILIAS\FileUpload\DTO\ProcessingStatus::REJECTED) {
                throw new ilException($processingStatus->getMessage());
            }
 
            $extension = pathinfo($uploadResult->getName(), PATHINFO_EXTENSION);
            $temp_file_path = $this->createBackgroundImageTempfilePath($extension);
            $target_file_name = basename($temp_file_path);
            $target_file_name = $this->fileUtilsHelper->getValidFilename($target_file_name);
 
            $target_file_system = $this->getTargetFilesystem($temp_file_path);
            $target_directory = $this->getTargetDir($temp_file_path);
 
            $this->fileUpload->moveOneFileTo(
                $uploadResult,
                $target_directory,
                $target_file_system,
                $target_file_name,
                true
            );
 
            return $temp_file_path;
        } elseif (is_array($pending_file) && $pending_file !== []) {
            $extension = pathinfo($pending_file['name'], PATHINFO_EXTENSION);
            $temp_file_path = $this->createBackgroundImageTempfilePath($extension);
 
            $target_file_name = basename($temp_file_path);
            $target_file_name = $this->fileUtilsHelper->getValidFilename($target_file_name);
 
            $target_directory = $this->getTargetDir($temp_file_path);
 
            $stream = $this->tmp_file_system->readStream(basename($pending_file['tmp_name']));
            $this->fileSystem->writeStream($target_directory . '/' . $target_file_name, $stream);
 
            return $temp_file_path;
        } else {
            throw new ilException($this->language->txt('upload_error_file_not_found'));
        }
    }
 
    private function getTargetFilesystem(string $target): int
    {
        switch (true) {
            case strpos($target, $this->rootDirectory . '/' . $this->clientId) === 0:
            case strpos($target, './' . $this->rootDirectory . '/' . $this->clientId) === 0:
            case strpos($target, $this->rootDirectory) === 0:
                $targetFilesystem = Location::WEB;
                break;
            case strpos($target, CLIENT_DATA_DIR . "/temp") === 0:
                $targetFilesystem = Location::TEMPORARY;
                break;
            case strpos($target, CLIENT_DATA_DIR) === 0:
                $targetFilesystem = Location::STORAGE;
                break;
            case strpos($target, ILIAS_ABSOLUTE_PATH . '/Customizing') === 0:
                $targetFilesystem = Location::CUSTOMIZING;
                break;
            default:
                throw new InvalidArgumentException("Can not move files to \"$target\" because path can not be mapped to web, storage or customizing location.");
        }
 
        return $targetFilesystem;
    }
 
    private function getTargetDir(string $target): string
    {
        $absTargetDir = dirname($target);
        return $this->legacyPathHelper->createRelativePath($absTargetDir);
    }
 
    private function createBackgroundImageTempfilePath(string $extension): string
    {
        return implode('', [
            $this->rootDirectory,
            $this->certificatePath,
            self::BACKGROUND_TEMPORARY_FILENAME,
            '.' . $extension
        ]);
    }
 
    private function createBackgroundImageThumbPath(): string
    {
        return $this->rootDirectory . $this->certificatePath . self::BACKGROUND_THUMBNAIL_IMAGE_NAME;
    }
}