class.ilObjFileAbstractZipProcessor.php

Go to the documentation of this file.

<?php
 
use ILIAS\ResourceStorage\Identification\ResourceIdentification;
use ILIAS\Filesystem\Stream\Streams;
use ILIAS\ResourceStorage\Stakeholder\ResourceStakeholder;
use ILIAS\ResourceStorage\Services;
 
abstract class ilObjFileAbstractZipProcessor extends ilObjFileAbstractProcessor
{
    private const IRSS_FILEPATH_KEY = 'uri';
 
    private ?ZipArchive $archive = null;
    private int $id_type;
 
    protected bool $create_base_container_for_multiple_root_entries = false;
 
    public function __construct(
        ResourceStakeholder $stakeholder,
        ilObjFileGUI $gui_object,
        Services $storage,
        ilFileServicesSettings $settings,
        private $tree
    ) {
        parent::__construct($stakeholder, $gui_object, $storage, $settings);
 
        $this->id_type = $gui_object->getIdType();
    }
 
    protected function createSurroundingContainer(ResourceIdentification $rid): int
    {
        // create one base container with the name of the zip itself, all other containers will be created inside this one
        $zip_name = $this->storage->manage()->getCurrentRevision($rid)->getInformation()->getTitle();
        $info = new SplFileInfo($zip_name);
        $base_path = $info->getBasename("." . $info->getExtension());
        $base_container = $this->createContainerObj($base_path, $this->gui_object->getParentId());
 
        return (int) $base_container->getRefId();
    }
 
    protected function createContainerObj(string $dir_name, int $parent_id): ilObject
    {
        $container_obj = $this->getPossibleContainerObj($parent_id);
        $container_obj->setTitle($dir_name);
 
        $container_obj->create();
        $container_obj->createReference();
 
        $this->gui_object->putObjectInTree($container_obj, $parent_id);
 
        return $container_obj;
    }
 
    protected function openZip(ResourceIdentification $rid): void
    {
        if ($this->archive instanceof \ZipArchive) {
            throw new LogicException("openZip() can only be called once, yet it was called again.");
        }
 
        $file_uri = $this->storage->consume()->stream($rid)->getStream()->getMetadata(self::IRSS_FILEPATH_KEY);
        $this->archive = new ZipArchive();
        $this->archive->open($file_uri);
    }
 
    private function getZipPaths(): Generator
    {
        if (!$this->archive instanceof \ZipArchive) {
            throw new LogicException("cannot read content of unopened zip archive");
        }
 
        for ($i = 0, $i_max = $this->archive->count(); $i < $i_max; $i++) {
            $path = $this->archive->getNameIndex($i, ZipArchive::FL_UNCHANGED);
            if (str_contains($path, '__MACOSX')) {
                continue;
            }
            if (str_contains($path, '.DS_')) {
                continue;
            }
 
            yield $path;
        }
    }
 
    protected function getZipFiles(): Generator
    {
        foreach ($this->getZipPaths() as $path) {
            if (str_ends_with($path, "/")) {
                continue;
            }
            if (str_ends_with($path, "\\")) {
                continue;
            }
            yield $path;
        }
    }
 
    protected function hasMultipleRootEntriesInZip(): bool
    {
        $amount = 0;
        foreach ($this->getZipDirectories() as $zip_directory) {
            $dirname = dirname($zip_directory);
            if ($dirname === '.') {
                $amount++;
            }
            if ($amount > 1) {
                return true;
            }
        }
        foreach ($this->getZipFiles() as $zip_file) {
            $dirname = dirname($zip_file);
            if ($dirname === '.') {
                $amount++;
            }
            if ($amount > 1) {
                return true;
            }
        }
        return false;
    }
 
    protected function getZipDirectories(): Generator
    {
        $directories = [];
        foreach ($this->getZipPaths() as $path) {
            if (str_ends_with($path, "/") || str_ends_with($path, "\\")) {
                $directories[] = $path;
                continue;
            }
            // add all parent directories of files, too. depending on the OS used to create the zip,
            // these directories may not be present as explicit directory entries in the zip
            $dir_name = dirname($path) . '/';
            if ($dir_name !== './' && $dir_name !== '/' && !in_array($dir_name, $directories, true)) {
                $directories[] = $dir_name;
            }
        }
 
        $directories_with_parents = [];
 
        foreach ($directories as $directory) {
            $parent = dirname($directory) . '/';
            if ($parent !== './' && !in_array($parent, $directories)) {
                $directories_with_parents[] = $parent;
            }
            $directories_with_parents[] = $directory;
        }
 
        $directories_with_parents = array_unique($directories_with_parents);
        sort($directories_with_parents);
        yield from $directories_with_parents;
    }
 
    protected function storeZippedFile(string $file_path): ResourceIdentification
    {
        if (!$this->archive instanceof \ZipArchive) {
            throw new LogicException("No archive has been opened yet, call openZip() first in order to read files.");
        }
 
        return $this->storage->manage()->stream(
            Streams::ofString($this->archive->getFromName($file_path)),
            $this->stakeholder,
            basename($file_path)
        );
    }
 
    protected function closeZip(): void
    {
        if ($this->archive instanceof \ZipArchive) {
            $this->archive->close();
        }
    }
 
    protected function isWorkspace(): bool
    {
        return (ilObject2GUI::WORKSPACE_NODE_ID === $this->id_type);
    }
 
    private function getPossibleContainerObj(int $parent_id): ilObject
    {
        $type = ($this->isWorkspace()) ?
            ilObject::_lookupType($this->tree->lookupObjectId($parent_id)) :
            ilObject::_lookupType($parent_id, true);
 
        return match ($type) {
            'wfld', 'wsrt' => new ilObjWorkspaceFolder(),
            'cat', 'root' => new ilObjCategory(),
            default => new ilObjFolder(),
        };
    }
}