InitResourceStorage.php

Go to the documentation of this file.

<?php

use ILIAS\DI\Container;
use ILIAS\FileUpload\Location;
use ILIAS\ResourceStorage\Consumer\SrcBuilder;
use ILIAS\ResourceStorage\Consumer\StreamAccess\StreamAccess;
use ILIAS\ResourceStorage\Information\Repository\InformationDBRepository;
use ILIAS\ResourceStorage\Lock\LockHandler;
use ILIAS\ResourceStorage\Lock\LockHandlerilDB;
use ILIAS\ResourceStorage\Policy\FileNamePolicy;
use ILIAS\ResourceStorage\Policy\NoneFileNamePolicy;
use ILIAS\ResourceStorage\Preloader\DBRepositoryPreloader;
use ILIAS\ResourceStorage\Repositories;
use ILIAS\ResourceStorage\Resource\Repository\CollectionDBRepository;
use ILIAS\ResourceStorage\Resource\Repository\ResourceDBRepository;
use ILIAS\ResourceStorage\Resource\ResourceBuilder;
use ILIAS\ResourceStorage\Revision\Repository\RevisionDBRepository;
use ILIAS\ResourceStorage\Stakeholder\Repository\StakeholderDBRepository;
use ILIAS\ResourceStorage\StorageHandler\FileSystemBased\FileSystemStorageHandler;
use ILIAS\ResourceStorage\StorageHandler\FileSystemBased\MaxNestingFileSystemStorageHandler;
use ILIAS\ResourceStorage\StorageHandler\StorageHandlerFactory;

class InitResourceStorage
{
    public const D_SERVICE = 'resource_storage';
    public const D_REPOSITORIES = self::D_SERVICE . '.repositories';
    public const D_STORAGE_HANDLERS = self::D_SERVICE . '.storage_handlers';
    public const D_BUILDER = self::D_SERVICE . '.resource_builder';
    public const D_REPOSITORY_PRELOADER = self::D_SERVICE . '.repository_preloader';
    public const D_SOURCE_BUILDER = self::D_SERVICE . '.source_builder';
    public const D_LOCK_HANDLER = self::D_SERVICE . '.lock_handler';
    public const D_FILENAME_POLICY = self::D_SERVICE . '.filename_policy';
    public const D_STREAM_ACCESS = self::D_SERVICE . '.stream_access';

    public function getResourceBuilder(\ILIAS\DI\Container $c): ResourceBuilder
    {
        self::init($c);
        $c[self::D_BUILDER] = function (Container $c): ResourceBuilder {
            return new ResourceBuilder(
                $c[self::D_STORAGE_HANDLERS],
                $c[self::D_REPOSITORIES],
                $c[self::D_LOCK_HANDLER],
                $c[self::D_STREAM_ACCESS],
                $c[self::D_FILENAME_POLICY],
            );
        };
        return $c[self::D_BUILDER];
    }

    public function init(\ILIAS\DI\Container $c): void
    {
        $base_dir = $this->buildBasePath();

        // DB Repositories
        $c[self::D_REPOSITORIES] = static function (Container $c): Repositories {
            return new Repositories(
                new RevisionDBRepository($c->database()),
                new ResourceDBRepository($c->database()),
                new CollectionDBRepository($c->database()),
                new InformationDBRepository($c->database()),
                new StakeholderDBRepository($c->database())
            );
        };

        // Repository Preloader
        $c[self::D_REPOSITORY_PRELOADER] = static function (Container $c) {
            return new DBRepositoryPreloader(
                $c->database(),
                $c[self::D_REPOSITORIES]
            );
        };

        // Lock Handler
        $c[self::D_LOCK_HANDLER] = static function (Container $c): LockHandler {
            return new LockHandlerilDB($c->database());
        };

        // Storage Handlers
        $c[self::D_STORAGE_HANDLERS] = static function (Container $c) use ($base_dir): StorageHandlerFactory {
            return new StorageHandlerFactory([
                new MaxNestingFileSystemStorageHandler($c['filesystem.storage'], Location::STORAGE),
                new FileSystemStorageHandler($c['filesystem.storage'], Location::STORAGE)
            ], $base_dir);
        };

        // Source Builder for Consumers
        $c[self::D_SOURCE_BUILDER] = static function (Container $c): ?SrcBuilder {
            return null;
        };

        // Filename Policy for Consumers
        $c[self::D_FILENAME_POLICY] = static function (Container $c): FileNamePolicy {
            if ($c->isDependencyAvailable('settings') && $c->isDependencyAvailable('clientIni')) {
                return new ilFileServicesPolicy($c->fileServiceSettings());
            }
            return new NoneFileNamePolicy();
        };

        // Stream Access for Consumers and internal Usage
        $c[self::D_STREAM_ACCESS] = static function (Container $c) use ($base_dir): StreamAccess {
            return new StreamAccess(
                $base_dir,
                $c[self::D_STORAGE_HANDLERS]
            );
        };

        //
        // IRSS
        //
        $c[self::D_SERVICE] = static function (Container $c): \ILIAS\ResourceStorage\Services {
            return new \ILIAS\ResourceStorage\Services(
                $c[self::D_STORAGE_HANDLERS],
                $c[self::D_REPOSITORIES],
                $c[self::D_LOCK_HANDLER],
                $c[self::D_FILENAME_POLICY],
                $c[self::D_STREAM_ACCESS],
                $c[self::D_SOURCE_BUILDER],
                $c[self::D_REPOSITORY_PRELOADER],
            );
        };
    }

    protected function buildBasePath(): string
    {
        return (defined('ILIAS_DATA_DIR') && defined('CLIENT_ID'))
            ? rtrim(ILIAS_DATA_DIR, "/") . "/" . CLIENT_ID
            : '-';
    }
}